Esempio n. 1
0
        /// <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);
        }
Esempio n. 2
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 = 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)))));

            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 = Expression.AND(
                Expression.LE(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);
        }
Esempio n. 3
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);
        }
Esempio n. 4
0
        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 = Expression.AND(Expression.EQ(new Variable(state), new IntConstant(t)),
                                   Expression.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);
        }