Esterel

Esterel
Paradigms	Imperative, synchronous
Designed by	Gérard Berry
Developer	Inria
First appeared	1980s
Website	www.esterel.org

Last updated November 19, 2024

Esterel is a synchronous programming language for the development of complex reactive systems. The imperative programming style of Esterel allows the simple expression of parallelism and preemption. As a consequence, it is well suited for control-dominated model designs.

The language is still under development, with several compilers out. The commercial development environment of Esterel is Esterel Studio. The company that commercialized it (Synfora) initiated a normalization process with the IEEE in April 2007 however the working group (P1778) dissolved March 2011. The reference manual is publicly available.^[1]

A provisional version of Esterel has been implemented in Racket.^[2]

The multiform notion of time

The notion of time used in Esterel differs from that of non-synchronous languages in the following way: The notion of physical time is replaced with the notion of order. Only the simultaneity and precedence of events are considered. This means that the physical time does not play any special role. This is called multiform notion of time. An Esterel program describes a totally ordered sequence of logical instants. At each instant, an arbitrary number of events occur (including 0). Event occurrences that happen at the same logical instant are considered simultaneous. Other events are ordered as their instances of occurrences. There are two types of statements: Those that take zero time (execute and terminate in the same instant) and those that delay for a prescribed number of cycles.

Signals

Signals are the only means of communication. There are valued and non-valued signals. They are further categorized as being input, output, or local signals. A signal has the property of being either present or absent in an instant. Valued signals also contain a value. Signals are broadcast across the program, and that means any process can read or write a signal. The value of a valued signal can be determined in any instant, even if the signal is absent. The default status of a signal is absent. Signals remain absent until they are explicitly set to present using the emit statement. Communication is instantaneous, that means that a signal emitted in a cycle is visible immediately. Note that one can communicate back and forth in the same cycle.

Signal coherence rules

Each signal is only present or absent in a cycle, never both.
All writers run before any readers do.

Thus

present A else     emit A end

is an erroneous program, since the writer "emit A" should run before the reader "present A", whereas this program requires "present A" to be performed first.

The language statements

Primitive Esterel statements

Pure Esterel has eleven primitive statements.^[3]

`nothing`	Terminates immediately with no other effect.
`pause`	Blocks control flow in the current cycle for resumption in the next cycle.
p`;`q	Runs p until it terminates and then, in the same reaction, starts q.
p`\|\|`q	Runs p and q in parallel
`loop`p`end`	Restarts the body p as soon as it terminates. Every path through the loop body must contain at least one `pause` statement to avoid unbounded looping within a single reaction.
`signal`S`in`p`end`	Declares a local signal.
`emit`S	Make signal S present in the current instant. A signal is absent unless it is emitted.
`present`S`then`p`else`q`end`	If signal S is present in the current instant, immediately run p, otherwise run q.
`suspend`p`when`S	Suspends the execution of the body in instants where S is present.
`trap`T`in`p`end`	Declare a labeled escape block.
`exit`T	Jump to the end of the innermost T-labeled escape block.

Derived Esterel statements

Esterel has several derived constructions:^[4]^[5]

Derived statement	Expansion
`halt`	`loop pause end`
`sustain`s	`loop emit`s`; pause end`
`present`s`then`p`end`	`present`s`then`p`else nothingend`
`await`s	`trap T in loop pause; present`s`then exit T end end loop end`
`await immediate`s	`trap T in loop present`s`then exit T end; pause end loop end`
`suspend`p`when immediate`s	`suspend present`s`then pause end;`p`when`s
`abort`p`when (immediate)`s	`trap T in suspend`p`when (immediate)`s`; exit T \|\| await (immediate)`s`; exit T; end`
`weak abort`p`when (immediate)`s	`trap T in`p`; exit T \|\| await (immediate)`s`; exit T; end`
`looppeach`s	`loop abort`p`; halt when`s`end loop`
`every (immediate)`s`do`p`end every`	`await (immediate)`s`; loop`p`each`s

Other Esterel statements

The full Esterel language also has statements for declaring and instantiating modules, for variables, for calling external procedures, and for valued signals.

Example (ABRO)

The following program emits the output O as soon as both inputs A and B have been received. Reset the behaviour whenever the input R is received.

module ABRO: input A, B, R; output O;  loop   [ await A || await B ];   emit O each R  end module

Advantages of Esterel

Model of time gives programmer precise control
Concurrency convenient for specifying control systems
Completely deterministic
Finite-state language
- Execution time predictable
- Much easier to verify formally
Can be implemented in hardware as well as in software

Disadvantages of Esterel

Finite-state nature of the language limits flexibility (but expressivity is sufficient for the chosen application field)
Semantic challenges
- Avoiding causality violations is often difficult
- Difficult to compile in the general case, but simple correctness criteria exist

Related Research Articles

Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995.

In computer programming, a macro is a rule or pattern that specifies how a certain input should be mapped to a replacement output. Applying a macro to an input is known as macro expansion.

OCaml is a general-purpose, high-level, multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.

Verilog, standardized as IEEE 1364, is a hardware description language (HDL) used to model electronic systems. It is most commonly used in the design and verification of digital circuits at the register-transfer level of abstraction. It is also used in the verification of analog circuits and mixed-signal circuits, as well as in the design of genetic circuits. In 2009, the Verilog standard was merged into the SystemVerilog standard, creating IEEE Standard 1800-2009. Since then, Verilog has been officially part of the SystemVerilog language. The current version is IEEE standard 1800-2023.

BLISS is a system programming language developed at Carnegie Mellon University (CMU) by W. A. Wulf, D. B. Russell, and A. N. Habermann around 1970. It was perhaps the best known system language until C debuted a few years later. Since then, C became popular and common, and BLISS faded into obscurity. When C was in its infancy, a few projects within Bell Labs debated the merits of BLISS vs. C.

In computer science, a deterministic algorithm is an algorithm that, given a particular input, will always produce the same output, with the underlying machine always passing through the same sequence of states. Deterministic algorithms are by far the most studied and familiar kind of algorithm, as well as one of the most practical, since they can be run on real machines efficiently.

In computer science, extensible programming is a style of computer programming that focuses on mechanisms to extend the programming language, compiler, and runtime system (environment). Extensible programming languages, supporting this style of programming, were an active area of work in the 1960s, but the movement was marginalized in the 1970s. Extensible programming has become a topic of renewed interest in the 21st century.

IP Pascal is an implementation of the Pascal programming language using the IP portability platform, a multiple machine, operating system and language implementation system. It implements the language "Pascaline", and has passed the Pascal Validation Suite.

A synchronous programming language is a computer programming language optimized for programming reactive systems.

Lustre is a formally defined, declarative, and synchronous dataflow programming language for programming reactive systems. It began as a research project in the early 1980s. A formal presentation of the language can be found in the 1991 Proceedings of the IEEE. In 1993 it progressed to practical, industrial use in a commercial product as the core language of the industrial environment SCADE, developed by Esterel Technologies. It is now used for critical control software in aircraft, helicopters, and nuclear power plants.

Lola is designed to be a simple hardware description language for describing synchronous, digital circuits. Niklaus Wirth developed the language to teach digital design on field-programmable gate arrays (FPGAs) to computer science students while a professor at ETH Zurich.

Racket is a general-purpose, multi-paradigm programming language. The Racket language is a modern dialect of Lisp and a descendant of Scheme. It is designed as a platform for programming language design and implementation. In addition to the core Racket language, Racket is also used to refer to the family of programming languages and set of tools supporting development on and with Racket. Racket is also used for scripting, computer science education, and research.

Gérard Philippe Berry is a French computer scientist, member of the French Academy of Sciences, French Academy of Technologies, and Academia Europaea. He was the Chief Scientist Officer of Esterel Technologies from 2000 to 2009. He held the 2007-2008 yearly Liliane Bettencourt chair of Technological Innovation at the Collège de France. He was Director of Research at INRIA Sophia-Antipolis and held the 2009-2010 yearly Informatics and Digital Sciences chair at the Collège de France. Berry's work, which spans over more than 30 years, brought important contributions to three main fields:

Esterel Technologies is a supplier of model-based design, validation, and code generation tools for safety-critical software and hardware applications. Esterel's tools create formal specifications that produce control designs code in software and/or hardware.

The Parallax P8X32A Propeller is a multi-core processor parallel computer architecture microcontroller chip with eight 32-bit reduced instruction set computer (RISC) central processing unit (CPU) cores. Introduced in 2006, it is designed and sold by Parallax, Inc.

Sawzall is a procedural domain-specific programming language, used by Google to process large numbers of individual log records. Sawzall was first described in 2003, and the szl runtime was open-sourced in August 2010. However, since the MapReduce table aggregators have not been released, the open-sourced runtime is not useful for large-scale data analysis of multiple log files off the shelf. Sawzall has been replaced by Lingo for most purposes within Google.

Reo is a domain-specific language for programming and analyzing coordination protocols that compose individual processes into full systems, broadly construed. Examples of classes of systems that can be composed with Reo include component-based systems, service-oriented systems, multithreading systems, biological systems, and cryptographic protocols. Reo has a graphical syntax in which every Reo program, called a connector or circuit, is a labeled directed hypergraph. Such a graph represents the data-flow among the processes in the system. Reo has formal semantics, which stand at the basis of its various formal verification techniques and compilation tools.

TNSDL stands for TeleNokia Specification and Description Language. TNSDL is based on the ITU-T SDL-88 language. It is used exclusively at Nokia Networks, primarily for developing applications for telephone exchanges.

SIGNAL is a programming language based on synchronized dataflow : a process is a set of equations on elementary flows describing both data and control.

Join-patterns provides a way to write concurrent, parallel and distributed computer programs by message passing. Compared to the use of threads and locks, this is a high level programming model using communication constructs model to abstract the complexity of concurrent environment and to allow scalability. Its focus is on the execution of a chord between messages atomically consumed from a group of channels.

References

↑ Lefebvre, J. (November 3, 2005). "Esterel v7 Reference Manual Version v7 30 – initial IEEE standardization proposal" (PDF). Esterel Technologies. Archived from the original (PDF) on December 30, 2005.
↑ "Esterel in Racket". docs.racket-lang.org.
↑ Berry, Gérard (1999). "The Constructive Semantics of Pure Esterel". CiteSeerX 10.1.1.46.2076 .
↑ Berry, Gérard (June 2000). "The Esterel v5 Language Primer". Ecole des Mines and INRIA. CiteSeerX 10.1.1.3.1177 .
↑ Berry, Gérard; Gonthier, Georges (November 1992). "The Esterel synchronous programming language: Design, semantics, implementation". Science of Computer Programming. 19 (2): 87–152. CiteSeerX 10.1.1.17.5606 . doi:10.1016/0167-6423(92)90005-V.

External links

The Esterel Language at Inria
The Columbia Esterel Compiler an open-source compiler

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.

[1] Lefebvre, J. (November 3, 2005). "Esterel v7 Reference Manual Version v7 30 – initial IEEE standardization proposal" (PDF). Esterel Technologies. Archived from the original (PDF) on December 30, 2005.

[2] "Esterel in Racket". docs.racket-lang.org.

[3] Berry, Gérard (1999). "The Constructive Semantics of Pure Esterel". CiteSeerX 10.1.1.46.2076 .

[4] Berry, Gérard (June 2000). "The Esterel v5 Language Primer". Ecole des Mines and INRIA. CiteSeerX 10.1.1.3.1177 .

[5] Berry, Gérard; Gonthier, Georges (November 1992). "The Esterel synchronous programming language: Design, semantics, implementation". Science of Computer Programming. 19 (2): 87–152. CiteSeerX 10.1.1.17.5606 . doi:10.1016/0167-6423(92)90005-V.

[1]

[2]

[3]

[4]

[5]