now break several things at same time... sog/sop updates, threads options,...

1 files changed, 16 insertions, 52 deletions

diff --git a/OpenSim/Framework/Monitoring/WorkManager.cs b/OpenSim/Framework/Monitoring/WorkManager.cs
index 5d9b185..c6d97e1 100644
--- a/OpenSim/Framework/Monitoring/WorkManager.cs
+++ b/OpenSim/Framework/Monitoring/WorkManager.cs
@@ -88,6 +88,11 @@ namespace OpenSim.Framework.Monitoring
             Watchdog.Stop();
         }
 
+        public static Thread StartThread(ThreadStart start, string name, bool alarmIfTimeout = false, bool log = true)
+        {
+            return StartThread(start, name, ThreadPriority.Normal, true, alarmIfTimeout, null, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, log);
+        }
+
         /// <summary>
         /// Start a new long-lived thread.
         /// </summary>
@@ -99,9 +104,9 @@ namespace OpenSim.Framework.Monitoring
         /// <param name="log">If true then creation of thread is logged.</param>
         /// <returns>The newly created Thread object</returns>
         public static Thread StartThread(
-            ThreadStart start, string name, ThreadPriority priority, bool isBackground, bool alarmIfTimeout, bool log = true)
+            ThreadStart start, string name, ThreadPriority priority, bool alarmIfTimeout, bool log = true)
         {
-            return StartThread(start, name, priority, isBackground, alarmIfTimeout, null, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, log);
+            return StartThread(start, name, priority, true, alarmIfTimeout, null, Watchdog.DEFAULT_WATCHDOG_TIMEOUT_MS, log);
         }
 
         /// <summary>
@@ -162,15 +167,22 @@ namespace OpenSim.Framework.Monitoring
                 {
                     Culture.SetCurrentCulture();
                     callback(obj);
-                    Watchdog.RemoveThread(log:false);
                 }
                 catch (Exception e)
                 {
                     m_log.Error(string.Format("[WATCHDOG]: Exception in thread {0}.", name), e);
                 }
+                finally
+                {
+                    try
+                    {
+                        Watchdog.RemoveThread(log: false);
+                    }
+                    catch { }
+                }
             });
 
-            StartThread(ts, name, ThreadPriority.Normal, true, false, log:log);
+            StartThread(ts, name, false, log:log);
         }
 
         /// <summary>
@@ -187,54 +199,6 @@ namespace OpenSim.Framework.Monitoring
             Util.FireAndForget(callback, obj, name, timeout);
         }
 
-        /// <summary>
-        /// Run a job.
-        /// </summary>
-        /// <remarks>
-        /// This differs from direct scheduling (e.g. Util.FireAndForget) in that a job can be run in the job
-        /// engine if it is running, where all jobs are currently performed in sequence on a single thread.  This is
-        /// to prevent observed overload and server freeze problems when there are hundreds of connections which all attempt to
-        /// perform work at once (e.g. in conference situations).  With lower numbers of connections, the small
-        /// delay in performing jobs in sequence rather than concurrently has not been notiecable in testing, though a future more
-        /// sophisticated implementation could perform jobs concurrently when the server is under low load.
-        ///
-        /// However, be advised that some callers of this function rely on all jobs being performed in sequence if any
-        /// jobs are performed in sequence (i.e. if jobengine is active or not).  Therefore, expanding the jobengine
-        /// beyond a single thread will require considerable thought.
-        ///
-        /// Also, any jobs submitted must be guaranteed to complete within a reasonable timeframe (e.g. they cannot
-        /// incorporate a network delay with a long timeout).  At the moment, work that could suffer such issues
-        /// should still be run directly with RunInThread(), Util.FireAndForget(), etc.  This is another area where
-        /// the job engine could be improved and so CPU utilization improved by better management of concurrency within
-        /// OpenSimulator.
-        /// </remarks>
-        /// <param name="jobType">General classification for the job (e.g. "RezAttachments").</param>
-        /// <param name="callback">Callback for job.</param>
-        /// <param name="obj">Object to pass to callback when run</param>
-        /// <param name="name">Specific name of job (e.g. "RezAttachments for Joe Bloggs"</param>
-        /// <param name="canRunInThisThread">If set to true then the job may be run in ths calling thread.</param>
-        /// <param name="mustNotTimeout">If the true then the job must never timeout.</param>
-        /// <param name="log">If set to true then extra logging is performed.</param>
-        public static void RunJob(
-            string jobType, WaitCallback callback, object obj, string name,
-            bool canRunInThisThread = false, bool mustNotTimeout = false,
-            bool log = false)
-        {
-            if (Util.FireAndForgetMethod == FireAndForgetMethod.RegressionTest)
-            {
-                Culture.SetCurrentCulture();
-                callback(obj);
-                return;
-            }
-
-            if (JobEngine.IsRunning)
-                JobEngine.QueueJob(name, () => callback(obj));
-            else if (canRunInThisThread)
-                callback(obj);
-            else
-                Util.FireAndForget(callback, obj, name, !mustNotTimeout);
-        }
-
         private static void HandleControlCommand(string module, string[] args)
         {
             //            if (SceneManager.Instance.CurrentScene != null && SceneManager.Instance.CurrentScene != m_udpServer.Scene)