private void SynchronousChannelInputOutput(List <Configuration> returnList, int i, Valuation GlobalEnv, string evt) { List <ConfigurationWithChannelData> outputs = new List <ConfigurationWithChannelData>(); Processes[i].SyncOutput(GlobalEnv, outputs); foreach (ConfigurationWithChannelData vm in outputs) { if (evt != null && vm.Event != evt) { continue; } Process output = vm.Process; for (int k = 0; k < Processes.Count; k++) { if (k != i) { List <Configuration> syncedProcess = new List <Configuration>(); Processes[k].SyncInput(vm, syncedProcess); foreach (Configuration p in syncedProcess) { List <Process> newProcess = new List <Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = output; newProcess[k] = p.Process; IndexParallel interleave = new IndexParallel(newProcess, Alphabets); Configuration newStep = new Configuration(interleave, vm.Event, vm.DisplayName, p.GlobalEnv, false); newStep.IsAtomic = vm.IsAtomic || p.IsAtomic; if (AssertionBase.CalculateParticipatingProcess) { newStep.ParticipatingProcesses = new string[] { i.ToString(), k.ToString() }; } returnList.Add(newStep); } } } } }
public override Process Rename(Dictionary <string, Expression> constMapping, Dictionary <string, string> newDefNames, Dictionary <string, Definition> renamedProcesses) { List <Process> newnewListProcess = Processes; if (Processes == null) { newnewListProcess = IndexedProcessDefinition.GetIndexedProcesses(constMapping); } List <Process> newProceses = new List <Process>(); foreach (Process process in newnewListProcess) { newProceses.Add(process.Rename(constMapping, newDefNames, renamedProcesses)); } Process result = new IndexParallel(newProceses); result.IsBDDEncodableProp = this.IsBDDEncodableProp; return(result); }
public override void MoveOneStep(Valuation GlobalEnv, List <Configuration> list) { if (Alphabets == null) { IdentifySharedEventsAndVariables(); } List <string> barrierEnabledEvents = new List <string>(); List <string> disabled = new List <string>(); System.Diagnostics.Debug.Assert(list.Count == 0); Dictionary <string, List <Configuration> > syncSteps = new Dictionary <string, List <Configuration> >(); for (int i = 0; i < Processes.Count; i++) { //Process process = Processes[i]; List <Configuration> list1 = new List <Configuration>(); Processes[i].MoveOneStep(GlobalEnv, list1); List <string> enabled = new List <string>(list1.Count); for (int j = 0; j < list1.Count; j++) { Configuration step = list1[j]; string evt = step.Event; //liuyang, commented here //enabled.Add(evt); //if it happens that a data operation shares the same name with the sync event, treat it as an interleave case if (!Alphabets[i].Contains(evt) || step.IsDataOperation) { if (AssertionBase.CalculateParticipatingProcess) { step.ParticipatingProcesses = new string[] { i.ToString() }; } List <Process> newProcess = new List <Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = step.Process; step.Process = new IndexParallel(newProcess, Alphabets); list.Add(step); } else { //liuyang, added here enabled.Add(evt); string key = evt + Constants.SEPARATOR + i; if (!syncSteps.ContainsKey(key)) { syncSteps.Add(key, new List <Configuration>()); } syncSteps[key].Add(step); if (!barrierEnabledEvents.Contains(evt)) //Alphabets[i].Contains(evt) && { barrierEnabledEvents.Add(evt); } } } //int alphabetsCount = Alphabets[i].Count; foreach (string s in Alphabets[i]) { if (!enabled.Contains(s) && !disabled.Contains(s)) { disabled.Add(s); } } //to check whether there are synchoronous channel input/output if (SpecificationBase.HasSyncrhonousChannel) { SynchronousChannelInputOutput(list, i, GlobalEnv, null); } } int disabledCount = disabled.Count; for (int i = 0; i < disabledCount; i++) { barrierEnabledEvents.Remove(disabled[i]); } List <bool> isAtomic = null; //move the barrier synchronization events. foreach (string evt in barrierEnabledEvents) { //maps an event to the list of resulting processes. List <List <Process> > moves = new List <List <Process> >(); moves.Add(new List <Process>()); if (SpecificationBase.HasAtomicEvent) { isAtomic = new List <bool>(); isAtomic.Add(false); } List <string> participatingProcesses = new List <string>(); for (int i = 0; i < Processes.Count; i++) { if (Alphabets[i].Contains(evt)) { participatingProcesses.Add(i.ToString()); List <Configuration> steps = syncSteps[evt + Constants.SEPARATOR + i]; //Processes[i].MoveOneStep(eStep, evt); List <List <Process> > toAdd = new List <List <Process> >(moves.Count); foreach (Configuration step in steps) { //if it happens that a data operation shares the same name with the sync event, ignore if (!step.IsDataOperation) { if (moves[0].Count == i) { foreach (List <Process> list2 in moves) { list2.Add(step.Process); if (step.IsAtomic) { for (int j = 0; j < isAtomic.Count; j++) { isAtomic[j] = true; } } } } else { //If there non-determinism, clone and then add. for (int k = 0; k < moves.Count; k++) { List <Process> list2 = moves[k]; List <Process> newProcList = new List <Process>(); for (int j = 0; j < list2.Count - 1; j++) { newProcList.Add(list2[j]); } newProcList.Add(step.Process); toAdd.Add(newProcList); if (SpecificationBase.HasAtomicEvent) { if (!isAtomic[k]) { isAtomic.Add(step.IsAtomic); } else { isAtomic.Add(true); } } } } } } moves.AddRange(toAdd); } else { foreach (List <Process> move in moves) { move.Add(Processes[i]); } } } for (int i = 0; i < moves.Count; i++) { List <Process> list2 = moves[i]; IndexParallel para = new IndexParallel(list2, Alphabets); Configuration tmpStep = new Configuration(para, evt, null, GlobalEnv, false); if (SpecificationBase.HasAtomicEvent) { tmpStep.IsAtomic = isAtomic[i]; } if (AssertionBase.CalculateParticipatingProcess) { tmpStep.ParticipatingProcesses = participatingProcesses.ToArray(); } list.Add(tmpStep); } } //return returnList; }