L'approche synchrone est destinée aux programmeurs des systèmes réactifs temps-réel. En apportant des primitives de concurrence et de communication, les langages synchrones, tels que Signal, Lustre ou Esterel, permettent une spécification des systèmes à un haut niveau d'abstraction ; basés sur une sémantique forte, ils offrent les possibilités de vérification formelle et d'optimisations poussées.
Cette thèse se place dans le cadre de l'environnement Signal en explorant la répartition manuelle et semi-automatique de programmes flots-de-données synchrones. L'étude, basée sur un modèle dynamique, permet de combler les manques de la description statique habituellement utilisée. Ce modèle permet ainsi de décrire des exécutions synchronisées et désynchronisées, respectant tout ou partie de la sémantique synchrone traditionnelle.
Le prototype réalisé dans le cadre de ce travail met l'accent sur l'automatisation et la transparence des mécanismes de distribution, en introduisant les directives de répartition au sein même du langage Signal.

Modularity is advocated as a solution for the design of large systems, the mathematical translation of this concept is often that of compositionality. This paper is devoted the issues of compositionality aiming at modular code generation, for dataflow synchronous languages. As careless storing of object code for further reuse in systems design fails to work, we first concentrate on what are the additional features needed to abstract programs for the purpose of code generation: we show that a central notion is that of scheduling specification as resulting from a causality analysis of the given program. Then we study separate compilation for synchronous programs, and we discuss the issue of distributed implementation using an asynchronous medium of communication; for both topics we provide a complete formal study in the extended version [BlGA97] of this paper. Corresponding algorithms are currently under development in the framework of the DC+ common format for synchronous languages.

Synchronous data-flow programming is based on the abstraction of the continuous time into a discrete one. It offers verification and proof techniques appreciated by programmers of critical reactive systems. Armed with a strong semantics, the synchronous data-flow languages (Signal, Lustre,...) generally lead to strongly synchronized executions. In the case of distributed implementations, some constraints, introduced by the specification itself, are very prejudiciable in terms of performance.

To conciliate rigorous specification and efficient implementations, we introduce a new model for real-time applications, fitted to the synchronous approach, and ables to describe programs from their specifications to their final distributed implementations. Thanks to this model we show the desynchronization process leading to desynchronized executions from a synchronized specification.

SIGNAL, a synchronous and data-flow oriented langage, allows the user to design safe real-time applications. Its compiler uses a single formalism called Synchronized Data-Flow Graphs" (GFDS) all along the conception chain from specification to proof and verification. We show how this formalism can be kept on until distributed code generation. The implementation described here, called synchronous distribution, respects the semantics of SIGNAL. We finally show the limits of SDFGs and conclude on the necessity of another model describing dynamic behaviours of distributed executions.

Basés sur l'hypothèse d'un temps logique discret, les langages synchrones (SIGNAL, LUSTRE, ESTEREL) ont prouvé leur efficacité pour la conception d'application temps réel critiques sûres. Ils sont caractérisés par une sémantique forte offrant des techniques de vérification et de preuve.

SIGNAL, un des langages synchrone, est déclaratif et orienté flot de données. Dans ce langage, un signal est une succession de valeurs ; les instants de présence de ce signal sont appelés horloges. Tout au long de la conception, jusqu'à la phase finale de compilation , le compilateur SIGNAL utilise un seul formalisme appelé Graphe Flot de Données Synchronisé (GFDS).

Pour différentes raisons, telles la délocalisation géographique de capteurs, l'accélération de la fréquence de réponse ou une plus grande tolérance aux fautes, les applications temps-réel nécessitent une production de code distribué. Nous allons présenter une méthode de distribution fonctionnelle des programmes, et prouver qu'elle peut se faire par transformations successives du GFDS, ce qui permet de conserver ce formalisme jusqu'à la phase finale de génération de code distribué.

Après une rapide présentation du langage SIGNAL en nous intéressant plus particulièrement au GFDS, nous allons donner une méthode de propagation de directives de distribution du code source jusqu'au GFDS. Nous allons ensuite montrer comment les communications peuvent être introduites dans le GFDS, et comment la partie «contrôle» des programmes SIGNAL peut être distribuée pour obtenir sur chaque processeur, un sous-graphe indépendant des autres. Finalement, nous montrerons des implémentations possibles et des perspectives de ce travail.

Based on an abstraction of the time as a discrete logical time, the synchronous languages, armed with a strong semantics, enable the design of safe real-time applications. Some of them are of imperative style, while others are declarative. Academic and industrial teams involved in synchronous programming defined together three intermediate representations, on the way to standardization:

• IC, a parallel format of imperative style,
• GC, a parallel format of data-flow style,
• OC, a sequential format to describe automata.

In this paper, we describe more specifically the format GC, and its links with the synchronous data-flow language \signal. Thanks to the first experimentations, GC reveals itself as a powerful representation for graph transformations, code production, optimizations, hardware synthesis, etc.

The main concern of the research project ASAR is to build a multi-formalism framework towards archtectural synthesis. This paper describes the CENTAUR system, used to build this framework, and the common intermediate data-flow format GC, that will be the common denominator of the different formalisms and tools available in that framework.