////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   RobinScheduler.cs
//
//  Note:
//

using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using Microsoft.Singularity;
using Microsoft.Singularity.Scheduling;

namespace Microsoft.Singularity.Scheduling
{
#if !SIMULATOR
    public class SystemScheduler
    {
        static public void RegisterScheduler()
        {
            Robin.RobinScheduler.RegisterScheduler();
        }
    }
#endif
}

namespace Microsoft.Singularity.Scheduling.Robin
{
    /// <summary>
    /// Summary description for RobinScheduler.
    /// </summary>
    public class RobinScheduler : ICpuScheduler
    {
        public static readonly TimeSpan ContextSwitch = new TimeSpan(200);
        // minimum time slice to be worth scheduling the CPU: 1 millisec
        public static readonly TimeSpan MinSlice = new TimeSpan(10 * ContextSwitch.Ticks);
        public static readonly TimeSpan AFewSlice = new TimeSpan(3 * MinSlice.Ticks);
        public static readonly TimeSpan RobinSlice = new TimeSpan(10 * TimeSpan.TicksPerMillisecond);


        static public void RegisterScheduler()
        {
            CpuResource.RegisterSystemScheduler(new RobinScheduler());
        }

        public override ISchedulerProcessor CreateSchedulerProcessor(Processor processor)
        {
            return new RobinProcessor(processor);
        }

        public override ISchedulerThread CreateSchedulerThread(Thread thread)
        {
            return new RobinThread(thread);
        }

        public override ISchedulerActivity CreateSchedulerActivity()
        {
            return new RobinActivity();
        }

        public override ISchedulerCpuReservation ReserveCpu(ISchedulerActivity activity,
                                                                    CpuResourceAmount amount,
                                                                    TimeSpan period)
        {
            return null;
        }

        public bool ReserveRecurringCpu(Activity activity,
                                        ref TimeSpan amount,
                                        ref TimeSpan period)
        {
            return true;
        }

        public override bool ShouldReschedule()
        {
            RobinThread currentThread = GetCurrentThread();
            if (Scheduler.TimerInterruptedFlag && currentThread != null) {
                //SchedulerClock.CheckInterrupt();
            }

            if (currentThread == null ||
                Scheduler.YieldFlag ||
                currentThread.EnclosingThread.IsWaiting() ||
                currentThread.EnclosingThread.IsStopped()) {

                Reschedule();
            }
            return NeedToReschedule || Scheduler.TimerInterruptedFlag;
            // || timer should have fired but didn't?
        }

        // DI -- this is somehow similar to EnableInterrupts
        public override bool NextThread(out Thread nextThread)
        {
            Debug.Assert(!Processor.InterruptsDisabled());
            bool iflag = Processor.DisableInterrupts();
            bool halted = false;
            RobinThread currentThread = GetCurrentThread();

            SchedulerClock.CheckInterrupt();
            if (ShouldReschedule()) {
                //Debug.Print("Calling RescheduleInterrupt()\n");
                halted = RescheduleInterrupt(); //TODO: RescheduleInterrupt returns true if the processor needs to be halted.
                currentThread = GetCurrentThread();
            }
            else {
                //Debug.Print("No call to RescheduleInterrupt()\n");
            }
            if (currentThread != null) {
                nextThread = currentThread.EnclosingThread;
            }
            else {
                Debug.Assert(halted);
                nextThread = null;
            }

            ((RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor).NeedToReschedule = false;
            // printf("-------------------------currentThread-Id %d\n", currentThread.Id);
            //return currentThread;
            Processor.RestoreInterrupts(iflag);
            return halted;
        }
        //public static void Yield();

#region Constants

        // Maximum Scheduling Period is 1 sec (i.e. in 100s of nanoseconds).
        static readonly TimeSpan AmountCpu = CpuResource.MaxPeriod;
        //TODO: TICKS vs. TIME_SPAN vs DATE_TIME

#endregion

#region Static data members

        static RobinActivity      CircularActivityList = null;
        /// <summary>
        /// This must ALWAYS (when lock not held) point to a current resource
        /// container in the queue.
        /// </summary>
        static internal RobinActivity NextActivity;


        //moved to be processor specific
        //static RobinActivity        RobinActivityNext = null;
        //static RobinActivity        RobinActivityCurrent = null;  // activity currently executing from

        static OneShotReservation ReservationFreePool;
        static TimeSpan     IdleTime = new TimeSpan(0);
        static bool         Idle
        {
            get { return GetCurrentProcessor().Idle; }
        }

        //moved to be processor specific
        //static RobinThread       CurrentThreadGlobal = null;
        //static TimeSpan       RobinSliceLeft = RobinScheduler.RobinSlice; //new TimeSpan(0);  // the round robin list, if any, and its CPU slice
        //public static DateTime        SchedulingTime = new DateTime(0);
        //static bool           NeedToReschedule = false;

        public static TimeSpan      LA_Time = RobinScheduler.MinSlice;

        public static DateTime SchedulingTime
        {
            get {
                return ((RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor).SchedulingTime;
            }
        }

        public static bool NeedToReschedule
        {
            get {
                return ((RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor).NeedToReschedule;
            }
        }

#endregion

        public RobinScheduler()
        {
        }

        public override void Initialize()
        {
            RobinScheduler.InitializeScheduler();
        }

        public static void InitializeScheduler()
        { //TODO: Should all the null's be added in here?
            for (int i=0; i<Processor.processorTable.Length; i++) {
                ((RobinProcessor)Processor.processorTable[i].SchedulerProcessor).SchedulingTime = SystemClock.GetKernelTime();
            }
//
//            TimeSpan currentSliceLeft = RobinSliceLeft;
            bool iflag = Processor.DisableInterrupts();
            SchedulerClock.SetNextInterrupt(SchedulingTime+RobinScheduler.RobinSlice);
            Processor.RestoreInterrupts(iflag);
        }

#region ISystemScheduler Members

        public override void BeginDelayedConstraint(Hashtable resourceEstimates, TimeSpan relativeDeadline, ISchedulerTask taskToEnd, out ISchedulerTask schedulerTask)
        {
            TimeConstraint timeConstraint = new TimeConstraint();
            timeConstraint.Estimate = CpuResource.Provider().CpuToTime((CpuResourceAmount)resourceEstimates[CpuResource.Provider().ResourceString]);
            timeConstraint.Start = new DateTime(0); //Start now.
            timeConstraint.RelativeDeadline = relativeDeadline;
            timeConstraint.Deadline = new DateTime(0); //A 0-deadline means relative instead.
            schedulerTask = Thread.CurrentThread.SchedulerThread.PrepareDelayedTask(taskToEnd, ref timeConstraint, SystemClock.GetKernelTime());
        }

        public override bool BeginConstraint(Hashtable resourceEstimates, DateTime deadline, ISchedulerTask taskToEnd, out ISchedulerTask schedulerTask)
        {
            DateTime    timeNow = SystemClock.GetKernelTime();
            RobinThread        thread = GetCurrentThread();
            ulong    start, stop; // S97
            Debug.Assert(!Processor.InterruptsDisabled());

            thread.IpcCheckFreeConstraint();

            start = Processor.CycleCount;

            Debug.Assert(taskToEnd == null || taskToEnd == thread.ReservationStack);
            bool end_previous = (taskToEnd != null);
            TimeConstraint constraint = new TimeConstraint();
            constraint.Deadline = deadline;
            constraint.Estimate = CpuResource.Provider().CpuToTime((CpuResourceAmount)resourceEstimates[CpuResource.Provider().ResourceString]);
            constraint.Start = timeNow;

            bool ok = thread.BeginConstraintBeforeWaitValidate(end_previous, ref constraint, timeNow);
            schedulerTask = thread.PendingReservation;
            if (ok) {
                OneShotReservation.BeginConstraintBeforeWait(thread, end_previous, constraint, timeNow);
                bool iflag = Processor.DisableInterrupts();
                ok = OneShotReservation.ResolveConstraint(thread);
                Processor.RestoreInterrupts(iflag);
            }
            stop = Processor.CycleCount;

            Scheduler.LogBeginConstraint(thread.EnclosingThread, ok, start, stop);

            //TODO: Check if this is a necessity, or if it's only for sim time.  Call in wrapper if necessary.
            //NextThread();
            return ok;
        }

        public override bool EndConstraint(ISchedulerTask taskToEnd)
        {
            Debug.Assert(!Processor.InterruptsDisabled());
            Debug.Assert(taskToEnd == GetCurrentThread().ReservationStack);
            bool iflag = Processor.DisableInterrupts();
            bool ok = OneShotReservation.EndPreviousConstraint(GetCurrentThread(), SystemClock.GetKernelTime());
            //
            // need to reschedule only if on a reserved slot and the top of EarliestDeadlineFirst doesn't
            //  belong to this task
            //
            if ((OneShotReservation.CurrentReservation != null) &&
                (OneShotReservation.GuaranteedReservations != null) &&
                (OneShotReservation.GuaranteedReservations.ReservTask != (GetCurrentThread()))) {
                Reschedule();
            }

            Processor.RestoreInterrupts(iflag);
            Scheduler.LogEndConstraint();

            //TODO: In the system wrapper for BeginConstraint -- it needs to call Yield/NextThread/MaybeYield
            //NextThread();
            return ok;
        }

        public static bool ReserveRecurringCpu(RobinActivity activity, ref TimeSpan amount, ref TimeSpan period)
        {
            return true;
        }

#endregion


#region OneShotCpuReservation related functions
        // OneShotCpuReservation related functions begin:

        public static int ReleaseReservationProtected(OneShotReservation reservation)
        {
            Debug.Assert(Processor.InterruptsDisabled());
            Debug.Assert(reservation.ReferenceCount > 0);

            int newrefcnt = Interlocked.Decrement(ref reservation.ReferenceCount);

            if (newrefcnt == 0) {
                // Estimate may be positive when reservation reaches
                // its Deadline w/o using its Estimate
                Debug.Assert((reservation.Next == null) && (reservation.Previous == null));
                if (reservation.OriginalThread != null) {
                    reservation.OriginalThread.ReleaseProtected();
                    //Debug.Assert(reservation.ActiveThread != null);
                    //reservation.ActiveThread.ReleaseProtected();
                }
                else {
                    Debug.Assert(reservation.AssociatedActivity != null);
                    ActivityReleaseProtected(reservation.AssociatedActivity);
                }
                Debug.Assert(reservation.Next == null);
                CacheFreeReservation(reservation);
            }
            return newrefcnt;
        }


        public static OneShotReservation AllocateReservation()
        {
            OneShotReservation reservation;

            //  DisableInterrupts();
            reservation = IpcAllocateReservation();
            //  EnableInterrupts();

            if (reservation == null) {
                reservation = new OneShotReservation(); //(PRESERVATION)malloc(sizeof(struct OneShotReservation)); // to be done while on the I-stack!
                reservation.Clear();
            }
            return reservation;
        }

        static void FreeReservation(OneShotReservation reservation)
        {
            reservation = null; //free(reservation);
        }

        // Garbage-collect unused Reservations.
        public static int ReleaseReservation(OneShotReservation reservation)
        {
            // Debug.Assert(!Processor.InterruptsDisabled());
            Debug.Assert(reservation.ReferenceCount > 0);
            int newrefcnt = reservation.ReferenceCount - 1;
            reservation.ReferenceCount = newrefcnt;

            if (newrefcnt == 0) {
                // Estimate may be positive when reservation reaches its Deadline w/o using its Estimate
                Debug.Assert((reservation.Next == null) && (reservation.Previous == null));
                if (reservation.OriginalThread != null) {
                    reservation.OriginalThread.Release();
                    //Debug.Assert(reservation.ActiveThread != null);
                    //reservation.ActiveThread.Release();
                }
                else if (reservation.AssociatedActivity != null) {
                    ActivityObjRelease(reservation.AssociatedActivity);
                }
                CacheFreeReservation(reservation);
            }
            return newrefcnt;
        }

        // Like CheckFreeConstraint, but callable from the IPC path.
        // Because we can't call AllocateReservation, we use the helper thread
        // if there aren't any free Reservations.
        static void CacheFreeReservation(OneShotReservation reservation)
        {
            if (reservation.OriginalThread != null  &&
                reservation.OriginalThread.FreeReservation == null) {
                reservation.OriginalThread.FreeReservation = reservation;
            }
            else {
                IpcFreeReservation(reservation);
            }
        }


        // Callable with preemption disabled. Allocates a OneShotReservation
        // from the global free list.
        public static OneShotReservation IpcAllocateReservation()
        {
            OneShotReservation reservation;

            if ((reservation = ReservationFreePool) != null) {
                ReservationFreePool = reservation.FreeListNext;
            }

            return reservation;
        }

        // Callable with preemption disabled. Frees a OneShotReservation
        // to the global free list.
        public static void IpcFreeReservation(OneShotReservation reservation)
        {
            Debug.Assert(reservation != null);
            Debug.Assert(reservation.ReferenceCount == 0);

            reservation.FreeListNext = ReservationFreePool;
            ReservationFreePool = reservation;
        }

        //////////////////////////////////////////////////////////////////////

        public static void AddRefReservation(OneShotReservation reservation)
        {
            Debug.Assert(reservation.ReferenceCount >= 0);
            reservation.ReferenceCount++;
        }

#endregion

#region Potpourri (Unregioned functions)

        public static RobinThread GetCurrentThread()
        {
            return ((RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor).RunningThread;
        }

        public static void IChangeCurrentThread(RobinThread thread)
        {
            ((RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor).RunningThread = thread;
        }

        // Auxiliary Routines
        // TODO: Revisit the necessity of these functions.
        public static TimeSpan minInterval(TimeSpan TimeInterv0, TimeSpan TimeInterv1)
        {
            return (TimeInterv0 < TimeInterv1? TimeInterv0: TimeInterv1);
        }

        public static DateTime minTime(DateTime Time0, DateTime Time1)
        {
            return (Time0 < Time1? Time0: Time1);
        }

        static TimeSpan maxInterval(TimeSpan TimeInterv0, TimeSpan TimeInterv1)
        {
            return (TimeInterv0 < TimeInterv1? TimeInterv1: TimeInterv0);
        }

        static DateTime maxTime(DateTime Time0, DateTime Time1)
        {
            return (Time0 < Time1? Time1: Time0);
        }

        internal static RobinProcessor GetCurrentProcessor()
        {
            return (RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor;
        }

        // Add Activity in the last Round-Robin position
        public static void EnqueueActivity(RobinActivity activity)
        {
            Debug.Assert(Processor.InterruptsDisabled());
            if (CircularActivityList == null) {
                NextActivity = CircularActivityList /*= GetCurrentProcessor().CurrentActivity */=
                    activity.Next = activity.Previous = activity;
                //Here modifying other processor specific data rather than global.
//                for (int i=0; i<Processor.processorTable.Length; i++) {
//                    ((RobinProcessor)Processor.processorTable[i].SchedulerProcessor).NextActivity = activity;
//                    ((RobinProcessor)Processor.processorTable[i].SchedulerProcessor).Reschedule();
//                }
                SchedulerClock.SignalOtherProcessors();
            }
            else {
                activity.Next = NextActivity;
                activity.Previous = NextActivity.Previous;
                NextActivity.Previous.Next = activity;
                NextActivity.Previous = activity;
            }
        }

        public static void DequeueActivity(RobinActivity activity) //TODO: Make an activity function?
        {
            // In our simulated environment, Activity 0 is never removed from the Q.
            Debug.Assert(Processor.InterruptsDisabled());
            //NOTE: Might be replaced with a test and return.
            Debug.Assert(activity.Next != null);
            Debug.Assert(activity.Previous != null);

            // Previous. in RoundRobin  if (activity.Id == 0) return;

            activity.Next.Previous = activity.Previous;
            activity.Previous.Next = activity.Next;
            if (CircularActivityList == activity) {
                CircularActivityList = activity.Next;
            }
            if (NextActivity == activity) {
                NextActivity = activity.Next;
            }
//            for (int i=0; i<Processor.processorTable.Length; i++) {
//                RobinProcessor processor = (RobinProcessor)Processor.processorTable[i].SchedulerProcessor;
//                if (processor.NextActivity == activity) {
//                    processor.NextActivity = activity.Next;
//                }
//            }
        }

        // if possible, places thread in the 2nd position in the RunnableThreads Q.
        // Make this a function on a resource container.
        public static void EnqueueRunThread(RobinThread thread, bool fromSleeping)
        {
            Debug.Assert(Processor.InterruptsDisabled());
            RobinActivity activity = thread.AssociatedActivity;
            if (thread.Next != null) {
                Debug.Assert(thread.Previous != null);
                return;
            }

            //  Debug.Assert(thread.QueueType == QUEUE_NONE);

            //if (thread.State == RobinThread.ThreadState.ThreadWaiting)
            //    thread.SetState(RobinThread.ThreadState.ThreadReady);

            if (activity.RunnableThreads == null) {
                thread.Next = thread.Previous = thread;
                activity.RunnableThreads = thread;
            }
            else {
                if (fromSleeping) {
                    thread.Previous = activity.RunnableThreads;
                    thread.Next = activity.RunnableThreads.Next;
                    activity.RunnableThreads.Next.Previous = thread;
                    activity.RunnableThreads.Next = thread;
                }
                else {
                    //If we weren't sleeping/waiting, then we were running --
                    // then put thread at end of list, not 2nd.
                    thread.Next = activity.RunnableThreads;
                    thread.Previous = activity.RunnableThreads.Previous;
                    activity.RunnableThreads.Previous.Next = thread;
                    activity.RunnableThreads.Previous = thread;
                }
            }

            //Editing other processor data again.  Here we actually tell all
            //processors they need to reschedule, since there is a new thread to
            //consider.  (perhaps wrong).
            //NOTE: SignalOtherProcessors only alerts those who are halted at the
            //moment.
            for (int i=0; i<Processor.processorTable.Length; i++) {
                ((RobinProcessor)Processor.processorTable[i].SchedulerProcessor).Reschedule();
            }
            SchedulerClock.SignalOtherProcessors();
        }

        public static bool DequeueRunThread(RobinThread thread)
        {
            Debug.Assert(Processor.InterruptsDisabled());
            if (thread.Next == null) {
                Debug.Assert(thread.Previous == null);
                return false;
            }

            if (thread.Next == thread) {
                Debug.Assert(thread.Previous == thread);
                thread.AssociatedActivity.RunnableThreads = null;
            }
            else {
                // multiple threads in the RunnableThreads Q
                thread.Previous.Next = thread.Next;
                thread.Next.Previous = thread.Previous;
                if (thread.AssociatedActivity.RunnableThreads == thread)
                    thread.AssociatedActivity.RunnableThreads = thread.Next;
            }
            thread.Next = thread.Previous = null;
            return true;
        }
#endregion

#region Additions according to kernel implementation

        static bool ResetTimerTimeout(DateTime NewTimerTimeout)
        {
            DateTime timeNow = SchedulingTime;

            if (timeNow > NewTimerTimeout) {
                return false;
            }

            Debug.Assert(Processor.InterruptsDisabled());
            // Debug.Assert(CurrentThread().GetState() == Thread.ThreadState.ThreadRunning);

            Debug.Assert(NewTimerTimeout > SchedulingTime);
            // Debug.Assert(SleepTimeout > SchedulingTime);

            //TODO: Need LA_Time?
            //            if (NewTimerTimeout > SleepTimeout - LA_Time)
            //                NewTimerTimeout = SleepTimeout - LA_Time;
            if (NewTimerTimeout > RobinThread.GetSleepTimeout()) {
                NewTimerTimeout = RobinThread.GetSleepTimeout();
            }

            //DebugStub.Print("Setting Next Interrupt for: {0}...\n",
            //__arglist(NewTimerTimeout.Ticks);
            bool success = SchedulerClock.SetNextInterrupt(NewTimerTimeout); //TODO: Perhaps only call this if the time changed.

            //DebugStub.Print(success ? "SUCCESS\n" : "FAILED\n");

            return success;
        }

        public static  void UpdateSchedulingStatus()
        {
            TimeSpan timeRun;
            RobinThread currentThread = GetCurrentThread();

            DateTime newSchedulingTime = SystemClock.GetKernelTime();

            timeRun = newSchedulingTime - SchedulingTime;
            RobinProcessor processor = (RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor;
            processor.SchedulingTime = newSchedulingTime;

            if (Idle) {
                // UpdateIdleTime
                IdleTime += timeRun;
                return;
            }

            // if IDLE compute CurrentPlanNode & set currentThread to null.
            if (currentThread != null) {
                // unless thread just exited.
                // Update Thread & Activity execution times.
                currentThread.AddExecutionTime(timeRun);
                Scheduler.CurrentTask().AddResourceAmountUsed(CpuResource.Provider().ResourceString, CpuResource.Provider().TimeToCpu(timeRun));
//                if (currentThread.AssociatedActivity != null) {
//                    currentThread.AssociatedActivity.MyRecurringCpuReservation.EnclosingCpuReservation.AddTimeUsed(timeRun);
//                }
            }

            if (OneShotReservation.CurrentReservation != null) {
                // Slice used for a reservation.
                OneShotReservation.CurrentReservation.Estimate -= timeRun;
            }
            else if (processor.CurrentActivity != null) {
                // Slice used for RoundRobin.
                processor.SliceLeft -= timeRun;
                processor.CurrentActivity = null;
            }
        }

        internal static void CheckInvariants()
        {
            if (CircularActivityList != null) {
                bool listNextFound = (CircularActivityList == NextActivity);
                RobinActivity start = CircularActivityList, current = CircularActivityList.Next, previous = CircularActivityList;
                while (current != start) {
                    //perhaps check thread invariants here too.
                    Debug.Assert(current != null, "resource container list is not circular");
                    Debug.Assert(current.Previous == previous, "back pointer doesn't match forward pointer");
                    if (current == NextActivity) {
                        listNextFound = true;
                    }
                    previous = current;
                    current = current.Next;
                }
                Debug.Assert(listNextFound, "NextActivity isn't in the loop!");
                Debug.Assert(current.Previous == previous, "Head doesn't point to tail");
            }
        }

        // Always called when another thread needs to be scheduled.
        static bool RescheduleInterrupt()
        {
            CheckInvariants();
            Debug.Assert(Processor.InterruptsDisabled());
            Debug.Assert(!Processor.InterruptsDisabled());
            RobinThread currentThread = GetCurrentThread();
            Debug.Assert(currentThread == null || currentThread.ActiveProcessor == GetCurrentProcessor());
            if (currentThread != null) {
                currentThread.ActiveProcessor = null;
            }

            DateTime nextStart;
            RobinThread previousThread;

          RescheduleAgain: // !!!!!!!!!! SIM ONLY !!!!!!!!!
            if (Idle) {
                currentThread = null;
            }

            previousThread = currentThread;

            UpdateSchedulingStatus();

            //  if thread was the head of the runnable threads Q:
            //  Advance the runnable threads Q.
            if ((currentThread != null) &&
                (currentThread.AssociatedActivity != null) &&
                (currentThread.AssociatedActivity.RunnableThreads == currentThread)) {

                currentThread.AssociatedActivity.RunnableThreads = currentThread.Next;
                Debug.Assert(currentThread.AssociatedActivity.RunnableThreads != null);
            }

            OneShotReservation.UpdateCurrentReservation();
            OneShotReservation.ClearCurrentReservation();
            currentThread = null;

            // Finished first stage, i.e. updated state.
            // Start second stage: wakeup threads & select Next CPU slice.

            RobinThread.WakeThreads();

            // NOTE: In the original RoundRobin Simulator Code (& MMOSA code)
            // The call to DrainDeferredConditions() was made here.
            // In Singularity, this will basically be replaced with a
            // queue of wait-events to fix.

            OneShotReservation.FreshenReservationQueues();

            TimeSpan currentNodeSliceLeft;
            RobinProcessor currentProcessor = (RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor;
            if (currentProcessor.CurrentActivity != null && currentProcessor.SliceLeft >= RobinScheduler.MinSlice) {
                currentThread = currentProcessor.CurrentActivity.GetRunnableThread();
                if (currentThread != null) {
                    goto exit;
                }
            }

            // Find Next Runnable Activity.
            currentProcessor.SliceLeft = RobinScheduler.RobinSlice;
            currentProcessor.CurrentActivity = NextActivity; // !!!!!!!!!!!!!SIM ONLY !!!!!!!!!!
            while ((currentThread = NextActivity.GetRunnableThread()) == null) {
                NextActivity = NextActivity.Next;
                //currentProcessor.SliceLeft = RobinScheduler.RobinSlice;
                if (NextActivity == currentProcessor.CurrentActivity) {
                    // !!!!!!!!SIM ONLY !!!!!!!
                    // in the real scheduler, execute halt
                    if (OneShotReservation.IdleReservations != null) {
                        // reuse nextStart
                        nextStart = minTime(RobinThread.GetSleepTimeout(), OneShotReservation.IdleReservations.Start);
                    }
                    else {
                        nextStart = RobinThread.GetSleepTimeout();
                        DebugStub.Print("Idle, sleeping until {0} cf maxvalue {1}\n",
                                        __arglist(nextStart.Ticks,
                                                  DateTime.MaxValue.Ticks));
                    }

                    if (nextStart == DateTime.MaxValue) {
                        Scheduler.StopSystem();
                    }

                    if (! ResetTimerTimeout(nextStart)) {
                        //Error setting timer.  Try scheduling again.
                        DebugStub.Print("Thought Idle, failed to set interrupt.\n");
                        goto RescheduleAgain;
                    }
                    GetCurrentProcessor().Idle = true;

                    // !!!!!!!!SIM ONLY !!!!!!!
                    currentThread = null;           // !!!!!!!!SIM ONLY !!!!!!!
                    OneShotReservation.ClearCurrentReservation();
                    currentProcessor.CurrentActivity = null;

                    if (DateTime.MaxValue != nextStart) {
                        //Scheduler.LogTimeJump();
                    }

                    //DebugStub.Print("Halted.\n");
                    IChangeCurrentThread(null);
                    return true;            // !!!!!!!!SIM ONLY !!!!!!!
                }
                // !!!!!!!!SIM ONLY !!!!!!!
            }
            //DebugStub.Print("Running Round Robin Resource Container\n");
            currentProcessor.CurrentActivity = NextActivity; // we probably need only one of the two variables
            NextActivity = NextActivity.Next;

          exit:
            currentNodeSliceLeft = currentProcessor.SliceLeft;

            Debug.Assert(currentThread != null);
            if (currentThread != previousThread) {
                Scheduler.LogContextSwitch(); // Context Switch statistics
            }

            if (OneShotReservation.IdleReservations != null) {
                // reuse nextStart
                nextStart = minTime(RobinThread.GetSleepTimeout(), OneShotReservation.IdleReservations.Start);
            }
            else {
                nextStart = RobinThread.GetSleepTimeout();
            }

            if (SchedulingTime + currentNodeSliceLeft /* CurrentSlice */ > nextStart) {
                currentNodeSliceLeft /* CurrentSlice */ = nextStart - currentProcessor.SchedulingTime;
            }


            Scheduler.LogReschedule();
            if (!ResetTimerTimeout(currentProcessor.SchedulingTime + currentNodeSliceLeft) || Scheduler.TimerInterruptedFlag) {
                //TODO: What do we REALLY want here?
                currentThread = null;           // !!!!!!!!SIM ONLY !!!!!!!
                OneShotReservation.ClearCurrentReservation();
                currentProcessor.CurrentActivity = null;
                goto RescheduleAgain;
            }

            Debug.Assert(currentThread.ActiveProcessor == null);
            currentThread.ActiveProcessor = GetCurrentProcessor();
            Debug.Assert(currentThread.ActiveProcessor != null);

            if (currentThread != previousThread) {
                IChangeCurrentThread(currentThread);
            }
            GetCurrentProcessor().Idle = false;

            // Not necessarily true:  Debug.Assert(!Scheduler.TimerInterruptedFlag);
            CheckInvariants();
            return false;
        }

#endregion

        public static void Reschedule()
        {
            ((RobinProcessor)Processor.CurrentProcessor.SchedulerProcessor).Reschedule();
        }

        public static void ActivityObjAddRef(RobinActivity activity)
        {
            activity.ReferenceCount++;
        }


        public static void ActivityObjRelease(RobinActivity activity)
        {
            Debug.Assert(activity.ReferenceCount >= 1);
            activity.ReleaseReference();
        }

        public static void ActivityReleaseProtected(RobinActivity activity)
        {
            Debug.Assert(activity.ReferenceCount >= 1);
            Debug.Assert(Processor.InterruptsDisabled(), "Interrupts Not Disabled!");
            activity.ReleaseReference();
        }
    }
}