Self-stabilization

The Meeting problem for k ≥ 2 searchers in a polygon P (possibly with holes) consists in making the searchers move within P , according to a distributed algorithm, in such a way that at least two of them eventually come to see each other, regardless of their initial positions. The polygon is initially unknown to the searchers, and its edges obstruct both movement and vision. Depending on the shape of P , we minimize the number of searchers k for which the Meeting problem is solvable. Specifically, if P has a rotational symmetry of order σ (where σ = 1 corresponds to no rotational symmetry), we prove that k = σ + 1 searchers are sufficient, and the bound is tight. Furthermore, we give an improved algorithm that optimally solves the Meeting problem with k = 2 searchers in all polygons whose barycenter is not in a hole (which includes the polygons with no holes). Our algorithms can be implemented in a variety of standard models of mobile robots operating in Look-Compute-Move cycles. For instance, if the searchers have memory but are anonymous, asynchronous, and have no agreement on a coordinate system or a notion of clockwise direction, then our algorithms work even if the initial memory contents of the searchers are arbitrary and possibly misleading. Moreover, oblivious searchers can execute our algorithms as well, encoding information by carefully positioning themselves within the polygon. This code is computable with basic arithmetic operations (provided that the coordinates of the polygon's vertices are algebraic real numbers in some global coordinate system), and each searcher can geometrically construct its own destination point at each cycle using only a compass and a straightedge. We stress that such memoryless searchers may be located anywhere in the polygon when the execution begins, and hence the information they initially encode is arbitrary. Our algorithms use a self-stabilizing map construction subroutine which is of independent interest.

We i n v estigate the problem of self-stabilizing round-robin token management s c heme on an anonymous bidirectional ring of identical processors, where each processor is an asynchronous probabilistic coin-ipping nite state machine which sends and receives messages. We show that the solution to this problem is equivalent to symmetry breaking i.e., leader election. Requiring only constant-size messages and message-passing model has practical implications: our solution can be implemented in high-speed networks using a universal fast hardware switches i.e., nite state machines of size independent of the size of the network. Our automata-based message-passing model has inherent deadlock possibility i.e., when all processors are waiting for a message which w e assume is detected by an external timeout mechanism. Provided that there is no deadlock to begin with, we show h o w starting from an arbitrary con guration, the system never enters a deadlock state and further stabilizes in polynomial time. We note that Dijkstra showed that the last problem does not have a deterministic solution even when the identical processors possess an arbitrary power: starting from a ring with a multitude of tokens, any deterministic system will either not stabilize or will enter a deadlock state.

Abstract| W e present a self-stabilizing token passing algorithm for a tree network. The algorithm is based on the 4-state mutual exclusion algorithm of Dijkstra 5] and works under the distributed daemon model of execution. Keywords|Distributed algorithms, fault-tolerance, mutual exclusion, self-stabilization, token passing.

We present a deterministic distributed depth-rst token passing protocol on a rooted network. This protocol does not use either the processor identi ers or the size of the network, but assumes the existence of a distinguished processor, called the root of the network. The protocol is self-stabilizing, meaning that starting from an arbitrary state (in response to an arbitrary perturbation modifying the memory state), it is guaranteed to reach a state with no more than one token in the network. The protocol implements a strictly fair token circulation|during a round, every processor obtains the token exactly once. The proposed protocol has extremely small memory requirement|only O(1) bits of memory per incident n e t work link.

Grid is a parallel and distributed computing network system comprising of heterogeneous computing resources spread over multiple administrative domains that offers high throughput computing. Since the Grid operates at a large scale, there is always a possibility of failure ranging from hardware to software. The penalty paid of these failures may be on a very large scale. System needs to be tolerant to various possible failures which, in spite of many precautions, are bound to happen. Replication is a strategy often used to introduce fault tolerance in the system to ensure successful execution of the job, even when some of the computational resources fail. Though replication incurs a heavy cost, a selective degree of replication can offer a good compromise between the performance and the cost. This chapter proposes a co-scheduler that can be integrated with main scheduler for the execution of the jobs submitted to computational Grid. The main scheduler may have any performance optimization criteria; the integration of co-scheduler will be an added advantage towards fault tolerance. The chapter evaluates the performance of the co-scheduler with the main scheduler designed to minimize the turnaround time of a modular job by introducing module replication to counter the effects of node failures in a Grid. Simulation study reveals that the model works well under various conditions resulting in a graceful degradation of the scheduler's performance with improving the overall reliability offered to the job.

Computational Grid attributed with distributed load sharing has evolved as a platform to large scale problem solving. Grid is a collection of heterogeneous resources, offering services of varying natures, in which jobs are submitted to any of the participating nodes. Scheduling these jobs in such a complex and dynamic environment has many challenges. Reliability analysis of the grid gains paramount importance because grid involves a large number of resources which may fail anytime, making it unreliable. These failures result in wastage of both computational power and money on the scarce grid resources. It is normally desired that the job should be scheduled in an environment that ensures maximum reliability to the job execution. This work presents a reliability based scheduling model for the jobs on the computational grid. The model considers the failure rate of both the software and hardware grid constituents like application demanding execution, nodes executing the job, and the ne...

In the framework of self-stabilizing systems, the convergence proof is generally done by exhibiting a measure that strictly decreases until a legitimate con guration is reached. The discovery of such a measure is very speci c and requires a deep understanding of the studied transition system. In contrast we propose here a simple method for proving convergence, which regards self-stabilizing systems as string rewrite systems, and adapts a procedure initially designed by Dershowitz for proving termination of string rewrite systems. In order to make the method terminate more often, we also propose an adapted procedure that manipulates \schemes", i.e. regular sets of words, and incorporate a process of scheme generalization. The interest of the method is illustrated on several nontrivial examples.

We present the design, correctness, and analysis of SONDe, a simple fully decentralized object deployment algorithm for highly requested systems. Given an object (service or data), SONDe provides a node with a constant upper bound (h) on the number of logical hops to access an object holder (provider), thus making tunable and predictable the communication latency between a node and any provider. In addition, SONDe is able to dynamically adapt the number of providers to reflect load variations experienced in localized portions of the system. Each node individually decides to be a provider, based on the observation of its h-hops neighborhood. We show theoretically that SONDe self-stabilizes and provides an independent-dominating set of providers. Finally simulation results, conducted over different network topologies, demonstrate the efficiency of the approach and confirm the theoretical analysis.

We describe how a virtual node abstraction layer could be used to coordinate the motion of real mobile nodes in a region of 2-space. In particular, we consider how nodes in a mobile ad hoc network can arrange themselves along a predetermined closed curve in the plane, and can maintain themselves in such a configuration in the presence of changes in the underlying mobile ad hoc network, specifically, when nodes may join or leave the system or may fail. Our strategy is to allow the mobile nodes to implement a virtual layer consisting of mobile client nodes, stationary virtual nodes (VNs) at predetermined locations in the plane, and local broadcast communication. The VNs coordinate among themselves to distribute the client nodes relatively evenly among the VNs' regions, and each VN directs its local client nodes to form themselves into the local portion of the target curve.

We describe how a set of mobile robots can arrange themselves on any specified curve on the plane in the presence of dynamic changes both in the underlying ad hoc network and in the set of participating robots. Our strategy is for the mobile robots to implement a self-stabilizing virtual layer consisting of mobile client nodes, stationary Virtual Nodes (VNs), and local broadcast communication. The VNs are associated with predetermined regions in the plane and coordinate among themselves to distribute the client nodes relatively uniformly among the VNs' regions. Each VN directs its local client nodes to align themselves on the local portion of the target curve. The resulting motion coordination protocol is self-stabilizing, in that each robot can begin the execution in any arbitrary state and at any arbitrary location in the plane. In addition, self-stabilization ensures that the robots can adapt to changes in the desired target formation.

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Tixeuil distingue les fautes sur l'état d'un processus ou sur le code de celui-ci et les fautes sur son exécution : 1.1 Contribution. La contribution de ce chapitre est de trois ordres : 1. On montre d'abord qu'il y a une connexion forte entre l'unisson synchrone et l'unisson asynchrone : quand un unisson asynchrone est implémenté sur un système synchrone alors il converge vers un unisson synchroneà la condition que K > M.C G. * → m ′. Alors r m (p.v 0) ≥ ⊕ r m′ (p.v 0) ; et si m estélémentaire, alors r m (p.v 0) =

We introduce a simple tool called the wavelet (or, r-wavelet) scheme. Wavelets deals with coordination among processes which are at most r hops away of each other. We present a selfstabilizing solution for this scheme. Our solution requires no underlying structure and works in arbritrary anonymous networks, i.e., no process identifier is required. Moreover, our solution works under any (even unfair) daemon. Next, we use the wavelet scheme to design self-stabilizing layer clocks. We show that they provide an efficient device in the design of local coordination problems at distance r, i.e., r-barrier synchronization and r-local resource allocation (LRA) such as r-local mutual exclusion (LME), r-group mutual exclusion (GME), and r-Reader/Writers. Some solutions to the r-LRA problem (e.g., r-LME) also provide transformers to transform algorithms written assuming any r-central daemon into algorithms working with any distributed daemon.

How to pass from local to global scales in anonymous networks? In such networks, how to organize a self-stabilizing propagation of information with feedback? From Angluin's results, the deterministic leader election is impossible in general anonymous networks. Thus, it is impossible to build a rooted spanning tree. In this paper we show how to use Unison to design a self- stabilizing barrier synchronization in an anonymous network. We show that the communication structure of this barrier synchronization designs a self-stabilizing wave stream, or pipelined wave, in anonymous networks. We introduce two variants of waves: Strong Wave and Wavelet. Strong waves can be used to solve the idempotent r-operator parametrized problem, which implies well known problems like depth-first search tree construction - this instance requires identities for the processors. Wavelets deal with ρ-distance computation. We show how to use Unison to design a self-stabilizing strong wave stream, and wave...

The undersigned certify that they have read, and recommend to the Faculty of Graduate Studies for acceptance, a thesis entitled "Dynamic and Self-stabilizing Distributed Matching" submitted by Subhendu Chattopadhyay in partial fulfillment of the requirements for the degree of Master of Science.

The problem of achieving optimal clock synchronization in a communication network with arbitrary topology and perfect clocks (that do not drift) is studied. A novel modular presentation of the problem is described which allows to deal with different assumptions for the delay of messages. We present a definition of clock synchronization under arbitrary delay assumptions, and present an optimal clock synchronization algorithm for general systems. We then show that in local systems (where delays on each link are independent of the other links) the inputs for the clock synchronization algorithm can be computed from the maximum local shifts for each pair of processors sharing a link. The maximum local shift for two processors depends only on their views. This allows our theory to deal with systems where different links adhere to different assumptions, or the same link satisfies several sets of assumptions; such mixtures are quite likely in practice. In particular, we show how to compute the maximum local shifts from the views, and hence provide optimal algorithms for systems where some links may have upper and/or lower bounds on the delay, some may have a bound on the difference between the delay in both directions, some may have both kinds of bounds and some may

The goal of the paper is to provide designers of distributed self-stabilizing protocols with a fair and reliable communication primitive which allows any process which writes a value in its own registers to make sure that every neighbour eventually does read that value. We assume a link-register communication model under read/write atomicity, where every process can read from but cannot write into its neighbours' registers. The primitive runs a self-stabilizing protocol which implements a \rendezvous" communication mechanism in the link-register asynchronous model. This protocol works in arbitrary networks and also solves the problem of how to simulate reliable self-stabilizing message-passing in asynchronous distributed systems.

Several schemes for checkpointing and rollback recovery have been reported in the literature. In this paper, we analyze some of these schemes under a stochastic model. We have derived expressions for average cost of checkpointing, rollback recovery, message logging and piggybacking with application messages in synchronous as well as asynchronous checkpointing. For quasi-synchronous checkpointing we show that in a system with n processes, the upper bound and lower bound of selective message logging are O(n 2) and O(n), respectively.

We propose a simple self-stabilizing distributed algorithm that maintains an arbitrary spanning tree in a connected graph. In proving the correctness of the algorithm we develop a new technique without using a bounded function (which is customary for proving correctness of self-stabilizing algorithms); the new approach is simple and can be potentially applied to proving correctness of other self-stabilizing algorithms.

The goal of decentralized consensus protocols is to exchange information among nodes so that each node acquires the information held by every other node in the system. This paper presents a quorum-based, self-stabilizing maxima finding protocol which is based on a decentralized consensus protocol. The protocol exchanges information with less delay than existing ring-based, self-stablizing protocols. Furthermore, quorums can be composed, and the resulting composite quorums can be used to efficiently obtain a solution for any internetwork.

We present an algorithm by which nodes arranged in a tree, with each node initially knowing only its parent and children, can construct a fault-tolerant communication structure (an expander graph) among themselves in a distributed and scalable way. The tree overlayed with this logical expander is a useful structure for distributed applications that require the intrinsic "treeness" from the topology but cannot afford any obstruction in communication due to failures. At the core of our construction is a novel distributed mechanism that samples nodes uniformly at random from the tree. In the event of node joins, node departures or node failures, the expander maintains its own fault tolerance and permits the reformation of the tree. We present simulation results to quantify the convergence of our algorithm to a fault tolerant network having both good vertex connectivity and expansion properties.

We present a self-stabilizing algorithm for the (asynchronous) unison problem which achieves an efficient trade-off between time, workload, and space in a weak model. Precisely, our algorithm is defined in the atomic-state model and works in anonymous networks in which even local ports are unlabeled. It makes no assumption on the daemon and thus stabilizes under the weakest one: the distributed unfair daemon. In a n-node network of diameter D and assuming a period B ≥ 2D + 2, our algorithm only requires O(log B) bits per node to achieve full polynomiality as it stabilizes in at most 2D−2 rounds and O(min(n 2 B, n 3)) moves. In particular and to the best of our knowledge, it is the first self-stabilizing unison for arbitrary anonymous networks achieving an asymptotically optimal stabilization time in rounds using a bounded memory at each node. Finally, we show that our solution allows to efficiently simulate synchronous self-stabilizing algorithms in an asynchronous environment. This provides a new state-of-the-art algorithm solving both the leader election and the spanning tree construction problem in any identified connected network which, to the best of our knowledge, beat all existing solutions of the literature.

In this paper, we formalize design patterns, commonly used in the self-stabilizing area, to obtain general statements regarding both correctness and time complexity guarantees. Precisely, we study a general class of algorithms designed for networks endowed with a sense of direction describing a spanning forest (e.g., a directed tree or a network where a directed spanning tree is available) whose characterization is a simple (i.e., quasi-syntactic) condition. We show that any algorithm of this class is (1) silent and self-stabilizing under the distributed unfair daemon, and (2) has a stabilization time which is polynomial in moves and asymptotically optimal in rounds. To illustrate the versatility of our method, we review several existing works where our results apply.

We propose a general scheme, called Algorithm STlC, to compute spanning-tree-like data structures on arbitrary networks. STlC is self-stabilizing and silent and, despite its generality, is also efficient. It is written in the locally shared memory model with composite atomicity assuming the distributed unfair daemon, the weakest scheduling assumption of the model. Its stabilization time is in O(nmaxCC) rounds, where nmaxCC is the maximum number of processes in a connected component. We also exhibit polynomial upper bounds on its stabilization time in steps and process moves holding for large classes of instantiations of Algorithm STlC. We illustrate the versatility of our approach by proposing several such instantiations that efficiently solve classical problems such as leader election, as well as, unconstrained and shortest-path spanning tree constructions.

We initiate research on self-stabilization in highly dynamic identified message-passing systems where dynamics is modeled using time-varying graphs (TVGs). More precisely, we address the selfstabilizing leader election problem in three wide classes of TVGs: the class T C B (∆) of TVGs with temporal diameter bounded by ∆, the class T C Q (∆) of TVGs with temporal diameter quasi-bounded by ∆, and the class T C R of TVGs with recurrent connectivity only, where T C B (∆) ⊆ T C Q (∆) ⊆ T C R. We first study conditions under which our problem can be solved. Precisely, we introduce the notion of size-ambiguity to show that the assumption on the knowledge of the number n of processes is central. Our results reveal that, despite the existence of unique process identifiers, any deterministic self-stabilizing leader election algorithm working in the TVG class T C Q (∆) or T C R cannot be size-ambiguous, justifying why our solutions for those classes assume the exact knowledge of n. We then present three self-stabilizing leader election algorithms for the TVG classes T C B (∆), T C Q (∆), and T C R , respectively.

In this paper, we address the problem of k-out-of-ℓ exclusion, a generalization of the mutual exclusion problem, in which there are ℓ units of a shared resource, and any process can request up to k units (1 ≤ k ≤ ℓ). We propose the first deterministic self-stabilizing distributed k-out-of-ℓ exclusion protocol in message-passing systems for asynchronous oriented tree networks which assumes bounded local memory for each process.

We propose several self-stabilizing protocols for unidirectional, anonymous, and uniform synchronous rings of arbitrary size, where processors communicate by exchanging messages. When the size of the ring $n$ is unknown, we better the service time by a factor of $n$ (performing the best possible complexity for the stabilization time and the memory consumption). When the memory size is known, we present a protocol that is optimal in memory (constant and independant of $n$), stabilization time, and service time (both are in $\Theta(n)$).

A novel injection locking architecture is demonstrated to simultaneously improve the axial mode linewidth and stabilize the repetition rate of a monolithically integrated modelocked laser. First linewidth reduction is demonstrated via multitone injection locking. Then the passive mode-locked laser is used as a source to make a coupled optoelectronic oscillator, and its RF spectral characteristics are investigated for different optical delays. A novel combination of these two techniques is established by creating a coupled optoelectronic oscillator via multi-tone injection locking, using an intracavity element as photodetector to generate the feedback signal to a Mach-Zehnder modulator. Using this combination of methods, the axial mode linewidth is reduced by over 6000x to ∼100 kHz and the RF linewidth is reduced by a factor of 70 at-30dBc, resulting in a 3 dB RF linewidth of 400 Hz. The improvement in RF phase noise at 200 kHz offset is >40 dB. Finally, the system is referenced to a RF synthesizer using a variable voltage phase-shifter and a PID controller. Allan deviation measurements show a resolution limited stability in the repetition rate of 10 −10 at 1 second following a 1/τ trend.

Despite the various attractive features that grid computing has to offer, it has many great security challenges, such as access control. With the expansion of the network scale, a large number of authorization requests have to be treated; on the other hand, the multi-domain nature of grid computing generates difficult to manage questions about cross-domain access control, and a variety of solutions use the role mapping mechanism to allow collaborations between domains. But this mechanism gives a potential risk of violating consistency properties of domains. This article aims to address this issue and proposes a parallel access control model in cross-domain grid computing architecture to be more convenient to the security requirements of the multi-domain environment. Finally, as a proof of concept, the authors implement a cross-domain and parallel authorization simulator (CD-PAS) where experiments are done. The obtained results show that the proposed model is sensitive to the number ...

Our work presents a self-stabilizing solution to the '-exclusion problem. This problem is a well-known generalization of the mutual-exclusion problem in which up to ', but never more than ', processes are allowed simultaneously in their critical sections. Self-stabilization means that even when transient failures occur and some processes crash, the system ÿnally resumes its regular and correct behavior. The model of communication assumed here is that of shared memory, in which processes use single-writer multiple-reader regular registers.

The emerging field of wireless sensor networks offers countless possibilities for achieving large scale monitoring in a distributed environment. These networks of resource constrained nodes require time synchronization for various distributed operations, but traditional protocols have significant overhead and rapidly deplete battery power. This paper addresses the challenges of sensor network engineering by proposing an efficient and secure time synchronization protocol named Tempest. The protocol reduces overhead and conserves power by using passive participation. It allows a node to infer the canonical time by simply overhearing the communication of its neighbors. It also authenticates protocol messages, and uses cross-layer control to manipulate counters in an encryption module to prevent attacks. Its implementation uses only minimal processing and negligible state, while an emphasis on reuse and modularity reduces code size. The protocol is implemented on embedded sensor node hardware, and is shown to substantially reduce overhead while maintaining the synchronization accuracy of recent related work. This reduction in overhead saves valuable energy, extending the lifetime of each sensor node and the lifetime of the sensor network itself.

A snap-stabilizing protocol, starting from any configuration, always behaves according to its specification. Here, we present the first snap-stabilizing protocol for arbitrary rooted networks which detects if a set of nodes is a cutset. This protocol is based on the depth-first search (DF S) traversal and its properties. One of the most interesting properties of our protocol is that, despite the initial configuration, as soon as the protocol is initiated by the root, the result obtained from the computations will be right. So, after the first execution of the protocol, the root is able to take a decision: "the input set is a cutset or not", and this decision is right.

A self-stabilizing algorithm, after transient faults hit the system and place it in some arbitrary global state, causes the system to recover in finite time without external (e.g., human) intervention. In this paper, we give a distributed asynchronous silent self-stabilizing algorithm for finding a minimal k-dominating set of at most n k+1 processes in an arbitrary identified network of size n. We give a transformer that allows our algorithm to work under an unfair daemon, the weakest scheduling assumption. The complexity of our solution is O(n) rounds and O(Dn 3) steps using O(log k + log n + k log N k) bits per process, where D is the diameter of the network and N is an upper bound on n.

This paper deals with the trade-off between time, workload, and versatility in self-stabilization, a general and lightweight fault-tolerant concept in distributed computing. In this context, we propose a transformer that provides an asynchronous silent self-stabilizing version T rans(AlgI) of any terminating synchronous algorithm AlgI. The transformed algorithm T rans(AlgI) works under the distributed unfair daemon and is efficient both in moves and rounds. Our transformer allows to easily obtain fully-polynomial silent self-stabilizing solutions that are also asymptotically optimal in rounds. We illustrate the efficiency and versatility of our transformer with several efficient (i.e., fully-polynomial) silent self-stabilizing instances solving major distributed computing problems, namely vertex coloring, Breadth-First Search (BFS) spanning tree construction, k-clustering, and leader election.

We initiate research on self-stabilization in highly dynamic identified message-passing systems where dynamics is modeled using time-varying graphs (TVGs). More precisely, we address the self-stabilizing leader election problem in three wide classes of TVGs: the class T C B (∆) of TVGs with temporal diameter bounded by ∆, the class T C Q (∆) of TVGs with temporal diameter quasi-bounded by ∆, and the class T C R of TVGs with recurrent connectivity only, where T C B (∆) ⊆ T C Q (∆) ⊆ T C R. We first study conditions under which our problem can be solved. We introduce the notion of size-ambiguity to show that the assumption on the knowledge of the number n of processes is central. Our results reveal that, despite the existence of unique process identifiers, any deterministic self-stabilizing leader election algorithm working in the class T C Q (∆) or T C R cannot be size-ambiguous, justifying why our solutions for those classes assume the exact knowledge of n. We then present three self-stabilizing leader election algorithms for Classes T C B (∆), T C Q (∆), and T C R , respectively. Our algorithm for T C B (∆) stabilizes in at most 3∆ rounds. In T C Q (∆) and T C R , stabilization time cannot be bounded, except for trivial specifications. However, we show that our solutions are speculative in the sense that their stabilization time in T C B (∆) is O(∆) rounds.

In this paper, we revisit two fundamental results of the self-stabilizing literature about silent BFS spanning tree constructions: the Dolev et al algorithm and the Huang and Chen's algorithm. More precisely, we propose in the composite atomicity model three straightforward adaptations inspired from those algorithms. We then present a deep study of these three algorithms. Our results are related to both correctness (convergence and closure, assuming a distributed unfair daemon) and complexity (analysis of the stabilization time in terms of rounds and steps).

We propose a silent self-stabilizing leader election algorithm for bidirectional arbitrary connected identified networks. This algorithm is written in the locally shared memory model under the distributed unfair daemon. It requires no global knowledge on the network. Its stabilization time is in Θ(n 3) steps in the worst case, where n is the number of processes. Its memory requirement is asymptotically optimal, i.e., Θ(log n) bits per processes. Its round complexity is of the same order of magnitude-i.e., Θ(n) rounds-as the best existing algorithms designed with similar settings. To the best of our knowledge, this is the first self-stabilizing leader election algorithm for arbitrary identified networks that is proven to achieve a stabilization time polynomial in steps. By contrast, we show that the previous best existing algorithms designed with similar settings stabilize in a non polynomial number of steps in the worst case.

In this paper, we present SASA, an open-source SimulAtor of Self-stabilizing Algorithms. Self-stabilization defines the ability of a distributed algorithm to recover after transient failures. SASA is implemented as a faithful representation of the atomic-state model (also called the locally shared memory model with composite atomicity). This model is the most commonly used one in the self-stabilizing area to prove both the correct operation of self-stabilizing algorithms and complexity bounds on them. SASA encompasses all features necessary to debug, test, and analyze self-stabilizing algorithms. All these facilities are programmable to enable users to accommodate to their particular needs. For example, asynchrony is modeled by programmable stochastic daemons playing the role of input sequence generators. Properties of algorithms can be checked using formal test oracles. The SASA distribution also provides several facilities to easily achieve (batch-mode) simulation campaigns. We show that the lightweight design of SASA allows to efficiently perform huge such campaigns. Following a modular approach, we have aimed at relying as much as possible the design of SASA on existing tools, including OCAML, DOT, and several tools developed in the Synchrone Group of the VERIMAG laboratory.

In distributed systems, resource allocation consists in managing fair access of a large number of processes to a typically small number of reusable resources. As soon as the number of available resources is greater than one, the efficiency in concurrent accesses becomes an important issue, as a crucial goal is to maximize the utilization rate of resources. In this paper, we tackle the concurrency issue in resource allocation problems. We first characterize the maximal level of concurrency we can obtain in such problems by proposing the notion of maximal concurrency. Then, we focus on Local Resource Allocation problems (LRA). Our results are both negative and positive. On the negative side, we show that there is a wide class of instances of LRA for which it is impossible to obtain maximal concurrency without compromising the fairness. On the positive side, we propose a snapstabilizing LRA algorithm which achieves a high (but not maximal) level of concurrency, called here strong concurrency.

In this paper, we address the problem of k-out-of-ℓ exclusion, a generalization of the mutual exclusion problem, in which there are ℓ units of a shared resource, and any process can request up to k units (1 ≤ k ≤ ℓ). We propose the first deterministic self-stabilizing distributed k-out-of-ℓ exclusion protocol in message-passing systems for asynchronous oriented tree networks which assumes bounded local memory for each process.

The paper presents three self-stabilizing protocols for basic fair and reliable link communication primitives. We assume a link-register communication model under read/write atomicity, where every process can read from but cannot write into its neighbours' registers. The first primitive guarantees that any process writes a new value in its register(s) only after all its neighbours have read the previous value, whatever the initial scheduling of processes' actions. The second primitive implements a "weak rendezvous" communication mechanism by using an alternating bit protocol: whenever a process consecutively writes n values (possibly the same ones) in a register, each neighbour is guaranteed to read each value from the register at least once. On the basis of the previous protocol, the third primitive implements a "quasi rendezvous": in words, this primitive ensures furthermore that there exists exactly one reading between two writing operations All protocols are self-stabilizing and run in asynchronous arbitrary networks. The goal of the paper is in handling each primitive by a separate procedure, which can be used as a "black box" in more involved self-stabilizing protocols.

The goal of the paper is to provide designers of distributed self-stabilizing protocols with a fair and reliable communication primitive which allows any process which writes a value in its own registers to make sure that every neighbour eventually does read that value. We assume a link-register communication model under read/write atomicity, where every process can read from but cannot write into its neighbours' registers. The primitive runs a self-stabilizing protocol which implements a \rendezvous" communication mechanism in the link-register asynchronous model. This protocol works in arbitrary networks and also solves the problem of how to simulate reliable self-stabilizing message-passing in asynchronous distributed systems.

The paper presents three self-stabilizing protocols for basic fair and reliable link communication primitives. We assume a link-register communication model under read/write atomicity, where every process can read from but cannot write into its neighbours' registers. The first primitive guarantees that any process writes a new value in its register(s) only after all its neighbours have read the previous value, whatever the initial scheduling of processes' actions. The second primitive implements a "weak rendezvous" communication mechanism by using an alternating bit protocol: whenever a process consecutively writes n values (possibly the same ones) in a register, each neighbour is guaranteed to read each value from the register at least once. On the basis of the previous protocol, the third primitive implements a "quasi rendezvous": in words, this primitive ensures furthermore that there exists exactly one reading between two writing operations All protocols are self-stabilizing and run in asynchronous arbitrary networks. The goal of the paper is in handling each primitive by a separate procedure, which can be used as a "black box" in more involved self-stabilizing protocols.

We assume a link-register communication model under read/write atomicity, where every process can read from but cannot write into its neighbours' registers. The paper presents two self-stabilizing protocols for basic fair and reliable link communication primitives. The first primitive guarantees that any process writes a new value in its register(s) only after all its neighbours have read the previous value, whatever the initial scheduling of processes' actions. The second primitive implements a "weak rendezvous" communication mechanism by using an alternating bit protocol: whenever a process consecutively writes n values (possibly the same ones) in a register, each neighbour is guaranteed to read each value from the register at least once. Both protocols are self-stabilizing and run in asynchronous arbitrary networks. The goal of the paper is in handling each primitive by a separate procedure, which can be used as a "black box" in more involved self-stabilizing protocols.

This paper presents a randomized self-stabilizing algorithm that elects a leader r in a general n-node undirected graph and constructs a spanning tree T rooted at r. The algorithm works under the synchronous message passing network model, assuming that the nodes know a linear upper bound on n and that each edge has a unique ID known to both its endpoints (or, alternatively, assuming the KT1 model). The highlight of this algorithm is its superior communication efficiency: It is guaranteed to send a total of Õ(n) messages, each of constant size, till stabilization, while stabilizing in Õ(n) rounds, in expectation and with high probability. After stabilization, the algorithm sends at most one constant size message per round while communicating only over the (n− 1) edges of T . In all these aspects, the communication overhead of the new algorithm is far smaller than that of the existing (mostly deterministic) self-stabilizing leader election algorithms. The algorithm is relatively simpl...