public IoServiceSynchronizationContext(IoServiceScheduler ioServiceScheduler, bool disposeIoServiceAfterComplete)
{
m_disposeIoServiceAfterComplete = disposeIoServiceAfterComplete;
m_ioServiceScheduler = ioServiceScheduler ?? throw new ArgumentNullException(nameof(ioServiceScheduler));
m_outstandingOperationCount = 0;
m_work = new Work(ioServiceScheduler);
}
public TestScheduler()
{
m_ioServiceScheduler = new IoServiceScheduler();
var scheduler = new ProxyScheduler(this);
m_taskFactory = new TaskFactory(scheduler.AsTplScheduler());
m_synchronizationContext = new IoServiceSynchronizationContext(m_ioServiceScheduler);
}
public IoServiceThreadPoolScheduler(IoServiceScheduler ioService, int numberOfThreads)
{
if (numberOfThreads < EXPECTED_MININUM_THREADS)
{
throw new ArgumentOutOfRangeException(nameof(numberOfThreads));
}
m_ioService = ioService ?? throw new ArgumentNullException(nameof(ioService));
m_ioServiceWork = new Work(m_ioService);
initThreads(numberOfThreads);
}
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;
}
public Work(IoServiceScheduler scheduler)
{
m_cancelTokenSource = new CancellationTokenSource();
scheduler.AddWork(this);
}
public IoServiceThreadPoolScheduler(IoServiceScheduler ioService)
: this(ioService, Environment.ProcessorCount)
{
}
public IoServiceSynchronizationContext(IoServiceScheduler ioServiceScheduler)
: this(ioServiceScheduler, disposeIoServiceAfterComplete : false)
{
}
