diff --git a/Implab.Test/AsyncTests.cs b/Implab.Test/AsyncTests.cs --- a/Implab.Test/AsyncTests.cs +++ b/Implab.Test/AsyncTests.cs @@ -14,7 +14,7 @@ namespace Implab.Test { p.Then(x => res = x); p.Resolve(100); - Assert.AreEqual(res, 100); + Assert.AreEqual(100, res); } [TestMethod] @@ -244,7 +244,7 @@ namespace Implab.Test { [TestMethod] public void ChainedMapTest() { - using (var pool = new WorkerPool(8,100,0)) { + using (var pool = new WorkerPool(4,4,0)) { int count = 10000; double[] args = new double[count]; diff --git a/Implab.v11.suo b/Implab.v11.suo index 0324d71b1911ff2672c0c8ae7c7d19bceabeae2e..63b1e94973db457fc0d00623c0509215803ae71d GIT binary patch literal 115712 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 l|I8lGH`rTs_`WyJ_{6O - /// The current state of the promise. - /// - PromiseState State - { - get; - } - /// - /// Registers handler for the case when the promise is cencelled. If the promise already cancelled the - /// handler will be invoked immediatelly. - /// - /// The handler - void HandleCancelled(Action handler); } } diff --git a/Implab/Parallels/ArrayTraits.cs b/Implab/Parallels/ArrayTraits.cs --- a/Implab/Parallels/ArrayTraits.cs +++ b/Implab/Parallels/ArrayTraits.cs @@ -140,7 +140,7 @@ namespace Implab.Parallels { AsyncPool.InvokeNewThread(() => { for (int i = 0; i < source.Length; i++) { - if(promise.State != PromiseState.Unresolved) + if(promise.IsResolved) break; // stop processing in case of error or cancellation var idx = i; semaphore.WaitOne(); diff --git a/Implab/Parallels/MTQueue.cs b/Implab/Parallels/MTQueue.cs --- a/Implab/Parallels/MTQueue.cs +++ b/Implab/Parallels/MTQueue.cs @@ -42,12 +42,13 @@ namespace Implab.Parallels { next = first.next; if (next == null) { // this is the last element, - // then try to update tail + // then try to update the tail if (first != Interlocked.CompareExchange(ref m_last, null, first)) { - // this is inconsistent situation which means that the queue is empty + // this is a ace condition if (m_last == null) + // the queue is empty return false; - // tail has been changed, that means that we need to restart + // tail has been changed, than we need to restart continue; } diff --git a/Implab/Promise.cs b/Implab/Promise.cs --- a/Implab/Promise.cs +++ b/Implab/Promise.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Reflection; using System.Diagnostics; using System.Threading; +using Implab.Parallels; namespace Implab { @@ -48,24 +49,53 @@ namespace Implab { /// public class Promise : IPromise { - struct ResultHandlerInfo { + struct HandlerDescriptor { public ResultHandler resultHandler; public ErrorHandler errorHandler; + public Action cancellHandler; + + public void Resolve(T result) { + if (resultHandler != null) + try { + resultHandler(result); + } catch (Exception e) { + Reject(e); + } + } + + public void Reject(Exception err) { + if (errorHandler != null) + try { + errorHandler(err); + } catch { + } + } + + public void Cancel() { + if (cancellHandler != null) + try { + cancellHandler(); + } catch { + } + } } + const int UnresolvedSate = 0; + const int TransitionalState = 1; + const int ResolvedState = 2; + const int RejectedState = 3; + const int CancelledState = 4; + readonly IPromise m_parent; - - LinkedList m_resultHandlers = new LinkedList(); - LinkedList m_cancelHandlers = new LinkedList(); + readonly bool m_cancellable; - readonly object m_lock = new Object(); - readonly bool m_cancellable; int m_childrenCount = 0; - - PromiseState m_state; + int m_state; T m_result; Exception m_error; + readonly MTQueue m_handlers = new MTQueue(); + public Promise() { m_cancellable = true; } @@ -73,8 +103,6 @@ namespace Implab { public Promise(IPromise parent, bool cancellable) { m_cancellable = cancellable; m_parent = parent; - if (parent != null) - parent.HandleCancelled(InternalCancel); } void InternalCancel() { @@ -82,22 +110,39 @@ namespace Implab { Cancel(false); } + bool BeginTransit() { + return UnresolvedSate == Interlocked.CompareExchange(ref m_state, TransitionalState, UnresolvedSate); + } + + void CompleteTransit(int state) { + if (TransitionalState != Interlocked.CompareExchange(ref m_state, state, TransitionalState)) + throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state"); + } + + public bool IsResolved { + get { + return m_state > 1; + } + } + + public bool IsCancelled { + get { + return m_state == CancelledState; + } + } + /// /// Выполняет обещание, сообщая об успешном выполнении. /// /// Результат выполнения. /// Данное обещание уже выполнено public void Resolve(T result) { - lock (m_lock) { - if (m_state == PromiseState.Cancelled) - return; - if (m_state != PromiseState.Unresolved) - throw new InvalidOperationException("The promise is already resolved"); + if (BeginTransit()) { m_result = result; - m_state = PromiseState.Resolved; - } - - OnStateChanged(); + CompleteTransit(ResolvedState); + OnStateChanged(); + } else if (m_state != CancelledState) + throw new InvalidOperationException("The promise is already resolved"); } /// @@ -111,16 +156,12 @@ namespace Implab { /// Исключение возникшее при выполнении операции /// Данное обещание уже выполнено public void Reject(Exception error) { - lock (m_lock) { - if (m_state == PromiseState.Cancelled || m_state == PromiseState.Rejected) - return; - if (m_state != PromiseState.Unresolved) - throw new InvalidOperationException("The promise is already resolved"); + if (BeginTransit()) { m_error = error; - m_state = PromiseState.Rejected; - } - - OnStateChanged(); + CompleteTransit(RejectedState); + OnStateChanged(); + } else if (m_state == ResolvedState) + throw new InvalidOperationException("The promise is already resolved"); } /// @@ -144,27 +185,27 @@ namespace Implab { var medium = new Promise(this, true); - var handlerInfo = new ResultHandlerInfo(); - + ResultHandler resultHandler; if (success != null) - handlerInfo.resultHandler = x => { + resultHandler = x => { success(x); medium.Resolve(x); }; else - handlerInfo.resultHandler = medium.Resolve; + resultHandler = medium.Resolve; + ErrorHandler errorHandler; if (error != null) - handlerInfo.errorHandler = x => { + errorHandler = x => { try { error(x); } catch { } medium.Reject(x); }; else - handlerInfo.errorHandler = medium.Reject; + errorHandler = medium.Reject; - AddHandler(handlerInfo); + AddHandler(resultHandler, errorHandler, medium.InternalCancel); return medium; } @@ -182,27 +223,28 @@ namespace Implab { var medium = new Promise(this, true); - var handlerInfo = new ResultHandlerInfo(); + ResultHandler resultHandler; + ErrorHandler errorHandler; if (success != null) - handlerInfo.resultHandler = x => { + resultHandler = x => { success(x); medium.Resolve(x); }; else - handlerInfo.resultHandler = medium.Resolve; + resultHandler = medium.Resolve; if (error != null) - handlerInfo.errorHandler = x => { + errorHandler = x => { try { medium.Resolve(error(x)); } catch { } medium.Reject(x); }; else - handlerInfo.errorHandler = medium.Reject; + errorHandler = medium.Reject; - AddHandler(handlerInfo); + AddHandler(resultHandler, errorHandler, medium.InternalCancel); return medium; } @@ -214,19 +256,17 @@ namespace Implab { var medium = new Promise(this, true); - var handlerInfo = new ResultHandlerInfo(); - + ResultHandler resultHandler; + if (success != null) - handlerInfo.resultHandler = x => { + resultHandler = x => { success(x); medium.Resolve(x); }; else - handlerInfo.resultHandler = medium.Resolve; + resultHandler = medium.Resolve; - handlerInfo.errorHandler = medium.Reject; - - AddHandler(handlerInfo); + AddHandler(resultHandler, medium.Reject, medium.InternalCancel); return medium; } @@ -249,15 +289,17 @@ namespace Implab { var medium = new Promise(this, true); - AddHandler(new ResultHandlerInfo { - errorHandler = e => { + AddHandler( + null, + e => { try { medium.Resolve(handler(e)); } catch (Exception e2) { medium.Reject(e2); } - } - }); + }, + medium.InternalCancel + ); return medium; } @@ -268,8 +310,8 @@ namespace Implab { var medium = new Promise(); - AddHandler(new ResultHandlerInfo { - resultHandler = x => { + AddHandler( + x => { // to avoid handler being called multiple times we handle exception by ourselfs try { handler(); @@ -278,13 +320,16 @@ namespace Implab { medium.Reject(e); } }, - errorHandler = x => { + + e => { try { handler(); } catch { } - medium.Reject(x); - } - }); + medium.Reject(e); + }, + + medium.InternalCancel + ); return medium; } @@ -304,17 +349,22 @@ namespace Implab { // создаем прицепленное обещание var chained = new Promise(); - AddHandler(new ResultHandlerInfo() { - resultHandler = result => chained.Resolve(mapper(result)), - errorHandler = delegate(Exception e) { - if (error != null) - try { - error(e); - } catch { } - // в случае ошибки нужно передать исключение дальше по цепочке - chained.Reject(e); - } - }); + ResultHandler resultHandler = result => chained.Resolve(mapper(result)); + ErrorHandler errorHandler = delegate(Exception e) { + if (error != null) + try { + error(e); + } catch { } + // в случае ошибки нужно передать исключение дальше по цепочке + chained.Reject(e); + }; + + + AddHandler( + resultHandler, + errorHandler, + chained.InternalCancel + ); return chained; } @@ -341,27 +391,32 @@ namespace Implab { // передать через него результаты работы. var medium = new Promise(this, true); - AddHandler(new ResultHandlerInfo { - resultHandler = delegate(T result) { - if (medium.State == PromiseState.Cancelled) - return; + ResultHandler resultHandler = delegate(T result) { + if (medium.IsCancelled) + return; - var promise = chained(result); + var promise = chained(result); - // notify chained operation that it's not needed - medium.Cancelled(() => promise.Cancel()); - promise.Then( - x => medium.Resolve(x), - e => medium.Reject(e) - ); - }, - errorHandler = delegate(Exception e) { - if (error != null) - error(e); - // в случае ошибки нужно передать исключение дальше по цепочке - medium.Reject(e); - } - }); + // notify chained operation that it's not needed + medium.Cancelled(() => promise.Cancel()); + promise.Then( + x => medium.Resolve(x), + e => medium.Reject(e) + ); + }; + + ErrorHandler errorHandler = delegate(Exception e) { + if (error != null) + error(e); + // в случае ошибки нужно передать исключение дальше по цепочке + medium.Reject(e); + }; + + AddHandler( + resultHandler, + errorHandler, + medium.InternalCancel + ); return medium; } @@ -371,19 +426,19 @@ namespace Implab { } public Promise Cancelled(Action handler) { - if (handler == null) - return this; - lock (m_lock) { - if (m_state == PromiseState.Unresolved) - m_cancelHandlers.AddLast(handler); - else if (m_state == PromiseState.Cancelled) - handler(); - } + AddHandler(null, null, handler); return this; } - public void HandleCancelled(Action handler) { - Cancelled(handler); + public Promise Finally(Action handler) { + if (handler == null) + throw new ArgumentNullException("handler"); + AddHandler( + x => handler(), + e => handler(), + handler + ); + return this; } /// @@ -415,15 +470,15 @@ namespace Implab { if (!evt.WaitOne(timeout, true)) throw new TimeoutException(); - switch (State) { - case PromiseState.Resolved: + switch (m_state) { + case ResolvedState: return m_result; - case PromiseState.Cancelled: + case CancelledState: throw new OperationCanceledException(); - case PromiseState.Rejected: + case RejectedState: throw new TargetInvocationException(m_error); default: - throw new ApplicationException(String.Format("Invalid promise state {0}", State)); + throw new ApplicationException(String.Format("Invalid promise state {0}", m_state)); } } @@ -431,40 +486,45 @@ namespace Implab { return Join(Timeout.Infinite); } - void AddHandler(ResultHandlerInfo handler) { - bool invokeRequired = false; + void AddHandler(ResultHandler success, ErrorHandler error, Action cancel) { + Interlocked.Increment(ref m_childrenCount); + + HandlerDescriptor handler = new HandlerDescriptor { + resultHandler = success, + errorHandler = error, + cancellHandler = cancel + }; - lock (m_lock) { - m_childrenCount++; - if (m_state == PromiseState.Unresolved) { - m_resultHandlers.AddLast(handler); - } else - invokeRequired = true; + bool queued; + + if (!IsResolved) { + m_handlers.Enqueue(handler); + queued = true; + } else { + // the promise is in resolved state, just invoke the handled with minimum overhead + queued = false; + InvokeHandler(handler); } - // обработчики не должны блокировать сам объект - if (invokeRequired) + if (queued && IsResolved && m_handlers.TryDequeue(out handler)) + // if the promise have been resolved while we was adding handler to the queue + // we can't guarantee that someone is still processing it + // therefore we will fetch a handler from the queue and execute it + // note that fetched handler may be not the one we have added InvokeHandler(handler); + } - void InvokeHandler(ResultHandlerInfo handler) { + void InvokeHandler(HandlerDescriptor handler) { switch (m_state) { - case PromiseState.Resolved: - try { - if (handler.resultHandler != null) - handler.resultHandler(m_result); - } catch (Exception e) { - try { - if (handler.errorHandler != null) - handler.errorHandler(e); - } catch { } - } + case ResolvedState: + handler.Resolve(m_result); break; - case PromiseState.Rejected: - try { - if (handler.errorHandler != null) - handler.errorHandler(m_error); - } catch { } + case RejectedState: + handler.Reject(m_error); + break; + case CancelledState: + handler.Cancel(); break; default: // do nothing @@ -473,76 +533,31 @@ namespace Implab { } protected virtual void OnStateChanged() { - switch (m_state) { - case PromiseState.Resolved: - foreach (var resultHandlerInfo in m_resultHandlers) - try { - if (resultHandlerInfo.resultHandler != null) - resultHandlerInfo.resultHandler(m_result); - } catch (Exception e) { - try { - if (resultHandlerInfo.errorHandler != null) - resultHandlerInfo.errorHandler(e); - } catch { } - } - break; - case PromiseState.Cancelled: - foreach (var cancelHandler in m_cancelHandlers) - cancelHandler(); - break; - case PromiseState.Rejected: - foreach (var resultHandlerInfo in m_resultHandlers) - try { - if (resultHandlerInfo.errorHandler != null) - resultHandlerInfo.errorHandler(m_error); - } catch { } - break; - default: - throw new InvalidOperationException(String.Format("Promise entered an invalid state {0}", m_state)); - } - - m_resultHandlers = null; - m_cancelHandlers = null; + HandlerDescriptor handler; + while (m_handlers.TryDequeue(out handler)) + InvokeHandler(handler); } public bool IsExclusive { get { - lock (m_lock) { - return m_childrenCount <= 1; - } - } - } - - public PromiseState State { - get { - lock (m_lock) { - return m_state; - } + return m_childrenCount <= 1; } } protected bool Cancel(bool dependencies) { - bool result; - - lock (m_lock) { - if (m_state == PromiseState.Unresolved) { - m_state = PromiseState.Cancelled; - result = true; - } else { - result = false; - } - } - - if (result) + if (BeginTransit()) { + CompleteTransit(CancelledState); OnStateChanged(); - if (dependencies && m_parent != null && m_parent.IsExclusive) { - m_parent.Cancel(); + if (dependencies && m_parent != null && m_parent.IsExclusive) + m_parent.Cancel(); + + return true; + } else { + return false; } - - return result; } }