Download to read offline
Uploaded byVince Molnár
ICSE2018 - The Gamma Statechart Composition Framework: Design, Verification and Code Generation for Component-Based Reactive Systems
The Gamma Statechart Composition Framework is an integrated tool to support the design, verification and validation as well as code generation for component-based reactive systems where the behavior of each component is captured by a statechart, while assembling the system from components is driven by a domain-specific composition language. Gamma automatically synthesizes executable Java code on top of existing code generators, and it supports formal verification by mapping composite statecharts to a back-end model checker. Execution traces obtained as witnesses during verification are back-annotated as test cases to replay an error trace or to validate external code generators. Video link: https://www.youtube.com/watch?v=ng7lKd1wlDo
ICSE2018 - The Gamma Statechart Composition Framework: Design, Verification and Code Generation for Component-Based Reactive Systems
- 1. Background created byCreative_hat - Freepik.com 1 Fault Tolerant Systems Research Group, Budapest University of Technology and Economics, 2 MTA-BME Lendület Cyber-Physical Systems Research Group 3 Department of Electrical & Computer Engineering, McGill University Gamma Statechart Composition Framework Vince Molnár1,2, Bence Graics1, András Vörös1,2, István Majzik1, Dániel Varró1,2,3
- 2. Motivation System Integrator (OEM, Airframer) Subcontractor Subcontractor Subcontractor Simulink model Yakindu statechart UML statechart ? Codegeneration & Deployment (Co-)simulation Verification & Validation γ
- 3. Hidden Formal Methods: V&V,Test generation Formal Compositional Semantics Hidden Formal Methods With modular model transformations & back-annotation Hierarchical Composition With precise composition semantics for interactions Gamma Statechart & Composition Language Integration of Statechart Implementations γ Reactive Components Potentially from different modelling tools Code Generation Building on pluggable external code generators
- 4. Composition semantics Assumptions: Components arereactive – produce output in response to input Multiple inputs can be set before eliciting a response Execution is triggered by a control signal (e.g., periodically) Corresponds to synchronous-reactive semantics Synchronous: time is an ordered sequence of discrete instants Reactive: instants initiated by external events Components are executed concurrently Outputs are visible to other components in the next instant
- 5. Composition semantics Component 1Component 2 Component 3 Time: Ordered instants Signal reception: In next instant Input processing: Multiple inputs
- 6.
- 7. Additional composition semantics Cascade Executecomponents sequentially, passing outputs immediately Ideal for pipeline-like (sub)systems Asynchronous-reactive Components executed independently No guarantees on frequency or runtime Messages and message queues Ideal for distributed systems Component 1 Component 2 Component 3 Component 1 Component 2 Component 3
- 8. Summary Motivation Subcontractor Subcontractor Subcontractor System Integrator (OEM, Airframer) Simulink model Yakindu statechart UML statechart ? Codegeneration & Deployment (Co-)simulation Verification & Validation Component 1 Component 2 Component 3 Synchronous-reactive Component 1 Component 2 Component 3 Asynchronous-reactive Hidden Formal Methods: V&V, Test generation Formal Compositional Semantics Gamma Statechart & Composition Language Integration of Statechart Implementations γ γ Cascade Component 1 Component 2 Component 3
- 9. Summary Motivation Subcontractor Subcontractor Subcontractor System Integrator (OEM, Airframer) Simulink model Yakindu statechart UML statechart ? Codegeneration & Deployment (Co-)simulation Verification & Validation Component 1 Component 2 Component 3 Synchronous-reactive Component 1 Component 2 Component 3 Asynchronous-reactive Hidden Formal Methods: V&V, Test generation Formal Compositional Semantics Gamma Statechart & Composition Language Integration of Statechart Implementations γ γ Cascade Component 1 Component 2 Component 3 Future work Additional modeling languages Additional code generators Additional verification backends Co-simulation & verification
- 10. gamma.inf.mit.bme.hu Background created byCreative_hat - Freepik.com goo.gl/ae7V63
Editor's Notes
- #2 Helo everybody, thank you for the introduction. I am going to present the gamma statechart composition framework, which is developed primarily at the Budapest University of Technology and Economics, with supervision from Professor Daniel Varro from McGill University, who’s also here.
- #3 To illustrate the motivation of our work, imagine that you’re a system integrator working in one of the traditional safety-critical industries such as automotive or avionics. One of your main challanges would probably be that the system you are producing is not necessarily composed of components or subsystems that you build in the company, but come from subcontractors. Some of them may even be proprietary or confidential, meaning that you are not allowed to look at the concrete implementation or model, but most certaily they will come from heterogeneous tools. So the question is, how do you model your system, how do you integrate these heterogeneous components into a whole? Besides this obvious need, it would also be nice to have simulation capabilities, so that you can make informed design decisions. Also, as you work in a safety critical domain, it is preferable to have system-wide verification and validation to ensure high quality. Furthermore, in accordance with the model-driven paradigms, automatic code generation would also be a nice feature. Our experience shows that there are quite limited solutions that cover all these problems, so that is why we started our research, materialized in the Gamma statechart composition framework.
- #4 The workflow followed by Gamma builds on rective components, potentially coming from different modelling tools. Gamma provides a modelling language to compose these components hierarchically, and one of the key features is the precise definition of communication semantics specifying how components interact. Give a composite system, Gamma can generate code for these interactons, building on pluggable external code geneartors for the different components. Currently, as a showcase, Gamma is integrated with Yakindu Statechart Tools, an eclipse-based statechart modeling tools that has a built-in code generator. Finally, Gamma can integrate formal verification tools to check the properties of a system, mapping the components and the interaction layer to the formal modelling language of a tool in a modular way, also taking care of back-annotating the verification results on the Gamma model and generating test cases for potential witness execution traces. Currently, we use UPPAAL as the verification backend.
- #5 The composition semantics used by the tool assume that components are reactive, that is, they produce outputs in response to inputs, potentially depending on an inner state as well. We also assume that multiple inputs can be fed into a component before actually executing it to get an output, and this execution is triggered by a separate control signal, for example peridically. This semantics is similar in spirit to the synchronous-reactive semantics described in the literature – it is synchronous, because time is regarded as an ordered sequence of discrete instants, and reactive, because these instants are initiated by external events. In Gamma, components are executed concurrenly in a lock-step fashion, and the semantics says that the outputs of a component will be read by other components in the next step only. This makes the order of execution irrelevant, making formal verification easier and yielding a deterministic execution.
- #6 As an example, take a look at this schematic sequence diagram. Note that time is an ordered sequence of discrete instants, denoted by these horizontal lines. Signals sent between the components will always arrive in the next instant, in which the target also produces its response (if any). This semantics have one consequence that may seem exotic to UML practitioners: components should be able to handle multiple signals in the same run, contrary to UML statecharts which process events one by one.
- #7 Let me show you how this works in practice.
- #8 In addition to what you have just seen, we are heavily working on the seond major release of Gamma, which supports two additional semantics. One of them is a variant of the synchronous reactive semantics shown before, but here the output of a components is passed to the target component right away, and components are executed in a user-specified order – some components may even be executed more than once. This is ideal for pipeline-like systems, where we want to model the processing of some data and there is no real concurrency between the components. The other one is the asynchronous-reactive semantics, which is similar to how UML specifies the semantics of statecharts. Here, components are executed independently and there is no guarantee on the frequency and running time. Actually it is safe to say that we assume the components may be running on different computers, so this is ideal for distributed systems. Communication happens with messages which are buffered in message queues.
- #9 So to summarize, the motivation behind Gamma is to help the integration of heterogeneous reactive components with support for simulation, code generation and formal verification. We already cover some of these functionalities, currently the prototype can be demonstrated with Yakindu statechart tools and the UPPAAL model checker. We currently support 3 kinds of composition semantics, the synchronous-reactive, the cascade and the asynchronous-reactive. Our future work is mostly related to expand the integration with more tools, including modeling languages, verification backends and code generators, and we are also working on advanced interface-based co-simulation and verification using the capabilities of external tools.
- #10 Thank you for your attention, and feel free to ask questions.
- #11 The stable version of Gamma seen in the demo can be downloaded along with a tutorial from the following website, wehre you can also find all related papers.