public AccumulateTasksSchedulerDecorator(ITaskScheduler innerScheduler, Action <Task> newTaskQueuedAction)
{
m_innerScheduler = innerScheduler ?? throw new ArgumentNullException(nameof(innerScheduler));
m_newTaskQueuedAction = newTaskQueuedAction;
m_tasks = new ConcurrentQueue <Task>();
m_queueToInnerSchedulerSwitch = new ThreadSafeSwitch();
m_ignoreCancellationToken = new ThreadLocal <bool>(() => false);
}
private void taskAdded(ThreadSafeSwitch taskSwitch)
{
if (m_stopCts.IsCancellationRequested)
{
throw new InvalidOperationException("Could not add task - dispose is in progress");
}
taskSwitch.TrySet();
isTaskLoopRequired();
}
public StrandSchedulerDecorator(ITaskScheduler originalScheduler)
{
m_originalScheduler = originalScheduler ?? throw new ArgumentNullException(nameof(originalScheduler));
m_tasks = new ConcurrentQueue <Task>();
m_canExecuteTaskSwitch = new ThreadSafeSwitch();
m_postOnCallStack = new ThreadLocal <bool>(() => false);
m_delayedTaskDequeueCts = new CancellationTokenSource();
m_alreadyQueuedTasksTable = new ConditionalWeakTable <Task, ThreadSafeSwitch>();
}
private void init(TaskScheduler controlScheduler, int maxTasksConcurrency)
{
if (maxTasksConcurrency <= 0)
{
throw new ArgumentOutOfRangeException(nameof(maxTasksConcurrency));
}
m_maxConcurrentTaskBatch = Math.Min(CONCURRENT_TASK_BATCH_LIMIT, maxTasksConcurrency);
m_exclusiveTaskAdded = new ThreadSafeSwitch();
m_concurrentTaskAdded = new ThreadSafeSwitch();
m_ownControlTaskScheduler = (controlScheduler == null);
if (m_ownControlTaskScheduler)
{
var ioControlService = new IoServiceScheduler();
m_ioControlScheduler = new IoServiceThreadPoolScheduler(ioControlService, CONTROL_SCHEDULER_CONCURRENCY);
var controlProxyScheduler = new ProxyScheduler(m_ioControlScheduler);
m_controlTaskFactory = new TaskFactory(controlProxyScheduler.AsTplScheduler());
}
else
{
m_controlTaskFactory = new TaskFactory(controlScheduler);
}
var ioService = new IoServiceScheduler();
m_threadPoolScheduler = new IoServiceThreadPoolScheduler(ioService, maxTasksConcurrency);
m_concurrentAccumulateScheduler = new AccumulateTasksSchedulerDecorator(m_threadPoolScheduler, _ => taskAdded(m_concurrentTaskAdded));
var strandScheduler = new StrandSchedulerDecorator(m_threadPoolScheduler);
var innerStrandProxyScheduler = new ProxyScheduler(strandScheduler);
m_strandAccumulateScheduler = new AccumulateTasksSchedulerDecorator(strandScheduler, _ => taskAdded(m_exclusiveTaskAdded));
m_strandProxyScheduler = new ProxyScheduler(m_strandAccumulateScheduler);
m_concurrentProxyScheduler = new ProxyScheduler(m_concurrentAccumulateScheduler);
m_processTaskLoop = null;
m_completedTcs = new TaskCompletionSource <Object>();
m_stopCts = new CancellationTokenSource();
m_isDisposed = false;
}
