Séparation et interférence en jeux concurrents

Separation and interference in concurrent games

• Auteur / Autrice : Victor Blanchi
• Direction : Pierre Clairambault
• Type : Projet de thèse
• Discipline(s) : Informatique
• Date : Inscription en doctorat le 01/09/2024
• Etablissement(s) : Aix-Marseille
• Ecole(s) doctorale(s) : Ecole Doctorale Mathématiques et Informatique de Marseille
• Partenaire(s) de recherche : Laboratoire : LIS Laboratoire d'Informatique et Systèmes

Mots clés

Mots clés libres

Théorie des catégories

Théorie des langages de programmation

Sémantique dénotationnelle

Category theory

Theory of programming languages

Denotational semantics

Résumé

Une évolution notable du monde des langages de programmation dans la dernière décennie est l'essor du langage Rust. Rust permet de combiner une gestion bas niveau de la mémoire (sans GC) avec une sûreté des accès mémoire garantie par typage. Pour ce faire, son système de types se base sur un principe d'ownership des ressources mémoire. Un processus ne peut affecter une ressource que s'il détient l'ownership, garantissant que la ressource n'a pas été désallouée. De même, le caractère affine du système de types garantit qu'aucun autre processus n'a l'ownership, interdisant les conflits mémoire. Bien que Rust vienne du monde de l'industrie, plusieurs des idées que ce langage met en œuvre ont des précurseurs dans la littérature scientifique: son système de type affine rappelle la logique linéaire, et en particulier son instrumentalisation pour formaliser le langage Syntactic Control of Interference (SCI) de Reynolds; à noter que l'étude sémantique de SCI a également inspiré la logique de séparation, qui a récemment amené avec Infer à une des applications industrielles les plus marquantes de ce côté des méthodes formelles. Pour autant, Rust n'a pas de sémantique claire, son système de types n'est pas prouvé sûr. Récemment, le projet RustBelt mené par Dreyer a visé à prouver corrects des fragments de Rust au sein de l'outil de formalisation en logique de séparation Iris. Rust est basé sur la sémantique opérationnelle; d'autres approches plus compositionnelles existent pour approcher la sémantique de Rust, par exemple via des traductions fonctionnelles. Mais à notre connaissance, personne ne s'est essayé à étudier même des fragments minimes de Rust avec des outils de sémantique dénotationnelle. Ceux-ci pourraient pourtant être complémentaires des approches existantes et s'avérer plus explicatives; l'enjeu est de mieux comprendre les structures mathématiques compositionnelles interactives, s'il y en a, derrière la sûreté à la Rust. Le fil central de cette thèse est l'objectif de proposer une sémantique dénotationnelle justifiant la sûreté de langages concurrents, d'ordre supérieur avec ressources partagées (e.g. références mutables) et munis d'un système de types qui, à l'instar de Rust, interdit certaines fautes mémoire. Crucialement, le modèle doit prouver cette sûreté (par exemple, en représentant les programmes par des structures satisfaisant une forme adéquate de déterminisme) et faire apparaître les structures compositionnelles interactives qui la sous-tendent. Notre outil pour attaquer ce problème sera le cadre des jeux concurrents, qui rendent explicite la structure causale présente dans le comportement interactif des programmes: un programme est représenté par une stratégie qui trace les événements calculatoires observables, avec leurs dépendances et indépendances causales. Les jeux concurrents sont un modèle expressif proposant une des représentations du comportement interactif des programmes les plus fines sur le marché. Cette structure causale semble naturelle (voire nécessaire) pour exprimer l'absence d'interférence entre processus, propriété qui ressemble à une indépendance causale.

A notable evolution in the world of programming languages over the past decade is the rise of the Rust language. Rust allows combining low-level memory management (without a garbage collector) with memory access safety guaranteed by typing. To achieve this, its type system is based on the principle of ownership of memory resources. A process can only affect a resource if it holds ownership, ensuring that the resource has not been deallocated. Similarly, the affine nature of the type system guarantees that no other process holds ownership, preventing memory conflicts. Although Rust originates from the industrial world, several ideas implemented by this language have precursors in the scientific literature: its affine type system recalls linear logic, particularly its application to formalize Reynolds' language Syntactic Control of Interference (SCI). It's worth noting that the semantic study of SCI also inspired separation logic, which recently led to one of the most significant industrial applications of formal methods, through Infer. However, Rust lacks a clear semantics, and its type system has not been proven safe. Recently, the RustBelt project led by Dreyer aimed to prove the correctness of fragments of Rust within the separation logic formalization tool Iris. Rust is based on operational semantics; other more compositional approaches exist to address the semantics of Rust, for example, via functional translations. But to our knowledge, no one has attempted to study even minimal fragments of Rust using denotational semantics tools. Yet, these could complement existing approaches and prove to be more explanatory; the challenge is to better understand the compositional interactive mathematical structures, if any, behind Rust's safety. The central theme of this thesis is the goal of proposing a denotational semantics that justifies the safety of concurrent languages, with higher-order shared resources (e.g., mutable references), equipped with a type system that, like Rust, prevents certain memory errors. Crucially, the model must prove this safety (for example, by representing programs with structures that satisfy an appropriate form of determinism) and reveal the interactive compositional structures that underlie it. Our tool for tackling this problem will be the framework of concurrent games, which makes explicit the causal structure present in the interactive behavior of programs: a program is represented by a strategy that traces observable computational events, with their causal dependencies and independencies. Concurrent games are an expressive model offering one of the finest representations of the interactive behavior of programs available. This causal structure seems natural (even necessary) to express the absence of interference between processes, a property that resembles causal independence.