OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add some nullref checks to the UnackedPacketCollection.

avinationmerge
meta7 2010-08-07 08:06:41 -07:00
parent b58a47c373
commit b017d985ab
1 changed files with 184 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

353
OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
View File

@ -1,169 +1,184 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the * * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.ClientStack.LindenUDP namespace OpenSim.Region.ClientStack.LindenUDP
{ {
/// <summary> /// <summary>
/// Special collection that is optimized for tracking unacknowledged packets /// Special collection that is optimized for tracking unacknowledged packets
/// </summary> /// </summary>
public sealed class UnackedPacketCollection public sealed class UnackedPacketCollection
{ {
/// <summary> /// <summary>
/// Holds information about a pending acknowledgement /// Holds information about a pending acknowledgement
/// </summary> /// </summary>
private struct PendingAck private struct PendingAck
{ {
/// <summary>Sequence number of the packet to remove</summary> /// <summary>Sequence number of the packet to remove</summary>
public uint SequenceNumber; public uint SequenceNumber;
/// <summary>Environment.TickCount value when the remove was queued. /// <summary>Environment.TickCount value when the remove was queued.
/// This is used to update round-trip times for packets</summary> /// This is used to update round-trip times for packets</summary>
public int RemoveTime; public int RemoveTime;
/// <summary>Whether or not this acknowledgement was attached to a /// <summary>Whether or not this acknowledgement was attached to a
/// resent packet. If so, round-trip time will not be calculated</summary> /// resent packet. If so, round-trip time will not be calculated</summary>
public bool FromResend; public bool FromResend;
public PendingAck(uint sequenceNumber, int currentTime, bool fromResend) public PendingAck(uint sequenceNumber, int currentTime, bool fromResend)
{ {
SequenceNumber = sequenceNumber; SequenceNumber = sequenceNumber;
RemoveTime = currentTime; RemoveTime = currentTime;
FromResend = fromResend; FromResend = fromResend;
} }
} }
/// <summary>Holds the actual unacked packet data, sorted by sequence number</summary> /// <summary>Holds the actual unacked packet data, sorted by sequence number</summary>
private Dictionary<uint, OutgoingPacket> m_packets = new Dictionary<uint, OutgoingPacket>(); private Dictionary<uint, OutgoingPacket> m_packets = new Dictionary<uint, OutgoingPacket>();
/// <summary>Holds packets that need to be added to the unacknowledged list</summary> /// <summary>Holds packets that need to be added to the unacknowledged list</summary>
private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>(); private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>();
/// <summary>Holds information about pending acknowledgements</summary> /// <summary>Holds information about pending acknowledgements</summary>
private LocklessQueue<PendingAck> m_pendingRemoves = new LocklessQueue<PendingAck>(); private LocklessQueue<PendingAck> m_pendingRemoves = new LocklessQueue<PendingAck>();
/// <summary> /// <summary>
/// Add an unacked packet to the collection /// Add an unacked packet to the collection
/// </summary> /// </summary>
/// <param name="packet">Packet that is awaiting acknowledgement</param> /// <param name="packet">Packet that is awaiting acknowledgement</param>
/// <returns>True if the packet was successfully added, false if the /// <returns>True if the packet was successfully added, false if the
/// packet already existed in the collection</returns> /// packet already existed in the collection</returns>
/// <remarks>This does not immediately add the ACK to the collection, /// <remarks>This does not immediately add the ACK to the collection,
/// it only queues it so it can be added in a thread-safe way later</remarks> /// it only queues it so it can be added in a thread-safe way later</remarks>
public void Add(OutgoingPacket packet) public void Add(OutgoingPacket packet)
{ {
m_pendingAdds.Enqueue(packet); m_pendingAdds.Enqueue(packet);
} }
/// <summary> /// <summary>
/// Marks a packet as acknowledged /// Marks a packet as acknowledged
/// </summary> /// </summary>
/// <param name="sequenceNumber">Sequence number of the packet to /// <param name="sequenceNumber">Sequence number of the packet to
/// acknowledge</param> /// acknowledge</param>
/// <param name="currentTime">Current value of Environment.TickCount</param> /// <param name="currentTime">Current value of Environment.TickCount</param>
/// <remarks>This does not immediately acknowledge the packet, it only /// <remarks>This does not immediately acknowledge the packet, it only
/// queues the ack so it can be handled in a thread-safe way later</remarks> /// queues the ack so it can be handled in a thread-safe way later</remarks>
public void Remove(uint sequenceNumber, int currentTime, bool fromResend) public void Remove(uint sequenceNumber, int currentTime, bool fromResend)
{ {
m_pendingRemoves.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend)); m_pendingRemoves.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
} }
/// <summary> /// <summary>
/// Returns a list of all of the packets with a TickCount older than /// Returns a list of all of the packets with a TickCount older than
/// the specified timeout /// the specified timeout
/// </summary> /// </summary>
/// <param name="timeoutMS">Number of ticks (milliseconds) before a /// <param name="timeoutMS">Number of ticks (milliseconds) before a
/// packet is considered expired</param> /// packet is considered expired</param>
/// <returns>A list of all expired packets according to the given /// <returns>A list of all expired packets according to the given
/// expiration timeout</returns> /// expiration timeout</returns>
/// <remarks>This function is not thread safe, and cannot be called /// <remarks>This function is not thread safe, and cannot be called
/// multiple times concurrently</remarks> /// multiple times concurrently</remarks>
public List<OutgoingPacket> GetExpiredPackets(int timeoutMS) public List<OutgoingPacket> GetExpiredPackets(int timeoutMS)
{ {
ProcessQueues(); ProcessQueues();
List<OutgoingPacket> expiredPackets = null; List<OutgoingPacket> expiredPackets = null;
if (m_packets.Count > 0) if (m_packets.Count > 0)
{ {
int now = Environment.TickCount & Int32.MaxValue; int now = Environment.TickCount & Int32.MaxValue;
foreach (OutgoingPacket packet in m_packets.Values) foreach (OutgoingPacket packet in m_packets.Values)
{ {
// TickCount of zero means a packet is in the resend queue // TickCount of zero means a packet is in the resend queue
// but hasn't actually been sent over the wire yet // but hasn't actually been sent over the wire yet
if (packet.TickCount == 0) if (packet.TickCount == 0)
continue; continue;
if (now - packet.TickCount >= timeoutMS) if (now - packet.TickCount >= timeoutMS)
{ {
if (expiredPackets == null) if (expiredPackets == null)
expiredPackets = new List<OutgoingPacket>(); expiredPackets = new List<OutgoingPacket>();
// The TickCount will be set to the current time when the packet // The TickCount will be set to the current time when the packet
// is actually sent out again // is actually sent out again
packet.TickCount = 0; packet.TickCount = 0;
expiredPackets.Add(packet); expiredPackets.Add(packet);
} }
} }
} }
return expiredPackets; return expiredPackets;
} }
private void ProcessQueues() private void ProcessQueues()
{ {
// Process all the pending adds // Process all the pending adds
OutgoingPacket pendingAdd;
while (m_pendingAdds.Dequeue(out pendingAdd)) OutgoingPacket pendingAdd;
m_packets[pendingAdd.SequenceNumber] = pendingAdd; if (m_pendingAdds != null)
{
// Process all the pending removes, including updating statistics and round-trip times while (m_pendingAdds.Dequeue(out pendingAdd))
PendingAck pendingRemove; {
OutgoingPacket ackedPacket; if (pendingAdd != null && m_packets != null)
while (m_pendingRemoves.Dequeue(out pendingRemove)) {
{ m_packets[pendingAdd.SequenceNumber] = pendingAdd;
if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket)) }
{ }
m_packets.Remove(pendingRemove.SequenceNumber); }
// Update stats // Process all the pending removes, including updating statistics and round-trip times
System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength); PendingAck pendingRemove;
OutgoingPacket ackedPacket;
if (!pendingRemove.FromResend) if (m_pendingRemoves != null)
{ {
// Calculate the round-trip time for this packet and its ACK while (m_pendingRemoves.Dequeue(out pendingRemove))
int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount; {
if (rtt > 0) if (m_pendingRemoves != null && m_packets != null)
ackedPacket.Client.UpdateRoundTrip(rtt); {
} if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))
} {
} m_packets.Remove(pendingRemove.SequenceNumber);
}
} // Update stats
} System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
if (!pendingRemove.FromResend)
{
// Calculate the round-trip time for this packet and its ACK
int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;
if (rtt > 0)
ackedPacket.Client.UpdateRoundTrip(rtt);
}
}
}
}
}
}
}
}