1 files changed, 316 insertions, 0 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
new file mode 100644
index 0000000..9f22fb4
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
@@ -0,0 +1,316 @@
+/*
+ * 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.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using log4net;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    public sealed class PacketPool
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static readonly PacketPool instance = new PacketPool();
+
+        private bool packetPoolEnabled = true;
+        private bool dataBlockPoolEnabled = true;
+
+        private PercentageStat m_packetsReusedStat = new PercentageStat(
+            "PacketsReused",
+            "Packets reused",
+            "Number of packets reused out of all requests to the packet pool",
+            "clientstack",
+            "packetpool",
+            StatType.Push,
+            null,
+            StatVerbosity.Debug);
+
+        private PercentageStat m_blocksReusedStat = new PercentageStat(
+            "PacketDataBlocksReused",
+            "Packet data blocks reused",
+            "Number of data blocks reused out of all requests to the packet pool",
+            "clientstack",
+            "packetpool",
+            StatType.Push,
+            null,
+            StatVerbosity.Debug);
+
+        /// <summary>
+        /// Pool of packets available for reuse.
+        /// </summary>
+        private readonly Dictionary<PacketType, Stack<Packet>> pool = new Dictionary<PacketType, Stack<Packet>>();
+
+        private static Dictionary<Type, Stack<Object>> DataBlocks = new Dictionary<Type, Stack<Object>>();
+
+        public static PacketPool Instance
+        {
+            get { return instance; }
+        }
+
+        public bool RecyclePackets
+        {
+            set { packetPoolEnabled = value; }
+            get { return packetPoolEnabled; }
+        }
+
+        public bool RecycleDataBlocks
+        {
+            set { dataBlockPoolEnabled = value; }
+            get { return dataBlockPoolEnabled; }
+        }
+
+        private PacketPool()
+        {
+            StatsManager.RegisterStat(m_packetsReusedStat);
+            StatsManager.RegisterStat(m_blocksReusedStat);
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "PacketsPoolCount",
+                    "Objects within the packet pool",
+                    "The number of objects currently stored within the packet pool",
+                    "",
+                    "clientstack",
+                    "packetpool",
+                    StatType.Pull,
+                    stat => { lock (pool) { stat.Value = pool.Count; } },
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "PacketDataBlocksPoolCount",
+                    "Objects within the packet data block pool",
+                    "The number of objects currently stored within the packet data block pool",
+                    "",
+                    "clientstack",
+                    "packetpool",
+                    StatType.Pull,
+                    stat => { lock (DataBlocks) { stat.Value = DataBlocks.Count; } },
+                    StatVerbosity.Debug));
+        }
+
+        /// <summary>
+        /// Gets a packet of the given type.
+        /// </summary>
+        /// <param name='type'></param>
+        /// <returns>Guaranteed to always return a packet, whether from the pool or newly constructed.</returns>
+        public Packet GetPacket(PacketType type)
+        {
+            m_packetsReusedStat.Consequent++;
+
+            Packet packet;
+
+            if (!packetPoolEnabled)
+                return Packet.BuildPacket(type);
+
+            lock (pool)
+            {
+                if (!pool.ContainsKey(type) || pool[type] == null || (pool[type]).Count == 0)
+                {
+//                    m_log.DebugFormat("[PACKETPOOL]: Building {0} packet", type);
+
+                    // Creating a new packet if we cannot reuse an old package
+                    packet = Packet.BuildPacket(type);
+                }
+                else
+                {
+//                    m_log.DebugFormat("[PACKETPOOL]: Pulling {0} packet", type);
+
+                    // Recycle old packages
+                    m_packetsReusedStat.Antecedent++;
+
+                    packet = pool[type].Pop();
+                }
+            }
+
+            return packet;
+        }
+
+        // private byte[] decoded_header = new byte[10];
+        private static PacketType GetType(byte[] bytes)
+        {
+            byte[] decoded_header = new byte[10 + 8];
+            ushort id;
+            PacketFrequency freq;
+
+            if ((bytes[0] & Helpers.MSG_ZEROCODED) != 0)
+            {
+                Helpers.ZeroDecode(bytes, 16, decoded_header);
+            }
+            else
+            {
+                Buffer.BlockCopy(bytes, 0, decoded_header, 0, 10);
+            }
+
+            if (decoded_header[6] == 0xFF)
+            {
+                if (decoded_header[7] == 0xFF)
+                {
+                    id = (ushort) ((decoded_header[8] << 8) + decoded_header[9]);
+                    freq = PacketFrequency.Low;
+                }
+                else
+                {
+                    id = decoded_header[7];
+                    freq = PacketFrequency.Medium;
+                }
+            }
+            else
+            {
+                id = decoded_header[6];
+                freq = PacketFrequency.High;
+            }
+
+            return Packet.GetType(id, freq);
+        }
+
+        public Packet GetPacket(byte[] bytes, ref int packetEnd, byte[] zeroBuffer)
+        {
+            PacketType type = GetType(bytes);
+
+//            Array.Clear(zeroBuffer, 0, zeroBuffer.Length);
+
+            int i = 0;
+            Packet packet = GetPacket(type);
+            if (packet == null)
+                m_log.WarnFormat("[PACKETPOOL]: Failed to get packet of type {0}", type);
+            else
+                packet.FromBytes(bytes, ref i, ref packetEnd, zeroBuffer);
+
+            return packet;
+        }
+
+        /// <summary>
+        /// Return a packet to the packet pool
+        /// </summary>
+        /// <param name="packet"></param>
+        public void ReturnPacket(Packet packet)
+        {
+            if (dataBlockPoolEnabled)
+            {
+                switch (packet.Type)
+                {
+                    case PacketType.ObjectUpdate:
+                        ObjectUpdatePacket oup = (ObjectUpdatePacket)packet;
+
+                        foreach (ObjectUpdatePacket.ObjectDataBlock oupod in oup.ObjectData)
+                            ReturnDataBlock<ObjectUpdatePacket.ObjectDataBlock>(oupod);
+
+                        oup.ObjectData = null;
+                        break;
+
+                    case PacketType.ImprovedTerseObjectUpdate:
+                        ImprovedTerseObjectUpdatePacket itoup = (ImprovedTerseObjectUpdatePacket)packet;
+
+                        foreach (ImprovedTerseObjectUpdatePacket.ObjectDataBlock itoupod in itoup.ObjectData)
+                            ReturnDataBlock<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>(itoupod);
+
+                        itoup.ObjectData = null;
+                        break;
+                }
+            }
+
+            if (packetPoolEnabled)
+            {
+                switch (packet.Type)
+                {
+                    // List pooling packets here
+                    case PacketType.AgentUpdate:
+                    case PacketType.PacketAck:
+                    case PacketType.ObjectUpdate:
+                    case PacketType.ImprovedTerseObjectUpdate:
+                        lock (pool)
+                        {
+                            PacketType type = packet.Type;
+
+                            if (!pool.ContainsKey(type))
+                            {
+                                pool[type] = new Stack<Packet>();
+                            }
+
+                            if ((pool[type]).Count < 50)
+                            {
+//                                m_log.DebugFormat("[PACKETPOOL]: Pushing {0} packet", type);
+
+                                pool[type].Push(packet);
+                            }
+                        }
+                        break;
+                    
+                    // Other packets wont pool
+                    default:
+                        return;
+                }
+            }
+        }
+
+        public T GetDataBlock<T>() where T: new()
+        {
+            lock (DataBlocks)
+            {
+                m_blocksReusedStat.Consequent++;
+
+                Stack<Object> s;
+
+                if (DataBlocks.TryGetValue(typeof(T), out s))
+                {
+                    if (s.Count > 0)
+                    {
+                        m_blocksReusedStat.Antecedent++;
+                        return (T)s.Pop();
+                    }
+                }
+                else
+                {
+                    DataBlocks[typeof(T)] = new Stack<Object>();
+                }
+                
+                return new T();
+            }
+        }
+
+        public void ReturnDataBlock<T>(T block) where T: new()
+        {
+            if (block == null)
+                return;
+
+            lock (DataBlocks)
+            {
+                if (!DataBlocks.ContainsKey(typeof(T)))
+                    DataBlocks[typeof(T)] = new Stack<Object>();
+
+                if (DataBlocks[typeof(T)].Count < 50)
+                    DataBlocks[typeof(T)].Push(block);
+            }
+        }
+    }
+}
\ No newline at end of file