"threads" command now works. I've added manual tracking of threads (only if compiled in DEBUG mode)... Its ugly and even requires a separate thread to track the treads, but it will be very valuable in debugging.

author: Tedd Hansen 2008-02-21 10:43:24 +0000
committer: Tedd Hansen 2008-02-21 10:43:24 +0000
commit: 7102ac77698f4bfd7406d6e8871db7b006c2cae2 (patch)
tree: 7253775d1a6ae64e2469b1ef79863aaebe83e1d1 /OpenSim/Framework/ThreadTracker.cs
parent: Remove a couple compiler warnings. (diff)
download: opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.zip
opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.tar.gz
opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.tar.bz2
opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.tar.xz
1 files changed, 106 insertions, 0 deletions
diff --git a/OpenSim/Framework/ThreadTracker.cs b/OpenSim/Framework/ThreadTracker.cs
new file mode 100644
index 0000000..42e3879
--- /dev/null
+++ b/OpenSim/Framework/ThreadTracker.cs
@@ -0,0 +1,106 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+namespace OpenSim.Framework
+{
+    public static class ThreadTracker
+    {
+        public static List<ThreadTrackerItem> m_Threads;
+        public static System.Threading.Thread ThreadTrackerThread;
+        private static readonly long ThreadTimeout = 30 * 10000000;
+        static ThreadTracker()
+        {
+#if DEBUG
+            m_Threads = new List<ThreadTrackerItem>();
+            ThreadTrackerThread = new Thread(ThreadTrackerThreadLoop);
+            ThreadTrackerThread.Name = "ThreadTrackerThread";
+            ThreadTrackerThread.IsBackground = true;
+            ThreadTrackerThread.Priority = System.Threading.ThreadPriority.BelowNormal;
+            ThreadTrackerThread.Start();
+#endif
+        }
+        private static void ThreadTrackerThreadLoop()
+        {
+            while (true)
+            {
+                Thread.Sleep(5000);
+                CleanUp();
+            }
+        }
+        public static void Add(System.Threading.Thread thread)
+        {
+#if DEBUG
+            lock (m_Threads)
+            {
+                ThreadTrackerItem tti = new ThreadTrackerItem();
+                tti.Thread = thread;
+                tti.LastSeenActive = DateTime.Now.Ticks;
+                m_Threads.Add(tti);
+            }
+#endif
+        }
+        public static void Remove(System.Threading.Thread thread)
+        {
+#if DEBUG
+            lock (m_Threads)
+            {
+                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
+                {
+                    if (tti.Thread == thread)
+                        m_Threads.Remove(tti);
+                }
+            }
+#endif
+        }
+        public static void CleanUp()
+        {
+            lock (m_Threads)
+            {
+                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
+                {
+                    if (tti.Thread.IsAlive)
+                    {
+                        // Its active
+                        tti.LastSeenActive = DateTime.Now.Ticks;
+                    }
+                    else
+                    {
+                        // Its not active -- if its expired then remove it
+                        if (tti.LastSeenActive + ThreadTimeout < DateTime.Now.Ticks)
+                            m_Threads.Remove(tti);
+                    }
+                }
+            }
+        }
+        public static List<Thread> GetThreads()
+        {
+            if (m_Threads == null)
+                return null;
+            List<Thread> threads = new List<Thread>();
+            lock (m_Threads)
+            {
+                foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
+                {
+                    threads.Add(tti.Thread);
+                }
+            }
+            return threads;
+        }
+        public class ThreadTrackerItem
+        {
+            public System.Threading.Thread Thread;
+            public long LastSeenActive;
+        }
+    }
+}
author	Tedd Hansen	2008-02-21 10:43:24 +0000
committer	Tedd Hansen	2008-02-21 10:43:24 +0000
commit	7102ac77698f4bfd7406d6e8871db7b006c2cae2 (patch)
tree	7253775d1a6ae64e2469b1ef79863aaebe83e1d1 /OpenSim/Framework/ThreadTracker.cs
parent	Remove a couple compiler warnings. (diff)
download	opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.zip opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.tar.gz opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.tar.bz2 opensim-SC_OLD-7102ac77698f4bfd7406d6e8871db7b006c2cae2.tar.xz

diff --git a/OpenSim/Framework/ThreadTracker.cs b/OpenSim/Framework/ThreadTracker.cs new file mode 100644 index 0000000..42e3879 --- /dev/null +++ b/OpenSim/Framework/ThreadTracker.cs
@@ -0,0 +1,106 @@
	1	using System;
	2	using System.Collections;
	3	using System.Collections.Generic;
	4	using System.Text;
	5	using System.Threading;
	6
	7	namespace OpenSim.Framework
	8	{
	9	public static class ThreadTracker
	10	{
	11	public static List<ThreadTrackerItem> m_Threads;
	12	public static System.Threading.Thread ThreadTrackerThread;
	13	private static readonly long ThreadTimeout = 30 * 10000000;
	14
	15	static ThreadTracker()
	16	{
	17	#if DEBUG
	18	m_Threads = new List<ThreadTrackerItem>();
	19	ThreadTrackerThread = new Thread(ThreadTrackerThreadLoop);
	20	ThreadTrackerThread.Name = "ThreadTrackerThread";
	21	ThreadTrackerThread.IsBackground = true;
	22	ThreadTrackerThread.Priority = System.Threading.ThreadPriority.BelowNormal;
	23	ThreadTrackerThread.Start();
	24	#endif
	25	}
	26
	27	private static void ThreadTrackerThreadLoop()
	28	{
	29	while (true)
	30	{
	31	Thread.Sleep(5000);
	32	CleanUp();
	33	}
	34	}
	35
	36	public static void Add(System.Threading.Thread thread)
	37	{
	38	#if DEBUG
	39	lock (m_Threads)
	40	{
	41	ThreadTrackerItem tti = new ThreadTrackerItem();
	42	tti.Thread = thread;
	43	tti.LastSeenActive = DateTime.Now.Ticks;
	44	m_Threads.Add(tti);
	45	}
	46	#endif
	47	}
	48
	49	public static void Remove(System.Threading.Thread thread)
	50	{
	51	#if DEBUG
	52	lock (m_Threads)
	53	{
	54	foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
	55	{
	56	if (tti.Thread == thread)
	57	m_Threads.Remove(tti);
	58	}
	59	}
	60	#endif
	61	}
	62
	63	public static void CleanUp()
	64	{
	65	lock (m_Threads)
	66	{
	67	foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
	68	{
	69	if (tti.Thread.IsAlive)
	70	{
	71	// Its active
	72	tti.LastSeenActive = DateTime.Now.Ticks;
	73	}
	74	else
	75	{
	76	// Its not active -- if its expired then remove it
	77	if (tti.LastSeenActive + ThreadTimeout < DateTime.Now.Ticks)
	78	m_Threads.Remove(tti);
	79	}
	80	}
	81	}
	82	}
	83
	84	public static List<Thread> GetThreads()
	85	{
	86	if (m_Threads == null)
	87	return null;
	88
	89	List<Thread> threads = new List<Thread>();
	90	lock (m_Threads)
	91	{
	92	foreach (ThreadTrackerItem tti in new ArrayList(m_Threads))
	93	{
	94	threads.Add(tti.Thread);
	95	}
	96	}
	97	return threads;
	98	}
	99
	100	public class ThreadTrackerItem
	101	{
	102	public System.Threading.Thread Thread;
	103	public long LastSeenActive;
	104	}
	105	}
	106	}