private void runInnerTaskLoop()
{
QueueTasksResult exclusiveQueueResult = null;
QueueTasksResult concurrentQueueResult = null;
do
{
do
{
m_exclusiveTaskAdded.TryReset();
m_exclusiveQueueTasksParams = m_exclusiveQueueTasksParams ?? new QueueTasksParams(maxNumberOfQueuedTasks: MAX_STRAND_TASK_BATCH);
exclusiveQueueResult = m_strandAccumulateScheduler.QueueTasksToInnerScheduler(m_exclusiveQueueTasksParams);
exclusiveQueueResult.WhenAllTask.Wait();
} while (m_exclusiveTaskAdded.IsSet || exclusiveQueueResult.HasMoreTasks);
do
{
m_concurrentTaskAdded.TryReset();
m_concurrentQueueTaskParams = m_concurrentQueueTaskParams ?? new QueueTasksParams(maxNumberOfQueuedTasks: m_maxConcurrentTaskBatch);
concurrentQueueResult = m_concurrentAccumulateScheduler.QueueTasksToInnerScheduler(m_concurrentQueueTaskParams);
concurrentQueueResult.WhenAllTask.Wait();
} while (!m_exclusiveTaskAdded.IsSet && (m_concurrentTaskAdded.IsSet || concurrentQueueResult.HasMoreTasks));
} while (existsTasksToProcess(exclusiveQueueResult, concurrentQueueResult));
var resetTaskResult = tryResetLoopTask();
Debug.Assert(resetTaskResult);
isTaskLoopRequired();
}
private void queueTasks(QueueTasksParams currentParams, List <Task> currentTasks)
{
while (canQueueTask(currentParams, currentTasks) && m_tasks.TryDequeue(out var task))
{
currentTasks.Add(task);
currentParams.BeforeTaskQueuedAction?.Invoke(task);
if (currentParams.TaskContinuation != null)
{
task.ContinueWith(currentParams.TaskContinuation);
}
m_innerScheduler.QueueTask(task);
currentParams.AfterTaskQueuedAction?.Invoke(task);
}
}
public virtual QueueTasksResult QueueTasksToInnerScheduler(QueueTasksParams queueTasksParams = null)
{
CheckIfDisposed();
var currentParams = queueTasksParams ?? new QueueTasksParams();
var currentTasks = new List <Task>();
var hasMoreTasks = false;
try
{
if (processingCanceled())
{
return(new QueueTasksResult(numberOfQueuedTasks: 0,
whenAllTask: PredefinedTasks.CompletedTask,
hasMoreTasks: false));
}
if (!m_queueToInnerSchedulerSwitch.TrySet())
{
return(new QueueTasksResult(numberOfQueuedTasks: 0,
whenAllTask: PredefinedTasks.CompletedTask,
hasMoreTasks: !m_tasks.IsEmpty));
}
queueTasks(currentParams, currentTasks);
hasMoreTasks = !m_tasks.IsEmpty;
}
finally
{
m_queueToInnerSchedulerSwitch.TryReset();
}
var whenAllTask = Task.WhenAll(currentTasks);
var result = new QueueTasksResult(numberOfQueuedTasks: currentTasks.Count,
whenAllTask: whenAllTask,
hasMoreTasks: hasMoreTasks);
return(result);
}
private static bool canQueueTask(QueueTasksParams currentParams, List <Task> currentTasks)
{
return(currentTasks.Count < currentParams.MaxNumberOfQueuedTasks);
}
