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); }