Compilation vérifiée d'un langage synchrone à flots de données avec machines à etats

Verified compilation of a synchronous dataflow language with state machines

• Auteur / Autrice : Basile Pesin
• Direction : Marc Pouzet
• Type : Projet de thèse
• Discipline(s) : Informatique
• Date : Inscription en doctorat le ; Soutenance le 13/10/2023
• Etablissement(s) : Université Paris sciences et lettres
• Ecole(s) doctorale(s) : École doctorale Sciences mathématiques de Paris centre (Paris ; 2000-....)
• Partenaire(s) de recherche : Laboratoire : DIENS - Département d'informatique de l'École normale supérieure
• Partenaire(s) de recherche : établissement opérateur d'inscription : École normale supérieure (Paris ; 1985-....)
• Jury : Président / Présidente : Florence Maraninchi
• Jury : Examinateurs / Examinatrices : Marc Pouzet, Timothy Bourke, Magnus Myreen, Robert De simone, Julien Forget, Carlos Agon, Xavier Leroy
• Jury : Rapporteur / Rapporteuse : Magnus Myreen, Robert De simone

Mots clés

Mots clés libres

Ingénierie Logicielle

Méthodes formelles

Systèmes embarqués

Langages Synchrones

Vérification Formelle

Assistants de Preuve

Software Engineering

Formal Verification

Formal Methods

Proof Assistants

Embedded Systems

Synchronous Languages

Résumé

Les systèmes embarqués critiques sont souvent spécifiés par des formalismes schéma-bloc. SCADE Suite est un environnement de développement pour ces systèmes utilisé depuis vingt ans dans l'industrie avionique, nucléaire, automobile, et autres domaines critiques. Son formalisme graphique se traduit en une représentation textuelle basée sur le langage synchrone à flots de données Lustre, et incorpore des fonctionnalités de langages plus récents comme Lucid Synchrone. En Lustre, un programme est défini comme un ensemble d'équations qui spécifie la relation entre entrées et sorties du programme à chaque instant. Le langage des expressions inclut des opérateurs arithmétiques et logiques, des opérateurs de délais qui permettent d'accéder à la précédente valeur d'une expression, et des opérateurs d'échantillonage qui permettent à certaines valeurs d'être calculées moins souvent que d'autres. Le projet Vélus est une formalisation d'un sous-ensemble du langage Scade 6 dans l'assistant de preuves Coq. Il propose une formalisation de la sémantique dynamique du langage sous forme de relations entre flots infinis d'entrées et de sorties. Il inclut aussi un compilateur qui utilise CompCert, un compilateur vérifié pour C, pour produire du code assembleur. Enfin, il fournit une preuve de bout-en-bout que ce compilateur préserve la sémantique à flots de données des programmes sources. Cette thèse étends Vélus en y ajoutant des blocs de contrôles présents dans Scade 6 et Lucid Synchrone. Cela inclut une construction qui contrôle l'activation des équations selon une condition (switch), une construction permettant d'accéder à la valeur précédente d'une variable (last), une construction qui réinitialise les opérateurs de délai (reset), et, enfin, des machines à états hiérarchiques, qui permettent la spécification de comportements modaux complexes. Toutes ces constructions peuvent être arbitrairement imbriquées dans un programme. Nous étendons la sémantique de Vélus avec une nouvelle spécification pour ces constructions qui encode leur comportement par l'échantillonnage. Nous proposons un schéma d'induction générique pour les programmes bien formés qui permet de prouver certaines propriétés du modèle sémantique, comme son déterminisme ou l'adhérence des valeurs aux types déclarés. Enfin, nous décrivons la compilation de ces constructions telle qu'implémentée dans Vélus. Nous montrons que le modèle de compilation qui réécrit ces constructions dans le langage noyau peut être implémenté, spécifié et vérifié dans Coq. La compilation de last et reset nécessite des changements plus profonds dans les langages intermédiaires de Vélus.

Safety-critical embedded systems are often specified using block-diagram formalisms. SCADE Suite is a development environment for such systems which has been used industrially in avionics, nuclear plants, automotive and other safety-critical contexts for twenty years. Its graphical formalism translates to a textual representation based on the Lustre synchronous dataflow language, with extensions from later languages like Lucid Synchrone. In Lustre, a program is defined as a set of equations that relate inputs and outputs of the program at each discrete time step. The language of expressions at right of equations includes arithmetic and logic operators, delay operators that access the previous value of an expression, and sampling operators that allow some values to be calculated less often than others. The Vélus project aims at formalizing a subset of the Scade 6 language in the Coq Proof Assistant. It proposes a specification of the dynamic semantics of the language as a relation between infinite streams of inputs and outputs. It also includes a compiler that uses CompCert, a verified compiler for C, as its back end to produce assembly code, and an end-to-end proof that compilation preserves the semantics of dataflow programs. In this thesis, we extend Vélus to support control blocks present in Scade 6 and Lucid Synchrone. This includes a construction that controls the activation of equations based on a condition (switch), a construction that accesses the previous value of a named variable (last), a construction that re-initializes delay operators (reset), and finally, hierarchical state machines, which allow for the definition of complex modal behaviors. All of these constructions may be arbitrarily nested in a program. We extend the existing semantics of Vélus with a novel specification for these constructs that encodes their behavior using sampling. We propose a generic induction principle for well-formed programs, which is used to prove properties of the semantic model such as determinism and type-preservation. Finally, we describe the extension of the Vélus compiler to handle these new constructs. We show that the existing compilation scheme that lowers these constructs into the core dataflow language can be implemented, specified and verified in Coq. Compiling the reset and last constructs requires deeper changes in the intermediate languages of Vélus.