Marcus Cuda
17 years ago
23 changed files with 1471 additions and 3075 deletions
File diff suppressed because it is too large
@ -1,69 +0,0 @@ |
|||
// <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>
|
|||
#if !SILVERLIGHT
|
|||
[Serializable] |
|||
#endif
|
|||
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); } |
|||
} |
|||
} |
|||
} |
|||
@ -1,485 +0,0 @@ |
|||
// <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 Properties; |
|||
|
|||
/// <summary>
|
|||
/// Provides support for parallel loops.
|
|||
/// </summary>
|
|||
internal static class Parallel |
|||
{ |
|||
/// <summary>
|
|||
/// The amount to scale the foreach buffer after each iteration.
|
|||
/// </summary>
|
|||
private const int ScalingFactor = 2; |
|||
|
|||
/// <summary>
|
|||
/// The maximum size of the foreach buffer.
|
|||
/// </summary>
|
|||
private const int MaxBlockSize = 65536; |
|||
|
|||
/// <summary>
|
|||
/// The initial size of the for each buffer.
|
|||
/// </summary>
|
|||
private const int IntialBlockSize = 1024; |
|||
|
|||
/// <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>
|
|||
public static void For(int fromInclusive, int toExclusive, Action<int> body) |
|||
{ |
|||
if (body == null) |
|||
{ |
|||
throw new ArgumentNullException("body"); |
|||
} |
|||
|
|||
// fast forward execution if it's only one or none items
|
|||
var count = toExclusive - fromInclusive; |
|||
if (count <= 1) |
|||
{ |
|||
if (count == 1) |
|||
{ |
|||
body(fromInclusive); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
// fast forward execution in case parallelization is disabled
|
|||
if (Control.DisableParallelization |
|||
|| ThreadQueue.ThreadCount <= 1 |
|||
|| ThreadQueue.IsInWorkerThread) |
|||
{ |
|||
for (int i = fromInclusive; i < toExclusive; i++) |
|||
{ |
|||
body(i); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
var actions = new Action[ThreadQueue.ThreadCount]; |
|||
var size = count / actions.Length; |
|||
|
|||
// 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 (int j = start; j < stop; j++) |
|||
{ |
|||
body(j); |
|||
} |
|||
}; |
|||
} |
|||
|
|||
// add another set for last worker thread
|
|||
actions[actions.Length - 1] = |
|||
() => |
|||
{ |
|||
for (int i = fromInclusive + ((actions.Length - 1) * size); i < toExclusive; i++) |
|||
{ |
|||
body(i); |
|||
} |
|||
}; |
|||
|
|||
Invoke(actions); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Executes a for loop in which iterations may run in parallel.
|
|||
/// </summary>
|
|||
/// <typeparam name="T">The type of the thread-local data.</typeparam>
|
|||
/// <param name="fromInclusive">The start index, inclusive.</param>
|
|||
/// <param name="toExclusive">The end index, exclusive.</param>
|
|||
/// <param name="localInit">The function delegate that returns the initial state of the local data for each thread.</param>
|
|||
/// <param name="body">The delegate that is invoked once per iteration.</param>
|
|||
/// <param name="localFinally">The delegate that performs a final action on the local state of each thread.</param>
|
|||
public static void For<T>(int fromInclusive, int toExclusive, Func<T> localInit, Func<int, T, T> body, Action<T> localFinally) |
|||
{ |
|||
var count = toExclusive - fromInclusive; |
|||
var tasks = new Task<T>[ThreadQueue.ThreadCount]; |
|||
var size = count / tasks.Length; |
|||
|
|||
// fast forward execution if it's only one or none items
|
|||
if (count <= 1) |
|||
{ |
|||
if (count == 1) |
|||
{ |
|||
localFinally(body(fromInclusive, localInit())); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
// fast forward execution in case parallelization is disabled
|
|||
if (Control.DisableParallelization |
|||
|| ThreadQueue.ThreadCount <= 1 |
|||
|| ThreadQueue.IsInWorkerThread) |
|||
{ |
|||
var localresult = localInit(); |
|||
for (var i = fromInclusive; i < toExclusive; i++) |
|||
{ |
|||
localresult = body(i, localresult); |
|||
} |
|||
|
|||
localFinally(localresult); |
|||
return; |
|||
} |
|||
|
|||
// partition the jobs into separate sets for each but the last worked thread
|
|||
for (var i = 0; i < tasks.Length - 1; i++) |
|||
{ |
|||
var start = fromInclusive + (i * size); |
|||
var stop = fromInclusive + ((i + 1) * size); |
|||
tasks[i] = new Task<T>( |
|||
localData => |
|||
{ |
|||
var localresult = (T)localData; |
|||
for (var j = start; j < stop; j++) |
|||
{ |
|||
localresult = body(j, localresult); |
|||
} |
|||
|
|||
return localresult; |
|||
}, |
|||
localInit()); |
|||
ThreadQueue.Enqueue(tasks[i]); |
|||
} |
|||
|
|||
// add another set for last worker thread
|
|||
tasks[tasks.Length - 1] = new Task<T>( |
|||
localData => |
|||
{ |
|||
var localresult = (T)localData; |
|||
for (var i = fromInclusive + ((tasks.Length - 1) * size); i < toExclusive; i++) |
|||
{ |
|||
localresult = body(i, localresult); |
|||
} |
|||
|
|||
return localresult; |
|||
}, |
|||
localInit()); |
|||
|
|||
ThreadQueue.Enqueue(tasks[tasks.Length - 1]); |
|||
if (tasks.Length <= 0) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
WaitForTasksToComplete(tasks); |
|||
|
|||
foreach (var t in tasks) |
|||
{ |
|||
localFinally(t.Result); |
|||
} |
|||
|
|||
CollectExceptions(tasks); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Executes a for each operation on an IEnumerable{T} in which iterations may run in parallel.
|
|||
/// </summary>
|
|||
/// <typeparam name="T">The type of the data in the source.</typeparam>
|
|||
/// <param name="source">An enumerable data source.</param>
|
|||
/// <param name="body">The delegate that is invoked once per iteration.</param>
|
|||
public static void ForEach<T>(IEnumerable<T> source, Action<T> body) |
|||
{ |
|||
if (body == null) |
|||
{ |
|||
throw new ArgumentNullException("body"); |
|||
} |
|||
|
|||
// fast forward execution in case parallelization is disabled
|
|||
if (Control.DisableParallelization |
|||
|| ThreadQueue.ThreadCount <= 1 |
|||
|| ThreadQueue.IsInWorkerThread) |
|||
{ |
|||
foreach (var item in source) |
|||
{ |
|||
body(item); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
// source is a IList, call For instead.
|
|||
if (source is IList<T>) |
|||
{ |
|||
var list = (IList<T>)source; |
|||
For(0, list.Count, i => body(list[i])); |
|||
return; |
|||
} |
|||
|
|||
var maxBlockSize = IntialBlockSize; |
|||
var tasks = new List<Task>(); |
|||
|
|||
var enumerator = source.GetEnumerator(); |
|||
while (enumerator.MoveNext()) |
|||
{ |
|||
var pos = 0; |
|||
var list = new T[maxBlockSize]; |
|||
list[pos++] = enumerator.Current; |
|||
|
|||
var count = 1; |
|||
while (count < maxBlockSize && enumerator.MoveNext()) |
|||
{ |
|||
list[pos++] = enumerator.Current; |
|||
count++; |
|||
} |
|||
|
|||
var task = new Task( |
|||
() => |
|||
{ |
|||
for (var i = 0; i < pos; i++) |
|||
{ |
|||
body(list[i]); |
|||
} |
|||
}); |
|||
|
|||
ThreadQueue.Enqueue(task); |
|||
tasks.Add(task); |
|||
maxBlockSize = Math.Min(MaxBlockSize, maxBlockSize * ScalingFactor); |
|||
} |
|||
|
|||
if (tasks.Count > 0) |
|||
{ |
|||
WaitForTasksToComplete(tasks.ToArray()); |
|||
CollectExceptions(tasks); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Executes a for each operation on an IEnumerable{TSource in which iterations may run in parallel.
|
|||
/// </summary>
|
|||
/// <typeparam name="TSource">The type of the data in the source.</typeparam>
|
|||
/// <typeparam name="TLocal">The type of the thread-local data.</typeparam>
|
|||
/// <param name="source">An enumerable data source.</param>
|
|||
/// <param name="localInit">The function delegate that returns the initial state of the local data for each thread.</param>
|
|||
/// <param name="body">The delegate that is invoked once per iteration.</param>
|
|||
/// <param name="localFinally">The delegate that performs a final action on the local state of each thread.</param>
|
|||
public static void ForEach<TSource, TLocal>(IEnumerable<TSource> source, Func<TLocal> localInit, Func<TSource, TLocal, TLocal> body, Action<TLocal> localFinally) |
|||
{ |
|||
if (body == null) |
|||
{ |
|||
throw new ArgumentNullException("body"); |
|||
} |
|||
|
|||
// fast forward execution in case parallelization is disabled
|
|||
if (Control.DisableParallelization |
|||
|| ThreadQueue.ThreadCount <= 1 |
|||
|| ThreadQueue.IsInWorkerThread) |
|||
{ |
|||
var localResult = localInit(); |
|||
foreach (var item in source) |
|||
{ |
|||
localResult = body(item, localResult); |
|||
} |
|||
|
|||
localFinally(localResult); |
|||
return; |
|||
} |
|||
|
|||
// source is a IList, call For instead.
|
|||
if (source is IList<TSource>) |
|||
{ |
|||
var list = (IList<TSource>)source; |
|||
For(0, list.Count, localInit, (i, local) => body(list[i], local), localFinally); |
|||
return; |
|||
} |
|||
|
|||
var maxBlockSize = IntialBlockSize; |
|||
var tasks = new List<Task<TLocal>>(); |
|||
|
|||
var enumerator = source.GetEnumerator(); |
|||
while (enumerator.MoveNext()) |
|||
{ |
|||
var pos = 0; |
|||
var list = new TSource[maxBlockSize]; |
|||
list[pos++] = enumerator.Current; |
|||
|
|||
var count = 1; |
|||
while (count < maxBlockSize && enumerator.MoveNext()) |
|||
{ |
|||
list[pos++] = enumerator.Current; |
|||
count++; |
|||
} |
|||
|
|||
var task = new Task<TLocal>( |
|||
localData => |
|||
{ |
|||
var localresult = localData; |
|||
for (var i = 0; i < pos; i++) |
|||
{ |
|||
localresult = body(list[i], (TLocal)localresult); |
|||
} |
|||
|
|||
return (TLocal)localresult; |
|||
}, |
|||
localInit()); |
|||
|
|||
ThreadQueue.Enqueue(task); |
|||
tasks.Add(task); |
|||
maxBlockSize = Math.Min(MaxBlockSize, maxBlockSize * ScalingFactor); |
|||
} |
|||
|
|||
if (tasks.Count <= 0) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var taskArray = tasks.ToArray(); |
|||
WaitForTasksToComplete(taskArray); |
|||
|
|||
for (var i = 0; i < taskArray.Length; i++) |
|||
{ |
|||
localFinally(tasks[i].Result); |
|||
} |
|||
|
|||
CollectExceptions(taskArray); |
|||
} |
|||
|
|||
/// <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>
|
|||
public static void Run(params Action[] actions) |
|||
{ |
|||
if (actions == null) |
|||
{ |
|||
throw new ArgumentNullException("actions"); |
|||
} |
|||
|
|||
// fast forward execution if it's only one or none items
|
|||
if (actions.Length <= 1) |
|||
{ |
|||
if (actions.Length == 1) |
|||
{ |
|||
actions[0](); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
// fast forward execution in case parallelization is disabled
|
|||
if (Control.DisableParallelization |
|||
|| ThreadQueue.ThreadCount <= 1 |
|||
|| ThreadQueue.IsInWorkerThread) |
|||
{ |
|||
for (var i = 0; i < actions.Length; i++) |
|||
{ |
|||
actions[i](); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
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="ArgumentException">The actions array contains a null element.</exception>
|
|||
/// <exception cref="AggregateException">An action threw an exception.</exception>
|
|||
private static void Invoke(params Action[] actions) |
|||
{ |
|||
// create a job for each action
|
|||
var tasks = new Task[actions.Length]; |
|||
for (var 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); |
|||
|
|||
WaitForTasksToComplete(tasks); |
|||
|
|||
CollectExceptions(tasks); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Waits for tasks to complete.
|
|||
/// </summary>
|
|||
/// <param name="tasks">The tasks.</param>
|
|||
private static void WaitForTasksToComplete(Task[] tasks) |
|||
{ |
|||
foreach (var task in tasks) |
|||
{ |
|||
task.Wait(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Collects the exceptions and dispose tasks.
|
|||
/// </summary>
|
|||
/// <param name="tasks">The tasks.</param>
|
|||
private static void CollectExceptions(IEnumerable<Task> tasks) |
|||
{ |
|||
// collect all thrown exceptions and dispose the jobs
|
|||
var exceptions = new List<Exception>(); |
|||
foreach (var task in tasks) |
|||
{ |
|||
if (task.IsFaulted) |
|||
{ |
|||
exceptions.Add(task.Exception); |
|||
} |
|||
} |
|||
|
|||
// throw the aggregated exceptions, if any
|
|||
if (exceptions.Count > 0) |
|||
{ |
|||
throw new AggregateException(exceptions); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,127 +0,0 @@ |
|||
// <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 |
|||
{ |
|||
/// <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>
|
|||
public Task(Action body) |
|||
{ |
|||
if (body == null) |
|||
{ |
|||
throw new ArgumentNullException("body"); |
|||
} |
|||
|
|||
_body = body; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Task"/> class.
|
|||
/// </summary>
|
|||
protected Task() |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the task completed due to an unhandled exception.
|
|||
/// </summary>
|
|||
/// <value>
|
|||
/// <c>true</c> if this task completed due to an unhandled exception; otherwise, <c>false</c>.
|
|||
/// </value>
|
|||
public bool IsFaulted |
|||
{ |
|||
get { return Exception != null; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether this task has completed.
|
|||
/// </summary>
|
|||
/// <value>
|
|||
/// <c>true</c> if this task has completed; otherwise, <c>false</c>.
|
|||
/// </value>
|
|||
public bool IsCompleted |
|||
{ |
|||
get; private set; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the exception thrown by the task, if any.
|
|||
/// </summary>
|
|||
public Exception Exception { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Run the task.
|
|||
/// </summary>
|
|||
public void Compute() |
|||
{ |
|||
try |
|||
{ |
|||
DoCompute(); |
|||
IsCompleted = true; |
|||
} |
|||
catch (Exception e) |
|||
{ |
|||
Exception = e; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Runs the actual task.
|
|||
/// </summary>
|
|||
protected virtual void DoCompute() |
|||
{ |
|||
_body(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Waits for the task to complete execution.
|
|||
/// </summary>
|
|||
public void Wait() |
|||
{ |
|||
while (!IsCompleted && !IsFaulted) |
|||
{ |
|||
Thread.Sleep(0); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,79 +0,0 @@ |
|||
// <copyright file="TaskOfT.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; |
|||
|
|||
/// <summary>
|
|||
/// Internal Generic Parallel Task Handle.
|
|||
/// </summary>
|
|||
/// <typeparam name="TResult">The type of the result.</typeparam>
|
|||
internal class Task<TResult> : Task |
|||
{ |
|||
/// <summary>
|
|||
/// Delegate to the task's action.
|
|||
/// </summary>
|
|||
private readonly Func<object, TResult> _body; |
|||
|
|||
/// <summary>
|
|||
/// Variable used to hold state information between iterations.
|
|||
/// </summary>
|
|||
private readonly object _state; |
|||
|
|||
/// <summary>
|
|||
/// Gets the result of the task.
|
|||
/// </summary>
|
|||
/// <value>The result of the task.</value>
|
|||
public TResult Result { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the Task class.
|
|||
/// </summary>
|
|||
/// <param name="body">Delegate to the task's action.</param>
|
|||
/// <param name="state">An object representing data to be used by the action.</param>
|
|||
public Task(Func<object, TResult> body, object state) |
|||
{ |
|||
if (body == null) |
|||
{ |
|||
throw new ArgumentNullException("body"); |
|||
} |
|||
|
|||
_state = state; |
|||
_body = body; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Runs the actual task.
|
|||
/// </summary>
|
|||
protected override void DoCompute() |
|||
{ |
|||
Result = _body(_state); |
|||
} |
|||
} |
|||
} |
|||
@ -1,262 +0,0 @@ |
|||
// <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>
|
|||
/// 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>
|
|||
/// Gets the number of worker threads.
|
|||
/// </summary>
|
|||
internal static int ThreadCount { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Indicating whether the current thread is a parallelized worker thread.
|
|||
/// </summary>
|
|||
[ThreadStatic] |
|||
private static bool _isInWorkerThread; |
|||
|
|||
/// <summary>
|
|||
/// Initializes static members of the ThreadQueue class.
|
|||
/// </summary>
|
|||
static ThreadQueue() |
|||
{ |
|||
#if SILVERLIGHT
|
|||
Start(1); |
|||
#else
|
|||
Start(Environment.ProcessorCount); |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the current thread is a parallelized worker thread.
|
|||
/// </summary>
|
|||
public static bool IsInWorkerThread |
|||
{ |
|||
get { return _isInWorkerThread; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add a job to the queue.
|
|||
/// </summary>
|
|||
/// <param name="task">The job to run.</param>
|
|||
public static void Enqueue(Task task) |
|||
{ |
|||
if (!_running) |
|||
{ |
|||
Start(); |
|||
} |
|||
|
|||
lock (_queueSync) |
|||
{ |
|||
_queue.Enqueue(task); |
|||
Monitor.Pulse(_queueSync); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add a set of jobs to the queue.
|
|||
/// </summary>
|
|||
/// <param name="tasks">The jobs to run.</param>
|
|||
public static void Enqueue(IList<Task> tasks) |
|||
{ |
|||
if (!_running) |
|||
{ |
|||
Start(); |
|||
} |
|||
|
|||
lock (_queueSync) |
|||
{ |
|||
foreach (var task in tasks) |
|||
{ |
|||
_queue.Enqueue(task); |
|||
} |
|||
|
|||
Monitor.PulseAll(_queueSync); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Worker Thread Program
|
|||
/// </summary>
|
|||
private static void WorkerThreadStart() |
|||
{ |
|||
_isInWorkerThread = true; |
|||
|
|||
while (_running) |
|||
{ |
|||
// Get the job...
|
|||
Task task = null; |
|||
|
|||
lock (_queueSync) |
|||
{ |
|||
// Check whether we should shut down
|
|||
if (!_running) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (_queue.Count > 0) |
|||
{ |
|||
task = _queue.Dequeue(); |
|||
} |
|||
else |
|||
{ |
|||
Monitor.Wait(_queueSync); |
|||
} |
|||
} |
|||
|
|||
if (task == null) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
// ...and run it
|
|||
task.Compute(); |
|||
} |
|||
|
|||
_isInWorkerThread = false; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Start or restart the queue with the specified number of worker threads.
|
|||
/// </summary>
|
|||
/// <param name="numberOfThreads">Number of worker threads.</param>
|
|||
public static void Start(int numberOfThreads) |
|||
{ |
|||
lock (_stateSync) |
|||
{ |
|||
// instead of throwing an out of range exception, simply normalize
|
|||
numberOfThreads = Math.Max(1, Math.Min(1024, numberOfThreads)); |
|||
|
|||
if (_threads != null) |
|||
{ |
|||
if (_threads.Length == numberOfThreads) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
Shutdown(); |
|||
} |
|||
|
|||
ThreadCount = numberOfThreads; |
|||
Start(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Start the thread queue, if it is not already running.
|
|||
/// </summary>
|
|||
public static void Start() |
|||
{ |
|||
lock (_stateSync) |
|||
{ |
|||
if (_threads != null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
_running = true; |
|||
|
|||
_threads = new Thread[ThreadCount]; |
|||
|
|||
for (var i = 0; i < _threads.Length; i++) |
|||
{ |
|||
_threads[i] = new Thread(WorkerThreadStart) |
|||
{ |
|||
IsBackground = true |
|||
}; |
|||
|
|||
_threads[i].Start(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Stop the thread queue, if it is running.
|
|||
/// </summary>
|
|||
public static void Shutdown() |
|||
{ |
|||
// try to stop the worker threads cleanly
|
|||
lock (_stateSync) |
|||
{ |
|||
if (_threads == null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
_running = false; |
|||
|
|||
lock (_queueSync) |
|||
{ |
|||
Monitor.PulseAll(_queueSync); |
|||
} |
|||
|
|||
// wait until all threads have stopped
|
|||
foreach (var thread in _threads) |
|||
{ |
|||
thread.Join(); |
|||
} |
|||
|
|||
_threads = null; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,602 +0,0 @@ |
|||
// <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.Collections.Generic; |
|||
using System.Threading; |
|||
using MbUnit.Framework; |
|||
using Threading; |
|||
|
|||
[TestFixture] |
|||
public class ParallelForEachTests |
|||
{ |
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceMTAOnePerCore(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceSTAOnePerCore(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceMTATwoPerCore(int count) |
|||
{ |
|||
// ensure Two-Per-Core
|
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceSTATwoPerCore(int count) |
|||
{ |
|||
// ensure Two-Per-Core
|
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceMTAOnePerCore(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceSTAOnePerCore(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceMTATwoPerCore(int count) |
|||
{ |
|||
// ensure Two-Per-Core
|
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceSTATwoPerCore(int count) |
|||
{ |
|||
// ensure Two-Per-Core
|
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var items = new double[count]; |
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
Parallel.ForEach(pairs, pair => items[pair.Key] = pair.Value); |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
public void DoesNotGetConfusedByMultipleStartShutdown() |
|||
{ |
|||
ThreadQueue.Shutdown(); |
|||
ThreadQueue.Shutdown(); |
|||
|
|||
ThreadQueue.Start(2); |
|||
Assert.AreEqual(2, ThreadQueue.ThreadCount); |
|||
|
|||
Control.NumberOfParallelWorkerThreads = 2; |
|||
Assert.AreEqual(2, ThreadQueue.ThreadCount); |
|||
|
|||
ThreadQueue.Start(4); |
|||
Assert.AreEqual(4, ThreadQueue.ThreadCount); |
|||
Assert.AreEqual(4, Control.NumberOfParallelWorkerThreads); |
|||
|
|||
ThreadQueue.Shutdown(); |
|||
ThreadQueue.Start(); |
|||
Assert.AreEqual(4, ThreadQueue.ThreadCount); |
|||
|
|||
ThreadQueue.Start(2); |
|||
Assert.AreEqual(2, ThreadQueue.ThreadCount); |
|||
|
|||
var items = new double[50]; |
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
items[i] = i; |
|||
pairs.Add(new KeyValuePair<int, double>(i, i)); |
|||
} |
|||
|
|||
Parallel.ForEach(pairs, |
|||
pair => |
|||
{ |
|||
items[pair.Key] = pair.Value + 1000; |
|||
} |
|||
); |
|||
|
|||
for (int i = 0; i < items.Length; i++) |
|||
{ |
|||
Assert.AreEqual(1000 + i, items[i], i.ToString()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
public void DoesDetectAndResolveRecursiveParallelization() |
|||
{ |
|||
var countSharedBetweenClosures = 0; |
|||
var values = new int[10]; |
|||
|
|||
Assert.DoesNotThrow( |
|||
() => |
|||
Parallel.ForEach(values, |
|||
j => Interlocked.Increment(ref countSharedBetweenClosures))); |
|||
|
|||
Assert.AreEqual(10, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.ForEach(values, |
|||
i => |
|||
Parallel.ForEach(values, |
|||
j => Interlocked.Increment(ref countSharedBetweenClosures))); |
|||
|
|||
Assert.AreEqual(100, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.ForEach(values, |
|||
i => |
|||
Parallel.ForEach(values, |
|||
j => |
|||
Parallel.ForEach(values, |
|||
k => Interlocked.Increment(ref countSharedBetweenClosures)))); |
|||
|
|||
Assert.AreEqual(1000, countSharedBetweenClosures); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceMTAOnePerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceSTAOnePerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceMTATwoPerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInListOnceSTATwoPerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var pairs = new List<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceMTAOnePerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceSTAOnePerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceMTATwoPerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1001)] |
|||
public void ParallelForEachInvokesEveryItemInSetOnceSTATwoPerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var pairs = new HashSet<KeyValuePair<int, double>>(); |
|||
for (var i = 0; i < count; i++) |
|||
{ |
|||
pairs.Add(new KeyValuePair<int, double>(i, 2)); |
|||
} |
|||
|
|||
var sum = 0.0; |
|||
var sync = new object(); |
|||
|
|||
Parallel.ForEach( |
|||
pairs, () => 0.0, (pair, localData) => localData += pair.Value, |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, Timeout(15)] |
|||
public void DoesDetectAndResolveRecursiveParallelizationWithIntialAndFinally() |
|||
{ |
|||
var countSharedBetweenClosures = 0; |
|||
var values = new int[10]; |
|||
|
|||
Assert.DoesNotThrow( |
|||
() => |
|||
Parallel.ForEach(values, |
|||
j => Interlocked.Increment(ref countSharedBetweenClosures))); |
|||
|
|||
Assert.AreEqual(10, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.ForEach(values, |
|||
i => |
|||
Parallel.ForEach(values, |
|||
j => Interlocked.Increment(ref countSharedBetweenClosures))); |
|||
|
|||
Assert.AreEqual(100, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.ForEach(values, |
|||
i => |
|||
Parallel.ForEach(values, |
|||
j => |
|||
Parallel.ForEach(values, () => 0.0, |
|||
(iterator, localData) => Interlocked.Increment(ref countSharedBetweenClosures), |
|||
localResult => { return; } |
|||
))); |
|||
|
|||
Assert.AreEqual(1000, countSharedBetweenClosures); |
|||
} |
|||
} |
|||
} |
|||
@ -1,364 +0,0 @@ |
|||
// <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 ParallelForTests |
|||
{ |
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[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), Timeout(15)] |
|||
[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), Timeout(15)] |
|||
[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), Timeout(15)] |
|||
[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, MultipleAsserts, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
public void DoesNotGetConfusedByMultipleStartShutdown() |
|||
{ |
|||
ThreadQueue.Shutdown(); |
|||
ThreadQueue.Shutdown(); |
|||
|
|||
ThreadQueue.Start(2); |
|||
Assert.AreEqual(2, ThreadQueue.ThreadCount); |
|||
|
|||
Control.NumberOfParallelWorkerThreads = 2; |
|||
Assert.AreEqual(2, ThreadQueue.ThreadCount); |
|||
|
|||
ThreadQueue.Start(4); |
|||
Assert.AreEqual(4, ThreadQueue.ThreadCount); |
|||
Assert.AreEqual(4, Control.NumberOfParallelWorkerThreads); |
|||
|
|||
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()); |
|||
} |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
public void DoesDetectAndResolveRecursiveParallelization() |
|||
{ |
|||
int countSharedBetweenClosures = 0; |
|||
|
|||
Assert.DoesNotThrow( |
|||
() => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
j => Interlocked.Increment(ref countSharedBetweenClosures))); |
|||
|
|||
Assert.AreEqual(10, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
i => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
j => Interlocked.Increment(ref countSharedBetweenClosures))); |
|||
|
|||
Assert.AreEqual(100, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
i => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
j => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
k => Interlocked.Increment(ref countSharedBetweenClosures)))); |
|||
|
|||
Assert.AreEqual(1000, countSharedBetweenClosures); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)] |
|||
public void ParallelForInvokesEveryItemOnceMTAOnePerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
var items = new double[count]; |
|||
|
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var sum = 0.0; |
|||
for(var i = 0; i < items.Length; i++) |
|||
{ |
|||
items[i] = 2; |
|||
} |
|||
var sync = new object(); |
|||
Parallel.For( |
|||
0, |
|||
count, |
|||
() => 0.0, |
|||
(i, localData) =>localData += items[i], |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)] |
|||
public void ParallelForInvokesEveryItemOnceSTAOnePerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
var items = new double[count]; |
|||
|
|||
// ensure One-Per-Core
|
|||
ThreadQueue.Start(Environment.ProcessorCount); |
|||
|
|||
var sum = 0.0; |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
items[i] = 2; |
|||
} |
|||
var sync = new object(); |
|||
Parallel.For( |
|||
0, |
|||
count, |
|||
() => 0.0, |
|||
(i, localData) => localData += items[i], |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)] |
|||
public void ParallelForInvokesEveryItemOnceMTATwoPerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
var items = new double[count]; |
|||
|
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var sum = 0.0; |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
items[i] = 2; |
|||
} |
|||
var sync = new object(); |
|||
Parallel.For( |
|||
0, |
|||
count, |
|||
() => 0.0, |
|||
(i, localData) => localData += items[i], |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.STA), Timeout(15)] |
|||
[Column(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 101)] |
|||
public void ParallelForInvokesEveryItemOnceSTATwoPerCoreWithIntialAndFinally(int count) |
|||
{ |
|||
var items = new double[count]; |
|||
|
|||
ThreadQueue.Start(2 * Environment.ProcessorCount); |
|||
|
|||
var sum = 0.0; |
|||
for (var i = 0; i < items.Length; i++) |
|||
{ |
|||
items[i] = 2; |
|||
} |
|||
var sync = new object(); |
|||
Parallel.For( |
|||
0, |
|||
count, |
|||
() => 0.0, |
|||
(i, localData) => localData += items[i], |
|||
localResult => |
|||
{ |
|||
lock (sync) |
|||
{ |
|||
sum += localResult; |
|||
} |
|||
} |
|||
); |
|||
Assert.AreEqual(count * 2, sum); |
|||
} |
|||
|
|||
[Test, ApartmentState(ApartmentState.MTA), Timeout(15)] |
|||
public void DoesDetectAndResolveRecursiveParallelizationWithIntialAndFinally() |
|||
{ |
|||
int countSharedBetweenClosures = 0; |
|||
|
|||
Assert.DoesNotThrow( |
|||
() => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
() => 0.0, |
|||
(j, localData) => Interlocked.Increment(ref countSharedBetweenClosures), |
|||
localResult => { return; } |
|||
)); |
|||
|
|||
Assert.AreEqual(10, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
i => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
() => 0.0, |
|||
(j, localData) => Interlocked.Increment(ref countSharedBetweenClosures), |
|||
localResult => { return; } |
|||
)); |
|||
|
|||
Assert.AreEqual(100, countSharedBetweenClosures); |
|||
countSharedBetweenClosures = 0; |
|||
|
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
i => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
j => |
|||
Parallel.For( |
|||
0, |
|||
10, |
|||
() => 0.0, |
|||
(k, localData) => Interlocked.Increment(ref countSharedBetweenClosures), |
|||
localResult => { return; } |
|||
))); |
|||
|
|||
Assert.AreEqual(1000, countSharedBetweenClosures); |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue