internal override void Run(Task task, bool canInlineContinuationTask) { // For the base AwaitTaskContinuation, we allow inlining if our caller allows it // and if we're in a "valid location" for it. See the comments on // IsValidLocationForInlining for more about what's valid. For performance // reasons we would like to always inline, but we don't in some cases to avoid // running arbitrary amounts of work in suspected "bad locations", like UI threads. if (canInlineContinuationTask && IsValidLocationForInlining) { RunCallback(GetInvokeActionCallback(), m_action, ref Task.t_currentTask); // any exceptions from m_action will be handled by s_callbackRunAction } else { #if !MONO TplEtwProvider etwLog = TplEtwProvider.Log; if (etwLog.IsEnabled()) { m_continuationId = Task.NewId(); etwLog.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, m_continuationId); } #endif // We couldn't inline, so now we need to schedule it ThreadPool.UnsafeQueueCustomWorkItem(this, forceGlobal: false); } }
/// <summary>IThreadPoolWorkItem override, which is the entry function for this when the ThreadPool scheduler decides to run it.</summary> private void ExecuteWorkItemHelper() { var etwLog = TplEtwProvider.Log; Guid savedActivityId = Guid.Empty; if (etwLog.TasksSetActivityIds && m_continuationId != 0) { Guid activityId = TplEtwProvider.CreateGuidForTaskID(m_continuationId); System.Diagnostics.Tracing.EventSource.SetCurrentThreadActivityId(activityId, out savedActivityId); } try { // We're not inside of a task, so t_currentTask doesn't need to be specially maintained. // We're on a thread pool thread with no higher-level callers, so exceptions can just propagate. // If there's no execution context, just invoke the delegate. if (m_capturedContext == null) { m_action(); } // If there is an execution context, get the cached delegate and run the action under the context. else { ExecutionContext.Run(m_capturedContext, GetInvokeActionCallback(), m_action); } } finally { if (etwLog.TasksSetActivityIds && m_continuationId != 0) { System.Diagnostics.Tracing.EventSource.SetCurrentThreadActivityId(savedActivityId); } } }
private void ExecuteWorkItemHelper() { TplEtwProvider tplEtwProvider = TplEtwProvider.Log; Guid oldActivityThatWillContinue = Guid.Empty; if (tplEtwProvider.TasksSetActivityIds && this.m_continuationId != 0) { EventSource.SetCurrentThreadActivityId(TplEtwProvider.CreateGuidForTaskID(this.m_continuationId), out oldActivityThatWillContinue); } try { if (this.m_capturedContext == null) { this.m_action(); } else { try { ExecutionContext.Run(this.m_capturedContext, AwaitTaskContinuation.GetInvokeActionCallback(), (object)this.m_action, true); } finally { this.m_capturedContext.Dispose(); } } } finally { if (tplEtwProvider.TasksSetActivityIds && this.m_continuationId != 0) { EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue); } } }
public unsafe void TaskWaitBegin(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID, TplEtwProvider.TaskWaitBehavior Behavior, int ContinueWithTaskID, int appDomain) { if (!this.IsEnabled() || !this.IsEnabled(EventLevel.Informational, (EventKeywords)3)) { return; } EventSource.EventData *data = stackalloc EventSource.EventData[5]; data->Size = 4; data->DataPointer = (IntPtr)((void *)&OriginatingTaskSchedulerID); data[1].Size = 4; data[1].DataPointer = (IntPtr)((void *)&OriginatingTaskID); data[2].Size = 4; data[2].DataPointer = (IntPtr)((void *)&TaskID); data[3].Size = 4; data[3].DataPointer = (IntPtr)((void *)&Behavior); data[4].Size = 4; data[4].DataPointer = (IntPtr)((void *)&ContinueWithTaskID); if (this.TasksSetActivityIds) { this.WriteEventWithRelatedActivityIdCore(10, &TplEtwProvider.CreateGuidForTaskID(TaskID), 5, data); } else { this.WriteEventCore(10, 5, data); } }
private static Action GetActionLogDelegate(int continuationId, Action action) { return(() => { Guid savedActivityId; Guid activityId = TplEtwProvider.CreateGuidForTaskID(continuationId); System.Diagnostics.Tracing.EventSource.SetCurrentThreadActivityId(activityId, out savedActivityId); try { action(); } finally { System.Diagnostics.Tracing.EventSource.SetCurrentThreadActivityId(savedActivityId); } }); }
internal static void UnsafeScheduleAction(Action action, Task task) { AwaitTaskContinuation taskContinuation = new AwaitTaskContinuation(action, false); TplEtwProvider tplEtwProvider = TplEtwProvider.Log; if (tplEtwProvider.IsEnabled() && task != null) { taskContinuation.m_continuationId = Task.NewId(); tplEtwProvider.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, taskContinuation.m_continuationId); } ThreadPool.UnsafeQueueCustomWorkItem((IThreadPoolWorkItem)taskContinuation, false); }
private static void PostAction(object state) { SynchronizationContextAwaitTaskContinuation synchronizationContextAwaitTaskContinuation = (SynchronizationContextAwaitTaskContinuation)state; TplEtwProvider log = TplEtwProvider.Log; if (log.TasksSetActivityIds && synchronizationContextAwaitTaskContinuation.m_continuationId != 0) { synchronizationContextAwaitTaskContinuation.m_syncContext.Post(SynchronizationContextAwaitTaskContinuation.s_postCallback, SynchronizationContextAwaitTaskContinuation.GetActionLogDelegate(synchronizationContextAwaitTaskContinuation.m_continuationId, synchronizationContextAwaitTaskContinuation.m_action)); return; } synchronizationContextAwaitTaskContinuation.m_syncContext.Post(SynchronizationContextAwaitTaskContinuation.s_postCallback, synchronizationContextAwaitTaskContinuation.m_action); }
private static void PostAction(object state) { var c = (SynchronizationContextAwaitTaskContinuation)state; TplEtwProvider etwLog = TplEtwProvider.Log; if (etwLog.TasksSetActivityIds && c.m_continuationId != 0) { c.m_syncContext.Post(s_postCallback, GetActionLogDelegate(c.m_continuationId, c.m_action)); } else { c.m_syncContext.Post(s_postCallback, c.m_action); // s_postCallback is manually cached, as the compiler won't in a SecurityCritical method } }
internal sealed override void Run(Task task, bool canInlineContinuationTask) { if (canInlineContinuationTask && this.m_syncContext == SynchronizationContext.CurrentNoFlow) { base.RunCallback(AwaitTaskContinuation.GetInvokeActionCallback(), this.m_action, ref Task.t_currentTask); return; } TplEtwProvider log = TplEtwProvider.Log; if (log.IsEnabled()) { this.m_continuationId = Task.NewId(); log.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, this.m_continuationId); } base.RunCallback(SynchronizationContextAwaitTaskContinuation.GetPostActionCallback(), this, ref Task.t_currentTask); }
private static void PostAction(object state) { var c = (SynchronizationContextAwaitTaskContinuation)state; #if !FEATURE_PAL && !FEATURE_CORECLR // PAL and CoreClr don't support eventing TplEtwProvider etwLog = TplEtwProvider.Log; if (etwLog.IsEnabled() && c.m_continuationId != 0) { c.m_syncContext.Post(s_postCallback, GetActionLogDelegate(c.m_continuationId, c.m_action)); } else #endif { c.m_syncContext.Post(s_postCallback, c.m_action); // s_postCallback is manually cached, as the compiler won't in a SecurityCritical method } }
private static Action GetActionLogDelegate(int continuationId, Action action) { return((Action)(() => { Guid oldActivityThatWillContinue; EventSource.SetCurrentThreadActivityId(TplEtwProvider.CreateGuidForTaskID(continuationId), out oldActivityThatWillContinue); try { action(); } finally { EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue); } })); }
internal override void Run(Task task, bool canInlineContinuationTask) { if (canInlineContinuationTask && AwaitTaskContinuation.IsValidLocationForInlining) { this.RunCallback(AwaitTaskContinuation.GetInvokeActionCallback(), this.m_action, ref Task.t_currentTask); return; } TplEtwProvider log = TplEtwProvider.Log; if (log.IsEnabled()) { this.m_continuationId = Task.NewId(); log.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, this.m_continuationId); } ThreadPool.UnsafeQueueCustomWorkItem(this, false); }
internal override sealed void Run(Task task, bool canInlineContinuationTask) { if (canInlineContinuationTask && this.m_syncContext == SynchronizationContext.CurrentNoFlow) { this.RunCallback(AwaitTaskContinuation.GetInvokeActionCallback(), (object)this.m_action, ref Task.t_currentTask); } else { TplEtwProvider tplEtwProvider = TplEtwProvider.Log; if (tplEtwProvider.IsEnabled()) { this.m_continuationId = Task.NewId(); tplEtwProvider.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, this.m_continuationId); } this.RunCallback(SynchronizationContextAwaitTaskContinuation.GetPostActionCallback(), (object)this, ref Task.t_currentTask); } }
// Token: 0x06004058 RID: 16472 RVA: 0x000EFDB8 File Offset: 0x000EDFB8 private static Action GetActionLogDelegate(int continuationId, Action action) { return(delegate() { Guid activityId = TplEtwProvider.CreateGuidForTaskID(continuationId); Guid currentThreadActivityId; EventSource.SetCurrentThreadActivityId(activityId, out currentThreadActivityId); try { action(); } finally { EventSource.SetCurrentThreadActivityId(currentThreadActivityId); } }); }
void ExecuteWorkItemHelper() { #if !FEATURE_PAL && !FEATURE_CORECLR // PAL and CoreClr don't support eventing var etwLog = TplEtwProvider.Log; Guid savedActivityId = Guid.Empty; if (etwLog.IsEnabled() && m_continuationId != 0) { Guid activityId = TplEtwProvider.CreateGuidForTaskID(m_continuationId); System.Diagnostics.Tracing.EventSource.SetCurrentThreadActivityId(activityId, out savedActivityId); } try { #endif // We're not inside of a task, so t_currentTask doesn't need to be specially maintained. // We're on a thread pool thread with no higher-level callers, so exceptions can just propagate. // If there's no execution context, just invoke the delegate. if (m_capturedContext == null) { m_action(); } // If there is an execution context, get the cached delegate and run the action under the context. else { try { ExecutionContext.Run(m_capturedContext, GetInvokeActionCallback(), m_action, true); } finally { m_capturedContext.Dispose(); } } #if !FEATURE_PAL && !FEATURE_CORECLR // PAL and CoreClr don't support eventing } finally { if (etwLog.IsEnabled() && m_continuationId != 0) { System.Diagnostics.Tracing.EventSource.SetCurrentThreadActivityId(savedActivityId); } } #endif }
public unsafe void AwaitTaskContinuationScheduled(int OriginatingTaskSchedulerID, int OriginatingTaskID, int ContinuwWithTaskId) { if (base.IsEnabled() && base.IsEnabled(EventLevel.Informational, (EventKeywords)3L)) { EventSource.EventData *ptr = stackalloc EventSource.EventData[checked (unchecked ((UIntPtr)3) * (UIntPtr)sizeof(EventSource.EventData))]; ptr->Size = 4; ptr->DataPointer = (IntPtr)((void *)(&OriginatingTaskSchedulerID)); ptr[1].Size = 4; ptr[1].DataPointer = (IntPtr)((void *)(&OriginatingTaskID)); ptr[2].Size = 4; ptr[2].DataPointer = (IntPtr)((void *)(&ContinuwWithTaskId)); if (this.TasksSetActivityIds) { Guid guid = TplEtwProvider.CreateGuidForTaskID(ContinuwWithTaskId); base.WriteEventWithRelatedActivityIdCore(12, &guid, 3, ptr); return; } base.WriteEventCore(12, 3, ptr); } }
internal sealed override void Run(Task task, bool canInlineContinuationTask) { // If we're allowed to inline, run the action on this thread. if (canInlineContinuationTask && m_syncContext == SynchronizationContext.CurrentNoFlow) { RunCallback(GetInvokeActionCallback(), m_action, ref Task.t_currentTask); } // Otherwise, Post the action back to the SynchronizationContext. else { TplEtwProvider etwLog = TplEtwProvider.Log; if (etwLog.IsEnabled()) { m_continuationId = Task.NewId(); etwLog.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, m_continuationId); } RunCallback(GetPostActionCallback(), this, ref Task.t_currentTask); } // Any exceptions will be handled by RunCallback. }
public unsafe void AwaitTaskContinuationScheduled(int OriginatingTaskSchedulerID, int OriginatingTaskID, int ContinuwWithTaskId) { if (!this.IsEnabled() || !this.IsEnabled(EventLevel.Informational, (EventKeywords)3)) { return; } EventSource.EventData *data = stackalloc EventSource.EventData[3]; data->Size = 4; data->DataPointer = (IntPtr)((void *)&OriginatingTaskSchedulerID); data[1].Size = 4; data[1].DataPointer = (IntPtr)((void *)&OriginatingTaskID); data[2].Size = 4; data[2].DataPointer = (IntPtr)((void *)&ContinuwWithTaskId); if (this.TasksSetActivityIds) { this.WriteEventWithRelatedActivityIdCore(12, &TplEtwProvider.CreateGuidForTaskID(ContinuwWithTaskId), 3, data); } else { this.WriteEventCore(12, 3, data); } }
private void ExecuteWorkItemHelper() { TplEtwProvider log = TplEtwProvider.Log; Guid empty = Guid.Empty; if (log.TasksSetActivityIds && this.m_continuationId != 0) { Guid activityId = TplEtwProvider.CreateGuidForTaskID(this.m_continuationId); EventSource.SetCurrentThreadActivityId(activityId, out empty); } try { if (this.m_capturedContext == null) { this.m_action(); } else { try { ExecutionContext.Run(this.m_capturedContext, AwaitTaskContinuation.GetInvokeActionCallback(), this.m_action, true); } finally { this.m_capturedContext.Dispose(); } } } finally { if (log.TasksSetActivityIds && this.m_continuationId != 0) { EventSource.SetCurrentThreadActivityId(empty); } } }
public unsafe void TaskWaitBegin(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID, TplEtwProvider.TaskWaitBehavior Behavior, int ContinueWithTaskID, int appDomain) { if (base.IsEnabled() && base.IsEnabled(EventLevel.Informational, (EventKeywords)3L)) { EventSource.EventData *ptr = stackalloc EventSource.EventData[checked (unchecked ((UIntPtr)5) * (UIntPtr)sizeof(EventSource.EventData))]; ptr->Size = 4; ptr->DataPointer = (IntPtr)((void *)(&OriginatingTaskSchedulerID)); ptr[1].Size = 4; ptr[1].DataPointer = (IntPtr)((void *)(&OriginatingTaskID)); ptr[2].Size = 4; ptr[2].DataPointer = (IntPtr)((void *)(&TaskID)); ptr[3].Size = 4; ptr[3].DataPointer = (IntPtr)((void *)(&Behavior)); ptr[4].Size = 4; ptr[4].DataPointer = (IntPtr)((void *)(&ContinueWithTaskID)); if (this.TasksSetActivityIds) { Guid guid = TplEtwProvider.CreateGuidForTaskID(TaskID); base.WriteEventWithRelatedActivityIdCore(10, &guid, 5, ptr); return; } base.WriteEventCore(10, 5, ptr); } }