/// <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>
/// 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 = new PrimitiveApplication(PrimitiveApplication.EQUAL, 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 = new PrimitiveApplication(PrimitiveApplication.EQUAL, 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 = new PrimitiveApplication(PrimitiveApplication.EQUAL, 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));
}
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 static void Test1()
{
int length = 100;
int loop = 1;
Valuation valuation = new Valuation();
Expression exp = new IntConstant(1);
for (int i = 0; i < length; i++)
{
exp = new PrimitiveApplication(PrimitiveApplication.PLUS, exp, new IntConstant(1));
}
Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond);
for (int i = 0; i < loop; i++)
{
EvaluatorDenotational.Evaluate(exp, valuation);
}
Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond);
DynamicMethod method = GetDynamicMethodOfExpression(exp);
for (int i = 0; i < loop; i++)
{
method.Invoke(null, null);
}
Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond);
Console.WriteLine("---------------------");
//---------------------------------------------------
exp = new Variable(var1);
for (int i = 0; i < length; i++)
{
exp = new PrimitiveApplication(PrimitiveApplication.PLUS, exp, new Variable(var1));
}
valuation.Variables = new StringDictionaryWithKey <ExpressionValue>();
valuation.Variables.Add(var1, new IntConstant(1));
Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond);
for (int i = 0; i < loop; i++)
{
EvaluatorDenotational.Evaluate(exp, valuation);
}
Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond);
method = GetDynamicMethodOfExpression(exp);
for (int i = 0; i < loop; i++)
{
UpdateVarsBasedOnValuation(valuation);
object value = method.Invoke(null, null);
Console.WriteLine(value);
UpdateValuationBasedOnClassValues(valuation);
}
Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond);
}
/// <summary>
///
/// </summary>
/// <param name="encoder"></param>
/// <param name="processVariableName"></param>
/// <param name="localVars">Local of the current SymbolicLTS is unchanged</param>
/// <returns></returns>
public List <CUDDNode> EncodeSyncChannelInTransition(BDDEncoder encoder, string processVariableName, List <int> localVars)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(processVariableName), new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromState.Name]));
guard = Expression.CombineGuard(guard, GuardCondition);
List <Expression> parameters = encoder.GetParaExpInEvent(this.Event);
int channelEventIndex = encoder.GetEventIndex(this.Event.BaseName, parameters.Count);
guard = new PrimitiveApplication(PrimitiveApplication.AND, guard, new Assignment(Model.EVENT_NAME, new IntConstant(channelEventIndex)));
guard = new PrimitiveApplication(PrimitiveApplication.AND, guard, new Assignment(processVariableName, new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToState.Name])));
//channel input has not program block
for (int i = 0; i < parameters.Count; i++)
{
if (parameters[i] is IntConstant)
{
//eventParameterVariables[i]' = exps[i]
guard = new PrimitiveApplication(PrimitiveApplication.AND, guard, new Assignment(encoder.model.eventParameterVariables[i], parameters[i]));
}
else
{
//eventParameterVariables[i]' = exps[i]'
guard = new PrimitiveApplication(PrimitiveApplication.AND, guard,
new PrimitiveApplication(PrimitiveApplication.EQUAL, new VariablePrime(encoder.model.eventParameterVariables[i]),
new VariablePrime(parameters[i].expressionID)));
}
}
List <CUDDNode> transitions = guard.TranslateBoolExpToBDD(encoder.model).GuardDDs;
return(encoder.model.AddVarUnchangedConstraint(transitions, localVars));
}
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 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);
}
private static Expression CreateFunctionApplication(
Dictionary <string, List <int> > availableFunctions,
IEnumerable <IGrouping <string, GeneLink> > toDictionary,
int i,
Mode mode,
Dictionary <string, bool> values)
{
Expression res = null;
toDictionary.ToList().ForEach(ff =>
{
Expression ass = null;
var to = ff.Key;
var froms = ff.Where(a => !a.IsOptional).ToList();
// can be null!!
if (availableFunctions == null || !availableFunctions.ContainsKey(to))
{
res = AddIfExist(res, CreateAssignment(ff.FirstOrDefault(), i, GetFunction(mode)), mode);
}
else
{
var availableFunc = availableFunctions[to];
var funcAssignmentHelper = new FuncAssignmentHelper();
var toFormatted = Formater.FormatParameter(to, i + 1);
availableFunc.ForEach(f =>
{
ass =
funcAssignmentHelper.CreateFuncAssignment(to, froms, i, f);
//if (values != null && values.ContainsKey(toFormatted))
//{
// ass = new PrimitiveApplication(PrimitiveApplication.AND, ass, new BoolConstant(values[toFormatted]));
// values.Remove(toFormatted);
//}
});
if (mode == Mode.Equal)
{
res = new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(toFormatted),
ass);
}
else
{
res = GetFunction(mode).Invoke(toFormatted, ass);
}
}
});
return(res);
}
/// <summary>
/// [ REFS: '', DEREFS: 'P1, P2']
/// </summary>
/// <param name="isP1Terminate"></param>
/// <param name="P1"></param>
/// <param name="P2"></param>
/// <param name="model"></param>
/// <param name="result"></param>
public static void SequenceEncodeTransition(string isP1Terminate, AutomataBDD P1, AutomataBDD P2, Model model, AutomataBDD result)
{
CUDDNode tauEvent = GetTauTransEncoding(model);
CUDDNode terminateEvent = GetTerminationTransEncoding(model);
CUDD.Ref(terminateEvent);
CUDD.Ref(P1.transitionBDD);
List <CUDDNode> notTerminateTransition = CUDD.Function.And(P1.transitionBDD, CUDD.Function.Not(terminateEvent));
//CUDD.Ref(terminateEvent);
//CUDD.Ref(P1.transitionBDD);
List <CUDDNode> terminateTransition = CUDD.Function.And(P1.transitionBDD, terminateEvent);
//Convert terminate transition to tau transition
terminateTransition = CUDD.Abstract.ThereExists(terminateTransition, model.GetAllEventVars());
terminateTransition = CUDD.Function.And(terminateTransition, tauEvent);
//1. !isP1Terminate and not terminate transition, channel and !isP1Terminate
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(isP1Terminate), new IntConstant(0)),
new Assignment(isP1Terminate, new IntConstant(0)));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(guardDD);
result.transitionBDD.AddRange(CUDD.Function.And(guardDD, notTerminateTransition));
CUDD.Ref(guardDD);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelInTransitionBDD));
// CUDD.Ref(guardDD);
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelOutTransitionBDD));
//2. (!isP1Terminate ∧ terminate P1.transition ∧ isP1Terminate' and P2.Init')
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(isP1Terminate), new IntConstant(0)),
new Assignment(isP1Terminate, new IntConstant(1)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(guardDD, P2.GetInitInColumn(model));
result.transitionBDD.AddRange(CUDD.Function.And(guardDD, terminateTransition));
//3. (isP1Terminate ∧ P2.Trans/In/Out ∧ isP1Terminate')
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(isP1Terminate), new IntConstant(1)),
new Assignment(isP1Terminate, new IntConstant(1)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(guardDD);
result.transitionBDD.AddRange(CUDD.Function.And(guardDD, P2.transitionBDD));
CUDD.Ref(guardDD);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P2.channelInTransitionBDD));
//CUDD.Ref(guardDD);
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P2.channelOutTransitionBDD));
}
private static void SkipEncodeTick(Model model, AutomataBDD result)
{
//2. state = 0 & event' = tick & state = 0
//3. state = 1 & event' = tick & state = 1
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, GetTickTransExpression(),
new Assignment(result.newLocalVarName, new Variable(result.newLocalVarName)));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex);
result.Ticks.AddRange(guardDD);
}
private CUDDNode EncodePrimitive(PrimitiveApplication exp)
{
if (exp.Argument2 != null)
{
return(EncodeBinary(exp));
}
else
{
return(EncodeUnary(exp));
}
}
/// <summary>
/// choice = i and Tick.i and choice' = i
/// </summary>
/// <param name="choices"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void ResolvedChoiceEncodeTick(List <AutomataBDD> choices, Model model, AutomataBDD result)
{
//2. choice = i and Tick.i and choice' = i
for (int i = 0; i < choices.Count; i++)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(i)),
new Assignment(result.newLocalVarName, new IntConstant(i)));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(guardDD, choices[i].Ticks);
result.Ticks.AddRange(guardDD);
}
}
/// <summary>
/// (!temp ∧ event ' = terminate ∧ temp ')
/// </summary>
private static void SkipEncodeTransition(Model model, AutomataBDD result)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(
PrimitiveApplication.EQUAL,
new Variable(result.newLocalVarName),
new IntConstant(0)),
GetTerminateTransExpression()),
new Assignment(result.newLocalVarName, new IntConstant(1)));
result.transitionBDD.AddRange(model.AddVarUnchangedConstraint(guard.TranslateBoolExpToBDD(model).GuardDDs, model.GlobalVarIndex));
}
private static void WaitEncodeTransitionChannel(string state, int t, Model model, AutomataBDD result)
{
//1. state = t and event' = terminate and state' = t + 1
Expression guard;
List <CUDDNode> guardDD;
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(state), new IntConstant(t)),
new PrimitiveApplication(PrimitiveApplication.AND, AutomataBDD.GetTerminateTransExpression(),
new Assignment(state, new IntConstant(t + 1))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex);
result.transitionBDD.AddRange(guardDD);
}
private static Expression SetGoalBasedOnFunction(List <GeneLink> booleanNetwok,
Dictionary <string, List <int> > availableFunctions, int depth)
{
Expression seq = null;
var toDictionary = booleanNetwok.GroupBy(a => a.To);
for (int i = 0; i < depth - 1; i++)
{
Expression ass = null;
toDictionary.ToList().ForEach(ff =>
{
var b = ff.FirstOrDefault();
var from = Formater.FormatParameter(b.From, i);
var to = Formater.FormatParameter(b.To, i + 1);
if (b.IsPositive)
{
//ass = new Assignment(b.To,
// new Variable(b.From));
ass = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(to), new Variable(from));
}
else
{
ass = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(to),
new PrimitiveApplication(
PrimitiveApplication.AND, new PrimitiveApplication(nOT, new Variable(from))));
}
if (seq == null)
{
seq = ass;
}
else
{
seq =
new PrimitiveApplication(PrimitiveApplication.AND,
seq,
ass);
}
});
}
return(seq);
}
private static void WaitUntilEncodeTransitionChannel(string state, string isTerminate, AutomataBDD m0, int t, Model model, AutomataBDD result)
{
Expression guard;
List <CUDDNode> guardDD, transTemp;
//1. m0.Trans/In/Out and state' = state and [(event' = terminate and isTerminate') or (event' != terminate and isTerminate' = isTerminate)]
guard = new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(state, new Variable(state)),
new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND,
new Assignment(Model.EVENT_NAME, new IntConstant(Model.TERMINATE_EVENT_INDEX)),
new Assignment(isTerminate, new IntConstant(1))), new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.NOT, new Assignment(Model.EVENT_NAME, new IntConstant(Model.TERMINATE_EVENT_INDEX))),
new Assignment(isTerminate, new Variable(isTerminate)))));
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. isTerminate and state = t and event' = terminate and isTermniate' & state = t + 1
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(isTerminate), new IntConstant(1)),
new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(state), new IntConstant(t)),
new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(Model.EVENT_NAME, new IntConstant(Model.TERMINATE_EVENT_INDEX)),
new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(isTerminate, new IntConstant(1)),
new Assignment(state, new IntConstant(t + 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>
/// tau transition in process 2 does not resolve
/// [ REFS: '', DEREFS: 'P1, P2']
/// </summary>
/// <param name="P1"></param>
/// <param name="P2"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void InterruptEncodeTransition(AutomataBDD P1, AutomataBDD P2, Model model, AutomataBDD result)
{
//1. (isInterrupted < 2 ∧ P1.Trans/In/Out ∧ [(event' = termination and isInterrupted' = 1) or (event' != termination and isInterrupted' = isInterrupted)] P2.var = P2.var')
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.LESS, new Variable(result.newLocalVarName), new IntConstant(2)),
new PrimitiveApplication(PrimitiveApplication.OR,
new PrimitiveApplication(PrimitiveApplication.AND,
GetTerminateTransExpression(),
new Assignment(result.newLocalVarName, new IntConstant(1))),
new PrimitiveApplication(PrimitiveApplication.AND,
GetNotTerminateTransExpression(),
new Assignment(result.newLocalVarName, new Variable(result.newLocalVarName))))
);
List <CUDDNode> transition = guard.TranslateBoolExpToBDD(model).GuardDDs;
transition = model.AddVarUnchangedConstraint(transition, P2.variableIndex);
//
CUDD.Ref(transition);
result.transitionBDD.AddRange(CUDD.Function.And(transition, P1.transitionBDD));
CUDD.Ref(transition);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, P1.channelInTransitionBDD));
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, P1.channelOutTransitionBDD));
//2. (isInterrupted != 1 ∧ P2.Trans/In/Out ∧ [(event' = tau and isInterrupted' = isInterrupted) or (event' != tau and isInterrupted' = 2)])
guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.NOT_EQUAL, new Variable(result.newLocalVarName), new IntConstant(1)),
new PrimitiveApplication(PrimitiveApplication.OR,
new PrimitiveApplication(PrimitiveApplication.AND,
GetTauTransExpression(),
new Assignment(result.newLocalVarName, new Variable(result.newLocalVarName))),
new PrimitiveApplication(PrimitiveApplication.AND,
GetNotTauTransExpression(),
new Assignment(result.newLocalVarName, new IntConstant(2))))
);
transition = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(transition);
result.transitionBDD.AddRange(CUDD.Function.And(transition, P2.transitionBDD));
CUDD.Ref(transition);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, P2.channelInTransitionBDD));
//CUDD.Ref(transition);
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, P2.channelOutTransitionBDD));
}
/// <summary>
/// (!temp ∧ guard∧ ∧ update ∧ temp ' ∧ P1.init)
/// </summary>
private static void EventPrefixTransitition(Expression guardOfTrans, Expression updateOfTrans, AutomataBDD P1, Model model, AutomataBDD result)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(0)),
guardOfTrans);
Expression update = new Sequence(updateOfTrans, new Assignment(result.newLocalVarName, new IntConstant(1)));
List <CUDDNode> transition = model.EncodeTransition(guard, update, new List <int>());
transition = CUDD.Function.And(transition, P1.GetInitInColumn(model));
transition = model.AddVarUnchangedConstraint(transition, model.GlobalVarIndex);
result.transitionBDD.AddRange(transition);
}
/// <summary>
/// (temp ∧ P1.Trans/In/Out ∧ temp')
/// [ REFS: '', DEREFS: 'P1']
/// </summary>
private static void CopyTransitionAfterEventChannel(AutomataBDD P1, Model model, AutomataBDD result)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(1)),
new Assignment(result.newLocalVarName, new IntConstant(1)));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(guardDD);
result.transitionBDD.AddRange(CUDD.Function.And(guardDD, P1.transitionBDD));
CUDD.Ref(guardDD);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelInTransitionBDD));
//CUDD.Ref(guardDD);
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelOutTransitionBDD));
}
private static void WithinEncodeTick(string clk, AutomataBDD m0, int t, Model model, AutomataBDD result)
{
Expression guard;
List <CUDDNode> guardDD;
//1. m0.Tick and [(clk >= 0 and clk < t and clk' = clk + 1) or (clk = -1 and clk' = -1)]
guard = new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.GREATER_EQUAL, new Variable(clk), new IntConstant(0)),
new PrimitiveApplication(PrimitiveApplication.LESS, new Variable(clk), new IntConstant(t))),
new Assignment(clk, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(clk), new IntConstant(1)))), new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(clk), new IntConstant(-1)),
new Assignment(clk, new IntConstant(-1))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(m0.Ticks, guardDD);
result.Ticks.AddRange(guardDD);
}
/// <summary>
/// Test evaluate expression without reading variable value
/// </summary>
private static void Test()
{
Expression exp;
ExpressionValue value;
int valueOfVar = 0;
exp = new PrimitiveApplication(PrimitiveApplication.PLUS, new PrimitiveApplication(PrimitiveApplication.TIMES, new IntConstant(2), new IntConstant(3)),
new IntConstant(4));
value = EvaluateExpression(exp);
Console.WriteLine(value.ExpressionID);
//
exp = new Variable(var1);
value = EvaluateExpression(exp);
Console.WriteLine(value.ExpressionID);
//
exp = new Sequence(new Assignment(var1, new IntConstant(10)), new Variable(var1));
value = EvaluateExpression(exp);
Console.WriteLine(value.ExpressionID);
//
exp = new Sequence(new Assignment(var1, new IntConstant(10)), new Variable(var1));
SetValue(var1, 5);
valueOfVar = (int)GetValue(var1);
value = EvaluateExpression(exp);
valueOfVar = (int)GetValue(var1);
Console.WriteLine(value.ExpressionID);
Console.WriteLine(valueOfVar);
//
exp = new Sequence(new Assignment(var1, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(var1), new IntConstant(10))), new Variable(var1));
SetValue(var1, 5);
value = EvaluateExpression(exp);
valueOfVar = (int)GetValue(var1);
Console.WriteLine(value.ExpressionID);
Console.WriteLine(valueOfVar);
//
exp = new Sequence(new PropertyAssignment(new Variable(var2), new IntConstant(0),
new PrimitiveApplication(PrimitiveApplication.PLUS, new PrimitiveApplication(PrimitiveApplication.ARRAY, new Variable(var2), new IntConstant(0))
, new IntConstant(10))), new PrimitiveApplication(PrimitiveApplication.ARRAY, new Variable(var2), new IntConstant(0)));
SetValue(var2, new int[2] {
20, 30
});
value = EvaluateExpression(exp);
int[] temp = (int[])GetValue(var2);
Console.WriteLine(value.ExpressionID);
Console.WriteLine(temp);
}
/// <summary>
/// [ REFS: '', DEREFS: 'P1']
/// </summary>
/// <param name="b"></param>
/// <param name="P1"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void GuardEncodeTransition(Expression b, AutomataBDD P1, Model model, AutomataBDD result)
{
//(P1.Trans/In/Out and [(b and !temp and temp') or (temp and temp')]
Expression guard = new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND, b,
new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.NOT, new Variable(result.newLocalVarName)),
new Assignment(result.newLocalVarName, new IntConstant(1)))), new PrimitiveApplication(PrimitiveApplication.AND,
new Variable(result.newLocalVarName), new Assignment(result.newLocalVarName, new IntConstant(1))));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
CUDD.Ref(guardDD);
result.transitionBDD.AddRange(CUDD.Function.And(guardDD, P1.transitionBDD));
CUDD.Ref(guardDD);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelInTransitionBDD));
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelOutTransitionBDD));
}
/// <summary>
/// Note that this is different from EventPrefixEncodeTick because it need to make sure local variable unchanged
/// </summary>
/// <param name="P1"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void GuardEncodeTick(Expression guard1, AutomataBDD P1, Model model, AutomataBDD result)
{
//allow time evolution when the guard is not resolved
//temp = 0 and P1.init and not (b and P1.init and event = tau and P1.transition) and event = tick and temp = 0
Expression exp;
List <CUDDNode> expDD;
exp = new PrimitiveApplication(PrimitiveApplication.AND, guard1,
new PrimitiveApplication(PrimitiveApplication.AND, P1.initExpression,
AutomataBDD.GetTauTransExpression()));
expDD = exp.TranslateBoolExpToBDD(model).GuardDDs;
CUDD.Ref(P1.transitionBDD);
expDD = CUDD.Function.And(expDD, P1.transitionBDD);
//find state where b is true and tau is enable
expDD = CUDD.Abstract.ThereExists(expDD, model.AllColVars);
CUDDNode tauIsNotEnabled = CUDD.Function.Not(expDD);
exp = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(
PrimitiveApplication.EQUAL,
new Variable(result.newLocalVarName),
new IntConstant(0)),
P1.initExpression),
GetTickTransExpression());
expDD = exp.TranslateBoolExpToBDD(model).GuardDDs;
expDD = CUDD.Function.And(expDD, tauIsNotEnabled);
expDD = model.AddVarUnchangedConstraint(expDD, model.GlobalVarIndex);
expDD = model.AddVarUnchangedConstraint(expDD, result.variableIndex);
result.Ticks.AddRange(expDD);
//temp & P1.tick & temp'
exp = new PrimitiveApplication(PrimitiveApplication.AND,
new Variable(result.newLocalVarName), new Assignment(result.newLocalVarName, new IntConstant(1)));
expDD = exp.TranslateBoolExpToBDD(model).GuardDDs;
expDD = CUDD.Function.And(P1.Ticks, expDD);
result.Ticks.AddRange(expDD);
}
private static Expression SetGoalsBasedOnAutomata(GeneNode automata)
{
Expression goal1 = null;
if (automata == null || automata.Transitions == null || !automata.Transitions.Any())
{
return(null);
}
int i = 0;
automata.Visit(l =>
{
var tr = GetTransitions(l);
if (tr == null)
{
return;
}
tr
.ForEach(
f =>
{
var primitiveApplication =
BddHelper.SetBooleanValue(i, f.Value.Value, f.Key);
if (goal1 == null)
{
goal1 = primitiveApplication;
}
else
{
goal1 = new PrimitiveApplication(PrimitiveApplication.AND,
goal1,
primitiveApplication);
}
});
i++;
});
return(goal1);
}
private static Expression AddIfExist(Expression res, Expression createAssignment, Mode mode)
{
if (res == null)
{
return(createAssignment);
}
if (mode == Mode.Equal)
{
res = new PrimitiveApplication(PrimitiveApplication.AND, res, createAssignment);
}
else
{
res = new Sequence(res, createAssignment);
}
return(res);
}
/// <summary>
/// [ REFS: '', DEREFS: '']
/// </summary>
/// <param name="choices"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void ExternalChoiceEncodeTick(List <AutomataBDD> choices, Model model, AutomataBDD result)
{
//if all components of the choice may evolve for a particular length of time, then so may the choice
//1. choice = -1 and all Tick.i and choice' = -1
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(-1)),
new Assignment(result.newLocalVarName, new IntConstant(-1)));
List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
for (int i = 0; i < choices.Count; i++)
{
CUDD.Ref(choices[i].Ticks);
guardDD = CUDD.Function.And(guardDD, choices[i].Ticks);
}
result.Ticks.AddRange(guardDD);
//2. choice = i and Tick.i and choice' = i
ResolvedChoiceEncodeTick(choices, model, result);
}
/// <summary>
/// (temp = -1 and tau and temp' in [0, n-1])
/// (temp = i ∧ Pi.transition ∧ temp' = i)
/// </summary>
/// <param name="choices"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void InternalChoiceEncodeTransition(List <AutomataBDD> choices, Model model, AutomataBDD result)
{
//Tau transition resolves the choice
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(
PrimitiveApplication.AND,
new PrimitiveApplication(
PrimitiveApplication.EQUAL,
new Variable(result.newLocalVarName),
new IntConstant(-1)),
GetTauTransExpression()),
new PrimitiveApplication(
PrimitiveApplication.GREATER_EQUAL,
new VariablePrime(
result.newLocalVarName),
new IntConstant(0))),
new PrimitiveApplication(PrimitiveApplication.LESS_EQUAL,
new VariablePrime(result.newLocalVarName),
new IntConstant(choices.Count - 1)));
List <CUDDNode> transition = guard.TranslateBoolExpToBDD(model).GuardDDs;
model.AddVarUnchangedConstraint(transition, model.GlobalVarIndex);
result.transitionBDD.AddRange(transition);
//Copy transitions from other processes after the choice is resolved
for (int i = 0; i < choices.Count; i++)
{
//(temp = i ∧ Pi.transition ∧ temp' = i)
guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(i)),
new Assignment(result.newLocalVarName, new IntConstant(i)));
transition = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(transition);
result.transitionBDD.AddRange(CUDD.Function.And(transition, choices[i].transitionBDD));
CUDD.Ref(transition);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, choices[i].channelInTransitionBDD));
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, choices[i].channelOutTransitionBDD));
}
}
/// <summary>
/// Return guard, update of channel output
/// guard: buffer not full
/// update: buffer = sender and update size of message and update length of buffer and update top of buffer
/// Does not include update Model.Event_Name
/// </summary>
/// <param name="channelName"></param>
/// <param name="exps"></param>
/// <param name="assignmentExp">null if not exist</param>
/// <param name="model"></param>
/// <returns></returns>
private static List <Expression> GetGuardUpdateOfChannelOutput(string channelName, List <Expression> exps, Expression assignmentExp, Model model)
{
string topChannelVariable = Model.GetTopVarChannel(channelName);
string countChannelVariable = Model.GetCountVarChannel(channelName);
string sizeElementArray = Model.GetArrayOfSizeElementChannel(channelName);
//count_a < L
Expression guardOfChannel = new PrimitiveApplication(PrimitiveApplication.LESS, new Variable(countChannelVariable), new IntConstant(model.mapChannelToSize[channelName]));
Expression updateOfChannel = new BoolConstant(true);
//Update buffer channel
//a[top_a] [ i] = exps[i]
for (int i = 0; i < exps.Count; i++)
{
updateOfChannel = new Sequence(updateOfChannel, new PropertyAssignment(new Variable(channelName),
new PrimitiveApplication(PrimitiveApplication.PLUS,
new PrimitiveApplication(PrimitiveApplication.TIMES, new Variable(topChannelVariable), new IntConstant(Model.MAX_MESSAGE_LENGTH)),
new IntConstant(i)),
exps[i]));
}
//Set size of the new element
//size_a[top_a] = exps.count
updateOfChannel = new Sequence(updateOfChannel, new PropertyAssignment(new Variable(sizeElementArray), new Variable(topChannelVariable), new IntConstant(exps.Count)));
//Update size: count_a = count_a + 1
updateOfChannel = new Sequence(updateOfChannel, new Assignment(countChannelVariable, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(countChannelVariable), new IntConstant(1))));
//Update top position: top_a = (top_a + 1) %L
updateOfChannel = new Sequence(updateOfChannel, new Assignment(topChannelVariable, new PrimitiveApplication(PrimitiveApplication.MOD,
new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(topChannelVariable), new IntConstant(1)), new IntConstant(model.mapChannelToSize[channelName]))));
if (assignmentExp != null)
{
updateOfChannel = new Sequence(updateOfChannel, assignmentExp);
}
return(new List <Expression>()
{
guardOfChannel, updateOfChannel
});
}
private CUDDNode EncodeUnary(PrimitiveApplication exp)
{
CUDDNode dd1 = EncodeExpression(exp.Argument1);
CUDDNode dd;
switch (exp.Operator)
{
case PrimitiveApplication.NOT:
dd = CUDD.Function.Not(dd1);
break;
case PrimitiveApplication.MINUS:
dd = CUDD.Function.Minus(CUDD.Constant(0), dd1);
break;
default:
throw new Exception("Invalid Expression!");
}
return(dd);
}
/// <summary>
/// (temp = i ∧ Pi.transition ∧ temp' = i)
/// </summary>
/// <param name="choices"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void ChoiceEncodeTransition(List <AutomataBDD> choices, Model model, AutomataBDD result)
{
for (int i = 0; i < choices.Count; i++)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(result.newLocalVarName),
new IntConstant(i)),
new Assignment(result.newLocalVarName, new IntConstant(i)));
List <CUDDNode> transition = guard.TranslateBoolExpToBDD(model).GuardDDs;
//
CUDD.Ref(transition);
result.transitionBDD.AddRange(CUDD.Function.And(transition, choices[i].transitionBDD));
CUDD.Ref(transition);
result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, choices[i].channelInTransitionBDD));
result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, choices[i].channelOutTransitionBDD));
}
}
