Пример #1
0
        public static void Initialize(AssertionBase Assertion, DefinitionRef Process, SpecificationBase spec)
        {
            Specification Spec = spec as Specification;

            //get the relevant global variables; remove irrelevant variables so as to save memory;
            Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(Process.GetGlobalVariables(), Process.GetChannels());

            //Initialize InitialStep
            Assertion.InitialStep = new Configuration(Process, Constants.INITIAL_EVENT, null, GlobalEnv, false);

            Assertion.MustAbstract = Process.MustBeAbstracted();
        }
Пример #2
0
        public static void Initialize(AssertionRefinement Assertion, DefinitionRef ImplementationProcess, DefinitionRef SpecificationProcess, SpecificationBase spec)
        {
            Specification Spec = spec as Specification;

            //get the relevant global variables; remove irrelevant variables so as to save memory;
            List <string> varList = ImplementationProcess.GetGlobalVariables();

            varList.AddRange(SpecificationProcess.GetGlobalVariables());

            Valuation GlobalEnv = Spec.SpecValuation.GetVariableChannelClone(varList, ImplementationProcess.GetChannels());

            //Initialize InitialStep
            Assertion.InitialStep  = new PNConfiguration(ImplementationProcess, Constants.INITIAL_EVENT, null, GlobalEnv, false, spec);
            Assertion.InitSpecStep = new PNConfiguration(SpecificationProcess, Constants.INITIAL_EVENT, null, GlobalEnv, false, spec);

            Assertion.MustAbstract = ImplementationProcess.MustBeAbstracted();
            if (SpecificationProcess.MustBeAbstracted())
            {
                throw new ParsingException(
                          "Process " + Assertion.SpecProcess + " has infinite states and therefore can not be used as a property model for refinement checking!", Assertion.AssertToken);
            }
        }
Пример #3
0
 public ADLAssertionDeadLock(DefinitionRef processDef) : base()
 {
     Process = processDef;
 }
Пример #4
0
 public ADLAssertionDeadLock(DefinitionRef processDef, bool isNontermination) : base(isNontermination)
 {
     Process = processDef;
 }
Пример #5
0
 public ADLAssertionAmbiguousInterface(DefinitionRef processDef) : base()
 {
     Process = processDef;
 }
 public KWSNAssertionReachabilityWith(DefinitionRef processDef, string reachableState, QueryConstraintType cont, Expression constraintCondition)
     : base(reachableState, cont, constraintCondition)
 {
     Process = processDef;
 }
 public KWSNAssertionReachability(DefinitionRef processDef, string reachableState)
     : base(reachableState)
 {
     Process = processDef;
 }
Пример #8
0
        private void createRoleProcessSpec(Feature role, Feature linkedRole, String eventPrefixStr, Feature attachedPort, String componentName)
        {
            if (Spec.DefinitionDatabase.ContainsKey(eventPrefixStr + "_" + role.getName()))
            {
                return;
            }
            //Feature role = conn.getRoleByName(roleName);

            Spec.CompStateDatabase.TryGetValue(componentName, out List <string> statesList);
            if (statesList == null)
            {
                statesList = new List <string>();
                Spec.CompStateDatabase.Add(componentName, statesList);
            }

            // create parameter of role process
            List <Expression> paramsExpr = new List <Expression>();

            if (role.Params.Count > 0)
            {
                foreach (var param in role.Params)
                {
                    paramsExpr.Add(new Variable(param));
                }
            }
            // create main role process
            DefinitionRef process = new DefinitionRef(eventPrefixStr + "_" + role.getName(), paramsExpr.ToArray());
            Process       prev    = null;

            Console.WriteLine(role.process.ElementAt(role.process.Count - 1).Name + "====" + role.getName());
            if (role.process.ElementAt(role.process.Count - 1).getName() == role.getName())
            {
                prev = process;
            }
            else if (role.process.ElementAt(role.process.Count - 1).Name.IndexOf("Skip") != -1)
            {
                prev = new Skip();
            }
            else if (role.process.ElementAt(role.process.Count - 1).Name.IndexOf("Stop") != -1)
            {
                prev = new Stop();
            }
            // copy list of event from the role process
            List <SysEvent> roleProcess = new List <SysEvent>();

            roleProcess.AddRange(role.process);

            // intercept if there is a link to other role
            if (linkedRole != null)
            {
                for (int i = 0; i < roleProcess.Count; i++)
                {
                    if (roleProcess.ElementAt(i).Name.IndexOf("_process") != -1)

                    {
                        // get rid of xxx() in linked role process
                        if (linkedRole.process.ElementAt(linkedRole.process.Count - 1).Name == linkedRole.Name)
                        {
                            linkedRole.process.RemoveAt(linkedRole.process.Count - 1);
                        }
                        Console.WriteLine("##inserting " + roleProcess.ElementAt(i));
                        // combine process at where  _process is
                        roleProcess.InsertRange(i, linkedRole.process);

                        // combine process after where  _process is
                        // roleProcess.InsertRange(i+1, linkedRole.process);
                        break;
                    }
                }
            }

            // insert component internal computation
            if (attachedPort.process.Count != 0)
            {
                for (int i = 0; i < roleProcess.Count; i++)
                {
                    if (roleProcess.ElementAt(i).Name.IndexOf("_process") != -1)

                    {
                        if (attachedPort.process.ElementAt(attachedPort.process.Count - 1).Name == attachedPort.Name)
                        {
                            attachedPort.process.RemoveAt(attachedPort.process.Count - 1);
                        }

                        // insert event trail after process event
                        //  roleProcess.InsertRange(i+1, attachedPort.process);

                        // insert event trail at process event
                        roleProcess.InsertRange(i, attachedPort.process);

                        break;
                    }
                }
            }


            // construct a sequenc for the role process
            // start from the second event
            for (int i = roleProcess.Count - 2; i >= 0; i--)
            {
                var     sysEvent = roleProcess.ElementAt(i);
                Process current  = null;
                if (sysEvent is SysProcess)
                {
                    // it is event
                    current = new EventPrefix(new Common.Classes.LTS.Event(eventPrefixStr + "_" + sysEvent.getName()), prev);
                    Console.WriteLine("   ->" + componentName + "  addEvent " + eventPrefixStr + "_" + sysEvent.getName());
                    statesList.Add(eventPrefixStr + "_" + sysEvent.getName());
                }
                else if (sysEvent is SysChannel)
                {
                    // it is channel
                    SysChannel channel = (SysChannel)sysEvent;
                    // parse channel parameters
                    List <Expression> chparamsExpr = new List <Expression>();
                    if (channel.Parameters.Count > 0)
                    {
                        foreach (var param in channel.Parameters)
                        {
                            chparamsExpr.Add(new Variable(param));
                        }
                    }
                    // add channelqueue to database, if still not exists
                    if (!Spec.ChannelDatabase.ContainsKey(channel.getName()))
                    {
                        ChannelQueue queue = new ChannelQueue(1);
                        Spec.ChannelDatabase.Add(channel.getName(), queue);
                    }
                    if (channel.ChannelType == SysChannel.Type.Input)
                    {
                        current = new ChannelInput(channel.getName(), null, chparamsExpr.ToArray(), prev);
                    }
                    else if (channel.ChannelType == SysChannel.Type.Output)
                    {
                        current = new ChannelOutput(channel.getName(), null, chparamsExpr.ToArray(), prev);
                    }
                }
                prev = current;
            }
            //Spec.CompStateDatabase.Add(componentName, statesList);
            Spec.CompStateDatabase.TryGetValue(componentName, out List <string> outstatesList);
            Console.WriteLine("     -> outstate: " + outstatesList.Count);
            // create process definition
            Definition processDef = new Definition(eventPrefixStr + "_" + role.getName(), role.Params.ToArray(), prev);

            process.Def = processDef;

            // add role process to spec
            Console.WriteLine("............ create role process :" + role.getName());
            Spec.DefinitionDatabase.Add(processDef.Name, processDef);
        }
Пример #9
0
 public ADLAssertionLavaFlow(DefinitionRef processDef) : base()
 {
     Process = processDef;
 }
Пример #10
0
 public ADLAssertionPoltergeist(DefinitionRef processDef) : base()
 {
     Process = processDef;
 }
Пример #11
0
 public KWSNAssertionDivergence(DefinitionRef processDef)
     : base()
 {
     Process = processDef;
 }
Пример #12
0
 public ADLAssertionDecomposition(DefinitionRef processDef) : base()
 {
     Process = processDef;
 }
Пример #13
0
        public void parse(SystemConfig config)
        {
            Dictionary <string, Connector> connectorInstanceList = new Dictionary <string, Connector>();

            // get connector instance to the dictionary
            foreach (var define in config.declareList)
            {
                Spec.ConnectorDatabase.TryGetValue(define.RightName, out Connector conn);
                if (conn == null)
                {
                    throw new Exception("At define statement, cannot find connector :" + define.RightName);
                }

                // Console.WriteLine(".......... define: " + define.LeftName + ", conn:" + conn.Name);
                Connector connInst = conn.DeepClone();
                connInst.setConfigName(define.LeftName);
                connectorInstanceList.Add(define.LeftName, connInst);
            }

            // create attach process
            //  Dictionary<string, DefinitionRef> attachMap = new Dictionary<string, DefinitionRef>();
            foreach (var attach in config.attachList)
            {
                Console.WriteLine("##loop on attach: " + attach.LeftName);
                if (!Spec.ComponentDatabase.ContainsKey(attach.LeftName))
                {
                    throw new Exception("No component " + attach.LeftName + " found");
                }
                // find component
                Spec.ComponentDatabase.TryGetValue(attach.LeftName, out Component comp);
                // find internal process associated to the component
                Feature port = comp.getPortByName(attach.LeftFunction.Name);
                Spec.AttachmentDatabase.Add(port.Name, attach);
                Console.WriteLine("attach " + attach.LeftName + "port: " + port.Name + " portproc:" + attach.HeadFunction.getCountEventAfter());

                SysProcess    current     = attach.HeadFunction;
                SysProcess    prevProc    = null;
                Feature       prevRole    = null;
                DefinitionRef atprocRef   = null;
                Process       headprocRef = null;
                // loop through trail of process of attachment
                String         process_prefix    = attach.LeftName + "_";
                List <Feature> linkedRoles       = new List <Feature>();
                Feature        headEmbedProcRole = null;
                SysProcess     headEmbedProc     = null;
                while (current != null)
                {
                    Console.WriteLine("#loop on attach process " + current.getName());
                    atprocRef = new DefinitionRef(process_prefix + current.Super + "_" + current.Name, convertParamValues(current.Parameters));
                    // retrieve connector
                    connectorInstanceList.TryGetValue(current.Super, out Connector conn);

                    if (conn == null)
                    {
                        throw new Exception("At attach statement, " + current.Super + " is not defined");
                    }

                    //  Console.WriteLine("finding role process " + config.Name + "_" + current.Name + ": " + atprocRef.Args);
                    Feature role = conn.getRoleByName(current.Name);
                    if (headprocRef != null)
                    {
                        List <Process> coProcs = new List <Process>();
                        coProcs.Add(headprocRef);

                        if (current.operation == SysProcess.Operation.Interleave)
                        {
                            this.createRoleProcessSpec(role, null, attach.LeftName, port, comp.Name);
                            Spec.DefinitionDatabase.TryGetValue(process_prefix + current.Super + "_" + current.Name, out atprocRef.Def);
                            coProcs.Add(atprocRef);
                            IndexInterleave procs = new IndexInterleave(coProcs);
                            headprocRef = procs;
                        }
                        else if (current.operation == SysProcess.Operation.Parallel)
                        {
                            this.createRoleProcessSpec(role, null, attach.LeftName, port, comp.Name);
                            Spec.DefinitionDatabase.TryGetValue(process_prefix + current.Super + "_" + current.Name, out atprocRef.Def);
                            coProcs.Add(atprocRef);
                            IndexParallel procs = new IndexParallel(coProcs);
                            headprocRef = procs;
                        }

                        else if (current.operation == SysProcess.Operation.Embed)
                        {
                            if (current.next != null && current.next.operation == SysProcess.Operation.Embed)
                            {
                                linkedRoles.Add(role.DeepClone <Feature>());
                            }
                            else
                            {
                                linkedRoles.Add(role.DeepClone <Feature>());
                                Console.WriteLine(" #process: " + process_prefix + headEmbedProcRole.getName() + " headEmbedProc: " + headEmbedProc + " creating...");
                                atprocRef = new DefinitionRef(process_prefix + headEmbedProcRole.ConfigName + "_" + headEmbedProcRole.Name, convertParamValues(headEmbedProc.Parameters));
                                // create embed process

                                this.createRoleProcessSpecWithMultipleLinked(headEmbedProcRole, linkedRoles, attach.LeftName, port, comp.Name);
                                Spec.DefinitionDatabase.TryGetValue(process_prefix + headEmbedProcRole.getName(), out atprocRef.Def);
                                headprocRef = atprocRef;
                            }
                        }
                    }
                    else
                    {
                        if (current.next != null && current.next.operation == SysProcess.Operation.Embed)
                        {
                            // this is head of embeded processs

                            headEmbedProcRole = conn.getRoleByName(current.Name);
                            headEmbedProc     = current;
                        }
                        else
                        {
                            // other process rather than embeded process
                            this.createRoleProcessSpec(role, null, attach.LeftName, port, comp.Name);
                        }

                        Console.WriteLine("     #create first sub process");
                        Spec.DefinitionDatabase.TryGetValue(process_prefix + current.Super + "_" + current.Name, out atprocRef.Def);
                        // first sub process
                        headprocRef = atprocRef;
                    }
                    prevProc = current;
                    prevRole = conn.getRoleByName(current.Name);
                    current  = current.next;
                }

                Definition atprocDef = new Definition(attach.LeftName + "_" + attach.LeftFunction.Name, new String[] { }, headprocRef);
                Spec.DefinitionDatabase.Add(atprocDef.Name, atprocDef);
                //   attachMap.Add(atprocRef.Name, atprocRef);
            }

            // find exec statement and create exec process
            SysProcess subproc = config.Exec;
            //loop through each function in the exec process
            Process head = null;

            while (subproc != null)
            {
                // find attachment process according to what is called in exec process
                DefinitionRef atprocRef = new DefinitionRef(subproc.Super + "_" + subproc.Name, new Expression[] { });
                Spec.DefinitionDatabase.TryGetValue(subproc.Super + "_" + subproc.Name, out atprocRef.Def);
                if (atprocRef.Def == null)
                {
                    throw new Exception("At exec statement, cannot find port" + subproc.Name + " on " + subproc.Super);
                }
                // Process atprocRef = def.Process;
                if (head != null)
                {
                    List <Process> coProcs = new List <Process>();
                    coProcs.Add(head);
                    coProcs.Add(atprocRef);
                    if (subproc.operation == SysProcess.Operation.Interleave)
                    {
                        IndexInterleave interleaveProcs = new IndexInterleave(coProcs);
                        head = interleaveProcs;
                    }
                    else if (subproc.operation == SysProcess.Operation.Parallel)
                    {
                        IndexParallel parallelProcs = new IndexParallel(coProcs);
                        head = parallelProcs;
                    }
                    else if (subproc.operation == SysProcess.Operation.Choice)
                    {
                        IndexChoice choiceProcs = new IndexChoice(coProcs);
                        head = choiceProcs;
                    }
                }
                else
                {
                    // first sub process
                    head = atprocRef;
                }

                // go to next process
                subproc = subproc.next;
            }
            // create exec process
            DefinitionRef execRef = new DefinitionRef(config.Name, new Expression[] { });
            //Console.WriteLine("exec proc: " + head.ToString());
            Definition instanceDef = new Definition(execRef.Name, new String[] { }, head);

            execRef.Def = instanceDef;
            Spec.DefinitionDatabase.Add(instanceDef.Name, instanceDef);
            Spec.ExecProcessDatabase.Add(execRef.Name, execRef);
        }
Пример #14
0
 public KWSNAssertionRefinement(DefinitionRef processDef, DefinitionRef target)
     : base()
 {
     ImplementationProcess = processDef;
     SpecificationProcess  = target;
 }
Пример #15
0
 public ADLAssertionCircular(DefinitionRef processDef) : base()
 {
     Process = processDef;
 }
Пример #16
0
 public PNAssertionLTL(DefinitionRef processDef, string ltl) : base(ltl)
 {
     Process = processDef;
 }
 public KWSNAssertionDeterminism(DefinitionRef processDef)
     : base()
 {
     Process = processDef;
 }