The synchronous languages have demonstrated in the past their pertinence, both from the theoretical point of view (the so-called synchronous/reactive model of computation) and from the industrial point of view (Airbus A340 and A380 civil airplanes, EDF nuclear plants, railway signaling, system-on-chip for consumer electronics, etc.). There also exist a variety of environment or platforms for the development of embedded systems : Matlab + Simulink/StateFlow, Scilab + Scicos which both account for programming and simulation, Ptolemy II which incorporates various models of computation, and so on.
Nonetheless, the current industrial application domain of synchronous languages is still limited and could be applied to a much wider range of applications, provided that we give answer to two kinds of questions. The first one is the co-simulation of mixed discrete-continuous specifications, and more generally the co-simulation of programs (deterministic, fully specified objects) and properties (partial descriptions/specifications, either discrete or continuous). This in turn raises the question of the interaction between programs and various kinds of differential equations solvers, the adequate module systems and typing disciplines to structure the whole system and way to get both efficient code and efficient simulation such that the very same code can be used for both simulation and code generation.
The second one, as important, is the ability, inside the programming model, to account for the architecture constraints (execution time, memory footprint, energy, power, reliability, etc.). The goal is to define compilation methods for modern (mainly parallel) architectures and such that synchronous language could be used for programming, and not only for modeling as it is often the case as of today. This raises the question of the relationship with traditional compilation techniques (parallelization and optimization methods, intermediate representation like SSA for scalar code generalized to data-flow systems, link with polyhedral methods and abstract representation of data-dependences). Existing solutions, mainly based on programming in low level sequential languages, are not satisfactory for programming modern parallel architectures. We can see a growing understanding (in the compilation community and beyond) that better programming languages and models are absolutely necessary to program parallel machines while preserving programmer productivity, keeping a precise control over resources, and aiming for a high efficiency (StreamIt is mostly a coordination language but a clear example of that trend, although it lacks the clean synchronous model of computation).
Having these two objectives in mind, we shall follow a language-centered approach, focusing our efforts on the development of a language and using it as a laboratory for experimenting our research results. This is thus a pragmatic point of view which can be related to the Ptolemy project. Our technical approach shall be slightly different nonetheless, since we choose to stick within the synchronous model of concurrency and time, to account for heterogeneous simulation and to address programming issues for parallel architectures. In doing so, our goal is to provide a programming language with modern features, including type inference, polymorphism, dedicated type systems (such as the so-called clock calculus or program analysis to ensure safety properties as well as modular compilation and portability of performance.
We advocate that it is the right moment for launching this research and development program for two reasons. On the one hand, the underlying synchronous languages technology is now mature, from the programming languages point of view (e.g., the evolution from Lustre to Lucid Synchrone), the semantics point of view (e.g., the theoretical results on MoCs), the compiling point of view (e.g, rich type-systems, dedicated program analysis, code generation for various platforms) or verification. On the other hand, there is an actual need for mixing programming and simulation, and for encompassing in a unique environment continuous and discrete programs. There is also the observation that the synchronous model of time is expressive enough to account for other models of computation (e.g., discrete-event and continuous). We base our proposal on the development of a synchronous programming language providing state-of-the-art language features to increase safety (such as rich type systems or modules), associated to advanced compilation techniques (multi-threaded and multi-processors) and allowing to mix discrete-continuous systems (possibly including partially specified components). Basing the language on a unique synchronous model will make it easier to design a common sound semantics for all the language features and shall simplifies remaining test and verification steps ; this approach has proved to be crucial for the industrial success of the synchronous languages. Finding efficient ways to perform the early simulation of mixed discrete-continuous programs is also essential in the design flow of today’s embedded systems. Providing such a simulation tool along with the above-mentioned code generation tools is an original point of our project.
- Pascal Raymond
- Erwan Jahier