public PrtImplMachine() : base() { this.maxBufferSize = 0; this.doAssume = false; this.eventQueue = new PrtEventBuffer(); this.receiveSet = new HashSet <PrtValue>(); }
public PrtEventBuffer CloneAndResolve(StateImpl s) { PrtEventBuffer x = Clone(); x.Resolve(s); return(x); }
public PrtEventBuffer Clone() { var clonedVal = new PrtEventBuffer(); foreach (var ev in this.events) { clonedVal.events.Add(ev.Clone()); } return(clonedVal); }
public PrtImplMachine(StateImpl app, int maxBuff) : base() { this.instanceNumber = this.NextInstanceNumber(app); this.eventQueue = new PrtEventBuffer(); this.receiveSet = new HashSet <PrtValue>(); this.maxBufferSize = maxBuff; this.stateImpl = app; //Push the start state function on the funStack. PrtPushState(StartState); }
public PrtImplMachine(StateImpl app, int maxBuff, bool assume) : base() { this.instanceNumber = this.NextInstanceNumber(app); this.eventQueue = new PrtEventBuffer(); this.receiveSet = new HashSet <PrtValue>(); this.maxBufferSize = maxBuff; this.doAssume = assume; this.stateImpl = app; this.self = new PrtInterfaceValue(this, new List <PrtEventValue>()); //Push the start state function on the funStack. PrtPushState(StartState); }
public PrtEventBuffer Clone() { var clonedVal = new PrtEventBuffer(); foreach (PrtEventNode ev in events) { clonedVal.events.Add(ev.Clone()); } clonedVal.concrete = concrete; return(clonedVal); }
/// <summary> /// Compute the abstract successors caused by updating the queue of <paramref name="currIndex"/> machine. /// /// </summary> /// <param name="currIndex">The index for the machine about to explore</param> /// <param name="abstract_succs"></param> /// <param name="abstract_succs_SW"></param> void CollectAbstractSuccessorsFromList(int currIndex, HashSet <int> abstract_succs, StreamWriter abstract_succs_SW) { List <PrtEventNode> preDequeEvents = ImplMachines[currIndex].eventQueue.events; // pre-dequeue events list var choiceVector = new List <bool>(); bool more; do { StateImpl succ = (StateImpl)Clone(); PrtImplMachine machineOfSucc = succ.ImplMachines[currIndex]; // the machine of successor indexing in currIndex PrtEventBuffer queueOfMachine = machineOfSucc.eventQueue; // the message queue of successor machine List <PrtEventNode> queueEvents = queueOfMachine.events; // the events list of successor machine more = machineOfSucc.PrtRunStateMachineNextChoice(choiceVector); Debug.Assert(preDequeEvents.Count - queueOfMachine.Size() <= 1); // we have dequeued at most one event /// If dequeing was unsuccessful, then there is nothing left to do. /// No more nondeterministic choices to try if (preDequeEvents.Count == queueOfMachine.Size() || succ.CheckFailure(0)) // { return; // } int idxOfEventDequeuedFromSuffix = Math.Max(PrtEventBuffer.idxOfLastDequeuedEvent, PrtEventBuffer.p); PrtEventNode eventDequeuedFromSuffix = preDequeEvents[idxOfEventDequeuedFromSuffix]; /// <remarks>Choice 1: </remarks> The eventDequeuedFromSuffix, aka the last dequeued event, existed /// exactly once in the concrete suffix. /// Then it is gone after the dequeue, in both abstract and concrete. The new state abstract is valid. succ.AddToAbstractSuccessorsIfInvSat(currIndex, this, abstract_succs, abstract_succs_SW); /// <remarks>Choice 1: </remarks> The eventDequeuedFromSuffix, aka the last dequeued event, existed /// >= twice in concrete suffix. /// We need to find all positions where to re-introduce it in the abstract queue, and try them all /// non-deterministically. for (int pos = idxOfEventDequeuedFromSuffix; pos < queueOfMachine.Size(); ++pos) { // insert eventDequeuedFromSuffix at position pos (push the rest to the right) queueEvents.Insert(pos, eventDequeuedFromSuffix); succ.AddToAbstractSuccessorsIfInvSat(currIndex, this, abstract_succs, abstract_succs_SW); queueEvents.RemoveAt(pos); // restore previous state } queueEvents.Add(eventDequeuedFromSuffix); // finally, insert eventDequeuedFromSuffix at end succ.AddToAbstractSuccessorsIfInvSat(currIndex, this, abstract_succs, abstract_succs_SW); } while (more); }