This book presents a synthesis of recent works concerning reactive system design. The term `reactive system' has been introduced in order to avoid ambiguities often involved with the term `real-time system' which, while being best-known and suggestive, has been assigned so many different meanings that it is almost inevitably misunderstood. Industrial Process control system, transportation control and supervision systems, signal processing systems, etc. are examples of the systems we have in mind. Four programming languages are presented, which share the same underlying synchronous model: based on Robin Milner's pioneering works about synchronous process algebras, this model consists in considering that a program instantaneously reacts to events, or that the machine execution time is negligible with respect to the response delays of its environment. Using this abstract point of view, the time behavior of a system can be formalized in a very simple and elegant way. The languages presented are ESTEREL, a textual imperative language; ARGOS, a graphical language inspired by STATECHARTS; and LUSTRE and SIGNAL, two declarative languages. After a tutorial description of the languages, illustrated by various examples, a set of related tools is presented: compilers to sequential and distributed code, silicon compilers, verification tools.

http://www-verimag.imag.fr/~halbwach/newbook.pdf

Synchronous programming of reactive systems

Twelve years ago, Proceedings of the IEEE devoted a special section to the synchronous languages. This paper discusses the improvements, difficulties, and successes that have occured with the synchronous languages since then. Today, synchronous languages have been established as a technology of choice for modeling, specifying, validating, and implementing real-time embedded applications. The paradigm of synchrony has emerged as an engineer-friendly design method based on mathematically sound tools.

/pdf/the-synchronous-languages-12-years-later-55re7ed5k3.pdf

The synchronous languages 12 years later

We provide an algebraic formalization of connectors in the BIP component framework. A connector relates a set of typed ports. Types are used to describe different modes of synchronization, in particular, rendezvous and broadcast. Connectors on a set of ports P are modeled as terms of the algebra AC(P), generated from P by using a binary fusion operator and a unary typing operator. Typing associates with terms (ports or connectors) synchronization types - trigger or synchron - that determine modes of synchronization. Broadcast interactions are initiated by triggers. Rendezvous is a maximal interaction of a connector that includes only synchrons. The semantics of AC(P) associates with a connector the set of its interactions. It induces on connectors an equivalence relation which is not a congruence as it is not stable for fusion. We provide a number of properties of AC(P) used to symbolically simplify and handle connectors. We provide examples illustrating applications of AC(P), including a general component model encompassing methods for incremental model decomposition and efficient implementation by using symbolic techniques.

/pdf/the-algebra-of-connectors-structuring-interaction-in-bip-3sk7xvhh2j.pdf

The Algebra of Connectors—Structuring Interaction in BIP

Over the past ten years, the family of synchronous languages (Special Section of the Proc. IEEE 79 (9) (1991)) has been very successful in offering domain-specific, formally defined languages and programming environments for safety-critical systems. Among them, Lustre is well-suited for the development of regulation systems, which are first designed by control engineers, and can then be programmed as block-diagrams. Automatic generation of C code provides the embedded software.The success of Lustre showed that it is a good idea to offer domain-specific languages and constructs to reduce the gap between the first design of a system (for instance a control law) and the program written for it. When the structure of the first design has to be encoded into the available constructs of a general-purpose programming language, the interesting information is likely to be lost somewhere on the way from the original design to the actual implementation. This may have consequences on the efficiency of the code produced, or even on the correctness of the design.Working with the systems Lustre is well-suited for, we observed that they are often specified informally using the notion of running modes. However, there seemed to exist no language in which the mode-structure of a complex system could be expressed directly. Following the approach of domain-specific languages, we proposed to extend Lustre with a new construct, called mode-automaton, devoted to the description of these running modes of regulation systems.In this paper, we define the language of mode-automata and its semantics, give some ideas on the compilation process, illustrate the approach with the example of the production cell, and comment on the benefits of the approach, in general.

Mode-automata: a new domain-specific construct for the development of safe critical systems

Mode automata and their compilation into fault trees

https://hal.archives-ouvertes.fr/hal-00273055/document

Argos: an automaton-based synchronous language

In the field of reactive system programming, dataflow synchronous languages like Lustre [BCH+85,CHPP87] or Signal [GBBG85] offer a syntax similar to block-diagrams, and can be efficiently compiled into C code, for instance. Designing a system that clearly exhibits several “independent” running modes is not difficult since the mode structure can be encoded explicitly with the available dataflow constructs. However the mode structure is no longer readable in the resulting program; modifying it is error prone, and it cannot be used to improve the quality of the generated code.

/pdf/mode-automata-about-modes-and-states-for-reactive-systems-47ks71ce0q.pdf

Mode-Automata: About Modes and States for Reactive Systems

In this paper, we present a tool for estimating the activity of asynchronous circuit specifications. This tool is well suited for monitoring how and where the activity is spread in a circuit. The quality and the precision of the results allow the designer to perform optimizations early in the design flow in order to improve the energy consumption and the speed of asynchronous circuits. Based on the TAST profiler, an energy optimization methodology is defined, focusing on micro-architecture decomposition, choice structures unbalancing and channels splitting. All these techniques are illustrated using an example.

TAST Profiler and Low Energy Asynchronous Design Methodology

Mode-Automata have been proposed in. They introduce, in the domain-specific data-flow language Lustre for reactive systems, a new construct devoted to the expression of running modes. The idea is to associate data-flow programs with the states of an automaton, representing modes. We define flat automata first, and then several composition operators, such as parallel composition and hierarchic composition, which give the language a state structure reminiscent from Statecharts. The semantics of this extension may be defined by describing the translation of Mode-automata into pure Lustre. However, the translation scheme is complex and it gives poor code; we study here the translation of mode-automata into the declarative format dc, used as an intermediate form in the compilers of several synchronous languages (Lustre, Esterel, ...). dc can be compiled into C, Java or Ada code. This allows to take advantage of the imperative mode-structure of a mode-automaton in order to improve the final sequential code.

/pdf/matou-an-implementation-of-mode-automata-2idbhx0tye.pdf

Yann Rémond

Papers

Mode-automata: a new domain-specific construct for the development of safe critical systems

Argos: an automaton-based synchronous language

Mode-Automata: About Modes and States for Reactive Systems

TAST Profiler and Low Energy Asynchronous Design Methodology

MATOU: An Implementation of Mode-Automata