public ExecutionSlot( IAllocationDefinition definition )
{
if( definition == null )
throw new NullReferenceException( "Definition cannot be null" );
_Plugins = new List<IPlugin>();
_Definition = definition;
_ParallelPluginRunner = new ParallelQueue( definition.MaxSlots, true );
}
/// <summary>
/// Implements Provider-Consumer pattern.
/// </summary>
/// <typeparam name="TSource">Type of source value</typeparam>
/// <typeparam name="TTarget">Type of target value</typeparam>
/// <param name="source">Incoming data.</param>
/// <param name="providerCount">Number of provider threads.</param>
/// <param name="providerFunc">Provider function</param>
/// <param name="consumerCount">Number of consumer threads.</param>
/// <param name="consumerAction">Consumer action.</param>
/// <param name="processName">Process name pattern.</param>
public static void RunInParallel <TSource, TTarget>([NotNull, InstantHandle] this IEnumerable <TSource> source, Int32 providerCount,
[NotNull, InstantHandle] Func <TSource, TTarget> providerFunc, Int32 consumerCount,
[NotNull, InstantHandle] Action <TTarget> consumerAction, String processName = DefaultProcessName)
{
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
if (providerFunc is null)
{
throw new ArgumentNullException(nameof(providerFunc));
}
if (consumerAction is null)
{
throw new ArgumentNullException(nameof(consumerAction));
}
using ParallelQueue providerQueue = new ParallelQueue(providerCount, processName + "_provider_");
using ParallelQueue consumerQueue = new ParallelQueue(consumerCount, processName + "_consumer_");
foreach (TSource item in source)
{
TSource pItem = item;
providerQueue.EnqueueItem(() =>
{
TTarget data = providerFunc(pItem);
// ReSharper disable once AccessToDisposedClosure
consumerQueue.EnqueueItem(() => consumerAction(data));
});
}
providerQueue.WaitAll();
consumerQueue.WaitAll();
}
private void Enqueue(WorkItem work)
{
log.Debug("Enqueuing {0}", work.Test.Name);
if (work.IsParallelizable)
{
if (work.TargetApartment == ApartmentState.STA)
{
ParallelSTAQueue.Enqueue(work);
}
else
{
ParallelQueue.Enqueue(work);
}
}
else if (work.TargetApartment == ApartmentState.STA)
{
NonParallelSTAQueue.Enqueue(work);
}
else
{
NonParallelQueue.Enqueue(work);
}
}
private void Dispatch(WorkItem work, ExecutionStrategy strategy)
{
log.Debug("Using {0} strategy for {1}", strategy, work.Name);
switch (strategy)
{
default:
case ExecutionStrategy.Direct:
work.Execute();
break;
case ExecutionStrategy.Parallel:
if (work.TargetApartment == ApartmentState.STA)
{
ParallelSTAQueue.Enqueue(work);
}
else
{
ParallelQueue.Enqueue(work);
}
break;
case ExecutionStrategy.NonParallel:
if (work.TargetApartment == ApartmentState.STA)
{
NonParallelSTAQueue.Enqueue(work);
}
else
{
NonParallelQueue.Enqueue(work);
}
break;
}
Interlocked.Increment(ref _itemsDispatched);
}
protected override async void ReceiveCallback(IAsyncResult result)
{
var state = (ClientMetadata)result.AsyncState;
state.MreTimeout.Set();
try
{
// Listener has already been disposed of.
if (state.Listener == null)
{
Log("Unable to receive data from client, client has been disposed.");
return;
}
if (!IsConnected(state.Id))
{
Log("Can't read a message from a disconnected client. Client: " + state.Id + " and guid: " + state.Guid + ".");
RaiseClientDisconnected(state);
return;
}
var receive = state.Listener.EndReceive(result, out var soError);
if (soError != SocketError.Success)
{
throw new SocketException((int)soError);
}
if (receive > 0)
{
if (state.UnhandledBytes != null && state.UnhandledBytes.Length > 0)
{
receive += state.UnhandledBytes.Length;
state.UnhandledBytes = null;
}
//Does header check
if (state.Flag == 0)
{
if (state.SimpleMessage == null)
{
state.SimpleMessage = new SimpleMessage(state, this, Debug);
}
await ParallelQueue.Enqueue(() => state.SimpleMessage.ReadBytesAndBuildMessage(receive));
}
else if (receive > 0)
{
await ParallelQueue.Enqueue(() => state.SimpleMessage.ReadBytesAndBuildMessage(receive));
}
}
Log("Received " + receive + "bytes from client with id: " + state.Id + " and guid:" + state.Guid);
state.MreReceiving.Set();
}
catch (SocketException se)
{
state.Reset();
RaiseErrorThrown(se);
Log("Client with id: " + state.Id + " and guid:" + state.Guid + " has thrown a socketerror.");
Log(se);
}
catch (Exception ex)
{
state.Reset();
RaiseErrorThrown(ex);
Log("Error handling message from client with guid : " + state.Guid + ".");
Log(ex);
}
}
public RpcClientBatchManager(int batchCount, int idleMs)
{
_queue = new ParallelQueue <KeyWrapper <ServerUri, RpcConnection>, RpcBatchClientTransaction>(
"RpcBatchClientMamager", batchCount, idleMs, BatchDequeueProc);
}
