Steven Smyth

SCCharts: sequentially constructive statecharts for safety-critical applications: HW/SW-synthesis for a conservative extension of synchronous statecharts

We present a new visual language, SCCharts, designed for specifying safety-critical reactive systems. SCCharts use a statechart notation and provide determinate concurrency based on a synchronous model of computation (MoC), without restrictions common to previous synchronous MoCs. Specifically, we lift earlier limitations on sequential accesses to shared variables, by leveraging the sequentially constructive MoC. The semantics and key features of SCCharts are defined by a very small set of elements, the Core SCCharts, consisting of state machines plus fork/join concurrency. We also present a compilation chain that allows efficient synthesis of software and hardware.

Compiling SCCharts -- A Case-Study on Interactive Model-Based Compilation

SCCharts is a recently proposed statechart language designed for specifying safety-critical reactive systems. We have developed an Eclipse-based compilation chain that synthesizes SCCharts into either hardware or software. The user edits a textual description which is visualized as SCChart and subsequently transformed into VHDL or C code via a series of model-to-model M2M transformation steps. An interactive environment gives the user control over which transformations are applied and allows the user to inspect intermediate transformation results. This Single-Pass Language-Driven Incremental Compilation SLIC approach should conceptually be applicable to other languages as well. Key benefits are: 1 a compact, light-weight definition of the core semantics, 2 intermediate transformation results open to inspection and support for certification, 3i¾?high-level formulations of transformations that define advanced language constructs, 4 a divide-and-conquer validation strategy, 5 simplified language/compiler subsetting and DSL construction.

Interactive Model-Based Compilation Continued – Incremental Hardware Synthesis for SCCharts

The Single-Pass Language-Driven Incremental Compilation (slic) strategy uses a series of model-to-model (M2M) transformations to compile a model or program to a specified target. Tool developer and modeler can inspect the result of each transformation step, using a familiar, graphical syntax of the successively transformed model, which is made possible by harnessing automatic layout. Previous work (presented at ISoLA’14) introduced the basics of the slic approach and illustrated it with a compiler that translated SCCharts, a synchronous, deterministic statechart language developed for safety-critical systems, to software. The compiler is implemented in the Kiel Integrated Environment for Layout Eclipse Rich Client (KIELER), an open-source development framework based on Eclipse.

SCEst: Sequentially Constructive Esterel

The synchronous language Esterel provides determinate concurrency for reactive systems. Determinacy is ensured by the “signal coherence rule,” which demands that signals have a stable value throughout one reaction cycle. This is natural for the original application domains of Esterel, such as controller design and hardware development; however, it is unnecessarily restrictive for software development. Sequentially Constructive Esterel (SCEst) overcomes this restriction by allowing values to change instantaneously, as long as determinacy is still guaranteed, adopting the recently proposed Sequentially Constructive model of computation. SCEst is grounded in the minimal Sequentially Constructive Language, which also provides a novel semantic definition and compilation approach for Esterel.

Towards Interactive Compilation Models

A chain of model-to-model transformations prescribes a particular work process, while executing such a chain generates a concrete instance of this process. Modeling the entire development process itself on a meta-model level extends the possibilities of the model-based approach to guide the developer. Besides refining tools for model creation, this kind of meta-modeling also facilitates debugging, optimization, and prototyping of new compilations. A compiler is such a process system. In this paper, we share the experiences gathered while we worked on the model-based reference compiler of the kieler SCCharts project and ideas towards a unified view on similar prescribed processes.

SCEst: Sequentially constructive esterel

The synchronous language Esterel provides determinate concurrency for reactive systems. Determinacy is ensured by the “signal coherence rule,” which demands that signals have a stable value throughout one reaction cycle. This is natural for the original application domains of Esterel, such as controller design and hardware development; however, it is unnecessarily restrictive for software development. Sequentially Constructive Esterel (SCEst) overcomes this restriction by allowing values to change instantaneously, as long as determinacy is still guaranteed, adopting the recently proposed Sequentially Constructive model of computation. SCEst is grounded in the minimal Sequentially Constructive Language, which also provides a novel semantic definition and compilation approach for Esterel.

Synthesizing manually verifiable code for statecharts

Statecharts are an established mechanism to model reactive, state-oriented behavior of embedded systems. We here present an approach to automatically generate code from statecharts, with a particular focus on readability and ease of matching the generated code with the original model. This not only saves programming effort and reduces the error rate compared to manual coding, but it also facilitates the task of verifying that the code does what it is supposed to do. We have implemented this approach for the SCCharts language in an open-source framework. A user study confirmed that the generated code tends to be more readable than code from other code generators.

Augmenting State Models with Data Flow

Numerous modeling languages have adapted a graphical syntax that emphasizes control flow or state rather than data flow. We here refer to these as state diagrams, which include classic control flow diagrams as well as for example Statecharts. State diagrams are usually considered to be fairly easy to comprehend and to facilitate the understanding of the general system behavior. However, finding data dependencies between concurrent activities can be difficult as these dependencies must be deduced by matching textual variable references.

Model Extraction of Legacy C Code in SCCharts

With increasing volumes of developed software and steadily growing complexity of these systems, software engineers struggle to manually maintain the vast amount of legacy code. Therefore, it is of interest to create a system which supports the documentation, maintenance, and reusability of software and its legacy code. The approach presented here automatically derives SCCharts models out of C code. These models can be used as visual documentation. By applying focus and context methods important parts of the model can be highlighted and may grant a better understanding of the overall software. Additionally, the models can also be used as a source to create new state-of-the-art code for various languages and platforms, such as C code or VHDL, using automatic code generators.

Runtime enforcement of reactive systems using synchronous enforcers

Synchronous programming is a paradigm of choice for the design of safety-critical reactive systems. Runtime enforcement is a technique to ensure that the output of a black-box system satisfies some desired properties. This paper deals with the problem of runtime enforcement in the context of synchronous programs. We propose a framework where an enforcer monitors both the inputs and the outputs of a synchronous program and (minimally) edits erroneous inputs/outputs in order to guarantee that a given property holds. We define enforceability conditions, develop an online enforcement algorithm, and prove its correctness. We also report on an implementation of the algorithm on top of the KIELER framework for the SCCharts synchronous language. Experimental results show that enforcement has minimal execution time overhead, which decreases proportionally with larger benchmarks.