Label all threadpool calls being made in core OpenSimulator. This is to add problem diagnosis.

"show threadpool calls" now also returns named (labelled), anonymous (unlabelled) and total call stats.

3 files changed, 22 insertions, 11 deletions

diff --git a/OpenSim/Framework/Communications/RestClient.cs b/OpenSim/Framework/Communications/RestClient.cs
index de6fe30..72018e4 100644
--- a/OpenSim/Framework/Communications/RestClient.cs
+++ b/OpenSim/Framework/Communications/RestClient.cs
@@ -483,7 +483,7 @@ namespace OpenSim.Framework.Communications
             /// In case, we are invoked asynchroneously this object will keep track of the state
             /// </summary>
             AsyncResult<Stream> ar = new AsyncResult<Stream>(callback, state);
-            Util.FireAndForget(RequestHelper, ar);
+            Util.FireAndForget(RequestHelper, ar, "RestClient.BeginRequest");
             return ar;
         }
 
diff --git a/OpenSim/Framework/Servers/ServerBase.cs b/OpenSim/Framework/Servers/ServerBase.cs
index 379e224..eb9fb8b 100644
--- a/OpenSim/Framework/Servers/ServerBase.cs
+++ b/OpenSim/Framework/Servers/ServerBase.cs
@@ -365,13 +365,21 @@ namespace OpenSim.Framework.Servers
         {
             List<KeyValuePair<string, int>> calls = Util.GetFireAndForgetCallsMade().ToList();
             calls.Sort((kvp1, kvp2) => kvp2.Value.CompareTo(kvp1.Value));
+            int namedCallsMade = 0;
 
             ConsoleDisplayList cdl = new ConsoleDisplayList();
             foreach (KeyValuePair<string, int> kvp in calls)
             {
                 cdl.AddRow(kvp.Key, kvp.Value);
+                namedCallsMade += kvp.Value;
             }
 
+            cdl.AddRow("TOTAL NAMED", namedCallsMade);
+
+            long allCallsMade = Util.TotalFireAndForgetCallsMade;
+            cdl.AddRow("TOTAL ANONYMOUS", allCallsMade - namedCallsMade);
+            cdl.AddRow("TOTAL ALL", allCallsMade);
+
             MainConsole.Instance.Output(cdl.ToString());
         }
 
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 53bbb06..baad0b9 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -1928,11 +1928,6 @@ namespace OpenSim.Framework
             }
         }
 
-        public static void FireAndForget(System.Threading.WaitCallback callback)
-        {
-            FireAndForget(callback, null, null);
-        }
-
         public static void InitThreadPool(int minThreads, int maxThreads)
         {
             if (maxThreads < 2)
@@ -1977,8 +1972,7 @@ namespace OpenSim.Framework
                     throw new NotImplementedException();
             }
         }
-
-        
+                
         /// <summary>
         /// Additional information about threads in the main thread pool. Used to time how long the
         /// thread has been running, and abort it if it has timed-out.
@@ -2052,10 +2046,10 @@ namespace OpenSim.Framework
             }
         }
 
-
         private static long nextThreadFuncNum = 0;
         private static long numQueuedThreadFuncs = 0;
         private static long numRunningThreadFuncs = 0;
+        private static long numTotalThreadFuncsCalled = 0;
         private static Int32 threadFuncOverloadMode = 0;
 
         // Maps (ThreadFunc number -> Thread)
@@ -2086,20 +2080,29 @@ namespace OpenSim.Framework
             }
         }
 
+        public static long TotalFireAndForgetCallsMade { get { return numTotalThreadFuncsCalled; } }
+
         public static Dictionary<string, int> GetFireAndForgetCallsMade()
         {
             return new Dictionary<string, int>(m_fireAndForgetCallsMade);
-        }
+        }       
 
         private static Dictionary<string, int> m_fireAndForgetCallsMade = new Dictionary<string, int>();
 
+        public static void FireAndForget(System.Threading.WaitCallback callback)
+        {
+            FireAndForget(callback, null, null);
+        }
+
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
         {
             FireAndForget(callback, obj, null);
         }
-        
+     
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj, string context)
         {
+            Interlocked.Increment(ref numTotalThreadFuncsCalled);
+
             if (context != null)
             {
                 if (!m_fireAndForgetCallsMade.ContainsKey(context))