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

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

namespace Microsoft.Singularity.Scheduling.Rialto
{
    /// <summary>
    /// OneShotReservations are created from tasks for the calling thread.
    /// It has fields to track the thread calling and the thread waiting on,
    /// the activity associated when it becomes an activity reservation, its
    /// surrounding reservation, its place on the free reservation list,
    /// general bookkeeping, bookkeeping for possible stolen time, and
    /// references for the general reservation list.
    /// </summary>
    public class OneShotReservation : ISchedulerTask
    {

        static OneShotReservation  guaranteedReservations = null;
        public static OneShotReservation GuaranteedReservations
        {
            get { return guaranteedReservations; }
        }

        static OneShotReservation  idleReservations = null;
        public static OneShotReservation IdleReservations
        {
            get { return idleReservations; }
        }

        static OneShotReservation  currentReservation = null;
        public static OneShotReservation CurrentReservation
        {
            get { return currentReservation; }
            //set { currentReservation = value; }
        }

        public Hashtable resourcesGranted = new Hashtable();
        public override Hashtable ResourcesGranted
        {
            get {
                resourcesGranted[CpuResource.Provider().ResourceString] = CpuResource.Provider().TimeToCpu(InitialEstimate);
                return resourcesGranted;
            }
        }

        private Task enclosingTask;
        public override Task EnclosingTask
        {
            get { return enclosingTask; }
            set { enclosingTask = value; }
        }

        public OneShotReservation      SurroundingReservation;
        public OneShotReservation      FreeListNext;
        public RialtoThread             ReservTask;

        TimeSpan     constraintExecution;
        public TimeSpan ConstraintExecution
        {
            get { return constraintExecution; }
        }

        TimeSpan     initialThreadExecution;

        public DateTime     Start, Deadline;
        public TimeSpan        Estimate, RelativeDeadline;

        public TimeSpan     InitialEstimate; // test only
        public QueueType    MyQueueType;
        public bool         Guaranteed;
        public bool         Valid;
        public bool         Satisfied;

        // Reservations can be made for Threads XOR Activities!.
        public RialtoThread         OriginalThread;
        // always the constraint thread -- non-null until the reservation is complete
        //public RialtoThread           ActiveThread;
        // the above, or the thread blocking it
        //public int                ActiveThreadEpoch;
        public RialtoActivity      AssociatedActivity;        // the two fields above must be null!


        public OneShotReservation      Next;
        public OneShotReservation      Previous;

        public TimeSpan     InheritedEstimate;  // Stolen => Inherited, no longer critical
        public int          ResolutionEpoch;    // Stolen => Resolution, since not stealing.

        public int              ReferenceCount;

        public OneShotReservation()
        {
        }

        public void Clear()
        {
            //ActiveThread = null;
            //ActiveThreadEpoch = 0;
            constraintExecution = new TimeSpan(0); //Move to enclosing class
            initialThreadExecution = new TimeSpan(0); //Move to enclosing class
            Deadline = new DateTime(0);
            RelativeDeadline = new TimeSpan(0);
            Estimate = new TimeSpan(0);
            FreeListNext = null;
            Guaranteed = false;
            InitialEstimate = new TimeSpan(0);
            Next = null;
            OriginalThread = null;
            AssociatedActivity = null;
            Previous = null;
            MyQueueType = QueueType.NoQueue;
            ReferenceCount = 0;
            ReservTask = null;
            Satisfied = false;
            Start = new DateTime(0);
            SurroundingReservation = null;
            ResolutionEpoch = 0;
            InheritedEstimate = new TimeSpan(0);
            Valid = false;
            if (enclosingTask != null) {
                enclosingTask.ClearSchedulerTask();
                enclosingTask = null;
            }
        }

        // find the runnable thread of a reservation:
        public RialtoThread GetRunnableThread()
        {
//            RialtoThread thread;
//
            if (AssociatedActivity != null) {
                // if an activity reservation
                return AssociatedActivity.GetRunnableThread();
            }

            Debug.Assert(OriginalThread != null);

//            if ((ActiveThread == OriginalThread) &&
//                (ActiveThread.EnclosingThread.ThreadState == System.Threading.ThreadState.Running))
//                return ActiveThread;
//
//            thread = OriginalThread; // search for active thread starting w/ original thread
//
//            if ((ActiveThread != null) &&
//                (ActiveThread.Epoch == ActiveThreadEpoch)) {
//                if (ActiveThread.EnclosingThread.ThreadState == System.Threading.ThreadState.Running) {
//#if DEBUG_MUTEX
//                  DebugStub.WriteLine("Mutex inheritance (Epoch ok): Orig {0} Active {1} GO ON",
//                      thread.Id, ActiveThread.Id);
//#endif
//                    return ActiveThread;
//                }
//            }
            //CKillian -- can't do this because of the array of blockedOn.
            //    else if (ActiveThread.EnclosingThread.IsSleeping()) {
            //        // more efficient: search for active thread starting w/ current active thread
            //        thread = ActiveThread;
            //    }
            //    else {
            //        Debug.Assert(false);
            //    }
            //}

            Thread temp = /*Active*/OriginalThread.EnclosingThread.GetRunnableBeneficiary();
            if (temp == null) {
                return null;
            }
            else {
                return (RialtoThread)temp.SchedulerThread;
            }

        }

        public void StopThreadExecution(RialtoThread thread)
        {
            Debug.Assert(thread.ExecutionTime >= initialThreadExecution);
            constraintExecution += thread.ExecutionTime - initialThreadExecution;
            //Between two reservations which are atomically stopped/started, some
            //      time is charged against the default parent resource container.  This
            //      is because I changed the way we account for tasks to do the general
            //      rule we wanted.  In particular, I update the scheduling status just
            //      before resolving a new reservation.  Not sure what the right fix is,
            //      so I'm leaving it.  The assertion below will reveal the "error."  The
            //      old code to track CPU usage is still active under constraintExecution,
            //      but isn't presently exposed to the applications.  Currently UpdateSchedulingStatus()
            //      updates the CPU resources used for the whole task stack.
            //Debug.Assert(CpuResource.Provider().TimeToCpu(constraintExecution).Cycles == ((CpuResourceAmount)enclosingTask.resourcesUsed[CpuResource.Provider().ResourceString]).Cycles);
            //EnclosingTask.AddResourceAmountUsed(CpuResource.Provider().ResourceString, CpuResource.Provider().TimeToCpu(constraintExecution));
        }

        public void StartThreadExecution(RialtoThread thread)
        {
            initialThreadExecution = thread.ExecutionTime;
        }

        public void StartThreadExecution(RialtoThread thread, TimeSpan delta)
        {
            initialThreadExecution = thread.ExecutionTime + delta;
        }

        public static void BeginConstraintBeforeWait(RialtoThread thread,
                                                            bool endPrevious,
                                                            TimeConstraint timeConstraint,
                                                            DateTime timeNow)
        {
            OneShotReservation reservation;

            Debug.Assert(thread == RialtoScheduler.GetCurrentThread());
            Debug.Assert(!Processor.InterruptsDisabled());
            if (endPrevious) {
                bool iflag = Processor.DisableInterrupts();
                EndPreviousConstraint(thread, timeNow);
                Processor.RestoreInterrupts(iflag);
            }

            RialtoScheduler.UpdateSchedulingStatus();

            reservation = thread.PendingReservation;

            reservation.StartThreadExecution(thread, (timeNow - RialtoScheduler.SchedulingTime));
            reservation.constraintExecution = new TimeSpan(0);
            reservation.Start = timeConstraint.Start;
            reservation.Deadline = timeConstraint.Deadline;
            reservation.RelativeDeadline = timeConstraint.RelativeDeadline;
            reservation.Estimate = timeConstraint.Estimate;
            reservation.Valid = reservation.Guaranteed = true;
            reservation.MyQueueType = QueueType.NoQueue;
            reservation.ReservTask = thread;
            reservation.OriginalThread = /*reservation.ActiveThread =*/ thread;
            thread.AddRef();
            //thread.AddRef();
            //reservation.ActiveThreadEpoch = thread.Epoch;
            reservation.AssociatedActivity = null;
            reservation.Next = reservation.Previous = null;
        }

        // DI -- this is a new function used in both Begin and EndConstraint
        public static bool EndPreviousConstraint(RialtoThread thread, DateTime timeNow)
        {
            OneShotReservation reservation;
            OneShotReservation reservationNext;
            bool            success;
            QueueType       tempQueue; //Value assigned but never used.

            Debug.Assert(Processor.InterruptsDisabled());

            reservation = thread.ReservationStack;

            success = (timeNow <= reservation.Deadline);
            RialtoScheduler.UpdateSchedulingStatus();
            reservation.StopThreadExecution(thread);

            Debug.Assert(reservation.ConstraintExecution.Ticks >= 0);
//            if (timeTaken.Ticks != 0) {
//                timeTaken = reservation.ConstraintExecution;
//                Debug.Assert(timeTaken.Ticks >= 0); //CK: Added = because VPC returns 0 sometimes.
//            }

            thread.ReservationStack = reservation.SurroundingReservation;
            reservation.SurroundingReservation = null;

            if (currentReservation == reservation) {
                // note that it might be the case that
                // a reservation for the task id exist on the guaranteed Q but the
                // the actual (executed) constraint is in the UnfinishedQ
                currentReservation = null; // ????????????
                RialtoScheduler.Reschedule();
            }
            Debug.Assert(reservation.OriginalThread == thread);
            Debug.Assert(reservation.Start <= timeNow);

            if (thread.ReservationStack == null) {
                if (reservation.Estimate >= RialtoScheduler.MinSlice) {
                    // the constraint used less than estimated:
                    Debug.Assert(reservation.MyQueueType == QueueType.GuaranteedQueue);
                    //Debug.Assert((reservation.ActiveThread == null) ||
                    //  (reservation.ActiveThread.Epoch != reservation.ActiveThreadEpoch) ||
                    //  (reservation.ActiveThread == reservation.OriginalThread));
                    //  reservation.ActiveThread.ReleaseProtected();
                    reservation.OriginalThread.ReleaseProtected();
                    reservation.AssociatedActivity = reservation.OriginalThread.AssociatedActivity; // and make it an activity reserv
                    reservation.OriginalThread = null;
                    //reservation.ActiveThread = null;
                    reservation.ReservTask = null;
                    RialtoScheduler.ActivityObjAddRef(reservation.AssociatedActivity);
                    // leave it on whatever Q it happens to be on
                }
                else {
                    reservation.DequeueReservation(); // from whatever Q it happens to be on
                }
            }
            else {
                tempQueue = reservation.MyQueueType;
                reservationNext = thread.ReservationStack;
                reservationNext.Estimate += reservation.Estimate;
                reservationNext.constraintExecution += reservation.constraintExecution;
                reservationNext.StartThreadExecution(thread);
                Debug.Assert(((reservation.MyQueueType == QueueType.GuaranteedQueue) &&
                    (reservationNext.MyQueueType == QueueType.NoQueue)) ||
                    ((reservation.MyQueueType == QueueType.UnfinishedQueue) &&
                    ((reservationNext.Estimate.Ticks <= 0) || (reservationNext.MyQueueType != QueueType.UnfinishedQueue))));
                reservation.Estimate = new TimeSpan(0);
                Debug.Assert(reservation.Next != null);
                reservation.DequeueReservation();
                ReplaceOnEarliestDeadlineFirst(reservationNext, timeNow);

            }
            // fprintf(stdout,"EndPrevConstr 0x%x %d\n", reservation, reservation.ReferenceCount);
            reservation.ReleaseReservationProtected();

            Scheduler.LogEndConstraint();

            if (success == false) {
                Scheduler.LogSchedulerLate();
            }

            // DebugStub.WriteLine("EndPreviousConstraint() {0} constraintExecution: {1}", success?"SUCCESS":"FAILURE", reservation.constraintExecution.Ticks);

            return success;
        }


        public static bool ResolveConstraint(RialtoThread thread)
        {
            TimeSpan timeLeft, ownNodesTimeToSteal = new TimeSpan(1);
            DateTime start, deadline;
            TimeSpan timeInherited;
            OneShotReservation pendingReservation = thread.PendingReservation;
            OneShotReservation reservationPrevious;
            DateTime timeNow = SystemClock.GetKernelTime();
            bool ok = false;

            Debug.Assert(Processor.InterruptsDisabled());
            Debug.Assert(pendingReservation != null);

            Scheduler.LogResolveConstraint();

            thread.PendingReservation = null;   // just clean the place

            Debug.Assert(pendingReservation.Start.Ticks >= 0);
            start = pendingReservation.Start;
            if (start < timeNow) {
                start = timeNow;
            }
            Debug.Assert(pendingReservation.Deadline.Ticks >= 0);
            deadline = pendingReservation.Deadline;
            if (deadline.Ticks == 0) {
                deadline = timeNow + pendingReservation.RelativeDeadline;
            }

            if (thread.ReservationStack != null) {
                OneShotReservation reservation = thread.ReservationStack;
                while (!reservation.Valid && ((reservation = reservation.SurroundingReservation)!= null)) {
                    // no body.
                }

                if (reservation!= null) {
                    deadline = RialtoScheduler.minTime(deadline, reservation.Deadline);
                }
            }

            // update data ure
            pendingReservation.Start = start;
            pendingReservation.Deadline = deadline;
            //TODO: Should be for SIM ONLY!
            Scheduler.LogReservationId(pendingReservation);           // SIM only
            if (start + pendingReservation.Estimate > deadline) {
                // DebugStub.WriteLine("RialtoScheduler::ResolveConstraint FAIL - start({0}) + pendingReservation.Estimate({1}) > deadline({2})", start.Ticks, pendingReservation.Estimate.Ticks, deadline.Ticks);
                ok = false;
                goto Failure;
            }
            timeInherited = new TimeSpan(0);
            RialtoScheduler.ResolutionAttempt++;    // mark a new resolution epoch

            RecurringReservation recurringReservation = thread.AssociatedActivity.MyRecurringCpuReservation;
            RialtoScheduler.ReserveSlices(start, deadline, pendingReservation.Estimate,
                thread, out timeLeft, ref timeInherited,
                pendingReservation, (recurringReservation != null?recurringReservation.AssignedNodes:null), timeNow);

            if (timeLeft.Ticks == 0) {
                // Success:
                goto Success;
            }

            RialtoScheduler.ReserveSlices(start, deadline, timeLeft,
                thread, out timeLeft, ref timeInherited,
                pendingReservation, RialtoScheduler.FreeNodes, timeNow);
            if (timeLeft.Ticks <= 0) {
                // Success:
                goto Success;
            }
            // DebugStub.WriteLine("RialtoScheduler::ResolveConstraint FAIL - couldn't find time in schedule");
          Failure:
            // Failure:
            pendingReservation.Valid = false;
            pendingReservation.Start = timeNow;     // no waiting if failed
            pendingReservation.Estimate = new TimeSpan(0);
            goto Exit;

          Success:

            // DebugStub.WriteLine("RialtoScheduler::ResolveConstraint SUCCESS");
            InheritAndReplaceOnEarliestDeadlineFirst(thread.ReservationStack, timeInherited, timeNow);
            ok = true;
          Exit:
            pendingReservation.InitialEstimate = pendingReservation.Estimate;
            reservationPrevious = thread.ReservationStack;
            pendingReservation.SurroundingReservation= thread.ReservationStack;
            thread.ReservationStack = pendingReservation;
            RialtoScheduler.AddRefReservation(pendingReservation);
            if (reservationPrevious != null) {
                reservationPrevious.constraintExecution += pendingReservation.initialThreadExecution -
                    reservationPrevious.initialThreadExecution;
            }
            //
            // Reschedule()  called if currently we are executing on a pendingReservation
            //                              and the EarliestDeadlineFirst top changed
            //              or   the current pendingReservation goes into the idle list
            //                  solve in SetStateWaiting
            //
            pendingReservation.EnqueueReservation(timeNow);
            RialtoScheduler.DirectSwitchOnConstraint();

#if DEBUG_RESERV
            PrintReservations(pendingReservation, sc, timeNow);
#endif
            return ok;
        }

        void EnqueueReservation(DateTime timeNow)
        {
            OneShotReservation temp;

            Debug.Assert((AssociatedActivity != null) ||
                (OriginalThread != null));

            // Infeasible or (Estimate == 0) Reservations:
            if (Estimate <= RialtoScheduler.AFewSlice) {
                RialtoActivity activity;
                Debug.Assert(OriginalThread != null);
                Debug.Assert(AssociatedActivity == null);
                activity = OriginalThread.AssociatedActivity;
                MyQueueType = QueueType.UnfinishedQueue;
                if (activity.UnfinishedConstraints == null) {
                    Next = Previous = this;
                    activity.UnfinishedConstraints = this;
                }
                else {
                    // no order enforced
                    Next = activity.UnfinishedConstraints;
                    Previous = activity.UnfinishedConstraints.Previous;
                    activity.UnfinishedConstraints.Previous.Next = this;
                    activity.UnfinishedConstraints.Previous = this;
                    activity.UnfinishedConstraints = this; // optional
                }
                //  DebugStub.WriteLine("Add: EnqueueReserve  1 0x{0:x} {1}", this, ReferenceCount);
                RialtoScheduler.AddRefReservation(this);
                return;
            }
            //  Debug.Assert(Valid);

            // Idle Reservations:
            if (Start > timeNow + RialtoScheduler.AFewSlice) {
                // take thread off activity RoundRobin queue and simulate a sleep
                //    i.e. don't set a timer interrupt

                OriginalThread.InternalSetStateWaiting(DateTime.MaxValue);

#if DEBUG_START_RESERV
                DebugStub.WriteLine("Put reservation {0}:{1} in IdleQueue\n", OriginalThread,
                    ReservationId);
#endif
                Debug.Assert(OriginalThread != null);
                MyQueueType = QueueType.IdleQueue;

                if (idleReservations == null) {
                    Next = Previous = this;
                    idleReservations = this;
                }
                else {
                    temp = idleReservations;
                    if (Start < temp.Start) {
                        idleReservations = this;
                    }
                    else {
                        do {
                            temp = temp.Next;
                        } while (temp != idleReservations &&
                                 Start >= temp.Start); // >= is compulsory to keep it 'FIFO'
                    } // insert before 'temp'
                    Next = temp;
                    Previous = temp.Previous;
                    temp.Previous.Next = this;
                    temp.Previous = this;
                }
                //  fprintf(stdout,"Add: EnqueueReserve  2 0x%x %d\n", this, ReferenceCount);
                RialtoScheduler.AddRefReservation(this);
                return;
            }

            // Guaranteed OneShotReservation:
            MyQueueType = QueueType.GuaranteedQueue;
            if (GuaranteedReservations == null) {
                Next = Previous = this;
                guaranteedReservations = this;
            }
            else {
                temp = GuaranteedReservations;
                if (Deadline < GuaranteedReservations.Deadline) {
                    guaranteedReservations = this;
                }
                else {
                    do {
                        temp = temp.Next;
                    } while (temp != guaranteedReservations &&
                             Deadline > temp.Deadline); // > is compulsory to keep it 'FIFO'
                } // insert before 'temp'
                Next = temp;
                Previous = temp.Previous;
                temp.Previous.Next = this;
                temp.Previous = this;
            }
            RialtoScheduler.AddRefReservation(this);
#if DEBUG_RESERV
            PrintQueueReserv(guaranteedReservations, timeNow); //TODO: PrintQueueReserv
#endif
            return;
        }


        static void ReplaceOnEarliestDeadlineFirst(OneShotReservation reservation, DateTime timeNow)
        {
            while (reservation != null) {
                if (reservation.Estimate.Ticks > 0) {
                    if (reservation.MyQueueType == QueueType.NoQueue) {
                        reservation.EnqueueReservation(timeNow);
                    }
                    else {
                        Debug.Assert(reservation.MyQueueType == QueueType.GuaranteedQueue);
                    }
                    break;
                }
                if (reservation.MyQueueType == QueueType.NoQueue) {
                    reservation.EnqueueReservation(timeNow);
                }
                else {
                    Debug.Assert(reservation.MyQueueType == QueueType.UnfinishedQueue);
                }
                reservation = reservation.SurroundingReservation;
            }
        }

        public static bool SatisfyAcceptedConstraint(DateTime timeNow)
        {
            OneShotReservation    reservation;

            if (currentReservation != null) {
                currentReservation.Estimate -= timeNow - RialtoScheduler.SchedulingTime;
                if (currentReservation.Estimate.Ticks <= 0) {
                    RialtoThread tempThread  = currentReservation.OriginalThread;
                    currentReservation.DequeueReservation();
                    if (tempThread != null) {
                        // activity reservations vanish here
                        //Debug.Assert(currentReservation.ActiveThread == RialtoScheduler.GetCurrentThread()); // only thread reserv are added to
                        currentReservation.EnqueueReservation(RialtoScheduler.SchedulingTime); // the UnfinishedConstraints list of the OriginalThread's Activ
                        OneShotReservation.ReplaceOnEarliestDeadlineFirst(currentReservation.SurroundingReservation, RialtoScheduler.SchedulingTime);
                    }
                }
            }

            reservation = guaranteedReservations;
            while (reservation != null) {
                if (!RialtoScheduler.CheckReservation(reservation, timeNow)) {
                    return false;
                }
                reservation = reservation.Next;
                if (reservation == guaranteedReservations) {
                    break;
                }
            }
            reservation = idleReservations;
            while (reservation != null) {
                if (!RialtoScheduler.CheckReservation(reservation, timeNow)) {
                    return false;
                }
                reservation = reservation.Next;
                if (reservation == idleReservations) {
                    break;
                }
            }
            return true;
        }

        public static void UpdateCurrentReservation()
        {
            if ((currentReservation != null) &&
                (currentReservation.Estimate <= RialtoScheduler.AFewSlice)) {
                // slice used for a reservation (CK: & estimate now empty)
                RialtoThread tempThread  = currentReservation.OriginalThread;
                currentReservation.DequeueReservation();
                if (tempThread != null) {
                    // activity reservations vanish here
                    currentReservation.EnqueueReservation(RialtoScheduler.SchedulingTime); // the UnfinishedConstraints list of the OriginalThread's Activ
                    ReplaceOnEarliestDeadlineFirst(currentReservation.SurroundingReservation, RialtoScheduler.SchedulingTime);
                }
            }

        }

        public static void FreshenReservationQueues()
        {
            OneShotReservation tempReservation;

            //  Move 'idle' reservations to the 'active' reservations list, if necessary.
            //  A reservation is 'idle' until its Start time is reached.
            //  The 'active' reservation list is ordered 'Earliest Deadline Firts'.
            //  The 'idle' queue is ordered Earliest Start First.
            while ((tempReservation = IdleReservations) != null) {
                if (RialtoScheduler.SchedulingTime + RialtoScheduler.AFewSlice < tempReservation.Start) {
                    break;
                }
                tempReservation.DequeueReservation(); // Remove OneShotReservation from the Idle Queue
                tempReservation.EnqueueReservation(RialtoScheduler.SchedulingTime); // Earliest Deadline First in the (Non)Guaranteed Queue
                RialtoScheduler.EnqueueRunThread(tempReservation.OriginalThread);
#if DEBUG_START_RESERV
                DebugStub.WriteLine("Get reservation {0}:{1} from IdleQueue", tempReservation.OriginalThread,
                    tempReservation.ReservationId);
#endif
            }

            // Remove the active reservations from the guaranteed and nonguaranteed queues
            // if their Deadline is <= CurrentTime.
            while ((tempReservation = guaranteedReservations) != null) {
                if (RialtoScheduler.SchedulingTime + RialtoScheduler.AFewSlice < tempReservation.Deadline) {
                    break;
                }
                //      fprintf(stdout,"Add: Reschedule Guaranteed Deadline 0x%x %d\n", tempReservation, tempReservation.ReferenceCount);
                RialtoScheduler.AddRefReservation(tempReservation);
                tempReservation.DequeueReservation(); // Remove OneShotReservation from the Guaranteed Queue
                if ((tempReservation.OriginalThread != null) && // if a thread reservation
                    (tempReservation.OriginalThread.AssociatedActivity != null)) {
                    // if a thread reservation
                    tempReservation.Estimate = new TimeSpan(0);
                    tempReservation.EnqueueReservation(RialtoScheduler.SchedulingTime); // add it to the Pending End Constraint List
                }
                //  fprintf(stdout,"Reschedule Guaranteed Deadline off 0x%x %d\n", tempReservation, tempReservation.ReferenceCount);
                tempReservation.ReleaseReservationProtected();
            }

        }

        int ReleaseReservationProtected()
        {
            return RialtoScheduler.ReleaseReservationProtected(this);
        }

        public void DequeueReservation() //TODO: Should this be a resource container function?
        {
            Debug.Assert(Processor.InterruptsDisabled());
            OneShotReservation next;
            // OneShotReservation pSurrounding = null;

            Debug.Assert((AssociatedActivity != null) ||
                (OriginalThread != null));

            if (Next != this) {
                //If there's another reservation, remove us from the queue
                Next.Previous = Previous;
                Previous.Next = Next;
                next = Next;
                Debug.Assert(next.Deadline.Ticks > 0);
            }
            else {
                //Otherwise we are only reservation.
                Debug.Assert(Previous == this);
                next = null;
            }

            if (this == GuaranteedReservations) {
                //Take care when we're the head of the list.
                guaranteedReservations = next;
#if DEBUG_RESERV
                DebugStub.WriteLine("Dequeue {0}: {1}", ReservationId, Estimate);
                //      Debug.Assert(Criticality != CRITICAL || !Valid || Estimate ==0);
                PrintQueueReserv(GuaranteedReservations, SystemClock.GetKernelTime());
#endif
            }
            else if (this == IdleReservations) {
                //Or maybe we're the head of this list (but definitely not both).
                idleReservations = next;
            }
            else if ((OriginalThread != null) &&
                (this == OriginalThread.AssociatedActivity.UnfinishedConstraints)) {
                //Or else we might be the head of the unfinished constraints list for the activity associated with our original thread.
                OriginalThread.AssociatedActivity.UnfinishedConstraints = next;
            } // else { we're OK! }

            Next = Previous = null;
            //  DebugStub.WriteLine("DequeueReservation 0x{0:x} {1}", this, ReferenceCount);
            MyQueueType = QueueType.NoQueue;
            ReleaseReservationProtected();
        }

        public static void FindRunnableReservation(ref RialtoThread currentThread)
        {
            currentReservation = guaranteedReservations;
            while (currentReservation != null) {
                if ((currentThread = currentReservation.GetRunnableThread()) != null) {
                    break;
                }
                currentReservation = currentReservation.Next;
                if (currentReservation == guaranteedReservations) {
                    break;
                }
            }
        }

        static void InheritAndReplaceOnEarliestDeadlineFirst(OneShotReservation reservation,
                                                             TimeSpan timeInherited,
                                                             DateTime timeNow)
        {
            OneShotReservation current = null;

            while (reservation != null) {
                if (reservation.Estimate.Ticks > 0) {
                    if (current == null) {
                        Debug.Assert(reservation.MyQueueType != QueueType.NoQueue);
                        current = reservation;
                    }
                    else {
                        Debug.Assert(reservation.MyQueueType == QueueType.NoQueue);
                    }
                }
                else if (reservation.MyQueueType != QueueType.NoQueue) {
                    Debug.Assert (current != null || reservation.MyQueueType == QueueType.UnfinishedQueue);
                    reservation.DequeueReservation();
                }
                if (reservation.ResolutionEpoch == RialtoScheduler.ResolutionAttempt) {
                    Debug.Assert(timeInherited >= reservation.InheritedEstimate);
                    timeInherited -= reservation.InheritedEstimate;
                    Debug.Assert(reservation.Estimate >= reservation.InheritedEstimate);
                    reservation.Estimate -= reservation.InheritedEstimate;
                }
                reservation = reservation.SurroundingReservation;
            }
            if (current != null) {
                if (current == CurrentReservation) {
                    current.Estimate -= timeNow - RialtoScheduler.SchedulingTime;
                    currentReservation = null;
                    RialtoScheduler.Reschedule();
                }
                current.DequeueReservation();
            }
        }

        public static void InheritOnEarliestDeadlineFirst(OneShotReservation reservation,
                                                          TimeSpan timeToInherit)
        {
            while (reservation != null && timeToInherit.Ticks > 0) {
                if (reservation.ResolutionEpoch == RialtoScheduler.ResolutionAttempt) {
                    Debug.Assert(timeToInherit >= reservation.InheritedEstimate);
                    reservation.Estimate -= reservation.InheritedEstimate;
                    timeToInherit -= reservation.InheritedEstimate;
                }
                reservation = reservation.SurroundingReservation;
            }
        }

        public static void ClearCurrentReservation() {
            currentReservation = null;
        }
    }
}