# HG changeset patch
# User cin
# Date 2013-11-06 23:41:32
# Node ID 0f982f9b7d4d0bf83e1700783d6b0eb8fe01aec5
# Parent  e943453e5039617dcc330948d1aa9a17b3ce4c70

implemented parallel map and foreach for arrays
rewritten WorkerPool with MTQueue for more efficiency

diff --git a/Implab.Test/AsyncTests.cs b/Implab.Test/AsyncTests.cs
--- a/Implab.Test/AsyncTests.cs
+++ b/Implab.Test/AsyncTests.cs
@@ -4,71 +4,64 @@ using System.Reflection;
 using System.Threading;
 using Implab.Parallels;
 
-namespace Implab.Test
-{
-	[TestClass]
-	public class AsyncTests
-	{
-		[TestMethod]
-		public void ResolveTest ()
-		{
-			int res = -1;
-			var p = new Promise<int> ();
-			p.Then (x => res = x);
-			p.Resolve (100);
+namespace Implab.Test {
+    [TestClass]
+    public class AsyncTests {
+        [TestMethod]
+        public void ResolveTest() {
+            int res = -1;
+            var p = new Promise<int>();
+            p.Then(x => res = x);
+            p.Resolve(100);
 
-			Assert.AreEqual (res, 100);
-		}
+            Assert.AreEqual(res, 100);
+        }
 
         [TestMethod]
-		public void RejectTest ()
-		{
-			int res = -1;
-			Exception err = null;
+        public void RejectTest() {
+            int res = -1;
+            Exception err = null;
 
-			var p = new Promise<int> ();
-			p.Then (x => res = x, e => err = e);
-			p.Reject (new ApplicationException ("error"));
+            var p = new Promise<int>();
+            p.Then(x => res = x, e => err = e);
+            p.Reject(new ApplicationException("error"));
 
-			Assert.AreEqual (res, -1);
-			Assert.AreEqual (err.Message, "error");
+            Assert.AreEqual(res, -1);
+            Assert.AreEqual(err.Message, "error");
 
-		}
+        }
 
         [TestMethod]
-		public void JoinSuccessTest ()
-		{
-			var p = new Promise<int> ();
-			p.Resolve (100);
-			Assert.AreEqual (p.Join (), 100);
-		}
+        public void JoinSuccessTest() {
+            var p = new Promise<int>();
+            p.Resolve(100);
+            Assert.AreEqual(p.Join(), 100);
+        }
 
         [TestMethod]
-		public void JoinFailTest ()
-		{
-			var p = new Promise<int> ();
-			p.Reject (new ApplicationException ("failed"));
+        public void JoinFailTest() {
+            var p = new Promise<int>();
+            p.Reject(new ApplicationException("failed"));
 
-			try {
-				p.Join ();
-				throw new ApplicationException ("WRONG!");
-			} catch (TargetInvocationException err) {
-				Assert.AreEqual (err.InnerException.Message, "failed");
-			} catch {
-				Assert.Fail ("Got wrong excaption");
-			}
-		}
+            try {
+                p.Join();
+                throw new ApplicationException("WRONG!");
+            } catch (TargetInvocationException err) {
+                Assert.AreEqual(err.InnerException.Message, "failed");
+            } catch {
+                Assert.Fail("Got wrong excaption");
+            }
+        }
 
         [TestMethod]
-		public void MapTest ()
-		{
-			var p = new Promise<int> ();
+        public void MapTest() {
+            var p = new Promise<int>();
 
-			var p2 = p.Map (x => x.ToString ());
-			p.Resolve (100);
+            var p2 = p.Map(x => x.ToString());
+            p.Resolve(100);
 
-			Assert.AreEqual (p2.Join (), "100");
-		}
+            Assert.AreEqual(p2.Join(), "100");
+        }
 
         [TestMethod]
         public void FixErrorTest() {
@@ -82,65 +75,90 @@ namespace Implab.Test
         }
 
         [TestMethod]
-		public void ChainTest ()
-		{
-			var p1 = new Promise<int> ();
+        public void ChainTest() {
+            var p1 = new Promise<int>();
 
-			var p3 = p1.Chain (x => {
-				var p2 = new Promise<string> ();
-				p2.Resolve (x.ToString ());
-				return p2;
-			});
+            var p3 = p1.Chain(x => {
+                var p2 = new Promise<string>();
+                p2.Resolve(x.ToString());
+                return p2;
+            });
 
-			p1.Resolve (100);
+            p1.Resolve(100);
 
-			Assert.AreEqual (p3.Join (), "100");
-		}
+            Assert.AreEqual(p3.Join(), "100");
+        }
 
         [TestMethod]
-		public void PoolTest ()
-		{
-			var pid = Thread.CurrentThread.ManagedThreadId;
-			var p = AsyncPool.Invoke (() => Thread.CurrentThread.ManagedThreadId);
+        public void PoolTest() {
+            var pid = Thread.CurrentThread.ManagedThreadId;
+            var p = AsyncPool.Invoke(() => Thread.CurrentThread.ManagedThreadId);
 
-			Assert.AreNotEqual (pid, p.Join ());
-		}
+            Assert.AreNotEqual(pid, p.Join());
+        }
 
         [TestMethod]
         public void WorkerPoolSizeTest() {
-            var pool = new WorkerPool(5,10);
+            var pool = new WorkerPool(5, 10);
 
             Assert.AreEqual(5, pool.ThreadCount);
 
-            pool.Invoke(() => { Thread.Sleep(1000); return 10; });
-            pool.Invoke(() => { Thread.Sleep(1000); return 10; });
-            pool.Invoke(() => { Thread.Sleep(1000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
 
             Assert.AreEqual(5, pool.ThreadCount);
 
             for (int i = 0; i < 100; i++)
-                pool.Invoke(() => { Thread.Sleep(1000); return 10; });
+                pool.Invoke(() => { Thread.Sleep(1000000); return 10; });
+            Thread.Sleep(100);
             Assert.AreEqual(10, pool.ThreadCount);
+
+            pool.Dispose();
         }
 
         [TestMethod]
         public void WorkerPoolCorrectTest() {
-            var pool = new WorkerPool(5, 20);
+            var pool = new WorkerPool();
+
+            int iterations = 1000;
+            int pending = iterations;
+            var stop = new ManualResetEvent(false);
 
             var count = 0;
-            for (int i = 0; i < 1000; i++)
+            for (int i = 0; i < iterations; i++) {
                 pool
                     .Invoke(() => 1)
-                    .Then(x => Interlocked.Add(ref count, x));
+                    .Then(x => Interlocked.Add(ref count, x))
+                    .Then(x => Math.Log10(x))
+                    .Anyway(() => {
+                        Interlocked.Decrement(ref pending);
+                        if (pending == 0)
+                            stop.Set();
+                    });
+            }
+
+            stop.WaitOne();
 
-            Assert.AreEqual(1000, count);
+            Assert.AreEqual(iterations, count);
+            Console.WriteLine("Max threads: {0}", pool.MaxRunningThreads);
+            pool.Dispose();
+            
+        }
+
+        [TestMethod]
+        public void WorkerPoolDisposeTest() {
+            var pool = new WorkerPool(5, 20);
+            Assert.AreEqual(5, pool.ThreadCount);
+            pool.Dispose();
+            Thread.Sleep(100);
+            Assert.AreEqual(0, pool.ThreadCount);
+            pool.Dispose();
         }
 
         [TestMethod]
         public void MTQueueTest() {
             var queue = new MTQueue<int>();
-            var pool = new WorkerPool(5, 20);
-
             int res;
 
             queue.Enqueue(10);
@@ -169,33 +187,27 @@ namespace Implab.Test
                 var wn = i;
                 AsyncPool
                     .InvokeNewThread(() => {
-                        Console.WriteLine("Started writer: {0}", wn);
                         for (int ii = 0; ii < itemsPerWriter; ii++) {
                             queue.Enqueue(1);
-                            Thread.Sleep(1);
                         }
-                        Console.WriteLine("Stopped writer: {0}", wn);
                         return 1;
                     })
-                    .Then(x => Interlocked.Decrement(ref writers) );
+                    .Anyway(() => Interlocked.Decrement(ref writers));
             }
-            
+
             for (int i = 0; i < 10; i++) {
                 Interlocked.Increment(ref readers);
                 var wn = i;
                 AsyncPool
                     .InvokeNewThread(() => {
                         int t;
-                        Console.WriteLine("Started reader: {0}", wn);
                         do {
                             while (queue.TryDequeue(out t))
                                 Interlocked.Add(ref total, t);
-                            Thread.Sleep(0);
                         } while (writers > 0);
-                        Console.WriteLine("Stopped reader: {0}", wn);
                         return 1;
                     })
-                    .Then(x => {
+                    .Anyway(() => {
                         Interlocked.Decrement(ref readers);
                         if (readers == 0)
                             stop.Set();
@@ -208,6 +220,55 @@ namespace Implab.Test
         }
 
         [TestMethod]
+        public void ParallelMapTest() {
+
+            int count = 100000;
+
+            double[] args = new double[count];
+            var rand = new Random();
+
+            for (int i = 0; i < count; i++)
+                args[i] = rand.NextDouble();
+
+            var t = Environment.TickCount;
+            var res = args.ParallelMap(x => Math.Sin(x*x), 4).Join();
+
+            Console.WriteLine("Map complete in {0} ms", Environment.TickCount - t);
+
+            t = Environment.TickCount;
+            for (int i = 0; i < count; i++)
+                Assert.AreEqual(Math.Sin(args[i] * args[i]), res[i]);
+            Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
+        }
+
+        [TestMethod]
+        public void ParallelForEachTest() {
+
+            int count = 100000;
+
+            int[] args = new int[count];
+            var rand = new Random();
+
+            for (int i = 0; i < count; i++)
+                args[i] = (int)(rand.NextDouble() * 100);
+
+            int result = 0;
+
+            var t = Environment.TickCount;
+            args.ParallelForEach(x => Interlocked.Add(ref result, x), 4).Join();
+
+            Console.WriteLine("Iteration complete in {0} ms, result: {1}", Environment.TickCount - t, result);
+
+            int result2 = 0;
+
+            t = Environment.TickCount;
+            for (int i = 0; i < count; i++)
+                result2 += args[i];
+            Assert.AreEqual(result2, result);
+            Console.WriteLine("Verified in {0} ms", Environment.TickCount - t);
+        }
+
+        [TestMethod]
         public void ComplexCase1Test() {
             var flags = new bool[3];
 
@@ -219,7 +280,7 @@ namespace Implab.Test
                 .Chain(x =>
                     PromiseHelper
                         .Sleep(200, "Hi, " + x)
-                        .Map( y => y )
+                        .Map(y => y)
                         .Cancelled(() => flags[1] = true)
                 )
                 .Cancelled(() => flags[2] = true);
@@ -228,13 +289,13 @@ namespace Implab.Test
             try {
                 Assert.AreEqual(p.Join(), "Hi, Alan");
                 Assert.Fail("Shouldn't get here");
-            } catch(OperationCanceledException) {
+            } catch (OperationCanceledException) {
             }
 
             Assert.IsFalse(flags[0]);
             Assert.IsTrue(flags[1]);
             Assert.IsTrue(flags[2]);
         }
-	}
+    }
 }
 
diff --git a/Implab.v11.suo b/Implab.v11.suo
index 89d4ac29ba1a27fd1eba1015282feda7105746af..d05880eb554a9716b818e81f9e8e949a3388219a
GIT binary patch
literal 106496
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
KDNS?ynEwTg8UGpp

diff --git a/Implab/Implab.csproj b/Implab/Implab.csproj
--- a/Implab/Implab.csproj
+++ b/Implab/Implab.csproj
@@ -38,6 +38,8 @@
     <Compile Include="IPromise.cs" />
     <Compile Include="ITaskController.cs" />
     <Compile Include="ManagedPromise.cs" />
+    <Compile Include="Parallels\DispatchPool.cs" />
+    <Compile Include="Parallels\ArrayTraits.cs" />
     <Compile Include="Parallels\MTQueue.cs" />
     <Compile Include="Parallels\WorkerPool.cs" />
     <Compile Include="PromiseState.cs" />
diff --git a/Implab/Parallels/ArrayTraits.cs b/Implab/Parallels/ArrayTraits.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/ArrayTraits.cs
@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Implab.Parallels {
+    public static class ArrayTraits {
+        class ArrayIterator<TSrc> : DispatchPool<int> {
+            readonly Action<TSrc> m_action;
+            readonly TSrc[] m_source;
+            readonly Promise<int> m_promise = new Promise<int>();
+
+            int m_pending;
+            int m_next;
+
+            public ArrayIterator(TSrc[] source, Action<TSrc> action, int threads)
+                : base(threads) {
+
+                Debug.Assert(source != null);
+                Debug.Assert(action != null);
+
+                m_next = 0;
+                m_source = source;
+                m_pending = source.Length;
+                m_action = action;
+
+                m_promise.Anyway(() => Dispose());
+                m_promise.Cancelled(() => Dispose());
+
+                InitPool();
+            }
+
+            public Promise<int> Promise {
+                get {
+                    return m_promise;
+                }
+            }
+
+            protected override bool TryDequeue(out int unit) {
+                int index;
+                unit = -1;
+                do {
+                    index = m_next;
+                    if (index >= m_source.Length)
+                        return false;
+                } while (index != Interlocked.CompareExchange(ref m_next, index + 1, index));
+
+                unit = index;
+                return true;
+            }
+
+            protected override void InvokeUnit(int unit) {
+                try {
+                    m_action(m_source[unit]);
+                    int pending;
+                    do {
+                        pending = m_pending;
+                    } while (pending != Interlocked.CompareExchange(ref m_pending, pending - 1, pending));
+                    pending--;
+                    if (pending == 0)
+                        m_promise.Resolve(m_source.Length);
+                } catch (Exception e) {
+                    m_promise.Reject(e);
+                }
+            }
+        }
+
+        class ArrayMapper<TSrc, TDst>: DispatchPool<int> {
+            readonly Func<TSrc, TDst> m_transform;
+            readonly TSrc[] m_source;
+            readonly TDst[] m_dest;
+            readonly Promise<TDst[]> m_promise = new Promise<TDst[]>();
+
+            int m_pending;
+            int m_next;
+
+            public ArrayMapper(TSrc[] source, Func<TSrc, TDst> transform, int threads)
+                : base(threads) {
+
+                Debug.Assert (source != null);
+                Debug.Assert( transform != null);
+
+                m_next = 0;
+                m_source = source;
+                m_dest = new TDst[source.Length];
+                m_pending = source.Length;
+                m_transform = transform;
+
+                m_promise.Anyway(() => Dispose());
+                m_promise.Cancelled(() => Dispose());
+
+                InitPool();
+            }
+
+            public Promise<TDst[]> Promise {
+                get {
+                    return m_promise;
+                }
+            }
+
+            protected override bool TryDequeue(out int unit) {
+                int index;
+                unit = -1;
+                do {
+                    index = m_next;
+                    if (index >= m_source.Length)
+                        return false;
+                } while (index != Interlocked.CompareExchange(ref m_next, index + 1, index));
+
+                unit = index;
+                return true;
+            }
+
+            protected override void InvokeUnit(int unit) {
+                try {
+                    m_dest[unit] = m_transform(m_source[unit]);
+                    int pending;
+                    do {
+                        pending = m_pending;
+                    } while ( pending != Interlocked.CompareExchange(ref m_pending,pending -1, pending));
+                    pending --;
+                    if (pending == 0)
+                        m_promise.Resolve(m_dest);
+                } catch (Exception e) {
+                    m_promise.Reject(e);
+                }
+            }
+        }
+
+        public static Promise<TDst[]> ParallelMap<TSrc, TDst> (this TSrc[] source, Func<TSrc,TDst> transform, int threads) {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (transform == null)
+                throw new ArgumentNullException("transform");
+
+            var mapper = new ArrayMapper<TSrc, TDst>(source, transform, threads);
+            return mapper.Promise;
+        }
+
+        public static Promise<int> ParallelForEach<TSrc>(this TSrc[] source, Action<TSrc> action, int threads) {
+            if (source == null)
+                throw new ArgumentNullException("source");
+            if (action == null)
+                throw new ArgumentNullException("action");
+
+            var iter = new ArrayIterator<TSrc>(source, action, threads);
+            return iter.Promise;
+        }
+    }
+}
diff --git a/Implab/Parallels/DispatchPool.cs b/Implab/Parallels/DispatchPool.cs
new file mode 100644
--- /dev/null
+++ b/Implab/Parallels/DispatchPool.cs
@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Diagnostics;
+
+namespace Implab.Parallels {
+    public abstract class DispatchPool<TUnit> : IDisposable {
+        readonly int m_minThreads;
+        readonly int m_maxThreads;
+        int m_runningThreads = 0;
+        int m_maxRunningThreads = 0;
+        int m_suspended = 0;
+        int m_exitRequired = 0;
+        AutoResetEvent m_hasTasks = new AutoResetEvent(false);
+
+        protected DispatchPool(int min, int max) {
+            if (min < 0)
+                throw new ArgumentOutOfRangeException("min");
+            if (max <= 0)
+                throw new ArgumentOutOfRangeException("max");
+
+            if (min > max)
+                min = max;
+            m_minThreads = min;
+            m_maxThreads = max;
+        }
+
+        protected DispatchPool(int threads)
+            : this(threads, threads) {
+        }
+
+        protected DispatchPool() {
+            int maxThreads, maxCP;
+            ThreadPool.GetMaxThreads(out maxThreads, out maxCP);
+
+            m_minThreads = 0;
+            m_maxThreads = maxThreads;
+        }
+
+        protected void InitPool() {
+            for (int i = 0; i < m_minThreads; i++)
+                StartWorker();
+        }
+
+        public int ThreadCount {
+            get {
+                return m_runningThreads;
+            }
+        }
+
+        public int MaxRunningThreads {
+            get {
+                return m_maxRunningThreads;
+            }
+        }
+
+        protected bool IsDisposed {
+            get {
+                return m_exitRequired != 0;
+            }
+        }
+
+        bool StartWorker() {
+            var current = m_runningThreads;
+            // use spins to allocate slot for the new thread
+            do {
+                if (current >= m_maxThreads || m_exitRequired != 0)
+                    // no more slots left or the pool has been disposed
+                    return false;
+            } while (current != Interlocked.CompareExchange(ref m_runningThreads, current + 1, current));
+
+            m_maxRunningThreads = Math.Max(m_maxRunningThreads, current + 1);
+
+            // slot successfully allocated
+
+            var worker = new Thread(this.Worker);
+            worker.IsBackground = true;
+            worker.Start();
+
+            return true;
+        }
+
+        protected abstract bool TryDequeue(out TUnit unit);
+
+        protected virtual void WakeNewWorker() {
+            if (m_suspended > 0)
+                m_hasTasks.Set();
+            else
+                StartWorker();
+        }
+
+        bool FetchTask(out TUnit unit) {
+            do {
+                // exit if requested
+                if (m_exitRequired != 0) {
+                    // release the thread slot
+                    int running;
+                    do {
+                        running = m_runningThreads;
+                    } while (running != Interlocked.CompareExchange(ref m_runningThreads, running - 1, running));
+                    running--;
+
+                    if (running == 0) // it was the last worker
+                        m_hasTasks.Dispose();
+                    else
+                        m_hasTasks.Set(); // release next worker
+                    unit = default(TUnit);
+                    return false;
+                }
+
+                // fetch task
+                if (TryDequeue(out unit)) {
+                    WakeNewWorker();
+                    return true;
+                }
+
+                //no tasks left, exit if the thread is no longer needed
+                int runningThreads;
+                bool exit = true;
+                do {
+                    runningThreads = m_runningThreads;
+                    if (runningThreads <= m_minThreads) {
+                        exit = false;
+                        break;
+                    }
+                } while (runningThreads != Interlocked.CompareExchange(ref m_runningThreads, runningThreads - 1, runningThreads));
+
+                if (exit) {
+                    Interlocked.Decrement(ref m_runningThreads);
+                    return false;
+                }
+
+                // keep this thread and wait
+                Interlocked.Increment(ref m_suspended);
+                m_hasTasks.WaitOne();
+                Interlocked.Decrement(ref m_suspended);
+            } while (true);
+        }
+
+        protected abstract void InvokeUnit(TUnit unit);
+
+        void Worker() {
+            TUnit unit;
+            while (FetchTask(out unit))
+                InvokeUnit(unit);
+        }
+
+        protected virtual void Dispose(bool disposing) {
+            if (disposing) {
+                if (m_exitRequired == 0) {
+                    if (Interlocked.CompareExchange(ref m_exitRequired, 1, 0) != 0)
+                        return;
+
+                    // wake sleeping threads
+                    m_hasTasks.Set();
+                    GC.SuppressFinalize(this);
+                }
+            }
+        }
+
+        public void Dispose() {
+            Dispose(true);
+        }
+
+        ~DispatchPool() {
+            Dispose(false);
+        }
+    }
+}
diff --git a/Implab/Parallels/WorkerPool.cs b/Implab/Parallels/WorkerPool.cs
--- a/Implab/Parallels/WorkerPool.cs
+++ b/Implab/Parallels/WorkerPool.cs
@@ -6,66 +6,35 @@ using System.Threading;
 using System.Diagnostics;
 
 namespace Implab.Parallels {
-    public class WorkerPool : IDisposable {
-        readonly int m_minThreads;
-        readonly int m_maxThreads;
-        int m_runningThreads;
-        object m_lock = new object();
-
-        bool m_disposed = false;
-
-        // this event will signal that workers can try to fetch a task from queue or the pool has been disposed
-        ManualResetEvent m_hasTasks = new ManualResetEvent(false);
-        Queue<Action> m_queue = new Queue<Action>();
+    public class WorkerPool : DispatchPool<Action> {
 
-        public WorkerPool(int min, int max) {
-            if (min < 0)
-                throw new ArgumentOutOfRangeException("min");
-            if (max <= 0)
-                throw new ArgumentOutOfRangeException("max");
+        MTQueue<Action> m_queue = new MTQueue<Action>();
+        int m_queueLength = 0;
 
-            if (min > max)
-                min = max;
-            m_minThreads = min;
-            m_maxThreads = max;
-
-            InitPool();
+        public WorkerPool(int minThreads, int maxThreads)
+            : base(minThreads, maxThreads) {
+                InitPool();
         }
 
-        public WorkerPool(int max)
-            : this(0, max) {
+        public WorkerPool(int threads)
+            : base(threads) {
+                InitPool();
         }
 
-        public WorkerPool() {
-            int maxThreads, maxCP;
-            ThreadPool.GetMaxThreads(out maxThreads, out maxCP);
-
-            m_minThreads = 0;
-            m_maxThreads = maxThreads;
-
-            InitPool();
-        }
-
-        void InitPool() {
-            for (int i = 0; i < m_minThreads; i++)
-                StartWorker();
-        }
-
-        public int ThreadCount {
-            get {
-                return m_runningThreads;
-            }
+        public WorkerPool()
+            : base() {
+                InitPool();
         }
 
         public Promise<T> Invoke<T>(Func<T> task) {
-            if (m_disposed)
-                throw new ObjectDisposedException(ToString());
             if (task == null)
                 throw new ArgumentNullException("task");
+            if (IsDisposed)
+                throw new ObjectDisposedException(ToString());
 
             var promise = new Promise<T>();
 
-            var queueLen = EnqueueTask(delegate() {
+            EnqueueTask(delegate() {
                 try {
                     promise.Resolve(task());
                 } catch (Exception e) {
@@ -73,99 +42,28 @@ namespace Implab.Parallels {
                 }
             });
 
-            if (queueLen > 1)
-                StartWorker();
-
             return promise;
         }
 
-        bool StartWorker() {
-            var current = m_runningThreads;
-            // use spins to allocate slot for the new thread
-            do {
-                if (current >= m_maxThreads)
-                    // no more slots left
-                    return false;
-            } while (current != Interlocked.CompareExchange(ref m_runningThreads, current + 1, current));
-
-            // slot successfully allocated
-
-            var worker = new Thread(this.Worker);
-            worker.IsBackground = true;
-            worker.Start();
-
-            return true;
-        }
-
-        int EnqueueTask(Action task) {
-            Debug.Assert(task != null);
-            lock (m_queue) {
-                m_queue.Enqueue(task);
-                m_hasTasks.Set();
-                return m_queue.Count;
-            }
+        protected void EnqueueTask(Action unit) {
+            Debug.Assert(unit != null);
+            Interlocked.Increment(ref m_queueLength);
+            m_queue.Enqueue(unit);
+            // if there are sleeping threads in the pool wake one
+            // probably this will lead a dry run
+            WakeNewWorker();
         }
 
-        bool FetchTask(out Action task) {
-            task = null;
-
-            while (true) {
-
-                m_hasTasks.WaitOne();
-
-                if (m_disposed)
-                    return false;
-
-                lock (m_queue) {
-                    if (m_queue.Count > 0) {
-                        task = m_queue.Dequeue();
-                        return true;
-                    }
-
-                    // no tasks left
-                    // signal that no more tasks left, current lock ensures that this event won't suppress newly added task
-                    m_hasTasks.Reset();
-                }
-                
-                bool exit = true;
-
-                var current = m_runningThreads;
-                do {
-                    if (current <= m_minThreads) {
-                        exit = false; // this thread should return and wait for the new events
-                        break;
-                    }
-                } while (current != Interlocked.CompareExchange(ref m_runningThreads, current - 1, current));
-
-                if (exit)
-                    return false;
+        protected override bool TryDequeue(out Action unit) {
+            if (m_queue.TryDequeue(out unit)) {
+                Interlocked.Decrement(ref m_queueLength);
+                return true;
             }
+            return false;
         }
 
-        void Worker() {
-            Action task;
-            while (FetchTask(out task))
-                task();
-        }
-
-        protected virtual void Dispose(bool disposing) {
-            if (disposing) {
-                lock (m_lock) {
-                    if (m_disposed)
-                        return;
-                    m_disposed = true;
-                }
-                m_hasTasks.Set();
-                GC.SuppressFinalize(this);
-            }
-        }
-
-        public void Dispose() {
-            Dispose(true);
-        }
-
-        ~WorkerPool() {
-            Dispose(false);
+        protected override void InvokeUnit(Action unit) {
+            unit();
         }
     }
 }
diff --git a/Implab/Promise.cs b/Implab/Promise.cs
--- a/Implab/Promise.cs
+++ b/Implab/Promise.cs
@@ -539,5 +539,6 @@ namespace Implab {
 
             return result;
         }
+
     }
 }