public void SimpleExecutionTest () { bool executed = false; Task t = new Task (() => executed = true); t.Execute (delegate {}); Assert.IsTrue (executed); }
public void ExecutionWithChildCreationTest () { bool executed = false; bool childRetrieved = false; Task t = new Task (() => { Task.Factory.StartNew (() => Console.WriteLine ("execution")); executed = true; }); t.Execute ((child) => childRetrieved = child != null); Assert.IsTrue (executed); Assert.IsTrue (childRetrieved); }
protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued) { if (task.IsCompleted) return false; if (task.Status == TaskStatus.WaitingToRun) { task.Execute (null); return true; } return false; }
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) { if (task.IsCompleted) { return(false); } if (task.Status == TaskStatus.WaitingToRun) { task.Execute(null); return(true); } return(false); }
internal protected bool TryExecuteTask(Task task) { if (task.IsCompleted) { return(false); } if (task.Status == TaskStatus.WaitingToRun) { task.Execute(); return(true); } return(false); }
/// <summary> /// Attempts to execute the provided Task on this scheduler. /// </summary> protected bool TryExecuteTask(Task task) { if (task.IsCompleted) { return(false); } if (task.Status == TaskStatus.WaitingToRun) { task.Execute(); //if (task.WaitOnChildren()) task.Wait(); return(true); } return(false); }
public void ParticipateUntil(Task task) { if (participateUntil1 != null) { participateUntil1(task); return; } if (task.Status == TaskStatus.WaitingToRun) { task.Execute(null); } if (task.IsCompleted) { return; } ManualResetEventSlim evt = new ManualResetEventSlim(false); task.ContinueWith(_ => evt.Set(), TaskContinuationOptions.ExecuteSynchronously); ParticipateUntil(evt, -1); }
private static void TaskExecuterCallback(object obj) { Task task = (Task)obj; task.Execute(); }
// Almost same as above but with an added predicate and treating one item at a time. // It's used by Scheduler Participate(...) method for special waiting case like // Task.WaitAll(someTasks) or Task.WaitAny(someTasks) // Predicate should be really fast and not blocking as it is called a good deal of time // Also, the method skip tasks that are LongRunning to avoid blocking (Task are not LongRunning by default) public static void ParticipativeWorkerMethod (Task self, ManualResetEventSlim predicateEvt, int millisecondsTimeout, IProducerConsumerCollection<Task> sharedWorkQueue, ThreadWorker[] others, ManualResetEvent evt, Func<Task, Task, bool> checkTaskFitness) { const int stage1 = 5, stage2 = 0; int tries = 50; WaitHandle[] handles = null; Watch watch = Watch.StartNew (); if (millisecondsTimeout == -1) millisecondsTimeout = int.MaxValue; bool aggressive = false; bool hasAutoReference = autoReference != null; Action<Task> adder = null; while (!predicateEvt.IsSet && watch.ElapsedMilliseconds < millisecondsTimeout && !self.IsCompleted) { // We try to execute the self task as it may be the simplest way to unlock // the situation if (self.Status == TaskStatus.WaitingToRun) { self.Execute (hasAutoReference ? autoReference.adder : (Action<Task>)null); if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout) return; } Task value; // If we are in fact a normal ThreadWorker, use our own deque if (hasAutoReference) { var enumerable = autoReference.dDeque.GetEnumerable (); if (adder == null) adder = hasAutoReference ? autoReference.adder : (Action<Task>)null; if (enumerable != null) { foreach (var t in enumerable) { if (t == null) continue; if (checkTaskFitness (self, t)) t.Execute (adder); if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout) return; } } } int count = sharedWorkQueue.Count; // Dequeue only one item as we have restriction while (--count >= 0 && sharedWorkQueue.TryTake (out value) && value != null) { evt.Set (); if (checkTaskFitness (self, value) || aggressive) value.Execute (null); else { if (autoReference == null) sharedWorkQueue.TryAdd (value); else autoReference.dDeque.PushBottom (value); evt.Set (); } if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout) return; } // First check to see if we comply to predicate if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout) return; // Try to complete other work by stealing since our desired tasks may be in other worker ThreadWorker other; for (int i = 0; i < others.Length; i++) { if ((other = others [i]) == autoReference || other == null) continue; if (other.dDeque.PopTop (out value) == PopResult.Succeed && value != null) { evt.Set (); if (checkTaskFitness (self, value) || aggressive) value.Execute (null); else { if (autoReference == null) sharedWorkQueue.TryAdd (value); else autoReference.dDeque.PushBottom (value); evt.Set (); } } if (predicateEvt.IsSet || watch.ElapsedMilliseconds > millisecondsTimeout) return; } /* Waiting is split in 4 phases * - until stage 1 we simply yield the thread to let others add data * - between stage 1 and stage2 we use ManualResetEventSlim light waiting mechanism * - after stage2 we fall back to the heavier WaitHandle waiting mechanism * - if really the situation isn't evolving after a couple of sleep, we disable * task fitness check altogether */ if (--tries > stage1) Thread.Yield (); else if (tries >= stage2) predicateEvt.Wait (ComputeTimeout (5, millisecondsTimeout, watch)); else { if (tries == stage2 - 1) handles = new [] { predicateEvt.WaitHandle, evt }; System.Threading.WaitHandle.WaitAny (handles, ComputeTimeout (1000, millisecondsTimeout, watch)); if (tries == stage2 - 10) aggressive = true; } } }
void ExecuteTask (Task value, ref bool result) { if (value == null) return; var saveCurrent = currentTask; currentTask = value; value.Execute (adder); result = true; currentTask = saveCurrent; }
public void AddWork (Task t) { ThreadPool.QueueUserWorkItem (delegate { t.Execute (AddWork); }); }
internal protected bool TryExecuteTask (Task task) { if (task.IsCompleted) return false; if (task.Status == TaskStatus.WaitingToRun) { task.Execute (null); return true; } return false; }
protected internal bool TryExecuteTask(Task task) { if (task.IsCompleted) return false; if (task.Status == TaskStatus.WaitingToRun) { task.Execute (); if (task.WaitOnChildren ()) task.Wait (); return true; } return false; }
protected void TaskExecuterCallback(object obj) { Task task = (Task)obj; task.Execute(); }
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) { task.Execute(null); return(true); }
protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued) { task.Execute (null); return true; }
static void TaskExecuterCallback(object obj) { Task task = (Task)obj; task.Execute(null); }