Пример #1
0
        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);
        }
Пример #2
0
        private static void TimeInterruptEncodeTransitionChannel(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' = termination & clk' = -1) or (event' != termination & clk' = clk)]
            guard = Expression.AND(Expression.LE(new Variable(clk), new IntConstant(t)),
                                   Expression.OR(Expression.AND(
                                                     AutomataBDD.GetTerminateTransExpression(),
                                                     new Assignment(clk, new IntConstant(-1))), Expression.AND(
                                                     AutomataBDD.GetNotTerminateTransExpression(),
                                                     new Assignment(clk, new Variable(clk)))));
            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 = Expression.AND(Expression.EQ(new Variable(clk), new IntConstant(t)),
                                   Expression.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 = Expression.AND(Expression.EQ(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);
        }
Пример #3
0
        /// <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 = Expression.AND(guard1,
                                 Expression.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 = Expression.AND(
                Expression.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 = Expression.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);
        }