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);
}
