TTCC : Cohérence Causal Transactionnel par Tour

TTCC : Transactional-Turn Causal Consistency

• Auteur / Autrice : Benoît Martin
• Direction : Mesaac Makpamgou, Marc Shapiro
• Type : Thèse de doctorat
• Discipline(s) : Ingénierie / Systèmes Informatiques
• Date : Soutenance le 21/04/2023
• Etablissement(s) : Sorbonne université
• Ecole(s) doctorale(s) : École doctorale Informatique, télécommunications et électronique de Paris (1992-...)
• Partenaire(s) de recherche : Laboratoire : LIP6 (1997-....)
• Jury : Président / Présidente : Bernd Amann
• Jury : Examinateurs / Examinatrices : Carla Ferreira, Peter Van Roy, Annette Bieniusa
• Jury : Rapporteurs / Rapporteuses : Gaël Thomas, Achour Mostefaoui

Mots clés

Mots clés contrôlés

Informatique dans les nuages

Mémoire partagée répartie

Traitement réparti

Cohérence (informatique)

Mots clés libres

Cohérence causal

Systèmes distribués

Modèle acteur

Mémoire partagée

Causal consistency

Distributed systems

Actor model

Shared memory

Résumé

Les applications serverless sont construites à l'aide de frameworks asynchrones basés sur des messages qui permettent aux utilisateurs de composer de manière abstraite des fonctions dans le cloud. Très souvent, ces applications ont besoin de stocker leur état et de gérer la logique métier, comme l'authentification des utilisateurs, le traitement des flux en temps réel ou les espaces de travail collaboratifs. Le serverless avec état stocke l'état dans une base de données distribuée telle que DynamoDB. Ce scénario architectural courant est fragile car les garanties de cohérence des données pour la composition de la couche de messages et de la couche de base de données ne sont pas bien définies. Cela peut entraîner des incohérences, des pannes et des pertes de données. La cohérence est l'ensemble des règles qui contraignent l'ordre dans lequel les mises à jour (par exemple, l'envoi d'un message ou l'affectation d'une variable partagée) deviennent visibles (pour les récepteurs ou les lecteurs). Il existe de nombreux modèles de cohérence, allant de la sérialisation ou de la linéarisation stricte, où les mises à jour sont visibles instantanément par tous les processus, aux modèles de cohérence les plus faibles, où les mises à jour sont transmises aux nœuds distants dans un ordre imprévisible. La plupart des systèmes existants sont conçus pour communiquer soit par message, soit par mémoire partagée, mais pas les deux. Par conséquent, la littérature définit séparément les modèles de cohérence basés sur les messages et ceux basés sur les données. Cependant, le serverless combine les deux paradigmes. Maintenir des garanties de cohérence séparées n'est pas intuitif et peut conduire à des incohérences entre les garanties de transmission de messages et d'objets partagés. Un modèle de cohérence unifié pour le passage de messages et la mémoire partagée est nécessaire pour éviter de telles erreurs. Ce modèle doit garantir que plusieurs éléments de données restent cohérents, que les données soient envoyées par messages ou partagées dans une mémoire distribuée. Le serverless est asynchrone et donc incompatible avec une cohérence forte (par exemple, linéarisation ou sérialisation) car elle impose des exigences de synchronisation fortes. À l'autre extrémité du spectre, la cohérence éventuelle viole l'intuition. La cohérence causale est un modèle intermédiaire utile, parce qu'il est asynchrone, et en même temps fournit des garanties utiles qui facilitent le raisonnement. Notre modèle TTCC est un modèle transactionnel, causalement cohérent, mémoire-message, qui unifie le passage de messages et la mémoire partagée dans un environnement asynchrone et isolé.

Serverless computing applications are built using asynchronous message-based frameworks which enable users to abstractly compose functions in the cloud. Very often, applications need to store state and to handle business logic, such as user authentication, real-time stream processing or collaborative workspaces. Stateful serverless computing stores state in a distributed database such as DynamoDB. This common architectural scenario is brittle because the data consistency guarantees for the composition of the message layer and of the database layer are not well defined. This can result in inconsistency, crashes and data loss. Consistency is the set of rules that constraint the order in which updates (e.g. sending a message or assigns a shared variable) become visible (to receivers or to readers). There are many consistency models, ranging from strict serializability or linearizability, where become updates are visible instantaneously to all processes, to the weakest consistency models, where updates are delivered to remote nodes in no predictable order. Most existing systems are designed to communicate either by message or by shared memory, but not both. Therefore, the literature defines message-based and data-based consistency models separately. However, serverless computing combines both paradigms. Maintaining separate consistency guarantees is non-intuitive and can lead to inconsistencies between message-delivery and shared-object guarantees. A unified consistency model for message passing and shared memory is required to avoid such errors. The model should ensure that multiple pieces of data remain emph{mutually} consistent, whether data is sent using messages or shared in a distributed memory. Serverless computing is asynchronous and thus incompatible with strong consistency (e.g. linearizability or serializability) as it imposes strong synchronicity requirements. On the other end of the spectrum, eventual consistency violates intuition. Causal consistency is a useful intermediate model, because it is asynchronous, and at the same time provides useful guarantees that ease reasoning. Our TTCC model is a transactional, causally consistent, memory-message model, that unifies message passing and shared memory in an asynchronous and isolated environment.