## Section: New Results

### Automatic distribution of synchronous programs

Participants : Mouaiad Alras, Alain Girault [ contact person ] .

#### Modular distribution

Synchronous programming languages describe functionally centralized
systems, where every value, input, output, or function are always
directly available for every operation. However, most embedded systems
are nowadays composed of several computing resources. The aim of this
work is to provide a language-oriented solution to describe
*functionally distributed reactive systems* . This research is
conducted within the INRIA large scale action Synchronics and
is a joint work with Gwenaël Delaval (Sardes team from Grenoble) and
Marc Pouzet (Orsay University and Proval team from Saclay).

We are working on type systems to formalize, in an uniform way, both
the clock calculus and the location calculus of a synchronous
data-flow programming language (the Heptagon language,
inspired from Lucid Synchrone [33] ). On one
hand, the clock calculus infers the clock of each variable in the
program and checks the clock consistency: e.g., a time-homogeneous
function, like `+` , should not be applied to variables of
different clocks. On the other hand, the location calculus infers
the spatial distribution of computations and checks the spatial
consistency: e.g., a centralized operator, like `+` , should not
be applied to variables located on different locations. Compared to
the recent PhD of Gwenaël Delaval [43] , [44] ,
the goal is to achieve *modular* distribution. By modular, we
mean that we want to compile each function of the program into a
single function capable of running on any computing location. We make
use of our uniform type system to express the computing locations as
first-class abstract types, exactly like clocks, which allows us to
compile a typed variable (typed by both the clock and the location
calculi) into `if ... then ... else ...` structures.

#### Model-based development of fault-tolerant embedded systems, code generation for distributed heterogeneous platforms

Model-based design (MBD) involves designing a model of a control system, simulating and debugging it with dedicated tools, and finally generating automatically code corresponding to this model. In the domain of embedded systems, it offers the huge advantage of avoiding the time-consuming and error-prone final coding phase. The main issue raised by MBD is the faithfulness of the generated code with respect to the initial model, the latter being defined by the simulation semantics. To bridge the gap between the high-level model and the low-level implementation, we use the synchronous programming language Lustre as an intermediary formal model [54] . Concretely, starting from a high-level model specified in the de-facto standard Simulink, we first generate Lustre code along with some necessary structured “glue code”, and then we generate embedded real-time code for the Xenomai RTOS(http://www.xenomai.org ). Thanks to Lustre's clean mathematical semantics, we are able to guarantee the faithfulness of the generated multi-tasked real-time code [14] . This is the topic of the PhD of Mouaiad Alras, co-advised by Alain Girault and Pascal Raymond (CNRS, Verimag).