// Initializes the the precise timing mechanism private static void InitializePreciseTime() { // We just use the recommended synchronization period for general purpose use const int synchronizationPeriod = 10; // Create a new precise time class s_preciseTime = new PreciseTime(synchronizationPeriod); // We setup a lightweight timer that will make sure precise time mechanism gets // called regularly, in case user doesn't, so it can maintain synchronization s_synchronizer = new Timer(synchronizationPeriod * 1000.0D); s_synchronizer.Elapsed += s_synchronizer_Elapsed; s_synchronizer.Start(); }
internal long RunScheduledTasks() { var time = PreciseTime.NanoTime(); while (true) { IRunnable task = PollScheduledTask(time); if (task is null) { return(NextScheduledTaskNanos()); } task.Run(); } }
private void TestScheduleLaggyTaskAtFixedRate(IEventLoop loopA) { var timestamps = new BlockingCollection <long>(); int expectedTimeStamps = 5; var allTimeStampsLatch = new CountdownEvent(expectedTimeStamps); var f = loopA.ScheduleAtFixedRate(() => { var empty = timestamps.Count == 0; timestamps.Add(Stopwatch.GetTimestamp()); if (empty) { try { Thread.Sleep(401); } catch { } } allTimeStampsLatch.Signal(); }, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100)); Assert.True(allTimeStampsLatch.Wait(TimeSpan.FromMinutes(1))); Assert.True(f.Cancel()); Thread.Sleep(300); Assert.Equal(expectedTimeStamps, timestamps.Count); // Check if the task was run with lag. int i = 0; long?previousTimestamp = null; foreach (long t in timestamps) { if (previousTimestamp == null) { previousTimestamp = t; continue; } long diff = t - previousTimestamp.Value; if (i == 0) { Assert.True(diff >= PreciseTime.ToDelayNanos(TimeSpan.FromMilliseconds(400))); } else { Assert.True(diff <= PreciseTime.ToDelayNanos(TimeSpan.FromMilliseconds(10))); } previousTimestamp = t; i++; } }
internal void ProcessVoteConfirmation(Connection sender, int term) { serialLock.AssertIsLockedByMe(); LogMinorEvent("Processing vote confirmation for term " + term + " from " + sender); if (state == State.Candidate && term == currentTerm) { nextActionAt = GetElectionTimeout(); numVotes++; CheckElectionMajority(); } else { LogMinorEvent("Confirmation rejected: " + state + ", t" + term); } }
public void TestScheduling() { var ch = new EmbeddedChannel(new ChannelHandlerAdapter()); var latch = new CountdownEvent(2); Task future = ch.EventLoop.ScheduleAsync(() => latch.Signal(), TimeSpan.FromSeconds(1)); future.ContinueWith(t => latch.Signal()); var next = ch.RunScheduledPendingTasks(); Assert.True(next > PreciseTime.Zero); // Sleep for the nanoseconds but also give extra 50ms as the clock my not be very precise and so fail the test // otherwise. Thread.Sleep(PreciseTime.ToTimeSpan(next) + TimeSpan.FromMilliseconds(50)); Assert.Equal(PreciseTime.MinusOne, ch.RunScheduledPendingTasks()); latch.Wait(); }
protected sealed override IRunnable PollTask() { const long MaxDelayMilliseconds = int.MaxValue - 1; Debug.Assert(InEventLoop); var taskQueue = _taskQueue; var task = PollTaskFrom(taskQueue); if (task is object) { return(task); } #if DEBUG if (_tailTasks.IsEmpty) { _emptyEvent.Reset(); } #else _emptyEvent.Reset(); #endif task = PollTaskFrom(taskQueue); if (task is object || IsShuttingDown) // revisit queue as producer might have put a task in meanwhile { return(task); } // revisit queue as producer might have put a task in meanwhile if (TryPeekScheduledTask(out IScheduledRunnable nextScheduledTask)) { var delayNanos = nextScheduledTask.DelayNanos; if ((ulong)delayNanos > 0UL) // delayNanos 为非负值 { var timeout = PreciseTime.ToMilliseconds(delayNanos); _emptyEvent.Wait((int)Math.Min(timeout, MaxDelayMilliseconds)); } } else { if (!IsShuttingDown) { _emptyEvent.Wait(); } task = PollTaskFrom(taskQueue); } return(task); }
public override Task ScheduleAsync(Action <object> action, object state, TimeSpan delay, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(TaskUtil.Cancelled); } if (!cancellationToken.CanBeCanceled) { return(Schedule(action, state, delay).Completion); } if (action is null) { return(ThrowHelper.FromArgumentNullException(ExceptionArgument.action)); } return(Schedule(new StateActionScheduledAsyncTask(this, action, state, PreciseTime.DeadlineNanos(delay), cancellationToken)).Completion); }
private void CommitTo(int newCommitCount) { serialLock.AssertIsLockedByMe(); try { if (commitCount < newCommitCount) { lastCommit = DateTime.Now; LogMinorEvent("Committing " + commitCount + ".." + newCommitCount + ", history length " + log.Count); for (int i = commitCount; i < newCommitCount; i++) { PrivateEntry e = log[i]; if (e == null) { LogMinorEvent("Skipping removed entry at #" + i); } else { if (DebugState != null) { DebugState.SignalExecution(i, e.Entry.Term, this); } if (!e.WasExecuted) { commitCount = Math.Max(commitCount, i + 1); LogMinorEvent("Executing " + e.Entry); e.Execute(this); committed.TryRemove(e.Entry.CommitID); } } } //Debug.Assert(commitCount == newCommitCount); if (IsLeader) { Broadcast(new AppendEntries(this)); nextActionAt = NextHeartbeat; } } } catch (Exception ex) { } }
internal void Yield() { serialLock.AssertIsLockedByMe(); LogEvent("Yielding..."); state = State.Follower; leader = null; votedFor = null; //votedInTerm = -1; nextActionAt = GetElectionTimeout(); if (cfgChange != null) { Join(cfgChange.NewCFG); if (cfgChange != null) { throw new IntegrityViolation("Consensus: New CFG should have been unset by Join()"); } } OnConsensusChange(Status.NotEstablished, null); }
/// <summary> /// Return <c>true</c> if at least one scheduled task was executed. /// </summary> private bool ExecuteExpiredScheduledTasks() { if (_scheduledTaskQueue.IsEmpty) { return(false); } var nanoTime = PreciseTime.NanoTime(); var scheduledTask = PollScheduledTask(nanoTime); if (scheduledTask is null) { return(false); } do { SafeExecute(scheduledTask); } while ((scheduledTask = PollScheduledTask(nanoTime)) is object); return(true); }
private bool TryTakeTask(long delayNanos, out IRunnable task) { const long MaxDelayMilliseconds = int.MaxValue - 1; if ((ulong)delayNanos > 0UL) // delayNanos 为非负值 { var timeout = PreciseTime.ToMilliseconds(delayNanos); if (_blockingTaskQueue.TryTake(out task, (int)Math.Min(timeout, MaxDelayMilliseconds))) { return(true); } } // We need to fetch the scheduled tasks now as otherwise there may be a chance that // scheduled tasks are never executed if there is always one task in the taskQueue. // This is for example true for the read task of OIO Transport // See https://github.com/netty/netty/issues/1614 _ = FetchFromScheduledTaskQueue(); return(_blockingTaskQueue.TryTake(out task, 0)); }
internal void ProcessVoteRequest(Connection sender, int term, bool upToDate) { serialLock.AssertIsLockedByMe(); if ((/*votedFor == null ||*/ votedFor == sender || term > currentTerm) && upToDate) //already voted: all good. { Yield(); //state = State.Follower; //leader = null; leave old leader in place LogMinorEvent("Recognized vote request for term " + term + " from " + sender); //nextActionAt = GetElectionTimeout(); votedFor = sender; currentTerm = term; //currentTerm = term; //!!!!we voted: we cannot accept any other appendentries from our last leader!!!! try { sender.Dispatch(new VoteConfirm(currentTerm)); } catch { bool brk = true; } } else { LogMinorEvent("Rejected vote request for term " + term + " (at term " + currentTerm + ", upToDate=" + upToDate + ") from " + sender); if (term > currentTerm) { bool now = state == State.Candidate && !upToDate; //preemt currentTerm = term; Yield(); nextActionAt = now ? PreciseTime.Now : GetElectionTimeout(); } } }
public void ScheduleTaskAtFixedRate() { var timestamps = new BlockingCollection <long>(); int expectedTimeStamps = 5; var allTimeStampsLatch = new CountdownEvent(expectedTimeStamps); var f = this.eventLoop.ScheduleAtFixedRate(() => { timestamps.Add(Stopwatch.GetTimestamp()); try { Thread.Sleep(50); } catch { } allTimeStampsLatch.Signal(); }, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100)); Assert.True(allTimeStampsLatch.Wait(TimeSpan.FromMinutes(1))); Assert.True(f.Cancel()); Thread.Sleep(300); Assert.Equal(expectedTimeStamps, timestamps.Count); // Check if the task was run without a lag. long?firstTimestamp = null; int cnt = 0; foreach (long t in timestamps) { if (firstTimestamp == null) { firstTimestamp = t; continue; } long timepoint = t - firstTimestamp.Value; Assert.True(timepoint >= PreciseTime.ToDelayNanos(TimeSpan.FromMilliseconds(100 * cnt + 80))); Assert.True(timepoint <= PreciseTime.ToDelayNanos(TimeSpan.FromMilliseconds(100 * (cnt + 1) + 20))); cnt++; } }
private bool FetchFromScheduledTaskQueue() { if (_scheduledTaskQueue.IsEmpty) { return(true); } var nanoTime = PreciseTime.NanoTime(); IScheduledRunnable scheduledTask = PollScheduledTask(nanoTime); while (scheduledTask is object) { if (!_taskQueue.TryEnqueue(scheduledTask)) { // No space left in the task queue add it back to the scheduledTaskQueue so we pick it up again. _ = _scheduledTaskQueue.TryEnqueue(scheduledTask); return(false); } scheduledTask = PollScheduledTask(nanoTime); } return(true); }
protected override void AfterRunningAllTasks() { const long MaxDelayMilliseconds = int.MaxValue - 1; #if DEBUG base.AfterRunningAllTasks(); #endif if (IsShuttingDown) { // Immediate shutdown WakeUp(true); return; } var nextTimeout = InfiniteBreakoutTime; if (HasTasks) { nextTimeout = DefaultBreakoutTime; } else if (TryPeekScheduledTask(out IScheduledRunnable nextScheduledTask)) { long delayNanos = nextScheduledTask.DelayNanos; if ((ulong)delayNanos > 0UL) // delayNanos 为非负值 { var timeout = PreciseTime.ToMilliseconds(delayNanos); nextTimeout = Math.Min(timeout, MaxDelayMilliseconds); } else { nextTimeout = MinimumBreakoutTime; } } if ((ulong)nextTimeout > 0UL) // nextTimeout 为非负值 { _ = _timerHandle.Start(nextTimeout, 0); } }
public void TestGracefulShutdownQuietPeriod() { _loopA.ShutdownGracefullyAsync(TimeSpan.FromSeconds(1), TimeSpan.FromDays(1)); // Keep Scheduling tasks for another 2 seconds. for (int i = 0; i < 20; i++) { Thread.Sleep(100); _loopA.Execute(NOOP.Instance); } long startTime = PreciseTime.NanoTime(); Assert.True(_loopA.IsShuttingDown); Assert.False(_loopA.IsShutdown); while (!_loopA.IsTerminated) { _loopA.WaitTermination(TimeSpan.FromDays(1)); } Assert.True(PreciseTime.NanoTime() - startTime >= PreciseTime.ToDelayNanos(TimeSpan.FromSeconds(1))); }
protected bool FetchFromScheduledTaskQueue() { if (ScheduledTaskQueue.IsEmpty) { return(true); } var nanoTime = PreciseTime.NanoTime(); var scheduledTask = PollScheduledTask(nanoTime); var taskQueue = _taskQueue; while (scheduledTask is object) { if (!taskQueue.TryEnqueue(scheduledTask)) { // No space left in the task queue add it back to the scheduledTaskQueue so we pick it up again. _ = ScheduledTaskQueue.TryEnqueue(scheduledTask); return(false); } scheduledTask = PollScheduledTask(nanoTime); } return(true); }
public override Task ScheduleWithFixedDelayAsync(Action <object> action, object state, TimeSpan initialDelay, TimeSpan delay, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(TaskUtil.Cancelled); } if (!cancellationToken.CanBeCanceled) { return(ScheduleWithFixedDelay(action, state, initialDelay, delay).Completion); } if (action is null) { return(ThrowHelper.FromArgumentNullException(ExceptionArgument.action)); } if (delay <= TimeSpan.Zero) { return(ThrowHelper.FromArgumentException_DelayMustBeGreaterThanZero()); } return(Schedule(new StateActionScheduledAsyncTask(this, action, state, PreciseTime.DeadlineNanos(initialDelay), -PreciseTime.ToDelayNanos(delay), cancellationToken)).Completion); }
public override Task ScheduleAtFixedRateAsync(Action action, TimeSpan initialDelay, TimeSpan period, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(TaskUtil.Cancelled); } if (!cancellationToken.CanBeCanceled) { return(ScheduleAtFixedRate(action, initialDelay, period).Completion); } if (action is null) { return(ThrowHelper.FromArgumentNullException(ExceptionArgument.action)); } if (period <= TimeSpan.Zero) { return(ThrowHelper.FromArgumentException_PeriodMustBeGreaterThanZero()); } return(Schedule(new ActionScheduledAsyncTask(this, action, PreciseTime.DeadlineNanos(initialDelay), PreciseTime.ToDelayNanos(period), cancellationToken)).Completion); }
public void GracefulShutdownQuietPeriod() { Task task = this.eventLoop.ShutdownGracefullyAsync(TimeSpan.FromSeconds(1), TimeSpan.MaxValue); // Keep Scheduling tasks for another 2 seconds. for (int i = 0; i < 20; i++) { Thread.Sleep(100); this.eventLoop.Execute(new NoOp()); } long startTime = PreciseTime.NanoTime(); Assert.True(this.eventLoop.IsShuttingDown); Assert.False(this.eventLoop.IsShutdown); Assert.True(task.Wait(DefaultTimeout), "Loop shutdown timed out"); Assert.True(this.eventLoop.IsShuttingDown); Assert.True(this.eventLoop.IsShutdown); long duration = (long)PreciseTime.ToTimeSpan(PreciseTime.NanoTime() - startTime).TotalMilliseconds; Assert.True(duration >= 1000, $"Expecting shutdown quite period >= 1000 milliseconds, but was {duration}"); }
public void ScheduleTaskWithFixedDelay() { var timestamps = new BlockingCollection <long>(); int expectedTimeStamps = 3; var allTimeStampsLatch = new CountdownEvent(expectedTimeStamps); var f = this.eventLoop.ScheduleWithFixedDelay(() => { timestamps.Add(Stopwatch.GetTimestamp()); try { Thread.Sleep(51); } catch { } allTimeStampsLatch.Signal(); }, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100)); Assert.True(allTimeStampsLatch.Wait(TimeSpan.FromMinutes(1))); Assert.True(f.Cancel()); Thread.Sleep(300); Assert.Equal(expectedTimeStamps, timestamps.Count); // Check if the task was run without a lag. long?previousTimestamp = null; foreach (long t in timestamps) { if (previousTimestamp is null) { previousTimestamp = t; continue; } Assert.True(t - previousTimestamp.Value >= PreciseTime.ToDelayNanos(TimeSpan.FromMilliseconds(150))); previousTimestamp = t; } }
protected static long DeadlineToDelayNanos(long deadlineNanos) => PreciseTime.DeadlineToDelayNanos(deadlineNanos);
protected static long NanoTime() => PreciseTime.NanoTime();
protected virtual long GetTimeFromStart() { return(PreciseTime.NanoTime()); }
public override IScheduledTask ScheduleWithFixedDelay(Action <object, object> action, object context, object state, TimeSpan initialDelay, TimeSpan delay) { if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } if (delay <= TimeSpan.Zero) { ThrowHelper.ThrowArgumentException_DelayMustBeGreaterThanZero(); } return(Schedule(new StateActionWithContextScheduledTask(this, action, context, state, PreciseTime.DeadlineNanos(initialDelay), -PreciseTime.ToDelayNanos(delay)))); }
public override IScheduledTask ScheduleWithFixedDelay(IRunnable action, TimeSpan initialDelay, TimeSpan delay) { if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } if (delay <= TimeSpan.Zero) { ThrowHelper.ThrowArgumentException_DelayMustBeGreaterThanZero(); } return(Schedule(new RunnableScheduledTask(this, action, PreciseTime.DeadlineNanos(initialDelay), -PreciseTime.ToDelayNanos(delay)))); }
public override IScheduledTask ScheduleAtFixedRate(Action <object> action, object state, TimeSpan initialDelay, TimeSpan period) { if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } if (period <= TimeSpan.Zero) { ThrowHelper.ThrowArgumentException_PeriodMustBeGreaterThanZero(); } return(Schedule(new StateActionScheduledTask(this, action, state, PreciseTime.DeadlineNanos(initialDelay), PreciseTime.ToDelayNanos(period)))); }
public override IScheduledTask Schedule(Action <object, object> action, object context, object state, TimeSpan delay) { if (action is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action); } return(Schedule(new StateActionWithContextScheduledTask(this, action, context, state, PreciseTime.DeadlineNanos(delay)))); }
/// <summary> /// Returns <c>true</c> if a scheduled task is ready for processing. /// </summary> protected bool HasScheduledTasks() { return(ScheduledTaskQueue.TryPeek(out IScheduledRunnable scheduledTask) && scheduledTask.DeadlineNanos <= PreciseTime.NanoTime()); }
protected virtual long ToPreciseTime(TimeSpan time) { return(PreciseTime.TicksToPreciseTicks(time.Ticks)); }
private static PreciseTime m_preciseTime; // Precise time implementation. // Static Constructor static PrecisionTimer() { // Get multimedia timer capabilities timeGetDevCaps(ref m_capabilities, Marshal.SizeOf(m_capabilities)); // We just use the recommended synchronization period for general purpose TVA use m_preciseTime = new PreciseTime(10); }
// Initializes the the precise timing mechanism private static void InitializePreciseTime() { // We just use the recommended synchronization period for general purpose use const int synchronizationPeriod = 10; // Create a new precise time class s_preciseTime = new PreciseTime(synchronizationPeriod); // We setup a lightweight timer that will make sure precise time mechanism gets // called regularly, in case user doesn't, so it can maintain synchronization s_synchronizer = new Timer(synchronizationPeriod * 1000.0D); s_synchronizer.Elapsed += s_synchronizer_Elapsed; s_synchronizer.Start(); }