private static IteratorContext ExecuteTaskHelper(ITask currentTask) { if (currentTask.LinkedIterator != null) { IteratorContext iteratorContext = (IteratorContext)currentTask.LinkedIterator; if (CausalityThreadContext.IsEmpty(iteratorContext._causalities)) { Dispatcher.ClearCausalities(); } else { Dispatcher.SetCurrentThreadCausalities(iteratorContext._causalities.Clone()); } } else { Dispatcher.TransferCausalitiesFromTaskToCurrentThread(currentTask); } if (Debugger.IsAttached) { CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities(); if (!CausalityThreadContext.IsEmpty(currentThreadCausalities) && CausalityThreadContext.RequiresDebugBreak(currentThreadCausalities)) { Debugger.Break(); } } IEnumerator <ITask> enumerator = currentTask.Execute(); if (enumerator != null) { return(new IteratorContext(enumerator, Dispatcher.GetCurrentThreadCausalities())); } return(null); }
internal static void SetCurrentThreadCausalities(CausalityThreadContext context) { if (!Dispatcher._causalitiesActive) { return; } try { Dispatcher._causalityTable[Thread.CurrentThread.ManagedThreadId] = context; } catch (Exception) { if (!Dispatcher._causalityTable.ContainsKey(Thread.CurrentThread.ManagedThreadId)) { try { Dispatcher.AddThread(Thread.CurrentThread); Dispatcher._causalityTable[Thread.CurrentThread.ManagedThreadId] = context; } catch { } } } }
internal static void FilterExceptionThroughCausalities(ITask task, Exception exception) { try { CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities(); if (CausalityThreadContext.IsEmpty(currentThreadCausalities)) { if (task != null) { DispatcherQueue taskQueue = task.TaskQueue; if (!taskQueue.RaiseUnhandledException(exception)) { Dispatcher dispatcher = taskQueue.Dispatcher; if (dispatcher != null) { dispatcher.RaiseUnhandledException(exception); } } } } else { currentThreadCausalities.PostException(exception); } } catch (Exception exception2) { Dispatcher.LogError(Resource1.ExceptionDuringCausalityHandling, exception2); } }
internal static bool RequiresDebugBreak(CausalityThreadContext context) { if (context == null) { return(false); } if (context.ActiveCausality != null && context.ActiveCausality is Causality) { return(((Causality)context.ActiveCausality).BreakOnReceive); } if (context.Stacks != null) { foreach (CausalityStack current in context.Stacks) { foreach (ICausality current2 in current) { Causality causality = current2 as Causality; if (causality != null && causality.BreakOnReceive) { return(true); } } } return(false); } return(false); }
public ClrSystemTimerContext(Port <DateTime> timerPort, CausalityThreadContext causalityContext) { CausalityContext = causalityContext; lock (typeof(DispatcherQueue.ClrSystemTimerContext)) { DispatcherQueue._timerContextIdentifier += 1L; Id = DispatcherQueue._timerContextIdentifier; } TimerPort = timerPort; }
public static void AddCausality(ICausality causality) { Dispatcher._causalitiesActive = true; CausalityThreadContext causalityThreadContext = Dispatcher.GetCurrentThreadCausalities(); if (CausalityThreadContext.IsEmpty(causalityThreadContext)) { causalityThreadContext = new CausalityThreadContext(causality, null); Dispatcher.SetCurrentThreadCausalities(causalityThreadContext); return; } causalityThreadContext.AddCausality(causality); }
internal static CausalityThreadContext CloneCausalitiesFromCurrentThread() { if (!Dispatcher._causalitiesActive) { return(null); } CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities(); if (CausalityThreadContext.IsEmpty(currentThreadCausalities)) { return(null); } return(currentThreadCausalities.Clone()); }
internal CausalityThreadContext Clone() { CausalityThreadContext causalityThreadContext = new CausalityThreadContext(ActiveCausality, null); if (ActiveCausality != null) { return(causalityThreadContext); } causalityThreadContext.Stacks = new List <CausalityStack>(); foreach (CausalityStack current in Stacks) { CausalityStack causalityStack = new CausalityStack(); causalityStack.AddRange(current); causalityThreadContext.Stacks.Add(causalityStack); } return(causalityThreadContext); }
internal void AddCausality(ICausality causality) { if (CausalityThreadContext.IsEmpty(this)) { ActiveCausality = causality; return; } if (CausalityTable == null) { CausalityTable = new Dictionary <Guid, ICausality>(); } if (ActiveCausality == null) { if (Stacks != null) { if (CausalityTable.ContainsKey(causality.Guid)) { return; } CausalityTable.Add(causality.Guid, causality); foreach (CausalityStack current in Stacks) { current.Add(causality); } } return; } if (causality.Guid == ActiveCausality.Guid) { return; } CausalityTable.Add(ActiveCausality.Guid, ActiveCausality); CausalityTable.Add(causality.Guid, causality); Stacks = new List <CausalityStack>(); CausalityStack causalityStack = new CausalityStack(); causalityStack.Add(ActiveCausality); causalityStack.Add(causality); ActiveCausality = null; Stacks.Add(causalityStack); }
protected virtual Timer EnqueueTimerUsingClrSystemTimers(TimeSpan timeSpan, Port <DateTime> timerPort) { CausalityThreadContext causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread(); if (timeSpan.TotalMilliseconds <= 5.0 && timeSpan.Milliseconds >= 0) { timerPort.Post(DateTime.Now); return(null); } timeSpan = TimeSpan.FromSeconds(timeSpan.TotalSeconds * _timescale); DispatcherQueue.ClrSystemTimerContext clrSystemTimerContext = new DispatcherQueue.ClrSystemTimerContext(timerPort, causalityContext); Timer timer = new Timer(new TimerCallback(ClrSystemTimerHandler), clrSystemTimerContext, -1, -1); clrSystemTimerContext.Timer = timer; lock (_clrSystemTimerTable) { _clrSystemTimerTable.Add(clrSystemTimerContext.Id, timer); } timer.Change(timeSpan, TimeSpan.FromMilliseconds(-1.0)); return(timer); }
public virtual void EnqueueTimer(TimeSpan timeSpan, Port <DateTime> timerPort) { if (_dispatcher == null || (_dispatcher.Options & DispatcherOptions.UseHighAccuracyTimerLogic) == DispatcherOptions.None) { EnqueueTimerUsingClrSystemTimers(timeSpan, timerPort); return; } CausalityThreadContext causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread(); timeSpan = TimeSpan.FromSeconds(timeSpan.TotalSeconds * _timescale); DateTime dateTime = DateTime.UtcNow + timeSpan; DispatcherQueue.TimerContext item = new DispatcherQueue.TimerContext(timerPort, causalityContext, dateTime); bool flag = false; lock (_timerTable) { if (dateTime < _nextTimerExpiration) { _nextTimerExpiration = dateTime; flag = true; } if (_timerTable.ContainsKey(dateTime.Ticks)) { _timerTable[dateTime.Ticks].Add(item); } else { List <DispatcherQueue.TimerContext> list = new List <DispatcherQueue.TimerContext>(1); list.Add(item); _timerTable[dateTime.Ticks] = list; } } if (flag) { Enqueue(new Task(delegate { })); } }
internal static void TransferCausalitiesFromTaskToCurrentThread(ITask currentTask) { if (!Dispatcher._causalitiesActive) { return; } CausalityThreadContext causalityThreadContext = null; for (int i = 0; i < currentTask.PortElementCount; i++) { IPortElement portElement = currentTask[i]; if (portElement != null && portElement.CausalityContext != null) { CausalityThreadContext context = (CausalityThreadContext)portElement.CausalityContext; if (causalityThreadContext == null) { causalityThreadContext = new CausalityThreadContext(null, null); } causalityThreadContext.MergeWith(context); } } Dispatcher.SetCurrentThreadCausalities(causalityThreadContext); }
public IterativeTask(IteratorHandler handler) { _Handler = handler; _causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread(); }
public TimerContext(Port <DateTime> timerPort, CausalityThreadContext causalityContext, DateTime expiration) { CausalityContext = causalityContext; TimerPort = timerPort; Expiration = expiration; }
private static bool RemoveCausality(string name, ICausality causality) { CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities(); return(!CausalityThreadContext.IsEmpty(currentThreadCausalities) && currentThreadCausalities.RemoveCausality(name, causality)); }
internal void MergeWith(CausalityThreadContext context) { if (Stacks == null && ActiveCausality == null) { if (context.ActiveCausality != null) { AddCausality(context.ActiveCausality); return; } foreach (CausalityStack current in context.Stacks) { AddCausalityStack(current); } return; } else { if (Stacks == null) { Stacks = new List <CausalityStack>(1); } if (CausalityTable == null) { CausalityTable = new Dictionary <Guid, ICausality>(); } if (Stacks.Count == 0 && context.ActiveCausality != null) { if (ActiveCausality.Guid == context.ActiveCausality.Guid) { return; } CausalityTable[ActiveCausality.Guid] = ActiveCausality; CausalityTable[context.ActiveCausality.Guid] = context.ActiveCausality; ((List <CausalityStack>)Stacks).Add(new CausalityStack()); ((List <CausalityStack>)Stacks)[0].Add(ActiveCausality); ((List <CausalityStack>)Stacks).Add(new CausalityStack()); ((List <CausalityStack>)Stacks)[1].Add(context.ActiveCausality); ActiveCausality = null; return; } else { if (ActiveCausality != null && context.Stacks != null) { ((List <CausalityStack>)Stacks).Add(new CausalityStack()); ((List <CausalityStack>)Stacks)[0].Add(ActiveCausality); CausalityTable[ActiveCausality.Guid] = ActiveCausality; foreach (CausalityStack current2 in context.Stacks) { AddCausalityStack(current2); } ActiveCausality = null; Normalize(); return; } if (Stacks.Count > 0 && context.Stacks != null) { foreach (CausalityStack current3 in context.Stacks) { AddCausalityStack(current3); } } return; } } }
public static bool IsEmpty(CausalityThreadContext context) { return(context == null || (context.ActiveCausality == null && context.Stacks == null)); }
public Task(Handler handler) { _handler = handler; _causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread(); }
public IteratorContext(IEnumerator <ITask> iterator, CausalityThreadContext causalities) { _iterator = iterator; _causalities = causalities; }