1 files changed, 184 insertions, 184 deletions
diff --git a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
index 043e7d3..4cb4aee 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
@@ -1,184 +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;
+            OutgoingPacket pendingAdd;
-            if (m_pendingAdds != null)
+            if (m_pendingAdds != null)
-            {
+            {
-                while (m_pendingAdds.TryDequeue(out pendingAdd))
+                while (m_pendingAdds.TryDequeue(out pendingAdd))
-                {
+                {
-                    if (pendingAdd != null && m_packets != null)
+                    if (pendingAdd != null && m_packets != null)
-                    {
+                    {
-                        m_packets[pendingAdd.SequenceNumber] = pendingAdd;
+                        m_packets[pendingAdd.SequenceNumber] = pendingAdd;
-                    }
+                    }
-                }
+                }
-            }
+            }
-            
+            
-            // Process all the pending removes, including updating statistics and round-trip times
+            // Process all the pending removes, including updating statistics and round-trip times
-            PendingAck pendingRemove;
+            PendingAck pendingRemove;
-            OutgoingPacket ackedPacket;
+            OutgoingPacket ackedPacket;
-            if (m_pendingRemoves != null)
+            if (m_pendingRemoves != null)
-            {
+            {
-                while (m_pendingRemoves.TryDequeue(out pendingRemove))
+                while (m_pendingRemoves.TryDequeue(out pendingRemove))
-                {
+                {
-                    if (m_pendingRemoves != null && m_packets != null)
+                    if (m_pendingRemoves != null && m_packets != null)
-                    {
+                    {
-                        if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))
+                        if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))
-                        {
+                        {
-                            m_packets.Remove(pendingRemove.SequenceNumber);
+                            m_packets.Remove(pendingRemove.SequenceNumber);
-                            // Update stats
+                            // Update stats
-                            System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
+                            System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
-                            if (!pendingRemove.FromResend)
+                            if (!pendingRemove.FromResend)
-                            {
+                            {
-                                // Calculate the round-trip time for this packet and its ACK
+                                // Calculate the round-trip time for this packet and its ACK
-                                int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;
+                                int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;
-                                if (rtt > 0)
+                                if (rtt > 0)
-                                    ackedPacket.Client.UpdateRoundTrip(rtt);
+                                    ackedPacket.Client.UpdateRoundTrip(rtt);
-                            }
+                            }
-                        }
+                        }
-                    }
+                    }
-                }
+                }
-            }
+            }
-        }
+        }
-    }
+    }
-}
+}

diff --git a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs index 043e7d3..4cb4aee 100644 --- a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs +++ b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
@@ -1,184 +1,184 @@
1	/*	1	/*
2	* Copyright (c) Contributors, http://opensimulator.org/	2	* Copyright (c) Contributors, http://opensimulator.org/
3	* See CONTRIBUTORS.TXT for a full list of copyright holders.	3	* See CONTRIBUTORS.TXT for a full list of copyright holders.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions are met:	6	* modification, are permitted provided that the following conditions are met:
7	* * Redistributions of source code must retain the above copyright	7	* * Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.	8	* notice, this list of conditions and the following disclaimer.
9	* * Redistributions in binary form must reproduce the above copyright	9	* * Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the	10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.	11	* documentation and/or other materials provided with the distribution.
12	* * Neither the name of the OpenSimulator Project nor the	12	* * Neither the name of the OpenSimulator Project nor the
13	* names of its contributors may be used to endorse or promote products	13	* names of its contributors may be used to endorse or promote products
14	* derived from this software without specific prior written permission.	14	* derived from this software without specific prior written permission.
15	*	15	*
16	* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY	16	* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
17	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED	17	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE	18	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19	* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY	19	* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
20	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES	20	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;	21	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND	22	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	23	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS	24	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	25	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26	*/	26	*/
27		27
28	using System;	28	using System;
29	using System.Collections.Generic;	29	using System.Collections.Generic;
30	using System.Net;	30	using System.Net;
31	using OpenMetaverse;	31	using OpenMetaverse;
32		32
33	namespace OpenSim.Region.ClientStack.LindenUDP	33	namespace OpenSim.Region.ClientStack.LindenUDP
34	{	34	{
35	/// <summary>	35	/// <summary>
36	/// Special collection that is optimized for tracking unacknowledged packets	36	/// Special collection that is optimized for tracking unacknowledged packets
37	/// </summary>	37	/// </summary>
38	public sealed class UnackedPacketCollection	38	public sealed class UnackedPacketCollection
39	{	39	{
40	/// <summary>	40	/// <summary>
41	/// Holds information about a pending acknowledgement	41	/// Holds information about a pending acknowledgement
42	/// </summary>	42	/// </summary>
43	private struct PendingAck	43	private struct PendingAck
44	{	44	{
45	/// <summary>Sequence number of the packet to remove</summary>	45	/// <summary>Sequence number of the packet to remove</summary>
46	public uint SequenceNumber;	46	public uint SequenceNumber;
47	/// <summary>Environment.TickCount value when the remove was queued.	47	/// <summary>Environment.TickCount value when the remove was queued.
48	/// This is used to update round-trip times for packets</summary>	48	/// This is used to update round-trip times for packets</summary>
49	public int RemoveTime;	49	public int RemoveTime;
50	/// <summary>Whether or not this acknowledgement was attached to a	50	/// <summary>Whether or not this acknowledgement was attached to a
51	/// resent packet. If so, round-trip time will not be calculated</summary>	51	/// resent packet. If so, round-trip time will not be calculated</summary>
52	public bool FromResend;	52	public bool FromResend;
53		53
54	public PendingAck(uint sequenceNumber, int currentTime, bool fromResend)	54	public PendingAck(uint sequenceNumber, int currentTime, bool fromResend)
55	{	55	{
56	SequenceNumber = sequenceNumber;	56	SequenceNumber = sequenceNumber;
57	RemoveTime = currentTime;	57	RemoveTime = currentTime;
58	FromResend = fromResend;	58	FromResend = fromResend;
59	}	59	}
60	}	60	}
61		61
62	/// <summary>Holds the actual unacked packet data, sorted by sequence number</summary>	62	/// <summary>Holds the actual unacked packet data, sorted by sequence number</summary>
63	private Dictionary<uint, OutgoingPacket> m_packets = new Dictionary<uint, OutgoingPacket>();	63	private Dictionary<uint, OutgoingPacket> m_packets = new Dictionary<uint, OutgoingPacket>();
64	/// <summary>Holds packets that need to be added to the unacknowledged list</summary>	64	/// <summary>Holds packets that need to be added to the unacknowledged list</summary>
65	private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>();	65	private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>();
66	/// <summary>Holds information about pending acknowledgements</summary>	66	/// <summary>Holds information about pending acknowledgements</summary>
67	private LocklessQueue<PendingAck> m_pendingRemoves = new LocklessQueue<PendingAck>();	67	private LocklessQueue<PendingAck> m_pendingRemoves = new LocklessQueue<PendingAck>();
68		68
69	/// <summary>	69	/// <summary>
70	/// Add an unacked packet to the collection	70	/// Add an unacked packet to the collection
71	/// </summary>	71	/// </summary>
72	/// <param name="packet">Packet that is awaiting acknowledgement</param>	72	/// <param name="packet">Packet that is awaiting acknowledgement</param>
73	/// <returns>True if the packet was successfully added, false if the	73	/// <returns>True if the packet was successfully added, false if the
74	/// packet already existed in the collection</returns>	74	/// packet already existed in the collection</returns>
75	/// <remarks>This does not immediately add the ACK to the collection,	75	/// <remarks>This does not immediately add the ACK to the collection,
76	/// it only queues it so it can be added in a thread-safe way later</remarks>	76	/// it only queues it so it can be added in a thread-safe way later</remarks>
77	public void Add(OutgoingPacket packet)	77	public void Add(OutgoingPacket packet)
78	{	78	{
79	m_pendingAdds.Enqueue(packet);	79	m_pendingAdds.Enqueue(packet);
80	}	80	}
81		81
82	/// <summary>	82	/// <summary>
83	/// Marks a packet as acknowledged	83	/// Marks a packet as acknowledged
84	/// </summary>	84	/// </summary>
85	/// <param name="sequenceNumber">Sequence number of the packet to	85	/// <param name="sequenceNumber">Sequence number of the packet to
86	/// acknowledge</param>	86	/// acknowledge</param>
87	/// <param name="currentTime">Current value of Environment.TickCount</param>	87	/// <param name="currentTime">Current value of Environment.TickCount</param>
88	/// <remarks>This does not immediately acknowledge the packet, it only	88	/// <remarks>This does not immediately acknowledge the packet, it only
89	/// queues the ack so it can be handled in a thread-safe way later</remarks>	89	/// queues the ack so it can be handled in a thread-safe way later</remarks>
90	public void Remove(uint sequenceNumber, int currentTime, bool fromResend)	90	public void Remove(uint sequenceNumber, int currentTime, bool fromResend)
91	{	91	{
92	m_pendingRemoves.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));	92	m_pendingRemoves.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
93	}	93	}
94		94
95	/// <summary>	95	/// <summary>
96	/// Returns a list of all of the packets with a TickCount older than	96	/// Returns a list of all of the packets with a TickCount older than
97	/// the specified timeout	97	/// the specified timeout
98	/// </summary>	98	/// </summary>
99	/// <param name="timeoutMS">Number of ticks (milliseconds) before a	99	/// <param name="timeoutMS">Number of ticks (milliseconds) before a
100	/// packet is considered expired</param>	100	/// packet is considered expired</param>
101	/// <returns>A list of all expired packets according to the given	101	/// <returns>A list of all expired packets according to the given
102	/// expiration timeout</returns>	102	/// expiration timeout</returns>
103	/// <remarks>This function is not thread safe, and cannot be called	103	/// <remarks>This function is not thread safe, and cannot be called
104	/// multiple times concurrently</remarks>	104	/// multiple times concurrently</remarks>
105	public List<OutgoingPacket> GetExpiredPackets(int timeoutMS)	105	public List<OutgoingPacket> GetExpiredPackets(int timeoutMS)
106	{	106	{
107	ProcessQueues();	107	ProcessQueues();
108		108
109	List<OutgoingPacket> expiredPackets = null;	109	List<OutgoingPacket> expiredPackets = null;
110		110
111	if (m_packets.Count > 0)	111	if (m_packets.Count > 0)
112	{	112	{
113	int now = Environment.TickCount & Int32.MaxValue;	113	int now = Environment.TickCount & Int32.MaxValue;
114		114
115	foreach (OutgoingPacket packet in m_packets.Values)	115	foreach (OutgoingPacket packet in m_packets.Values)
116	{	116	{
117	// TickCount of zero means a packet is in the resend queue	117	// TickCount of zero means a packet is in the resend queue
118	// but hasn't actually been sent over the wire yet	118	// but hasn't actually been sent over the wire yet
119	if (packet.TickCount == 0)	119	if (packet.TickCount == 0)
120	continue;	120	continue;
121		121
122	if (now - packet.TickCount >= timeoutMS)	122	if (now - packet.TickCount >= timeoutMS)
123	{	123	{
124	if (expiredPackets == null)	124	if (expiredPackets == null)
125	expiredPackets = new List<OutgoingPacket>();	125	expiredPackets = new List<OutgoingPacket>();
126		126
127	// The TickCount will be set to the current time when the packet	127	// The TickCount will be set to the current time when the packet
128	// is actually sent out again	128	// is actually sent out again
129	packet.TickCount = 0;	129	packet.TickCount = 0;
130		130
131	expiredPackets.Add(packet);	131	expiredPackets.Add(packet);
132	}	132	}
133	}	133	}
134	}	134	}
135		135
136	return expiredPackets;	136	return expiredPackets;
137	}	137	}
138		138
139	private void ProcessQueues()	139	private void ProcessQueues()
140	{	140	{
141	// Process all the pending adds	141	// Process all the pending adds
142		142
143	OutgoingPacket pendingAdd;	143	OutgoingPacket pendingAdd;
144	if (m_pendingAdds != null)	144	if (m_pendingAdds != null)
145	{	145	{
146	while (m_pendingAdds.TryDequeue(out pendingAdd))	146	while (m_pendingAdds.TryDequeue(out pendingAdd))
147	{	147	{
148	if (pendingAdd != null && m_packets != null)	148	if (pendingAdd != null && m_packets != null)
149	{	149	{
150	m_packets[pendingAdd.SequenceNumber] = pendingAdd;	150	m_packets[pendingAdd.SequenceNumber] = pendingAdd;
151	}	151	}
152	}	152	}
153	}	153	}
154		154
155	// Process all the pending removes, including updating statistics and round-trip times	155	// Process all the pending removes, including updating statistics and round-trip times
156	PendingAck pendingRemove;	156	PendingAck pendingRemove;
157	OutgoingPacket ackedPacket;	157	OutgoingPacket ackedPacket;
158	if (m_pendingRemoves != null)	158	if (m_pendingRemoves != null)
159	{	159	{
160	while (m_pendingRemoves.TryDequeue(out pendingRemove))	160	while (m_pendingRemoves.TryDequeue(out pendingRemove))
161	{	161	{
162	if (m_pendingRemoves != null && m_packets != null)	162	if (m_pendingRemoves != null && m_packets != null)
163	{	163	{
164	if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))	164	if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))
165	{	165	{
166	m_packets.Remove(pendingRemove.SequenceNumber);	166	m_packets.Remove(pendingRemove.SequenceNumber);
167		167
168	// Update stats	168	// Update stats
169	System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);	169	System.Threading.Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
170		170
171	if (!pendingRemove.FromResend)	171	if (!pendingRemove.FromResend)
172	{	172	{
173	// Calculate the round-trip time for this packet and its ACK	173	// Calculate the round-trip time for this packet and its ACK
174	int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;	174	int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;
175	if (rtt > 0)	175	if (rtt > 0)
176	ackedPacket.Client.UpdateRoundTrip(rtt);	176	ackedPacket.Client.UpdateRoundTrip(rtt);
177	}	177	}
178	}	178	}
179	}	179	}
180	}	180	}
181	}	181	}
182	}	182	}
183	}	183	}
184	}	184	}