/// <summary>
 /// This function is called in response to invoke-scheduler function in the zing model.
 /// </summary>
 /// <param name="Params"></param>
 public void Invoke(ZingerSchedulerState ZSchedulerState, params object[] Params)
 {
     var param1_operation = (string)Params[0];
     if (param1_operation == "map")
     {
         var Param2_PprocessId = (int)Params[1];
         ZSchedulerState.Map(Param2_PprocessId);
     }
     else if (param1_operation == "enabled")
     {
         var param2_target = (int)Params[1];
         var param3_source = (int)Params[2];
         OnEnabled(ZSchedulerState, param2_target, param3_source);
     }
     else if (param1_operation == "blocked")
     {
         var param2_source = (int)Params[1];
         OnBlocked(ZSchedulerState, param2_source);
     }
     else if (param1_operation == "zingerop")
     {
         ZingerOperation(ZSchedulerState, Params);
     }
     else
     {
         OtherOperations(ZSchedulerState, Params);
     }
 }
 /// <summary>
 /// Returns the first element in the list.
 /// </summary>
 /// <param name="zSchedState"></param>
 /// <returns>The next process to be executed</returns>
 public override int Next(ZingerSchedulerState zSchedState)
 {
     var SchedState = zSchedState as RoundRobinDBSchedulerState;
     if (SchedState.enabledProcesses.Count == 0)
         return -1;
     else
         return SchedState.enabledProcesses.ElementAt(0);
 }
 /// <summary>
 /// Perform the delay operation. Move process at the start of the list to the end.
 /// </summary>
 /// <param name="zSchedState"></param>
 public override void Delay(ZingerSchedulerState zSchedState)
 {
     //Console.WriteLine("Delayed");
     var SchedState = zSchedState as RoundRobinDBSchedulerState;
     if (SchedState.enabledProcesses.Count == 0)
         return;
     //remove the current process and push it at the back of the queue.
     var delayProcess = SchedState.enabledProcesses.ElementAt(0);
     SchedState.enabledProcesses.RemoveAt(0);
     SchedState.enabledProcesses.Add(delayProcess);
     //one delay operation performed
     zSchedState.numOfTimesCurrStateDelayed++;
 }
Example #4
0
 public FrontierNode(TraversalInfo ti)
 {
     this.Bounds = new ZingerBounds(ti.zBounds.ExecutionCost, ti.zBounds.ChoiceCost);
     if (ZingerConfiguration.DoDelayBounding)
     {
         schedulerState = ti.ZingDBSchedState.Clone(true);
     }
     else if (ZingerConfiguration.DoPreemptionBounding)
     {
         preemptionBounding = ti.preemptionBounding.Clone();
     }
     ti.IsFingerPrinted = true;
     TheTrace = ti.GenerateTrace();
 }
Example #5
0
        public void Deserialize(Stream inputStream)
        {
            BinaryReader bReader = new BinaryReader(inputStream);

            this.Bounds = new ZingerBounds();
            this.Bounds.ExecutionCost = bReader.ReadInt32();
            this.Bounds.ChoiceCost = bReader.ReadInt32();
            if (ZingerConfiguration.DoDelayBounding)
            {
                BinaryFormatter bFormat = new BinaryFormatter();
                bFormat.Binder = new AllowAllAssemblyVersionsDeserializationBinder();
                this.schedulerState = (ZingerSchedulerState)bFormat.Deserialize(inputStream);
            }
            Int32 traceCount = bReader.ReadInt32();
            UInt32[] steps = new UInt32[traceCount];
            for (int i = 0; i < traceCount; i++)
            {
                steps[i] = bReader.ReadUInt32();
            }
            this.TheTrace = new Trace(steps);
        }
 /// <summary>
 /// The Delay operation drops the last scheduled process such that it is never scheduled again
 /// for that state.
 /// </summary>
 /// <param name="zSchedState"></param>
 public override void Delay(ZingerSchedulerState zSchedState)
 {
     var SchedState = zSchedState as RandomDBSchedulerState;
     // Drop the element
     SchedState.setOfProcesses.Remove(SchedState.scheculedProcess);
     zSchedState.numOfTimesCurrStateDelayed++;
     return;
 }
 /// <summary>
 /// This function is called by Zinger whenever a new process is created.
 /// Add the new created process at the end of RR list.
 /// </summary>
 /// <param name="processId"> process Id of the newly created process</param>
 public override void Start(ZingerSchedulerState ZSchedulerState, int processId)
 {
     var SchedState = ZSchedulerState as RoundRobinDBSchedulerState;
     ZSchedulerState.Start(processId);
     //add the process to the enabled processes list
     SchedState.enabledProcesses.Add(processId);
 }
        /// <summary>
        /// This function is called when an enqueue is performed on a process, hence it has a pending event to be serviced.
        /// </summary>
        /// <param name="ZSchedulerState"></param>
        /// <param name="targetSM"> targetSM is the target process in which the event was enqueued.
        /// This process is pushed on top of the stack to follow event enqueue order.</param>
        /// <param name="sourceSM">This parameter is passed for debugging purposes</param>
        public override void OnEnabled(ZingerSchedulerState ZSchedulerState, int targetSM, int sourceSM)
        {
            var SchedState = ZSchedulerState as RTCDBSchedulerState;
            var procId = SchedState.GetZingProcessId(targetSM);

            if (!SchedState.DBStack.Contains(procId))
                SchedState.DBStack.Push(procId);
        }
 /// <summary>
 /// This function is provided for extending or customizing the delayingExplorer.
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="Params"></param>
 public override void ZingerOperation(ZingerSchedulerState ZSchedulerState, params object[] Params)
 {
     //do nothing
 }
        /// <summary>
        /// Remove the completed process from Stack so that it is never scheduled again.
        /// </summary>
        /// <param name="processId">Process id to be removed from the stack</param>
        public override void Finish(ZingerSchedulerState zSchedState, int processId)
        {
            var SchedState = zSchedState as RTCDBSchedulerState;
            Stack<int> tempStack = new Stack<int>();
            while (SchedState.DBStack.Count != 0)
            {
                int topStack;
                if ((topStack = SchedState.DBStack.Pop()) == processId)
                {
                    break;
                }
                else
                {
                    tempStack.Push(topStack);
                }
            }

            while (tempStack.Count != 0)
            {
                SchedState.DBStack.Push(tempStack.Pop());
            }
        }
        /// <summary>
        /// Return process at the top of stack.
        /// This process is executed next and follows the deterministic schedule.
        /// </summary>
        /// <returns>next process to be scheduled</returns>
        public override int Next(ZingerSchedulerState zSchedState)
        {
            var SchedState = zSchedState as RTCDBSchedulerState;
            if (SchedState.DBStack.Count == 0)
                return -1;

            return SchedState.DBStack.Peek();
        }
 /// <summary>
 /// This function is called by Zinger whenever a process has finished execution.
 /// Remove the process from list of enabled processes.
 /// </summary>
 /// <param name="processId"> process Id of the completed process</param>
 public override void Finish(ZingerSchedulerState ZSchedulerState, int processId)
 {
     var schedState = ZSchedulerState as RoundRobinDBSchedulerState;
     schedState.enabledProcesses.Remove(processId);
 }
 /// <summary>
 /// This function is called by Zinger to obtain next process to be scheduled.
 /// </summary>
 /// <returns>process Id of next process to be scheduled</returns>
 public abstract int Next(ZingerSchedulerState ZSchedulerState);
Example #14
0
        protected TraversalInfo(StateImpl s, StateType st,
            TraversalInfo pred, Via bt)
        {
            stateType = st;
            Via = bt;
            NumProcesses = s.NumProcesses;
            ProcessInfo = s.GetProcessInfo();
            events = s.GetEvents();
            exception = s.Exception;
            IsAcceptingState = s.IsAcceptingState;

            //initialize the plugin information.

            if (pred != null)
            {
                Predecessor = pred;
                CurrentDepth = pred.CurrentDepth + 1;
                zBounds = new ZingerBounds(pred.zBounds.ExecutionCost, pred.zBounds.ChoiceCost);
                zBounds.IncrementDepthCost();

                doDelay = false;
                if (ZingerConfiguration.DoDelayBounding)
                {
                    ZingDBSchedState = s.ZingDBSchedState;
                    ZingDBScheduler = s.ZingDBScheduler;
                }
                else if (ZingerConfiguration.DoPreemptionBounding)
                {
                    preemptionBounding = new ZingPreemptionBounding(ProcessInfo, NumProcesses, Predecessor.preemptionBounding.currentProcess);
                }

                if (ZingerConfiguration.DronacharyaEnabled || ZingerConfiguration.IsPluginEnabled)
                {
                    ZingerPlugin = s.ZingerPlugin;
                    ZingerPluginState = s.ZingerPluginState;
                }
                pred.Successor = this;
                MagicBit = pred.MagicBit;
            }
            else
            {
                zBounds = new ZingerBounds();
                MagicBit = false;
                CurrentDepth = 0;
                if (ZingerConfiguration.DoDelayBounding)
                {
                    ZingDBSchedState = s.ZingDBSchedState.Clone(false);
                    ZingDBScheduler = s.ZingDBScheduler;
                }
                else if (ZingerConfiguration.DoPreemptionBounding)
                {
                    preemptionBounding = new ZingPreemptionBounding(ProcessInfo, NumProcesses, 0);
                }
                if (ZingerConfiguration.DronacharyaEnabled || ZingerConfiguration.IsPluginEnabled)
                {
                    ZingerPlugin = s.ZingerPlugin;
                    ZingerPluginState = s.ZingerPluginState.Clone();
                }
            }
        }
 /// <summary>
 /// This function is called by Zinger whenever a new process is created.
 /// </summary>
 /// <param name="processId"> process Id of the newly created process</param>
 public abstract void Start(ZingerSchedulerState ZSchedulerState, int processId);
 /// <summary>
 /// Unhandled operation or a special operation.
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="Params"></param>
 public virtual void OtherOperations(ZingerSchedulerState ZSchedulerState, params object[] Params)
 {
     throw new Exception("This operation is not supported by the delaying scheduler");
 }
 /// <summary>
 /// This function is called when a P process is enabled.
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="targetSM"></param>
 /// <param name="sourceSM"></param>
 public abstract void OnEnabled(ZingerSchedulerState ZSchedulerState, int targetSM, int sourceSM);
 /// <summary>
 /// This function is called when a P process is blocked on a dequeue
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="sourceSM"></param>
 public abstract void OnBlocked(ZingerSchedulerState ZSchedulerState, int sourceSM);
 /// <summary>
 /// This function is used internally by the ZING explorer.
 /// It checks if we have applied the maximum number of delays in the current state.
 /// Applying any more delay operations will not lead to new transitions/states being explored.
 /// Maximum delay operations for a state is always (totalEnabledProcesses - 1).
 /// </summary>
 /// <param name="zSchedState"></param>
 /// <returns>If max bound for the given state has reached</returns>
 public override bool MaxDelayReached(ZingerSchedulerState zSchedState)
 {
     var SchedState = zSchedState as RoundRobinDBSchedulerState;
     return zSchedState.numOfTimesCurrStateDelayed >= (SchedState.enabledProcesses.Count - 1);
 }
 /// <summary>
 /// This function is called by Zinger whenever a process has finished execution (terminated).
 /// </summary>
 /// <param name="processId"> process Id of the completed process</param>
 public override void Finish(ZingerSchedulerState ZSchedulerState, int processId)
 {
     var schedState = (ZSchedulerState as RandomDBSchedulerState);
     schedState.EnabledProcesses.Remove(processId);
     schedState.setOfProcesses.Remove(processId);
 }
 /// <summary>
 /// This function is called when a process is blocked on dequeue.
 /// There are no more events to be serviced and the queue is empty.
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="sourceSM">Process that is blocked</param>
 public override void OnBlocked(ZingerSchedulerState ZSchedulerState, int sourceSM)
 {
     var SchedState = (ZSchedulerState as RoundRobinDBSchedulerState);
     var procId = SchedState.GetZingProcessId(sourceSM);
     SchedState.enabledProcesses.Remove(procId);
 }
        /// <summary>
        /// Randomly return a process from the set of processes SetOfProcesses not yet delayed.
        /// </summary>
        /// <param name="zSchedState"></param>
        /// <returns></returns>
        public override int Next(ZingerSchedulerState zSchedState)
        {
            var SchedState = zSchedState as RandomDBSchedulerState;
            if (SchedState.setOfProcesses.Count() == 0)
                return -1;

            var index = SchedState.randGen.Next(0, SchedState.setOfProcesses.Count);
            var procId = SchedState.setOfProcesses.ElementAt(index);
            SchedState.scheculedProcess = procId;
            return procId;
        }
 /// <summary>
 /// This function is used internally by the ZING explorer.
 /// It checks if we have applied the maximum number of delays in the current state.
 /// Applying any more delay operations will not lead to new transitions/states being explored.
 /// Maximum delay operations for a state is always (totalEnabledProcesses - 1).
 /// </summary>
 /// <param name="zSchedState"></param>
 /// <returns>If max bound for the given state has reached</returns>
 public override bool MaxDelayReached(ZingerSchedulerState zSchedState)
 {
     var SchedState = zSchedState as RTCDBSchedulerState;
     return zSchedState.numOfTimesCurrStateDelayed >= (SchedState.DBStack.Count - 1);
 }
 /// <summary>
 /// This function is called when a process is blocked on dequeue.
 /// There are no more events to be serviced and the queue is empty.
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="sourceSM">Process that is blocked</param>
 public override void OnBlocked(ZingerSchedulerState ZSchedulerState, int sourceSM)
 {
     var SchedState = ZSchedulerState as RandomDBSchedulerState;
     var procId = SchedState.GetZingProcessId(sourceSM);
     // Console.WriteLine(SchedState.ToString());
     SchedState.setOfProcesses.Remove(procId);
     SchedState.EnabledProcesses.Remove(procId);
 }
 /// <summary>
 /// This function is called when a process is blocked. In the context of asynchronous message
 /// passing programs, a process is blocked when its queue is empty and the process is waiting for an event.
 /// The process that gets blocked is poped off the stack.
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="sourceSM">This parameter is passed for debugging purposes</param>
 public override void OnBlocked(ZingerSchedulerState ZSchedulerState, int sourceSM)
 {
     var SchedState = ZSchedulerState as RTCDBSchedulerState;
     if (SchedState.DBStack.Count > 0)
     {
         SchedState.DBStack.Pop();
     }
 }
 /// <summary>
 /// This function is called on a enqueue operation. A process is enabled
 /// if it has messages in its queue to be serviced
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="targetSM">process is added to the set of enabled processes</param>
 /// <param name="sourceSM"></param>
 public override void OnEnabled(ZingerSchedulerState ZSchedulerState, int targetSM, int sourceSM)
 {
     var SchedState = ZSchedulerState as RandomDBSchedulerState;
     var procId = SchedState.GetZingProcessId(targetSM);
     if (!SchedState.EnabledProcesses.Contains(procId))
     {
         SchedState.EnabledProcesses.Add(procId);
         SchedState.setOfProcesses.Add(procId);
     }
 }
 /// <summary>
 /// Push newly created process on top of Stack
 /// </summary>
 /// <param name="processId"> process Id of the newly created process</param>
 public override void Start(ZingerSchedulerState zSchedState, int processId)
 {
     var SchedState = zSchedState as RTCDBSchedulerState;
     SchedState.DBStack.Push(processId);
     SchedState.Start(processId);
 }
 /// <summary>
 /// This function is called by Zinger whenever a new process is created.
 /// </summary>
 /// <param name="processId"> process Id of the newly created process</param>
 public override void Start(ZingerSchedulerState ZSchedulerState, int processId)
 {
     var schedState = (ZSchedulerState as RandomDBSchedulerState);
     ZSchedulerState.Start(processId);
     schedState.EnabledProcesses.Add(processId);
     schedState.setOfProcesses.Add(processId);
 }
        /// <summary>
        /// Move the process on top of stack to the bottom of the stack. Moving the process to the bottom of the stack deviates
        /// the scheduler from following the casual order of events (RTC strategy).
        /// </summary>
        public override void Delay(ZingerSchedulerState zSchedState)
        {
            var SchedState = zSchedState as RTCDBSchedulerState;
            if (SchedState.DBStack.Count == 0)
                return;

            var topOfStack = SchedState.DBStack.Pop();
            var tempStack = new Stack<int>();
            while (SchedState.DBStack.Count != 0)
            {
                tempStack.Push(SchedState.DBStack.Pop());
            }
            SchedState.DBStack.Push(topOfStack);
            while (tempStack.Count != 0)
            {
                SchedState.DBStack.Push(tempStack.Pop());
            }

            zSchedState.numOfTimesCurrStateDelayed++;
        }
 /// <summary>
 /// This function is called on a enqueue operation. A process is enabled
 /// if it has messages in its queue to be serviced
 /// </summary>
 /// <param name="ZSchedulerState"></param>
 /// <param name="targetSM">The process that is enabled because of an enqueue</param>
 /// <param name="sourceSM">This parameter is passed for debugging purposes</param>
 public override void OnEnabled(ZingerSchedulerState ZSchedulerState, int targetSM, int sourceSM)
 {
     var SchedState = (ZSchedulerState as RoundRobinDBSchedulerState);
     var procId = SchedState.GetZingProcessId(targetSM);
     if (!SchedState.enabledProcesses.Contains(procId))
         SchedState.enabledProcesses.Add(procId);
 }