Scade 6: A Formal Language for Embedded Critical Software Development

International audienceSCADE is a high-level language and environment for developing safety critical embedded control software. It is used for more than twenty years in various application domains like avionics, nuclear plants, transportation, automotive. SCADE has been founded on the synchronous data-flow language Lustre invented by Caspi and Halbwachs. In the early years, it was mainly seen as a graphical notation for Lustre but with the unique and key addition of a code generator qualified with the highest standards for safety critical applications.In 2008, a major revision based on the new language 'Scade 6' was released. This language originally combines the Lustre data-flow style with control structures borrowed from Esterel and SyncCharts, compilation and static analyses from Lucid Synchrone to ensure safety properties. This expressiveness increase for SCADE together with a qualified code generator have dramatically widened the scope of applications developed with.While previous publications have described some of its language constructs and compiler algorithms, no reference publication on 'Scade 6' existed so far. In this paper, we come back to the decisions made for its design, illustrate the main language features, static analyses, and the compiler organization in the context of a qualification process

Inférer et vérifier les tailles de tableaux avec des types polymorphes

National audienceCet article présente un système de vérification et d'inférence statique des tailles de tableaux dans un langage fonctionnel strict statiquement typé. Plutôt que de s'en remettre à des types dépendants, nous proposons un système de types proche de celui de ML. Le polymorphisme sert à définir des fonctions génériques en type et en taille. L'inférence permet une écriture plus légère des opérations classiques de traitement du signal-application point-à-point, accumulation, projection, transposée, convolution-et de leur composition ; c'est un atout clef de la solution proposée. Pour obtenir un bon compromis entre expressivité du langage des tailles et décidabilité de la vérification et de l'inférence, notre solution repose sur deux éléments : (i) un langage de types où les tailles sont des polynômes multi-variés et (ii) l'insertion de points de coercition explicites entre tailles dans le programme source. Lorsque le programme est bien typé, il s'exécute sans erreur de taille en dehors de ces points de coercition. Deux usages de la proposition faite ici peuvent être envisagés : (i) la génération de code défensif aux points de coercition ou, (ii) pour les applications critiques ou intensives, la vérification statique des coercitions en les limitant à des expressions évaluables à la compilation ou par d'autres moyens de vérification formelle. L'article définit le langage d'entrée, sa sémantique dynamique, son système de types et montre sa correction. Il est accompagné d'une implémentation en OCaml, dont le code source est accessible publiquement

Inférence parallèle pour un langage réactif probabiliste

National audienceProbZelus est un langage synchrone probabiliste qui permet de décrire des modèles probabilistes réactifs en interaction avec un environnement observable. Des méthodes d'inférences réactives permettent d'apprendre en ligne les distributions associées aux paramètres non-observés du modèle à partir d'observations statistiques. Ce problème n'a, en général, pas de solution analytique simple. Pour obtenir des estimations précises, une méthode classique consiste à analyser les résultats obtenus par de nombreuses exécutions indépendantes du modèle. Ces méthodes sont coûteuses, mais ont l'avantage de pouvoir être massivement parallélisées. Nous proposons d'utiliser JAX pour paralléliser les méthodes d'inférence réactive de ProbZelus. JAX est une bibliothèque récente qui permet de paralléliser automatiquement du code Python qui peut ensuite être exécuté de manière efficace et transparente sur CPU, GPU, ou TPU. Dans cet article, nous décrivons un nouveau moteur d'inférence réactive parallèle implémenté en JAX et le nouveau backend JAX associé pour ProbZelus. Nous montrons sur des exemples existants que notre nouvelle implémentation surpasse l'implémentation séquentielle originale pour un nombre de particules élevé

Scade 6: from a Kahn Semantics to a Kahn Implementation for Multicore

International audienceSCADE is an environment for developing critical embedded software that is used for more than twenty years in various application domains like avionics, nuclear plants, transportation, automotive. It comes with a language and a code generator which complies with the highest safety standards like DO-178C, IEC 61508, EN 50128, IEC 60880 and ISO 26262. The language has been founded on the pioneering work by Caspi and Halbwachs on Lustre. In 2008, a major revision of the language and compiler, named 'Scade 6', was released. One of its novelty was a smooth integration of the traditional data-flow style of Lustre with control-structures inspired from those of Esterel and SyncCharts, with static/dynamic semantics and a compilation inspired from Lucid Synchrone. In particular, it relies on four dedicated type systems-typing, clock calculus, causality analysis, initialization analysis-and a compilation through source-to-source transformations into a minimal clocked data-flow language, based on a Kahn semantics, that is translated to imperative code. One ongoing work is the generation of code for multi-core architectures. Because of the intrinsic deterministic parallelism of Scade, we propose a solution that relies on annotations that specify what must be executed concurrently but do not change the semantics. The paper is a survey of past to ongoing work on Scade 6 language definition and implementation

Programmation d'Applications Réactives Probabilistes

International audienceLes langages synchrones ont été introduits pour concevoir des systèmes embarqués temps-réel. Ces langages dédiés permettent d'écrire une spécification précise du système, de la simuler, la valider par du test ou de la vérification formelle puis de la compiler vers du code exécutable. Cependant, ils offrent un support limité pour modéliser les comportements non-déterministes qui sont omniprésents dans les systèmes embarqués. Dans cet article, nous présentons ProbZélus, une extension probabiliste d'un langage synchrone descendant de Lustre. ProbZélus permet de décrire des modèles probabilistes réactifs en interaction avec un environnement observable. Lors de l'exécution, un ensemble de techniques d'inférence peut être utilisé pour apprendre les distributions de paramètres du modèle à partir de données observées. Nous illustrons l'expressivité de ProbZélus avec des exemples comme un détecteur de trajectoire à partir d'observations bruitées, ou un contrôleur de robot capable d'inférer à la fois sa position et une carte de son environnement

Programmation d'Applications Réactives Probabilistes

National audienceLes langages synchrones ont été introduits pour concevoir des systèmes embarqués temps-réel. Ces langages dédiés permettent d'écrire une spécification précise du système, de la simuler, la valider par du test ou de la vérification formelle puis de la compiler vers du code exécutable. Cependant, ils offrent un support limité pour modéliser les comportements non-déterministes qui sont omniprésents dans les systèmes embarqués. Dans cet article, nous présentons ProbZélus, une extension probabiliste d'un langage synchrone descendant de Lustre. ProbZélus permet de décrire des modèles probabilistes réactifs en interaction avec un environnement observable. Lors de l'exécution, un ensemble de techniques d'inférence peut être utilisé pour apprendre les distributions de paramètres du modèle à partir de données observées. Nous illustrons l'expressivité de ProbZélus avec des exemples comme un détecteur de trajectoire à partir d'observations bruitées, ou un contrôleur de robot capable d'inférer à la fois sa position et une carte de son environnement

A Synchronous Look at the Simulink Standard Library

International audienceHybrid systems modelers like Simulink come with a rich collection of discrete-time and continuous-time blocks. Most blocks are not defined in terms of more elementary ones—and some cannot be—but are instead written in imperative code and explained informally in a reference manual. This raises the question of defining a minimal set of orthogonal programming constructs such that most blocks can be programmed directly and thereby given a specification that is mathematically precise, and whose compiled version performs comparably to handwritten code. In this paper, we show that a fairly large set of blocks of a standard library like the one provided by Simulink can be programmed in a precise, purely functional language using stream equations, hierarchical automata, Ordinary Differential Equations (ODEs), and deterministic synchronous parallel composition. Some blocks cannot be expressed in our setting as they mix discrete-time and continuous-time signals in unprincipled ways that are statically forbidden by the type checker. The experiment is conducted in Zélus, a synchronous language that conservatively extends Lustre with ODEs to program systems that mix discrete-time and continuous-time signals

Conception, sémantique et implantation de réactiveML (un langage à la ML pour la programmation réactive)

PARIS-BIUSJ-Thèses (751052125) / SudocGRENOBLE-INRIA Rhône-Alpes (383972301) / SudocPARIS-BIUSJ-Mathématiques rech (751052111) / SudocSudocFranceF

ReactiveML, a Reactive Extension to ML

We present ReactiveML, a programming language dedicated to the implementation of complex reactive systems as found in graphical user interfaces, video games or simulation problems. The language is based on the reactive model introduced by Boussinot. This model combines the so-called synchronous model found in Esterel which provides instantaneous communication and parallel composition with classical features found in asynchronous models like dynamic creation of processes. The language comes as a conservative extension of an existing call-by-value ML language and it provides additional constructs for describing the temporal part of a system. The language receives a behavioral semantics à la Esterel and a transition semantics describing precisely the interaction between ML values and reactive constructs. It is statically typed through a Milner type inference system and programs are compiled into regular ML programs. The language has been used for programming several complex simulation problems (e.g., routing protocols in mobile ad-hoc networks)