We consider distributed systems subject to frequent topological changes. Specifically, we assume the network topology evolves as a dynamic graph in which, at any point in time, the temporal distance between any two processes is at most $$\varDelta $$ . Under a synchronous message-passing model where processes have unique identifiers and know both $$\varDelta $$ and an upper bound N on the number of processes n, we provide a distributed self-stabilizing mutual exclusion algorithm working in that class of dynamic graphs. Our solution stabilizes in $$\mathcal{O}(\varDelta .N)$$ rounds using bounded local memories. Moreover, it achieves optimal waiting time: once stabilized, the maximum delay before a process enters its critical section is at most $$n-1$$ rounds. Our algorithm is actually a composition of several self-stabilizing building blocks that respectively achieve Leader Election, Unison, and Ranking. We also provide original self-stabilizing solutions for the latter two problems; for the self-stabilizing leader election, we use a solution given by Altisen et al. (Theoretical Computer Science, 2023).

We address the problem of Termination Detection (TD) in asynchronous networks. It is known that TD cannot be achieved in the context of self-stabilization, except in the specific case where the TD algorithm is snap-stabilizing, i.e., it always behaves according to its specification regardless of the initial configuration. In this paper, we propose a generic, deterministic, snap-stabilizing, silent algorithm that detects whether an observed terminating silent self-stabilizing algorithm, A, has converged to a configuration that satisfies an intended predicate. Our algorithm assumes that nodes know (an upper bound on) the network diameter D. However, it requires no underlying structure, nor specific topology (arbitrary network), and works in anonymous networks, i.e., our algorithm uses no kind of assumption allowing distinguishing one or more nodes. Furthermore, it works under the weakest scheduling assumptions a.k.a, the unfair daemon. Built over any asynchronous self-stabilizing underlying unison U, our solution adds only O(log D) bits per node. Since there exists no unison algorithm with better space complexity, the extra space of our solution is negligible w.r.t. the space complexity of the underlying unison algorithm. Our algorithm provides a positive answer in O(max (k, k’, D)) time units, where k and k’ are the stabilization time complexities of A and U, respectively.

We consider self-stabilization and its weakened form called pseudo-stabilization. We study conditions under which (pseudo- and self-) stabilizing leader election is solvable in networks subject to frequent topological changes. To model such an high dynamics, we use the dynamic graph (DG) paradigm and study a taxonomy of nine important DG classes. Our results show that self-stabilizing leader election can only be achieved in the classes where all processes are sources. Furthermore, even pseudo-stabilizing leader election cannot be solved in all remaining classes, except in the class where at least one process is a timely source. We illustrate that result by proposing a pseudo-stabilizing leader election algorithm for the latter class. We also show that in this last case, the convergence time of pseudo-stabilizing leader election algorithms cannot be bounded. Nevertheless, we show that our solution is speculative since its convergence time can be bounded when the dynamics is not too erratic, precisely when all processes are timely sources.

Abstract We consider swarms of asynchronous oblivious robots evolving into an anonymous grid-shaped network. In this context, we investigate optimal (w.r.t. the number of robots) deterministic solutions for the terminating exploration problem. We first show lower bounds in the semi-synchronous model. Precisely, we show that at least three robots are required to explore any grid of at least three nodes, even in the probabilistic case. Then, we show that at least four (resp. five) robots are necessary to deterministically explore a $\bf(2,2)$-Grid (resp. a $\bf(3,3)$-Grid). We then propose deterministic algorithms in the asynchronous model. This latter being strictly weakest than the semi-synchronous model, all the aforementioned bounds still hold in that context. Our algorithms actually exhibit the optimal number of robots that is necessary to explore a given grid. Overall, our results show that except in two particular cases, three robots are necessary and sufficient to deterministically explore a grid of at least three nodes and then terminate. The optimal number of robots for the two remaining cases is four for the $\bf(2,2)$-Grid and five for the $\bf(3,3)$-Grid, respectively.

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 TCB (Δ) of TVGs with temporal diameter bounded by Δ, the class TCB (Δ) of TVGs with temporal diameter quasi-bounded by Δ, and the class TCR of TVGs with recurrent connectivity only, where TCB (Δ) ⊆ TCB (Δ) ⊆ TCR. 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 TCB (Δ) or TCR 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 TCB (Δ), TCB(Δ), and TCR, respectively.

Two mobile agents represented by points freely moving in the plane and starting at two different positions, have to meet. The meeting, called rendezvous, occurs when agents are at distance at most r of each other and never move after this time, where r is a positive real unknown to them, called the visibility radius. Agents are anonymous and execute the same deterministic algorithm. Each agent has a set of private attributes, some or all of which can differ between agents. These attributes are: the initial position of the agent, its system of coordinates (orientation and chirality), the rate of its clock, its speed when it moves, and the time of its wake-up. If all attributes (except the initial positions) are identical and agents start at distance larger than r then they can never meet, as the distance between them can never change. However, differences between attributes make it sometimes possible to break the symmetry and accomplish rendezvous. Such instances of the rendezvous problem (formalized as lists of attributes), are called feasible.

In this paper we study the task of approach of two mobile agents having the same limited range of vision and moving asynchronously in the plane. This task consists in getting them in finite time within each other’s range of vision. The agents execute the same deterministic algorithm and are assumed to have a compass showing the cardinal directions as well as a unit measure. On the other hand, they do not share any global coordinates system (like GPS), cannot communicate and have distinct labels. Each agent knows its label but does not know the label of the other agent or the initial position of the other agent relative to its own. The route of an agent is a sequence of segments that are subsequently traversed in order to achieve approach. For each agent, the computation of its route depends only on its algorithm and its label. An adversary chooses the initial positions of both agents in the plane and controls the way each of them moves along every segment of the routes, in particular by arbitrarily varying the speeds of the agents. Roughly speaking, the goal of the adversary is to prevent the agents from solving the task, or at least to ensure that the agents have covered as much distance as possible before seeing each other. A deterministic approach algorithm is a deterministic algorithm that always allows two agents with any distinct labels to solve the task of approach regardless of the choices and the behavior of the adversary. The cost of a complete execution of an approach algorithm is the length of both parts of route travelled by the agents until approach is completed. Let $$\Delta $$ and l be the initial distance separating the agents and the length of (the binary representation of) the shortest label, respectively. Assuming that $$\Delta $$ andlare unknown to both agents, does there exist a deterministic approach algorithm always working at a cost that is polynomial in $$\Delta $$ andl? Actually the problem of approach in the plane reduces to the network problem of rendezvous in an infinite oriented grid, which consists in ensuring that both agents end up meeting at the same time at a node or on an edge of the grid. By designing such a rendezvous algorithm with appropriate properties, as we do in this paper, we provide a positive answer to the above question. Our result turns out to be an important step forward from a computational point of view, as the other algorithms allowing to solve the same problem either have an exponential cost in the initial separating distance and in the labels of the agents, or require each agent to know its starting position in a global system of coordinates, or only work under a much less powerful adversary.

A mobile agent equipped with a compass and a measure of length has to find an inert treasure in the Euclidean plane. Both the agent and the treasure are modeled as points. In the beginning, the agent is at a distance at most D>0 from the treasure, but knows neither the distance nor any bound on it. Finding the treasure means getting at distance at most 1 from it. The agent makes a series of moves. Each of them consists in moving straight in a chosen direction at a chosen distance. In the beginning and after each move the agent gets a hint consisting of a positive angle smaller than 2 pi whose vertex is at the current position of the agent and within which the treasure is contained. We investigate the problem of how these hints permit the agent to lower the cost of finding the treasure, using a deterministic algorithm, where the cost is the worst-case total length of the agent's trajectory. It is well known that without any hint the optimal (worst case) cost is Theta(D^2). We show that if all angles given as hints are at most pi, then the cost can be lowered to O(D), which is optimal. If all angles are at most beta, where beta<2 pi is a constant unknown to the agent, then the cost is at most O(D^{2-epsilon}), for some epsilon>0. For both these positive results we present deterministic algorithms achieving the above costs. Finally, if angles given as hints can be arbitrary, smaller than 2 pi, then we show that cost Theta(D^2) cannot be beaten.

We consider systems made of autonomous mobile robots evolving in highly dynamic discrete environment i.e., graphs where edges may appear and disappear unpredictably without any recurrence, stability, nor periodicity assumption. Robots are uniform (they execute the same algorithm), they are anonymous (they are devoid of any observable ID), they have no means allowing them to communicate together, they share no common sense of direction, and they have no global knowledge related to the size of the environment. However, each of them is endowed with persistent memory and is able to detect whether it stands alone at its current location. A highly dynamic environment is modeled by a graph such that its topology keeps continuously changing over time. In this paper, we consider only dynamic graphs in which nodes are anonymous, each of them is infinitely often reachable from any other one, and such that its underlying graph (i.e., the static graph made of the same set of nodes and that includes all edges that are present at least once over time) forms a ring of arbitrary size. In this context, we consider the fundamental problem of perpetual exploration: each node is required to be infinitely often visited by a robot. This paper analyzes the computability of this problem in (fully) synchronous settings, i.e., we study the deterministic solvability of the problem with respect to the number of robots. We provide three algorithms and two impossibility results that characterize, for any ring size, the necessary and sufficient number of robots to perform perpetual exploration of highly dynamic rings.

In its classical form, a consistent replicated service requires all replicas to witness the same evolution of the service state. Assuming a message-passing environment with a majority of correct processes, the necessary and sufficient information about failures for implementing a general state machine replication scheme ensuring consistency is captured by the Ω failure detector.

The problem of exploring a discrete environment by identical oblivious asynchronous agents (or robots) devoid of direct means of communication has been well investigated so far. The (terminating) exploration requires that starting from a configuration where no two agents occupy the same node, every node needs to be visited by at least one agent, with the additional constraint that all agents eventually stop moving. Agents have sensors that allow them to see their environment and move accordingly. The previous works on this problem assume agents having an unlimited visibility, that is, they can sense the agents on every node of the ring, whatever the ring size. In this paper, we address deterministic exploration in an anonymous, unoriented ring using oblivious, and myopic agents. By myopic, we mean that their visibility is limited in terms of sensing distance. We consider the strongest possible myopia that is, an agent can only sense agents located at its own and at its immediate neighboring nodes. Our contribution is threefold. We first prove that within such settings, no deterministic exploration is possible in the semi-synchronous model. The result is also valid for the (fully) asynchronous model and holds for any k 6. Finally, we provide optimal (in terms of number of agents) deterministic algorithms in the fully synchronous model for both cases 3 6.

In this paper, we propose two snap-stabilizing distributed algorithms for the committee coordination problem. In this problem, a committee consists of a set of processes and committee meetings are synchronized, so that each process participates in at most one committee meeting at a time. Snap-stabilization is a versatile technique allowing to design algorithms that efficiently tolerate transient faults. Indeed, after a finite number of such faults (e.g. memory corruptions, message losses, etc), a snap-stabilizing algorithm immediately operates correctly, without any external intervention. We design snap-stabilizing committee coordination algorithms enriched with some desirable properties related to concurrency, (weak) fairness, and a stronger synchronization mechanism called 2-Phase Discussion Time. From previous papers, we know that (1) in the general case, (weak) fairness cannot be achieved in the committee coordination, and (2) it becomes feasible provided that each process waits for meetings infinitely often. Nevertheless, we show that even under this latter assumption, it is impossible to implement a fair solution that allows maximal concurrency. Hence, we propose two orthogonal snap-stabilizing algorithms, each satisfying 2-phase discussion time, and either maximal concurrency or fairness. The algorithm implementing fairness requires that every process waits for meetings infinitely often. Moreover, for this algorithm, we introduce and evaluate a new efficiency criterion called the degree of fair concurrency. This criterion shows that even if it does not satisfy maximal concurrency, our snap-stabilizing fair algorithm still allows a high level of concurrency.

In this paper, we study the relationship between two fundammental problem in Robotics namely, leader election problem and pattern formation problem. In particular, we prove that both problems are equivalent for n≥4 in a fully asynchronous model, called CORDA, provided the robots share the same chirality.

We propose a group membership service for dynamic ad hoc networks. It maintains as long as possible the existing groups and ensures that each group diameter is always smaller than a constant, fixed according to the application using the groups. The proposed protocol is self-stabilizing and works in dynamic distributed systems. Moreover, it ensures a kind of continuity in the service offer to the application while the system is converging, except if too strong topology changes happen. Such a best effort behavior allows applications to rely on the groups while the stabilization has not been reached, which is very useful in dynamic ad hoc networks.

This paper provides a complexity study of the deterministic localization problem in robot networks using local and relative observations only. This is an important issue in collective and cooperative robotics where global positioning systems (GPS) are not available, and the basic premise is the localization ability of the group. We prove that given a set of relative observations made by the robots, the unique unambiguous pose estimation of the robot network in a deterministic way is an$N\!P$-hard problem. This means that no polynomial-time algorithm can deterministically solve the unique pose estimation problem based on relative observations unless$P=N\!P$. The consequence is that no guarantee can be provided, in a polynomial time, that the possibly estimated poses of the robots will correspond to the effective (actual) ones. The proof is based on complexity theory where we build appropriate polynomial-time reductions interrelating the multirobot localization problem to a well-known$N\!P$-complete problem (the partition problem). This$N\!P$-hardness result opens questions and perspectives for research into approximations to overcome its intractability.

In this paper, we address the deterministic rendezvous of mobile agents into any unoriented connected graph. The agents are autonomous, oblivious, move asynchronously. For this problem, we exhibit some time and space lower bounds as well as some necessary conditions. We also propose an algorithm that is space-optimal and asymptotically optimal in rounds.

We introduce the use of movement-signals (analogously to flight signals and bees waggle) as a mean to transfer messages, enabling the use of distributed algorithms among the robots. We propose one-to-one deterministic movement protocols that implement explicit communication.

This paper contributes to the problem of deterministic localization of robot networks using local and relative observations only. This is an important issue in collective and cooperative robotics where global positioning systems are not available, and the basic premise is the localization ability of the group. We prove that, giving a set of relative observations made by the robots, the unique non ambiguous pose estimation of the robot network in a deterministic way, is a NP-hard problem. This means that no polynomial-time algorithm can deterministically solve the unique pose estimation problem based on relative observations. The consequence is that no guaranty can be provided, in a polynomial time, that the possibly estimated poses of the robots, will correspond to the effective (actual) ones. The proof is based on complexity theory. We build appropriate polynomial-time reductions acting on the localization problem and leading to well known NP-hard problems. The paper gives some tracks to overcome this issue.

In this paper, we first introduce a simple tool called the wavelet or sigma-wavelet scheme. Wavelets deal with coordination among processes which are at most sigma hops away of each other. We propose a self-stabilizing solution for this scheme. Our solution requires no underlying structure and works in arbitrary anonymous settings, i.e., where process identifiers are not required. We show that our solution provides a simple and generic self-stabilizing sigma-infimum computation. Next, we present a self-stabilizing sigma-barrier synchronization protocol based on the wavelet scheme. We show that our protocol provides an efficient device in the design of local coordination problems at distance sigma, such as the sigma-local resource allocation (LRA). In particular, we propose a solution for the popular sigma-local mutual exclusion (LME) problem. The solution to sigma-LME also provides a transformer to transform algorithms written under sigma-central daemon into algorithms working with any distributed daemon.

The efficiency of service discovery is critical in the development of fully decentralized middleware intended to manage large scale computational grids. This demand influenced the design of many peer-to-peer based approaches. The ability to cope with the expressiveness of the service discovery was behind the design of a new kind of overlay structures that is based on tries, or prefix trees. Although these overlays are well designed, one of their weaknesses is the lack of any concrete fault tolerant mechanism, especially in dynamic platforms; the faults are handled by using preventive and costly mechanisms, \eg using a high degree of replication. Moreover, those systems cannot handle any arbitrary transient failure. Self-stabilization, which is an efficient approach to designreliable solutions for dynamic systems, was recently suggested to be a good alternative to inject fault-tolerance in peer-to-peer systems. However, most of the previous research on self-stabilization in tree and/or P2P networks was designed in theoretical models, making these approaches hard to implement in practice. In this paper, we provide a self-stabilizing message passing protocol to maintain prefix trees over practical peer-to-peer networks. A complete correctness proof is provided, as well as simulation results to estimate the practical impact of our protocol.

We consider distributed systems made of weak mobile robots, that is, mobile devices, equipped with sensors, that are anonymous , autonomous , disoriented , and oblivious . The Circle Formation Problem (CFP) consists of the design of a protocol insuring that, starting from an initial arbitrary configuration where no two robots are at the same position, all the robots eventually form a regular n-gon —the robots take place on the circumference of a circle C with equal spacing between any two adjacent robots on C . CFP is known to be unsolvable by arranging the robots evenly along the circumference of a circle C without leaving C —that is, starting from a configuration where the robots are on the boundary of C . We circumvent this impossibility result by designing a scheme based on concentric circles . This is the first scheme that deterministically solves CFP. We present our method with two different implementations working in the semi-synchronous system (SSM) for any number n ≥ 5 of robots.

A snap-stabilizing protocol, starting from any arbitrary initial configuration, always behaves according to its specification. In this paper, we present the first snap-stabilizing depth-first search wave protocol for arbitrary rooted networks assuming an unfair daemon, i.e. assuming the weakest scheduling assumption (a preliminary version of this work was presented in OPODIS 2004, 8th International Conference on Principles of Distributed Systems, Grenoble (France)).

DIET (Distributed Interactive Engineering Toolbox) is a set of hierarchical components to design network enabled server (NES) systems. In these systems, clients ask to agents (discovery and scheduling components) to find servers able to solve their problem using some performance metrics and information about the location of data already on the network. Today's NES middleware, in which agents are statically connected and potentially bottlenecks, don't cope with the dynamic and heterogeneous nature of future grid environments. In this paper, we present the design, the implementation and the experimentation of the first architecture extending traditional NES systems with an unstructured peer-to-peer network dynamically connecting distributed agents, to provide to clients an entry point to servers geographically distributed. Our implementation is based on DIET and the JXTA toolbox. Different algorithms have been implemented and experimented over the VTHD network which connects several supercomputers in different research institutes through a high-speed network, showing the scalability of the system

The group mutual exclusion (GME) problem was introduced by Joung. The GME solution allows n processes to share m mutually exclusive resources. We present several algorithms to solve the GME problem in token rings. The space requirement and the size of messages of all algorithms are bounded. So, the proposed algorithms solve the problem suggested by Joung, which is to obtain a solution using messages of bounded size. The time and space complexities of the first and second algorithms depend on n and m respectively. The first algorithm is more efficient when n ≪ m, whereas the second one when m ≪ n. The cost of the third algorithm is min(n, m). So, it is suitable for any type of network. However, the third solution is obtained with a message size of log(min(n, m)) extra bits. The third algorithm has an additional desirable property. It serves the requests in a first in first out manner. The fourth algorithm improves the bandwidth usage by avoiding the token circulation when no new requests are made for a different session. This property of the fourth algorithm can be incorporated into the other three algorithms.

We propose a general self-stabilizing scheme for solving any synchronization problem whose safety specification can be defined using a local property. We demonstrate the versatility of our scheme by showing that very memory-efficient solutions to many well-known problems (e.g., asynchronous phase clock, local mutual exclusion, local reader-writers, and local group mutual exclusion) can be derived using the proposed framework. We show that all these algorithms use a phase clock whose minimum size in terms of number of states per process is equal to CG + TG - 1, where CG is the length of the maximal cycle of the shortest maximum cycle basis if the graph contains cycles and 2 (otherwise) for tree networks, and TG is the length of the longest chordless cycle (i.e., hole) if the graph contains cycles and 2 for tree networks. In particular, for the asynchronous phase clock problem, our solution significantly improves all existing self-stabilizing solutions---all of them require quadratic space in terms of the number of states.As a by-product of our scheme, we present a silent bounded algorithm which can be used to transform any serial system into a distributed one. Thus, it answers an open question in [16], if there exists a bounded system transformation which is silent.

A snap-stabilizing protocol guarantees that the system always behaves according to its specification provided some processor initiated the protocol. We present how to snap-stabilize some important protocols, like Leader Election, Reset, Snapshot, and Termination Detection. We use a Snap-stabilizing Propagation of Information with Feedback protocol for arbitrary networks as the key module in the above transformation process. Finally, we design a universal transformer to provide a snap-stabilizing version of any protocol (which can be self-stabilized with the transformer of [15]).

We present the first snap-stabilizing propagation of information with feedback (PIF) protocol in arbitrary networks. A snap-stabilizing protocol, starting from any arbitrary initial system configuration, always behaves according to its specification. Our protocol is distributed, deterministic, and does not use a pre-constructed spanning tree.

The group mutual exclusion (GME) problem deals with sharing a set of (m) mutually exclusive resources among all (n) processes of a network. Processes are allowed to be in a critical section simultaneously provided they request the same resource. We present three group mutual exclusion solutions for tree networks. All three solutions do not use process identifiers, and use bounded size messages. They achieve the best context-switch complexity, which is O(min (n, m)). The first solution uses a fixed root of the tree and uses 0 to O(n) messages per critical section entry. This solution supports an unbounded degree of concurrency, thus provides the maximum resource utilization. The second solution also uses a fixed root, but uses a reduced number of messages for the critical section entry. It generates an average of O(log n) messages per critical section entry and also allows an unbounded degree of concurrency. However, the concurrency may be limited in some parts of the network. We remove the restriction of using a fixed root in the third solution in addition to maintaining all other desirable properties of the second solution.

We propose a group mutual exclusion algorithm for unidirectional rings. Our algorithm does not require the processes to have any id. Moreover, processes maintain no special data structures to implement any queues. The space requirement of processes depends only on the number of shared resources, and is equal to 4/spl times/log(m+1)+2 bits. The size of messages is 2/spl times/log(m+1) bits only. Every resource request generates O(n/sup 2/) messages in the worst case, but zero messages in the best case.

We present a deterministic distributed Propagation of Information with Feedback (PIF) protocol in arbitrary rooted networks. The proposed algorithm does not use a preconstructed spanning tree. 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 behave according to its specification. Every PIF wave initiated by the root inherently creates a tree in the graph. So, the tree is dynamically created according to the progress of the PIF wave. This allows our PIF algorithm to take advantage of the relative speed of different components of the network. The proposed algorithm can be easily used to implement any self-stabilizing system which requires a (self-stabilizing) wave protocol running on an arbitrary network.

We present the first deterministic self-stabilizing network orientation algorithms. We present three protocols for arbitrary and asynchronous networks. All the protocols set up a chordal sense of direction in the network. The protocols are self-stabilizing, meaning that starting from an arbitrary state, the protocols are guaranteed to reach a state, in which all edge labels (assigned to the links) are valid (meaning, they satisfy the specification of the orientation problem).

Recently (1998), we introduced a new self-stabilizing PIF paradigm, called the Propagation of information with Feedback and Cleaning (PFC), for the rooted tree networks. In this paper, we propose the first self-stabilizing PIF scheme for the tree networks without sense of direction-the trees do not have a root and the processors do not maintain any ancestor. The proposed PIF scheme is based on the paradigm PFC. A PIF algorithm in trees without sense of direction is very useful in many applications because this allows to maintain only one spanning tree of the network instead of one per processor. The proposed algorithm requires 3 states per processor, and only 2 states for the initiator and leaves. This space requirement is optimal for both self-stabilizing and non-stabilizing PIF algorithms on tree networks. Thus, the processors need no extra space to stabilize the proposed PIF scheme.