threading: ported from dnAnalytics

Signed-off-by: Christoph Ruegg <git@cdrnet.ch>

src/Managed.UnitTests/Managed.UnitTests.csproj

@@ -71,6 +71,7 @@
     <Compile Include="PrecisionTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SpecialFunctionsTest\ErfTests.cs" />
+    <Compile Include="ThreadingTests\ParallelTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Managed\Managed.csproj">

src/Managed.UnitTests/ThreadingTests/ParallelTest.cs

@@ -0,0 +1,146 @@
+// <copyright file="ParallelTest.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+namespace MathNet.Numerics.UnitTests.ThreadingTests
+{
+    using System;
+    using System.Threading;
+    using MbUnit.Framework;
+    using Threading;
+
+    [TestFixture]
+    public class ParallelTest
+    {
+        [Test, ApartmentState(ApartmentState.MTA)]
+        [Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)]
+        public void ParallelForInvokesEveryItemOnceMTAOnePerCore(int count)
+        {
+            var items = new int[count];
+
+            // ensure One-Per-Core
+            ThreadQueue.Start(Environment.ProcessorCount);
+
+            Parallel.For(0, count, i => items[i]++);
+            Parallel.For(0, count, i => items[i] += 1000);
+
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.AreEqual(1001, items[i], i.ToString());
+            }
+        }
+
+        [Test, ApartmentState(ApartmentState.STA)]
+        [Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)]
+        public void ParallelForInvokesEveryItemOnceSTAOnePerCore(int count)
+        {
+            var items = new int[count];
+
+            // ensure One-Per-Core
+            ThreadQueue.Start(Environment.ProcessorCount);
+
+            Parallel.For(0, count, i => items[i]++);
+            Parallel.For(0, count, i => items[i] += 1000);
+
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.AreEqual(1001, items[i], i.ToString());
+            }
+        }
+
+        [Test, ApartmentState(ApartmentState.MTA)]
+        [Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)]
+        public void ParallelForInvokesEveryItemOnceMTATwoPerCore(int count)
+        {
+            var items = new int[count];
+
+            // ensure Two-Per-Core
+            ThreadQueue.Start(2 * Environment.ProcessorCount);
+
+            Parallel.For(0, count, i => items[i]++);
+            Parallel.For(0, count, i => items[i] += 1000);
+
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.AreEqual(1001, items[i], i.ToString());
+            }
+        }
+
+        [Test, ApartmentState(ApartmentState.STA)]
+        [Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)]
+        public void ParallelForInvokesEveryItemOnceSTATwoPerCore(int count)
+        {
+            var items = new int[count];
+
+            // ensure Two-Per-Core
+            ThreadQueue.Start(2 * Environment.ProcessorCount);
+
+            Parallel.For(0, count, i => items[i]++);
+            Parallel.For(0, count, i => items[i] += 1000);
+
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.AreEqual(1001, items[i], i.ToString());
+            }
+        }
+
+        [Test, ApartmentState(ApartmentState.MTA)]
+        public void DoesNotGetConfusedByMultipleStartShutdown()
+        {
+            ThreadQueue.Shutdown();
+            ThreadQueue.Shutdown();
+
+            ThreadQueue.Start(2);
+            Assert.AreEqual(2, ThreadQueue.ThreadCount);
+
+            ThreadQueue.Start(2);
+            Assert.AreEqual(2, ThreadQueue.ThreadCount);
+
+            ThreadQueue.Start(4);
+            Assert.AreEqual(4, ThreadQueue.ThreadCount);
+
+            ThreadQueue.Shutdown();
+            ThreadQueue.Start();
+            Assert.AreEqual(4, ThreadQueue.ThreadCount);
+
+            ThreadQueue.Start(2);
+            Assert.AreEqual(2, ThreadQueue.ThreadCount);
+
+            var items = new int[50];
+
+            Parallel.For(0, items.Length, i => items[i]++);
+            Parallel.For(0, items.Length, i => items[i] += 1000);
+
+            ThreadQueue.Shutdown();
+
+            for(int i = 0; i < items.Length; i++)
+            {
+                Assert.AreEqual(1001, items[i], i.ToString());
+            }
+        }
+    }
+}

src/Managed/Managed.csproj

@@ -81,6 +81,10 @@
     <Compile Include="SiPrefixes.cs" />
     <Compile Include="SpecialFunctions.cs" />
     <Compile Include="SpecialFunctions\Erf.cs" />
+    <Compile Include="Threading\AggregateException.cs" />
+    <Compile Include="Threading\Parallel.cs" />
+    <Compile Include="Threading\Task.cs" />
+    <Compile Include="Threading\ThreadQueue.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">

src/Managed/Properties/Resources.Designer.cs

@@ -87,6 +87,15 @@ namespace MathNet.Numerics.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to At least one item of {0} is a null reference (Nothing in Visual Basic)..
+        /// </summary>
+        internal static string ArgumentItemNull {
+            get {
+                return ResourceManager.GetString("ArgumentItemNull", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to The matrix indices must not be out of range of the given matrix..
         /// </summary>

src/Managed/Properties/Resources.resx

@@ -246,4 +246,7 @@
   <data name="ArgumentOdd" xml:space="preserve">
     <value>Value must be odd.</value>
   </data>
+  <data name="ArgumentItemNull" xml:space="preserve">
+    <value>At least one item of {0} is a null reference (Nothing in Visual Basic).</value>
+  </data>
 </root>

src/Managed/Threading/AggregateException.cs

@@ -0,0 +1,66 @@
+// <copyright file="AggregateException.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+namespace MathNet.Numerics.Threading
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+
+    /// <summary>
+    /// Represents multiple errors that occur during application execution.
+    /// </summary>
+    public class AggregateException : Exception
+    {
+        /// <summary>
+        /// List of the aggregated exceptions.
+        /// </summary>
+        private readonly IList<Exception> _exceptions = new List<Exception>();
+
+        /// <summary>
+        /// Initializes a new instance of the AggregateException class with a specified error message and references to the inner exceptions that are the cause of this exception.
+        /// </summary>
+        /// <param name="exceptions">The exceptions that are the cause of the current exception.</param>
+        public AggregateException(IEnumerable<Exception> exceptions)
+        {
+            foreach (var exception in exceptions)
+            {
+                _exceptions.Add(exception);
+            }
+        }
+
+        /// <summary>
+        /// Gets a read-only collection of the Exception instances that caused the current exception. 
+        /// </summary>
+        /// <value>A read-only collection of the Exception instances that caused the current exception</value>
+        public ReadOnlyCollection<Exception> InnerExceptions
+        {
+            get { return new ReadOnlyCollection<Exception>(_exceptions); }
+        }
+    }
+}

src/Managed/Threading/Parallel.cs

@@ -0,0 +1,158 @@
+// <copyright file="Parallel.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+namespace MathNet.Numerics.Threading
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using Properties;
+
+    /// <summary>
+    /// Provides support for parallel loops. 
+    /// </summary>
+    internal static class Parallel
+    {
+        /// <summary>
+        /// Executes a for loop in which iterations may run in parallel. 
+        /// </summary>
+        /// <param name="fromInclusive">The start index, inclusive.</param>
+        /// <param name="toExclusive">The end index, exclusive.</param>
+        /// <param name="body">The body to be invoked for each iteration.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="body"/> argument is null.</exception>
+        /// <exception cref="AggregateException">At least one invocation of the body threw an exception.</exception>
+        internal static void For(int fromInclusive, int toExclusive, Action<int> body)
+        {
+            if (body == null)
+            {
+                throw new ArgumentNullException("body");
+            }
+
+            var actions = new Action[ThreadQueue.ThreadCount];
+            var count = toExclusive - fromInclusive;
+            var size = count / actions.Length;
+
+            if (count < 1)
+            {
+                return;
+            }
+
+            // partition the jobs into separate sets for each but the last worked thread
+            for (var i = 0; i < actions.Length - 1; i++)
+            {
+                var start = fromInclusive + (i * size);
+                var stop = fromInclusive + ((i + 1) * size);
+
+                actions[i] =
+                    () =>
+                    {
+                        for (var j = start; j < stop; j++)
+                        {
+                            body(j);
+                        }
+                    };
+            }
+
+            // add another set for last worker thread
+            actions[actions.Length - 1] =
+                () =>
+                {
+                    for (var i = fromInclusive + ((actions.Length - 1) * size); i < toExclusive; i++)
+                    {
+                        body(i);
+                    }
+                };
+
+            Invoke(actions);
+        }
+
+        /// <summary>
+        /// Executes each of the provided actions inside a discrete, asynchronous task. 
+        /// </summary>
+        /// <param name="actions">An array of actions to execute.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="actions"/> argument is null.</exception>
+        /// <exception cref="ArgumentException">The actions array contains a null element.</exception>
+        /// <exception cref="AggregateException">An action threw an exception.</exception>
+        internal static void Invoke(params Action[] actions)
+        {
+            if (actions == null)
+            {
+                throw new ArgumentNullException("actions");
+            }
+
+            // create a job for each action
+            var tasks = new Task[actions.Length];
+            for (int i = 0; i < tasks.Length; i++)
+            {
+                Action action = actions[i];
+                if (action == null)
+                {
+                    throw new ArgumentException(String.Format(Resources.ArgumentItemNull, "actions"), "actions");
+                }
+
+                tasks[i] = new Task(action);
+            }
+
+            // run the jobs
+            ThreadQueue.Enqueue(tasks);
+
+            // wait until all jobs have completed
+            if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)
+            {
+                //not sure if this the best approach for STA
+                for (int i = 0; i < tasks.Length; i++)
+                {
+                    tasks[i].WaitOne();
+                }
+            }
+            else
+            {
+                WaitHandle.WaitAll(tasks);
+            }
+
+            // collect all thrown exceptions and dispose the jobs
+            var exceptions = new List<Exception>();
+            foreach (var task in tasks)
+            {
+                if (task.ThrewException)
+                {
+                    exceptions.Add(task.Exception);
+                }
+
+                //this calls dispose
+                task.Close();
+            }
+
+            // throw the aggregated exceptions, if any
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+    }
+}

src/Managed/Threading/Task.cs

@@ -0,0 +1,87 @@
+// <copyright file="Task.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+namespace MathNet.Numerics.Threading
+{
+    using System;
+    using System.Threading;
+
+    /// <summary>
+    /// Internal Parallel Task Handle.
+    /// </summary>
+    internal class Task : EventWaitHandle
+    {
+        /// <summary>
+        /// Delegate to the task's action.
+        /// </summary>
+        private readonly Action _body;
+
+        /// <summary>
+        /// Initializes a new instance of the Task class.
+        /// </summary>
+        /// <param name="body">Delegate to the task's action.</param>
+        internal Task(Action body)
+            : base(false, EventResetMode.ManualReset)
+        {
+            if (body == null)
+            {
+                throw new ArgumentNullException("body");
+            }
+
+            _body = body;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the task has thrown one or more exceptions while executing.
+        /// </summary>
+        internal bool ThrewException
+        {
+            get { return Exception != null; }
+        }
+
+        /// <summary>
+        /// Gets the exception thrown by the task, if any.
+        /// </summary>
+        internal Exception Exception { get; private set; }
+
+        /// <summary>
+        /// Run the task.
+        /// </summary>
+        internal void Compute()
+        {
+            try
+            {
+                _body();
+            }
+            catch (Exception e)
+            {
+                Exception = e;
+            }
+        }
+    }
+}

src/Managed/Threading/ThreadQueue.cs

@@ -0,0 +1,235 @@
+// <copyright file="ThreadQueue.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+namespace MathNet.Numerics.Threading
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+
+    /// <summary>
+    /// Internal Parallel Thread Queue.
+    /// </summary>
+    internal static class ThreadQueue
+    {
+        /// <summary>
+        /// Sync Object for the thread queue state.
+        /// </summary>
+        private static readonly object _stateSync = new object();
+
+        /// <summary>
+        /// Sync Object for queue access (to be sure it's used by us only).
+        /// </summary>
+        private static readonly object _queueSync = new object();
+
+        /// <summary>
+        /// Maximum number of jobs that can be in the queue at the same time. 
+        /// </summary>
+        private const int _maximumQueueLength = 1024;
+
+        /// <summary>
+        /// Counting Semaphore to make the worker thread wait for jobs
+        /// </summary>
+        private static Semaphore _tasksAvailableSemaphore;
+
+        /// <summary>
+        /// Queue holding the pending jobs.
+        /// </summary>
+        private static readonly Queue<Task> _queue = new Queue<Task>();
+
+        /// <summary>
+        /// Running flag, used to signal worker threads to stop cleanly.
+        /// </summary>
+        private static bool _running = true;
+
+        /// <summary>
+        /// Worker threads
+        /// </summary>
+        private static Thread[] _threads;
+
+        /// <summary>
+        /// Number of worked threads.
+        /// </summary>
+        internal static int ThreadCount { get; private set; }
+
+        /// <summary>
+        /// Static Constructor
+        /// </summary>
+        static ThreadQueue()
+        {
+            // TODO: Control.ThreadCount instead of Environment.ProcessorCount
+            Start(Environment.ProcessorCount);
+        }
+
+        /// <summary>
+        /// Add a job to the queue.
+        /// </summary>
+        /// <param name="task">The job to run.</param>
+        internal static void Enqueue(Task task)
+        {
+            if(!_running)
+            {
+                Start();
+            }
+
+            lock(_queueSync)
+            {
+                _queue.Enqueue(task);
+            }
+
+            _tasksAvailableSemaphore.Release();
+        }
+
+        /// <summary>
+        /// Add a set of jobs to the queue.
+        /// </summary>
+        /// <param name="tasks">The jobs to run.</param>
+        internal static void Enqueue(IList<Task> tasks)
+        {
+            if(!_running)
+            {
+                Start();
+            }
+
+            lock(_queueSync)
+            {
+                foreach(var task in tasks)
+                {
+                    _queue.Enqueue(task);
+                }
+            }
+
+            _tasksAvailableSemaphore.Release(tasks.Count);
+        }
+
+        /// <summary>
+        /// Worker Thread Program
+        /// </summary>
+        private static void WorkerThreadStart()
+        {
+            while (_running)
+            {
+                // Wait until a job is available, or we should shut down
+                _tasksAvailableSemaphore.WaitOne();
+
+                // Check whether we should shut down
+                if(!_running)
+                {
+                    _tasksAvailableSemaphore.Release();
+                    break;
+                }
+
+                // Get the job...
+                Task task = null;
+                lock (_queueSync)
+                {
+                    if(_queue.Count > 0)
+                    {
+                        task = _queue.Dequeue();
+                    }
+                }
+
+                // ...and run it
+                if (task != null)
+                {
+                    task.Compute();
+                    task.Set();
+                }
+            }
+        }
+
+        internal static void Start(int numberOfThreads)
+        {
+            lock (_stateSync)
+            {
+                if (_threads != null)
+                {
+                    if (_threads.Length == numberOfThreads)
+                    {
+                        return;
+                    }
+
+                    Shutdown();
+                }
+
+                ThreadCount = numberOfThreads;
+                Start();
+            }
+        }
+
+        internal static void Start()
+        {
+            lock (_stateSync)
+            {
+                if (_threads != null)
+                {
+                    return;
+                }
+
+                _tasksAvailableSemaphore = new Semaphore(_queue.Count, _maximumQueueLength);
+                _running = true;
+                _threads = new Thread[ThreadCount];
+
+                for (var i = 0; i < _threads.Length; i++)
+                {
+                    _threads[i] = new Thread(WorkerThreadStart)
+                                  {
+                                      IsBackground = true
+                                  };
+
+                    _threads[i].Start();
+                }
+            }
+        }
+
+        internal static void Shutdown()
+        {
+            lock (_stateSync)
+            {
+                if (_threads == null)
+                {
+                    return;
+                }
+
+                // try to stop the worker threads cleanly
+                _running = false;
+                _tasksAvailableSemaphore.Release();
+
+                // wait until all threads have stopped
+                foreach (var thread in _threads)
+                {
+                    thread.Join();
+                }
+
+                _tasksAvailableSemaphore.Close();
+                _tasksAvailableSemaphore = null;
+                _threads = null;
+            }
+        }
+    }
+}

src/Native.UnitTests/Native.UnitTests.csproj

@@ -92,6 +92,9 @@
     <Compile Include="..\Managed.UnitTests\SpecialFunctionsTest\ErfTests.cs">
       <Link>SpecialFunctionsTest\ErfTests.cs</Link>
     </Compile>
+    <Compile Include="..\Managed.UnitTests\ThreadingTests\ParallelTest.cs">
+      <Link>ThreadingTests\ParallelTest.cs</Link>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

src/Native/Native.csproj

@@ -137,6 +137,18 @@
     <Compile Include="..\Managed\SpecialFunctions\Erf.cs">
       <Link>SpecialFunctions\Erf.cs</Link>
     </Compile>
+    <Compile Include="..\Managed\Threading\AggregateException.cs">
+      <Link>Threading\AggregateException.cs</Link>
+    </Compile>
+    <Compile Include="..\Managed\Threading\Parallel.cs">
+      <Link>Threading\Parallel.cs</Link>
+    </Compile>
+    <Compile Include="..\Managed\Threading\Task.cs">
+      <Link>Threading\Task.cs</Link>
+    </Compile>
+    <Compile Include="..\Managed\Threading\ThreadQueue.cs">
+      <Link>Threading\ThreadQueue.cs</Link>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>