## Section: New Results

### Distributed Algorithms for Dynamic Networks and Fault Tolerance

Participants : Luciana Bezerra Arantes [correspondent] , Sébastien Bouchard, Marjorie Bournat, João Paulo de Araujo, Swan Dubois, Denis Jeanneau, Jonathan Lejeune, Franck Petit [correspondent] , Pierre Sens, Julien Sopena.

Nowadays, distributed systems are more and more heterogeneous and versatile.
Computing units can join, leave or move inside a global infrastructure.
These features require the implementation of *dynamic* systems, that is to say they can cope autonomously with changes
in their structure in terms of physical facilities and software. It therefore becomes necessary to define, develop, and validate
distributed algorithms able to managed such dynamic and large scale systems, for instance mobile *ad hoc*
networks, (mobile) sensor networks, P2P systems, Cloud environments, robot networks, to quote only a few.

The fact that computing units may leave, join, or move may result of an intentional behavior or not. In the latter case, the system may be subject to disruptions due to component faults that can be permanent, transient, exogenous, evil-minded, etc. It is therefore crucial to come up with solutions tolerating some types of faults.

In 2017, we obtained the following results.

#### Algorithms for Dynamic and Large Systems

In [32] we propose VCube-PS, a new topic-based Publish/Subscribe system built on the top of a virtual hypercube like topology. Membership information and published messages to subscribers (members) of a topic group are broadcast over dynamically built spanning trees rooted at the message’s source. For a given topic, delivery of published messages respects causal order. Performance results of experiments conducted on the PeerSim simulator confirm the efficiency of VCube-PS in terms of scalability, latency, number, and size of messages when compared to a single rooted, not dynamically, tree built approach.

We also explore in [20] scheduling challenges in providing probabilistic Byzantine fault tolerance in a hybrid cloud environment, consisting of nodes with varying reliability levels, compute power, and monetary cost. In this context, the probabilistic Byzantine fault tolerance guarantee refers to the confidence level that the result of a given computation is correct despite potential Byzantine failures. We formally define a family of such scheduling problems distinguished by whether they insist on meeting a given latency limit and trying to optimize the monetary budget or vice versa. For the case where the latency bound is a restriction and the budget should be optimized, we propose several heuristic protocols and compare between them using extensive simulations.

In [27], we a new resource reservation protocol in the context of delay-sensitive rescue mobile networks. The search for service providers (e.g., ambulance, fire truck, etc.) after a disaster, must take place within a short time. Therefore, service discovery protocol which looks for providers that can attend victims, respecting time constraints, is crucial. In such a situation, a commonly solution for ensuring network connectivity between victims and providers is ad hoc networks (MANET), composed by battery-operated mobile nodes of persons (victims or not). Using message aggregations techniques, we propose an new reservation protocol aiming at reducing the number of messages over the network and, therefore, node’s battery consumption

#### Self-Stabilization

Self-stabilization is a generic paradigm to tolerate transient faults (*i.e.*, faults of finite duration) in distributed systems.
In [14],
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 $\Theta \left({n}^{3}\right)$ steps in the
worst case, where $n$ is the number of processes. Its memory
requirement is asymptotically optimal, *i.e.*, $\Theta (logn)$
bits per processes. Its round complexity is of the same order of
magnitude — *i.e.*, $\Theta \left(n\right)$ 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.

#### Mobile Agents

In [21], 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.

#### Approach in the Plane

In [35] 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 $ and $l$ are unknown to both agents, does there exist a deterministic
approach algorithm whose cost is polynomial in $\Delta $ and $l$?*

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.