V1.5 SuperSocket.SocketEngine.SocketSession.OnSendingCompleted NullReferenceException

Common/ConfigurationExtension.cs

@@ -58,6 +58,24 @@ public static string GetValue(this NameValueCollection collection, string key, s
         public static void Deserialize<TElement>(this TElement section, XmlReader reader)
             where TElement : ConfigurationElement
         {
+            if (section is ConfigurationElementCollection)
+            {
+                var collectionType = section.GetType();
+                var att = collectionType.GetCustomAttributes(typeof(ConfigurationCollectionAttribute), true).FirstOrDefault() as ConfigurationCollectionAttribute;
+
+                if (att != null)
+                {
+                    var property = collectionType.GetProperty("AddElementName", BindingFlags.NonPublic | BindingFlags.Instance);
+                    property.SetValue(section, att.AddItemName, null);
+
+                    property = collectionType.GetProperty("RemoveElementName", BindingFlags.NonPublic | BindingFlags.Instance);
+                    property.SetValue(section, att.RemoveItemName, null);
+
+                    property = collectionType.GetProperty("ClearElementName", BindingFlags.NonPublic | BindingFlags.Instance);
+                    property.SetValue(section, att.ClearItemsName, null);
+                }
+            }
+
             var deserializeElementMethod = typeof(TElement).GetMethod("DeserializeElement", BindingFlags.NonPublic | BindingFlags.Instance);
             deserializeElementMethod.Invoke(section, new object[] { reader, false });
         }

Common/SmartPool.cs

@@ -9,20 +9,10 @@
 namespace SuperSocket.Common
 {
     /// <summary>
-    /// The basic interface of smart pool
+    /// The pool information class
     /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public interface ISmartPool<T>
+    public interface IPoolInfo
     {
-        /// <summary>
-        /// Initializes the specified min pool size.
-        /// </summary>
-        /// <param name="minPoolSize">The min size of the pool.</param>
-        /// <param name="maxPoolSize">The max size of the pool.</param>
-        /// <param name="sourceCreator">The source creator.</param>
-        /// <returns></returns>
-        void Initialize(int minPoolSize, int maxPoolSize, ISmartPoolSourceCreator<T> sourceCreator);
-
         /// <summary>
         /// Gets the min size of the pool.
         /// </summary>
@@ -48,6 +38,31 @@ public interface ISmartPool<T>
         /// </value>
         int AvialableItemsCount { get; }
 
+
+        /// <summary>
+        /// Gets the total items count, include items in the pool and outside the pool.
+        /// </summary>
+        /// <value>
+        /// The total items count.
+        /// </value>
+        int TotalItemsCount { get; }
+    }
+
+    /// <summary>
+    /// The basic interface of smart pool
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface ISmartPool<T> : IPoolInfo
+    {
+        /// <summary>
+        /// Initializes the specified min pool size.
+        /// </summary>
+        /// <param name="minPoolSize">The min size of the pool.</param>
+        /// <param name="maxPoolSize">The max size of the pool.</param>
+        /// <param name="sourceCreator">The source creator.</param>
+        /// <returns></returns>
+        void Initialize(int minPoolSize, int maxPoolSize, ISmartPoolSourceCreator<T> sourceCreator);        
+
         /// <summary>
         /// Pushes the specified item into the pool.
         /// </summary>
@@ -186,6 +201,19 @@ public int AvialableItemsCount
             }
         }
 
+        private int m_TotalItemsCount;
+
+        /// <summary>
+        /// Gets the total items count, include items in the pool and outside the pool.
+        /// </summary>
+        /// <value>
+        /// The total items count.
+        /// </value>
+        public int TotalItemsCount
+        {
+            get { return m_TotalItemsCount; }
+        }
+
         /// <summary>
         /// Initializes the specified min and max pool size.
         /// </summary>
@@ -228,8 +256,12 @@ public void Initialize(int minPoolSize, int maxPoolSize, ISmartPoolSourceCreator
             {
                 m_GlobalStack.Push(items[i]);
             }
+
+            m_TotalItemsCount = m_MinPoolSize;
         }
 
+        private int m_IsIncreasing = 0;
+
         /// <summary>
         /// Pushes the specified item into the pool.
         /// </summary>
@@ -239,6 +271,24 @@ public void Push(T item)
             m_GlobalStack.Push(item);
         }
 
+        bool TryPopWithWait(out T item, int waitTicks)
+        {
+            var spinWait = new SpinWait();
+
+            while (true)
+            {
+                spinWait.SpinOnce();
+
+                if (m_GlobalStack.TryPop(out item))
+                    return true;
+
+                if (spinWait.Count >= waitTicks)
+                {
+                    return false;
+                }
+            }
+        }
+
         /// <summary>
         /// Tries to get one item from the pool.
         /// </summary>
@@ -253,42 +303,43 @@ public bool TryGet(out T item)
             var currentSourceCount = m_CurrentSourceCount;
 
             if (currentSourceCount >= m_ItemsSource.Length)
-                return false;
-
-            if (Interlocked.CompareExchange(ref m_CurrentSourceCount, currentSourceCount + 1, currentSourceCount) != currentSourceCount)
             {
-                var spinWait = new SpinWait();
+                return TryPopWithWait(out item, 100);
+            }
 
-                while (true)
-                {
-                    spinWait.SpinOnce();
+            var isIncreasing = m_IsIncreasing;
 
-                    if (m_GlobalStack.TryPop(out item))
-                        return true;
+            if (isIncreasing == 1)
+                return TryPopWithWait(out item, 100);
 
-                    if (spinWait.Count >= 100)
-                        return false;
-                }
-            }
+            if (Interlocked.CompareExchange(ref m_IsIncreasing, 1, isIncreasing) != isIncreasing)
+                return TryPopWithWait(out item, 100);
+
+            IncreaseCapacity();
 
-            int totalItemsCount = 0;
+            m_IsIncreasing = 0;
 
-            for (var i = 0; i < currentSourceCount; i++)
+            if (!m_GlobalStack.TryPop(out item))
             {
-                totalItemsCount += m_ItemsSource[i].Count;
+                return false;
             }
 
-            totalItemsCount = Math.Min(totalItemsCount, m_MaxPoolSize - totalItemsCount);
+            return true;
+        }
+
+        private void IncreaseCapacity()
+        {
+            var newItemsCount = Math.Min(m_TotalItemsCount, m_MaxPoolSize - m_TotalItemsCount);
 
             T[] items;
-            m_ItemsSource[currentSourceCount] = m_SourceCreator.Create(totalItemsCount, out items);
+            m_ItemsSource[m_CurrentSourceCount] = m_SourceCreator.Create(newItemsCount, out items);
+
+            m_TotalItemsCount += newItemsCount;
 
             for (var i = 0; i < items.Length; i++)
             {
                 m_GlobalStack.Push(items[i]);
             }
-
-            return m_GlobalStack.TryPop(out item);
         }
     }
 }