sealed class Runner : MarshalByRefObject

		/*

		{

			ManualResetEvent wait;

		Timer Scheduler

			AutoResetEvent start_event;

		---------------

			TimerCallback callback;

		Author: Rafael Ferreira (raf@ophion.org)

			object state;

			int dueTime;

		The code below implements a single thread scheduler that fires

			int period;

		events using the runtime's built-in thread pool.

			bool disposed;

			bool aborted;

			public Runner (TimerCallback callback, object state, AutoResetEvent start_event)

		Key Features:

			{

			Single thread scheduler:

				this.callback = callback;

				A single thread handles firing all timer jobs thus allowing a 

				this.state = state;

				much greater number of Timers to be defined

				this.start_event = start_event;

			Lazy init:

				this.wait = new ManualResetEvent (false);

				Timer scheduler is only started after the first System.Threading.Timer is created

			}

			Early termination:

				Timer scheduler thread dies if there are no more timer jobs in its Job queue

		In a nutshell the scheduler works like this:

			1 - The main scheduler thread (TimerScheduler) wakes up and finds out what time it is

			2 - The scheduler iterates over the list of timer jobs (Jobs) to find out when the next job is

			as well as fires all timers that were scheduled to run now or in the past

			3 - The Scheduler then calculates the mutiplier for its sleep algorithm. The multiplier

			is basically MSEC_UNTIL_NEXT_JOB / TIME_SLICE where TIME_SLICE is the minimum amount of 

			time the scheduler thread is allowed to sleep for

			4 - Sleep for multiplier * TIME_SLICE

			5 - Goto 1

			public int DueTime {

		Possible improvements:

				get { return dueTime; }

			* Convert the big for-loop into a sorted data structure. This will speed up the time

				set { dueTime = value; }

			it takes the scheduler to iterate over the timer jobs and lower CPU usage under insane 

			}

			amounts of Timers 

			public int Period {

		Possible issues:

				get { return period; }

			* Overflow issues with the multiplier

				set { period = value == 0 ? Timeout.Infinite : value; }

			* Race conditions with lazy-init of the scheduler thread.

			}

			bool WaitForDueTime ()

		Note:

			{

			* MONO_TIMER_DEBUG environment variable can be used to turn on the scheduler's debug log

				if (dueTime > 0) {

			* MONO_TIMER_USETP environment variable can be used to force the timer scheduler to use 

					bool signaled;

			the CLI's built in thread pool

					do {

			* sync_obj is used to make signaling the scheduler class sane so only one signal is sent at a

						wait.Reset ();

			time and a decision can be made on the signal so signals are "batched" or discarded 

						signaled = wait.WaitOne (dueTime, false);

					} while (signaled == true && !disposed && !aborted);

					if (!signaled)

		*/

						callback (state);

					if (disposed)

		// timer metadata:

						return false;

		internal long NextRun;

				}

		internal long LastRun;

				else

		internal long Period;

					callback (state);

		internal bool Enabled;

		internal TimerCallback Callback;

		internal int ID;

		internal object State = null;

		// flag that turns on "verbose logging"

		static bool debug_enabled = false;

		// flag that tells scheduler to use the cli's thread pool

		static bool use_threadpool = false;

		// mininum sleep time

		const int TIME_SLICE = 10 ; // 10 msec

		// next Timer ID;

		static int next_id = 0;

				return true;

		// timer scheduler - there can only be one

			}

		static Thread scheduler = null;

		// used to enforce thread safety

		static object sync_obj = new object();

		static Hashtable Jobs =  new Hashtable();

			public void Abort ()

		static bool scheduler_ready = false;

			{

				lock (this) {

		// this enum is used to signal the scheduler thread of the reason for the Abort() call

					aborted = true;

		// abort() is used to signal the timer thread since Interrupt() is not implemented

					wait.Set ();

		enum AbortSignals { TimerAdded, TimerRemoved, TimerChanged };

				}

		sealed class Runner: MarshalByRefObject

		{

			Timer timer;

			public Runner(Timer t) {

				this.timer = t;

			public void Dispose ()

				timer.Callback(timer.State);

			{

				lock (this) {

					disposed = true;

					Abort ();

				}

			public void Start ()

		}

			{

		// prorperly handles signaling the scheduler thread

				while (!disposed && start_event.WaitOne ()) {

		// it will retry for 500 msec (.5 sec) if it can't properly signal scheduler

					if (disposed)

		// NOT THREAD SAFE

						return;

		void SendSchedulerSignal (AbortSignals signal) 

		{

			for (int i = 0; i < 100; i++) {

					aborted = false;

				// we don't start a new scheduler if the signal is TimerRemoved

				if (scheduler == null) {

					log("Scheduler not currently running... new scheduler will be initiated");

					scheduler = new Thread( new ThreadStart(SchedulerThread));

					scheduler.IsBackground = true;

					scheduler.Start();

					return;

				} 

					if (dueTime == Timeout.Infinite)

				if (scheduler.ThreadState == ThreadState.AbortRequested || 	scheduler.ThreadState == ThreadState.Aborted) {

						continue;

					return;

				}

					if (!WaitForDueTime ())

				if (scheduler_ready) {

						return;

					// we batch send Abort() calls

					// Abort is used since Thread.Interrupt is not supported.

					scheduler.Abort(signal);

					return;

				}

				log("could not properly signal timer-scheduler, waiting...");

				Thread.Sleep(5); 

			}

			throw new Exception("Could not properly abort timer-scheduler thread");

		}

					if (aborted || (period == Timeout.Infinite))

		public void SchedulerThread () 

						continue;

		{

			Thread.CurrentThread.Name = "Timer-Scheduler";

			long tick = 0;

			long next_job = Int64.MaxValue;

			Timer tj = null;

			int multiplier = 1;

			// big scary for-loop that iterates over the jobs

			while(Jobs.Count > 0) {

				if (!scheduler_ready)  {

					scheduler_ready=true;

					log("Scheduler is ready");

				}

					bool signaled = false;

				try {

					while (true) {

					tick = DateTime.Now.Ticks;

						if (disposed)

					lock (Jobs) {

							return;

						foreach (DictionaryEntry entry in Jobs) {

							tj = entry.Value as Timer;

						if (aborted)

							if (tj.Enabled == false) {

							break;

								continue;

							}

							if ( tj.NextRun <= tick) {

								// Firing job 

								log("Firing job " + tj.ID);

								dispatch(tj);

								if (tj.Period == - 1) {

									// it is a run-once job, so we disable it

									tj.Enabled = false;

								}

								else {

									tj.NextRun = tick + tj.Period;

								}

								tj.LastRun = tick;

						try {

								// we reset the next_job to the max possible value so the real next job

							wait.Reset ();

								// can be figured out

						} catch (ObjectDisposedException) {

								next_job = Int64.MaxValue;

							// FIXME: There is some race condition

							}

							//        here when the thread is being

							if ( next_job > tj.NextRun) {

							//        aborted on exit.

								next_job = tj.NextRun;

							return;

							}

					}

						signaled = wait.WaitOne (period, false);

					// no other jobs are available and all timers

						if (aborted || disposed)

					// are disabled

							break;

					if (next_job == Int64.MaxValue) {

						log("no active timers found, going into infinite sleep");

						if (!signaled) {

						Thread.Sleep(Timeout.Infinite);

							callback (state);

						} else if (!WaitForDueTime ()) {

					}else {

							return;

						multiplier = (int) ((next_job - tick) / TimeSpan.TicksPerMillisecond);

						multiplier = multiplier / TIME_SLICE;

						if (multiplier > 0 ) {

							//TODO there are some edgy race conditions between the abort signal and telling a thread 

							// to sleep

							log("gong to sleep for " + multiplier + " times the time slice");

							Thread.Sleep(multiplier * TIME_SLICE);

		Runner runner;

		void log (string str)

		AutoResetEvent start_event;

		{

		Thread t;

			if (debug_enabled)

				Console.Error.WriteLine(String.Format("{0} TIMER SCHEDULER: {1}",DateTime.Now,str));

		}

			start_event = new AutoResetEvent (false);

			if (!debug_enabled) {

			runner = new Runner (callback, state, start_event);

				if(Environment.GetEnvironmentVariable("MONO_TIMER_DEBUG") != null)

			Change (dueTime, period);

					debug_enabled = true;

			t = new Thread (new ThreadStart (runner.Start));

			}

			t.IsBackground = true;

			t.Start ();

			if (!use_threadpool) {

				if(Environment.GetEnvironmentVariable("MONO_TIMER_USETP") != null) {

					log("timer will dispatch using the thread pool");	

					use_threadpool = true;

				}

			}			

			ID = Interlocked.Increment(ref next_id);

			// first run take into consideration the delay metric only

			SetProperties(dueTime,period);

			Callback = callback;

			State = state;

			// lock job Q

			lock(Jobs) {

				Jobs.Add(ID,this);

			}

			lock(sync_obj) {

				SendSchedulerSignal(AbortSignals.TimerAdded);

			}

			if (runner == null)

			// modifying the job is actually quicker (lock wise) than doing a Remove / Add combo

				return false;

			lock (Jobs) {

				if (!Jobs.Contains(ID)) {

			start_event.Reset ();

					return(false);

			runner.Abort ();

				}

			runner.DueTime = dueTime;

				SetProperties(dueTime,period);

			runner.Period = period;

				log("job " + ID +" changed");

			start_event.Set ();

			}

			lock (sync_obj) {

				SendSchedulerSignal(AbortSignals.TimerChanged);

			}

			if (t != null && t.IsAlive) {

			lock (Jobs) {

				if (t != Thread.CurrentThread)

				if (Jobs.Contains(ID)) { 

					t.Abort ();

					Jobs.Remove(ID);

				t = null;

					lock (sync_obj) {

						SendSchedulerSignal(AbortSignals.TimerRemoved);

					}

					log(String.Format("Job {0} removed",ID));

				}

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), null, 200, Timeout.Infinite);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 200, Timeout.Infinite);

			AssertEquals ("t0", 0, counter);

			AssertEquals ("t0", 0, bucket.count);

			AssertEquals ("t1", 1, counter);

			AssertEquals ("t1", 1, bucket.count);

			AssertEquals ("t2", 1, counter);

			AssertEquals ("t2", 1, bucket.count);

			Thread.Sleep (500);

			Thread.Sleep (1000);

			Assert ("t3", counter > 20);

			Assert ("t3", bucket.count > 20);

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), null, 1, 1);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 1, 1);

			int c = counter;

			int c = bucket.count;

			Assert ("t2", counter <= c + 6);

			Assert ("t2", bucket.count <= c + 6);

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (Callback), null, 0, Timeout.Infinite);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 0, Timeout.Infinite);

			AssertEquals (1, counter);

			AssertEquals (1, bucket.count);

			AssertEquals (2, counter);

			AssertEquals (2, bucket.count);

		{

		{	

			counter = 0;

			Bucket bucket = new Bucket();

			Timer t = new Timer (new TimerCallback (CallbackTestDispose), null, 10, 10);

			Timer t = new Timer (new TimerCallback (Callback), bucket, 10, 10);

			int c = counter;

			int c = bucket.count;

			Assert (counter > 5);

			Assert (bucket.count > 5);

			AssertEquals (c, counter);

			AssertEquals (c, bucket.count);

			Timer t = new Timer (new TimerCallback (CallbackTestDispose), null, 10, 10);

			Timer t = new Timer (new TimerCallback (Callback), null, 10, 10);

		[Category ("NotWorking")]

		[Category("NotWorking")]

			counter = 0;

			t1 = new Timer (new TimerCallback (CallbackTestDisposeOnCallback), null, 0, 10);

			Timer t1 = null;

			t1 = new Timer (new TimerCallback (CallbackTestDisposeOnCallback), t1, 0, 10);

			AssertNull (t1);

			AssertNull(t1);

			if (++counter == 3) {

			((Timer)foo).Dispose();

				t1.Dispose ();

				t1 = null;

			}

			counter++;

			Bucket b = foo as Bucket;

			b.count++;