public void CompletionTaskIsDoneWhenCompletedWith0ConcurrencyIsCalled(bool useChannelBasedImpl) { var actionBlock = ActionBlockSlim.Create <int>(0, n => { }, useChannelBasedImpl: useChannelBasedImpl); var task = actionBlock.CompletionAsync(); Assert.Equal(TaskStatus.RanToCompletion, task.Status); }
/// <summary> /// Construct a WorkerAnalyzer. /// </summary> public ConcurrentPipProcessor(PackedExecutionExporter exporter) { m_exporter = exporter; m_processingBlock = ActionBlockSlim.Create <ProcessFingerprintComputationEventData>( degreeOfParallelism: -1, // default processItemAction: ProcessFingerprintComputedCore); }
public async Task IncreaseConcurrency(bool useChannelBasedImpl) { int count = 0; var waitForFirstTwoItems = new TaskCompletionSource <object>(); // Event that will hold first two workers. var mre = new ManualResetEventSlim(false); var actionBlock = ActionBlockSlim.Create <int>( 2, n => { var currentCount = Interlocked.Increment(ref count); if (currentCount == 2) { // Notify the test that 2 items are processed. waitForFirstTwoItems.SetResult(null); } if (currentCount <= 2) { // This is the first or the second thread that should be blocked before we increase the number of threads. mre.Wait(TimeSpan.FromSeconds(100)); } Thread.Sleep(1); }, useChannelBasedImpl: useChannelBasedImpl); // Schedule work actionBlock.Post(1); actionBlock.Post(2); await waitForFirstTwoItems.Task; // The first 2 threads should be blocked in the callback in the action block, // but the count should be incremented Assert.Equal(2, count); var task = actionBlock.CompletionAsync(); // The task should not be completed yet! Assert.NotEqual(TaskStatus.RanToCompletion, task.Status); // This will cause another thread to spawn actionBlock.IncreaseConcurrencyTo(3); // Add more work actionBlock.Post(3); actionBlock.Complete(); // Release the first 2 threads mre.Set(); // Waiting for completion await task; // The new thread should run and increment the count Assert.Equal(3, count); }
public async Task CompletionTaskIsDoneWhenCompletedIsCalled(bool useChannelBasedImpl) { var actionBlock = ActionBlockSlim.Create <int>(42, n => { }, useChannelBasedImpl: useChannelBasedImpl); var task = actionBlock.CompletionAsync(); Assert.NotEqual(TaskStatus.RanToCompletion, task.Status); actionBlock.Complete(); await task; Assert.Equal(TaskStatus.RanToCompletion, task.Status); }
public FingerprintStoreEventProcessor(int degreeOfParallelism) { Contract.Requires(degreeOfParallelism > 0); // To ensure that events coming from the same pips are processed according to the order when they came, // we use N action blocks, all with degree of parallelism 1. Thus, we potentially get parallelism across // different pips, but maintain sequential processing within a single pip. // This is necessary in particular when the runtime cache miss analyzer is enabled because // we use cachelookup fingerprints to perform cache miss analyzer for strongfingerprint misses. m_actionBlocks = new ActionBlockSlim <Action> [degreeOfParallelism]; for (int i = 0; i < degreeOfParallelism; ++i) { // Initially we start each action block with a parallelism of 0 so they are in a paused state. // Processing is started once the RuntimeCacheMissAnalyzer is available via its initialization task completing. m_actionBlocks[i] = ActionBlockSlim.Create <Action>(0, a => a()); } }
public async Task AllTheElementsAreFinished(bool useChannelBasedImpl) { int count = 0; var actionBlock = ActionBlockSlim.Create <int>( 42, n => { Interlocked.Increment(ref count); Thread.Sleep(1); }, useChannelBasedImpl: useChannelBasedImpl); var task = actionBlock.CompletionAsync(); actionBlock.Post(1); actionBlock.Post(2); actionBlock.Complete(); await task; Assert.Equal(2, count); }
public async Task AllTheElementsAreProcessedBy2Thread(bool useChannelBasedImpl) { const int maxCount = 420; int count = 0; var actionBlock = ActionBlockSlim.Create <int>( 2, n => { Interlocked.Increment(ref count); }, useChannelBasedImpl: useChannelBasedImpl); for (int i = 0; i < maxCount; i++) { actionBlock.Post(i); } actionBlock.Complete(); await actionBlock.CompletionAsync(); Assert.Equal(maxCount, count); }
/// <nodoc /> public PipTableSerializationScheduler(int maxDegreeOfParallelism, bool debug, Action <Pip, MutablePipState> serializer) { Contract.Requires(maxDegreeOfParallelism >= -1); Contract.Requires(maxDegreeOfParallelism > 0 || debug); m_serializer = serializer; maxDegreeOfParallelism = maxDegreeOfParallelism == -1 ? Environment.ProcessorCount : maxDegreeOfParallelism; m_nonSerializedDebug = maxDegreeOfParallelism == 0 && debug; m_serializationQueue = ActionBlockSlim.Create <QueueItem>( m_nonSerializedDebug ? 1 : maxDegreeOfParallelism, item => ProcessQueueItem(item)); if (m_nonSerializedDebug) { m_serializationQueue.Complete(); // Don't allow more changes m_nonSerializablePips = new List <Pip>(); } }