internal ParallelQueue <InvokePart> FillWithInvoke(InvokeAction[] actions)
{
ParallelQueue <InvokePart> parallelQueue = new ParallelQueue <InvokePart>();
foreach (InvokeAction invokeAction in actions)
{
InvokePart invokePart = new InvokePart();
invokePart.InvokationParts.Add(invokeAction);
parallelQueue.Enqueue(invokePart);
}
return(parallelQueue);
}
internal ParallelQueue <InvokePart <T> > FillWithInvoke <T>(InvokeAction <T>[] actions, T value)
{
ParallelQueue <InvokePart <T> > parallelQueue = new ParallelQueue <InvokePart <T> >();
foreach (InvokeAction <T> invokeAction in actions)
{
InvokePart <T> invokePart = new InvokePart <T>();
invokePart.InvokationParts.Add(invokeAction);
invokePart.Value = value;
parallelQueue.Enqueue(invokePart);
}
return(parallelQueue);
}
internal ParallelQueue <InvokePart <T1, T2> > FillWithInvoke <T1, T2>(InvokeAction <T1, T2>[] actions, T1 value1, T2 value2)
{
ParallelQueue <InvokePart <T1, T2> > parallelQueue = new ParallelQueue <InvokePart <T1, T2> >();
foreach (InvokeAction <T1, T2> invokeAction in actions)
{
InvokePart <T1, T2> invokePart = new InvokePart <T1, T2>();
invokePart.InvokationParts.Add(invokeAction);
invokePart.Value1 = value1;
invokePart.Value2 = value2;
parallelQueue.Enqueue(invokePart);
}
return(parallelQueue);
}
public void InvokeExecution <T1, T2>(T1 value1, T2 value2, params InvokeAction <T1, T2>[] actions)
{
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);
InvokePart <T1, T2> invokePart = new InvokePart <T1, T2>();
invokePart.Value1 = value1;
invokePart.Value2 = value2;
for (int j = start; j <= end; j++)
{
invokePart.InvokationParts.Add(actions[j]);
}
ConstantInvokeSynchronisationContainer <T1, T2> invokeSynchronisationContainer =
new ConstantInvokeSynchronisationContainer <T1, T2>((ManualResetEvent)waitHandles[x], invokePart);
ThreadPool.QueueUserWorkItem(
delegate(object state)
{
ConstantInvokeSynchronisationContainer <T1, T2> localinvokeSynchronisationContainer = (ConstantInvokeSynchronisationContainer <T1, T2>)state;
InvokePart <T1, T2> localInvokePart = localinvokeSynchronisationContainer.InvokePart_;
try
{
foreach (InvokeAction <T1, T2> invokeAction in localInvokePart.InvokationParts)
{
invokeAction.Invoke(localInvokePart.Value1, localInvokePart.Value2);
}
}
finally
{
localinvokeSynchronisationContainer.ManualResetEvent_.Set();
}
}, invokeSynchronisationContainer);
start = end + 1;
end = end + chunk;
}
WaitHandle.WaitAll(waitHandles);
}
public ConstantInvokeSynchronisationContainer(ManualResetEvent manualResetEvent, InvokePart invokePart_)
: base(manualResetEvent)
{
this.invokePart_ = invokePart_;
}
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);
}
}
