A Pragmatic Approach to Stateful Partial Order Reduction

Partial order reduction (POR) is a classic technique for dealing with the state explosion problem in model checking of concurrent programs. Theoretical optimality, i.e., avoiding enumerating equivalent interleavings, does not necessarily guarantee optimal overall performance of the model checking algorithm. The computational overhead required to guarantee optimality may by far cancel out any benefits that an algorithm may have from exploring a smaller state space of interleavings. With a focus on overall performance, we propose new algorithms for stateful POR based on the recently proposed source sets, which are less precise but more efficient than the state of the art in practice. We evaluate efficiency using an implementation that extends Java Pathfinder in the context of verifying concurrent data structures

Using synchronizing heuristics to construct homing sequences

Computing a shortest synchronizing sequence of an automaton is an NP-Hard problem. There are well-known heuristics to find short synchronizing sequences. Finding a shortest homing sequence is also an NP-Hard problem. Unlike existing heuristics to find synchronizing sequences, homing heuristics are not widely studied. In this paper, we discover a relation between synchronizing and homing sequences by creating an automaton called homing automaton. By applying synchronizing heuristics on this automaton we get short homing sequences. Furthermore, we adapt some of the synchronizing heuristics to construct homing sequences

Vérification formelle de structures de données concurrentes

Modern automated services rely on concurrent software where multiple requests are processed by different processes at the same time. These processes execute concurrently either in a single machine or in a distributed system with multiple machines built on top of a network. The requests are typically about processing data which is stored in data structures that provide implementations of common abstract data types (ADTs) such as queues, key-value stores, and sets. The data structures themselves are concurrent in the sense that they support operations that can execute concurrently at the same time. Developing such concurrent data structures or even understanding and reasoning about them can be tricky. This is coming from the fact that synchronization between operations of these data structures must be minimized to reduce response time and increase throughput, yet this minimal amount of synchronization must also be adequate to ensure conformance to their specification. These opposing statements, along with the general challenge in reasoning about interleavings between operations make concurrent data structures a ripe source of insidious programming errors that are difficult to reproduce, locate, or fix. Therefore, verification techniques that can check the correctness of a concurrent data structure or (if it is not correct) that can detect, pinpoint and fix the errors in it, are invaluable. In this thesis, we introduce new algorithmic approaches for improving the reliability of concurrent data structures. For shared-memory data structures (where processes communicate using a shared memory), we introduce new algorithms for finding safety violations (if any) and repairing the implementation in order to exclude these violations. For data structures running on top of a network, we focus on the underlying consensus protocols and provide a new proof methodology for checking their safety specification which is based on refinement.Les services automatisés modernes reposent sur des logiciels concurrents où plusieurs demandes sont traitées par différents processus en même temps. Ces processus s'exécutent simultanément sur une seule machine ou dans un système distribué avec plusieurs machines reliés par un réseau. Les demandes concernent généralement le traitement de données stockées dans des structures de données qui fournissent des implémentations de types de données abstraits (ADT) courants tels que des files d'attente, des tables clé-valeur et des ensembles. Les structures de données elles-mêmes sont concurrentes dans le sens où elles permettent des opérations qui peuvent s'exécuter simultanément. Développer de telles structures de données concurrentes ou même les comprendre et raisonner dessus peut être difficile. Cela vient du fait que la synchronisation entre les opérations de ces structures de données doit être minimisée pour réduire le temps de réponse et augmenter le débit, mais cette synchronisation doit également être adéquate pour assurer la conformité à leur spécification. Ces contraintes qui s'opposent, ainsi que le défi général du raisonnement sur les entrelacements entre les opérations, font des structures de données concurrentes une source d'erreurs de programmation insidieuses, difficiles à reproduire, localiser ou corriger. Par conséquent, les techniques de vérification qui peuvent vérifier la correction d'une structure de données concurrente ou (si elle n'est pas correcte) qui peuvent détecter, identifier et corriger les erreurs qu'elle contient, sont très importantes. Dans cette thèse, nous introduisons de nouvelles approches algorithmiques pour améliorer la fiabilité des structures de données concurrentes. Pour les structures de données à mémoire partagée (où les processus communiquent à l'aide d'une mémoire partagée), nous introduisons de nouveaux algorithmes pour trouver les violations de sûreté (le cas échéant) et réparer l'implémentation afin d'exclure ces violations. Pour les structures de données qui m'exécutent au-dessus d'un réseau, nous nous concentrons sur les protocoles de consensus sous-jacents et nous fournissons une nouvelle méthodologie de preuve basée sur le raffinement pour vérifier leur spécification de sûreté

Vérification formelle de structures de données concurrentes

Les services automatisés modernes reposent sur des logiciels concurrents où plusieurs demandes sont traitées par différents processus en même temps. Ces processus s'exécutent simultanément sur une seule machine ou dans un système distribué avec plusieurs machines reliés par un réseau. Les demandes concernent généralement le traitement de données stockées dans des structures de données qui fournissent des implémentations de types de données abstraits (ADT) courants tels que des files d'attente, des tables clé-valeur et des ensembles. Les structures de données elles-mêmes sont concurrentes dans le sens où elles permettent des opérations qui peuvent s'exécuter simultanément. Développer de telles structures de données concurrentes ou même les comprendre et raisonner dessus peut être difficile. Cela vient du fait que la synchronisation entre les opérations de ces structures de données doit être minimisée pour réduire le temps de réponse et augmenter le débit, mais cette synchronisation doit également être adéquate pour assurer la conformité à leur spécification. Ces contraintes qui s'opposent, ainsi que le défi général du raisonnement sur les entrelacements entre les opérations, font des structures de données concurrentes une source d'erreurs de programmation insidieuses, difficiles à reproduire, localiser ou corriger. Par conséquent, les techniques de vérification qui peuvent vérifier la correction d'une structure de données concurrente ou (si elle n'est pas correcte) qui peuvent détecter, identifier et corriger les erreurs qu'elle contient, sont très importantes. Dans cette thèse, nous introduisons de nouvelles approches algorithmiques pour améliorer la fiabilité des structures de données concurrentes. Pour les structures de données à mémoire partagée (où les processus communiquent à l'aide d'une mémoire partagée), nous introduisons de nouveaux algorithmes pour trouver les violations de sûreté (le cas échéant) et réparer l'implémentation afin d'exclure ces violations. Pour les structures de données qui m'exécutent au-dessus d'un réseau, nous nous concentrons sur les protocoles de consensus sous-jacents et nous fournissons une nouvelle méthodologie de preuve basée sur le raffinement pour vérifier leur spécification de sûreté.Modern automated services rely on concurrent software where multiple requests are processed by different processes at the same time. These processes execute concurrently either in a single machine or in a distributed system with multiple machines built on top of a network. The requests are typically about processing data which is stored in data structures that provide implementations of common abstract data types (ADTs) such as queues, key-value stores, and sets. The data structures themselves are concurrent in the sense that they support operations that can execute concurrently at the same time. Developing such concurrent data structures or even understanding and reasoning about them can be tricky. This is coming from the fact that synchronization between operations of these data structures must be minimized to reduce response time and increase throughput, yet this minimal amount of synchronization must also be adequate to ensure conformance to their specification. These opposing statements, along with the general challenge in reasoning about interleavings between operations make concurrent data structures a ripe source of insidious programming errors that are difficult to reproduce, locate, or fix. Therefore, verification techniques that can check the correctness of a concurrent data structure or (if it is not correct) that can detect, pinpoint and fix the errors in it, are invaluable. In this thesis, we introduce new algorithmic approaches for improving the reliability of concurrent data structures. For shared-memory data structures (where processes communicate using a shared memory), we introduce new algorithms for finding safety violations (if any) and repairing the implementation in order to exclude these violations. For data structures running on top of a network, we focus on the underlying consensus protocols and provide a new proof methodology for checking their safety specification which is based on refinement

Quorum tree abstractions of consensus protocols

Distributed algorithms solving agreement problems like consensus or state machine replication are essential components of modern fault-tolerant distributed services. They are also notoriously hard to understand and reason about. Their complexity stems from the different assumptions on the environment they operate with, i.e., process or network link failures, Byzantine failures etc. In this paper, we propose a novel abstract representation of the dynamics of such protocols which focuses on quorums of responses (votes) to a request (proposal) that form during a run of the protocol. We show that focusing on such quorums, a run of a protocol can be viewed as working over a tree structure where different branches represent different possible outcomes of the protocol, the goal being to stabilize on the choice of a fixed branch. This abstraction resembles the description of recent protocols used in Blockchain infrastructures, e.g., the protocol supporting Bitcoin or Hotstuff. We show that this abstraction supports reasoning about the safety of various algorithms, e.g., Paxos, PBFT, Raft, and HotStuff, in a uniform way. In general, it provides a novel induction based argument for proving that such protocols are safe