arXiv subjects

Colette Johnen

Publications and source records attributed to Colette Johnen.

12 recordsLinked to original sources

arXiv2026

Introducing the Self-Stabilizing SLEEPING Model

The SLEEPING LOCAL model introduces a new complexity parameter, the awake complexity, to make distributed algorithms energy-efficient. In the synchronous LOCAL model, nodes can now decide to be awake or asleep in each round. In a round, only awake nodes can communicate to share information, which consumes energy. The awake complexity is the maximum number of times a node is activated to produce an output. In particular, it often comes at the cost of the total number of rounds required to solve a problem, compared with algorithms in which every node is awake in every round. In this article, we adapt the notion of awaken rounds to the context of self-stabilization, introducing the Self-Stabilizing SLEEPING model. Nodes are no longer required to remain awake at all times. However, in self-stabilization, nodes must be activated infinitely often to detect any issue in the system's current state. In this model, the complexities are: * How many synchronous rounds are needed to reach a legitimate configuration? * How many times does a node need to be awake to reach this configuration? * How often does a node need to be awake once this configuration is reached? The goal is to minimize those three metrics, and we can expect different trade-offs. We present energy-efficient algorithms to solve the problems of finding a $(\Delta+1)$-coloring, a Maximal Independent Set, and a Maximal Matching, thanks to new ad hoc sleeping techniques that reduce the awake complexity (i.e., energy consumption) during the convergence phase. We also propose two transformers that adapt silent self-stabilizing algorithms to the SLEEPING setup. The first transformer is pretty simple and deals with low-complexity algorithms. The second is more elaborate and is more energy-efficient when it transforms slow self-stabilizing algorithms.

cs.DC↗

arXiv2024

Efficient Wait-Free Linearizable Implementations of Approximate Bounded Counters Using Read-Write Registers

Relaxing the sequential specification of a shared object is a way to obtain an implementation with better performance compared to implementing the original specification. We apply this approach to the Counter object, under the assumption that the number of times the Counter is incremented in any execution is at most a known bound $m$. We consider the $k$-multiplicative-accurate Counter object, where each read operation returns an approximate value that is within a multiplicative factor $k$ of the accurate value. More specifically, a read is allowed to return an approximate value $x$ of the number $v$ of increments previously applied to the counter such that $v/k \le x \le vk$. We present three algorithms to implement this object in a wait-free linearizable manner in the shared memory model using read-write registers. All the algorithms have read operations whose worst-case step complexity improves exponentially on that for an exact $m$-bounded counter (which in turn improves exponentially on that for an exact unbounded counter). Two of the algorithms have read step complexity that is asymptotically optimal. The algorithms differ in their requirements on $k$, step complexity of the increment operation, and space complexity.

cs.DC↗

arXiv2023

Trade-off between Time, Space, and Workload: the case of the Self-stabilizing Unison

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 \geq 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^2B, 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.

cs.DC↗

arXiv2023

Making local algorithms efficiently self-stabilizing in arbitrary asynchronous environments

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 Trans(AlgI) of any terminating synchronous algorithm AlgI. The transformed algorithm Trans(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.

cs.DC↗

arXiv2019

Analysis of a Memory-Efficient Self-Stabilizing BFS Spanning Tree

We present results on the last topic we collaborate with our late friend, Professor Ajoy Kumar Datta (1958-2019). In this work, we shed new light on a self-stabilizing wave algorithm proposed by Colette Johnen in 1997. This algorithm constructs a BFS spanning tree in any connected rooted network. Nowadays, it is still the best existing self-stabilizing BFS spanning tree construction in terms of memory requirement, {\em i.e.}, it only requires $Θ(1)$ bits per edge. However, it has been proven assuming a weakly fair daemon. Moreover, its stabilization time was unknown. Here, we study the slightly modified version of this algorithm, still keeping the same memory requirement. We prove the self-stabilization of this variant under the distributed unfair daemon and show a stabilization time in $O(D.n^2)$ rounds, where $D$ is the network diameter and $n$ the number of processes.

cs.DC↗

arXiv2019

Self-Stabilizing Distributed Cooperative Reset

Self-stabilization is a versatile fault-tolerance approach that characterizes the ability of a system to eventually resume a correct behavior after any finite number of transient faults. In this paper, we propose a self-stabilizing reset algorithm working in anonymous networks. This algorithm resets the network in a distributed non-centralized manner, i.e., it is multi-initiator, as each process detecting an inconsistency may initiate a reset. It is also cooperative in the sense that it coordinates concurrent reset executions in order to gain efficiency. Our approach is general since our reset algorithm allows to build self-stabilizing solutions for various problems and settings. As a matter of facts, we show that it applies to both static and dynamic specifications since we propose efficient self-stabilizing reset-based algorithms for the (1-minimal) $f,g)-alliance (a generalization of the dominating set problem) in identified networks and the unison problem in anonymous networks. Notice that these two latter instantiations enhance the state of the art. Indeed, in the former case, our solution is more general than the previous ones; while in the latter case, the complexity of the proposed unison algorithm is better than that of previous solutions of the literature.

cs.DC↗

arXiv2017

Self-Stabilizing Disconnected Components Detection and Rooted Shortest-Path Tree Maintenance in Polynomial Steps

We deal with the problem of maintaining a shortest-path tree rooted at some process r in a network that may be disconnected after topological changes. The goal is then to maintain a shortest-path tree rooted at r in its connected component, V\_r, and make all processes of other components detecting that r is not part of their connected component. We propose, in the composite atomicity model, a silent self-stabilizing algorithm for this problem working in semi-anonymous networks, where edges have strictly positive weights. This algorithm does not require any a priori knowledge about global parameters of the network. We prove its correctness assuming the distributed unfair daemon, the most general daemon. Its stabilization time in rounds is at most 3nmax+D, where nmax is the maximum number of non-root processes in a connected component and D is the hop-diameter of V\_r. Furthermore, if we additionally assume that edge weights are positive integers, then it stabilizes in a polynomial number of steps: namely, we exhibit a bound in O(maxi nmax^3 n), where maxi is the maximum weight of an edge and n is the number of processes.

cs.DC↗

arXiv2017

Maintaining a Distributed Spanning Forest in Highly Dynamic Networks

Highly dynamic networks are characterized by frequent changes in the availability of communication links. These networks are often partitioned into several components, which split and merge unpredictably. We present a distributed algorithm that maintains a forest of (as few as possible) spanning trees in such a network, with no restriction on the rate of change. Our algorithm is inspired by high-level graph transformations, which we adapt here in a (synchronous) message passing model for dynamic networks. The resulting algorithm has the following properties: First, every decision is purely local---in each round, a node only considers its role and that of its neighbors in the tree, with no further information propagation (in particular, no wave mechanisms). Second, whatever the rate and scale of the changes, the algorithm guarantees that, by the end of every round, the network is covered by a forest of spanning trees in which 1) no cycle occur, 2) every node belongs to exactly one tree, and 3) every tree contains exactly one root (or token). We primarily focus on the correctness of this algorithm, which is established rigorously. While performance is not the main focus, we suggest new complexity metrics for such problems, and report on preliminary experimentation results validating our algorithm in a practical scenario.

cs.DC↗

arXiv2015

Silent Self-stabilizing BFS Tree Algorithms Revised

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).

cs.DC↗

arXiv2014

Testing Temporal Connectivity in Sparse Dynamic Graphs

We address the problem of testing whether a given dynamic graph is temporally connected, {\it i.e} a temporal path (also called a {\em journey}) exists between all pairs of vertices. We consider a discrete version of the problem, where the topology is given as an evolving graph ${\cal G}=\{G_1,G_2,...,G_{k}\}$ whose set of vertices is invariant and the set of (directed) edges varies over time. Two cases are studied, depending on whether a single edge or an unlimited number of edges can be crossed in a same $G_i$ (strict journeys {\it vs} non-strict journeys). In the case of {\em strict} journeys, a number of existing algorithms designed for more general problems can be adapted. We adapt one of them to the above formulation of the problem and characterize its running time complexity. The parameters of interest are the length of the graph sequence $k=|{\cal G}|$, the maximum {\em instant} density $μ=max(|E_i|)$, and the {\em cumulated} density $m=|\cup E_i|$. Our algorithm has a time complexity of $O(kμn)$, where $n$ is the number of nodes. This complexity is compared to that of the other solutions: one is always more costly (keep in mind that is solves a more general problem), the other one is more or less costly depending on the interplay between instant density and cumulated density. The length $k$ of the sequence also plays a role. We characterize the key values of $k, μ$ and $m$ for which either algorithm should be used. In the case of {\em non-strict} journeys, for which no algorithm is known, we show that some pre-processing of the input graph allows us to re-use the same algorithm than before. By chance, these operations happens to cost again $O(kμn)$ time, which implies that the second problem is not more difficult than the first.

cs.DS↗

arXiv2014

Un algorithme de test pour la connexité temporelle des graphes dynamiques de faible densité

We address the problem of testing whether a dynamic graph is temporally connected, i.e. a temporal path ({\em journey}) exists between all pairs of vertices. We consider a discrete version of the problem, where the topology is given as an evolving graph $\G=\{G_1,G_2,...,G_{k}\}$ in which only the set of (directed) edges varies. Two cases are studied, depending on whether a single edge or an unlimited number of edges can be crossed in a same $G_i$ (strict journeys {\it vs} non-strict journeys). For strict journeys, two existing algorithms designed for other problems can be adapted. However, we show that a dedicated approach achieves a better time complexity than one of these two algorithms in all cases, and than the other one for those graphs whose density is low at any time (though arbitrary over time). The time complexity of our algorithm is $O(kμn)$, where $k=|\G|$ is the number of time steps and $μ=max(|E_i|)$ is the maximum {\em instant} density, to be contrasted with $m=|\cup E_i|$, the {\em cumulated} density. Indeed, it is not uncommon for a mobility scenario to satisfy, for instance, both $μ=o(n)$ and $m=Θ(n^2)$. We characterize the key values of $k, μ$ and $m$ for which our algorithm should be used. For non-strict journeys, for which no algorithm is known, we show that a similar strategy can be used to answer the question, still in $O(kμn)$ time.

cs.DS↗

arXiv2010

Reliable Self-Stabilizing Communication for Quasi Rendezvous

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.

cs.DC↗