468 lines
15 KiB
C#
468 lines
15 KiB
C#
|
//------------------------------------------------------------
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//------------------------------------------------------------
|
||
|
|
namespace System.ServiceModel.Channels
|
||
|
|
{
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.Runtime;
|
||
|
|
using System.ServiceModel;
|
||
|
|
using System.ServiceModel.Description;
|
||
|
|
using System.Threading;
|
||
|
|
|
||
|
|
class UtilityExtension : IExtension<IPeerNeighbor>
|
||
|
|
{
|
||
|
|
uint linkUtility;
|
||
|
|
uint updateCount;
|
||
|
|
IOThreadTimer ackTimer;
|
||
|
|
const uint linkUtilityIncrement = 128;
|
||
|
|
const uint maxLinkUtility = 4096;
|
||
|
|
int outTotal;
|
||
|
|
uint inTotal;
|
||
|
|
uint inUseful;
|
||
|
|
IPeerNeighbor owner;
|
||
|
|
object thisLock = new object();
|
||
|
|
object throttleLock = new object();
|
||
|
|
public event EventHandler UtilityInfoReceived;
|
||
|
|
public event EventHandler UtilityInfoSent;
|
||
|
|
TypedMessageConverter messageConverter;
|
||
|
|
public const int AcceptableMissDistance = 2;
|
||
|
|
int pendingSends = 0;
|
||
|
|
int checkPointPendingSends = 0;
|
||
|
|
bool isMonitoring = false;
|
||
|
|
int expectedClearance;
|
||
|
|
IOThreadTimer pruneTimer;
|
||
|
|
const int PruneIntervalMilliseconds = 10000;
|
||
|
|
TimeSpan pruneInterval;
|
||
|
|
const int MinimumPendingMessages = 8;
|
||
|
|
public delegate void PruneNeighborCallback(IPeerNeighbor peer);
|
||
|
|
PruneNeighborCallback pruneNeighbor;
|
||
|
|
|
||
|
|
UtilityExtension()
|
||
|
|
{
|
||
|
|
ackTimer = new IOThreadTimer(new Action<object>(AcknowledgeLoop), null, false);
|
||
|
|
pendingSends = 0;
|
||
|
|
pruneTimer = new IOThreadTimer(new Action<object>(VerifyCheckPoint), null, false);
|
||
|
|
pruneInterval = TimeSpan.FromMilliseconds(PruneIntervalMilliseconds + new Random(Process.GetCurrentProcess().Id).Next(PruneIntervalMilliseconds));
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool IsAccurate
|
||
|
|
{
|
||
|
|
get { return updateCount >= 32; }
|
||
|
|
}
|
||
|
|
|
||
|
|
public uint LinkUtility
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
return linkUtility;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal TypedMessageConverter MessageConverter
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
if (messageConverter == null)
|
||
|
|
{
|
||
|
|
messageConverter = TypedMessageConverter.Create(typeof(UtilityInfo), PeerStrings.LinkUtilityAction);
|
||
|
|
}
|
||
|
|
return messageConverter;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void Attach(IPeerNeighbor host)
|
||
|
|
{
|
||
|
|
this.owner = host;
|
||
|
|
ackTimer.Set(PeerTransportConstants.AckTimeout);
|
||
|
|
}
|
||
|
|
|
||
|
|
static public void OnNeighborConnected(IPeerNeighbor neighbor)
|
||
|
|
{
|
||
|
|
Fx.Assert(neighbor != null, "Neighbor must have a value");
|
||
|
|
neighbor.Extensions.Add(new UtilityExtension());
|
||
|
|
}
|
||
|
|
|
||
|
|
static public void OnNeighborClosed(IPeerNeighbor neighbor)
|
||
|
|
{
|
||
|
|
Fx.Assert(neighbor != null, "Neighbor must have a value");
|
||
|
|
UtilityExtension ext = neighbor.Extensions.Find<UtilityExtension>();
|
||
|
|
if (ext != null) neighbor.Extensions.Remove(ext);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void Detach(IPeerNeighbor host)
|
||
|
|
{
|
||
|
|
ackTimer.Cancel();
|
||
|
|
owner = null;
|
||
|
|
|
||
|
|
lock (throttleLock)
|
||
|
|
{
|
||
|
|
pruneTimer.Cancel();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public object ThisLock
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
return thisLock;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void OnMessageSent(IPeerNeighbor neighbor)
|
||
|
|
{
|
||
|
|
UtilityExtension ext = neighbor.Extensions.Find<UtilityExtension>();
|
||
|
|
if (ext != null) ext.OnMessageSent();
|
||
|
|
}
|
||
|
|
|
||
|
|
void OnMessageSent()
|
||
|
|
{
|
||
|
|
lock (ThisLock)
|
||
|
|
{
|
||
|
|
outTotal++;
|
||
|
|
}
|
||
|
|
Interlocked.Increment(ref pendingSends);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void OnEndSend(IPeerNeighbor neighbor, FloodAsyncResult fresult)
|
||
|
|
{
|
||
|
|
if (neighbor.State >= PeerNeighborState.Disconnecting)
|
||
|
|
return;
|
||
|
|
UtilityExtension instance = neighbor.Utility;
|
||
|
|
if (instance == null)
|
||
|
|
return;
|
||
|
|
instance.OnEndSend(fresult);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void OnEndSend(FloodAsyncResult fresult)
|
||
|
|
{
|
||
|
|
Interlocked.Decrement(ref pendingSends);
|
||
|
|
}
|
||
|
|
|
||
|
|
void AcknowledgeLoop(object state)
|
||
|
|
{
|
||
|
|
IPeerNeighbor peer = owner;
|
||
|
|
if (peer == null || !peer.IsConnected)
|
||
|
|
return;
|
||
|
|
FlushAcknowledge();
|
||
|
|
if (owner != null)
|
||
|
|
ackTimer.Set(PeerTransportConstants.AckTimeout);
|
||
|
|
}
|
||
|
|
|
||
|
|
static public void ProcessLinkUtility(IPeerNeighbor neighbor, UtilityInfo umessage)
|
||
|
|
{
|
||
|
|
Fx.Assert(neighbor != null, "Neighbor must have a value");
|
||
|
|
UtilityExtension ext = neighbor.Extensions.Find<UtilityExtension>();
|
||
|
|
if (ext != null)
|
||
|
|
{
|
||
|
|
ext.ProcessLinkUtility(umessage.Useful, umessage.Total);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update link utility for the neighbor. received from the neighbor
|
||
|
|
void ProcessLinkUtility(uint useful, uint total)
|
||
|
|
{
|
||
|
|
uint i = 0;
|
||
|
|
lock (ThisLock)
|
||
|
|
{
|
||
|
|
if (total > PeerTransportConstants.AckWindow
|
||
|
|
|| useful > total
|
||
|
|
|| (uint)outTotal < total
|
||
|
|
)
|
||
|
|
{
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.PeerLinkUtilityInvalidValues, useful, total)));
|
||
|
|
}
|
||
|
|
|
||
|
|
//VERIFY with in this range, we are hoping that the order of useful/useless messages doesnt matter much.
|
||
|
|
for (i = 0; i < useful; i++)
|
||
|
|
{
|
||
|
|
this.linkUtility = Calculate(this.linkUtility, true);
|
||
|
|
}
|
||
|
|
for (; i < total; i++)
|
||
|
|
{
|
||
|
|
this.linkUtility = Calculate(this.linkUtility, false);
|
||
|
|
}
|
||
|
|
outTotal -= (int)total;
|
||
|
|
}
|
||
|
|
if (UtilityInfoReceived != null)
|
||
|
|
{
|
||
|
|
UtilityInfoReceived(this, EventArgs.Empty);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
uint Calculate(uint current, bool increase)
|
||
|
|
{
|
||
|
|
uint utility = 0;
|
||
|
|
// Refer to graph maintenance white paper for explanation of the formula
|
||
|
|
// used to compute utility index.
|
||
|
|
utility = (uint)current * 31 / 32;
|
||
|
|
if (increase)
|
||
|
|
utility += linkUtilityIncrement;
|
||
|
|
if (!(utility <= maxLinkUtility))
|
||
|
|
{
|
||
|
|
throw Fx.AssertAndThrow("Link utility should not exceed " + maxLinkUtility);
|
||
|
|
}
|
||
|
|
if (!IsAccurate)
|
||
|
|
++updateCount;
|
||
|
|
return utility;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static uint UpdateLinkUtility(IPeerNeighbor neighbor, bool useful)
|
||
|
|
{
|
||
|
|
Fx.Assert(neighbor != null, "Neighbor must have a value");
|
||
|
|
uint linkUtility = 0;
|
||
|
|
UtilityExtension ext = neighbor.Extensions.Find<UtilityExtension>();
|
||
|
|
if (ext != null)
|
||
|
|
{
|
||
|
|
// Can happen if the neighbor has been closed for instance
|
||
|
|
linkUtility = ext.UpdateLinkUtility(useful);
|
||
|
|
}
|
||
|
|
return linkUtility;
|
||
|
|
}
|
||
|
|
|
||
|
|
public uint UpdateLinkUtility(bool useful)
|
||
|
|
{
|
||
|
|
lock (ThisLock)
|
||
|
|
{
|
||
|
|
inTotal++;
|
||
|
|
if (useful)
|
||
|
|
inUseful++;
|
||
|
|
linkUtility = Calculate(linkUtility, useful);
|
||
|
|
if (inTotal == PeerTransportConstants.AckWindow)
|
||
|
|
{
|
||
|
|
FlushAcknowledge();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return linkUtility;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void FlushAcknowledge()
|
||
|
|
{
|
||
|
|
if (inTotal == 0)
|
||
|
|
return;
|
||
|
|
uint tempUseful = 0, tempTotal = 0;
|
||
|
|
lock (ThisLock)
|
||
|
|
{
|
||
|
|
tempUseful = inUseful;
|
||
|
|
tempTotal = inTotal;
|
||
|
|
inUseful = 0;
|
||
|
|
inTotal = 0;
|
||
|
|
}
|
||
|
|
SendUtilityMessage(tempUseful, tempTotal);
|
||
|
|
}
|
||
|
|
|
||
|
|
class AsyncUtilityState
|
||
|
|
{
|
||
|
|
public Message message;
|
||
|
|
public UtilityInfo info;
|
||
|
|
public AsyncUtilityState(Message message, UtilityInfo info)
|
||
|
|
{
|
||
|
|
this.message = message;
|
||
|
|
this.info = info;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void SendUtilityMessage(uint useful, uint total)
|
||
|
|
{
|
||
|
|
IPeerNeighbor host = owner;
|
||
|
|
if (host == null || !PeerNeighborStateHelper.IsConnected(host.State) || total == 0)
|
||
|
|
return;
|
||
|
|
UtilityInfo umessage = new UtilityInfo(useful, total);
|
||
|
|
IAsyncResult result = null;
|
||
|
|
Message message = MessageConverter.ToMessage(umessage, MessageVersion.Soap12WSAddressing10);
|
||
|
|
bool fatal = false;
|
||
|
|
try
|
||
|
|
{
|
||
|
|
result = host.BeginSend(message, Fx.ThunkCallback(new AsyncCallback(UtilityMessageSent)), new AsyncUtilityState(message, umessage));
|
||
|
|
if (result.CompletedSynchronously)
|
||
|
|
{
|
||
|
|
host.EndSend(result);
|
||
|
|
EventHandler handler = UtilityInfoSent;
|
||
|
|
if (handler != null)
|
||
|
|
handler(this, EventArgs.Empty);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e)
|
||
|
|
{
|
||
|
|
if (Fx.IsFatal(e))
|
||
|
|
{
|
||
|
|
fatal = true;
|
||
|
|
throw;
|
||
|
|
}
|
||
|
|
if (null != HandleSendException(host, e, umessage))
|
||
|
|
throw;
|
||
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
if (!fatal && (result == null || result.CompletedSynchronously))
|
||
|
|
message.Close();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void UtilityMessageSent(IAsyncResult result)
|
||
|
|
{
|
||
|
|
if (result == null || result.AsyncState == null)
|
||
|
|
return;
|
||
|
|
IPeerNeighbor host = this.owner;
|
||
|
|
if (host == null || !PeerNeighborStateHelper.IsConnected(host.State))
|
||
|
|
return;
|
||
|
|
if (result.CompletedSynchronously)
|
||
|
|
return;
|
||
|
|
|
||
|
|
AsyncUtilityState state = (AsyncUtilityState)result.AsyncState;
|
||
|
|
Fx.Assert(state != null, "IAsyncResult.AsyncState does not contain AsyncUtilityState");
|
||
|
|
Message message = state.message;
|
||
|
|
UtilityInfo umessage = state.info;
|
||
|
|
bool fatal = false;
|
||
|
|
if (!(umessage != null))
|
||
|
|
{
|
||
|
|
throw Fx.AssertAndThrow("expecting a UtilityInfo message in the AsyncState!");
|
||
|
|
}
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
host.EndSend(result);
|
||
|
|
}
|
||
|
|
catch (Exception e)
|
||
|
|
{
|
||
|
|
if (Fx.IsFatal(e))
|
||
|
|
{
|
||
|
|
fatal = true;
|
||
|
|
throw;
|
||
|
|
}
|
||
|
|
if (null != HandleSendException(host, e, umessage))
|
||
|
|
throw;
|
||
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
if (!fatal)
|
||
|
|
{
|
||
|
|
Fx.Assert(!result.CompletedSynchronously, "result.CompletedSynchronously");
|
||
|
|
message.Close();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EventHandler handler = UtilityInfoSent;
|
||
|
|
if (handler != null)
|
||
|
|
handler(this, EventArgs.Empty);
|
||
|
|
}
|
||
|
|
|
||
|
|
Exception HandleSendException(IPeerNeighbor host, Exception e, UtilityInfo umessage)
|
||
|
|
{
|
||
|
|
if ((e is ObjectDisposedException) ||
|
||
|
|
(e is TimeoutException) ||
|
||
|
|
(e is CommunicationException))
|
||
|
|
{
|
||
|
|
if (!(!(e.InnerException is QuotaExceededException)))
|
||
|
|
{
|
||
|
|
throw Fx.AssertAndThrow("insufficient quota for sending messages!");
|
||
|
|
}
|
||
|
|
lock (ThisLock)
|
||
|
|
{
|
||
|
|
this.inTotal += umessage.Total;
|
||
|
|
this.inUseful += umessage.Useful;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static internal void ReportCacheMiss(IPeerNeighbor neighbor, int missedBy)
|
||
|
|
{
|
||
|
|
Fx.Assert(missedBy > AcceptableMissDistance, "Call this method for cache misses ONLY!");
|
||
|
|
Fx.Assert(neighbor != null, "Neighbor must have a value");
|
||
|
|
|
||
|
|
if (!neighbor.IsConnected)
|
||
|
|
return;
|
||
|
|
UtilityExtension ext = neighbor.Extensions.Find<UtilityExtension>();
|
||
|
|
if (ext != null)
|
||
|
|
{
|
||
|
|
ext.ReportCacheMiss(missedBy);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ReportCacheMiss(int missedBy)
|
||
|
|
{
|
||
|
|
lock (ThisLock)
|
||
|
|
{
|
||
|
|
for (int i = 0; i < missedBy; i++)
|
||
|
|
{
|
||
|
|
this.linkUtility = Calculate(this.linkUtility, false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public int PendingMessages
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
return this.pendingSends;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void BeginCheckPoint(PruneNeighborCallback pruneCallback)
|
||
|
|
{
|
||
|
|
if (this.isMonitoring)
|
||
|
|
return;
|
||
|
|
|
||
|
|
lock (throttleLock)
|
||
|
|
{
|
||
|
|
if (this.isMonitoring)
|
||
|
|
return;
|
||
|
|
this.checkPointPendingSends = this.pendingSends;
|
||
|
|
this.pruneNeighbor = pruneCallback;
|
||
|
|
this.expectedClearance = this.pendingSends / 2;
|
||
|
|
this.isMonitoring = true;
|
||
|
|
if (owner == null)
|
||
|
|
return;
|
||
|
|
pruneTimer.Set(pruneInterval);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void VerifyCheckPoint(object state)
|
||
|
|
{
|
||
|
|
int lclPendingSends;
|
||
|
|
int lclCheckPointPendingSends;
|
||
|
|
IPeerNeighbor peer = (IPeerNeighbor)owner;
|
||
|
|
|
||
|
|
if (peer == null || !peer.IsConnected)
|
||
|
|
return;
|
||
|
|
|
||
|
|
lock (throttleLock)
|
||
|
|
{
|
||
|
|
lclPendingSends = this.pendingSends;
|
||
|
|
lclCheckPointPendingSends = this.checkPointPendingSends;
|
||
|
|
}
|
||
|
|
if (lclPendingSends <= MinimumPendingMessages)
|
||
|
|
{
|
||
|
|
lock (throttleLock)
|
||
|
|
{
|
||
|
|
isMonitoring = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (lclPendingSends + this.expectedClearance >= lclCheckPointPendingSends)
|
||
|
|
{
|
||
|
|
pruneNeighbor(peer);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
lock (throttleLock)
|
||
|
|
{
|
||
|
|
if (owner == null)
|
||
|
|
return;
|
||
|
|
this.checkPointPendingSends = this.pendingSends;
|
||
|
|
this.expectedClearance = this.expectedClearance / 2;
|
||
|
|
pruneTimer.Set(pruneInterval);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|