public override void Initialize(SpecificationBase spec)
{
//initialize the ModelCheckingOptions
base.Initialize(spec);
Specification Spec = spec as Specification;
ReachableStateCondition = Spec.DeclarationDatabase[ReachableStateLabel];
List<string> varList = Process.GetGlobalVariables();
varList.AddRange(ReachableStateCondition.GetVars());
varList.AddRange(ConstraintCondition.GetVars());
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels());
//Initialize InitialStep
InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
MustAbstract = Process.MustBeAbstracted();
if (MustAbstract)
{
throw new ParsingException(
"Process " + StartingProcess +
" has infinite states and therefore can not be used to assert reachability with MIN/MAX constraints!",
AssertToken);
}
}
public override void Initialize(SpecificationBase spec)
{
Specification Spec = spec as Specification;
List<string> varList = Process.GetGlobalVariables();
BA.Initialize(Spec.DeclarationDatabase);
foreach (KeyValuePair<string, Expression> pair in BA.DeclarationDatabase)
varList.AddRange(pair.Value.GetVars());
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels());
InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
MustAbstract = Process.MustBeAbstracted();
base.Initialize(spec);
}
public override void Initialize(SpecificationBase spec)
{
//initialize the ModelCheckingOptions
base.Initialize(spec);
Specification Spec = spec as Specification;
ReachableStateCondition = Spec.DeclarationDatabase[ReachableStateLabel];
List<string> varList = Process.GetGlobalVariables();
varList.AddRange(ReachableStateCondition.GetVars());
Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, Process.GetChannels());
//Initialize InitialStep
InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);
MustAbstract = Process.MustBeAbstracted();
}
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, GlobalEnv, false);
newStep.IsAtomic = vm.IsAtomic || p.IsAtomic;
if (AssertionBase.CalculateParticipatingProcess)
{
newStep.ParticipatingProcesses = new string[]{i.ToString(), k.ToString()};
}
returnList.Add(newStep);
}
}
}
}
}
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;
//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
{
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 (Specification.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;
}
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list)
{
System.Diagnostics.Debug.Assert(list.Count == 0);
bool allTerminationCount = true;
bool hasAtomicTermination = false;
for (int i = 0; i < Processes.Count; i++)
{
Process process = Processes[i];
List<Configuration> list1 = new List<Configuration>();
process.MoveOneStep(GlobalEnv, list1);
bool hasTermination = false;
for (int j = 0; j < list1.Count; j++)
{
Configuration step = list1[j];
if (step.Event == Constants.TERMINATION)
{
hasTermination = true;
if (step.IsAtomic)
{
hasAtomicTermination = true;
}
}
else
{
if (AssertionBase.CalculateParticipatingProcess)
{
step.ParticipatingProcesses = new string[] {i.ToString()};
}
List<Process> newProcess = new List<Process>(Processes.Count);
newProcess.AddRange(Processes);
newProcess[i] = step.Process;
IndexInterleave interleave = new IndexInterleave(newProcess);
step.Process = interleave;
list.Add(step);
}
}
//to check whether there are synchoronous channel input/output
if (Specification.HasSyncrhonousChannel)
{
SynchronousChannelInputOutput(list, i, GlobalEnv, null);
}
if (!hasTermination)
{
allTerminationCount = false;
}
}
if (allTerminationCount)
{
Configuration temp = new Configuration(new Stop(), Constants.TERMINATION, null, GlobalEnv, false);
if (hasAtomicTermination)
{
temp.IsAtomic = true;
}
if (AssertionBase.CalculateParticipatingProcess)
{
temp.ParticipatingProcesses = new string[Processes.Count];
for (int i = 0; i < Processes.Count; i++)
{
temp.ParticipatingProcesses[i] = i.ToString();
}
}
list.Add(temp);
}
//return returnList;
}
private void SynchronousChannelInputOutput(List<Configuration> returnList, int i, Valuation GlobalEnv, string evt)
{
List<ConfigurationWithChannelData> outputs = new List<ConfigurationWithChannelData>();
Processes[i].SyncOutput(GlobalEnv, outputs);
List<Dictionary<string, int>> nextProcessCounters1 =
Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter, Processes[i].ProcessID, 1);
foreach (ConfigurationWithChannelData vm in outputs)
{
if (evt != null & vm.Event != evt)
{
continue;
}
for (int k = 0; k < Processes.Count; k++)
{
string id = Processes[k].ProcessID;
if (k != i || (k == i && (ProcessesCounter[id] > 1 || ProcessesCounter[id] == -1)))
{
List<Configuration> syncedProcess = new List<Configuration>();
Processes[k].SyncInput(vm, syncedProcess);
if (syncedProcess.Count > 0)
{
if (k == i)
{
List<Dictionary<string, int>> nextProcessCountersInner =
Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter,
Processes[i].ProcessID, 2);
foreach (Configuration p in syncedProcess)
{
foreach (Dictionary<string, int> ints in nextProcessCountersInner)
{
Dictionary<string, int> dictionaryNew =
new Dictionary<string, int>(ints);
List<Process> newProcess = new List<Process>(Processes);
AddOneProcess(newProcess, p.Process, dictionaryNew);
AddOneProcess(newProcess, vm.Process, dictionaryNew);
Configuration newStep = new Configuration(new IndexInterleaveAbstract(newProcess, dictionaryNew), vm.Event,vm.DisplayName, GlobalEnv, false);
newStep.IsAtomic = vm.IsAtomic || p.IsAtomic;
if (AssertionBase.CalculateParticipatingProcess)
{
newStep.ParticipatingProcesses = new string[]
{
Processes[i].ProcessID,
Processes[k].ProcessID
};
}
returnList.Add(newStep);
}
}
}
else
{
foreach (Dictionary<string, int> ints in nextProcessCounters1)
{
List<Dictionary<string, int>> nextProcessCountersInner =
Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ints, id, 1);
foreach (Configuration p in syncedProcess)
{
foreach (Dictionary<string, int> dictionary in nextProcessCountersInner)
{
List<Process> newProcess = new List<Process>(Processes);
AddOneProcess(newProcess, p.Process, dictionary);
AddOneProcess(newProcess, vm.Process, dictionary);
Configuration newStep =
new Configuration(new IndexInterleaveAbstract(newProcess, dictionary),vm.Event, vm.DisplayName, GlobalEnv, false);
newStep.IsAtomic = vm.IsAtomic || p.IsAtomic;
if (AssertionBase.CalculateParticipatingProcess)
{
newStep.ParticipatingProcesses = new string[]
{
Processes[i].ProcessID,
Processes[k].ProcessID
};
}
returnList.Add(newStep);
}
}
}
}
}
}
}
}
}
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list)
{
System.Diagnostics.Debug.Assert(list.Count == 0);
int TerminationCount = 0;
bool hasAtomicTermination = false;
List<Dictionary<string, int>> nextProcessCounters = null;
for (int i = 0; i < Processes.Count; i++)
{
Process process = Processes[i];
List<Configuration> list1 = new List<Configuration>();
process.MoveOneStep(GlobalEnv, list1);
bool hasTermination = false;
if (list1.Count> 0)
{
nextProcessCounters = Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter, process.ProcessID, 1);
}
for (int j = 0; j < list1.Count; j++)
{
Configuration step = list1[j];
if (step.Event == Constants.TERMINATION)
{
hasTermination = true;
if (step.IsAtomic)
{
hasAtomicTermination = true;
}
}
else
{
foreach (Dictionary<string, int> ints in nextProcessCounters)
{
Dictionary<string, int> listInstance = new Dictionary<string, int>(ints);
List<Process> newProcess = new List<Process>(Processes);
AddOneProcess(newProcess, step.Process, listInstance);
IndexInterleaveAbstract interleave = new IndexInterleaveAbstract(newProcess, listInstance);
Configuration newStep = new Configuration(interleave, step.Event, step.DisplayName, step.GlobalEnv, step.IsDataOperation);
newStep.IsAtomic = step.IsAtomic;
if (AssertionBase.CalculateParticipatingProcess)
{
newStep.ParticipatingProcesses = new string[] { process.ProcessID };
}
list.Add(newStep);
}
}
}
if (hasTermination)
{
TerminationCount++;
}
//to check whether there are synchoronous channel input/output
if (Specification.HasSyncrhonousChannel)
{
SynchronousChannelInputOutput(list, i, GlobalEnv, null);
}
}
if (TerminationCount == Processes.Count)
{
Configuration temp = new Configuration(new Stop(), Constants.TERMINATION, null, GlobalEnv, false);
if(hasAtomicTermination)
{
temp.IsAtomic = true;
}
if (AssertionBase.CalculateParticipatingProcess)
{
temp.ParticipatingProcesses = new string[Processes.Count];
for (int i = 0; i < Processes.Count; i++)
{
temp.ParticipatingProcesses[i] = i.ToString();
}
}
list.Add(temp);
}
//return returnList;
}
public override void SyncInput(ConfigurationWithChannelData eStep, List<Configuration> list)
{
//List<Configuration> list = new List<Configuration>(1);
if (eStep.ChannelName == ChannelName && eStep.Expressions.Length == ExpressionList.Length)
{
Dictionary<string, Expression> mapping = new Dictionary<string, Expression>(eStep.Expressions.Length);
for (int i = 0; i < ExpressionList.Length; i++)
{
Expression v = eStep.Expressions[i];
if (ExpressionList[i] is Variable)
{
mapping.Add(ExpressionList[i].ExpressionID, v);
}
else
{
if (v.ExpressionID != ExpressionList[i].ExpressionID)
{
return ;
}
}
}
Expression guard = GuardExpression.ClearConstant(mapping);
ExpressionValue value = EvaluatorDenotational.Evaluate(guard, eStep.GlobalEnv);
if ((value as BoolConstant).Value)
{
Configuration vm;
if (mapping.Count > 0)
{
vm = new Configuration(Process.ClearConstant(mapping), null, null, eStep.GlobalEnv, false);
}
else
{
vm = new Configuration(Process, null, null, eStep.GlobalEnv, false);
}
list.Add(vm);
}
}
//return list;
}
public override void SyncInput(ConfigurationWithChannelData eStep, List<Configuration> list)
{
//List<Configuration> list = new List<Configuration>(1);
if (eStep.ChannelName == ChannelName && eStep.Expressions.Length == ExpressionList.Length)
{
Dictionary<string, Expression> mapping = new Dictionary<string, Expression>(eStep.Expressions.Length);
for (int i = 0; i < ExpressionList.Length; i++)
{
Expression v = eStep.Expressions[i];
if (ExpressionList[i] is Variable)
{
mapping.Add(ExpressionList[i].ExpressionID, v); //.GetID()
}
else
{
if (v.ExpressionID != ExpressionList[i].ExpressionID) //.GetID()
{
return ;
}
}
}
Configuration vm;
if (mapping.Count > 0)
{
vm = new Configuration(Process.ClearConstant(mapping), null, null, eStep.GlobalEnv, false);
}
else
{
vm = new Configuration(Process, null, null, eStep.GlobalEnv, false);
}
list.Add(vm);
}
//return list;
}