internal static OrleansTaskScheduler InitializeSchedulerForTesting(ISchedulingContext context)
 {
     StatisticsCollector.StatisticsCollectionLevel = StatisticsLevel.Info;
     SchedulerStatisticsGroup.Init();
     var scheduler = new OrleansTaskScheduler(4);
     scheduler.Start();
     WorkItemGroup ignore = scheduler.RegisterWorkContext(context);
     return scheduler;
 }

        /// <summary>
        /// Create a new TaskWorkItem for running the specified Task on the specified scheduler.
        /// </summary>
        /// <param name="sched">Scheduler to execute this Task action. A value of null means use the Orleans system scheduler.</param>
        /// <param name="t">Task to be performed</param>
        /// <param name="context">Execution context</param>
        internal TaskWorkItem(ITaskScheduler sched, Task t, ISchedulingContext context)
        {
            scheduler = sched;
            task = t;
            SchedulingContext = context;
#if DEBUG
            if (logger.IsVerbose2) logger.Verbose2("Created TaskWorkItem {0} for Id={1} State={2} with Status={3} Scheduler={4}",
                Name, task.Id, (task.AsyncState == null) ? "null" : task.AsyncState.ToString(), task.Status, scheduler);
#endif
        }

 public InvokeWorkItem(ActivationData activation, Message message, ISchedulingContext context)
 {
     this.activation = activation;
     this.message = message;
     SchedulingContext = context;
     if (activation == null || activation.GrainInstance==null)
     {
         var str = String.Format("Creating InvokeWorkItem with bad activation: {0}. Message: {1}", activation, message);
         logger.Warn(ErrorCode.SchedulerNullActivation, str);
         throw new ArgumentException(str);
     }
     activation.IncrementInFlightCount();
 }

 private async Task TimerTick(object state, ISchedulingContext context)
 {
     if (TimerAlreadyStopped)
         return;
     try
     {
         await RuntimeClient.Current.ExecAsync(() => ForwardToAsyncCallback(state), context, Name);
     }
     catch (InvalidSchedulingContextException exc)
     {
         logger.Error(ErrorCode.Timer_InvalidContext,
             string.Format("Caught an InvalidSchedulingContextException on timer {0}, context is {1}. Going to dispose this timer!",
                 GetFullName(), context), exc);
         DisposeTimer();
     }
 }

        // Only required if you have work groups flagged by a context that is not a WorkGroupingContext
        public WorkItemGroup RegisterWorkContext(ISchedulingContext context)
        {
            if (context == null) return null;

            var wg = new WorkItemGroup(this, context);
            workgroupDirectory.TryAdd(context, wg);
            return wg;
        }

        // Only required if you have work groups flagged by a context that is not a WorkGroupingContext
        public void UnregisterWorkContext(ISchedulingContext context)
        {
            if (context == null) return;

            WorkItemGroup workGroup;
            if (workgroupDirectory.TryRemove(context, out workGroup))
                workGroup.Stop();
        }

 public bool Equals(ISchedulingContext other)
 {
     return base.Equals(other);
 }

        // Enqueue a work item to a given context
        public void QueueWorkItem(IWorkItem workItem, ISchedulingContext context)
        {
#if DEBUG
            if (logger.IsVerbose2) logger.Verbose2("QueueWorkItem " + context);
#endif
            if (workItem is TaskWorkItem)
            {
                var error = String.Format("QueueWorkItem was called on OrleansTaskScheduler for TaskWorkItem {0} on Context {1}."
                    + " Should only call OrleansTaskScheduler.QueueWorkItem on WorkItems that are NOT TaskWorkItem. Tasks should be queued to the scheduler via QueueTask call.",
                    workItem.ToString(), context);
                logger.Error(ErrorCode.SchedulerQueueWorkItemWrongCall, error);
                throw new InvalidOperationException(error);
            }

            var workItemGroup = GetWorkItemGroup(context);
            if (applicationTurnsStopped && (workItemGroup != null) && !workItemGroup.IsSystem)
            {
                // Drop the task on the floor if it's an application work item and application turns are stopped
                var msg = string.Format("Dropping work item {0} because applicaiton turns are stopped", workItem);
                logger.Warn(ErrorCode.SchedulerAppTurnsStopped, msg);
                return;
            }

            workItem.SchedulingContext = context;

            // We must wrap any work item in Task and enqueue it as a task to the right scheduler via Task.Start.
            // This will make sure the TaskScheduler.Current is set correctly on any task that is created implicitly in the execution of this workItem.
            if (workItemGroup == null)
            {
                Task t = TaskSchedulerUtils.WrapWorkItemAsTask(workItem, context, this);
                t.Start(this);
            }
            else
            {
                // Create Task wrapper for this work item
                Task t = TaskSchedulerUtils.WrapWorkItemAsTask(workItem, context, workItemGroup.TaskRunner);
                t.Start(workItemGroup.TaskRunner);
            }
        }

 public async Task ExecAsync(Func<Task> asyncFunction, ISchedulingContext context, string activityName)
 {
     // Schedule call back to grain context
     await OrleansTaskScheduler.Instance.QueueNamedTask(asyncFunction, context, activityName);
 }

 internal void CheckSchedulingContextValidity(ISchedulingContext context)
 {
     if (context == null)
     {
         throw new InvalidSchedulingContextException(
             "CheckSchedulingContextValidity was called on a null SchedulingContext."
              + "Please make sure you are not trying to create a Timer from outside Orleans Task Scheduler, "
              + "which will be the case if you create it inside Task.Run.");
     }
     GetWorkItemGroup(context); // GetWorkItemGroup throws for Invalid context
 }

        private void EnqueueReceiveMessage(Message msg, ActivationData targetActivation, ISchedulingContext context)
        {
            MessagingProcessingStatisticsGroup.OnImaMessageEnqueued(context);

            if (targetActivation != null) targetActivation.IncrementEnqueuedOnDispatcherCount();

            scheduler.QueueWorkItem(new ClosureWorkItem(() =>
            {
                try
                {
                    dispatcher.ReceiveMessage(msg);
                }
                finally
                {
                    if (targetActivation != null) targetActivation.DecrementEnqueuedOnDispatcherCount();
                }
            },
            () => "Dispatcher.ReceiveMessage"), context);
        }

 public TaskScheduler GetTaskScheduler(ISchedulingContext context)
 {
     if (context == null)
         return this;
     
     WorkItemGroup workGroup;
     return workgroupDirectory.TryGetValue(context, out workGroup) ? (TaskScheduler) workGroup.TaskRunner : this;
 }

 // public for testing only -- should be private, otherwise
 public WorkItemGroup GetWorkItemGroup(ISchedulingContext context)
 {
     WorkItemGroup workGroup = null;
     if (context != null)
         workgroupDirectory.TryGetValue(context, out workGroup);
     
     return workGroup;
 }

 public bool Equals(ISchedulingContext other)
 {
     return AreSame(other);
 }

 private void UnobservedExceptionHandler(ISchedulingContext context, Exception exception)
 {
     var schedulingContext = context as SchedulingContext;
     if (schedulingContext == null)
     {
         if (context == null)
             logger.Error(ErrorCode.Runtime_Error_100102, "Silo caught an UnobservedException with context==null.", exception);
         else
             logger.Error(ErrorCode.Runtime_Error_100103, String.Format("Silo caught an UnobservedException with context of type different than OrleansContext. The type of the context is {0}. The context is {1}",
                 context.GetType(), context), exception);
     }
     else
     {
         logger.Error(ErrorCode.Runtime_Error_100104, String.Format("Silo caught an UnobservedException thrown by {0}.", schedulingContext.Activation), exception);
     }   
 }

 internal static void OnImaMessageEnqueued(ISchedulingContext context)
 {
     if (context == null)
     {
         imaEnqueuedByContext[0].Increment();
     }
     else if (context.ContextType == SchedulingContextType.SystemTarget)
     {
         imaEnqueuedByContext[1].Increment();
     }
     else if (context.ContextType == SchedulingContextType.Activation)
     {
         imaEnqueuedByContext[2].Increment();
     }
 }

 internal static Task WrapWorkItemAsTask(IWorkItem todo, ISchedulingContext context, TaskScheduler sched)
 {
     var task = new Task(state => RunWorkItemTask(todo, sched), context);
     return task;
 }

        // public for testing only -- should be private, otherwise
        public WorkItemGroup GetWorkItemGroup(ISchedulingContext context)
        {
            if (context == null)
                return null;
           
            WorkItemGroup workGroup;
            if(workgroupDirectory.TryGetValue(context, out workGroup))
                return workGroup;

            var error = String.Format("QueueWorkItem was called on a non-null context {0} but there is no valid WorkItemGroup for it.", context);
            logger.Error(ErrorCode.SchedulerQueueWorkItemWrongContext, error);
            throw new InvalidSchedulingContextException(error);
        }

 internal static void SetExecutionContext(ISchedulingContext shedContext, TaskScheduler scheduler)
 {
     if (context == null) throw new InvalidOperationException("SetExecutionContext called on unexpected non-WorkerPool thread");
     context.ActivationContext = shedContext;
     context.Scheduler = scheduler;
 }

 internal void CheckSchedulingContextValidity(ISchedulingContext context)
 {
     if (context == null)
     {
         throw new InvalidSchedulingContextException("CheckSchedulingContextValidity was called on a null SchedulingContext.");
     }
     GetWorkItemGroup(context); // GetWorkItemGroup throws for Invalid context
 }