public bool UpdateTimer(IOThreadTimer timer, long newDueTime) { int num = timer.index; IOThreadTimer[] oThreadTimerArray = this.timers; int num1 = this.count; int num2 = num / 2; if (num2 == 0 || oThreadTimerArray[num2].dueTime <= newDueTime) { int num3 = num * 2; if (num3 > num1 || oThreadTimerArray[num3].dueTime >= newDueTime) { int num4 = num3 + 1; if (num4 > num1 || oThreadTimerArray[num4].dueTime >= newDueTime) { timer.dueTime = newDueTime; return(num == 1); } } } this.DeleteTimer(timer); this.InsertTimer(timer, newDueTime); return(true); }
public void Set(IOThreadTimer timer, long dueTime) { long num = dueTime - timer.dueTime; if (num < (long)0) { num = -num; } if (num > timer.maxSkew) { lock (this.ThisLock) { IOThreadTimer.TimerGroup timerGroup = timer.timerGroup; IOThreadTimer.TimerQueue timerQueue = timerGroup.TimerQueue; if (timer.index > 0) { if (timerQueue.UpdateTimer(timer, dueTime)) { IOThreadTimer.TimerManager.UpdateWaitableTimer(timerGroup); } } else if (timerQueue.InsertTimer(timer, dueTime)) { IOThreadTimer.TimerManager.UpdateWaitableTimer(timerGroup); if (timerQueue.Count == 1) { this.EnsureWaitScheduled(); } } } } }
public bool UpdateTimer(IOThreadTimer timer, long newDueTime) { int index = timer.index; IOThreadTimer[] tempTimers = this.timers; int tempCount = this.count; Fx.Assert(index > 0, ""); Fx.Assert(index <= tempCount, ""); int parentIndex = index / 2; if (parentIndex == 0 || tempTimers[parentIndex].dueTime <= newDueTime) { int leftChildIndex = index * 2; if (leftChildIndex > tempCount || tempTimers[leftChildIndex].dueTime >= newDueTime) { int rightChildIndex = leftChildIndex + 1; if (rightChildIndex > tempCount || tempTimers[rightChildIndex].dueTime >= newDueTime) { timer.dueTime = newDueTime; return(index == 1); } } } DeleteTimer(timer); InsertTimer(timer, newDueTime); return(true); }
public void DeleteTimer(IOThreadTimer timer) { int index = timer.index; Fx.Assert(index > 0, ""); Fx.Assert(index <= this.count, ""); IOThreadTimer[] tempTimers = this.timers; for (;;) { int parentIndex = index / 2; if (parentIndex >= 1) { IOThreadTimer parentTimer = tempTimers[parentIndex]; tempTimers[index] = parentTimer; parentTimer.index = index; } else { break; } index = parentIndex; } timer.index = 0; timer.dueTime = 0; tempTimers[1] = null; DeleteMinTimerCore(); }
public void DeleteMinTimer() { IOThreadTimer minTimer = this.MinTimer; DeleteMinTimerCore(); minTimer.index = 0; minTimer.dueTime = 0; }
public AsyncQueueWaiter(TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { if (timeout != TimeSpan.MaxValue) { this.timer = new IOThreadTimer(InputQueue <T> .AsyncQueueWaiter.timerCallback, this, false); this.timer.Set(timeout); } }
public void CancelTimer() { if (this.timer != null) { this.timer.Cancel(); this.timer = null; } }
public void SetTimer(Action <object> timerCallback, object timerState, TimeSpan timeout) { if (this.timer != null) { throw Fx.Exception.AsError(new InvalidOperationException(SRCore.MustCancelOldTimer), null); } this.originalTimeout = timeout; this.timer = new IOThreadTimer(timerCallback, timerState, false); this.timer.Set(timeout); }
public AsyncQueueReader(InputQueue <T> inputQueue, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { if (inputQueue.AsyncCallbackGenerator != null) { base.VirtualCallback = new Action <AsyncCallback, IAsyncResult>(inputQueue.AsyncCallbackGenerator().Invoke); } this.inputQueue = inputQueue; if (timeout != TimeSpan.MaxValue) { this.timer = new IOThreadTimer(InputQueue <T> .AsyncQueueReader.timerCallback, this, false); this.timer.Set(timeout); } }
private static void ScheduleElapsedTimers(IOThreadTimer.TimerGroup timerGroup, long now) { IOThreadTimer.TimerQueue timerQueue = timerGroup.TimerQueue; while (timerQueue.Count > 0) { IOThreadTimer minTimer = timerQueue.MinTimer; if (minTimer.dueTime - now > minTimer.maxSkew) { break; } timerQueue.DeleteMinTimer(); ActionItem.Schedule(minTimer.callback, minTimer.callbackState); } }
private static void UpdateWaitableTimer(IOThreadTimer.TimerGroup timerGroup) { IOThreadTimer.WaitableTimer waitableTimer = timerGroup.WaitableTimer; IOThreadTimer minTimer = timerGroup.TimerQueue.MinTimer; long dueTime = waitableTimer.DueTime - minTimer.dueTime; if (dueTime < (long)0) { dueTime = -dueTime; } if (dueTime > minTimer.maxSkew) { waitableTimer.Set(minTimer.dueTime); } }
static void UpdateWaitableTimer(TimerGroup timerGroup) { WaitableTimer waitableTimer = timerGroup.WaitableTimer; IOThreadTimer minTimer = timerGroup.TimerQueue.MinTimer; long timeDiff = waitableTimer.DueTime - minTimer.dueTime; if (timeDiff < 0) { timeDiff = -timeDiff; } if (timeDiff > minTimer.maxSkew) { waitableTimer.Set(minTimer.dueTime); } }
public bool InsertTimer(IOThreadTimer timer, long dueTime) { Fx.Assert(timer.index == 0, "Timer should not have an index."); IOThreadTimer[] tempTimers = this.timers; int index = this.count + 1; if (index == tempTimers.Length) { tempTimers = new IOThreadTimer[tempTimers.Length * 2]; Array.Copy(this.timers, tempTimers, this.timers.Length); this.timers = tempTimers; } this.count = index; if (index > 1) { for (;;) { int parentIndex = index / 2; if (parentIndex == 0) { break; } IOThreadTimer parent = tempTimers[parentIndex]; if (parent.dueTime > dueTime) { tempTimers[index] = parent; parent.index = index; index = parentIndex; } else { break; } } } tempTimers[index] = timer; timer.index = index; timer.dueTime = dueTime; return(index == 1); }
static void ScheduleElapsedTimers(TimerGroup timerGroup, long now) { TimerQueue timerQueue = timerGroup.TimerQueue; while (timerQueue.Count > 0) { IOThreadTimer timer = timerQueue.MinTimer; long timeDiff = timer.dueTime - now; if (timeDiff <= timer.maxSkew) { timerQueue.DeleteMinTimer(); ActionItem.Schedule(timer.callback, timer.callbackState); } else { break; } } }
public void DeleteTimer(IOThreadTimer timer) { int num = timer.index; IOThreadTimer[] oThreadTimerArray = this.timers; while (true) { int num1 = num / 2; if (num1 < 1) { break; } IOThreadTimer oThreadTimer = oThreadTimerArray[num1]; oThreadTimerArray[num] = oThreadTimer; oThreadTimer.index = num; num = num1; } timer.index = 0; timer.dueTime = (long)0; oThreadTimerArray[1] = null; this.DeleteMinTimerCore(); }
public bool Cancel(IOThreadTimer timer) { lock (ThisLock) { if (timer.index > 0) { TimerGroup timerGroup = timer.timerGroup; TimerQueue timerQueue = timerGroup.TimerQueue; timerQueue.DeleteTimer(timer); if (timerQueue.Count > 0) { UpdateWaitableTimer(timerGroup); } else { TimerGroup otherTimerGroup = GetOtherTimerGroup(timerGroup); if (otherTimerGroup.TimerQueue.Count == 0) { long now = Ticks.Now; long thisGroupRemainingTime = timerGroup.WaitableTimer.DueTime - now; long otherGroupRemainingTime = otherTimerGroup.WaitableTimer.DueTime - now; if (thisGroupRemainingTime > maxTimeToWaitForMoreTimers && otherGroupRemainingTime > maxTimeToWaitForMoreTimers) { timerGroup.WaitableTimer.Set(Ticks.Add(now, maxTimeToWaitForMoreTimers)); } } } return(true); } else { return(false); } } }
public bool Cancel(IOThreadTimer timer) { bool flag; lock (this.ThisLock) { if (timer.index <= 0) { flag = false; } else { IOThreadTimer.TimerGroup timerGroup = timer.timerGroup; IOThreadTimer.TimerQueue timerQueue = timerGroup.TimerQueue; timerQueue.DeleteTimer(timer); if (timerQueue.Count <= 0) { IOThreadTimer.TimerGroup otherTimerGroup = this.GetOtherTimerGroup(timerGroup); if (otherTimerGroup.TimerQueue.Count == 0) { long now = Ticks.Now; long dueTime = timerGroup.WaitableTimer.DueTime - now; long num = otherTimerGroup.WaitableTimer.DueTime - now; if (dueTime > (long)10000000 && num > (long)10000000) { timerGroup.WaitableTimer.Set(Ticks.Add(now, (long)10000000)); } } } else { IOThreadTimer.TimerManager.UpdateWaitableTimer(timerGroup); } flag = true; } } return(flag); }
public void Set(IOThreadTimer timer, long dueTime) { long timeDiff = dueTime - timer.dueTime; if (timeDiff < 0) { timeDiff = -timeDiff; } if (timeDiff > timer.maxSkew) { lock (ThisLock) { TimerGroup timerGroup = timer.timerGroup; TimerQueue timerQueue = timerGroup.TimerQueue; if (timer.index > 0) { if (timerQueue.UpdateTimer(timer, dueTime)) { UpdateWaitableTimer(timerGroup); } } else { if (timerQueue.InsertTimer(timer, dueTime)) { UpdateWaitableTimer(timerGroup); if (timerQueue.Count == 1) { EnsureWaitScheduled(); } } } } } }
public bool InsertTimer(IOThreadTimer timer, long dueTime) { IOThreadTimer[] oThreadTimerArray = this.timers; int num = this.count + 1; if (num == (int)oThreadTimerArray.Length) { oThreadTimerArray = new IOThreadTimer[(int)oThreadTimerArray.Length * 2]; Array.Copy(this.timers, oThreadTimerArray, (int)this.timers.Length); this.timers = oThreadTimerArray; } this.count = num; if (num > 1) { while (true) { int num1 = num / 2; if (num1 == 0) { break; } IOThreadTimer oThreadTimer = oThreadTimerArray[num1]; if (oThreadTimer.dueTime <= dueTime) { break; } oThreadTimerArray[num] = oThreadTimer; oThreadTimer.index = num; num = num1; } } oThreadTimerArray[num] = timer; timer.index = num; timer.dueTime = dueTime; return(num == 1); }
void OnReceiveOpen(Open open) { Action<Open> openCallback = this.Settings.OnOpenCallback; if (openCallback != null) { openCallback(open); } this.Negotiate(open); StateTransition stateTransition; this.TransitState("R:OPEN", StateTransition.ReceiveOpen, out stateTransition); if (stateTransition.To == AmqpObjectState.OpenReceived) { this.SendOpen(); } if (this.isInitiator && this.Settings.IdleTimeOut.Value != uint.MaxValue) { this.heartBeatInterval = (int)(this.Settings.IdleTimeOut.Value * 3 / 8); if (this.heartBeatInterval < 500) { this.heartBeatInterval = 500; } this.heartBeatTimer = new IOThreadTimer(OnHeartBeatTimer, this, false); this.heartBeatTimer.Set(this.heartBeatInterval); Utils.Trace(TraceLevel.Info, "{0}: enabled heart beat timer ({1}ms)", this, this.heartBeatInterval); } this.CompleteOpen(stateTransition.From == AmqpObjectState.Start, null); }
public TimeoutAsyncResult(TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { if (timeout != TimeSpan.MaxValue) { this.timer = new IOThreadTimer(timerCallback, this, true); this.timer.Set(timeout); } }
void DeleteMinTimerCore() { int currentCount = this.count; if (currentCount == 1) { this.count = 0; this.timers[1] = null; } else { IOThreadTimer[] tempTimers = this.timers; IOThreadTimer lastTimer = tempTimers[currentCount]; this.count = --currentCount; int index = 1; for (;;) { int leftChildIndex = index * 2; if (leftChildIndex > currentCount) { break; } int childIndex; IOThreadTimer child; if (leftChildIndex < currentCount) { IOThreadTimer leftChild = tempTimers[leftChildIndex]; int rightChildIndex = leftChildIndex + 1; IOThreadTimer rightChild = tempTimers[rightChildIndex]; if (rightChild.dueTime < leftChild.dueTime) { child = rightChild; childIndex = rightChildIndex; } else { child = leftChild; childIndex = leftChildIndex; } } else { childIndex = leftChildIndex; child = tempTimers[childIndex]; } if (lastTimer.dueTime > child.dueTime) { tempTimers[index] = child; child.index = index; } else { break; } index = childIndex; if (leftChildIndex >= currentCount) { break; } } tempTimers[index] = lastTimer; lastTimer.index = index; tempTimers[currentCount + 1] = null; } }
public void Set(IOThreadTimer timer, long dueTime) { long timeDiff = dueTime - timer.dueTime; if (timeDiff < 0) { timeDiff = -timeDiff; } if (timeDiff > timer.maxSkew) { lock (ThisLock) { TimerGroup timerGroup = timer.timerGroup; TimerQueue timerQueue = timerGroup.TimerQueue; if (timer.index > 0) { if (timerQueue.UpdateTimer(timer, dueTime)) { UpdateWaitableTimer(timerGroup); } } else { if (timerQueue.InsertTimer(timer, dueTime)) { UpdateWaitableTimer(timerGroup); if (timerQueue.Count == 1) { EnsureWaitScheduled(); } } } } } }
public bool Cancel(IOThreadTimer timer) { lock (ThisLock) { if (timer.index > 0) { TimerGroup timerGroup = timer.timerGroup; TimerQueue timerQueue = timerGroup.TimerQueue; timerQueue.DeleteTimer(timer); if (timerQueue.Count > 0) { UpdateWaitableTimer(timerGroup); } else { TimerGroup otherTimerGroup = GetOtherTimerGroup(timerGroup); if (otherTimerGroup.TimerQueue.Count == 0) { long now = Ticks.Now; long thisGroupRemainingTime = timerGroup.WaitableTimer.DueTime - now; long otherGroupRemainingTime = otherTimerGroup.WaitableTimer.DueTime - now; if (thisGroupRemainingTime > maxTimeToWaitForMoreTimers && otherGroupRemainingTime > maxTimeToWaitForMoreTimers) { timerGroup.WaitableTimer.Set(Ticks.Add(now, maxTimeToWaitForMoreTimers)); } } } return true; } else { return false; } } }
public void DeleteTimer(IOThreadTimer timer) { int index = timer.index; Fx.Assert(index > 0, ""); Fx.Assert(index <= this.count, ""); IOThreadTimer[] tempTimers = this.timers; for (;;) { int parentIndex = index / 2; if (parentIndex >= 1) { IOThreadTimer parentTimer = tempTimers[parentIndex]; tempTimers[index] = parentTimer; parentTimer.index = index; } else { break; } index = parentIndex; } timer.index = 0; timer.dueTime = 0; tempTimers[1] = null; DeleteMinTimerCore(); }
public bool InsertTimer(IOThreadTimer timer, long dueTime) { Fx.Assert(timer.index == 0, "Timer should not have an index."); IOThreadTimer[] tempTimers = this.timers; int index = this.count + 1; if (index == tempTimers.Length) { tempTimers = new IOThreadTimer[tempTimers.Length * 2]; Array.Copy(this.timers, tempTimers, this.timers.Length); this.timers = tempTimers; } this.count = index; if (index > 1) { for (;;) { int parentIndex = index / 2; if (parentIndex == 0) { break; } IOThreadTimer parent = tempTimers[parentIndex]; if (parent.dueTime > dueTime) { tempTimers[index] = parent; parent.index = index; index = parentIndex; } else { break; } } } tempTimers[index] = timer; timer.index = index; timer.dueTime = dueTime; return index == 1; }
public bool UpdateTimer(IOThreadTimer timer, long newDueTime) { int index = timer.index; IOThreadTimer[] tempTimers = this.timers; int tempCount = this.count; Fx.Assert(index > 0, ""); Fx.Assert(index <= tempCount, ""); int parentIndex = index / 2; if (parentIndex == 0 || tempTimers[parentIndex].dueTime <= newDueTime) { int leftChildIndex = index * 2; if (leftChildIndex > tempCount || tempTimers[leftChildIndex].dueTime >= newDueTime) { int rightChildIndex = leftChildIndex + 1; if (rightChildIndex > tempCount || tempTimers[rightChildIndex].dueTime >= newDueTime) { timer.dueTime = newDueTime; return index == 1; } } } DeleteTimer(timer); InsertTimer(timer, newDueTime); return true; }
private void DeleteMinTimerCore() { int num; int num1; IOThreadTimer oThreadTimer; int num2 = this.count; if (num2 == 1) { this.count = 0; this.timers[1] = null; return; } IOThreadTimer[] oThreadTimerArray = this.timers; IOThreadTimer oThreadTimer1 = oThreadTimerArray[num2]; int num3 = num2 - 1; num2 = num3; this.count = num3; int num4 = 1; do { num = num4 * 2; if (num > num2) { break; } if (num >= num2) { num1 = num; oThreadTimer = oThreadTimerArray[num1]; } else { IOThreadTimer oThreadTimer2 = oThreadTimerArray[num]; int num5 = num + 1; IOThreadTimer oThreadTimer3 = oThreadTimerArray[num5]; if (oThreadTimer3.dueTime >= oThreadTimer2.dueTime) { oThreadTimer = oThreadTimer2; num1 = num; } else { oThreadTimer = oThreadTimer3; num1 = num5; } } if (oThreadTimer1.dueTime <= oThreadTimer.dueTime) { break; } oThreadTimerArray[num4] = oThreadTimer; oThreadTimer.index = num4; num4 = num1; }while (num < num2); oThreadTimerArray[num4] = oThreadTimer1; oThreadTimer1.index = num4; oThreadTimerArray[num2 + 1] = null; }
public void StartTimer(LinkedListNode <AsyncSemaphore.SemaphoreWaiter> node) { this.Node = node; this.timer = new IOThreadTimer(AsyncSemaphore.SemaphoreWaiter.OnTimeoutElapsedStaticDelegate, this, true); this.timer.SetIfValid(this.timeout); }
public void Initialize(LinkedListNode<ReceiveAsyncResult> node) { this.node = node; if (this.timeout != TimeSpan.MaxValue) { timer = new IOThreadTimer(onTimer, this, false); timer.Set(timeout); } }
public SessionChannel(AmqpSession session, int bufferSize) { this.session = session; this.nextDeliveryId = session.settings.InitialDeliveryId; this.unsettledLwm = this.nextDeliveryId; this.deliveryBuffer = new Delivery[Math.Min(bufferSize, SessionChannel.MaxBuferSize)]; this.dispositionTimer = new IOThreadTimer(DispositionTimerCallback, this, false); this.syncRoot = new object(); int defaultThreshold = this.deliveryBuffer.Length * 2 / 3; this.dispositionThreshold = session.settings.DispositionThreshold == 0 ? defaultThreshold : Math.Min(session.settings.DispositionThreshold, defaultThreshold); Utils.Trace(TraceLevel.Verbose, "{0}: buffer-size:{1}, disposition-threshold:{2}.", this, this.deliveryBuffer.Length, this.dispositionThreshold); }