11 files changed, 276 insertions, 78 deletions

diff --git a/OpenSim/Framework/ClientManager.cs b/OpenSim/Framework/ClientManager.cs
index 61b59e7..baff2f4 100644
--- a/OpenSim/Framework/ClientManager.cs
+++ b/OpenSim/Framework/ClientManager.cs
@@ -204,7 +204,10 @@ namespace OpenSim.Framework
         public void ForEach(Action<IClientAPI> action)
         {
             IClientAPI[] localArray = m_array;
-            Parallel.ForEach<IClientAPI>(localArray, action);
+            Parallel.For(0, localArray.Length,
+                delegate(int i)
+                { action(localArray[i]); }
+            );
         }
 
         /// <summary>
diff --git a/OpenSim/Framework/IScene.cs b/OpenSim/Framework/IScene.cs
index f34027d..8067052 100644
--- a/OpenSim/Framework/IScene.cs
+++ b/OpenSim/Framework/IScene.cs
@@ -62,7 +62,6 @@ namespace OpenSim.Framework
         RegionInfo RegionInfo { get; }
         RegionStatus RegionStatus { get; set; }
 
-        ClientManager ClientManager { get; }
         IConfigSource Config { get; }
 
         float TimeDilation { get; }
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/Parallel.cs b/OpenSim/Framework/Parallel.cs
index 70eecdc..515852f 100644
--- a/OpenSim/Framework/Parallel.cs
+++ b/OpenSim/Framework/Parallel.cs
@@ -118,6 +118,7 @@ namespace OpenSim.Framework
             int counter = threadCount;
             AutoResetEvent threadFinishEvent = new AutoResetEvent(false);
             IEnumerator<T> enumerator = enumerable.GetEnumerator();
+            object syncRoot = new object();
             Exception exception = null;
 
             for (int i = 0; i < threadCount; i++)
@@ -131,7 +132,7 @@ namespace OpenSim.Framework
                         {
                             T entry;
 
-                            lock (enumerator)
+                            lock (syncRoot)
                             {
                                 if (!enumerator.MoveNext())
                                     break;
diff --git a/OpenSim/Framework/PluginLoader.cs b/OpenSim/Framework/PluginLoader.cs
index 5d38f5f..819cb7b 100644
--- a/OpenSim/Framework/PluginLoader.cs
+++ b/OpenSim/Framework/PluginLoader.cs
@@ -194,10 +194,15 @@ namespace OpenSim.Framework
             }
         }
 
+        /// <summary>
+        /// Unregisters Mono.Addins event handlers, allowing temporary Mono.Addins
+        /// data to be garbage collected. Since the plugins created by this loader
+        /// are meant to outlive the loader itself, they must be disposed separately
+        /// </summary>
         public void Dispose()
         {
-            foreach (T plugin in Plugins)
-                plugin.Dispose();
+            AddinManager.AddinLoadError -= on_addinloaderror_;
+            AddinManager.AddinLoaded -= on_addinloaded_;
         }
 
         private void initialise_plugin_dir_(string dir)
diff --git a/OpenSim/Framework/PrimitiveBaseShape.cs b/OpenSim/Framework/PrimitiveBaseShape.cs
index b646f92..5e4d175 100644
--- a/OpenSim/Framework/PrimitiveBaseShape.cs
+++ b/OpenSim/Framework/PrimitiveBaseShape.cs
@@ -76,7 +76,7 @@ namespace OpenSim.Framework
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        private static readonly Primitive.TextureEntry m_defaultTexture;
+        private static readonly byte[] DEFAULT_TEXTURE = new Primitive.TextureEntry(new UUID("89556747-24cb-43ed-920b-47caed15465f")).GetBytes();
 
         private byte[] m_textureEntry;
 
@@ -104,33 +104,32 @@ namespace OpenSim.Framework
         private HollowShape _hollowShape;
 
         // Sculpted
-        [XmlIgnore] private UUID _sculptTexture = UUID.Zero;
-        [XmlIgnore] private byte _sculptType = (byte)0;
-        [XmlIgnore] private byte[] _sculptData = new byte[0];
-        [XmlIgnore] private Image _sculptBitmap = null;
+        [XmlIgnore] private UUID _sculptTexture;
+        [XmlIgnore] private byte _sculptType;
+        [XmlIgnore] private byte[] _sculptData = Utils.EmptyBytes;
 
         // Flexi
-        [XmlIgnore] private int _flexiSoftness = 0;
-        [XmlIgnore] private float _flexiTension = 0f;
-        [XmlIgnore] private float _flexiDrag = 0f;
-        [XmlIgnore] private float _flexiGravity = 0f;
-        [XmlIgnore] private float _flexiWind = 0f;
-        [XmlIgnore] private float _flexiForceX = 0f;
-        [XmlIgnore] private float _flexiForceY = 0f;
-        [XmlIgnore] private float _flexiForceZ = 0f;
+        [XmlIgnore] private int _flexiSoftness;
+        [XmlIgnore] private float _flexiTension;
+        [XmlIgnore] private float _flexiDrag;
+        [XmlIgnore] private float _flexiGravity;
+        [XmlIgnore] private float _flexiWind;
+        [XmlIgnore] private float _flexiForceX;
+        [XmlIgnore] private float _flexiForceY;
+        [XmlIgnore] private float _flexiForceZ;
 
         //Bright n sparkly
-        [XmlIgnore] private float _lightColorR = 0f;
-        [XmlIgnore] private float _lightColorG = 0f;
-        [XmlIgnore] private float _lightColorB = 0f;
-        [XmlIgnore] private float _lightColorA = 1f;
-        [XmlIgnore] private float _lightRadius = 0f;
-        [XmlIgnore] private float _lightCutoff = 0f;
-        [XmlIgnore] private float _lightFalloff = 0f;
-        [XmlIgnore] private float _lightIntensity = 1f;
-        [XmlIgnore] private bool _flexiEntry = false;
-        [XmlIgnore] private bool _lightEntry = false;
-        [XmlIgnore] private bool _sculptEntry = false;
+        [XmlIgnore] private float _lightColorR;
+        [XmlIgnore] private float _lightColorG;
+        [XmlIgnore] private float _lightColorB;
+        [XmlIgnore] private float _lightColorA = 1.0f;
+        [XmlIgnore] private float _lightRadius;
+        [XmlIgnore] private float _lightCutoff;
+        [XmlIgnore] private float _lightFalloff;
+        [XmlIgnore] private float _lightIntensity = 1.0f;
+        [XmlIgnore] private bool _flexiEntry;
+        [XmlIgnore] private bool _lightEntry;
+        [XmlIgnore] private bool _sculptEntry;
 
         public byte ProfileCurve
         {
@@ -172,17 +171,11 @@ namespace OpenSim.Framework
             }
         }
 
-        static PrimitiveBaseShape()
-        {
-            m_defaultTexture =
-                new Primitive.TextureEntry(new UUID("89556747-24cb-43ed-920b-47caed15465f"));
-        }
-
         public PrimitiveBaseShape()
         {
             PCode = (byte) PCodeEnum.Primitive;
             ExtraParams = new byte[1];
-            Textures = m_defaultTexture;
+            m_textureEntry = DEFAULT_TEXTURE;
         }
 
         public PrimitiveBaseShape(bool noShape)
@@ -192,7 +185,7 @@ namespace OpenSim.Framework
 
             PCode = (byte)PCodeEnum.Primitive;
             ExtraParams = new byte[1];
-            Textures = m_defaultTexture;
+            m_textureEntry = DEFAULT_TEXTURE;
         }
 
         [XmlIgnore]
@@ -577,15 +570,6 @@ namespace OpenSim.Framework
             }
         }
 
-        public Image SculptBitmap {
-            get {
-                return _sculptBitmap;
-            }
-            set {
-                _sculptBitmap = value;
-            }
-        }
-
         public int FlexiSoftness {
             get {
                 return _flexiSoftness;
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index 85d7be2..bec5ed3 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -1559,15 +1559,7 @@ namespace OpenSim.Framework.Servers.HttpServer
         public void Start()
         {
             m_log.Info("[HTTPD]: Starting up HTTP Server");
-
-            //m_workerThread = new Thread(new ThreadStart(StartHTTP));
-            //m_workerThread.Name = "HttpThread";
-            //m_workerThread.IsBackground = true;
-            //m_workerThread.Start();
-            //ThreadTracker.Add(m_workerThread);
             StartHTTP();
-            
-
         }
 
         private void StartHTTP()
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 1c54581..e7a64f7 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -50,9 +50,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             m_WorkerThreadCount = pWorkerThreadCount;
             m_workerThreads = new Thread[m_WorkerThreadCount];
             m_PollServiceWorkerThreads = new PollServiceWorkerThread[m_WorkerThreadCount];
-            m_watcherThread = new Thread(ThreadStart);
 
-            
             //startup worker threads
             for (uint i=0;i<m_WorkerThreadCount;i++)
             {
@@ -65,11 +63,11 @@ namespace OpenSim.Framework.Servers.HttpServer
                 m_workerThreads[i].Start();
                 
             }
+
             //start watcher threads
+            m_watcherThread = new Thread(ThreadStart);
             m_watcherThread.Name = "PollServiceWatcherThread";
             m_watcherThread.Start();
-
-
         }
 
         internal void ReQueueEvent(PollServiceHttpRequest req)
diff --git a/OpenSim/Framework/Servers/VersionInfo.cs b/OpenSim/Framework/Servers/VersionInfo.cs
index 62e7e92..9f98310 100644
--- a/OpenSim/Framework/Servers/VersionInfo.cs
+++ b/OpenSim/Framework/Servers/VersionInfo.cs
@@ -29,8 +29,8 @@ namespace OpenSim
 {
     public class VersionInfo
     {
-        private const string VERSION_NUMBER = "0.6.7";
-        private const Flavour VERSION_FLAVOUR = Flavour.RC1;
+        private const string VERSION_NUMBER = "0.6.8";
+        private const Flavour VERSION_FLAVOUR = Flavour.Dev;
 
         public enum Flavour
         {
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index d09bd6d..10f38ab 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;
+                throw new InvalidOperationException("SmartThreadPool is already initialized");
 
-            startInfo.StartSuspended = false;
-
-            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:
-                    m_ThreadPool.QueueWorkItem(delegate(object o) { callback(o); return null; }, obj);
+                    if (m_ThreadPool == null)
+                        m_ThreadPool = new SmartThreadPool(2000, 15, 2);
+                    m_ThreadPool.QueueWorkItem(SmartThreadPoolCallback, new object[] { callback, 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:
@@ -1362,6 +1358,16 @@ namespace OpenSim.Framework
             }
         }
 
+        private static object SmartThreadPoolCallback(object o)
+        {
+            object[] array = (object[])o;
+            WaitCallback callback = (WaitCallback)array[0];
+            object obj = array[1];
+
+            callback(obj);
+            return null;
+        }
+
         #endregion FireAndForget Threading Pattern
     }
 }
diff --git a/OpenSim/Framework/Watchdog.cs b/OpenSim/Framework/Watchdog.cs
new file mode 100644
index 0000000..5d46905
--- /dev/null
+++ b/OpenSim/Framework/Watchdog.cs
@@ -0,0 +1,183 @@
+/*
+ * 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.Collections.Generic;
+using System.Threading;
+using log4net;
+
+namespace OpenSim.Framework
+{
+    /// <summary>
+    /// Manages launching threads and keeping watch over them for timeouts
+    /// </summary>
+    public static class Watchdog
+    {
+        /// <summary>Timer interval in milliseconds for the watchdog timer</summary>
+        const double WATCHDOG_INTERVAL_MS = 2500.0d;
+        /// <summary>Maximum timeout in milliseconds before a thread is considered dead</summary>
+        const int WATCHDOG_TIMEOUT_MS = 5000;
+
+        [System.Diagnostics.DebuggerDisplay("{Thread.Name}")]
+        private class ThreadWatchdogInfo
+        {
+            public Thread Thread;
+            public int LastTick;
+
+            public ThreadWatchdogInfo(Thread thread)
+            {
+                Thread = thread;
+                LastTick = Environment.TickCount & Int32.MaxValue;
+            }
+        }
+
+        /// <summary>
+        /// This event is called whenever a tracked thread is stopped or
+        /// has not called UpdateThread() in time
+        /// </summary>
+        /// <param name="thread">The thread that has been identified as dead</param>
+        /// <param name="lastTick">The last time this thread called UpdateThread()</param>
+        public delegate void WatchdogTimeout(Thread thread, int lastTick);
+
+        /// <summary>This event is called whenever a tracked thread is
+        /// stopped or has not called UpdateThread() in time</summary>
+        public static event WatchdogTimeout OnWatchdogTimeout;
+
+        private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        private static Dictionary<int, ThreadWatchdogInfo> m_threads;
+        private static System.Timers.Timer m_watchdogTimer;
+
+        static Watchdog()
+        {
+            m_threads = new Dictionary<int, ThreadWatchdogInfo>();
+            m_watchdogTimer = new System.Timers.Timer(WATCHDOG_INTERVAL_MS);
+            m_watchdogTimer.AutoReset = false;
+            m_watchdogTimer.Elapsed += WatchdogTimerElapsed;
+            m_watchdogTimer.Start();
+        }
+
+        /// <summary>
+        /// Start a new thread that is tracked by the watchdog timer
+        /// </summary>
+        /// <param name="start">The method that will be executed in a new thread</param>
+        /// <param name="name">A name to give to the new thread</param>
+        /// <param name="priority">Priority to run the thread at</param>
+        /// <param name="isBackground">True to run this thread as a background
+        /// thread, otherwise false</param>
+        /// <returns>The newly created Thread object</returns>
+        public static Thread StartThread(ThreadStart start, string name, ThreadPriority priority, bool isBackground)
+        {
+            Thread thread = new Thread(start);
+            thread.Name = name;
+            thread.Priority = priority;
+            thread.IsBackground = isBackground;
+            thread.Start();
+
+            return thread;
+        }
+
+        /// <summary>
+        /// Marks the current thread as alive
+        /// </summary>
+        public static void UpdateThread()
+        {
+            UpdateThread(Thread.CurrentThread.ManagedThreadId);
+        }
+
+        /// <summary>
+        /// Stops watchdog tracking on the current thread
+        /// </summary>
+        /// <returns>True if the thread was removed from the list of tracked
+        /// threads, otherwise false</returns>
+        public static bool RemoveThread()
+        {
+            return RemoveThread(Thread.CurrentThread.ManagedThreadId);
+        }
+
+        private static void AddThread(ThreadWatchdogInfo threadInfo)
+        {
+            m_log.Debug("[WATCHDOG]: Started tracking thread \"" + threadInfo.Thread.Name + "\" (ID " + threadInfo.Thread.ManagedThreadId + ")");
+
+            lock (m_threads)
+                m_threads.Add(threadInfo.Thread.ManagedThreadId, threadInfo);
+        }
+
+        private static bool RemoveThread(int threadID)
+        {
+            lock (m_threads)
+                return m_threads.Remove(threadID);
+        }
+
+        private static void UpdateThread(int threadID)
+        {
+            ThreadWatchdogInfo threadInfo;
+
+            // Although TryGetValue is not a thread safe operation, we use a try/catch here instead
+            // of a lock for speed. Adding/removing threads is a very rare operation compared to
+            // UpdateThread(), and a single UpdateThread() failure here and there won't break
+            // anything
+            try
+            {
+                if (m_threads.TryGetValue(threadID, out threadInfo))
+                    threadInfo.LastTick = Environment.TickCount & Int32.MaxValue;
+                else
+                    AddThread(new ThreadWatchdogInfo(Thread.CurrentThread));
+            }
+            catch { }
+        }
+
+        private static void WatchdogTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
+        {
+            WatchdogTimeout callback = OnWatchdogTimeout;
+
+            if (callback != null)
+            {
+                ThreadWatchdogInfo timedOut = null;
+
+                lock (m_threads)
+                {
+                    int now = Environment.TickCount & Int32.MaxValue;
+
+                    foreach (ThreadWatchdogInfo threadInfo in m_threads.Values)
+                    {
+                        if (threadInfo.Thread.ThreadState == ThreadState.Stopped || now - threadInfo.LastTick >= WATCHDOG_TIMEOUT_MS)
+                        {
+                            timedOut = threadInfo;
+                            m_threads.Remove(threadInfo.Thread.ManagedThreadId);
+                            break;
+                        }
+                    }
+                }
+
+                if (timedOut != null)
+                    callback(timedOut.Thread, timedOut.LastTick);
+            }
+
+            m_watchdogTimer.Start();
+        }
+    }
+}