internal TaskRoutine Start(IEnumerator enumerator, CallbackDelegate onComplete)
{
TaskRoutine task = RetrieveTask();
task.Start(enumerator, onComplete);
return(task);
}
IEnumerator EnumeratorDecorator(IEnumerator enumerator, TaskRoutine task)
{
while (enumerator.MoveNext() == true)
yield return enumerator.Current;
_pool.Enqueue(task);
}
internal bool ReturnTaskToPool(TaskRoutine taskRoutine)
{
if (!taskRoutine.IsBusy)
{
_pool.Enqueue(taskRoutine);
return(true);
}
return(false);
}
public async Task <ActionResult <TaskRoutine> > PostTaskRoutine(TaskRoutine taskRoutine)
{
if (ModelState.IsValid)
{
await _taskRoutineRepo.SaveTaskRoutine(taskRoutine);
return(CreatedAtAction("GetTaskRoutine", new { id = taskRoutine.Id }, taskRoutine));
}
return(BadRequest("Model is not valid"));
}
void Cleanup()
{
finalFunc.OnDespawn();
LeanClassPool <UAsyncFinalFunc> .Despawn(finalFunc);
taskRoutine = null;
func.OnDespawn();
LeanClassPool <ChildFunc <T> > .Despawn(func);
}
void Cleanup()
{
finalFunc.action1 = null;
LeanClassPool <UAsyncFinalFunc> .Despawn(finalFunc);
taskRoutine = null;
for (int i = 0; i < funcs.Count; i++)
{
funcs [i].OnDespawn();
LeanClassPool <ChildFunc> .Despawn(funcs [i]);
}
funcs.Clear();
}
internal TaskRoutine RetrieveTask()
{
TaskRoutine task = null;
if (_pool.Count > 0)
{
task = _pool.Dequeue();
}
if (task != null && !task.IsBusy)
{
return(task);
}
return(CreateEmptyTask());
}
public void OnRoutineCompleted(TaskRoutine taskRoutine, CallbackDelegate onComplete, object err, object res)
{
try {
if (onComplete != null)
{
onComplete(err, res);
}
else if (err != null)
{
Debug.LogWarning(err);
}
} catch (Exception e) {
Debug.LogException(e); // TODO: Add global exception handler
}
ReturnTaskToPool(taskRoutine);
}
public async Task <IActionResult> PutTaskRoutine(int id, TaskRoutine taskRoutine)
{
if (id != taskRoutine.Id)
{
return(BadRequest());
}
try
{
await _taskRoutineRepo.SaveTaskRoutine(taskRoutine);
return(CreatedAtAction("GetTaskRoutine", new { id = taskRoutine.Id }, taskRoutine));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
void RunOneFunc(ChildFunc func)
{
var name = func.name;
if (func.action2 != null)
{
taskRoutine =
TaskRunner.Instance.Run(
new SingleTask(
() => func.action2((err, res) => Callback(name, err, res), result)),
TaskRunnerCallback
);
}
else
{
taskRoutine =
TaskRunner.Instance.Run(
func.enumerator2((err, res) => Callback(name, err, res), result),
TaskRunnerCallback);
}
}
void RunOneFunc()
{
if (func.action1 != null)
{
taskRoutine =
TaskRunner.Instance.Run(
new SingleTask(
() => func.action1(items [completeNum], (err, res) => Callback(err))
),
TaskRunnerCallback
);
}
else
{
taskRoutine = TaskRunner.Instance.Run(
func.enumerator1(
items [completeNum],
(err, res) => Callback(err)),
TaskRunnerCallback
);
}
}
void InitializeThreadsAndData(uint numberOfThreads, bool tightTasks)
{
_runners = new MultiThreadRunner <TaskRoutine <ParallelTaskCollection <TTask> > > [numberOfThreads];
_taskRoutines = new TaskRoutine <ParallelTaskCollection <TTask> > [numberOfThreads];
_parallelTasks = new ParallelTaskCollection <TTask> [numberOfThreads];
//prepare a single multithread runner for each group of fiber like task collections
//number of threads can be less than the number of tasks to run
for (int i = 0; i < numberOfThreads; i++)
{
_runners[i] = new MultiThreadRunner <TaskRoutine <ParallelTaskCollection <TTask> > >
("MultiThreadedParallelRunner ".FastConcat(_name, " #").FastConcat(i),
false, tightTasks);
}
Action ptcOnOnComplete = DecrementConcurrentOperationsCounter;
Func <Exception, bool> ptcOnOnException = (e) =>
{
DecrementConcurrentOperationsCounter();
return(false);
};
//prepare the fiber-like paralleltasks
for (int i = 0; i < numberOfThreads; i++)
{
var ptc = new ParallelTaskCollection <TTask>("MultiThreaded ParallelTaskCollection ".
FastConcat(_name, " #").FastConcat(i));
ptc.onComplete += ptcOnOnComplete;
ptc.onException += ptcOnOnException;
_parallelTasks[i] = ptc;
var taskRoutine = ptc.ToTaskRoutine(_runners[i]);
_taskRoutines[i] = taskRoutine;
}
}
public void OnRoutineCanceled(TaskRoutine taskRoutine)
{
ReturnTaskToPool(taskRoutine);
}
