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 DeleteTimer(IOThreadTimer timer)
{
int index = timer._index;
Fx.Assert(index > 0, "");
Fx.Assert(index <= Count, "");
IOThreadTimer[] tempTimers = _timers;
while (true)
{
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 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 IotHubConnection(IotHubConnectionString connectionString, AccessRights accessRights)
{
this.connectionString = connectionString;
this.accessRights = accessRights;
this.faultTolerantSession = new FaultTolerantAmqpObject<AmqpSession>(this.CreateSessionAsync, this.CloseConnection);
this.refreshTokenTimer = new IOThreadTimer(s => ((IotHubConnection)s).OnRefreshToken(), this, false);
}
public void DeleteMinTimer()
{
IOThreadTimer minTimer = MinTimer;
DeleteMinTimerCore();
minTimer._index = 0;
minTimer._dueTime = 0;
}
public void DeleteMinTimer()
{
IOThreadTimer minTimer = this.MinTimer;
DeleteMinTimerCore();
minTimer.index = 0;
minTimer.dueTime = 0;
}
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 = _timers;
int index = Count + 1;
if (index == tempTimers.Length)
{
tempTimers = new IOThreadTimer[tempTimers.Length * 2];
Array.Copy(_timers, tempTimers, _timers.Length);
_timers = tempTimers;
}
Count = index;
if (index > 1)
{
while (true)
{
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 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 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 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();
}
}
}
}
}
}
private void DeleteMinTimerCore()
{
int currentCount = Count;
if (currentCount == 1)
{
Count = 0;
_timers[1] = null;
}
else
{
IOThreadTimer[] tempTimers = _timers;
IOThreadTimer lastTimer = tempTimers[currentCount];
Count = --currentCount;
int index = 1;
while (true)
{
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 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;
}
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;
}
}
}
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();
}
}
}
}
}
}