mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
1161 lines
39 KiB
C#
1161 lines
39 KiB
C#
//----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
|
|
struct MessageAttemptInfo
|
|
{
|
|
readonly Message message;
|
|
readonly int retryCount;
|
|
readonly Int64 sequenceNumber;
|
|
readonly object state;
|
|
|
|
public MessageAttemptInfo(Message message, Int64 sequenceNumber, int retryCount, object state)
|
|
{
|
|
this.message = message;
|
|
this.sequenceNumber = sequenceNumber;
|
|
this.retryCount = retryCount;
|
|
this.state = state;
|
|
}
|
|
public Message Message
|
|
{
|
|
get { return this.message; }
|
|
}
|
|
|
|
public int RetryCount
|
|
{
|
|
get { return this.retryCount; }
|
|
}
|
|
|
|
public object State
|
|
{
|
|
get { return this.state; }
|
|
}
|
|
|
|
public Int64 GetSequenceNumber()
|
|
{
|
|
if (this.sequenceNumber <= 0)
|
|
{
|
|
throw Fx.AssertAndThrow("The caller is not allowed to get an invalid SequenceNumber.");
|
|
}
|
|
|
|
return this.sequenceNumber;
|
|
}
|
|
}
|
|
|
|
sealed class TransmissionStrategy
|
|
{
|
|
bool aborted;
|
|
bool closed;
|
|
int congestionControlModeAcks;
|
|
UniqueId id;
|
|
Int64 last = 0;
|
|
int lossWindowSize;
|
|
int maxWindowSize;
|
|
Int64 meanRtt;
|
|
ComponentExceptionHandler onException;
|
|
Int32 quotaRemaining;
|
|
ReliableMessagingVersion reliableMessagingVersion;
|
|
List<Int64> retransmissionWindow = new List<Int64>();
|
|
IOThreadTimer retryTimer;
|
|
RetryHandler retryTimeoutElapsedHandler;
|
|
bool requestAcks;
|
|
Int64 serrRtt;
|
|
int slowStartThreshold;
|
|
bool startup = true;
|
|
object thisLock = new object();
|
|
Int64 timeout;
|
|
Queue<IQueueAdder> waitQueue = new Queue<IQueueAdder>();
|
|
SlidingWindow window;
|
|
int windowSize = 1;
|
|
Int64 windowStart = 1;
|
|
|
|
public TransmissionStrategy(ReliableMessagingVersion reliableMessagingVersion, TimeSpan initRtt,
|
|
int maxWindowSize, bool requestAcks, UniqueId id)
|
|
{
|
|
if (initRtt < TimeSpan.Zero)
|
|
{
|
|
if (DiagnosticUtility.ShouldTrace(TraceEventType.Warning))
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WsrmNegativeElapsedTimeDetected,
|
|
SR.GetString(SR.TraceCodeWsrmNegativeElapsedTimeDetected), this);
|
|
}
|
|
|
|
initRtt = ReliableMessagingConstants.UnknownInitiationTime;
|
|
}
|
|
|
|
if (maxWindowSize <= 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument maxWindow size must be positive.");
|
|
}
|
|
|
|
this.id = id;
|
|
this.maxWindowSize = this.lossWindowSize = maxWindowSize;
|
|
this.meanRtt = Math.Min((long)initRtt.TotalMilliseconds, Constants.MaxMeanRtt >> Constants.TimeMultiplier) << Constants.TimeMultiplier;
|
|
this.serrRtt = this.meanRtt >> 1;
|
|
this.window = new SlidingWindow(maxWindowSize);
|
|
this.slowStartThreshold = maxWindowSize;
|
|
this.timeout = Math.Max(((200 << Constants.TimeMultiplier) * 2) + this.meanRtt, this.meanRtt + (this.serrRtt << Constants.ChebychevFactor));
|
|
this.quotaRemaining = Int32.MaxValue;
|
|
this.retryTimer = new IOThreadTimer(new Action<object>(OnRetryElapsed), null, true);
|
|
this.requestAcks = requestAcks;
|
|
this.reliableMessagingVersion = reliableMessagingVersion;
|
|
}
|
|
|
|
public bool DoneTransmitting
|
|
{
|
|
get
|
|
{
|
|
return (this.last != 0 && this.windowStart == this.last + 1);
|
|
}
|
|
}
|
|
|
|
public bool HasPending
|
|
{
|
|
get
|
|
{
|
|
return (this.window.Count > 0 || this.waitQueue.Count > 0);
|
|
}
|
|
}
|
|
|
|
public Int64 Last
|
|
{
|
|
get
|
|
{
|
|
return this.last;
|
|
}
|
|
}
|
|
|
|
// now in 128ths of a millisecond.
|
|
static Int64 Now
|
|
{
|
|
get
|
|
{
|
|
return (Ticks.Now / TimeSpan.TicksPerMillisecond) << Constants.TimeMultiplier;
|
|
}
|
|
}
|
|
|
|
public ComponentExceptionHandler OnException
|
|
{
|
|
set
|
|
{
|
|
this.onException = value;
|
|
}
|
|
}
|
|
|
|
public RetryHandler RetryTimeoutElapsed
|
|
{
|
|
set
|
|
{
|
|
this.retryTimeoutElapsedHandler = value;
|
|
}
|
|
}
|
|
|
|
public int QuotaRemaining
|
|
{
|
|
get
|
|
{
|
|
return this.quotaRemaining;
|
|
}
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this.thisLock;
|
|
}
|
|
}
|
|
|
|
public int Timeout
|
|
{
|
|
get
|
|
{
|
|
return (int)(this.timeout >> Constants.TimeMultiplier);
|
|
}
|
|
}
|
|
|
|
|
|
public void Abort(ChannelBase channel)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.aborted = true;
|
|
|
|
if (this.closed)
|
|
return;
|
|
|
|
this.closed = true;
|
|
|
|
this.retryTimer.Cancel();
|
|
|
|
while (waitQueue.Count > 0)
|
|
waitQueue.Dequeue().Abort(channel);
|
|
|
|
window.Close();
|
|
}
|
|
}
|
|
|
|
public bool Add(Message message, TimeSpan timeout, object state, out MessageAttemptInfo attemptInfo)
|
|
{
|
|
return InternalAdd(message, false, timeout, state, out attemptInfo);
|
|
}
|
|
|
|
public MessageAttemptInfo AddLast(Message message, TimeSpan timeout, object state)
|
|
{
|
|
if (this.reliableMessagingVersion != ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
throw Fx.AssertAndThrow("Last message supported only in February 2005.");
|
|
}
|
|
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
InternalAdd(message, true, timeout, state, out attemptInfo);
|
|
return attemptInfo;
|
|
}
|
|
|
|
// Must call in a lock(this.ThisLock).
|
|
MessageAttemptInfo AddToWindow(Message message, bool isLast, object state)
|
|
{
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
Int64 sequenceNumber;
|
|
|
|
sequenceNumber = this.windowStart + this.window.Count;
|
|
WsrmUtilities.AddSequenceHeader(this.reliableMessagingVersion, message, this.id, sequenceNumber, isLast);
|
|
|
|
if (this.requestAcks && (this.window.Count == this.windowSize - 1 || this.quotaRemaining == 1)) // can't add any more
|
|
{
|
|
message.Properties.AllowOutputBatching = false;
|
|
WsrmUtilities.AddAckRequestedHeader(this.reliableMessagingVersion, message, this.id);
|
|
}
|
|
|
|
if (this.window.Count == 0)
|
|
{
|
|
this.retryTimer.Set(this.Timeout);
|
|
}
|
|
|
|
this.window.Add(message, Now, state);
|
|
this.quotaRemaining--;
|
|
if (isLast)
|
|
this.last = sequenceNumber;
|
|
|
|
int index = (int)(sequenceNumber - this.windowStart);
|
|
attemptInfo = new MessageAttemptInfo(this.window.GetMessage(index), sequenceNumber, 0, state);
|
|
|
|
return attemptInfo;
|
|
}
|
|
|
|
public IAsyncResult BeginAdd(Message message, TimeSpan timeout, object state, AsyncCallback callback, object asyncState)
|
|
{
|
|
return InternalBeginAdd(message, false, timeout, state, callback, asyncState);
|
|
}
|
|
|
|
public IAsyncResult BeginAddLast(Message message, TimeSpan timeout, object state, AsyncCallback callback, object asyncState)
|
|
{
|
|
if (this.reliableMessagingVersion != ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
throw Fx.AssertAndThrow("Last message supported only in February 2005.");
|
|
}
|
|
|
|
return InternalBeginAdd(message, true, timeout, state, callback, asyncState);
|
|
}
|
|
|
|
bool CanAdd()
|
|
{
|
|
return (this.window.Count < this.windowSize && // Does the message fit in the transmission window?
|
|
this.quotaRemaining > 0 && // Can the receiver handle another message?
|
|
this.waitQueue.Count == 0); // Don't get ahead of anyone in the wait queue.
|
|
}
|
|
|
|
public void Close()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
return;
|
|
|
|
this.closed = true;
|
|
|
|
this.retryTimer.Cancel();
|
|
|
|
if (waitQueue.Count != 0)
|
|
{
|
|
throw Fx.AssertAndThrow("The reliable channel must throw prior to the call to Close() if there are outstanding send or request operations.");
|
|
}
|
|
|
|
window.Close();
|
|
}
|
|
}
|
|
|
|
public void DequeuePending()
|
|
{
|
|
Queue<IQueueAdder> adders = null;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed || this.waitQueue.Count == 0)
|
|
return;
|
|
|
|
int count = Math.Min(this.windowSize, this.quotaRemaining) - this.window.Count;
|
|
if (count <= 0)
|
|
return;
|
|
|
|
count = Math.Min(count, this.waitQueue.Count);
|
|
adders = new Queue<IQueueAdder>(count);
|
|
|
|
while (count-- > 0)
|
|
{
|
|
IQueueAdder adder = waitQueue.Dequeue();
|
|
adder.Complete0();
|
|
adders.Enqueue(adder);
|
|
}
|
|
}
|
|
|
|
while (adders.Count > 0)
|
|
adders.Dequeue().Complete1();
|
|
}
|
|
|
|
public bool EndAdd(IAsyncResult result, out MessageAttemptInfo attemptInfo)
|
|
{
|
|
return InternalEndAdd(result, out attemptInfo);
|
|
}
|
|
|
|
public MessageAttemptInfo EndAddLast(IAsyncResult result)
|
|
{
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
InternalEndAdd(result, out attemptInfo);
|
|
return attemptInfo;
|
|
}
|
|
|
|
bool IsAddValid()
|
|
{
|
|
return (!this.aborted && !this.closed);
|
|
}
|
|
|
|
public void OnRetryElapsed(object state)
|
|
{
|
|
try
|
|
{
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
return;
|
|
|
|
if (this.window.Count == 0)
|
|
return;
|
|
|
|
this.window.RecordRetry(0, Now);
|
|
this.congestionControlModeAcks = 0;
|
|
this.slowStartThreshold = Math.Max(1, this.windowSize >> 1);
|
|
this.lossWindowSize = this.windowSize;
|
|
this.windowSize = 1;
|
|
this.timeout <<= 1;
|
|
this.startup = false;
|
|
|
|
attemptInfo = new MessageAttemptInfo(this.window.GetMessage(0), this.windowStart, this.window.GetRetryCount(0), this.window.GetState(0));
|
|
}
|
|
|
|
retryTimeoutElapsedHandler(attemptInfo);
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.closed && (this.window.Count > 0))
|
|
{
|
|
this.retryTimer.Set(this.Timeout);
|
|
}
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
this.onException(e);
|
|
}
|
|
}
|
|
|
|
public void Fault(ChannelBase channel)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
return;
|
|
|
|
this.closed = true;
|
|
|
|
this.retryTimer.Cancel();
|
|
|
|
while (waitQueue.Count > 0)
|
|
waitQueue.Dequeue().Fault(channel);
|
|
|
|
window.Close();
|
|
}
|
|
}
|
|
|
|
public MessageAttemptInfo GetMessageInfoForRetry(bool remove)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
// Closed, no need to retry.
|
|
if (this.closed)
|
|
{
|
|
return default(MessageAttemptInfo);
|
|
}
|
|
|
|
if (remove)
|
|
{
|
|
if (this.retransmissionWindow.Count == 0)
|
|
{
|
|
throw Fx.AssertAndThrow("The caller is not allowed to remove a message attempt when there are no message attempts.");
|
|
}
|
|
|
|
this.retransmissionWindow.RemoveAt(0);
|
|
}
|
|
|
|
while (this.retransmissionWindow.Count > 0)
|
|
{
|
|
Int64 next = this.retransmissionWindow[0];
|
|
if (next < this.windowStart)
|
|
{
|
|
// Already removed from the window, no need to retry.
|
|
this.retransmissionWindow.RemoveAt(0);
|
|
}
|
|
else
|
|
{
|
|
int index = (int)(next - this.windowStart);
|
|
if (this.window.GetTransferred(index))
|
|
this.retransmissionWindow.RemoveAt(0);
|
|
else
|
|
return new MessageAttemptInfo(this.window.GetMessage(index), next, this.window.GetRetryCount(index), this.window.GetState(index));
|
|
}
|
|
}
|
|
|
|
// Nothing left to retry.
|
|
return default(MessageAttemptInfo);
|
|
}
|
|
}
|
|
|
|
public bool SetLast()
|
|
{
|
|
if (this.reliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
throw Fx.AssertAndThrow("SetLast supported only in 1.1.");
|
|
}
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.last != 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Cannot set last more than once.");
|
|
}
|
|
|
|
this.last = this.windowStart + this.window.Count - 1;
|
|
return (this.last == 0) || this.DoneTransmitting;
|
|
}
|
|
}
|
|
|
|
bool InternalAdd(Message message, bool isLast, TimeSpan timeout, object state, out MessageAttemptInfo attemptInfo)
|
|
{
|
|
attemptInfo = default(MessageAttemptInfo);
|
|
|
|
WaitQueueAdder adder;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (isLast && this.last != 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Can't add more than one last message.");
|
|
}
|
|
|
|
if (!this.IsAddValid())
|
|
return false;
|
|
|
|
ThrowIfRollover();
|
|
|
|
if (CanAdd())
|
|
{
|
|
attemptInfo = AddToWindow(message, isLast, state);
|
|
return true;
|
|
}
|
|
|
|
adder = new WaitQueueAdder(this, message, isLast, state);
|
|
this.waitQueue.Enqueue(adder);
|
|
}
|
|
|
|
attemptInfo = adder.Wait(timeout);
|
|
return true;
|
|
}
|
|
|
|
IAsyncResult InternalBeginAdd(Message message, bool isLast, TimeSpan timeout, object state, AsyncCallback callback, object asyncState)
|
|
{
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
bool isAddValid;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (isLast && this.last != 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Can't add more than one last message.");
|
|
}
|
|
|
|
isAddValid = this.IsAddValid();
|
|
|
|
if (isAddValid)
|
|
{
|
|
ThrowIfRollover();
|
|
|
|
if (CanAdd())
|
|
{
|
|
attemptInfo = AddToWindow(message, isLast, state);
|
|
}
|
|
else
|
|
{
|
|
AsyncQueueAdder adder = new AsyncQueueAdder(message, isLast, timeout, state, this, callback, asyncState);
|
|
this.waitQueue.Enqueue(adder);
|
|
|
|
return adder;
|
|
}
|
|
}
|
|
}
|
|
|
|
return new CompletedAsyncResult<bool, MessageAttemptInfo>(isAddValid, attemptInfo, callback, asyncState);
|
|
}
|
|
|
|
bool InternalEndAdd(IAsyncResult result, out MessageAttemptInfo attemptInfo)
|
|
{
|
|
if (result is CompletedAsyncResult<bool, MessageAttemptInfo>)
|
|
{
|
|
return CompletedAsyncResult<bool, MessageAttemptInfo>.End(result, out attemptInfo);
|
|
}
|
|
else
|
|
{
|
|
attemptInfo = AsyncQueueAdder.End((AsyncQueueAdder)result);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool IsFinalAckConsistent(SequenceRangeCollection ranges)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Nothing sent, ensure ack is empty.
|
|
if ((this.windowStart == 1) && (this.window.Count == 0))
|
|
{
|
|
return ranges.Count == 0;
|
|
}
|
|
|
|
// Ack is empty or first range is invalid.
|
|
if (ranges.Count == 0 || ranges[0].Lower != 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return ranges[0].Upper >= (this.windowStart - 1);
|
|
}
|
|
}
|
|
|
|
public void ProcessAcknowledgement(SequenceRangeCollection ranges, out bool invalidAck, out bool inconsistentAck)
|
|
{
|
|
invalidAck = false;
|
|
inconsistentAck = false;
|
|
bool newAck = false;
|
|
bool oldAck = false;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Int64 lastMessageSent = this.windowStart + this.window.Count - 1;
|
|
Int64 lastMessageAcked = this.windowStart - 1;
|
|
int transferredInWindow = this.window.TransferredCount;
|
|
|
|
for (int i = 0; i < ranges.Count; i++)
|
|
{
|
|
SequenceRange range = ranges[i];
|
|
|
|
// Ack for a message not yet sent.
|
|
if (range.Upper > lastMessageSent)
|
|
{
|
|
invalidAck = true;
|
|
return;
|
|
}
|
|
|
|
if (((range.Lower > 1) && (range.Lower <= lastMessageAcked)) || (range.Upper < lastMessageAcked))
|
|
{
|
|
oldAck = true;
|
|
}
|
|
|
|
if (range.Upper >= this.windowStart)
|
|
{
|
|
if (range.Lower <= this.windowStart)
|
|
{
|
|
newAck = true;
|
|
}
|
|
|
|
if (!newAck)
|
|
{
|
|
int beginIndex = (int)(range.Lower - this.windowStart);
|
|
int endIndex = (int)((range.Upper > lastMessageSent) ? (this.window.Count - 1) : (range.Upper - this.windowStart));
|
|
|
|
newAck = this.window.GetTransferredInRangeCount(beginIndex, endIndex) < (endIndex - beginIndex + 1);
|
|
}
|
|
|
|
if (transferredInWindow > 0 && !oldAck)
|
|
{
|
|
int beginIndex = (int)((range.Lower < this.windowStart) ? 0 : (range.Lower - this.windowStart));
|
|
int endIndex = (int)((range.Upper > lastMessageSent) ? (this.window.Count - 1) : (range.Upper - this.windowStart));
|
|
|
|
transferredInWindow -= this.window.GetTransferredInRangeCount(beginIndex, endIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (transferredInWindow > 0)
|
|
oldAck = true;
|
|
}
|
|
|
|
inconsistentAck = oldAck && newAck;
|
|
}
|
|
|
|
// Called for RequestReply.
|
|
// Argument transferred is the request sequence number and it is assumed to be positive.
|
|
public bool ProcessTransferred(Int64 transferred, int quotaRemaining)
|
|
{
|
|
if (transferred <= 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument transferred must be a valid sequence number.");
|
|
}
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return ProcessTransferred(new SequenceRange(transferred), quotaRemaining);
|
|
}
|
|
}
|
|
|
|
// Called for Duplex and Output
|
|
public bool ProcessTransferred(SequenceRangeCollection ranges, int quotaRemaining)
|
|
{
|
|
if (ranges.Count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool send = false;
|
|
|
|
for (int rangeIndex = 0; rangeIndex < ranges.Count; rangeIndex++)
|
|
{
|
|
if (this.ProcessTransferred(ranges[rangeIndex], quotaRemaining))
|
|
{
|
|
send = true;
|
|
}
|
|
}
|
|
|
|
return send;
|
|
}
|
|
}
|
|
|
|
// It is necessary that ProcessAcknowledgement be called prior, as
|
|
// this method does not check for valid ack ranges.
|
|
// This method returns true if the calling method should start sending retries
|
|
// obtained from GetMessageInfoForRetry.
|
|
bool ProcessTransferred(SequenceRange range, int quotaRemaining)
|
|
{
|
|
if (range.Upper < this.windowStart)
|
|
{
|
|
if (range.Upper == this.windowStart - 1 && (quotaRemaining != -1) && quotaRemaining > this.quotaRemaining)
|
|
this.quotaRemaining = quotaRemaining - Math.Min(this.windowSize, this.window.Count);
|
|
|
|
return false;
|
|
}
|
|
else if (range.Lower <= this.windowStart)
|
|
{
|
|
bool send = false;
|
|
|
|
this.retryTimer.Cancel();
|
|
|
|
Int64 slide = range.Upper - this.windowStart + 1;
|
|
|
|
// For Request Reply: Requests are transferred 1 at a time, (i.e. when the reply comes back).
|
|
// The TransmissionStrategy only removes messages if the window start is removed.
|
|
// Because of this, RequestReply messages transferred out of order will cause many, many retries.
|
|
// To avoid extraneous retries we mark each message transferred, and we remove our virtual slide.
|
|
if (slide == 1)
|
|
{
|
|
for (int i = 1; i < this.window.Count; i++)
|
|
{
|
|
if (this.window.GetTransferred(i))
|
|
{
|
|
slide++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Int64 now = Now;
|
|
Int64 oldWindowEnd = this.windowStart + this.windowSize;
|
|
|
|
for (int i = 0; i < (int)slide; i++)
|
|
UpdateStats(now, this.window.GetLastAttemptTime(i));
|
|
|
|
if (quotaRemaining != -1)
|
|
{
|
|
int inFlightAfterAck = Math.Min(this.windowSize, this.window.Count) - (int)slide;
|
|
this.quotaRemaining = quotaRemaining - Math.Max(0, inFlightAfterAck);
|
|
}
|
|
|
|
this.window.Remove((int)slide);
|
|
|
|
this.windowStart += slide;
|
|
|
|
int sendBeginIndex = 0;
|
|
|
|
if (this.windowSize <= this.slowStartThreshold)
|
|
{
|
|
this.windowSize = Math.Min(this.maxWindowSize, Math.Min(this.slowStartThreshold + 1, this.windowSize + (int)slide));
|
|
|
|
if (!startup)
|
|
sendBeginIndex = 0;
|
|
else
|
|
sendBeginIndex = Math.Max(0, (int)oldWindowEnd - (int)this.windowStart);
|
|
}
|
|
else
|
|
{
|
|
this.congestionControlModeAcks += (int)slide;
|
|
|
|
// EXPERIMENTAL, needs optimizing ///
|
|
int segmentSize = Math.Max(1, (this.lossWindowSize - this.slowStartThreshold) / 8);
|
|
int windowGrowthAckThreshold = ((this.windowSize - this.slowStartThreshold) * this.windowSize) / segmentSize;
|
|
|
|
if (this.congestionControlModeAcks > windowGrowthAckThreshold)
|
|
{
|
|
this.congestionControlModeAcks = 0;
|
|
this.windowSize = Math.Min(this.maxWindowSize, this.windowSize + 1);
|
|
}
|
|
|
|
sendBeginIndex = Math.Max(0, (int)oldWindowEnd - (int)this.windowStart);
|
|
}
|
|
|
|
int sendEndIndex = Math.Min(this.windowSize, this.window.Count);
|
|
|
|
if (sendBeginIndex < sendEndIndex)
|
|
{
|
|
send = (this.retransmissionWindow.Count == 0);
|
|
|
|
for (int i = sendBeginIndex; i < this.windowSize && i < this.window.Count; i++)
|
|
{
|
|
Int64 sequenceNumber = this.windowStart + i;
|
|
|
|
if (!this.window.GetTransferred(i) && !this.retransmissionWindow.Contains(sequenceNumber))
|
|
{
|
|
this.window.RecordRetry(i, Now);
|
|
retransmissionWindow.Add(sequenceNumber);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (window.Count > 0)
|
|
{
|
|
this.retryTimer.Set(this.Timeout);
|
|
}
|
|
|
|
return send;
|
|
}
|
|
else
|
|
{
|
|
for (Int64 i = range.Lower; i <= range.Upper; i++)
|
|
{
|
|
this.window.SetTransferred((int)(i - this.windowStart));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RemoveAdder(IQueueAdder adder)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
return false;
|
|
|
|
bool removed = false;
|
|
for (int i = 0; i < this.waitQueue.Count; i++)
|
|
{
|
|
IQueueAdder current = this.waitQueue.Dequeue();
|
|
|
|
if (Object.ReferenceEquals(adder, current))
|
|
removed = true;
|
|
else
|
|
this.waitQueue.Enqueue(current);
|
|
}
|
|
return removed;
|
|
}
|
|
}
|
|
|
|
void ThrowIfRollover()
|
|
{
|
|
if (this.windowStart + this.window.Count + this.waitQueue.Count == Int64.MaxValue)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageNumberRolloverFault(this.id).CreateException());
|
|
}
|
|
|
|
void UpdateStats(Int64 now, Int64 lastAttemptTime)
|
|
{
|
|
now = Math.Max(now, lastAttemptTime);
|
|
Int64 measuredRtt = now - lastAttemptTime;
|
|
Int64 error = measuredRtt - this.meanRtt;
|
|
this.serrRtt = Math.Min(this.serrRtt + ((Math.Abs(error) - this.serrRtt) >> Constants.Gain), Constants.MaxSerrRtt);
|
|
this.meanRtt = Math.Min(this.meanRtt + (error >> Constants.Gain), Constants.MaxMeanRtt);
|
|
this.timeout = Math.Max(((200 << Constants.TimeMultiplier) * 2) + this.meanRtt, this.meanRtt + (this.serrRtt << Constants.ChebychevFactor));
|
|
}
|
|
|
|
class AsyncQueueAdder : WaitAsyncResult, IQueueAdder
|
|
{
|
|
bool isLast;
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
TransmissionStrategy strategy;
|
|
|
|
public AsyncQueueAdder(Message message, bool isLast, TimeSpan timeout, object state, TransmissionStrategy strategy, AsyncCallback callback, object asyncState)
|
|
: base(timeout, true, callback, asyncState)
|
|
{
|
|
// MessageAttemptInfo(Message message, Int64 sequenceNumber, int retryCount, object state)
|
|
// this.attemptInfo is just a state bag, thus sequenceNumber can be 0 and should never be read.
|
|
this.attemptInfo = new MessageAttemptInfo(message, 0, 0, state);
|
|
this.isLast = isLast;
|
|
this.strategy = strategy;
|
|
base.Begin();
|
|
}
|
|
|
|
public void Abort(CommunicationObject communicationObject)
|
|
{
|
|
this.attemptInfo.Message.Close();
|
|
OnAborted(communicationObject);
|
|
}
|
|
|
|
public void Complete0()
|
|
{
|
|
this.attemptInfo = strategy.AddToWindow(this.attemptInfo.Message, this.isLast, this.attemptInfo.State);
|
|
}
|
|
|
|
public void Complete1()
|
|
{
|
|
OnSignaled();
|
|
}
|
|
|
|
public static MessageAttemptInfo End(AsyncQueueAdder result)
|
|
{
|
|
AsyncResult.End<AsyncQueueAdder>(result);
|
|
return result.attemptInfo;
|
|
}
|
|
|
|
public void Fault(CommunicationObject communicationObject)
|
|
{
|
|
this.attemptInfo.Message.Close();
|
|
OnFaulted(communicationObject);
|
|
}
|
|
|
|
protected override string GetTimeoutString(TimeSpan timeout)
|
|
{
|
|
return SR.GetString(SR.TimeoutOnAddToWindow, timeout);
|
|
}
|
|
|
|
protected override void OnTimerElapsed(object state)
|
|
{
|
|
if (this.strategy.RemoveAdder(this))
|
|
base.OnTimerElapsed(state);
|
|
}
|
|
}
|
|
|
|
static class Constants
|
|
{
|
|
// Used to adjust the timeout calculation, according to Chebychev's theorem,
|
|
// to fit ~98% of actual rtt's within our timeout.
|
|
public const int ChebychevFactor = 2;
|
|
|
|
// Gain of 0.125 (1/8). Shift right by 3 to apply the gain to a term.
|
|
public const int Gain = 3;
|
|
|
|
// 1ms == 128 of our time units. Shift left by 7 to perform the multiplication.
|
|
public const int TimeMultiplier = 7;
|
|
|
|
// These guarantee no overflows when calculating timeout.
|
|
public const long MaxMeanRtt = long.MaxValue / 3;
|
|
public const long MaxSerrRtt = MaxMeanRtt / 2;
|
|
}
|
|
|
|
interface IQueueAdder
|
|
{
|
|
void Abort(CommunicationObject communicationObject);
|
|
void Fault(CommunicationObject communicationObject);
|
|
void Complete0();
|
|
void Complete1();
|
|
}
|
|
|
|
class SlidingWindow
|
|
{
|
|
TransmissionInfo[] buffer;
|
|
int head = 0;
|
|
int tail = 0;
|
|
int maxSize;
|
|
|
|
public SlidingWindow(int maxSize)
|
|
{
|
|
this.maxSize = maxSize + 1;
|
|
this.buffer = new TransmissionInfo[this.maxSize];
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get
|
|
{
|
|
if (this.tail >= this.head)
|
|
return (this.tail - this.head);
|
|
else
|
|
return (this.tail - this.head + this.maxSize);
|
|
}
|
|
}
|
|
|
|
public int TransferredCount
|
|
{
|
|
get
|
|
{
|
|
if (this.Count == 0)
|
|
return 0;
|
|
else
|
|
return this.GetTransferredInRangeCount(0, this.Count - 1);
|
|
}
|
|
}
|
|
|
|
public void Add(Message message, Int64 addTime, object state)
|
|
{
|
|
if (this.Count >= (this.maxSize - 1))
|
|
{
|
|
throw Fx.AssertAndThrow("The caller is not allowed to add messages beyond the sliding window's maximum size.");
|
|
}
|
|
|
|
this.buffer[this.tail] = new TransmissionInfo(message, addTime, state);
|
|
this.tail = (this.tail + 1) % this.maxSize;
|
|
}
|
|
|
|
void AssertIndex(int index)
|
|
{
|
|
if (index >= Count)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument index must be less than Count.");
|
|
}
|
|
|
|
if (index < 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument index must be positive.");
|
|
}
|
|
}
|
|
|
|
public void Close()
|
|
{
|
|
this.Remove(Count);
|
|
}
|
|
|
|
public Int64 GetLastAttemptTime(int index)
|
|
{
|
|
this.AssertIndex(index);
|
|
return this.buffer[(head + index) % this.maxSize].LastAttemptTime;
|
|
}
|
|
|
|
public Message GetMessage(int index)
|
|
{
|
|
this.AssertIndex(index);
|
|
if (!this.buffer[(head + index) % this.maxSize].Transferred)
|
|
return this.buffer[(head + index) % this.maxSize].Buffer.CreateMessage();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
public int GetRetryCount(int index)
|
|
{
|
|
this.AssertIndex(index);
|
|
return this.buffer[(this.head + index) % this.maxSize].RetryCount;
|
|
}
|
|
|
|
public object GetState(int index)
|
|
{
|
|
this.AssertIndex(index);
|
|
return this.buffer[(this.head + index) % this.maxSize].State;
|
|
}
|
|
|
|
public bool GetTransferred(int index)
|
|
{
|
|
this.AssertIndex(index);
|
|
return this.buffer[(this.head + index) % this.maxSize].Transferred;
|
|
}
|
|
|
|
public int GetTransferredInRangeCount(int beginIndex, int endIndex)
|
|
{
|
|
if (beginIndex < 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument beginIndex cannot be negative.");
|
|
}
|
|
|
|
if (endIndex >= this.Count)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument endIndex cannot be greater than Count.");
|
|
}
|
|
|
|
if (endIndex < beginIndex)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument endIndex cannot be less than argument beginIndex.");
|
|
}
|
|
|
|
int result = 0;
|
|
|
|
for (int index = beginIndex; index <= endIndex; index++)
|
|
{
|
|
if (this.buffer[(head + index) % this.maxSize].Transferred)
|
|
result++;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public int RecordRetry(int index, Int64 retryTime)
|
|
{
|
|
this.AssertIndex(index);
|
|
this.buffer[(head + index) % this.maxSize].LastAttemptTime = retryTime;
|
|
|
|
return ++this.buffer[(head + index) % this.maxSize].RetryCount;
|
|
}
|
|
|
|
public void Remove(int count)
|
|
{
|
|
if (count > this.Count)
|
|
{
|
|
Fx.Assert("Cannot remove more messages than the window's Count.");
|
|
}
|
|
|
|
while (count-- > 0)
|
|
{
|
|
this.buffer[head].Buffer.Close();
|
|
this.buffer[head].Buffer = null;
|
|
this.head = (this.head + 1) % this.maxSize;
|
|
}
|
|
}
|
|
|
|
public void SetTransferred(int index)
|
|
{
|
|
this.AssertIndex(index);
|
|
this.buffer[(head + index) % this.maxSize].Transferred = true;
|
|
}
|
|
|
|
struct TransmissionInfo
|
|
{
|
|
internal MessageBuffer Buffer;
|
|
internal Int64 LastAttemptTime;
|
|
internal int RetryCount;
|
|
internal object State;
|
|
internal bool Transferred;
|
|
|
|
public TransmissionInfo(Message message, Int64 lastAttemptTime, object state)
|
|
{
|
|
this.Buffer = message.CreateBufferedCopy(int.MaxValue);
|
|
this.LastAttemptTime = lastAttemptTime;
|
|
this.RetryCount = 0;
|
|
this.State = state;
|
|
this.Transferred = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
class WaitQueueAdder : IQueueAdder
|
|
{
|
|
ManualResetEvent completeEvent = new ManualResetEvent(false);
|
|
Exception exception;
|
|
bool isLast;
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
TransmissionStrategy strategy;
|
|
|
|
public WaitQueueAdder(TransmissionStrategy strategy, Message message, bool isLast, object state)
|
|
{
|
|
this.strategy = strategy;
|
|
this.isLast = isLast;
|
|
this.attemptInfo = new MessageAttemptInfo(message, 0, 0, state);
|
|
}
|
|
|
|
public void Abort(CommunicationObject communicationObject)
|
|
{
|
|
this.exception = communicationObject.CreateClosedException();
|
|
completeEvent.Set();
|
|
}
|
|
|
|
public void Complete0()
|
|
{
|
|
attemptInfo = this.strategy.AddToWindow(this.attemptInfo.Message, this.isLast, this.attemptInfo.State);
|
|
this.completeEvent.Set();
|
|
}
|
|
|
|
public void Complete1()
|
|
{
|
|
}
|
|
|
|
public void Fault(CommunicationObject communicationObject)
|
|
{
|
|
this.exception = communicationObject.GetTerminalException();
|
|
completeEvent.Set();
|
|
}
|
|
|
|
public MessageAttemptInfo Wait(TimeSpan timeout)
|
|
{
|
|
if (!TimeoutHelper.WaitOne(this.completeEvent, timeout))
|
|
{
|
|
if (this.strategy.RemoveAdder(this) && this.exception == null)
|
|
this.exception = new TimeoutException(SR.GetString(SR.TimeoutOnAddToWindow, timeout));
|
|
}
|
|
|
|
if (this.exception != null)
|
|
{
|
|
this.attemptInfo.Message.Close();
|
|
this.completeEvent.Close();
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.exception);
|
|
}
|
|
|
|
// This is safe because, Abort, Complete0, Fault, and RemoveAdder all occur under
|
|
// the TransmissionStrategy's lock and RemoveAdder ensures that the
|
|
// TransmissionStrategy will never call into this object again.
|
|
this.completeEvent.Close();
|
|
return this.attemptInfo;
|
|
}
|
|
}
|
|
}
|
|
}
|