8 files changed, 417 insertions, 479 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 1f7e66d..43903ce 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -385,6 +385,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public bool IsGroupMember(UUID groupID) { return m_groupPowers.ContainsKey(groupID); }
 
         /// <summary>
+        /// Entity update queues
+        /// </summary>
+        public PriorityQueue EntityUpdateQueue { get { return m_entityUpdates; } }
+        
+        /// <summary>
         /// First name of the agent/avatar represented by the client
         /// </summary>
         public string FirstName { get { return m_firstName; } }
@@ -3561,6 +3566,44 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags, m_scene.TimeDilation));
         }
 
+        /// <summary>
+        /// Requeue an EntityUpdate when it was not acknowledged by the client. 
+        /// We will update the priority and put it in the correct queue, merging update flags 
+        /// with any other updates that may be queued for the same entity. 
+        /// The original update time is used for the merged update.
+        /// </summary>
+        private void ResendPrimUpdate(EntityUpdate update)
+        {
+            // If the update exists in priority queue, it will be updated.
+            // If it does not exist then it will be added with the current (rather than its original) priority
+            uint priority = m_prioritizer.GetUpdatePriority(this, update.Entity);
+
+            lock (m_entityUpdates.SyncRoot)
+                m_entityUpdates.Enqueue(priority, update);
+        }
+
+        /// <summary>
+        /// Requeue a list of EntityUpdates when they were not acknowledged by the client. 
+        /// We will update the priority and put it in the correct queue, merging update flags 
+        /// with any other updates that may be queued for the same entity. 
+        /// The original update time is used for the merged update.
+        /// </summary>
+        private void ResendPrimUpdates(List<EntityUpdate> updates, OutgoingPacket oPacket)
+        {
+            // m_log.WarnFormat("[CLIENT] resending prim update {0}",updates[0].UpdateTime);
+
+            // Remove the update packet from the list of packets waiting for acknowledgement
+            // because we are requeuing the list of updates. They will be resent in new packets
+            // with the most recent state and priority.
+            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
+
+            // Count this as a resent packet since we are going to requeue all of the updates contained in it
+            Interlocked.Increment(ref m_udpClient.PacketsResent);
+
+            foreach (EntityUpdate update in updates)
+                ResendPrimUpdate(update);
+        }
+
         private void ProcessEntityUpdates(int maxUpdates)
         {
             OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();
@@ -3568,6 +3611,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
             OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseAgentUpdateBlocks = new OpenSim.Framework.Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>();
 
+            OpenSim.Framework.Lazy<List<EntityUpdate>> objectUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+            OpenSim.Framework.Lazy<List<EntityUpdate>> compressedUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+            OpenSim.Framework.Lazy<List<EntityUpdate>> terseUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+            OpenSim.Framework.Lazy<List<EntityUpdate>> terseAgentUpdates = new OpenSim.Framework.Lazy<List<EntityUpdate>>();
+
             // Check to see if this is a flush
             if (maxUpdates <= 0)
             {
@@ -3583,7 +3631,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 float avgTimeDilation = 1.0f;
                 IEntityUpdate iupdate;
                 Int32 timeinqueue; // this is just debugging code & can be dropped later
-                
+
                 while (updatesThisCall < maxUpdates)
                 {
                     lock (m_entityUpdates.SyncRoot)
@@ -3688,24 +3736,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         if (update.Entity is ScenePresence)
                         {
                             objectUpdateBlocks.Value.Add(CreateAvatarUpdateBlock((ScenePresence)update.Entity));
+                            objectUpdates.Value.Add(update);
                         }
                         else
                         {
                             objectUpdateBlocks.Value.Add(CreatePrimUpdateBlock((SceneObjectPart)update.Entity, this.m_agentId));
+                            objectUpdates.Value.Add(update);
                         }
                     }
                     else if (!canUseImproved)
                     {
                         compressedUpdateBlocks.Value.Add(CreateCompressedUpdateBlock((SceneObjectPart)update.Entity, updateFlags));
+                        compressedUpdates.Value.Add(update);
                     }
                     else
                     {
                         if (update.Entity is ScenePresence && ((ScenePresence)update.Entity).UUID == AgentId)
+                        {
                             // Self updates go into a special list
                             terseAgentUpdateBlocks.Value.Add(CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures)));
+                            terseAgentUpdates.Value.Add(update);
+                        }
                         else
+                        {
                             // Everything else goes here
                             terseUpdateBlocks.Value.Add(CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures)));
+                            terseUpdates.Value.Add(update);
+                        }
                     }
     
                     #endregion Block Construction
@@ -3713,28 +3770,23 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 
     
                 #region Packet Sending
-        
-                //const float TIME_DILATION = 1.0f;
-
-
                 ushort timeDilation = Utils.FloatToUInt16(avgTimeDilation, 0.0f, 1.0f);
-    
+
                 if (terseAgentUpdateBlocks.IsValueCreated)
                 {
                     List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseAgentUpdateBlocks.Value;
-    
+
                     ImprovedTerseObjectUpdatePacket packet = new ImprovedTerseObjectUpdatePacket();
                     packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
                     packet.RegionData.TimeDilation = timeDilation;
                     packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[blocks.Count];
-    
+
                     for (int i = 0; i < blocks.Count; i++)
                         packet.ObjectData[i] = blocks[i];
-
-                    
-                    OutPacket(packet, ThrottleOutPacketType.Unknown, true);
+                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
+                    OutPacket(packet, ThrottleOutPacketType.Unknown, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseAgentUpdates.Value, oPacket); });
                 }
-    
+
                 if (objectUpdateBlocks.IsValueCreated)
                 {
                     List<ObjectUpdatePacket.ObjectDataBlock> blocks = objectUpdateBlocks.Value;
@@ -3746,8 +3798,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         
                     for (int i = 0; i < blocks.Count; i++)
                         packet.ObjectData[i] = blocks[i];
-        
-                    OutPacket(packet, ThrottleOutPacketType.Task, true);
+                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
+                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(objectUpdates.Value, oPacket); });
                 }
         
                 if (compressedUpdateBlocks.IsValueCreated)
@@ -3761,10 +3813,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         
                     for (int i = 0; i < blocks.Count; i++)
                         packet.ObjectData[i] = blocks[i];
-        
-                    OutPacket(packet, ThrottleOutPacketType.Task, true);
+                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
+                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(compressedUpdates.Value, oPacket); });
                 }
-        
+
                 if (terseUpdateBlocks.IsValueCreated)
                 {
                     List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseUpdateBlocks.Value;
@@ -3776,8 +3828,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         
                     for (int i = 0; i < blocks.Count; i++)
                         packet.ObjectData[i] = blocks[i];
-        
-                    OutPacket(packet, ThrottleOutPacketType.Task, true);
+                    // If any of the packets created from this call go unacknowledged, all of the updates will be resent
+                    OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseUpdates.Value, oPacket); });
                 }
             }
 
@@ -3969,7 +4021,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 SendFamilyProps = SendFamilyProps || update.SendFamilyProps;
                 SendObjectProps = SendObjectProps || update.SendObjectProps;
-                Flags |= update.Flags;
+                // other properties may need to be updated by base class
+                base.Update(update);
             }
         }
         
@@ -3980,6 +4033,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_entityProps.Enqueue(priority, new ObjectPropertyUpdate(entity,requestFlags,true,false));
         }
 
+        private void ResendPropertyUpdate(ObjectPropertyUpdate update)
+        {
+            uint priority = 0;
+            lock (m_entityProps.SyncRoot)
+                m_entityProps.Enqueue(priority, update);
+        }
+
+        private void ResendPropertyUpdates(List<ObjectPropertyUpdate> updates, OutgoingPacket oPacket)
+        {
+            // m_log.WarnFormat("[CLIENT] resending object property {0}",updates[0].UpdateTime);
+
+            // Remove the update packet from the list of packets waiting for acknowledgement
+            // because we are requeuing the list of updates. They will be resent in new packets
+            // with the most recent state.
+            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
+
+            // Count this as a resent packet since we are going to requeue all of the updates contained in it
+            Interlocked.Increment(ref m_udpClient.PacketsResent);
+
+            foreach (ObjectPropertyUpdate update in updates)
+                ResendPropertyUpdate(update);
+        }
+        
         public void SendObjectPropertiesReply(ISceneEntity entity)
         {
             uint priority = 0;  // time based ordering only
@@ -3995,6 +4071,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>> objectPropertiesBlocks =
                 new OpenSim.Framework.Lazy<List<ObjectPropertiesPacket.ObjectDataBlock>>();
 
+            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> familyUpdates =
+                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+
+            OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>> propertyUpdates =
+                new OpenSim.Framework.Lazy<List<ObjectPropertyUpdate>>();
+            
             IEntityUpdate iupdate;
             Int32 timeinqueue; // this is just debugging code & can be dropped later
 
@@ -4013,6 +4095,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         SceneObjectPart sop = (SceneObjectPart)update.Entity;
                         ObjectPropertiesFamilyPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesFamilyBlock(sop,update.Flags);
                         objectFamilyBlocks.Value.Add(objPropDB);
+                        familyUpdates.Value.Add(update);
                     }
                 }
 
@@ -4023,6 +4106,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         SceneObjectPart sop = (SceneObjectPart)update.Entity;
                         ObjectPropertiesPacket.ObjectDataBlock objPropDB = CreateObjectPropertiesBlock(sop);
                         objectPropertiesBlocks.Value.Add(objPropDB);
+                        propertyUpdates.Value.Add(update);
                     }
                 }
 
@@ -4030,12 +4114,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             
 
-            Int32 ppcnt = 0;
-            Int32 pbcnt = 0;
+            // Int32 ppcnt = 0;
+            // Int32 pbcnt = 0;
             
             if (objectPropertiesBlocks.IsValueCreated)
             {
                 List<ObjectPropertiesPacket.ObjectDataBlock> blocks = objectPropertiesBlocks.Value;
+                List<ObjectPropertyUpdate> updates = propertyUpdates.Value;
 
                 ObjectPropertiesPacket packet = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
                 packet.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[blocks.Count];
@@ -4043,28 +4128,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     packet.ObjectData[i] = blocks[i];
 
                 packet.Header.Zerocoded = true;
-                OutPacket(packet, ThrottleOutPacketType.Task, true);
 
-                pbcnt += blocks.Count;
-                ppcnt++;
+                // Pass in the delegate so that if this packet needs to be resent, we send the current properties
+                // of the object rather than the properties when the packet was created
+                OutPacket(packet, ThrottleOutPacketType.Task, true,
+                          delegate(OutgoingPacket oPacket)
+                          {
+                              ResendPropertyUpdates(updates, oPacket);
+                          });
+
+                // pbcnt += blocks.Count;
+                // ppcnt++;
             }
             
-            Int32 fpcnt = 0;
-            Int32 fbcnt = 0;
+            // Int32 fpcnt = 0;
+            // Int32 fbcnt = 0;
             
             if (objectFamilyBlocks.IsValueCreated)
             {
                 List<ObjectPropertiesFamilyPacket.ObjectDataBlock> blocks = objectFamilyBlocks.Value;
-
-                // ObjectPropertiesFamilyPacket objPropFamilyPack =
-                //     (ObjectPropertiesFamilyPacket)PacketPool.Instance.GetPacket(PacketType.ObjectPropertiesFamily);
-                //
-                // objPropFamilyPack.ObjectData = new ObjectPropertiesFamilyPacket.ObjectDataBlock[blocks.Count];
-                // for (int i = 0; i < blocks.Count; i++)
-                //     objPropFamilyPack.ObjectData[i] = blocks[i];
-                //
-                // OutPacket(objPropFamilyPack, ThrottleOutPacketType.Task, true);
-
+                
                 // one packet per object block... uggh...
                 for (int i = 0; i < blocks.Count; i++)
                 {
@@ -4073,10 +4156,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     packet.ObjectData = blocks[i];
                     packet.Header.Zerocoded = true;
-                    OutPacket(packet, ThrottleOutPacketType.Task);
 
-                    fpcnt++;
-                    fbcnt++;
+                    // Pass in the delegate so that if this packet needs to be resent, we send the current properties
+                    // of the object rather than the properties when the packet was created
+                    List<ObjectPropertyUpdate> updates = new List<ObjectPropertyUpdate>();
+                    updates.Add(familyUpdates.Value[i]);
+                    OutPacket(packet, ThrottleOutPacketType.Task, true,
+                              delegate(OutgoingPacket oPacket)
+                              {
+                                  ResendPropertyUpdates(updates, oPacket);
+                              });
+
+                    // fpcnt++;
+                    // fbcnt++;
                 }
                 
             }
@@ -4113,7 +4205,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             return block;
         }
-
+    
         private ObjectPropertiesPacket.ObjectDataBlock CreateObjectPropertiesBlock(SceneObjectPart sop)
         {
             //ObjectPropertiesPacket proper = (ObjectPropertiesPacket)PacketPool.Instance.GetPacket(PacketType.ObjectProperties);
@@ -4764,7 +4856,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             data.RelativePosition.ToBytes(objectData, 0);
             data.Velocity.ToBytes(objectData, 12);
             data.Acceleration.ToBytes(objectData, 24);
-            data.RotationOffset.ToBytes(objectData, 36);
+            try
+            {
+                data.RotationOffset.ToBytes(objectData, 36);
+            }
+            catch (Exception e)
+            {
+                m_log.Warn("[LLClientView]: exception converting quaternion to bytes, using Quaternion.Identity. Exception: " + e.ToString());
+                OpenMetaverse.Quaternion.Identity.ToBytes(objectData, 36);
+            }
             data.AngularVelocity.ToBytes(objectData, 48);
 
             ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();
@@ -11328,7 +11428,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <returns></returns>
         public byte[] GetThrottlesPacked(float multiplier)
         {
-            return m_udpClient.GetThrottlesPacked();
+            return m_udpClient.GetThrottlesPacked(multiplier);
         }
 
         /// <summary>
@@ -11363,6 +11463,22 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// handles splitting manually</param>
         protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting)
         {
+            OutPacket(packet, throttlePacketType, doAutomaticSplitting, null);
+        }
+
+        /// <summary>
+        /// This is the starting point for sending a simulator packet out to the client
+        /// </summary>
+        /// <param name="packet">Packet to send</param>
+        /// <param name="throttlePacketType">Throttling category for the packet</param>
+        /// <param name="doAutomaticSplitting">True to automatically split oversized
+        /// packets (the default), or false to disable splitting if the calling code
+        /// handles splitting manually</param>
+        /// <param name="method">The method to be called in the event this packet is reliable
+        /// and unacknowledged. The server will provide normal resend capability if you do not
+        /// provide your own method.</param>
+        protected void OutPacket(Packet packet, ThrottleOutPacketType throttlePacketType, bool doAutomaticSplitting, UnackedPacketMethod method)
+        {
             if (m_debugPacketLevel > 0)
             {
                 bool logPacket = true;
@@ -11388,7 +11504,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     m_log.DebugFormat("[CLIENT]: Packet OUT {0}", packet.Type);
             }
             
-            m_udpServer.SendPacket(m_udpClient, packet, throttlePacketType, doAutomaticSplitting);
+            m_udpServer.SendPacket(m_udpClient, packet, throttlePacketType, doAutomaticSplitting, method);
         }
 
         public bool AddMoney(int debit)
@@ -11519,7 +11635,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             info.userEP = m_userEndPoint;
             info.proxyEP = null;
-            info.agentcircuit = new sAgentCircuitData(RequestClientInfo());
+            info.agentcircuit = RequestClientInfo();
 
             return info;
         }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
index 7be8a0a..ca5501d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
@@ -135,7 +135,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private int m_nextOnQueueEmpty = 1;
 
         /// <summary>Throttle bucket for this agent's connection</summary>
-        private readonly TokenBucket m_throttleClient;
+        private readonly AdaptiveTokenBucket m_throttleClient;
+        public AdaptiveTokenBucket FlowThrottle
+        {
+            get { return m_throttleClient; }
+        }
+
         /// <summary>Throttle bucket for this agent's connection</summary>
         private readonly TokenBucket m_throttleCategory;
         /// <summary>Throttle buckets for each packet category</summary>
@@ -176,9 +181,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_maxRTO = maxRTO;
 
             // Create a token bucket throttle for this client that has the scene token bucket as a parent
-            m_throttleClient = new TokenBucket(parentThrottle, rates.TotalLimit);
+            m_throttleClient = new AdaptiveTokenBucket(parentThrottle, rates.Total, rates.AdaptiveThrottlesEnabled);
             // Create a token bucket throttle for the total categary with the client bucket as a throttle
-            m_throttleCategory = new TokenBucket(m_throttleClient, rates.TotalLimit);
+            m_throttleCategory = new TokenBucket(m_throttleClient, 0);
             // Create an array of token buckets for this clients different throttle categories
             m_throttleCategories = new TokenBucket[THROTTLE_CATEGORY_COUNT];
 
@@ -189,7 +194,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 // 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_throttleCategory, rates.GetLimit(type));
+                m_throttleCategories[i] = new TokenBucket(m_throttleCategory, rates.GetRate(type));
             }
 
             // Default the retransmission timeout to three seconds
@@ -223,26 +228,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <returns>Information about the client connection</returns>
         public ClientInfo GetClientInfo()
         {
-///<mic>
-            TokenBucket tb;
-
-            tb = m_throttleClient.Parent;
-            m_log.WarnFormat("[TOKENS] {3}: Actual={0},Request={1},TotalRequest={2}",tb.DripRate,tb.RequestedDripRate,tb.TotalDripRequest,"ROOT");
-
-            tb = m_throttleClient;
-            m_log.WarnFormat("[TOKENS] {3}: Actual={0},Request={1},TotalRequest={2}",tb.DripRate,tb.RequestedDripRate,tb.TotalDripRequest,"  CLIENT");
-
-            tb = m_throttleCategory;
-            m_log.WarnFormat("[TOKENS] {3}: Actual={0},Request={1},TotalRequest={2}",tb.DripRate,tb.RequestedDripRate,tb.TotalDripRequest,"    CATEGORY");
-
-            for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
-            {
-                tb = m_throttleCategories[i];
-                m_log.WarnFormat("[TOKENS] {4} <{0}:{1}>: Actual={2},Requested={3}",AgentID,i,tb.DripRate,tb.RequestedDripRate,"      BUCKET");
-            }
-                
-///</mic>
-
             // TODO: This data structure is wrong in so many ways. Locking and copying the entire lists
             // of pending and needed ACKs for every client every time some method wants information about
             // this connection is a recipe for poor performance
@@ -254,12 +239,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             info.landThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Land].DripRate;
             info.windThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Wind].DripRate;
             info.cloudThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].DripRate;
-            // info.taskThrottle = m_throttleCategories[(int)ThrottleOutPacketType.State].DripRate + m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
             info.taskThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Task].DripRate;
             info.assetThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Asset].DripRate;
             info.textureThrottle = (int)m_throttleCategories[(int)ThrottleOutPacketType.Texture].DripRate;
-            info.totalThrottle = info.resendThrottle + info.landThrottle + info.windThrottle + info.cloudThrottle +
-                info.taskThrottle + info.assetThrottle + info.textureThrottle;
+            info.totalThrottle = (int)m_throttleCategory.DripRate;
 
             return info;
         }
@@ -346,8 +329,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
             // State is a subcategory of task that we allocate a percentage to
             int state = 0;
-            // int state = (int)((float)task * STATE_TASK_PERCENTAGE);
-            // task -= state;
 
             // Make sure none of the throttles are set below our packet MTU,
             // otherwise a throttle could become permanently clogged
@@ -358,19 +339,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             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;
 
-            //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);
+            //int total = resend + land + wind + cloud + task + texture + asset;
+            //m_log.DebugFormat("[LLUDPCLIENT]: {0} is setting throttles. Resend={1}, Land={2}, Wind={3}, Cloud={4}, Task={5}, Texture={6}, Asset={7}, Total={8}",
+            //                  AgentID, resend, land, wind, cloud, task, texture, asset, total);
 
             // Update the token buckets with new throttle values
             TokenBucket bucket;
 
-            bucket = m_throttleCategory;
-            bucket.RequestedDripRate = total;
-
             bucket = m_throttleCategories[(int)ThrottleOutPacketType.Resend];
             bucket.RequestedDripRate = resend;
 
@@ -399,22 +375,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_packedThrottles = null;
         }
 
-        public byte[] GetThrottlesPacked()
+        public byte[] GetThrottlesPacked(float multiplier)
         {
             byte[] data = m_packedThrottles;
 
             if (data == null)
             {
+                float rate;
+
                 data = new byte[7 * 4];
                 int i = 0;
 
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].RequestedDripRate), 0, data, i, 4); i += 4;
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Land].RequestedDripRate), 0, data, i, 4); i += 4;
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Wind].RequestedDripRate), 0, data, i, 4); i += 4;
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].RequestedDripRate), 0, data, i, 4); i += 4;
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Task].RequestedDripRate), 0, data, i, 4); i += 4;
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Texture].RequestedDripRate), 0, data, i, 4); i += 4;
-                Buffer.BlockCopy(Utils.FloatToBytes((float)m_throttleCategories[(int)ThrottleOutPacketType.Asset].RequestedDripRate), 0, data, i, 4); i += 4;
+                // multiply by 8 to convert bytes back to bits
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Resend].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Land].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Wind].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Cloud].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Task].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Texture].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
+
+                rate = (float)m_throttleCategories[(int)ThrottleOutPacketType.Asset].RequestedDripRate * 8 * multiplier;
+                Buffer.BlockCopy(Utils.FloatToBytes(rate), 0, data, i, 4); i += 4;
 
                 m_packedThrottles = data;
             }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index d08b25f..aff90c5 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -297,7 +297,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         delegate(IClientAPI client)
                         {
                             if (client is LLClientView)
-                                SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category);
+                                SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category, null);
                         }
                     );
                 }
@@ -309,7 +309,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     delegate(IClientAPI client)
                     {
                         if (client is LLClientView)
-                            SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category);
+                            SendPacketData(((LLClientView)client).UDPClient, data, packet.Type, category, null);
                     }
                 );
             }
@@ -322,7 +322,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="packet"></param>
         /// <param name="category"></param>
         /// <param name="allowSplitting"></param>
-        public void SendPacket(LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting)
+        public void SendPacket(LLUDPClient udpClient, Packet packet, ThrottleOutPacketType category, bool allowSplitting, UnackedPacketMethod method)
         {
             // CoarseLocationUpdate packets cannot be split in an automated way
             if (packet.Type == PacketType.CoarseLocationUpdate && allowSplitting)
@@ -339,13 +339,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 for (int i = 0; i < packetCount; i++)
                 {
                     byte[] data = datas[i];
-                    SendPacketData(udpClient, data, packet.Type, category);
+                    SendPacketData(udpClient, data, packet.Type, category, method);
                 }
             }
             else
             {
                 byte[] data = packet.ToBytes();
-                SendPacketData(udpClient, data, packet.Type, category);
+                SendPacketData(udpClient, data, packet.Type, category, method);
             }
         }
 
@@ -356,7 +356,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="data"></param>
         /// <param name="type"></param>
         /// <param name="category"></param>        
-        public void SendPacketData(LLUDPClient udpClient, byte[] data, PacketType type, ThrottleOutPacketType category)
+        public void SendPacketData(LLUDPClient udpClient, byte[] data, PacketType type, ThrottleOutPacketType category, UnackedPacketMethod method)
         {
             int dataLength = data.Length;
             bool doZerocode = (data[0] & Helpers.MSG_ZEROCODED) != 0;
@@ -411,7 +411,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             #region Queue or Send
 
-            OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category);
+            OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category, null);
+            // If we were not provided a method for handling unacked, use the UDPServer default method
+            outgoingPacket.UnackedMethod = ((method == null) ? delegate(OutgoingPacket oPacket) { ResendUnacked(oPacket); } : method);
 
             // If a Linden Lab 1.23.5 client receives an update packet after a kill packet for an object, it will 
             // continue to display the deleted object until relog.  Therefore, we need to always queue a kill object
@@ -445,7 +447,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 packet.Header.Reliable = false;
                 packet.Packets = blocks.ToArray();
 
-                SendPacket(udpClient, packet, ThrottleOutPacketType.Unknown, true);
+                SendPacket(udpClient, packet, ThrottleOutPacketType.Unknown, true, null);
             }
         }
 
@@ -458,17 +460,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // We *could* get OldestUnacked, but it would hurt performance and not provide any benefit
             pc.PingID.OldestUnacked = 0;
 
-            SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false);
+            SendPacket(udpClient, pc, ThrottleOutPacketType.Unknown, false, null);
         }
 
         public void CompletePing(LLUDPClient udpClient, byte pingID)
         {
             CompletePingCheckPacket completePing = new CompletePingCheckPacket();
             completePing.PingID.PingID = pingID;
-            SendPacket(udpClient, completePing, ThrottleOutPacketType.Unknown, false);
+            SendPacket(udpClient, completePing, ThrottleOutPacketType.Unknown, false, null);
         }
 
-        public void ResendUnacked(LLUDPClient udpClient)
+        public void HandleUnacked(LLUDPClient udpClient)
         {
             if (!udpClient.IsConnected)
                 return;
@@ -488,31 +490,29 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             if (expiredPackets != null)
             {
-                //m_log.Debug("[LLUDPSERVER]: Resending " + expiredPackets.Count + " packets to " + udpClient.AgentID + ", RTO=" + udpClient.RTO);
-
+                //m_log.Debug("[LLUDPSERVER]: Handling " + expiredPackets.Count + " packets to " + udpClient.AgentID + ", RTO=" + udpClient.RTO);
                 // Exponential backoff of the retransmission timeout
                 udpClient.BackoffRTO();
+                for (int i = 0; i < expiredPackets.Count; ++i)
+                    expiredPackets[i].UnackedMethod(expiredPackets[i]);
+            }
+        }
 
-                // Resend packets
-                for (int i = 0; i < expiredPackets.Count; i++)
-                {
-                    OutgoingPacket outgoingPacket = expiredPackets[i];
-
-                    //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
-                    //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
+        public void ResendUnacked(OutgoingPacket outgoingPacket)
+        {
+            //m_log.DebugFormat("[LLUDPSERVER]: Resending packet #{0} (attempt {1}), {2}ms have passed",
+            //    outgoingPacket.SequenceNumber, outgoingPacket.ResendCount, Environment.TickCount - outgoingPacket.TickCount);
 
-                    // Set the resent flag
-                    outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
-                    outgoingPacket.Category = ThrottleOutPacketType.Resend;
+            // Set the resent flag
+            outgoingPacket.Buffer.Data[0] = (byte)(outgoingPacket.Buffer.Data[0] | Helpers.MSG_RESENT);
+            outgoingPacket.Category = ThrottleOutPacketType.Resend;
 
-                    // Bump up the resend count on this packet
-                    Interlocked.Increment(ref outgoingPacket.ResendCount);
+            // Bump up the resend count on this packet
+            Interlocked.Increment(ref outgoingPacket.ResendCount);
 
-                    // Requeue or resend the packet
-                    if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, false))
-                        SendPacketFinal(outgoingPacket);
-                }
-            }
+            // Requeue or resend the packet
+            if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket, false))
+                SendPacketFinal(outgoingPacket);
         }
 
         public void Flush(LLUDPClient udpClient)
@@ -672,7 +672,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (packet.Header.AppendedAcks && packet.Header.AckList != null)
             {
                 for (int i = 0; i < packet.Header.AckList.Length; i++)
-                    udpClient.NeedAcks.Remove(packet.Header.AckList[i], now, packet.Header.Resent);
+                    udpClient.NeedAcks.Acknowledge(packet.Header.AckList[i], now, packet.Header.Resent);
             }
 
             // Handle PacketAck packets
@@ -681,7 +681,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 PacketAckPacket ackPacket = (PacketAckPacket)packet;
 
                 for (int i = 0; i < ackPacket.Packets.Length; i++)
-                    udpClient.NeedAcks.Remove(ackPacket.Packets[i].ID, now, packet.Header.Resent);
+                    udpClient.NeedAcks.Acknowledge(ackPacket.Packets[i].ID, now, packet.Header.Resent);
 
                 // We don't need to do anything else with PacketAck packets
                 return;
@@ -1096,7 +1096,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (udpClient.IsConnected)
                     {
                         if (m_resendUnacked)
-                            ResendUnacked(udpClient);
+                            HandleUnacked(udpClient);
 
                         if (m_sendAcks)
                             SendAcks(udpClient);
@@ -1152,7 +1152,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             nticksUnack++;
                             watch2.Start();
 
-                            ResendUnacked(udpClient);
+                            HandleUnacked(udpClient);
 
                             watch2.Stop();
                             avgResendUnackedTicks = (nticksUnack - 1)/(float)nticksUnack * avgResendUnackedTicks + (watch2.ElapsedTicks / (float)nticksUnack);
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs b/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
index 1a1a1cb..76c6c14 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
@@ -31,6 +31,8 @@ using OpenMetaverse;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
+
+    public delegate void UnackedPacketMethod(OutgoingPacket oPacket);
     /// <summary>
     /// Holds a reference to the <seealso cref="LLUDPClient"/> this packet is
     /// destined for, along with the serialized packet data, sequence number
@@ -52,6 +54,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public int TickCount;
         /// <summary>Category this packet belongs to</summary>
         public ThrottleOutPacketType Category;
+        /// <summary>The delegate to be called if this packet is determined to be unacknowledged</summary>
+        public UnackedPacketMethod UnackedMethod;
 
         /// <summary>
         /// Default constructor
@@ -60,11 +64,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="buffer">Serialized packet data. If the flags or sequence number
         /// need to be updated, they will be injected directly into this binary buffer</param>
         /// <param name="category">Throttling category for this packet</param>
-        public OutgoingPacket(LLUDPClient client, UDPPacketBuffer buffer, ThrottleOutPacketType category)
+        public OutgoingPacket(LLUDPClient client, UDPPacketBuffer buffer, ThrottleOutPacketType category, UnackedPacketMethod method)
         {
             Client = client;
             Buffer = buffer;
             Category = category;
+            UnackedMethod = method;
         }
     }
 }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/PriorityQueue.cs b/OpenSim/Region/ClientStack/LindenUDP/PriorityQueue.cs
deleted file mode 100644
index b62ec07..0000000
--- a/OpenSim/Region/ClientStack/LindenUDP/PriorityQueue.cs
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * 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
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Reflection;
-
-using OpenSim.Framework;
-using OpenSim.Framework.Client;
-using log4net;
-
-namespace OpenSim.Region.ClientStack.LindenUDP
-{
-    public class PriorityQueue
-    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        internal delegate bool UpdatePriorityHandler(ref uint priority, ISceneEntity entity);
-
-        // Heap[0] for self updates
-        // Heap[1..12] for entity updates
-
-        internal const uint m_numberOfQueues = 12;
-
-        private MinHeap<MinHeapItem>[] m_heaps = new MinHeap<MinHeapItem>[m_numberOfQueues];
-        private Dictionary<uint, LookupItem> m_lookupTable;
-        private uint m_nextQueue = 0;
-        private UInt64 m_nextRequest = 0;
-
-        private object m_syncRoot = new object();
-        public object SyncRoot {
-            get { return this.m_syncRoot; }
-        }
-
-        internal PriorityQueue() : this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY) { }
-
-        internal PriorityQueue(int capacity)
-        {
-            m_lookupTable = new Dictionary<uint, LookupItem>(capacity);
-
-            for (int i = 0; i < m_heaps.Length; ++i)
-                m_heaps[i] = new MinHeap<MinHeapItem>(capacity);
-        }
-
-        internal int Count
-        {
-            get
-            {
-                int count = 0;
-                for (int i = 0; i < m_heaps.Length; ++i)
-                    count += m_heaps[i].Count;
-                return count;
-            }
-        }
-
-        public bool Enqueue(uint pqueue, IEntityUpdate value)
-        {
-            LookupItem lookup;
-
-            uint localid = value.Entity.LocalId;
-            UInt64 entry = m_nextRequest++;
-            if (m_lookupTable.TryGetValue(localid, out lookup))
-            {
-                entry = lookup.Heap[lookup.Handle].EntryOrder;
-                value.Update(lookup.Heap[lookup.Handle].Value);
-                lookup.Heap.Remove(lookup.Handle);
-            }
-
-            pqueue = Util.Clamp<uint>(pqueue, 0, m_numberOfQueues - 1);
-            lookup.Heap = m_heaps[pqueue];
-            lookup.Heap.Add(new MinHeapItem(pqueue, entry, value), ref lookup.Handle);
-            m_lookupTable[localid] = lookup;
-
-            return true;
-        }
-
-        internal bool TryDequeue(out IEntityUpdate value, out Int32 timeinqueue)
-        {
-            for (int i = 0; i < m_numberOfQueues; ++i)
-            {
-                // To get the fair queing, we cycle through each of the
-                // queues when finding an element to dequeue, this code
-                // assumes that the distribution of updates in the queues
-                // is polynomial, probably quadractic (eg distance of PI * R^2)
-                uint h = (uint)((m_nextQueue + i) % m_numberOfQueues);
-                if (m_heaps[h].Count > 0)
-                {
-                    m_nextQueue = (uint)((h + 1) % m_numberOfQueues);
-
-                    MinHeapItem item = m_heaps[h].RemoveMin();
-                    m_lookupTable.Remove(item.Value.Entity.LocalId);
-                    timeinqueue = Util.EnvironmentTickCountSubtract(item.EntryTime);
-                    value = item.Value;
-
-                    return true;
-                }
-            }
-
-            timeinqueue = 0;
-            value = default(IEntityUpdate);
-            return false;
-        }
-
-        internal void Reprioritize(UpdatePriorityHandler handler)
-        {
-            MinHeapItem item;
-            foreach (LookupItem lookup in new List<LookupItem>(this.m_lookupTable.Values))
-            {
-                if (lookup.Heap.TryGetValue(lookup.Handle, out item))
-                {
-                    uint pqueue = item.PriorityQueue;
-                    uint localid = item.Value.Entity.LocalId;
-
-                    if (handler(ref pqueue, item.Value.Entity))
-                    {
-                        // unless the priority queue has changed, there is no need to modify
-                        // the entry
-                        pqueue = Util.Clamp<uint>(pqueue, 0, m_numberOfQueues - 1);
-                        if (pqueue != item.PriorityQueue)
-                        {
-                            lookup.Heap.Remove(lookup.Handle);
-
-                            LookupItem litem = lookup;
-                            litem.Heap = m_heaps[pqueue];
-                            litem.Heap.Add(new MinHeapItem(pqueue, item), ref litem.Handle);
-                            m_lookupTable[localid] = litem;
-                        }
-                    }
-                    else
-                    {
-                        // m_log.WarnFormat("[PQUEUE]: UpdatePriorityHandler returned false for {0}",item.Value.Entity.UUID);
-                        lookup.Heap.Remove(lookup.Handle);
-                        this.m_lookupTable.Remove(localid);
-                    }
-                }
-            }
-        }
-
-        public override string ToString()
-        {
-            string s = "";
-            for (int i = 0; i < m_numberOfQueues; i++)
-            {
-                if (s != "") s += ",";
-                s += m_heaps[i].Count.ToString();
-            }
-            return s;
-        }
-
-#region MinHeapItem
-        private struct MinHeapItem : IComparable<MinHeapItem>
-        {
-            private IEntityUpdate value;
-            internal IEntityUpdate Value {
-                get {
-                    return this.value;
-                }
-            }
-
-            private uint pqueue;
-            internal uint PriorityQueue {
-                get {
-                    return this.pqueue;
-                }
-            }
-
-            private Int32 entrytime;
-            internal Int32 EntryTime {
-                get {
-                    return this.entrytime;
-                }
-            }
-
-            private UInt64 entryorder;
-            internal UInt64 EntryOrder
-            {
-                get {
-                    return this.entryorder;
-                }
-            }
-
-            internal MinHeapItem(uint pqueue, MinHeapItem other)
-            {
-                this.entrytime = other.entrytime;
-                this.entryorder = other.entryorder;
-                this.value = other.value;
-                this.pqueue = pqueue;
-            }
-
-            internal MinHeapItem(uint pqueue, UInt64 entryorder, IEntityUpdate value)
-            {
-                this.entrytime = Util.EnvironmentTickCount();
-                this.entryorder = entryorder;
-                this.value = value;
-                this.pqueue = pqueue;
-            }
-
-            public override string ToString()
-            {
-                return String.Format("[{0},{1},{2}]",pqueue,entryorder,value.Entity.LocalId);
-            }
-
-            public int CompareTo(MinHeapItem other)
-            {
-                // I'm assuming that the root part of an SOG is added to the update queue
-                // before the component parts
-                return Comparer<UInt64>.Default.Compare(this.EntryOrder, other.EntryOrder);
-            }
-        }
-#endregion
-
-#region LookupItem
-        private struct LookupItem
-        {
-            internal MinHeap<MinHeapItem> Heap;
-            internal IHandle Handle;
-        }
-#endregion
-    }
-}
diff --git a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs b/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
index aaf6e26..c9aac0b 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
@@ -52,30 +52,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public int Texture;
         /// <summary>Drip rate for asset packets</summary>
         public int Asset;
-        /// <summary>Drip rate for state packets</summary>
-        public int State;
+
         /// <summary>Drip rate for the parent token bucket</summary>
         public int Total;
 
-        /// <summary>Maximum burst rate for resent packets</summary>
-        public int ResendLimit;
-        /// <summary>Maximum burst rate for land packets</summary>
-        public int LandLimit;
-        /// <summary>Maximum burst rate for wind packets</summary>
-        public int WindLimit;
-        /// <summary>Maximum burst rate for cloud packets</summary>
-        public int CloudLimit;
-        /// <summary>Maximum burst rate for task (state and transaction) packets</summary>
-        public int TaskLimit;
-        /// <summary>Maximum burst rate for texture packets</summary>
-        public int TextureLimit;
-        /// <summary>Maximum burst rate for asset packets</summary>
-        public int AssetLimit;
-        /// <summary>Maximum burst rate for state packets</summary>
-        public int StateLimit;
-        /// <summary>Burst rate for the parent token bucket</summary>
-        public int TotalLimit;
-
+        /// <summary>Flag used to enable adaptive throttles</summary>
+        public bool AdaptiveThrottlesEnabled;
+        
         /// <summary>
         /// Default constructor
         /// </summary>
@@ -86,26 +69,17 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 IConfig throttleConfig = config.Configs["ClientStack.LindenUDP"];
 
-                Resend = throttleConfig.GetInt("resend_default", 12500);
-                Land = throttleConfig.GetInt("land_default", 1000);
-                Wind = throttleConfig.GetInt("wind_default", 1000);
-                Cloud = throttleConfig.GetInt("cloud_default", 1000);
-                Task = throttleConfig.GetInt("task_default", 1000);
-                Texture = throttleConfig.GetInt("texture_default", 1000);
-                Asset = throttleConfig.GetInt("asset_default", 1000);
-                State = throttleConfig.GetInt("state_default", 1000);
-
-                ResendLimit = throttleConfig.GetInt("resend_limit", 18750);
-                LandLimit = throttleConfig.GetInt("land_limit", 29750);
-                WindLimit = throttleConfig.GetInt("wind_limit", 18750);
-                CloudLimit = throttleConfig.GetInt("cloud_limit", 18750);
-                TaskLimit = throttleConfig.GetInt("task_limit", 18750);
-                TextureLimit = throttleConfig.GetInt("texture_limit", 55750);
-                AssetLimit = throttleConfig.GetInt("asset_limit", 27500);
-                StateLimit = throttleConfig.GetInt("state_limit", 37000);
+                Resend = throttleConfig.GetInt("resend_default", 6625);
+                Land = throttleConfig.GetInt("land_default", 9125);
+                Wind = throttleConfig.GetInt("wind_default", 1750);
+                Cloud = throttleConfig.GetInt("cloud_default", 1750);
+                Task = throttleConfig.GetInt("task_default", 18500);
+                Texture = throttleConfig.GetInt("texture_default", 18500);
+                Asset = throttleConfig.GetInt("asset_default", 10500);
 
                 Total = throttleConfig.GetInt("client_throttle_max_bps", 0);
-                TotalLimit = Total;
+
+                AdaptiveThrottlesEnabled = throttleConfig.GetBoolean("enable_adaptive_throttles", false);
             }
             catch (Exception) { }
         }
@@ -128,34 +102,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     return Texture;
                 case ThrottleOutPacketType.Asset:
                     return Asset;
-                case ThrottleOutPacketType.State:
-                    return State;
-                case ThrottleOutPacketType.Unknown:
-                default:
-                    return 0;
-            }
-        }
-
-        public int GetLimit(ThrottleOutPacketType type)
-        {
-            switch (type)
-            {
-                case ThrottleOutPacketType.Resend:
-                    return ResendLimit;
-                case ThrottleOutPacketType.Land:
-                    return LandLimit;
-                case ThrottleOutPacketType.Wind:
-                    return WindLimit;
-                case ThrottleOutPacketType.Cloud:
-                    return CloudLimit;
-                case ThrottleOutPacketType.Task:
-                    return TaskLimit;
-                case ThrottleOutPacketType.Texture:
-                    return TextureLimit;
-                case ThrottleOutPacketType.Asset:
-                    return AssetLimit;
-                case ThrottleOutPacketType.State:
-                    return StateLimit;
                 case ThrottleOutPacketType.Unknown:
                 default:
                     return 0;
diff --git a/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs b/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs
index 07b0a1d..29fd1a4 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs
@@ -29,6 +29,8 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
+using OpenSim.Framework;
+
 using log4net;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
@@ -48,31 +50,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// Number of ticks (ms) per quantum, drip rate and max burst
         /// are defined over this interval.
         /// </summary>
-        private const Int32 m_ticksPerQuantum = 1000;
+        protected const Int32 m_ticksPerQuantum = 1000;
 
         /// <summary>
         /// This is the number of quantums worth of packets that can
         /// be accommodated during a burst
         /// </summary>
-        private const Double m_quantumsPerBurst = 1.5;
+        protected const Double m_quantumsPerBurst = 1.5;
                 
         /// <summary>
         /// </summary>
-        private const Int32 m_minimumDripRate = 1400;
+        protected const Int32 m_minimumDripRate = 1400;
         
         /// <summary>Time of the last drip, in system ticks</summary>
-        private Int32 m_lastDrip;
+        protected Int32 m_lastDrip;
 
         /// <summary>
         /// The number of bytes that can be sent at this moment. This is the
         /// current number of tokens in the bucket
         /// </summary>
-        private Int64 m_tokenCount;
+        protected Int64 m_tokenCount;
 
         /// <summary>
         /// Map of children buckets and their requested maximum burst rate
         /// </summary>
-        private Dictionary<TokenBucket,Int64> m_children = new Dictionary<TokenBucket,Int64>();
+        protected Dictionary<TokenBucket,Int64> m_children = new Dictionary<TokenBucket,Int64>();
         
 #region Properties
 
@@ -81,7 +83,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// parent. The parent bucket will limit the aggregate bandwidth of all
         /// of its children buckets
         /// </summary>
-        private TokenBucket m_parent;
+        protected TokenBucket m_parent;
         public TokenBucket Parent
         {
             get { return m_parent; }
@@ -93,7 +95,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// of tokens that can accumulate in the bucket at any one time. This 
         /// also sets the total request for leaf nodes
         /// </summary>
-        private Int64 m_burstRate;
+        protected Int64 m_burstRate;
         public Int64 RequestedBurstRate
         {
             get { return m_burstRate; }
@@ -118,8 +120,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <remarks>Tokens are added to the bucket any time 
         /// <seealso cref="RemoveTokens"/> is called, at the granularity of
         /// the system tick interval (typically around 15-22ms)</remarks>
-        private Int64 m_dripRate;
-        public Int64 RequestedDripRate
+        protected Int64 m_dripRate;
+        public virtual Int64 RequestedDripRate
         {
             get { return (m_dripRate == 0 ? m_totalDripRequest : m_dripRate); }
             set {
@@ -131,7 +133,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
-        public Int64 DripRate
+        public virtual Int64 DripRate
         {
             get {
                 if (m_parent == null)
@@ -149,7 +151,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// The current total of the requested maximum burst rates of 
         /// this bucket's children buckets.
         /// </summary>
-        private Int64 m_totalDripRequest;
+        protected Int64 m_totalDripRequest;
         public Int64 TotalDripRequest 
             {
                 get { return m_totalDripRequest; }
@@ -177,7 +179,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             RequestedDripRate = dripRate;
             // TotalDripRequest = dripRate; // this will be overwritten when a child node registers
             // MaxBurst = (Int64)((double)dripRate * m_quantumsPerBurst);
-            m_lastDrip = Environment.TickCount & Int32.MaxValue;
+            m_lastDrip = Util.EnvironmentTickCount();
         }
 
 #endregion Constructor
@@ -189,7 +191,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// hierarchy. However, if any of the parents is over-booked, then
         /// the modifier will be less than 1.
         /// </summary>
-        private double DripRateModifier()
+        protected double DripRateModifier()
         {
             Int64 driprate = DripRate;
             return driprate >= TotalDripRequest ? 1.0 : (double)driprate / (double)TotalDripRequest;
@@ -197,7 +199,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         /// <summary>
         /// </summary>
-        private double BurstRateModifier()
+        protected double BurstRateModifier()
         {
             // for now... burst rate is always m_quantumsPerBurst (constant)
             // larger than drip rate so the ratio of burst requests is the
@@ -211,12 +213,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </summary>
         public void RegisterRequest(TokenBucket child, Int64 request)
         {
-            m_children[child] = request;
-            // m_totalDripRequest = m_children.Values.Sum();
+            lock (m_children)
+            {
+                m_children[child] = request;
+                // m_totalDripRequest = m_children.Values.Sum();
 
-            m_totalDripRequest = 0;
-            foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
-                m_totalDripRequest += cref.Value;
+                m_totalDripRequest = 0;
+                foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
+                    m_totalDripRequest += cref.Value;
+            }
             
             // Pass the new values up to the parent
             if (m_parent != null)
@@ -229,12 +234,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// </summary>
         public void UnregisterRequest(TokenBucket child)
         {
-            m_children.Remove(child);
-            // m_totalDripRequest = m_children.Values.Sum();
+            lock (m_children)
+            {
+                m_children.Remove(child);
+                // m_totalDripRequest = m_children.Values.Sum();
 
-            m_totalDripRequest = 0;
-            foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
-                m_totalDripRequest += cref.Value;
+                m_totalDripRequest = 0;
+                foreach (KeyValuePair<TokenBucket, Int64> cref in m_children)
+                    m_totalDripRequest += cref.Value;
+            }
+            
 
             // Pass the new values up to the parent
             if (m_parent != null)
@@ -268,7 +277,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// Deposit tokens into the bucket from a child bucket that did
         /// not use all of its available tokens
         /// </summary>
-        private void Deposit(Int64 count)
+        protected void Deposit(Int64 count)
         {
             m_tokenCount += count;
 
@@ -285,7 +294,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// call to Drip
         /// </summary>
         /// <returns>True if tokens were added to the bucket, otherwise false</returns>
-        private void Drip()
+        protected void Drip()
         {
             // This should never happen... means we are a leaf node and were created
             // with no drip rate...
@@ -297,10 +306,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             
             // Determine the interval over which we are adding tokens, never add
             // more than a single quantum of tokens
-            Int32 now = Environment.TickCount & Int32.MaxValue;
-            Int32 deltaMS = Math.Min(now - m_lastDrip, m_ticksPerQuantum);
-
-            m_lastDrip = now;
+            Int32 deltaMS = Math.Min(Util.EnvironmentTickCountSubtract(m_lastDrip), m_ticksPerQuantum);
+            m_lastDrip = Util.EnvironmentTickCount();
 
             // This can be 0 in the very unusual case that the timer wrapped
             // It can be 0 if we try add tokens at a sub-tick rate
@@ -310,4 +317,77 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             Deposit(deltaMS * DripRate / m_ticksPerQuantum);
         }
     }
+
+    public class AdaptiveTokenBucket : TokenBucket
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The minimum rate for flow control. Minimum drip rate is one
+        /// packet per second. Open the throttle to 15 packets per second
+        /// or about 160kbps.
+        /// </summary>
+        protected const Int64 m_minimumFlow = m_minimumDripRate * 15;
+
+        // <summary>
+        // The maximum rate for flow control. Drip rate can never be
+        // greater than this.
+        // </summary>
+        protected Int64 m_maxDripRate = 0;
+        protected Int64 MaxDripRate
+        {
+            get { return (m_maxDripRate == 0 ? m_totalDripRequest : m_maxDripRate); }
+            set { m_maxDripRate = (value == 0 ? 0 : Math.Max(value,m_minimumFlow)); }
+        }
+        
+        private bool m_enabled = false;
+        
+        // <summary>
+        // 
+        // </summary>
+        public virtual Int64 AdjustedDripRate
+        {
+            get { return m_dripRate; }
+            set {
+                m_dripRate = OpenSim.Framework.Util.Clamp<Int64>(value,m_minimumFlow,MaxDripRate);
+                m_burstRate = (Int64)((double)m_dripRate * m_quantumsPerBurst);
+                if (m_parent != null)
+                    m_parent.RegisterRequest(this,m_dripRate);
+            }
+        }
+
+        // <summary>
+        // 
+        // </summary>
+        public AdaptiveTokenBucket(TokenBucket parent, Int64 maxDripRate, bool enabled) : base(parent,maxDripRate)
+        {
+            m_enabled = enabled;
+
+            if (m_enabled)
+            {
+                // m_log.DebugFormat("[TOKENBUCKET] Adaptive throttle enabled");
+                MaxDripRate = maxDripRate;
+                AdjustedDripRate = m_minimumFlow;
+            }
+        }
+                
+        // <summary>
+        // 
+        // </summary>
+        public void ExpirePackets(Int32 count)
+        {
+            // m_log.WarnFormat("[ADAPTIVEBUCKET] drop {0} by {1} expired packets",AdjustedDripRate,count);
+            if (m_enabled)
+                AdjustedDripRate = (Int64) (AdjustedDripRate / Math.Pow(2,count));
+        }
+
+        // <summary>
+        // 
+        // </summary>
+        public void AcknowledgePackets(Int32 count)
+        {
+            if (m_enabled)
+                AdjustedDripRate = AdjustedDripRate + count;
+        }
+    }
 }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
index d195110..793aefe 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
@@ -65,7 +65,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>Holds packets that need to be added to the unacknowledged list</summary>
         private LocklessQueue<OutgoingPacket> m_pendingAdds = new LocklessQueue<OutgoingPacket>();
         /// <summary>Holds information about pending acknowledgements</summary>
-        private LocklessQueue<PendingAck> m_pendingRemoves = new LocklessQueue<PendingAck>();
+        private LocklessQueue<PendingAck> m_pendingAcknowledgements = new LocklessQueue<PendingAck>();
+        /// <summary>Holds information about pending removals</summary>
+        private LocklessQueue<uint> m_pendingRemoves = new LocklessQueue<uint>();
 
         /// <summary>
         /// Add an unacked packet to the collection
@@ -83,15 +85,33 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         /// <summary>
         /// Marks a packet as acknowledged
+        /// This method is used when an acknowledgement is received from the network for a previously
+        /// sent packet. Effects of removal this way are to update unacked byte count, adjust RTT
+        /// and increase throttle to the coresponding client.
         /// </summary>
         /// <param name="sequenceNumber">Sequence number of the packet to
         /// acknowledge</param>
         /// <param name="currentTime">Current value of Environment.TickCount</param>
         /// <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>
-        public void Remove(uint sequenceNumber, int currentTime, bool fromResend)
+        public void Acknowledge(uint sequenceNumber, int currentTime, bool fromResend)
         {
-            m_pendingRemoves.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
+            m_pendingAcknowledgements.Enqueue(new PendingAck(sequenceNumber, currentTime, fromResend));
+        }
+
+        /// <summary>
+        /// Marks a packet as no longer needing acknowledgement without a received acknowledgement.
+        /// This method is called when a packet expires and we no longer need an acknowledgement.
+        /// When some reliable packet types expire, they are handled in a way other than simply 
+        /// resending them. The only effect of removal this way is to update unacked byte count.
+        /// </summary>
+        /// <param name="sequenceNumber">Sequence number of the packet to
+        /// acknowledge</param>
+        /// <remarks>The does not immediately remove the packet, it only queues the removal
+        /// so it can be handled in a thread safe way later</remarks>
+        public void Remove(uint sequenceNumber)
+        {
+            m_pendingRemoves.Enqueue(sequenceNumber);
         }
 
         /// <summary>
@@ -130,6 +150,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         // is actually sent out again
                         packet.TickCount = 0;
 
+                        // As with other network applications, assume that an expired packet is
+                        // an indication of some network problem, slow transmission
+                        packet.Client.FlowThrottle.ExpirePackets(1);
+                        
                         expiredPackets.Add(packet);
                     }
                 }
@@ -147,29 +171,49 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     m_packets[pendingAdd.SequenceNumber] = pendingAdd;
             
             // Process all the pending removes, including updating statistics and round-trip times
-            PendingAck pendingRemove;
-            OutgoingPacket ackedPacket;
-            while (m_pendingRemoves.TryDequeue(out pendingRemove))
+            PendingAck pendingAcknowledgement;
+            while (m_pendingAcknowledgements.TryDequeue(out pendingAcknowledgement))
             {
-                if (m_packets.TryGetValue(pendingRemove.SequenceNumber, out ackedPacket))
+                OutgoingPacket ackedPacket;
+                if (m_packets.TryGetValue(pendingAcknowledgement.SequenceNumber, out ackedPacket))
                 {
                     if (ackedPacket != null)
                     {
-                        m_packets.Remove(pendingRemove.SequenceNumber);
+                        m_packets.Remove(pendingAcknowledgement.SequenceNumber);
+
+                        // As with other network applications, assume that an acknowledged packet is an
+                        // indication that the network can handle a little more load, speed up the transmission
+                        ackedPacket.Client.FlowThrottle.AcknowledgePackets(ackedPacket.Buffer.DataLength);
 
                         // Update stats
                         Interlocked.Add(ref ackedPacket.Client.UnackedBytes, -ackedPacket.Buffer.DataLength);
 
-                        if (!pendingRemove.FromResend)
+                        if (!pendingAcknowledgement.FromResend)
                         {
                             // Calculate the round-trip time for this packet and its ACK
-                            int rtt = pendingRemove.RemoveTime - ackedPacket.TickCount;
+                            int rtt = pendingAcknowledgement.RemoveTime - ackedPacket.TickCount;
                             if (rtt > 0)
                                 ackedPacket.Client.UpdateRoundTrip(rtt);
                         }
                     }
                 }
             }
+
+            uint pendingRemove;
+            while(m_pendingRemoves.TryDequeue(out pendingRemove))
+            {
+                OutgoingPacket removedPacket;
+                if (m_packets.TryGetValue(pendingRemove, out removedPacket))
+                {
+                    if (removedPacket != null)
+                    {
+                        m_packets.Remove(pendingRemove);
+
+                        // Update stats
+                        Interlocked.Add(ref removedPacket.Client.UnackedBytes, -removedPacket.Buffer.DataLength);
+                    }
+                }
+            }
         }
     }
-}
\ No newline at end of file
+}