Asynchronous neighborhood task synchronization

Faults are likely to occur in distributed systems. The motivation for designing self-stabilizing system is to be able to automatically recover from a faulty state. As per Dijkstra\u27s definition, a system is self-stabilizing if it converges to a desired state from an arbitrary state in a finite number of steps. The paradigm of self-stabilization is considered to be the most unified approach to designing fault-tolerant systems. Any type of faults, e.g., transient, process crashes and restart, link failures and recoveries, and byzantine faults, can be handled by a self-stabilizing system; Many applications in distributed systems involve multiple phases. Solving these applications require some degree of synchronization of phases. In this thesis research, we introduce a new problem, called asynchronous neighborhood task synchronization ( NTS ). In this problem, processes execute infinite instances of tasks, where a task consists of a set of steps. There are several requirements for this problem. Simultaneous execution of steps by the neighbors is allowed only if the steps are different. Every neighborhood is synchronized in the sense that all neighboring processes execute the same instance of a task. Although the NTS problem is applicable in nonfaulty environments, it is more challenging to solve this problem considering various types of faults. In this research, we will present a self-stabilizing solution to the NTS problem. The proposed solution is space optimal, fault containing, fully localized, and fully distributed. One of the most desirable properties of our algorithm is that it works under any (including unfair) daemon. We will discuss various applications of the NTS problem

On the Limits and Practice of Automatically Designing Self-Stabilization

A protocol is said to be self-stabilizing when the distributed system executing it is guaranteed to recover from any fault that does not cause permanent damage. Designing such protocols is hard since they must recover from all possible states, therefore we investigate how feasible it is to synthesize them automatically. We show that synthesizing stabilization on a fixed topology is NP-complete in the number of system states. When a solution is found, we further show that verifying its correctness on a general topology (with any number of processes) is undecidable, even for very simple unidirectional rings. Despite these negative results, we develop an algorithm to synthesize a self-stabilizing protocol given its desired topology, legitimate states, and behavior. By analogy to shadow puppetry, where a puppeteer may design a complex puppet to cast a desired shadow, a protocol may need to be designed in a complex way that does not even resemble its specification. Our shadow/puppet synthesis algorithm addresses this concern and, using a complete backtracking search, has automatically designed 4 new self-stabilizing protocols with minimal process space requirements: 2-state maximal matching on bidirectional rings, 5-state token passing on unidirectional rings, 3-state token passing on bidirectional chains, and 4-state orientation on daisy chains

The Weakest Failure Detector for Solving Wait-Free, Eventually Bounded-Fair Dining Philosophers

This dissertation explores the necessary and sufficient conditions to solve a variant of the dining philosophers problem. This dining variant is defined by three properties: wait-freedom, eventual weak exclusion, and eventual bounded fairness. Wait-freedom guarantees that every correct hungry process eventually enters its critical section, regardless of process crashes. Eventual weak exclusion guarantees that every execution has an infinite suffix during which no two live neighbors execute overlapping critical sections. Eventual bounded fairness guarantees that there exists a fairness bound k such that every execution has an infinite suffix during which no correct hungry process is overtaken more than k times by any neighbor. This dining variant (WF-EBF dining for short) is important for synchronization tasks where eventual safety (i.e., eventual weak exclusion) is sufficient for correctness (e.g., duty-cycle scheduling, self-stabilizing daemons, and contention managers). Unfortunately, it is known that wait-free dining is unsolvable in asynchronous message-passing systems subject to crash faults. To circumvent this impossibility result, it is necessary to assume the existence of bounds on timing properties, such as relative process speeds and message delivery time. As such, it is of interest to characterize the necessary and sufficient timing assumptions to solve WF-EBF dining. We focus on implicit timing assumptions, which can be encapsulated by failure detectors. Failure detectors can be viewed as distributed oracles that can be queried for potentially unreliable information about crash faults. The weakest detector D for WF-EBF dining means that D is both necessary and sufficient. Necessity means that every failure detector that solves WF-EBF dining is at least as strong as D. Sufficiency means that there exists at least one algorithm that solves WF-EBF dining using D. As such, our research goal is to characterize the weakest failure detector to solve WF-EBF dining. We prove that the eventually perfect failure detector 3P is the weakest failure detector for solving WF-EBF dining. 3P eventually suspects crashed processes permanently, but may make mistakes by wrongfully suspecting correct processes finitely many times during any execution. As such, 3P eventually stops suspecting correct processes

Mechanically supported design of self-stabilizing algorithms

Het schrijven van een programma is vaak veel gemakkelijker dan te bewijzen dat een programma doet wat het moet doen. Daarbij wordt onze samenleving steeds afhankelijker van computers; men denke daarbij aan complexe programmatuur die de verkeersleiding van treinen of vliegtuigen regelt, die de administratie van de eectenhandel bijhoudt of die besluit of de stormvloedkering al dan niet neergelaten moet worden. Om de kwaliteit van programmatuur te kunnen garanderen, wordt ze uitgebreid getest. Dit wordt meestal gedaan met de probeer-en-faal methode, waarbij een pro- gramma op testinvoer wordt losgelaten en er vervolgens wordt gekeken of het aan de verwachtingen van de programmeur en klant voldoet. Deze manier van testen elimi- neert helaas niet alle fouten. We horen dan ook vaak mensen over bugs in programma's praten. Softwarefabrikanten komen regelmatig met nieuwe versies van hun produkten die de bugs van de vorige versie niet meer bevatten. Dat klopt vaak wel, maar helaas is het eerder regel dan uitzondering dat de nieuwere versie nieuwe bugs bevat. Kortom, bugs lijken als een soort onvermijdbare erfenis in programma's voor te komen. Voor een programma zoals een tekstverwerking kunnen we best wel met een bug of twee leven, maar van een studenten-administratiesyteem verwachten we toch dat het pro- gramma niet onbedoeld met de cijfers van de studenten omgaat. We verwachten ook, om een paar andere voorbeelden te noemen, dat onze prive brieven die elektronisch via het Internet worden verzonden niet per ongeluk aan het verkeerde adres worden afgeleverd, of dat een elektronisch besturingsysteem van een vliegtuig niet plotseling weigert. Met de genoemde probeer-en-faal testmethode kunnen wij slechts constateren dat tijdens een test alles goed ging. Helaas is het veelal onmogelijk alle toestanden waarin een computersysteem zich kan bevinden na gaan met een test. Dat zou veel te veel tijd kosten of is soms zelfs theoretisch nietuitvoerbaar, nog daargelaten of het commercieel acceptabel zou zijn. Een andere methode die tot een betere softwarekwaliteit kan leiden is de volledig formele aanpak; hierbij is een programmeur verplicht om een wiskundig bewijs van de correctheid van zijn programma te leveren. Meestal wordt een programma hierbij ontworpen tegelijkertijd met het construeren van een bewijs dat het programma aan de specicatie voldoet. Er wordt gebruik gemaakt van een speciaal soort wiskunde (vaak programma-logica genoemd) voor het redeneren over eigenschappen van een pro- gramma. Met deze methode kan men bewijzen dat een programma qua ontwerp fout- loos is, zonder dat men het programma zelf hoeft te testen. Dit betekent nog niet dat in de praktijk het geproduceerde programma echt foutloos zal zijn, want het ontwerp is maar een van de vele stadia |alhoewel een van de belangrijkste| in het produceren van software. Wel kunnen wij zeggen dat het resultaat betrouwbaarder zal zijn. Net zoals dat wij fouten kunnen maken bij het schrijven van een programma, kun- nen wij helaas ook fouten maken bij het geven van een bewijs. Een gecompliceerd?Page 236 programma vraagt meestaal ook een gecompliceerd bewijs. De kans om fouten te maken zal toenemen, en het is niet onwaarschijnlijk dat een denkfout die gemaakt wordt bij het ontwerpen van een programma ook gemaakt wordt bij het construeren van een correctheidsbewijs voor dat programma. Parallel met het ontwikkelen van formele methoden, is ook de technologie om bewi- jzen te kunnen veri?eren met de computer ge?evolueerd. Deze technologie noemen we mechanisch vericatie en het computerprogramma die dat doet noemen we (niet echt passend) een stellingbewijzer. Een stellingbewijzer wordt gebaseerd op een handvol axiomas en bewijsregels. De consistentie en zinvolheid van deze axiomas en bewijs- regels zijn veelal al uitgebreid bestudeerd en er bestaat consensus over hun consis- tentie. Het bewijs van een nieuwe stelling kan alleen worden geconstrueerd door het herhaaldelijk toepassing van de bewijsregels, uitgaande van de axiomas. De juistheid van deze nieuwe stellingen wordt dus afgedwongen door de manier waarop ze wor- den gebouwd. In veel stellingbewijzers kan men ook nieuwe bewijsregels denieren in termen van reeds bestaande (primitieve) bewijsregels. Deze nieuwe stellingen en bewi- jstactieken zijn vaak krachtiger dan de ingebouwde en kunnen dus leiden tot kortere en meer inzichtelijke bewijzen. In dit proefschrift wordt speciaal aandacht besteed aan zogenaamde gedistribueerde programma's. Een gedistribueerd programma is een programma dat bestaat uit samen- werkende componenten |elke component heeft meestal een eigen processor. Zulke pro- gramma's worden heel veel gebruikt, bijvoorbeeld in het Internet waarbij computers uit de hele wereld in een groot elektronisch netwerk worden verbonden. Boodschappen van de ene computer moeten, via tussen-computers, worden verstuurd naar de bestem- mingscomputer. Op elk van deze tussen-computers draait een component van een routeringsprogramma. Deze routeringsprogramma's hebben kennis van (een gedeelte) van de structuur van het netwerk. Omdat het netwerk voortdurend van vorm veran- dert (er kunnen verbindingen bijkomen of wegvallen, en er kunnen tussen-computers aangezet en uitgezet worden) moeten deze computers het netwerk zelf gebruiken om samen uit te vinden hoe de globale structuur is. Zo'n routeringsprogramma is een voorbeeld van een gedistribueerd programma. Omdat het vaak om veel componenten gaat die over, tussen, met en door elkaar werken, is het redeneren over een gedistribueerd programma moeilijk. In dit proefschrift bestuderen we de programma-logica UNITY die speciaal ontworpen is omte redeneren over eigenschappen van gedistribueerde programma's [CM88]. UNITY is klein en sim- pel, en daarom aantrekkelijk. Toch is programma's ontwerpen met UNITY, in onze ervaring, vaak erg lastig. Er ontbreekt een systematische ontwerpmethodologie, en sommige ontwerptechnieken bleken niet ondersteund te (kunnen) worden. We hebben dus UNITY uitgebreid, vooral om technieken rond het opsplitsen van programma in parallel werkende componenten beter te ondersteunen. Er worden voorbeelden gegeven om te laten zien hoe we de specicatie van een probleem kunnen vereenvoudigen door een geschikte opsplitsing te kiezen. We besteden daarbij vooral aandacht aan zogenaamde zelf-stabiliserende, gedis- tribueerde programma's. Een zelf-stabiliserend programma is een programma dat het systeem weer in een gewenste toestand kan brengen als het daar, door een externe?Page 237 verstoring, uit geraakt is. Ook als er tijdens dit herstellen weer nieuwe verstoringen optreden is dat geen probleem voor dergelijke systemen. We hebben UNITY uitge- breid met een reeks van stellingen om over zulke programma's te kunen redeneren. We behandelen een groot voorbeeld, het zogenaamde Eerlijk en Herhaaldelijk Toepassing (EHT) programma. Het EHT programma is een gedistribueerd programma dat een bepaalde klasse van problemen zelf-stabiliserend kan oplossen (uitrekenen). Dit boek is uniek omdat het niet alleen over formele methoden of over het bewi- jzen van een of ander moeilijk programma gaat, maar omdat vrijwel alle resultaten mechanisch geverieerd zijn met een stellingbewijzer! Onze ervaring met mechanisch vericatie wordt ook in dit boek beschreven. Mensen die ook met mechanisch veri- catie van gedistribueerde programma's willen beginnen zullen veel onderwerpen in dit boek interessant vinden. Tot slot willen we benadrukken dat het beoefenen van formele methoden vereist dat programmeurs een goed ontwikkelde wiskundige handvaardigheid hebben. Het eectief opereren met een stellingbewijzer is tot nu toe, helaas, slechts voorbehouden aan een handjevol specialisten. Het is begrijpelijk dat de industrie twijfelt aan de economisch waarde van formele methoden. Toch zullen mensen vroeg of laat, naar mate wij steeds afhankelijker worden van computers, ontdekken hoe kwetsbaar ze zijn als er fouten in computers optreden. In de toekomst zullen mensen dus gedwongen zijn om naar stellingbewijzers te kijken. Investeren in de technologie van mechanisch vericatie en in het opleiden van 'formele' programmeurs, is daarom, naar onze mening, geen weg gegooide moeite.

Computer Aided Verification

This open access two-volume set LNCS 11561 and 11562 constitutes the refereed proceedings of the 31st International Conference on Computer Aided Verification, CAV 2019, held in New York City, USA, in July 2019. The 52 full papers presented together with 13 tool papers and 2 case studies, were carefully reviewed and selected from 258 submissions. The papers were organized in the following topical sections: Part I: automata and timed systems; security and hyperproperties; synthesis; model checking; cyber-physical systems and machine learning; probabilistic systems, runtime techniques; dynamical, hybrid, and reactive systems; Part II: logics, decision procedures; and solvers; numerical programs; verification; distributed systems and networks; verification and invariants; and concurrency

Proceedings of the 22nd Conference on Formal Methods in Computer-Aided Design – FMCAD 2022

The Conference on Formal Methods in Computer-Aided Design (FMCAD) is an annual conference on the theory and applications of formal methods in hardware and system verification. FMCAD provides a leading forum to researchers in academia and industry for presenting and discussing groundbreaking methods, technologies, theoretical results, and tools for reasoning formally about computing systems. FMCAD covers formal aspects of computer-aided system design including verification, specification, synthesis, and testing

Information Infrastructures in Distributed Environments: Algorithms for Mobile Networks and Resource Allocation

A distributed system is a collection of computing entities that communicate with each other to solve some problem. Distributed systems impact almost every aspect of daily life (e.g., cellular networks and the Internet); however, it is hard to develop services on top of distributed systems due to the unreliable nature of computing entities and communication. As handheld devices with wireless communication capabilities become increasingly popular, the task of providing services becomes even more challenging since dynamics, such as mobility, may cause the network topology to change frequently. One way to ease this task is to develop collections of information infrastructures which can serve as building blocks to design more complicated services and can be analyzed independently. The first part of the dissertation considers the dining philosophers problem (a generalization of the mutual exclusion problem) in static networks. A solution to the dining philosophers problem can be utilized when there is a need to prevent multiple nodes from accessing some shared resource simultaneously. We present two algorithms that solve the dining philosophers problem. The first algorithm considers an asynchronous message-passing model while the second one considers an asynchronous shared-memory model. Both algorithms are crash fault-tolerant in the sense that a node crash only affects its local neighborhood in the network. We utilize failure detectors (system services that provide some information about crash failures in the system) to achieve such crash fault-tolerance. In addition to crash fault-tolerance, the first algorithm provides fairness in accessing shared resources and the second algorithm tolerates transient failures (unexpected corruptions to the system state). Considering the message-passing model, we also provide a reduction such that given a crash fault-tolerant solution to our dining philosophers problem, we implement the failure detector that we have utilized to solve our dining philosophers problem. This reduction serves as the first step towards identifying the minimum information regarding crash failures that is required to solve the dining philosophers problem at hand. In the second part of this dissertation, we present information infrastructures for mobile ad hoc networks. In particular, we present solutions to the following problems in mobile ad hoc environments: (1) maintaining neighbor knowledge, (2) neighbor detection, and (3) leader election. The solutions to (1) and (3) consider a system with perfectly synchronized clocks while the solution to (2) considers a system with bounded clock drift. Services such as neighbor detection and maintaining neighbor knowledge can serve as a building block for applications that require point-to-point communication. A solution to the leader election problem can be used whenever there is a need for a unique coordinator in the system to perform a special task