public void AddParameterVariable(Model model)
{
if (Def.Parameters != null)
{
for (int i = 0; i < this.Def.Parameters.Length; i++)
{
string parameter = this.Def.Parameters[i];
int min = Model.BDD_INT_UPPER_BOUND;
int max = Model.BDD_INT_LOWER_BOUND;
if (this.Def.ParameterLowerBound.ContainsKey(parameter) && this.Def.ParameterUpperLowerBound.ContainsKey(parameter))
{
min = this.Def.ParameterLowerBound.GetContainsKey(parameter);
max = this.Def.ParameterUpperLowerBound.GetContainsKey(parameter);
}
else
{
ExpressionBDDEncoding argumentBDD = Args[i].TranslateIntExpToBDD(model);
foreach (CUDDNode argExp in argumentBDD.ExpressionDDs)
{
min = Math.Min(min, (int)CUDD.FindMinThreshold(argExp, Model.BDD_INT_LOWER_BOUND));
max = Math.Max(max, (int)CUDD.FindMaxThreshold(argExp, Model.BDD_INT_UPPER_BOUND));
}
}
//Also set the parameter as global variable to make sure that the parameters unchanged in encoding Transition
model.AddGlobalVar(parameter, min, max);
}
}
}
/// <summary>
/// [ REFS: traces, DEREFS: ]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="model"></param>
public void MCForTA(AutomataBDD automataBDD, Model model)
{
//Clear the old data
this.traces.Clear();
List <CUDDNode> allTransitions = new List <CUDDNode>(automataBDD.transitionBDD);
CUDDNode deadlockGoadDD = GetDeadlockDD(allTransitions, model);
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
this.VerificationOutput.VerificationResult = VerificationResultType.VALID;
}
else
{
CUDD.Ref(automataBDD.transitionBDD);
List <CUDDNode> discreteTrans = CUDD.Function.And(automataBDD.transitionBDD,
CUDD.Function.Not(AutomataBDD.GetTerminationTransEncoding(model)));
discreteTrans = CUDD.Abstract.ThereExists(discreteTrans, model.GetAllEventVars());
CUDD.Ref(automataBDD.Ticks);
List <CUDDNode> tickTrans = CUDD.Function.And(automataBDD.Ticks,
CUDD.Function.Not(AutomataBDD.GetTerminationTransEncoding(model)));
tickTrans = CUDD.Abstract.ThereExists(tickTrans, model.GetAllEventVars());
bool reachable = model.PathForTA(CUDD.Function.Or(initEncoding.GuardDDs), deadlockGoadDD, discreteTrans,
tickTrans, automataBDD.SimulationRel, SelectedEngineName);
CUDD.Deref(discreteTrans, tickTrans);
this.VerificationOutput.VerificationResult = (reachable) ? VerificationResultType.INVALID : VerificationResultType.VALID;
}
}
/// <summary>
/// Check whethere the goal can be reachable from the initial state of automataBDD
/// [ REFS: traces, DEREFS: ]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="goal"></param>
/// <param name="model"></param>
public void MCForTA(AutomataBDD automataBDD, Expression goal, Model model)
{
//Clear the old data
this.traces.Clear();
ExpressionBDDEncoding goalBddEncoding = goal.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
}
else
{
CUDDNode initDD = CUDD.Function.Or(initEncoding.GuardDDs);
CUDDNode goalDD = CUDD.Function.Or(goalBddEncoding.GuardDDs);
CUDD.Ref(automataBDD.transitionBDD);
List <CUDDNode> discreteTrans = CUDD.Abstract.ThereExists(automataBDD.transitionBDD, model.GetAllEventVars());
CUDD.Ref(automataBDD.Ticks);
List <CUDDNode> tickTrans = CUDD.Abstract.ThereExists(automataBDD.Ticks, model.GetAllEventVars());
bool reachable = model.PathForTA(initDD, goalDD, discreteTrans, tickTrans, automataBDD.SimulationRel,
SelectedEngineName);
CUDD.Deref(discreteTrans, tickTrans);
CUDD.Deref(initDD, goalDD);
VerificationOutput.VerificationResult = (reachable) ? VerificationResultType.VALID : VerificationResultType.INVALID;
}
}
/// <summary>
/// Encode transition with guard, update and unchangedVariables must be set as unchanged if they are not set in update.
/// [ REFS: 'result', DEREFS: '']
/// </summary>
/// <param name="guard">Guard of the transition</param>
/// <param name="update">Update command of the transition</param>
/// <param name="unchangedVariables">Set of variable which are needed to set unchanged if actually unchanged in the transition</param>
public List <CUDDNode> EncodeTransition(Expression guard, Expression update, List <int> unchangedVariables)
{
ExpressionBDDEncoding guardBddEncoding = guard.TranslateBoolExpToBDD(this);
ExpressionBDDEncoding updateBddEncoding = update.TranslateBoolExpToBDD(this);
//
List <CUDDNode> transitions = CUDD.Function.And(guardBddEncoding.GuardDDs, updateBddEncoding.GuardDDs);
return(AddVarUnchangedConstraint(transitions, unchangedVariables));
}
/// <summary>
/// Generate the counter example for LTL model checking, including 2 parts: prefix, and period.
/// [ REFS: '', DEREFS: automataBDD.transitionBDD, this.prefix, this.period ]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="encoder"></param>
/// <returns></returns>
public void GetMCResult(AutomataBDD automataBDD, BDDEncoder encoder)
{
VerificationOutput.CounterExampleTrace.Add(InitialStep);
if (VerificationOutput.VerificationResult == VerificationResultType.INVALID && VerificationOutput.GenerateCounterExample)
{
VerificationOutput.LoopIndex = this.prefix.Count + 1;
List <CUDDNode> traces = new List <CUDDNode>();
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(encoder.model);
traces.Add(CUDD.Function.Or(initEncoding.GuardDDs));
traces.AddRange(this.prefix);
traces.AddRange(this.period);
Valuation currentValuation = this.InitialStep.GlobalEnv;
Valuation lastValuation;
for (int i = 1; i < traces.Count; i++)
{
//Get event information
CUDD.Ref(traces[i], traces[i - 1]);
CUDDNode transitionTemp = CUDD.Function.And(traces[i - 1], encoder.model.SwapRowColVars(traces[i]));
CUDD.Ref(automataBDD.transitionBDD);
CUDDNode transWithEventInfo = CUDD.Function.And(transitionTemp, automataBDD.transitionBDD);
transWithEventInfo = CUDD.Abstract.ThereExists(transWithEventInfo, encoder.model.AllRowVarsExceptSingleCopy);
transWithEventInfo = CUDD.RestrictToFirst(transWithEventInfo, encoder.model.AllColVars);
lastValuation = currentValuation;
currentValuation = encoder.GetValuationFromBDD(transWithEventInfo, this.InitialStep.GlobalEnv);
string eventName = encoder.GetEventChannelName(lastValuation, currentValuation, transWithEventInfo);
VerificationOutput.CounterExampleTrace.Add(new ConfigurationBDD(eventName, currentValuation));
//
CUDD.Deref(transWithEventInfo);
}
//
CUDD.Deref(traces);
}
CUDD.Deref(automataBDD.transitionBDD);
VerificationOutput.ActualMemoryUsage = CUDD.ReadMemoryInUse();
VerificationOutput.numberOfBoolVars = encoder.model.NumberOfBoolVars;
encoder.model.Close();
}
/// <summary>
/// Add local variable including state, and parameters
/// Return the variable name encoding states
/// </summary>
/// <param name="encoder"></param>
public string AddLocalVariables(BDDEncoder encoder)
{
RenameLocalVars();
for (int i = 0; i < this.Parameters.Count; i++)
{
string parameter = this.Parameters[i];
int min = Model.BDD_INT_UPPER_BOUND;
int max = Model.BDD_INT_LOWER_BOUND;
if (ParameterUpperBound.ContainsKey(parameter) && ParameterLowerBound.ContainsKey(parameter))
{
min = ParameterLowerBound[parameter];
max = ParameterUpperBound[parameter];
}
else
{
ExpressionBDDEncoding argumentBDD = this.Arguments[i].TranslateIntExpToBDD(encoder.model);
foreach (CUDDNode argExp in argumentBDD.ExpressionDDs)
{
min = Math.Min(min, (int)CUDD.FindMinThreshold(argExp, Model.BDD_INT_LOWER_BOUND));
max = Math.Max(max, (int)CUDD.FindMaxThreshold(argExp, Model.BDD_INT_UPPER_BOUND));
}
}
//In its old transition encoding, we don't make sure this variable must be unchanged.
//We also need to add this variable to VaribleIndex of the AutomataBDD because previous process does not know this variable
//if global then later processes will set this variable as unchange.
encoder.model.AddLocalVar(parameter, min, max);
}
const string STATE = "state";
//
string processVariableName = Name + Model.NAME_SEPERATOR + STATE + Model.GetNewTempVarName();
encoder.model.AddLocalVar(processVariableName, 0, this.States.Count - 1);
//
encoder.stateIndexOfCurrentProcess = new Dictionary <string, int>();
//collect the state index
foreach (State state in this.States)
{
encoder.stateIndexOfCurrentProcess.Add(state.Name, encoder.stateIndexOfCurrentProcess.Count);
}
return(processVariableName);
}
/// <summary>
/// Run the model checking algorithm
/// [ REFS: prefix, period, DEREFS: modelBDD.transitionBDD, this.scc, this.eventMustHappen]
/// </summary>
/// <param name="intersection"></param>
/// <param name="modelBDD"></param>
/// <param name="model"></param>
public void FairMC(AutomataBDD intersection, AutomataBDD modelBDD, Model model)
{
ExpressionBDDEncoding initEncoding = intersection.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
return;
}
ExpressionBDDEncoding finalStateEncoding = intersection.acceptanceExpression.TranslateBoolExpToBDD(model);
if (finalStateEncoding.GuardDDs.Count == 0)
{
return;
}
CUDDNode initDD = CUDD.CUDD.Function.Or(initEncoding.GuardDDs);
CUDDNode finalDD = CUDD.CUDD.Function.Or(finalStateEncoding.GuardDDs);
CUDDNode finalStateWithNoEvent = CUDD.CUDD.Abstract.ThereExists(finalDD, model.GetAllEventVars());
CUDD.CUDD.Ref(intersection.transitionBDD);
this.transitionsNoEvents = CUDD.CUDD.Abstract.ThereExists(intersection.transitionBDD, model.GetAllEventVars());
CUDDNode allSCCs = SCCHull(model, initDD, finalStateWithNoEvent);
if (!allSCCs.Equals(CUDD.CUDD.ZERO))
{
//Pruning step: remove states whose predecessors are not belong to that set
while (true)
{
CUDD.CUDD.Ref(allSCCs, allSCCs);
CUDDNode temp = CUDD.CUDD.Function.And(allSCCs, model.Predecessors(allSCCs, this.transitionsNoEvents));
bool isSubSet = temp.Equals(allSCCs);
if (!isSubSet)
{
CUDD.CUDD.Deref(allSCCs);
allSCCs = temp;
}
else
{
CUDD.CUDD.Deref(temp);
break;
}
}
while (!allSCCs.Equals(CUDD.CUDD.ZERO))
{
CUDD.CUDD.Ref(allSCCs);
CUDDNode notInSCC = CUDD.CUDD.Function.Not(allSCCs);
CUDD.CUDD.Ref(this.transitionsNoEvents);
CUDD.CUDD.Ref(this.transitionsNoEvents);
CUDD.CUDD.Ref(notInSCC);//Kill notInSCC
List <CUDDNode> transitionNotInSCC = new List <CUDDNode>();
transitionNotInSCC.AddRange(CUDD.CUDD.Function.And(this.transitionsNoEvents, notInSCC));
transitionNotInSCC.AddRange(CUDD.CUDD.Function.And(this.transitionsNoEvents, model.SwapRowColVars(notInSCC)));
List <CUDDNode> path = new List <CUDDNode>();
model.Path(initDD, allSCCs, transitionNotInSCC, path, true, false);
prefix.AddRange(path);
//
CUDD.CUDD.Deref(transitionNotInSCC);
CUDD.CUDD.Ref(allSCCs, allSCCs);
CUDD.CUDD.Ref(this.transitionsNoEvents);
//Transitions inside all SCCs
List <CUDDNode> R = CUDD.CUDD.Function.And(CUDD.CUDD.Function.And(this.transitionsNoEvents, allSCCs), model.SwapRowColVars(allSCCs));
CUDDNode startStateOfCycle = (prefix.Count == 0) ? initDD : prefix[prefix.Count - 1];
CUDD.CUDD.Ref(startStateOfCycle);
//Find the scc if exists
CUDDNode scc = model.SCC(startStateOfCycle, R);
//
CUDD.CUDD.Deref(R);
if (!scc.Equals(CUDD.CUDD.ZERO))
{
//a new scc is found
if (IsFairScc(scc, intersection, modelBDD, model))
{
//
CUDD.CUDD.Deref(modelBDD.transitionBDD);
this.period.Add(startStateOfCycle);
BuildFairCounterExample(finalStateWithNoEvent, intersection, model);
break;
}
//
allSCCs = CUDD.CUDD.Function.Different(allSCCs, scc);
}
else
{
//
allSCCs = CUDD.CUDD.Function.Different(allSCCs, startStateOfCycle);
}
CUDD.CUDD.Deref(prefix);
prefix.Clear();
}
}
//
CUDD.CUDD.Deref(initDD, finalStateWithNoEvent, allSCCs);
CUDD.CUDD.Deref(this.transitionsNoEvents);
CUDD.CUDD.Deref(this.eventMustHappen, this.scc);
}
/// <summary>
/// Return a computation of a buchi automata in form "prefix (period)*"
/// [ REFS: 'prefix, period', DEREFS:]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="model"></param>
public void MC(AutomataBDD automataBDD, Model model)
{
//Clear the old data
this.transitionsNoEvents.Clear();
this.prefix.Clear();
this.period.Clear();
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
return;
}
ExpressionBDDEncoding finalStateEncoding = automataBDD.acceptanceExpression.TranslateBoolExpToBDD(model);
if (finalStateEncoding.GuardDDs.Count == 0)
{
return;
}
CUDDNode initState = CUDD.Function.Or(initEncoding.GuardDDs);
CUDDNode finalState = CUDD.Function.Or(finalStateEncoding.GuardDDs);
CUDDNode finalStateWithNoEvent = CUDD.Abstract.ThereExists(finalState, model.GetAllEventVars());
CUDD.Ref(automataBDD.transitionBDD);
this.transitionsNoEvents = CUDD.Abstract.ThereExists(automataBDD.transitionBDD, model.GetAllEventVars());
CUDDNode allSCCs = SCCHull(model, initState, finalStateWithNoEvent);
if (!allSCCs.Equals(CUDD.ZERO) && VerificationOutput.GenerateCounterExample)
{
this.VerificationOutput.VerificationResult = VerificationResultType.INVALID;
//Transitions out from allSCCs
CUDD.Ref(transitionsNoEvents);
CUDD.Ref(allSCCs);
List <CUDDNode> R = CUDD.Function.And(transitionsNoEvents, allSCCs);
//pick one state from the set final
CUDD.Ref(allSCCs);
CUDDNode s = CUDD.RestrictToFirst(allSCCs, model.AllRowVars);
//while the states from which we can reach s are not all states that can be reached from s
CUDDNode scc;
while (true)
{
CUDD.Ref(s);
CUDDNode backwardOfS = model.PredecessorsStart(s, R);
CUDD.Ref(s);
CUDDNode forwardOfS = model.SuccessorsStart(s, R);
//
CUDD.Ref(backwardOfS, forwardOfS);
CUDDNode temp = CUDD.Function.Different(backwardOfS, forwardOfS);
if (temp.Equals(CUDD.ZERO))
{
scc = backwardOfS;
CUDD.Deref(forwardOfS, temp);
break;
}
else
{
CUDD.Deref(backwardOfS, forwardOfS, s);
s = CUDD.RestrictToFirst(temp, model.AllRowVars);
}
}
//R now contains only transitions within the SCC scc
CUDD.Ref(scc, scc, scc, scc);
R[0] = CUDD.Function.And(CUDD.Function.And(R[0], scc), model.SwapRowColVars(scc));
R[1] = CUDD.Function.And(CUDD.Function.And(R[1], scc), model.SwapRowColVars(scc));
CUDD.Ref(scc);
CUDDNode notInSCC = CUDD.Function.Not(scc);
List <CUDDNode> transitionNotInSCC = new List <CUDDNode>();
CUDD.Ref(transitionsNoEvents, transitionsNoEvents);
CUDD.Ref(notInSCC, notInSCC);
transitionNotInSCC.AddRange(CUDD.Function.And(transitionsNoEvents, notInSCC));
transitionNotInSCC.AddRange(CUDD.Function.And(transitionsNoEvents, model.SwapRowColVars(notInSCC)));
//prefix is now a shortest path from an initial state to a state in final
model.Path(initState, scc, transitionNotInSCC, prefix, true);
CUDD.Deref(transitionNotInSCC[0], transitionNotInSCC[1]);
//Dummy value
period.Add((prefix.Count == 0) ? initState : prefix[prefix.Count - 1]);
//cycle must pass final state
CUDD.Ref(period);
CUDD.Ref(finalStateWithNoEvent);
CUDDNode temp1 = CUDD.Function.And(CUDD.Function.Or(period), finalStateWithNoEvent);
if (temp1.Equals(CUDD.ZERO))
{
CUDD.Ref(scc, finalStateWithNoEvent);
CUDDNode acceptanceStateInCyle = CUDD.Function.And(scc, finalStateWithNoEvent);
model.Path(period[period.Count - 1], acceptanceStateInCyle, R, period, true);
CUDD.Deref(acceptanceStateInCyle);
}
CUDD.Deref(temp1);
//
bool isEmptyPathAllowed = period.Count != 1;
model.Path(period[period.Count - 1], period[0], R, period, isEmptyPathAllowed);
//Remove dummy
CUDD.Deref(period[0]); period.RemoveAt(0);
//
CUDD.Deref(initState, finalStateWithNoEvent, allSCCs, s, scc, notInSCC);
CUDD.Deref(transitionsNoEvents[0], transitionsNoEvents[1]);
CUDD.Deref(R[0], R[1]);
}
else
{
this.VerificationOutput.VerificationResult = VerificationResultType.VALID;
CUDD.Deref(initState, finalStateWithNoEvent, allSCCs);
CUDD.Deref(transitionsNoEvents[0], transitionsNoEvents[1]);
}
}
