bool FetchFromScheduledTaskQueue()
{
PreciseTimeSpan nanoTime = PreciseTimeSpan.FromStart;
IScheduledRunnable scheduledTask = this.PollScheduledTask(nanoTime);
while (scheduledTask != null)
{
if (!this.taskQueue.TryEnqueue(scheduledTask))
{
// No space left in the task queue add it back to the scheduledTaskQueue so we pick it up again.
this.ScheduledTaskQueue.Enqueue(scheduledTask);
return(false);
}
scheduledTask = this.PollScheduledTask(nanoTime);
}
return(true);
}
protected IScheduledRunnable PollScheduledTask(PreciseTimeSpan nanoTime)
{
Contract.Assert(this.InEventLoop);
IScheduledRunnable scheduledTask = this.ScheduledTaskQueue.Peek();
if (scheduledTask == null)
{
return(null);
}
if (scheduledTask.Deadline <= nanoTime)
{
this.ScheduledTaskQueue.Dequeue();
return(scheduledTask);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="pool"></param>
/// <param name="threadName"></param>
/// <param name="breakoutInterval"></param>
/// <param name="taskQueue"></param>
protected SingleThreadEventExecutor(IThreadPoolExecutor pool, string threadName, TimeSpan breakoutInterval, IQueue <IRunnable> taskQueue)
: base(pool)
{
this.terminationCompletionSource = new TaskCompletionSource();
this.taskQueue = taskQueue;
this.preciseBreakoutInterval = PreciseTimeSpan.FromTimeSpan(breakoutInterval);
this.scheduler = new ExecutorTaskScheduler(this);
this.thread = new Thread(this.Loop);
if (string.IsNullOrEmpty(threadName))
{
this.thread.Name = DefaultWorkerThreadName;
}
else
{
this.thread.Name = threadName;
}
this.thread.Start();
}
bool RunAllTasks(PreciseTimeSpan timeout)
{
this.FetchFromScheduledTaskQueue();
IRunnable task = this.PollTask();
if (task == null)
{
return(false);
}
PreciseTimeSpan deadline = PreciseTimeSpan.Deadline(timeout);
long runTasks = 0;
PreciseTimeSpan executionTime;
while (true)
{
SafeExecute(task);
runTasks++;
// Check timeout every 64 tasks because nanoTime() is relatively expensive.
// XXX: Hard-coded value - will make it configurable if it is really a problem.
if ((runTasks & 0x3F) == 0)
{
executionTime = PreciseTimeSpan.FromStart;
if (executionTime >= deadline)
{
break;
}
}
task = this.PollTask();
if (task == null)
{
executionTime = PreciseTimeSpan.FromStart;
break;
}
}
this.lastExecutionTime = executionTime;
return(true);
}
protected bool RunAllTasks()
{
this.FetchFromScheduledTaskQueue();
IRunnable task = this.PollTask();
if (task == null)
{
return(false);
}
while (true)
{
Volatile.Write(ref this.progress, this.progress + 1); // volatile write is enough as this is the only thread ever writing
SafeExecute(task);
task = this.PollTask();
if (task == null)
{
this.lastExecutionTime = PreciseTimeSpan.FromStart;
return(true);
}
}
}
public StateActionScheduledTask(AbstractScheduledEventExecutor executor, Action <object> action, object state, PreciseTimeSpan deadline)
: base(executor, deadline, new TaskCompletionSource(state))
{
this.action = action;
}
public ActionScheduledAsyncTask(AbstractScheduledEventExecutor executor, Action action, PreciseTimeSpan deadline, CancellationToken cancellationToken)
: base(executor, deadline, new TaskCompletionSource(), cancellationToken)
{
this.action = action;
}
protected ScheduledTask(AbstractScheduledEventExecutor executor, PreciseTimeSpan deadline, TaskCompletionSource promise)
{
this.Executor = executor;
this.Promise = promise;
this.Deadline = deadline;
}
public ActionScheduledTask(AbstractScheduledEventExecutor executor, Action action, PreciseTimeSpan deadline)
: base(executor, deadline, new TaskCompletionSource())
{
this.action = action;
}
public override IScheduledTask Schedule(IRunnable action, TimeSpan delay)
{
Contract.Requires(action != null);
return(this.Schedule(new RunnableScheduledTask(this, action, PreciseTimeSpan.Deadline(delay))));
}
public override Task ScheduleAsync(Action <object, object> action, object context, object state, TimeSpan delay, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(TaskEx.Cancelled);
}
if (!cancellationToken.CanBeCanceled)
{
return(this.Schedule(action, context, state, delay).Completion);
}
return(this.Schedule(new StateActionWithContextScheduledAsyncTask(this, action, context, state, PreciseTimeSpan.Deadline(delay), cancellationToken)).Completion);
}
public override IScheduledTask Schedule(Action <object, object> action, object context, object state, TimeSpan delay)
{
Contract.Requires(action != null);
return(this.Schedule(new StateActionWithContextScheduledTask(this, action, context, state, PreciseTimeSpan.Deadline(delay))));
}
/// <inheritdoc cref="IEventExecutor"/>
public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan timeout)
{
Contract.Requires(quietPeriod >= TimeSpan.Zero);
Contract.Requires(timeout >= quietPeriod);
if (this.IsShuttingDown)
{
return(this.TerminationCompletion);
}
bool inEventLoop = this.InEventLoop;
bool wakeup;
int oldState;
while (true)
{
if (this.IsShuttingDown)
{
return(this.TerminationCompletion);
}
int newState;
wakeup = true;
oldState = this.executionState;
if (inEventLoop)
{
newState = ST_SHUTTING_DOWN;
}
else
{
switch (oldState)
{
case ST_NOT_STARTED:
case ST_STARTED:
newState = ST_SHUTTING_DOWN;
break;
default:
newState = oldState;
wakeup = false;
break;
}
}
if (Interlocked.CompareExchange(ref this.executionState, newState, oldState) == oldState)
{
break;
}
}
this.gracefulShutdownQuietPeriod = PreciseTimeSpan.FromTimeSpan(quietPeriod);
this.gracefulShutdownTimeout = PreciseTimeSpan.FromTimeSpan(timeout);
// todo: revisit
//if (oldState == ST_NOT_STARTED)
//{
// scheduleExecution();
//}
if (wakeup)
{
this.WakeUp(inEventLoop);
}
return(this.TerminationCompletion);
}
protected ScheduledAsyncTask(AbstractScheduledEventExecutor executor, PreciseTimeSpan deadline, TaskCompletionSource promise, CancellationToken cancellationToken)
: base(executor, deadline, promise)
{
this.cancellationToken = cancellationToken;
this.cancellationTokenRegistration = cancellationToken.Register(s => ((ScheduledAsyncTask)s).Cancel(), this);
}