8 files changed, 72 insertions, 28 deletions

diff --git a/OpenSim/Framework/Communications/RestClient.cs b/OpenSim/Framework/Communications/RestClient.cs
index 317b3a0..97b3b60 100644
--- a/OpenSim/Framework/Communications/RestClient.cs
+++ b/OpenSim/Framework/Communications/RestClient.cs
@@ -403,7 +403,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);
-            ThreadPool.UnsafeQueueUserWorkItem(RequestHelper, ar);
+            Util.FireAndForget(RequestHelper, ar);
             return ar;
         }
 
diff --git a/OpenSim/Framework/Parallel.cs b/OpenSim/Framework/Parallel.cs
index ab2e108..70eecdc 100644
--- a/OpenSim/Framework/Parallel.cs
+++ b/OpenSim/Framework/Parallel.cs
@@ -66,7 +66,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
@@ -122,7 +122,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
@@ -178,7 +178,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 7dde6dd..d09bd6d 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -53,6 +53,18 @@ using Amib.Threading;
 namespace OpenSim.Framework
 {
     /// <summary>
+    /// The method used by Util.FireAndForget for asynchronously firing events
+    /// </summary>
+    public enum FireAndForgetMethod
+    {
+        UnsafeQueueUserWorkItem,
+        QueueUserWorkItem,
+        BeginInvoke,
+        SmartThreadPool,
+        Thread,
+    }
+
+    /// <summary>
     /// Miscellaneous utility functions
     /// </summary>
     public class Util
@@ -74,7 +86,9 @@ namespace OpenSim.Framework
 
         public static readonly Regex UUIDPattern 
             = new Regex("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
-        
+
+        public static FireAndForgetMethod FireAndForgetMethod = FireAndForgetMethod.SmartThreadPool;
+
         /// <summary>
         /// Linear interpolates B<->C using percent A
         /// </summary>
@@ -1277,7 +1291,7 @@ namespace OpenSim.Framework
         /// <summary>
         /// Created to work around a limitation in Mono with nested delegates
         /// </summary>
-        /*private class FireAndForgetWrapper
+        private class FireAndForgetWrapper
         {
             public void FireAndForget(System.Threading.WaitCallback callback)
             {
@@ -1288,17 +1302,28 @@ namespace OpenSim.Framework
             {
                 callback.BeginInvoke(obj, EndFireAndForget, callback);
             }
-        }*/
+
+            private static void EndFireAndForget(IAsyncResult ar)
+            {
+                System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
+
+                try { callback.EndInvoke(ar); }
+                catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
+
+                ar.AsyncWaitHandle.Close();
+            }
+        }
 
         public static void FireAndForget(System.Threading.WaitCallback callback)
         {
-            //FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
-            //wrapper.FireAndForget(callback);
-            System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, null);
+            FireAndForget(callback, null);
         }
 
         public static void SetMaxThreads(int maxThreads)
         {
+            if (m_ThreadPool != null)
+                return;
+
             STPStartInfo startInfo = new STPStartInfo();
             startInfo.IdleTimeout = 2000; // 2 seconds
             startInfo.MaxWorkerThreads = maxThreads;
@@ -1313,11 +1338,28 @@ namespace OpenSim.Framework
 
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
         {
-            m_ThreadPool.QueueWorkItem(new WorkItemCallback(delegate(object o)
-                {
-                    callback(o);
-                    return null;
-                }), obj);
+            switch (FireAndForgetMethod)
+            {
+                case FireAndForgetMethod.UnsafeQueueUserWorkItem:
+                    System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, obj);
+                    break;
+                case FireAndForgetMethod.QueueUserWorkItem:
+                    System.Threading.ThreadPool.QueueUserWorkItem(callback, obj);
+                    break;
+                case FireAndForgetMethod.BeginInvoke:
+                    FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
+                    wrapper.FireAndForget(callback, obj);
+                    break;
+                case FireAndForgetMethod.SmartThreadPool:
+                    m_ThreadPool.QueueWorkItem(delegate(object o) { callback(o); return null; }, obj);
+                    break;
+                case FireAndForgetMethod.Thread:
+                    System.Threading.Thread thread = new System.Threading.Thread(delegate(object o) { callback(o); });
+                    thread.Start(obj);
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
         }
 
         #endregion FireAndForget Threading Pattern
diff --git a/OpenSim/Grid/MessagingServer.Modules/MessageService.cs b/OpenSim/Grid/MessagingServer.Modules/MessageService.cs
index 49f0fa8..8ad1e9c 100644
--- a/OpenSim/Grid/MessagingServer.Modules/MessageService.cs
+++ b/OpenSim/Grid/MessagingServer.Modules/MessageService.cs
@@ -148,8 +148,7 @@ namespace OpenSim.Grid.MessagingServer.Modules
                 friendlistupdater.presence2 = receiver;
                 friendlistupdater.OnGetRegionData += m_regionModule.GetRegionInfo;
                 friendlistupdater.OnDone += PresenceUpdateDone;
-                WaitCallback cb = new WaitCallback(friendlistupdater.go);
-                ThreadPool.UnsafeQueueUserWorkItem(cb, null);
+                Util.FireAndForget(friendlistupdater.go);
             }
             else
             {
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index c9cec75..c04b8c2 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -92,10 +92,17 @@ namespace OpenSim
                             appender.File = fileName;
                             appender.ActivateOptions();
                         }
-                        m_log.InfoFormat("[LOGGING] Logging started to file {0}", appender.File);
+                        m_log.InfoFormat("[LOGGING]: Logging started to file {0}", appender.File);
                     }
                 }
+
+                string asyncCallMethodStr = startupConfig.GetString("async_call_method", String.Empty);
+                FireAndForgetMethod asyncCallMethod;
+                if (!String.IsNullOrEmpty(asyncCallMethodStr) && Utils.EnumTryParse<FireAndForgetMethod>(asyncCallMethodStr, out asyncCallMethod))
+                    Util.FireAndForgetMethod = asyncCallMethod;
             }
+
+            m_log.Info("[OPENSIM MAIN]: Using async_call_method " + Util.FireAndForgetMethod);
         }
 
         /// <summary>
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 432fee7..0ba76ec 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -791,7 +791,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="map">heightmap</param>
         public virtual void SendLayerData(float[] map)
         {
-            ThreadPool.UnsafeQueueUserWorkItem(DoSendLayerData, map);
+            Util.FireAndForget(DoSendLayerData, map);
         }
 
         /// <summary>
@@ -931,7 +931,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="windSpeeds">16x16 array of wind speeds</param>
         public virtual void SendWindData(Vector2[] windSpeeds)
         {
-            ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(DoSendWindData), (object)windSpeeds);
+            Util.FireAndForget(DoSendWindData, windSpeeds);
         }
 
         /// <summary>
@@ -940,7 +940,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="windSpeeds">16x16 array of cloud densities</param>
         public virtual void SendCloudData(float[] cloudDensity)
         {
-            ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(DoSendCloudData), (object)cloudDensity);
+            Util.FireAndForget(DoSendCloudData, cloudDensity);
         }
 
         /// <summary>
diff --git a/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs b/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
index cbdca16..c6af806 100644
--- a/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
+++ b/OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
@@ -302,12 +302,8 @@ namespace Flotsam.RegionModules.AssetCache
 
                         }
 
-                        ThreadPool.UnsafeQueueUserWorkItem(
-                            delegate
-                            {
-                                WriteFileCache(filename, asset);
-                            }, null
-                        );
+                        Util.FireAndForget(
+                            delegate { WriteFileCache(filename, asset); });
                     }
                 }
                 catch (Exception e)
diff --git a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
index 1260584..4e40084 100644
--- a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
+++ b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
@@ -1095,7 +1095,7 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
             // The reason is so we don't cause the thread to freeze waiting
             // for the 1 second it costs to start a thread manually.
             if (!threadrunning)
-                ThreadPool.UnsafeQueueUserWorkItem(this.StartThread, null);
+                Util.FireAndForget(this.StartThread);
 
             lock (m_rootAgents)
             {