8 files changed, 83 insertions, 36 deletions

diff --git a/OpenSim/Framework/MinHeap.cs b/OpenSim/Framework/MinHeap.cs
index ad39bbc..33d0364 100755..100644
--- a/OpenSim/Framework/MinHeap.cs
+++ b/OpenSim/Framework/MinHeap.cs
@@ -1,3 +1,30 @@
+/*
+ * 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.Threading;
 using System.Collections;
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index d09bd6d..a18a827 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -69,8 +69,6 @@ namespace OpenSim.Framework
     /// </summary>
     public class Util
     {
-        private static SmartThreadPool m_ThreadPool = null;
-
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static uint nextXferID = 5000;
@@ -79,6 +77,9 @@ namespace OpenSim.Framework
         private static string regexInvalidFileChars = "[" + new String(Path.GetInvalidFileNameChars()) + "]";
         private static string regexInvalidPathChars = "[" + new String(Path.GetInvalidPathChars()) + "]";
         private static object XferLock = new object();
+        /// <summary>Thread pool used for Util.FireAndForget if
+        /// FireAndForgetMethod.SmartThreadPool is used</summary>
+        private static SmartThreadPool m_ThreadPool;
 
         // Unix-epoch starts at January 1st 1970, 00:00:00 UTC. And all our times in the server are (or at least should be) in UTC.
         private static readonly DateTime unixEpoch =
@@ -1319,21 +1320,14 @@ namespace OpenSim.Framework
             FireAndForget(callback, null);
         }
 
-        public static void SetMaxThreads(int maxThreads)
+        public static void InitThreadPool(int maxThreads)
         {
+            if (maxThreads < 2)
+                throw new ArgumentOutOfRangeException("maxThreads", "maxThreads must be greater than 2");
             if (m_ThreadPool != null)
-                return;
-
-            STPStartInfo startInfo = new STPStartInfo();
-            startInfo.IdleTimeout = 2000; // 2 seconds
-            startInfo.MaxWorkerThreads = maxThreads;
-            startInfo.MinWorkerThreads = 2;
-            startInfo.StackSize = 524288;
-            startInfo.ThreadPriority = ThreadPriority.Normal;
-
-            startInfo.StartSuspended = false;
+                throw new InvalidOperationException("SmartThreadPool is already initialized");
 
-            m_ThreadPool = new SmartThreadPool(startInfo);
+            m_ThreadPool = new SmartThreadPool(2000, maxThreads, 2);
         }
 
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
@@ -1341,20 +1335,22 @@ namespace OpenSim.Framework
             switch (FireAndForgetMethod)
             {
                 case FireAndForgetMethod.UnsafeQueueUserWorkItem:
-                    System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, obj);
+                    ThreadPool.UnsafeQueueUserWorkItem(callback, obj);
                     break;
                 case FireAndForgetMethod.QueueUserWorkItem:
-                    System.Threading.ThreadPool.QueueUserWorkItem(callback, obj);
+                    ThreadPool.QueueUserWorkItem(callback, obj);
                     break;
                 case FireAndForgetMethod.BeginInvoke:
                     FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
                     wrapper.FireAndForget(callback, obj);
                     break;
                 case FireAndForgetMethod.SmartThreadPool:
+                    if (m_ThreadPool != null)
+                        m_ThreadPool = new SmartThreadPool(2000, 15, 2);
                     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 thread = new Thread(delegate(object o) { callback(o); });
                     thread.Start(obj);
                     break;
                 default:
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index c04b8c2..26298e7 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -67,7 +67,7 @@ namespace OpenSim
 
             IConfig startupConfig = m_config.Source.Configs["Startup"];
 
-            Util.SetMaxThreads(startupConfig.GetInt("MaxPoolThreads", 15));
+            int stpMaxThreads = 15;
 
             if (startupConfig != null)
             {
@@ -100,8 +100,13 @@ namespace OpenSim
                 FireAndForgetMethod asyncCallMethod;
                 if (!String.IsNullOrEmpty(asyncCallMethodStr) && Utils.EnumTryParse<FireAndForgetMethod>(asyncCallMethodStr, out asyncCallMethod))
                     Util.FireAndForgetMethod = asyncCallMethod;
+
+                stpMaxThreads = startupConfig.GetInt("MaxPoolThreads", 15);
             }
 
+            if (Util.FireAndForgetMethod == FireAndForgetMethod.SmartThreadPool)
+                Util.InitThreadPool(stpMaxThreads);
+
             m_log.Info("[OPENSIM MAIN]: Using async_call_method " + Util.FireAndForgetMethod);
         }
 
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 0ba76ec..5acf25f 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -827,7 +827,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             for (int i = x1; i <= x2; i++)
                 SendLayerData(i, y1, map);
 
-            // Column    
+            // Column
             for (int j = y1 + 1; j <= y2; j++)
                 SendLayerData(x2, j, map);
      
diff --git a/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs b/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
index ad05bab..f5ab454 100644
--- a/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/InstantMessage/PresenceModule.cs
@@ -274,8 +274,14 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
                 }
                 m_RootAgents[agentID] = scene;
             }
+
             // inform messaging server that agent changed the region
-            NotifyMessageServerOfAgentLocation(agentID, scene.RegionInfo.RegionID, scene.RegionInfo.RegionHandle);
+            Util.FireAndForget(
+                delegate(object o)
+                {
+                    NotifyMessageServerOfAgentLocation(agentID, scene.RegionInfo.RegionID, scene.RegionInfo.RegionHandle);
+                }
+            );
         }
 
         private void OnEconomyDataRequest(UUID agentID)
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 11f255f..669189d 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -1267,12 +1267,14 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         protected void SetScale(SceneObjectPart part, LSL_Vector scale)
         {
             // TODO: this needs to trigger a persistance save as well
-
             if (part == null || part.ParentGroup == null || part.ParentGroup.IsDeleted)
                 return;
-
-            if (scale.x < 0.01 || scale.y < 0.01 || scale.z < 0.01)
-                return;
+            if (scale.x < 0.01)
+                                scale.x = 0.01;
+            if (scale.y < 0.01)
+                                scale.y = 0.01;
+            if (scale.z < 0.01)
+                                scale.z = 0.01;
 
             if (part.ParentGroup.RootPart.PhysActor != null && part.ParentGroup.RootPart.PhysActor.IsPhysical)
             {
@@ -1283,12 +1285,14 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 if (scale.z > World.m_maxPhys)
                     scale.z = World.m_maxPhys;
             }
+
             if (scale.x > World.m_maxNonphys)
                 scale.x = World.m_maxNonphys;
             if (scale.y > World.m_maxNonphys)
                 scale.y = World.m_maxNonphys;
             if (scale.z > World.m_maxNonphys)
                 scale.z = World.m_maxNonphys;
+
             Vector3 tmp = part.Scale;
             tmp.X = (float)scale.x;
             tmp.Y = (float)scale.y;
diff --git a/ThirdParty/SmartThreadPool/SmartThreadPool.cs b/ThirdParty/SmartThreadPool/SmartThreadPool.cs
index c21984e..bd52f62 100644
--- a/ThirdParty/SmartThreadPool/SmartThreadPool.cs
+++ b/ThirdParty/SmartThreadPool/SmartThreadPool.cs
@@ -499,7 +499,11 @@ namespace Amib.Threading
                     }
 
                     // Create a new thread
-                    Thread workerThread = new Thread(new ThreadStart(ProcessQueuedItems), _stpStartInfo.StackSize);
+                    Thread workerThread;
+                    if (_stpStartInfo.StackSize > 0)
+                        workerThread = new Thread(ProcessQueuedItems, _stpStartInfo.StackSize);
+                    else
+                        workerThread = new Thread(ProcessQueuedItems);
 
                     // Configure the new thread and start it
                     workerThread.Name = "STP " + Name + " Thread #" + _threadCounter;
diff --git a/bin/OpenSim.ini.example b/bin/OpenSim.ini.example
index 79d57d2..6ff70fc 100644
--- a/bin/OpenSim.ini.example
+++ b/bin/OpenSim.ini.example
@@ -38,8 +38,15 @@
     
     ; Sets the method that OpenSim will use to fire asynchronous
     ; events. Valid values are UnsafeQueueUserWorkItem,
-    ; QueueUserWorkItem, BeginInvoke, SmartThreadPool, and Thread
-    ; async_call_method = SmartThreadPool
+    ; QueueUserWorkItem, BeginInvoke, SmartThreadPool, and Thread.
+    ; SmartThreadPool is reported to work well on Mono/Linux, but 
+    ; UnsafeQueueUserWorkItem has been benchmarked with better
+    ; performance on .NET/Windows
+    ;async_call_method = SmartThreadPool
+    
+    ; Max threads to allocate on the FireAndForget thread pool
+    ; when running with the SmartThreadPool option above
+    MaxPoolThreads = 15
 
     ; ##
     ; ## CLIENTS
@@ -51,9 +58,6 @@
     ; Set this to the DLL containing the client stack to use.
     clientstack_plugin="OpenSim.Region.ClientStack.LindenUDP.dll"
 
-    ; Max threads to allocate on the FireAndForget pool
-    MaxPoolThreads = 15
-
     ; ##
     ; ## REGIONS
     ; ##
@@ -1392,12 +1396,13 @@
     ;TextureDataLimit = 5
 
 [InterestManagement]
-    ; This section controls how state updates are prioritized for each client
-    UpdatePrioritizationScheme = Distance
-    ReprioritizeUpdate = true
-    RootUpdateReprioritizationDistance = 10.0
-    ChildUpdateReprioritizationDistance = 20.0
-    ReprioritizeUpdatesInterval = 5000.0
+     ; This section controls how state updates are prioritized for each client
+     ; Valid values are Time, Distance, and SimpleAngularDistance
+     UpdatePrioritizationScheme = Distance;
+     ReprioritizationEnabled = true;
+     ReprioritizationInterval = 2000.0;
+     RootReprioritizationDistance = 10.0;
+     ChildReprioritizationDistance = 20.0;
 
 ;;
 ;; These are defaults that are overwritten below in [Architecture].