# HG changeset patch
# User cin
# Date 2013-11-09 20:21:33
# Node ID e3935fdf59a2a7ec7e38de609b39531519cf4ea3
# Parent  7cd4a843b4e4084855ab73d2a036bffaa0705f4f

Promise is rewritten to use interlocked operations instead of locks

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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

diff --git a/Implab/IPromise.cs b/Implab/IPromise.cs
--- a/Implab/IPromise.cs
+++ b/Implab/IPromise.cs
@@ -15,19 +15,6 @@ namespace Implab
             get;
         }
 
-        /// <summary>
-        /// The current state of the promise.
-        /// </summary>
-        PromiseState State
-        {
-            get;
-        }
 
-        /// <summary>
-        /// Registers handler for the case when the promise is cencelled. If the promise already cancelled the
-        /// handler will be invoked immediatelly.
-        /// </summary>
-        /// <param name="handler">The handler</param>
-        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 {
     /// </remarks>
     public class Promise<T> : IPromise {
 
-        struct ResultHandlerInfo {
+        struct HandlerDescriptor {
             public ResultHandler<T> 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<ResultHandlerInfo> m_resultHandlers = new LinkedList<ResultHandlerInfo>();
-        LinkedList<Action> m_cancelHandlers = new LinkedList<Action>();
+        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<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
+
         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;
+            }
+        }
+
         /// <summary>
         /// Выполняет обещание, сообщая об успешном выполнении.
         /// </summary>
         /// <param name="result">Результат выполнения.</param>
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         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");
         }
 
         /// <summary>
@@ -111,16 +156,12 @@ namespace Implab {
         /// <param name="error">Исключение возникшее при выполнении операции</param>
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         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");
         }
 
         /// <summary>
@@ -144,27 +185,27 @@ namespace Implab {
 
             var medium = new Promise<T>(this, true);
 
-            var handlerInfo = new ResultHandlerInfo();
-
+            ResultHandler<T> 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<T>(this, true);
 
-            var handlerInfo = new ResultHandlerInfo();
+            ResultHandler<T> 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<T>(this, true);
 
-            var handlerInfo = new ResultHandlerInfo();
-
+            ResultHandler<T> 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<T>(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<T>();
 
-            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<TNew>();
 
-            AddHandler(new ResultHandlerInfo() {
-                resultHandler = result => chained.Resolve(mapper(result)),
-                errorHandler = delegate(Exception e) {
-                    if (error != null)
-                        try {
-                            error(e);
-                        } catch { }
-                    // в случае ошибки нужно передать исключение дальше по цепочке
-                    chained.Reject(e);
-                }
-            });
+            ResultHandler<T> 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<TNew>(this, true);
 
-            AddHandler(new ResultHandlerInfo {
-                resultHandler = delegate(T result) {
-                    if (medium.State == PromiseState.Cancelled)
-                        return;
+            ResultHandler<T> 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<T> 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<T> Finally(Action handler) {
+            if (handler == null)
+                throw new ArgumentNullException("handler");
+            AddHandler(
+                x => handler(),
+                e => handler(),
+                handler
+            );
+            return this;
         }
 
         /// <summary>
@@ -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<T> 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;
         }
 
     }