Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

655 lines
22 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.Runtime
{
using System;
using System.ComponentModel;
using System.Runtime.Interop;
using System.Security;
using System.Threading;
using Microsoft.Win32.SafeHandles;
// IOThreadTimer has several characterstics that are important for performance:
// - Timers that expire benefit from being scheduled to run on IO threads using IOThreadScheduler.Schedule.
// - The timer "waiter" thread thread is only allocated if there are set timers.
// - The timer waiter thread itself is an IO thread, which allows it to go away if there is no need for it,
// and allows it to be reused for other purposes.
// - After the timer count goes to zero, the timer waiter thread remains active for a bounded amount
// of time to wait for additional timers to be set.
// - Timers are stored in an array-based priority queue to reduce the amount of time spent in updates, and
// to always provide O(1) access to the minimum timer (the first one that will expire).
// - The standard textbook priority queue data structure is extended to allow efficient Delete in addition to
// DeleteMin for efficient handling of canceled timers.
// - Timers that are typically set, then immediately canceled (such as a retry timer,
// or a flush timer), are tracked separately from more stable timers, to avoid having
// to update the waitable timer in the typical case when a timer is canceled. Whether
// a timer instance follows this pattern is specified when the timer is constructed.
// - Extending a timer by a configurable time delta (maxSkew) does not involve updating the
// waitable timer, or taking a lock.
// - Timer instances are relatively cheap. They share "heavy" resources like the waiter thread and
// waitable timer handle.
// - Setting or canceling a timer does not typically involve any allocations.
class IOThreadTimer
{
const int maxSkewInMillisecondsDefault = 100;
static long systemTimeResolutionTicks = -1;
Action<object> callback;
object callbackState;
long dueTime;
int index;
long maxSkew;
TimerGroup timerGroup;
public IOThreadTimer(Action<object> callback, object callbackState, bool isTypicallyCanceledShortlyAfterBeingSet)
: this(callback, callbackState, isTypicallyCanceledShortlyAfterBeingSet, maxSkewInMillisecondsDefault)
{
}
public IOThreadTimer(Action<object> callback, object callbackState, bool isTypicallyCanceledShortlyAfterBeingSet, int maxSkewInMilliseconds)
{
this.callback = callback;
this.callbackState = callbackState;
this.maxSkew = Ticks.FromMilliseconds(maxSkewInMilliseconds);
this.timerGroup =
(isTypicallyCanceledShortlyAfterBeingSet ? TimerManager.Value.VolatileTimerGroup : TimerManager.Value.StableTimerGroup);
}
public static long SystemTimeResolutionTicks
{
get
{
if (IOThreadTimer.systemTimeResolutionTicks == -1)
{
IOThreadTimer.systemTimeResolutionTicks = GetSystemTimeResolution();
}
return IOThreadTimer.systemTimeResolutionTicks;
}
}
[Fx.Tag.SecurityNote(Critical = "Calls critical method GetSystemTimeAdjustment", Safe = "method is a SafeNativeMethod")]
[SecuritySafeCritical]
static long GetSystemTimeResolution()
{
int dummyAdjustment;
uint increment;
uint dummyAdjustmentDisabled;
if (UnsafeNativeMethods.GetSystemTimeAdjustment(out dummyAdjustment, out increment, out dummyAdjustmentDisabled) != 0)
{
return (long)increment;
}
// Assume the default, which is around 15 milliseconds.
return 15 * TimeSpan.TicksPerMillisecond;
}
public bool Cancel()
{
return TimerManager.Value.Cancel(this);
}
public void Set(TimeSpan timeFromNow)
{
if (timeFromNow != TimeSpan.MaxValue)
{
SetAt(Ticks.Add(Ticks.Now, Ticks.FromTimeSpan(timeFromNow)));
}
}
public void Set(int millisecondsFromNow)
{
SetAt(Ticks.Add(Ticks.Now, Ticks.FromMilliseconds(millisecondsFromNow)));
}
public void SetAt(long dueTime)
{
TimerManager.Value.Set(this, dueTime);
}
[Fx.Tag.SynchronizationObject(Blocking = false, Scope = Fx.Tag.Strings.AppDomain)]
class TimerManager
{
const long maxTimeToWaitForMoreTimers = 1000 * TimeSpan.TicksPerMillisecond;
[Fx.Tag.Queue(typeof(IOThreadTimer), Scope = Fx.Tag.Strings.AppDomain, StaleElementsRemovedImmediately = true)]
static TimerManager value = new TimerManager();
Action<object> onWaitCallback;
TimerGroup stableTimerGroup;
TimerGroup volatileTimerGroup;
[Fx.Tag.SynchronizationObject(Blocking = false)]
WaitableTimer[] waitableTimers;
bool waitScheduled;
public TimerManager()
{
this.onWaitCallback = new Action<object>(OnWaitCallback);
this.stableTimerGroup = new TimerGroup();
this.volatileTimerGroup = new TimerGroup();
this.waitableTimers = new WaitableTimer[] { this.stableTimerGroup.WaitableTimer, this.volatileTimerGroup.WaitableTimer };
}
object ThisLock
{
get { return this; }
}
public static TimerManager Value
{
get
{
return TimerManager.value;
}
}
public TimerGroup StableTimerGroup
{
get
{
return this.stableTimerGroup;
}
}
public TimerGroup VolatileTimerGroup
{
get
{
return this.volatileTimerGroup;
}
}
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;
}
}
}
void EnsureWaitScheduled()
{
if (!this.waitScheduled)
{
ScheduleWait();
}
}
TimerGroup GetOtherTimerGroup(TimerGroup timerGroup)
{
if (object.ReferenceEquals(timerGroup, this.volatileTimerGroup))
{
return this.stableTimerGroup;
}
else
{
return this.volatileTimerGroup;
}
}
void OnWaitCallback(object state)
{
WaitHandle.WaitAny(this.waitableTimers);
long now = Ticks.Now;
lock (ThisLock)
{
this.waitScheduled = false;
ScheduleElapsedTimers(now);
ReactivateWaitableTimers();
ScheduleWaitIfAnyTimersLeft();
}
}
void ReactivateWaitableTimers()
{
ReactivateWaitableTimer(this.stableTimerGroup);
ReactivateWaitableTimer(this.volatileTimerGroup);
}
void ReactivateWaitableTimer(TimerGroup timerGroup)
{
TimerQueue timerQueue = timerGroup.TimerQueue;
if (timerQueue.Count > 0)
{
timerGroup.WaitableTimer.Set(timerQueue.MinTimer.dueTime);
}
else
{
timerGroup.WaitableTimer.Set(long.MaxValue);
}
}
void ScheduleElapsedTimers(long now)
{
ScheduleElapsedTimers(this.stableTimerGroup, now);
ScheduleElapsedTimers(this.volatileTimerGroup, now);
}
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;
}
}
}
void ScheduleWait()
{
ActionItem.Schedule(this.onWaitCallback, null);
this.waitScheduled = true;
}
void ScheduleWaitIfAnyTimersLeft()
{
if (this.stableTimerGroup.TimerQueue.Count > 0 ||
this.volatileTimerGroup.TimerQueue.Count > 0)
{
ScheduleWait();
}
}
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);
}
}
}
class TimerGroup
{
TimerQueue timerQueue;
WaitableTimer waitableTimer;
public TimerGroup()
{
this.waitableTimer = new WaitableTimer();
this.waitableTimer.Set(long.MaxValue);
this.timerQueue = new TimerQueue();
}
public TimerQueue TimerQueue
{
get
{
return this.timerQueue;
}
}
public WaitableTimer WaitableTimer
{
get
{
return this.waitableTimer;
}
}
}
class TimerQueue
{
int count;
IOThreadTimer[] timers;
public TimerQueue()
{
this.timers = new IOThreadTimer[4];
}
public int Count
{
get { return count; }
}
public IOThreadTimer MinTimer
{
get
{
Fx.Assert(this.count > 0, "Should have at least one timer in our queue.");
return timers[1];
}
}
public void DeleteMinTimer()
{
IOThreadTimer minTimer = this.MinTimer;
DeleteMinTimerCore();
minTimer.index = 0;
minTimer.dueTime = 0;
}
public void DeleteTimer(IOThreadTimer timer)
{
int index = timer.index;
Fx.Assert(index > 0, "");
Fx.Assert(index <= this.count, "");
IOThreadTimer[] timers = this.timers;
for (;;)
{
int parentIndex = index / 2;
if (parentIndex >= 1)
{
IOThreadTimer parentTimer = timers[parentIndex];
timers[index] = parentTimer;
parentTimer.index = index;
}
else
{
break;
}
index = parentIndex;
}
timer.index = 0;
timer.dueTime = 0;
timers[1] = null;
DeleteMinTimerCore();
}
public bool InsertTimer(IOThreadTimer timer, long dueTime)
{
Fx.Assert(timer.index == 0, "Timer should not have an index.");
IOThreadTimer[] timers = this.timers;
int index = this.count + 1;
if (index == timers.Length)
{
timers = new IOThreadTimer[timers.Length * 2];
Array.Copy(this.timers, timers, this.timers.Length);
this.timers = timers;
}
this.count = index;
if (index > 1)
{
for (;;)
{
int parentIndex = index / 2;
if (parentIndex == 0)
{
break;
}
IOThreadTimer parent = timers[parentIndex];
if (parent.dueTime > dueTime)
{
timers[index] = parent;
parent.index = index;
index = parentIndex;
}
else
{
break;
}
}
}
timers[index] = timer;
timer.index = index;
timer.dueTime = dueTime;
return index == 1;
}
public bool UpdateTimer(IOThreadTimer timer, long dueTime)
{
int index = timer.index;
IOThreadTimer[] timers = this.timers;
int count = this.count;
Fx.Assert(index > 0, "");
Fx.Assert(index <= count, "");
int parentIndex = index / 2;
if (parentIndex == 0 ||
timers[parentIndex].dueTime <= dueTime)
{
int leftChildIndex = index * 2;
if (leftChildIndex > count ||
timers[leftChildIndex].dueTime >= dueTime)
{
int rightChildIndex = leftChildIndex + 1;
if (rightChildIndex > count ||
timers[rightChildIndex].dueTime >= dueTime)
{
timer.dueTime = dueTime;
return index == 1;
}
}
}
DeleteTimer(timer);
InsertTimer(timer, dueTime);
return true;
}
void DeleteMinTimerCore()
{
int count = this.count;
if (count == 1)
{
this.count = 0;
this.timers[1] = null;
}
else
{
IOThreadTimer[] timers = this.timers;
IOThreadTimer lastTimer = timers[count];
this.count = --count;
int index = 1;
for (;;)
{
int leftChildIndex = index * 2;
if (leftChildIndex > count)
{
break;
}
int childIndex;
IOThreadTimer child;
if (leftChildIndex < count)
{
IOThreadTimer leftChild = timers[leftChildIndex];
int rightChildIndex = leftChildIndex + 1;
IOThreadTimer rightChild = timers[rightChildIndex];
if (rightChild.dueTime < leftChild.dueTime)
{
child = rightChild;
childIndex = rightChildIndex;
}
else
{
child = leftChild;
childIndex = leftChildIndex;
}
}
else
{
childIndex = leftChildIndex;
child = timers[childIndex];
}
if (lastTimer.dueTime > child.dueTime)
{
timers[index] = child;
child.index = index;
}
else
{
break;
}
index = childIndex;
if (leftChildIndex >= count)
{
break;
}
}
timers[index] = lastTimer;
lastTimer.index = index;
timers[count + 1] = null;
}
}
}
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.NonBlocking)]
class WaitableTimer : WaitHandle
{
long dueTime;
[Fx.Tag.SecurityNote(Critical = "Call the critical CreateWaitableTimer method in TimerHelper",
Safe = "Doesn't leak information or resources")]
[SecuritySafeCritical]
public WaitableTimer()
{
this.SafeWaitHandle = TimerHelper.CreateWaitableTimer();
}
public long DueTime
{
get { return this.dueTime; }
}
[Fx.Tag.SecurityNote(Critical = "Call the critical Set method in TimerHelper",
Safe = "Doesn't leak information or resources")]
[SecuritySafeCritical]
public void Set(long dueTime)
{
this.dueTime = TimerHelper.Set(this.SafeWaitHandle, dueTime);
}
[Fx.Tag.SecurityNote(Critical = "Provides a set of unsafe methods used to work with the WaitableTimer")]
[SecurityCritical]
static class TimerHelper
{
public static unsafe SafeWaitHandle CreateWaitableTimer()
{
SafeWaitHandle handle = UnsafeNativeMethods.CreateWaitableTimer(IntPtr.Zero, false, null);
if (handle.IsInvalid)
{
Exception exception = new Win32Exception();
handle.SetHandleAsInvalid();
throw Fx.Exception.AsError(exception);
}
return handle;
}
public static unsafe long Set(SafeWaitHandle timer, long dueTime)
{
if (!UnsafeNativeMethods.SetWaitableTimer(timer, ref dueTime, 0, IntPtr.Zero, IntPtr.Zero, false))
{
throw Fx.Exception.AsError(new Win32Exception());
}
return dueTime;
}
}
}
}
}