Une logique de programme mécanisée pour les programmes concurrents dans le modèle mémoire faible de Multicore OCaml

A mechanized program logic for concurrent programs with the weak memory model of Multicore OCaml

• Auteur / Autrice : Glen Mével
• Direction : François Pottier
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 14/12/2022
• Etablissement(s) : Université Paris Cité
• Ecole(s) doctorale(s) : École doctorale Sciences mathématiques de Paris centre (Paris ; 2000-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire Méthodes formelles (Gif-sur-Yvette, Essonne ; 2021-....)
• Jury : Président / Présidente : Ralf Treinen
• Jury : Examinateurs / Examinatrices : Ralf Treinen, Aleksandar Nanevski, Mark Batty, Azalea Raad, Stephen Dolan
• Jury : Rapporteurs / Rapporteuses : Aleksandar Nanevski, Mark Batty

Mots clés

Mots clés contrôlés

Programmation logique

Vérification de modèles (informatique)

Programmation concurrente

Objective Caml (langage de programmation)

Mots clés libres

Programmation

Concurrence

Mémoire faible

Vérification

Logique de séparation

OCaml

Programming

Concurrency

Weak memory

Verification

Separation logic

OCaml

Résumé

Multicore OCaml ajoute au langage de programmation OCaml le support de la concurrence à mémoire partagée. Ce langage étendu obéit à un modèle faible de la mémoire dont une sémantique opérationnelle a été publiée. On peut alors se demander de quels principes de raisonnement on dispose pour s'assurer de la correction d'un programme écrit en Multicore OCaml. Pour y répondre, on instancie Iris, un descendant moderne de la Logique de Séparation Concurrente, pour Multicore OCaml. On obtient une logique de programme de bas niveau, dont les règles de raisonnement exposent les détails techniques du modèle mémoire. Au-dessus de cette logique, on construit Cosmo, une logique de plus haut niveau dans laquelle on jouit de règles plus simples, au prix d'une légère limitation concernant les programmes qu'on peut vérifier. Cosmo offre des raisonnements naturels à propos des variables non-atomiques si elles sont exemptes de courses de données; à propos des variables atomiques; et à propos de la synchronisation en deux temps (acquisition/relâchement, ou «release/acquire») que ces dernières réalisent. La synchronisation entre fils d'exécution est transcrite de façon concise par un mécanisme de vues de la mémoire, qui permet de s'abstraire du modèle sous-jacent. On illustre l'emploi de cette logique de programme par plusieurs études de cas. On vérifie plusieurs implémentations de verrous vis-à-vis d'une spécification classique. On spécifie et vérifie également une structure de données concurrente élaborée et réaliste: une file concurrente multi-écrivains et multi-lecteurs. Dans chacun de ces cas, la spécification de la structure de données considérée décrit son comportement de synchronisation indépendamment de son implémentation et du modèle mémoire sur laquelle cette implémentation repose. On parvient à ce résultat par l'emploi combiné de vues et de «triplets logiquement atomiques». Ainsi, cette approche de la vérification est modulaire vis-à-vis du modèle mémoire: une application qui utilise ces structure de données comme seul moyen de synchronisation peut être vérifiée sans aucune connaissance du modèle mémoire de Multicore OCaml.

Multicore OCaml extends OCaml with support for shared-memory concurrency. It is equipped with a weak memory model, for which an operational semantics has been published. This begs the question: what reasoning rules can one rely upon while writing or verifying Multicore OCaml code? To answer it, we instantiate Iris, a modern descendant of Concurrent Separation Logic, for Multicore OCaml. This yields a low-level program logic whose reasoning rules expose the details of the memory model. On top of it, we build a higher-level logic, Cosmo, which trades off some expressive power in return for a simple set of reasoning rules that allow accessing non-atomic locations in a data-race-free manner, exploiting the sequentially-consistent behavior of atomic locations, and exploiting the release/acquire behavior of atomic locations. Cosmo allows both low-level reasoning, where the details of the Multicore OCaml memory model are apparent, and high-level reasoning, which is independent of this memory model. We illustrate this claim via a number of case studies. We verify several implementations of locks with respect to a classic specification. We also specify and verify a realistic, sophisticated concurrent data structure: namely, a multiple-producer multiple-consumer concurrent queue. In each case, the specification describes the memory behavior of the data structure independently of its implementation¿and of the underlying memory model. We achieve this through the joint use of so-called "logically atomic triples" and of Cosmo's views. Thus, Cosmo's approach to verification is modular with respect to the memory model: a coarse-grained application that uses these data structures as the sole means of synchronization can be verified without any knowledge of the weak memory model.