private static void InitInitialState(GeneNode automata,
AutomataBDD systemBDD,
List <string> letters)
{
HashSet <string> handledLetters = new HashSet <string>();
if (automata == null)
{
return;
}
int i = 0;
//// init is only based on first condition
//// that's why here their not "visit"
//automata.CurrentCondition.ToList()
// .Where(f => f.Value.HasValue).ToList().ForEach(f =>
// {
// Expression value = Value(f);
// var formatParameter = Formater.FormatParameter(f.Key, i);
// handledLetters.Add(formatParameter);
// var primitiveApplication = BddHelper.SetBooleanValue(i, f.Value.Value, f.Key);
// systemBDD.initExpression =
// new PrimitiveApplication(PrimitiveApplication.AND,
// systemBDD.initExpression,
// primitiveApplication);
// });
//i++;
logger.Info("init: " + systemBDD.initExpression);
}
/// <summary>
/// P.init: m0.init ^ clk = 0
/// </summary>
private static void DeadlineSetInit(string clk, AutomataBDD m0, AutomataBDD result)
{
result.initExpression = Expression.AND(m0.initExpression,
Expression.EQ(
new Variable(clk),
new IntConstant(0)));
}
private static void DeadlineEncodeTransitionChannel(string clk, AutomataBDD m0, int t, Model model, AutomataBDD result)
{
//1. (clk <= t) and m0.Trans/In/Out and [(event' = terminate and clk' = -1) or (event' != terminate and clk' = clk)]
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.LESS_EQUAL, new Variable(clk), new IntConstant(t)),
new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND,
AutomataBDD.GetTerminateTransExpression(),
new Assignment(clk, new IntConstant(-1))), new PrimitiveApplication(PrimitiveApplication.AND,
AutomataBDD.GetNotTerminateTransExpression(),
new Assignment(clk, new Variable(clk)))));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
List <CUDDNode> transTemp = CUDD.Function.And(m0.transitionBDD, guardDD);
result.transitionBDD.AddRange(transTemp);
//1. (clk <= t & clk' = clk & In/Out)
guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.LESS_EQUAL, new Variable(clk),
new IntConstant(t)),
new Assignment(clk, new Variable(clk)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.channelInTransitionBDD, guardDD);
result.channelInTransitionBDD.AddRange(transTemp);
//
//CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.channelOutTransitionBDD, guardDD);
result.channelOutTransitionBDD.AddRange(transTemp);
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD processAutomataBDD = this.Process.Encode(encoder);
//
return(AutomataBDD.Guard(this.Condition, processAutomataBDD, encoder.model));
}
/// <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>
/// [ 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;
}
}
private static void WithinEncodeTransitionChannel(string clk, AutomataBDD m0, int t, Model model, AutomataBDD result)
{
Expression guard;
List <CUDDNode> guardDD, transTemp;
//1. (clk <= t) and m0.Trans/In/Out and [(event' = tau and clk' = clk) or (event' != tau and clk' = -1)]
guard = Expression.AND(Expression.LE(new Variable(clk), new IntConstant(t)),
Expression.OR(Expression.AND(
AutomataBDD.GetTauTransExpression(),
new Assignment(clk, new Variable(clk))), Expression.AND(
AutomataBDD.GetNotTauTransExpression(),
new Assignment(clk, new IntConstant(-1)))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.transitionBDD, guardDD);
result.transitionBDD.AddRange(transTemp);
//
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.channelInTransitionBDD, guardDD);
result.channelInTransitionBDD.AddRange(transTemp);
//
//CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.channelOutTransitionBDD, guardDD);
result.channelOutTransitionBDD.AddRange(transTemp);
}
/// <summary>
/// Check whether scc is strong fairness.
/// [ REFS: , DEREFS: ]
/// </summary>
/// <param name="scc"></param>
/// <param name="intersection"></param>
/// <param name="modelBDD"></param>
/// <param name="model"></param>
/// <returns></returns>
private bool IsStrongFairness(CUDDNode scc, AutomataBDD intersection, AutomataBDD modelBDD, Model model)
{
CUDD.CUDD.Ref(modelBDD.transitionBDD);
CUDD.CUDD.Ref(scc);
List <CUDDNode> transitionFromSCC = CUDD.CUDD.Function.And(modelBDD.transitionBDD, scc);
CUDD.CUDD.Ref(intersection.transitionBDD);
CUDD.CUDD.Ref(scc, scc);
List <CUDDNode> transitionInSCC = CUDD.CUDD.Function.And(CUDD.CUDD.Function.And(intersection.transitionBDD, scc), model.SwapRowColVars(scc));
CUDDNode eventHappened = model.GetEventRowInTransition(transitionInSCC);
CUDDNode eventEnabled = model.GetEventRowInTransition(transitionFromSCC);
bool isStrongFairness = CUDD.CUDD.IsSubSet(eventHappened, eventEnabled);
if (isStrongFairness)
{
CUDD.CUDD.Ref(eventEnabled);
CUDD.CUDD.Deref(this.eventMustHappen);
this.eventMustHappen = eventEnabled;
CUDD.CUDD.Ref(scc);
CUDD.CUDD.Deref(this.scc);
this.scc = scc;
}
//
CUDD.CUDD.Deref(eventHappened, eventEnabled);
return(isStrongFairness);
}
public override void MakeDiscreteTransition(List <Expression> guards, List <Event> events, List <Expression> programBlocks, List <Process> processes, Model model, SymbolicLTS lts)
{
lts.AddParaInChannelAsLocalVar(ExpressionList);
if (model.mapChannelToSize.ContainsKey(ChannelName))
{
List <Expression> guardUpdateChannel = AutomataBDD.GetGuardUpdateOfChannelInput(this.ChannelName, new BoolConstant(true), new List <Expression>(ExpressionList), AssignmentExpr, model);
guardUpdateChannel[0] = Expression.AND(guardUpdateChannel[0], this.GuardExpression);
Event channelInput = new BDDEncoder.EventChannelInfo(this.ChannelName, 0, BDDEncoder.EventChannelInfo.EventType.ASYNC_CHANNEL_INPUT);
guards.Add(guardUpdateChannel[0]);
events.Add(channelInput);
programBlocks.Add(guardUpdateChannel[1]);
processes.Add(Process);
}
else
{
Event channelInput = new BDDEncoder.EventChannelInfo(this.ChannelName, 0, BDDEncoder.EventChannelInfo.EventType.SYNC_CHANNEL_INPUT);
channelInput.ExpressionList = this.ExpressionList;
guards.Add(null);
events.Add(channelInput);
programBlocks.Add(null);
processes.Add(Process);
}
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
AutomataBDD process2BDD = this.SecondProcess.Encode(encoder);
return(AutomataBDD.Sequence(process1BDD, process2BDD, encoder.model));
}
/// <summary>
/// Tick transition if done is false, don't need to add unchanged condition of other local variables.
/// They will be updated after the event becomes true
/// use the tick transition of P1 if done is true
/// </summary>
/// <param name="P1"></param>
/// <param name="model"></param>
/// <param name="result"></param>
public static void TauEventPrefixEncodeTick(Expression guardOfTick, AutomataBDD P1, Model model, AutomataBDD result)
{
Expression guard;
List <CUDDNode> guardDD;
//1. !done and guardOfTick and event = tick and !done'
if (!(guardOfTick is BoolConstant && !(guardOfTick as BoolConstant).Value))
{
guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(result.newLocalVarName),
new IntConstant(0)),
new PrimitiveApplication(PrimitiveApplication.AND,
guardOfTick,
new PrimitiveApplication(
PrimitiveApplication.AND,
AutomataBDD.
GetTerminateTransExpression
(),
new Assignment(
result.newLocalVarName,
new IntConstant(0)))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex);
result.Ticks.AddRange(guardDD);
}
//2. done and p1.Tick and done'
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(1)),
new Assignment(result.newLocalVarName, new IntConstant(0)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(guardDD, P1.Ticks);
result.Ticks.AddRange(guardDD);
}
/// <summary>
/// Create a new variable which know whether event is tick or not
/// Later all event information is removed from the transition
/// Return the justice based on that new varaible
/// justice: event = tick, event != tick
/// </summary>
/// <param name="modelBDD"></param>
/// <param name="model"></param>
/// <returns></returns>
public List <CUDDNode> GetJustices(AutomataBDD modelBDD, Model model)
{
model.AddLocalVar(EVENT_DUMMY, 0, 1);
//Because later event variables are removed, add new variable to check whether it is tick or not
Expression guard = Expression.OR(
Expression.AND(
TimeBehaviors.GetTickTransExpression(),
new Assignment(EVENT_DUMMY,
new IntConstant(1))),
Expression.AND(
TimeBehaviors.GetNotTickTransExpression(),
new Assignment(EVENT_DUMMY,
new IntConstant(0))));
modelBDD.transitionBDD = CUDD.Function.And(modelBDD.transitionBDD, guard.TranslateBoolExpToBDD(model).GuardDDs);
//the cycle must contain tick transition (zeno) and other transitions (progress)
List <CUDDNode> justices = new List <CUDDNode>();
guard = Expression.EQ(new Variable(EVENT_DUMMY),
new IntConstant(0));
justices.Add(CUDD.Function.Or(guard.TranslateBoolExpToBDD(model).GuardDDs));
guard = Expression.EQ(new Variable(EVENT_DUMMY),
new IntConstant(1));
justices.Add(CUDD.Function.Or(guard.TranslateBoolExpToBDD(model).GuardDDs));
return(justices);
}
private static void WaitUntilEncodeTick(string state, string isTerminate, AutomataBDD m0, int t, Model model, AutomataBDD result)
{
Expression guard;
List <CUDDNode> guardDD;
//1. m0.Tick and [(state < t and state' = state + 1) or (state = t and state' = t)] and isTerminate' = isTerminate
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.LESS, new Variable(state), new IntConstant(t)),
new Assignment(state, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(state), new IntConstant(1)))), new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(state), new IntConstant(t)),
new Assignment(state, new Variable(state)))),
new Assignment(isTerminate, new Variable(isTerminate)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(m0.Ticks, guardDD);
result.Ticks.AddRange(guardDD);
//2. isTerminate and state < t and event' = tick and isTerminate' and state' = state + 1
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(isTerminate), new IntConstant(1)),
new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.LESS, new Variable(state), new IntConstant(t)),
new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(Model.EVENT_NAME, new IntConstant(Model.TOCK_EVENT_INDEX)),
new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(isTerminate, new IntConstant(1)),
new Assignment(state, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(state), new IntConstant(1)))))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex);
guardDD = model.AddVarUnchangedConstraint(guardDD, result.variableIndex);
result.Ticks.AddRange(guardDD);
}
private static List <CUDDNode> IsExistPath(Expression goal1, BDDEncoder encoder,
List <CUDDNode> path,
CUDDNode initDD,
AutomataBDD systemBDD,
List <string> letters,
ref bool reach1)
{
CUDDNode goal1DD;
goal1DD = CUDD.Function.Or(goal1.TranslateBoolExpToBDD(encoder.model).GuardDDs);
path = new List <CUDDNode>();
reach1 = encoder.model.PathForward(initDD, goal1DD, new List <List <CUDDNode> >()
{
systemBDD.transitionBDD
}, path, false);
logger.Info("Finish run. Result is " + reach1);
#if DEBUG
StringBuilder builder = new StringBuilder();
PrintResult(builder, path, encoder, letters);
logger.Info(builder.ToString());
#endif
return(path);
}
/// <summary>
/// P.init: m0.init ^ clk = 0
/// </summary>
private static void DeadlineSetInit(string clk, AutomataBDD m0, AutomataBDD result)
{
result.initExpression = new PrimitiveApplication(PrimitiveApplication.AND, m0.initExpression,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(clk),
new IntConstant(0)));
}
/// <summary>
/// 1. Interrupt is not resolved, time evolution is synchronized
/// 2. P1 terminate, or P2 interrupt, not need synchronization
/// </summary>
/// <param name="P1"></param>
/// <param name="P2"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void InterruptEncodeTick(AutomataBDD P1, AutomataBDD P2, Model model, AutomataBDD result)
{
//1. (isInterrupted = 0 ∧ P1.Tick ∧ P2.Tick ∧ isInterrupted' = 0)
Expression guard = Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(0));
Expression update = new Assignment(result.newLocalVarName, new IntConstant(0));
List <CUDDNode> transition = model.EncodeTransition(guard, update, new List <int>());
CUDD.Ref(P2.Ticks);
transition = CUDD.Function.And(CUDD.Function.And(transition, P1.Ticks), P2.Ticks);
result.Ticks.AddRange(CUDD.Function.And(transition, P1.Ticks));
//2. (isInterrupted = 1 and P1.tick ∧ isInterrupted' = 1)
guard = Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(1));
update = new Assignment(result.newLocalVarName, new IntConstant(1));
transition = model.EncodeTransition(guard, update, new List <int>());
result.Ticks.AddRange(CUDD.Function.And(transition, P1.Ticks));
//3. (isInterrupted = 2 and P2.tick ∧ isInterrupted' = 2)
guard = Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(2));
update = new Assignment(result.newLocalVarName, new IntConstant(2));
transition = model.EncodeTransition(guard, update, new List <int>());
result.Ticks.AddRange(CUDD.Function.And(transition, P2.Ticks));
}
/// <summary>
/// Return AutomataBDD of the process which is composed of some choices
/// tick transition could not resolve the choice
/// </summary>
/// <param name="choices">List of AutomataBDD of choices</param>
/// <param name="tauEvent">Event' = Tau Event Index</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD IndexChoice(List <AutomataBDD> choices, Model model)
{
AutomataBDD result = AutomataBDD.Choice(choices, model);
IndexChoiceEncodeTick(choices, model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of the guard process
/// </summary>
/// <param name="guard">The guard expression of the process P1</param>
/// <param name="P1">AutomataBDD of the process P1</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Guard(Expression guard, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.Guard(guard, P1, model);
GuardEncodeTick(guard, P1, model, result);
//
return(result);
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
return(AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model));
}
/// <summary>
/// Return AutomataBDD of the process which is composed of some choices
/// tick transition could not resolve the choice
/// </summary>
/// <param name="choices">List of AutomataBDD of choices</param>
/// <param name="tauEvent">Event' = Tau Event Index</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD ExternalChoice(List <AutomataBDD> choices, Model model)
{
AutomataBDD result = AutomataBDD.ExternalChoice(choices, model);
ExternalChoiceEncodeTick(choices, model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of the Skip process
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Skip(Model model)
{
AutomataBDD result = AutomataBDD.Skip(model);
SkipEncodeTick(model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of interrupt process
/// </summary>
/// <param name="P1">AutomataBDD of interrupted process</param>
/// <param name="P2">AutomataBDD of interrupting process</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Interrupt(AutomataBDD P1, AutomataBDD P2, Model model)
{
AutomataBDD result = AutomataBDD.Interrupt(P1, P2, model);
InterruptEncodeTick(P1, P2, model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of the not tau event prefix process with guard [b] e -> P1
/// </summary>
/// <param name="guard"></param>
/// <param name="updateOfEvent">Update command happening with the event</param>
/// <param name="guardOfTick">Guard of the tick before engaging the event</param>
/// <param name="P1">AutomataBDD of the process P1 engaging after the event</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD EventPrefix(Expression guard, Expression updateOfEvent, Expression guardOfTick, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.EventPrefix(guard, updateOfEvent, P1, model);
EventPrefixEncodeTick(guardOfTick, P1, model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of the tau event prefix process with guard [b] tau -> P1.
/// </summary>
/// <param name="guard">Guard of the event</param>
/// <param name="tauEventExp">Update command happening with the event</param>
/// <param name="guardOfTick">guard of tick idling at the initial state</param>
/// <param name="P1">AutomataBDD of the process P1 engaging after the event</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD TauEventPrefix(Expression guard, Expression tauEventExp, Expression guardOfTick, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.EventPrefix(guard, tauEventExp, P1, model);
TauEventPrefixEncodeTick(guardOfTick, P1, model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of Parallel process.
/// Note: synchronized is created by AND of transition of participant process. Therefore this only happens when the transition does not change any global variable
/// because when encoding transition, each transition will make variable unchanged if it is not updated in that transition. This synchronization is similar to
/// Explicit model checking when does not allow synchronized transition having program block.
/// </summary>
/// <param name="processes">List of AutomataBDD of parallel processes</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Parallel(List <AutomataBDD> processes, List <CUDDNode> alphabets, Model model)
{
AutomataBDD result = AutomataBDD.Parallel(processes, alphabets, model);
ParallelEncodeTick(processes, model, result);
//
return(result);
}
/// <summary>
/// Check whether scc is strong fairness.
/// [ REFS: , DEREFS: ]
/// </summary>
/// <param name="scc"></param>
/// <param name="intersection"></param>
/// <param name="modelBDD"></param>
/// <param name="model"></param>
/// <returns></returns>
private bool IsWeakFairness(CUDDNode scc, AutomataBDD intersection, AutomataBDD modelBDD, Model model)
{
CUDD.CUDD.Ref(intersection.transitionBDD);
CUDD.CUDD.Ref(scc, scc);
List <CUDDNode> transitionInSCC = CUDD.CUDD.Function.And(CUDD.CUDD.Function.And(intersection.transitionBDD, scc), model.SwapRowColVars(scc));
CUDDNode eventHappened = model.GetEventRowInTransition(transitionInSCC);
//-----------------------------------
CUDD.CUDD.Ref(modelBDD.transitionBDD);
CUDD.CUDD.Ref(scc);
List <CUDDNode> transitionFromSCC = CUDD.CUDD.Function.And(modelBDD.transitionBDD, scc);
CUDD.CUDD.Ref(transitionFromSCC);
CUDDNode eventEnabled = model.GetEventRowInTransition(transitionFromSCC);
//Get all the combination of state in scc and event
CUDD.CUDD.Ref(scc, eventEnabled);
CUDDNode complementTransitionFromSCC = CUDD.CUDD.Function.And(scc, model.SwapRowColVars(eventEnabled));
//
CUDDVars varsTemp = new CUDDVars();
varsTemp.AddVars(model.AllColVars);
varsTemp.RemoveVars(model.GetEventColVars());
//Get the source state (in scc) and event
transitionFromSCC = CUDD.CUDD.Abstract.ThereExists(transitionFromSCC, varsTemp);
complementTransitionFromSCC = CUDD.CUDD.Function.Different(complementTransitionFromSCC, CUDD.CUDD.Function.Or(transitionFromSCC));
CUDDNode eventNotAllEnabled = model.GetEventRowInTransition(new List <CUDDNode> {
complementTransitionFromSCC
});
CUDDNode eventAllEnabled = CUDD.CUDD.Function.Different(eventEnabled, eventNotAllEnabled);
bool isWeakFairness = CUDD.CUDD.IsSubSet(eventHappened, eventAllEnabled);
if (isWeakFairness)
{
//Must assign this.eventMushHappen to eventHappened to make sure that all enabled events will happen.
//In some case though the eventAllEnable is empty but if this.evenMustHappen = eventAllEnable, the scc is not restricted
//and a small part of this scc is explored, so in this small part, the eventAllEnable may be not empty.
CUDD.CUDD.Ref(eventHappened);
CUDD.CUDD.Deref(this.eventMustHappen);
this.eventMustHappen = eventHappened;
CUDD.CUDD.Ref(scc);
CUDD.CUDD.Deref(this.scc);
this.scc = scc;
}
//
CUDD.CUDD.Deref(eventHappened, eventAllEnabled);
return(isWeakFairness);
}
private static void TimeoutEncodeTransitionChannel(string clk, AutomataBDD m0, AutomataBDD m1, int t, Model model, AutomataBDD result)
{
Expression guard;
List <CUDDNode> guardDD, transTemp;
//1. (clk <= t) and m0.Trans/In/Out and [(event' = tau and clk' = clk) or (event' != tau and clk' = -1)]
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.LESS_EQUAL, new Variable(clk), new IntConstant(t)),
new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND,
AutomataBDD.GetTauTransExpression(),
new Assignment(clk, new Variable(clk))), new PrimitiveApplication(PrimitiveApplication.AND,
AutomataBDD.GetNotTauTransExpression(),
new Assignment(clk, new IntConstant(-1)))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.transitionBDD, guardDD);
result.transitionBDD.AddRange(transTemp);
//
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.channelInTransitionBDD, guardDD);
result.channelInTransitionBDD.AddRange(transTemp);
//
//CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m0.channelOutTransitionBDD, guardDD);
result.channelOutTransitionBDD.AddRange(transTemp);
//2. clk = t and event' = tau and clk' = t + 1 and m1.Init
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(clk), new IntConstant(t)),
new PrimitiveApplication(PrimitiveApplication.AND, AutomataBDD.GetTauTransExpression(),
new Assignment(clk, new IntConstant(t + 1))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(m1.GetInitInColumn(model), CUDD.Function.Or(guardDD));
guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex);
result.transitionBDD.AddRange(guardDD);
//3. clk = t + 1 and m1.Trans and clk' = t + 1
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(clk), new IntConstant(t + 1)),
new Assignment(clk, new IntConstant(t + 1)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m1.transitionBDD, guardDD);
result.transitionBDD.AddRange(guardDD);
//
CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m1.channelInTransitionBDD, guardDD);
result.channelInTransitionBDD.AddRange(guardDD);
//
//CUDD.Ref(guardDD);
transTemp = CUDD.Function.And(m1.channelOutTransitionBDD, guardDD);
result.channelOutTransitionBDD.AddRange(guardDD);
}
/// <summary>
/// Return the AutomataBDD of the Channel Input
/// </summary>
/// <param name="channelName">Channel's name</param>
/// <param name="channelEventIndex"></param>
/// <param name="guard">Guard expression of the channel input</param>
/// <param name="exps">List of input expression to the channel</param>
/// <param name="guardOfTick"></param>
/// <param name="P1">AutomataBDD of process P1 after the channel input</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD SyncChannelInputPrefixing(int channelEventIndex, Expression guard, List <Expression> exps, Expression guardOfTick, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.SyncChannelInputPrefixing(channelEventIndex, guard, exps, P1, model);
EventPrefixEncodeTick(guardOfTick, P1, model, result);
//
return(result);
}
/// <summary>
/// Return AutomataBDD of Interleave process
/// </summary>
/// <param name="processes">List of AutomataBDD of interleaving processes</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Interleave(List <AutomataBDD> processes, Model model)
{
AutomataBDD result = AutomataBDD.Interleave(processes, model);
ParallelEncodeTick(processes, model, result);
//
return(result);
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD processAutomataBDD = this.Process.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(this.Event);
//
return(AutomataBDD.EventPrefix(new BoolConstant(true), eventUpdateExpression, processAutomataBDD, encoder.model));
}