public void ForExecution(int from, int to, int step, Action action, ExecutionConstancyEnum executionConstancy)
{
if (executionConstancy == ExecutionConstancyEnum.Constant)
{
ForExecution(from, to, step, action);
}
else
{
ParallelQueue <ForPart>[] parallelQueues = new ParallelQueue <ForPart> [processorCount];
chunk = (to - from) / processorCount;
int start = from;
int end = chunk;
for (int i = 1; i <= processorCount; i++)
{
int x = i - 1;
waitHandles[x] = new ManualResetEvent(false);
ParallelQueueFiller parallelQueueFiller = new ParallelQueueFiller();
ParallelQueue <ForPart> parallelQueue = parallelQueueFiller.FillWithForPart(start, end, step, action);
parallelQueues[x] = parallelQueue;
UnconstantForSynchronisationContainer unconstantForSynchronisationContainer =
new UnconstantForSynchronisationContainer((ManualResetEvent)waitHandles[x], parallelQueue, parallelQueues);
ThreadPool.QueueUserWorkItem(
delegate(object state)
{
UnconstantForSynchronisationContainer localUnconstantForSynchronisationContainer =
(UnconstantForSynchronisationContainer)state;
ParallelQueue <ForPart> localparallelQueue = localUnconstantForSynchronisationContainer.ParallelQueue;
ParallelQueue <ForPart>[] localparallelQueues = localUnconstantForSynchronisationContainer.ParallelQueues;
try
{
bool localQueueIsEmpty = false;
while (!localQueueIsEmpty)
{
ForPart forPart = localparallelQueue.Dequeue();
if (forPart != null)
{
int ii = forPart.From;
forPart.ExecutionPart.Invoke(ref ii);
}
else
{
localQueueIsEmpty = true;
}
}
foreach (ParallelQueue <ForPart> localForegnParallelQueue in localparallelQueues)
{
if (localForegnParallelQueue != localparallelQueue)
{
bool localForegnQueueIsEmpty = false;
while (!localForegnQueueIsEmpty)
{
ForPart forPart = localForegnParallelQueue.Steal();
if (forPart != null)
{
int ii = forPart.From;
forPart.ExecutionPart.Invoke(ref ii);
}
else
{
localForegnQueueIsEmpty = true;
}
}
}
}
}
finally
{
localUnconstantForSynchronisationContainer.ManualResetEvent_.Set();
}
}, unconstantForSynchronisationContainer);
start = end + 1;
end = end + chunk;
}
WaitHandle.WaitAll(waitHandles);
}
}
public void InvokeExecution(ExecutionConstancyEnum executionConstancy, InvokeAction[] actions)
{
if (executionConstancy == ExecutionConstancyEnum.Constant)
{
InvokeExecution(actions);
}
else
{
ParallelQueue <InvokePart>[] parallelQueues = new ParallelQueue <InvokePart> [processorCount];
chunk = (actions.Length) / processorCount;
int start = 0;
int end = chunk;
for (int i = 1; i <= processorCount; i++)
{
int x = i - 1;
waitHandles[x] = new ManualResetEvent(false);
ParallelQueueFiller parallelQueueFiller = new ParallelQueueFiller();
List <InvokeAction> perProcessorInvokeActions = new List <InvokeAction>();
for (int j = start; j <= end; j++)
{
perProcessorInvokeActions.Add(actions[j]);
}
ParallelQueue <InvokePart> parallelQueue = parallelQueueFiller.FillWithInvoke(perProcessorInvokeActions.ToArray());
parallelQueues[x] = parallelQueue;
UnconstantInvokeSynchronisationContainer unconstantInvokeSynchronisationContainer =
new UnconstantInvokeSynchronisationContainer((ManualResetEvent)waitHandles[x], parallelQueue, parallelQueues);
ThreadPool.QueueUserWorkItem(
delegate(object state)
{
UnconstantInvokeSynchronisationContainer localUnconstantInvokeSynchronisationContainer =
(UnconstantInvokeSynchronisationContainer)state;
ParallelQueue <InvokePart> localparallelQueue = localUnconstantInvokeSynchronisationContainer.ParallelQueue;
ParallelQueue <InvokePart>[] localparallelQueues = localUnconstantInvokeSynchronisationContainer.ParallelQueues;
try
{
bool localQueueIsEmpty = false;
while (!localQueueIsEmpty)
{
InvokePart invokePart = localparallelQueue.Dequeue();
if (invokePart != null)
{
foreach (InvokeAction localInvokeAction in invokePart.InvokationParts)
{
localInvokeAction.Invoke();
}
}
else
{
localQueueIsEmpty = true;
}
}
foreach (ParallelQueue <InvokePart> localForegnParallelQueue in localparallelQueues)
{
if (localForegnParallelQueue != localparallelQueue)
{
bool localForegnQueueIsEmpty = false;
while (!localForegnQueueIsEmpty)
{
InvokePart invokePart = localForegnParallelQueue.Steal();
if (invokePart != null)
{
foreach (InvokeAction localInvokeAction in invokePart.InvokationParts)
{
localInvokeAction.Invoke();
}
}
else
{
localForegnQueueIsEmpty = true;
}
}
}
}
}
finally
{
localUnconstantInvokeSynchronisationContainer.ManualResetEvent_.Set();
}
}, unconstantInvokeSynchronisationContainer);
start = end + 1;
end = end + chunk;
}
WaitHandle.WaitAll(waitHandles);
}
}
public void ForeachExecution(IEnumerable <T> source, Action <T> action, ExecutionConstancyEnum executionConstancy)
{
if (executionConstancy == ExecutionConstancyEnum.Constant)
{
ForeachExecution(source, action);
}
else
{
ParallelQueue <ForeachPart <T> >[] parallelQueues = new ParallelQueue <ForeachPart <T> > [processorCount];
int counter = 0;
while (source.GetEnumerator().MoveNext())
{
counter++;
}
chunk = counter / processorCount;
int start = 0;
int end = chunk;
for (int i = 1; i <= processorCount; i++)
{
int x = i - 1;
waitHandles[x] = new ManualResetEvent(false);
ParallelQueueFiller parallelQueueFiller = new ParallelQueueFiller();
ParallelQueue <ForeachPart <T> > parallelQueue = parallelQueueFiller.FillWithForeachPart <T>(start, end, action, source);
parallelQueues[x] = parallelQueue;
UnconstantForeachSynchronisationContainer <T> unconstantForeachSynchronisationContainer =
new UnconstantForeachSynchronisationContainer <T>((ManualResetEvent)waitHandles[x], parallelQueue, parallelQueues);
ThreadPool.QueueUserWorkItem(
delegate(object state)
{
UnconstantForeachSynchronisationContainer <T> localUnconstantForeachSynchronisationContainer =
(UnconstantForeachSynchronisationContainer <T>)state;
ParallelQueue <ForeachPart <T> > localparallelQueue = localUnconstantForeachSynchronisationContainer.ParallelQueue;
ParallelQueue <ForeachPart <T> >[] localparallelQueues = localUnconstantForeachSynchronisationContainer.ParallelQueues;
try
{
bool localQueueIsEmpty = false;
while (!localQueueIsEmpty)
{
ForeachPart <T> foreachPart = localparallelQueue.Dequeue();
if (foreachPart != null)
{
int ii = foreachPart.Start;
foreachPart.ExecutionPart.Invoke(ref ii, foreachPart.SingleSource);
}
else
{
localQueueIsEmpty = true;
}
}
foreach (ParallelQueue <ForeachPart <T> > localForegnParallelQueue in localparallelQueues)
{
if (localForegnParallelQueue != localparallelQueue)
{
bool localForegnQueueIsEmpty = false;
while (!localForegnQueueIsEmpty)
{
ForeachPart <T> foreachPart = localForegnParallelQueue.Steal();
if (foreachPart != null)
{
int ii = foreachPart.Start;
foreachPart.ExecutionPart.Invoke(ref ii, foreachPart.SingleSource);
}
else
{
localForegnQueueIsEmpty = true;
}
}
}
}
}
finally
{
localUnconstantForeachSynchronisationContainer.ManualResetEvent_.Set();
}
}, unconstantForeachSynchronisationContainer);
start = end + 1;
end = end + chunk;
}
WaitHandle.WaitAll(waitHandles);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="executionConstancy"></param>
/// <param name="actions"></param>
public static void Invoke <T>(T value, ExecutionConstancyEnum executionConstancy, params InvokeAction <T>[] actions)
{
Invoke invoke = new Invoke();
invoke.InvokeExecution <T>(value, executionConstancy, actions);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <param name="value1"></param>
/// <param name="value2"></param>
/// <param name="executionConstancy"></param>
/// <param name="actions"></param>
public static void Invoke <T1, T2>(T1 value1, T2 value2, ExecutionConstancyEnum executionConstancy, params InvokeAction <T1, T2>[] actions)
{
Invoke invoke = new Invoke();
invoke.InvokeExecution <T1, T2>(value1, value2, executionConstancy, actions);
}
/// <summary>
/// Eine foreach Schleife wird parallel auf mehreren Kernen ausgeührt.
/// </summary>
/// <typeparam name="T">Type der Collectionelemente über die iteriert wird.</typeparam>
/// <param name="source">Die Collection über die iteriert wird.</param>
/// <param name="action">Welcher Schleifenkörper soll ausgeführt werden. </param>
/// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
public static void Foreach <T>(IEnumerable <T> source, Action <T> action, ExecutionConstancyEnum executionConstancy)
{
Foreach <T> foreachExecution = new Foreach <T>();
foreachExecution.ForeachExecution(source, action, executionConstancy);
}
/// <summary>
/// Eine foreach Schleife wird parallel auf mehreren Kernen ausgeührt.
/// </summary>
/// <typeparam name="T">Type der Collectionelemente über die iteriert wird.</typeparam>
/// <typeparam name="T1">Type des ersten value Elements.</typeparam>
/// <typeparam name="T2">Type des zweiten value Elements.</typeparam>
/// <param name="source">Die Collection über die iteriert wird.</param>
/// <param name="action">Der Schleifenkörper der ausgeführt wird.</param>
/// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
/// <param name="value1">erstes value Element dass an den Schleifenkörper mitgegeben wird.</param>
/// <param name="value2">zweites value Element dass an den Schleifenkörper mitgegeben wird.</param>
public static void Foreach <T, T1, T2>(IEnumerable <T> source, Action <T, T1, T2> action, ExecutionConstancyEnum executionConstancy, T1 value1, T2 value2)
{
Foreach <T> foreachExecution = new Foreach <T>();
foreachExecution.ForeachExecution <T1, T2>(source, action, executionConstancy, value1, value2);
}
/// <summary>
/// Eine for Schleife wird parallel auf mehreren Kernen ausgeführt.
/// </summary>
/// <typeparam name="T1">Type des ersten value Elements.</typeparam>
/// <typeparam name="T2">Type des zweiten value Elements.</typeparam>
/// <param name="from">von welchem Wert an soll die Schleife laufen</param>
/// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
/// <param name="step">um wieviel soll die Schleifenvaribale bei jedem Durchlauf erhöht werden</param>
/// <param name="action">Der Schleifenkörper der ausgeführt wird.
/// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
/// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
/// <param name="value1">erster mitübergebener wert</param>
/// <param name="value2">zweiter mitübergebener wert</param>
public static void For <T1, T2>(int from, int to, int step, Action <T1, T2> action, ExecutionConstancyEnum executionConstancy, T1 value1, T2 value2)
{
For forExecution = new For();
forExecution.ForExecution <T1, T2>(from, to, step, action, executionConstancy, value1, value2);
}
/// <summary>
/// Eine for schleife wird parallel auf mehreren Kernen ausgeführt.
/// </summary>
/// <param name="from">von welchem Wert an soll die Schleife laufen</param>
/// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
/// <param name="step">um wieviel soll die Schleifenvaribale bei jedem Durchlauf erhöht werden</param>
/// <param name="action">Der Schleifenkörper der ausgeführt wird.
/// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
/// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
public static void For(int from, int to, int step, Action action, ExecutionConstancyEnum executionConstancy)
{
For forExecution = new For();
forExecution.ForExecution(from, to, step, action, executionConstancy);
}
/// <summary>
///
/// </summary>
/// <param name="executionConstancy"></param>
/// <param name="actions"></param>
public static void Invoke(ExecutionConstancyEnum executionConstancy, params InvokeAction[] actions)
{
Invoke invoke = new Invoke();
invoke.InvokeExecution(executionConstancy, actions);
}
/// <summary>
/// Eine for schleife wird parallel auf mehreren Kernen ausgeführt.
/// </summary>
/// <typeparam name="T">Type des value Elements.</typeparam>
/// <param name="from">von welchem Wert an soll die Schleife laufen</param>
/// <param name="to">bis zu welchen Wert soll die for Schleife laufen</param>
/// <param name="action">Der Schleifenkörper der ausgeführt wird.
/// (mit dem übergebenen Wert kann auf die Schleifenvariable zugegriffen werden)</param>
/// <param name="executionConstancy">worksteeling verwenden (Nonconstant)</param>
/// <param name="value">value Element dass an den Schleifenkörper mitgegeben wird.</param>
public static void For <T>(int from, int to, Action <T> action, ExecutionConstancyEnum executionConstancy, T value)
{
For forExecution = new For();
forExecution.ForExecution <T>(from, to, 1, action, executionConstancy, value);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <param name="value1"></param>
/// <param name="value2"></param>
/// <param name="value3"></param>
/// <param name="executionConstancy"></param>
/// <param name="actions"></param>
public static void Invoke <T1, T2, T3>(T1 value1, T2 value2, T3 value3, ExecutionConstancyEnum executionConstancy, params InvokeAction <T1, T2, T3>[] actions)
{
//Invoke<T1, T2, T3> invoke = new Invoke<T1, T2, T3>();
//invoke.InvokeExecution(actions);
}
