1 files changed, 85 insertions, 55 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
index 4eee6b6..71f4c47 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
@@ -33,6 +33,8 @@ using OpenSim.Framework;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
 
+using TokenBucket = OpenSim.Region.ClientStack.LindenUDP.TokenBucket;
+
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
     #region Delegates
@@ -98,12 +100,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>True when this connection is alive, otherwise false</summary>
         public bool IsConnected = true;
         /// <summary>True when this connection is paused, otherwise false</summary>
-        public bool IsPaused = true;
+        public bool IsPaused;
         /// <summary>Environment.TickCount when the last packet was received for this client</summary>
         public int TickLastPacketReceived;
 
-        /// <summary>Timer granularity. This is set to the measured resolution of Environment.TickCount</summary>
-        public readonly float G;
         /// <summary>Smoothed round-trip time. A smoothed average of the round-trip time for sending a
         /// reliable packet to the client and receiving an ACK</summary>
         public float SRTT;
@@ -163,26 +163,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             CircuitCode = circuitCode;
             m_udpServer = server;
             m_defaultThrottleRates = rates;
+            // Create a token bucket throttle for this client that has the scene token bucket as a parent
             m_throttle = new TokenBucket(parentThrottle, rates.TotalLimit, rates.Total);
+            // Create an array of token buckets for this clients different throttle categories
             m_throttleCategories = new TokenBucket[THROTTLE_CATEGORY_COUNT];
 
             for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
             {
                 ThrottleOutPacketType type = (ThrottleOutPacketType)i;
 
+                // Initialize the packet outboxes, where packets sit while they are waiting for tokens
                 m_packetOutboxes[i] = new OpenSim.Framework.LocklessQueue<OutgoingPacket>();
+                // Initialize the token buckets that control the throttling for each category
                 m_throttleCategories[i] = new TokenBucket(m_throttle, rates.GetLimit(type), rates.GetRate(type));
             }
 
-            // Set the granularity variable used for retransmission calculations to
-            // the measured resolution of Environment.TickCount
-            G = server.TickCountResolution;
-
             // Default the retransmission timeout to three seconds
             RTO = 3000;
 
             // Initialize this to a sane value to prevent early disconnects
-            TickLastPacketReceived = Environment.TickCount;
+            TickLastPacketReceived = Environment.TickCount & Int32.MaxValue;
         }
 
         /// <summary>
@@ -191,7 +191,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public void Shutdown()
         {
             IsConnected = false;
-            NeedAcks.Clear();
             for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
             {
                 m_packetOutboxes[i].Clear();
@@ -293,36 +292,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             int state = (int)((float)task * STATE_TASK_PERCENTAGE);
             task -= state;
 
-            int ceiling = Int32.MaxValue;
-            if (m_defaultThrottleRates.Total != 0)
-            {
-                ceiling = m_defaultThrottleRates.Total;
-                if (ceiling < Packet.MTU) ceiling = Packet.MTU;
-            }
-
-            resend = Utils.Clamp(resend, Packet.MTU, ceiling);
-            land = Utils.Clamp(land, Packet.MTU, ceiling);
-            wind = Utils.Clamp(wind, Packet.MTU, ceiling);
-            cloud = Utils.Clamp(cloud, Packet.MTU, ceiling);
-            task = Utils.Clamp(task, Packet.MTU, ceiling);
-            texture = Utils.Clamp(texture, Packet.MTU, ceiling);
-            asset = Utils.Clamp(asset, Packet.MTU, ceiling);
-            state = Utils.Clamp(state, Packet.MTU, ceiling);
+            // Make sure none of the throttles are set below our packet MTU,
+            // otherwise a throttle could become permanently clogged
+            resend = Math.Max(resend, LLUDPServer.MTU);
+            land = Math.Max(land, LLUDPServer.MTU);
+            wind = Math.Max(wind, LLUDPServer.MTU);
+            cloud = Math.Max(cloud, LLUDPServer.MTU);
+            task = Math.Max(task, LLUDPServer.MTU);
+            texture = Math.Max(texture, LLUDPServer.MTU);
+            asset = Math.Max(asset, LLUDPServer.MTU);
+            state = Math.Max(state, LLUDPServer.MTU);
 
             int total = resend + land + wind + cloud + task + texture + asset + state;
-            int taskTotal = task + state;
 
             m_log.DebugFormat("[LLUDPCLIENT]: {0} is setting throttles. Resend={1}, Land={2}, Wind={3}, Cloud={4}, Task={5}, Texture={6}, Asset={7}, State={8}, Total={9}",
                 AgentID, resend, land, wind, cloud, task, texture, asset, state, total);
 
-            SetThrottle(ThrottleOutPacketType.Resend, resend, resend);
-            SetThrottle(ThrottleOutPacketType.Land, land, land);
-            SetThrottle(ThrottleOutPacketType.Wind, wind, wind);
-            SetThrottle(ThrottleOutPacketType.Cloud, cloud, cloud);
-            SetThrottle(ThrottleOutPacketType.Task, task, taskTotal);
-            SetThrottle(ThrottleOutPacketType.Texture, texture, texture);
-            SetThrottle(ThrottleOutPacketType.Asset, asset, asset);
-            SetThrottle(ThrottleOutPacketType.State, state, taskTotal);
+            // Update the token buckets with new throttle values
+            TokenBucket bucket;
+
+            bucket = m_throttle;
+            bucket.MaxBurst = total;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Resend];
+            bucket.DripRate = resend;
+            bucket.MaxBurst = resend;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Land];
+            bucket.DripRate = land;
+            bucket.MaxBurst = land;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Wind];
+            bucket.DripRate = wind;
+            bucket.MaxBurst = wind;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Cloud];
+            bucket.DripRate = cloud;
+            bucket.MaxBurst = cloud;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Asset];
+            bucket.DripRate = asset;
+            bucket.MaxBurst = asset;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Task];
+            bucket.DripRate = task + state;
+            bucket.MaxBurst = task + state;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.State];
+            bucket.DripRate = state;
+            bucket.MaxBurst = state;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Texture];
+            bucket.DripRate = texture;
+            bucket.MaxBurst = texture;
         }
 
         public byte[] GetThrottlesPacked()
@@ -342,17 +364,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return data;
         }
 
-        public void SetThrottle(ThrottleOutPacketType category, int rate, int maxBurst)
-        {
-            int i = (int)category;
-            if (i >= 0 && i < m_throttleCategories.Length)
-            {
-                TokenBucket bucket = m_throttleCategories[(int)category];
-                bucket.DripRate = rate;
-                bucket.MaxBurst = maxBurst;
-            }
-        }
-
         public bool EnqueueOutgoing(OutgoingPacket packet)
         {
             int category = (int)packet.Category;
@@ -395,9 +406,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             TokenBucket bucket;
             bool packetSent = false;
 
+            //string queueDebugOutput = String.Empty; // Serious debug business
+
             for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
             {
                 bucket = m_throttleCategories[i];
+                //queueDebugOutput += m_packetOutboxes[i].Count + " ";  // Serious debug business
 
                 if (m_nextPackets[i] != null)
                 {
@@ -449,6 +463,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 }
             }
 
+            //m_log.Info("[LLUDPCLIENT]: Queues: " + queueDebugOutput); // Serious debug business
             return packetSent;
         }
 
@@ -479,8 +494,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 SRTT = (1.0f - ALPHA) * SRTT + ALPHA * r;
             }
 
-            // Always round retransmission timeout up to two seconds
-            RTO = Math.Max(2000, (int)(SRTT + Math.Max(G, K * RTTVAR)));
+            RTO = (int)(SRTT + Math.Max(m_udpServer.TickCountResolution, K * RTTVAR));
+
+            // Clamp the retransmission timeout to manageable values
+            RTO = Utils.Clamp(RTO, 3000, 10000);
+
             //m_log.Debug("[LLUDPCLIENT]: Setting agent " + this.Agent.FullName + "'s RTO to " + RTO + "ms with an RTTVAR of " +
             //    RTTVAR + " based on new RTT of " + r + "ms");
         }
@@ -493,8 +511,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// for</param>
         private void BeginFireQueueEmpty(int throttleIndex)
         {
-            if (!m_onQueueEmptyRunning[throttleIndex])
-                Util.FireAndForget(FireQueueEmpty, throttleIndex);
+            // Unknown is -1 and Resend is 0. Make sure we are only firing the 
+            // callback for categories other than those
+            if (throttleIndex > 0)
+            {
+                if (!m_onQueueEmptyRunning[throttleIndex])
+                {
+                    m_onQueueEmptyRunning[throttleIndex] = true;
+                    Util.FireAndForget(FireQueueEmpty, throttleIndex);
+                }
+            }
         }
 
         /// <summary>
@@ -509,16 +535,20 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             ThrottleOutPacketType type = (ThrottleOutPacketType)i;
             QueueEmpty callback = OnQueueEmpty;
 
+            int start = Environment.TickCount;
+
             if (callback != null)
             {
-                if (!m_onQueueEmptyRunning[i])
-                {
-                    m_onQueueEmptyRunning[i] = true;
-                    try { callback(type); }
-                    catch (Exception e) { m_log.Error("[LLUDPCLIENT]: OnQueueEmpty(" + type + ") threw an exception: " + e.Message, e); }
-                    m_onQueueEmptyRunning[i] = false;
-                }
+                try { callback(type); }
+                catch (Exception e) { m_log.Error("[LLUDPCLIENT]: OnQueueEmpty(" + type + ") threw an exception: " + e.Message, e); }
             }
+
+            // Make sure all queue empty calls take at least a measurable amount of time,
+            // otherwise we'll peg a CPU trying to fire these too fast
+            if (Environment.TickCount == start)
+                System.Threading.Thread.Sleep((int)m_udpServer.TickCountResolution);
+
+            m_onQueueEmptyRunning[i] = false;
         }
     }
 }