|
private QueueSendMessage ( |
||
| om | ||
| seqNr | int | |
| return | void | |
// call this regularely
internal override void SendQueuedMessages(float now)
{
//
// resends
//
for (int i = 0; i < m_storedMessages.Length; i++)
{
NetOutgoingMessage om = m_storedMessages[i].Message;
if (om == null)
{
continue;
}
float t = m_storedMessages[i].LastSent;
if (t > 0 && (now - t) > m_resendDelay)
{
// deduce sequence number
/*
* int startSlot = m_windowStart % m_windowSize;
* int seqNr = m_windowStart;
* while (startSlot != i)
* {
* startSlot--;
* if (startSlot < 0)
* startSlot = m_windowSize - 1;
* seqNr--;
* }
*/
//m_connection.m_peer.LogVerbose("Resending due to delay #" + m_storedMessages[i].SequenceNumber + " " + om.ToString());
m_connection.m_statistics.MessageResent(MessageResendReason.Delay);
m_connection.QueueSendMessage(om, m_storedMessages[i].SequenceNumber);
m_storedMessages[i].LastSent = now;
m_storedMessages[i].NumSent++;
}
}
int num = GetAllowedSends();
if (num < 1)
{
return;
}
// queued sends
while (m_queuedSends.Count > 0 && num > 0)
{
NetOutgoingMessage om;
if (m_queuedSends.TryDequeue(out om))
{
ExecuteSend(now, om);
}
num--;
NetException.Assert(num == GetAllowedSends());
}
}
// call this regularely
public override NetSocketResult SendQueuedMessages(TimeSpan now)
{
TimeSpan resendDelay = ResendDelay;
for (int i = 0; i < StoredMessages.Length; i++)
{
ref NetStoredReliableMessage storedMessage = ref StoredMessages[i];
if (storedMessage.Message == null)
{
continue;
}
TimeSpan t = storedMessage.LastSent;
if (t > TimeSpan.Zero && (now - t) > resendDelay)
{
var sendResult = _connection.QueueSendMessage(storedMessage.Message, storedMessage.SequenceNumber);
if (!sendResult.Success)
{
return(sendResult);
}
storedMessage.LastSent = now;
storedMessage.NumSent++;
_connection.Statistics.MessageResent(MessageResendReason.Delay);
}
}
private void ExecuteSend(NetOutgoingMessage message)
{
int seqNr = m_sendStart;
m_sendStart = (m_sendStart + 1) % NetConstants.NumSequenceNumbers;
m_connection.QueueSendMessage(message, seqNr);
if (message.m_recyclingCount <= 0)
{
m_connection.m_peer.Recycle(message);
}
return;
}
private void ExecuteSend(float now, NetOutgoingMessage message)
{
m_connection.m_peer.VerifyNetworkThread();
int seqNr = m_sendStart;
m_sendStart = (m_sendStart + 1) % NetConstants.NumSequenceNumbers;
m_connection.QueueSendMessage(message, seqNr);
Interlocked.Decrement(ref message.m_recyclingCount);
if (message.m_recyclingCount <= 0)
{
m_connection.m_peer.Recycle(message);
}
return;
}
private NetSocketResult ExecuteSend(NetOutgoingMessage message)
{
_connection.Peer.AssertIsOnLibraryThread();
int seqNr = _sendStart;
var sendResult = _connection.QueueSendMessage(message, seqNr);
if (sendResult.Success)
{
_sendStart = NetUtility.PowOf2Mod(seqNr + 1, NetConstants.SequenceNumbers);
Interlocked.Decrement(ref message._recyclingCount);
if (message._recyclingCount <= 0)
{
_connection.Peer.Recycle(message);
}
}
return(sendResult);
}
// call this regularely
internal override void SendQueuedMessages(double now)
{
//
// resends
//
m_anyStoredResends = false;
for (int i = 0; i < m_storedMessages.Length; i++)
{
var storedMsg = m_storedMessages[i];
NetOutgoingMessage om = storedMsg.Message;
if (om == null)
{
continue;
}
m_anyStoredResends = true;
double t = storedMsg.LastSent;
if (t > 0 && (now - t) > m_resendDelay)
{
// deduce sequence number
/*
* int startSlot = m_windowStart % m_windowSize;
* int seqNr = m_windowStart;
* while (startSlot != i)
* {
* startSlot--;
* if (startSlot < 0)
* startSlot = m_windowSize - 1;
* seqNr--;
* }
*/
//m_connection.m_peer.LogVerbose("Resending due to delay #" + m_storedMessages[i].SequenceNumber + " " + om.ToString());
m_connection.m_statistics.MessageResent(MessageResendReason.Delay);
Interlocked.Increment(ref om.m_recyclingCount); // increment this since it's being decremented in QueueSendMessage
m_connection.QueueSendMessage(om, storedMsg.SequenceNumber);
m_storedMessages[i].LastSent = now;
m_storedMessages[i].NumSent++;
}
}
int num = GetAllowedSends();
if (num < 1)
{
return;
}
// queued sends
while (num > 0 && m_queuedSends.Count > 0)
{
NetOutgoingMessage om;
if (m_queuedSends.TryDequeue(out om))
{
ExecuteSend(now, om);
}
num--;
NetException.Assert(num == GetAllowedSends());
}
}
