Merge branch 'switch' into Domme.

10 files changed, 70 insertions, 115 deletions

diff --git a/OpenSim/Framework/Monitoring/BaseStatsCollector.cs b/OpenSim/Framework/Monitoring/BaseStatsCollector.cs
index e513abd..7119964 100644
--- a/OpenSim/Framework/Monitoring/BaseStatsCollector.cs
+++ b/OpenSim/Framework/Monitoring/BaseStatsCollector.cs
@@ -48,28 +48,25 @@ namespace OpenSim.Framework.Monitoring
                 Math.Round(GC.GetTotalMemory(false) / 1024.0 / 1024.0));
 
             sb.AppendFormat(
-                "Last heap allocation rate   : {0} MB/s\n",
-                Math.Round((MemoryWatchdog.LastHeapAllocationRate * 1000) / 1024.0 / 1024, 3));
+                "Heap allocation rate (last/avg): {0}/{1}MB/s\n",
+                Math.Round((MemoryWatchdog.LastHeapAllocationRate * 1000) / 1048576.0, 3),
+                Math.Round((MemoryWatchdog.AverageHeapAllocationRate * 1000) / 1048576.0, 3));
 
-            sb.AppendFormat(
-                "Average heap allocation rate: {0} MB/s\n",
-                Math.Round((MemoryWatchdog.AverageHeapAllocationRate * 1000) / 1024.0 / 1024, 3));
-
-            Process myprocess = Process.GetCurrentProcess();
-//            if (!myprocess.HasExited)
             try
             {
-                myprocess.Refresh();
-                sb.AppendFormat(
-                        "Process memory:      Physical {0} MB \t Paged {1} MB \t Virtual {2} MB\n",
-                        Math.Round(myprocess.WorkingSet64 / 1024.0 / 1024.0),
-                        Math.Round(myprocess.PagedMemorySize64 / 1024.0 / 1024.0),
-                        Math.Round(myprocess.VirtualMemorySize64 / 1024.0 / 1024.0));
-                sb.AppendFormat(
-                        "Peak process memory: Physical {0} MB \t Paged {1} MB \t Virtual {2} MB\n",
-                        Math.Round(myprocess.PeakWorkingSet64 / 1024.0 / 1024.0),
-                        Math.Round(myprocess.PeakPagedMemorySize64 / 1024.0 / 1024.0),
-                        Math.Round(myprocess.PeakVirtualMemorySize64 / 1024.0 / 1024.0));
+                using (Process myprocess = Process.GetCurrentProcess())
+                {
+                    sb.AppendFormat(
+                            "Process memory:      Physical {0} MB \t Paged {1} MB \t Virtual {2} MB\n",
+                            Math.Round(myprocess.WorkingSet64 / 1024.0 / 1024.0),
+                            Math.Round(myprocess.PagedMemorySize64 / 1024.0 / 1024.0),
+                            Math.Round(myprocess.VirtualMemorySize64 / 1024.0 / 1024.0));
+                    sb.AppendFormat(
+                            "Peak process memory: Physical {0} MB \t Paged {1} MB \t Virtual {2} MB\n",
+                            Math.Round(myprocess.PeakWorkingSet64 / 1024.0 / 1024.0),
+                            Math.Round(myprocess.PeakPagedMemorySize64 / 1024.0 / 1024.0),
+                            Math.Round(myprocess.PeakVirtualMemorySize64 / 1024.0 / 1024.0));
+                }
             }
             catch
             { }
diff --git a/OpenSim/Framework/Monitoring/ChecksManager.cs b/OpenSim/Framework/Monitoring/ChecksManager.cs
index ff3b041..f719099 100644
--- a/OpenSim/Framework/Monitoring/ChecksManager.cs
+++ b/OpenSim/Framework/Monitoring/ChecksManager.cs
@@ -88,7 +88,7 @@ namespace OpenSim.Framework.Monitoring
                         con.Output("check categories available are:");
 
                         foreach (string category in RegisteredChecks.Keys)
-                            con.OutputFormat("  {0}", category);
+                            con.Output("  {0}", category);
                     }
 //                    else
 //                    {
diff --git a/OpenSim/Framework/Monitoring/JobEngine.cs b/OpenSim/Framework/Monitoring/JobEngine.cs
index 7264c25..6c388b3 100644
--- a/OpenSim/Framework/Monitoring/JobEngine.cs
+++ b/OpenSim/Framework/Monitoring/JobEngine.cs
@@ -79,7 +79,7 @@ namespace OpenSim.Framework.Monitoring
         /// </remarks>
         private bool m_warnOverMaxQueue = true;
 
-        private BlockingCollection<Job> m_jobQueue = new BlockingCollection<Job>(new ConcurrentQueue<Job>(), 5000);
+        private BlockingCollection<Job> m_jobQueue = new BlockingCollection<Job>(5000);
 
         private CancellationTokenSource m_cancelSource;
 
@@ -194,7 +194,7 @@ namespace OpenSim.Framework.Monitoring
             {
                 if(!IsRunning)
                     return false;
-
+                
                 if(!m_threadRunnig)
                 {
                      WorkManager.RunInThreadPool(ProcessRequests, null, Name, false);
@@ -238,7 +238,7 @@ namespace OpenSim.Framework.Monitoring
                         break;
                     }
                 }
-                catch (ObjectDisposedException)
+                catch(ObjectDisposedException)
                 {
                     m_log.DebugFormat("[JobEngine] {0} stopping ignoring {1} jobs in queue",
                         Name,m_jobQueue.Count);
diff --git a/OpenSim/Framework/Monitoring/MemoryWatchdog.cs b/OpenSim/Framework/Monitoring/MemoryWatchdog.cs
index c474622..f2e47f8 100644
--- a/OpenSim/Framework/Monitoring/MemoryWatchdog.cs
+++ b/OpenSim/Framework/Monitoring/MemoryWatchdog.cs
@@ -110,20 +110,17 @@ namespace OpenSim.Framework.Monitoring
             long memoryNow = GC.GetTotalMemory(false);
             long memoryDiff = memoryNow - m_lastUpdateMemory;
 
-            if (memoryDiff >= 0)
-            {
-                if (m_samples.Count >= m_maxSamples)
+            if (m_samples.Count >= m_maxSamples)
                     m_samples.Dequeue();
 
-                double elapsed = Util.EnvironmentTickCountSubtract(now, m_lastUpdateTick);
+            double elapsed = Util.EnvironmentTickCountSubtract(now, m_lastUpdateTick);
 
-                // This should never happen since it's not useful for updates to occur with no time elapsed, but
-                // protect ourselves from a divide-by-zero just in case.
-                if (elapsed == 0)
-                    return;
+            // This should never happen since it's not useful for updates to occur with no time elapsed, but
+            // protect ourselves from a divide-by-zero just in case.
+            if (elapsed == 0)
+                return;
 
-                m_samples.Enqueue(memoryDiff / (double)elapsed);
-            }
+            m_samples.Enqueue(memoryDiff / (double)elapsed);
 
             UpdateLastRecord(memoryNow, now);
         }
diff --git a/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs b/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs
index 88a0297..c41c4b9 100644
--- a/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs
+++ b/OpenSim/Framework/Monitoring/SimExtraStatsCollector.cs
@@ -435,21 +435,19 @@ Asset service request failures: {3}" + Environment.NewLine,
             // Get the amount of physical memory, allocated with the instance of this program, in kilobytes;
             // the working set is the set of memory pages currently visible to this program in physical RAM
             // memory and includes both shared (e.g. system libraries) and private data
-            double memUsage = Process.GetCurrentProcess().WorkingSet64 / 1024.0;
-
-            // Get the number of threads from the system that are currently
-            // running
             int numberThreadsRunning = 0;
-            foreach (ProcessThread currentThread in
-                Process.GetCurrentProcess().Threads)
+            double memUsage = 0;
+            using(Process p = Process.GetCurrentProcess())
             {
-                // A known issue with the current process .Threads property is
-                // that it can return null threads, thus don't count those as
-                // running threads and prevent the program function from failing
-                if (currentThread != null &&
-                    currentThread.ThreadState == ThreadState.Running)
+                memUsage = p.WorkingSet64 / 1024.0;
+
+                // Get the number of threads from the system that are currently
+                // running
+                
+                foreach (ProcessThread currentThread in p.Threads)
                 {
-                    numberThreadsRunning++;
+                    if (currentThread != null && currentThread.ThreadState == ThreadState.Running)
+                        numberThreadsRunning++;
                 }
             }
 
diff --git a/OpenSim/Framework/Monitoring/Stats/Stat.cs b/OpenSim/Framework/Monitoring/Stats/Stat.cs
index 2276341..4b1a229 100644
--- a/OpenSim/Framework/Monitoring/Stats/Stat.cs
+++ b/OpenSim/Framework/Monitoring/Stats/Stat.cs
@@ -242,11 +242,7 @@ namespace OpenSim.Framework.Monitoring
         public virtual OSDMap ToBriefOSDMap()
         {
             OSDMap ret = new OSDMap();
-
             ret.Add("Value", OSD.FromReal(Value));
-
-//            double lastChangeOverTime, averageChangeOverTime;
-
             return ret;
         }
 
diff --git a/OpenSim/Framework/Monitoring/StatsLogger.cs b/OpenSim/Framework/Monitoring/StatsLogger.cs
index b719af9..e87c188 100644
--- a/OpenSim/Framework/Monitoring/StatsLogger.cs
+++ b/OpenSim/Framework/Monitoring/StatsLogger.cs
@@ -79,7 +79,7 @@ namespace OpenSim.Framework.Monitoring
             if (cmd[2] == "start")
             {
                 Start();
-                con.OutputFormat("Now recording all stats to file every {0}ms", m_statsLogIntervalMs);
+                con.Output("Now recording all stats to file every {0}ms", m_statsLogIntervalMs);
             }
             else if (cmd[2] == "stop")
             {
@@ -106,7 +106,7 @@ namespace OpenSim.Framework.Monitoring
                     sw.WriteLine(line);
             }
 
-            MainConsole.Instance.OutputFormat("Stats saved to file {0}", path);
+            MainConsole.Instance.Output("Stats saved to file {0}", path);
         }
 
         public static void Start()
diff --git a/OpenSim/Framework/Monitoring/StatsManager.cs b/OpenSim/Framework/Monitoring/StatsManager.cs
index a6b341f..05fb07a 100644
--- a/OpenSim/Framework/Monitoring/StatsManager.cs
+++ b/OpenSim/Framework/Monitoring/StatsManager.cs
@@ -117,14 +117,14 @@ namespace OpenSim.Framework.Monitoring
                     {
                         con.Output("Statistic categories available are:");
                         foreach (string category in RegisteredStats.Keys)
-                            con.OutputFormat("  {0}", category);
+                            con.Output("  {0}", category);
                     }
                     else
                     {
                         SortedDictionary<string, SortedDictionary<string, Stat>> category;
                         if (!RegisteredStats.TryGetValue(categoryName, out category))
                         {
-                            con.OutputFormat("No such category as {0}", categoryName);
+                            con.Output("No such category as {0}", categoryName);
                         }
                         else
                         {
@@ -150,14 +150,14 @@ namespace OpenSim.Framework.Monitoring
                                         }
                                         else
                                         {
-                                            con.OutputFormat(
+                                            con.Output(
                                                 "No such stat {0} in {1}.{2}", statName, categoryName, containerName);
                                         }
                                     }
                                 }
                                 else
                                 {
-                                    con.OutputFormat("No such container {0} in category {1}", containerName, categoryName);
+                                    con.Output("No such container {0} in category {1}", containerName, categoryName);
                                 }
                             }
                         }
diff --git a/OpenSim/Framework/Monitoring/Watchdog.cs b/OpenSim/Framework/Monitoring/Watchdog.cs
index 9cac451..ad21d93 100644
--- a/OpenSim/Framework/Monitoring/Watchdog.cs
+++ b/OpenSim/Framework/Monitoring/Watchdog.cs
@@ -197,6 +197,9 @@ namespace OpenSim.Framework.Monitoring
                 foreach(ThreadWatchdogInfo twi in m_threads.Values)
                 {
                     Thread t = twi.Thread;
+                    // m_log.DebugFormat(
+                    //    "[WATCHDOG]: Stop: Removing thread {0}, ID {1}", twi.Thread.Name, twi.Thread.ManagedThreadId);
+
                     if(t.IsAlive)
                         t.Abort();
                 }
diff --git a/OpenSim/Framework/Monitoring/WorkManager.cs b/OpenSim/Framework/Monitoring/WorkManager.cs
index 5d9b185..ce639b9 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)
@@ -251,23 +215,23 @@ namespace OpenSim.Framework.Monitoring
             if (subCommand == "stop")
             {
                 JobEngine.Stop();
-                MainConsole.Instance.OutputFormat("Stopped job engine.");
+                MainConsole.Instance.Output("Stopped job engine.");
             }
             else if (subCommand == "start")
             {
                 JobEngine.Start();
-                MainConsole.Instance.OutputFormat("Started job engine.");
+                MainConsole.Instance.Output("Started job engine.");
             }
             else if (subCommand == "status")
             {
-                MainConsole.Instance.OutputFormat("Job engine running: {0}", JobEngine.IsRunning);
+                MainConsole.Instance.Output("Job engine running: {0}", JobEngine.IsRunning);
 
                 JobEngine.Job job = JobEngine.CurrentJob;
-                MainConsole.Instance.OutputFormat("Current job {0}", job != null ? job.Name : "none");
+                MainConsole.Instance.Output("Current job {0}", job != null ? job.Name : "none");
 
-                MainConsole.Instance.OutputFormat(
+                MainConsole.Instance.Output(
                     "Jobs waiting: {0}", JobEngine.IsRunning ? JobEngine.JobsWaiting.ToString() : "n/a");
-                MainConsole.Instance.OutputFormat("Log Level: {0}", JobEngine.LogLevel);
+                MainConsole.Instance.Output("Log Level: {0}", JobEngine.LogLevel);
             }
             else if (subCommand == "log")
             {
@@ -282,12 +246,12 @@ namespace OpenSim.Framework.Monitoring
                 //                if (ConsoleUtil.TryParseConsoleInt(MainConsole.Instance, args[4], out logLevel))
                 //                {
                 JobEngine.LogLevel = logLevel;
-                MainConsole.Instance.OutputFormat("Set debug log level to {0}", JobEngine.LogLevel);
+                MainConsole.Instance.Output("Set debug log level to {0}", JobEngine.LogLevel);
                 //                }
             }
             else
             {
-                MainConsole.Instance.OutputFormat("Unrecognized job engine subcommand {0}", subCommand);
+                MainConsole.Instance.Output("Unrecognized job engine subcommand {0}", subCommand);
             }
         }
     }