Terminating cases of flooding

Flooding is one of the most fundamental of all graph/network algorithms - for example, to achieve broadcast in networks [2, 31]. The algorithm that is usually implemented is: (i) initiator nodes send a message to all their neighbours, (ii) on first receipt, receiving nodes send the message to every neighbour from which they did not receive and (iii) on subsequent receipts, the receiving node does not send the message to any neighbour. This algorithm checks if the message has been received before, to ensure termination. It requires each node records a previous event in its state, making it a stateful protocol. We consider the pure version of flooding, i.e. algorithms that are ‘amnesiac’ in the sense that they hold no record or memory of any event beyond the immediate round. Thus, implemented algorithms that are stateless are amnesiac. The basic pure flooding algorithm is as follows.

Hitherto, it was not known whether a stateless flooding algorithm exists that terminates on every graph. In this paper, we show that basic amnesiac flooding is itself such an algorithm. The termination times for a single source $g_{0}$ are $e$ rounds if $G$ is bipartite and $j$ rounds with $e<j\leq e+d+1$ otherwise, where $e$ and $d$ are the eccentricity of $g_{0}$ and diameter of $G$ respectively. These times are asymptotically time optimal. The difference in times between bipartite and non-bipartite graphs means that a stateless algorithm can approximate the topology or diameter/eccentricities of a network in certain cases.

Gopal, Gopal and Kutten [14] highlighted the memory requirement inherent in stateful flooding and its overhead on fast networks. For example, when multiple messages are being flooded, nodes need to keep a record of the messages they have seen and search through their data structure whenever a message arrives before deciding if it can be further flooded. This is also a limitation for low memory devices, e.g. sensor networks. We show that not only amnesiac flooding of the same message in a single round, but also amnesiac flooding of multiple messages initiated in multiple rounds, where at most one message is sent along any given edge each round, terminates.

One advantage of the stateful variant of flooding is that it can be used to construct spanning structures, such as spanning trees, which can be subsequently re-used for efficient communication [25, 2, 31, 38]. It is not easy to maintain these structures in dynamic conditions, i.e. when edges/nodes are being added or removed. We show that even when edges are being arbitrarily or adversarially removed from the graph, amnesiac flooding with the correct forwarding rules will still terminate. Under some other forwarding rules, termination is not guaranteed. Termination is also not guaranteed in asynchronous models where the delivery time of messages on edges can vary - we show this with a non-terminating delivery schedule over the edges and even with a single edge with delayed delivery in some pathological cases. Note that amnesiac flooding uses rules that avoid forwarding to the most recently chosen nodes - similar ideas have been used before in distributed computing, e.g. in social networks [10] and broadcasting [12].

There are numerous applications of flooding as a distributed algorithm. It is often used to set up spanning trees[25, 2, 31, 38] and solving leader election. For example, the time-optimal leader election of Peleg [30] utilises continuous flooding of node $ID$s to determine the node with the highest $ID$ while using a condition on the node $ID$s to achieve and detect termination. Kutten et al [23], on the other hand, use controlled stateful flooding and resulting spanning tree for efficient time and message leader election. Processes such as random walks [35, 36, 13, 23, 24] and its deterministic variant Rotor-Router (or Propp) machine [22, 8] can also be seen as restricted variants of flooding. Finally, in some models such as population protocols, the low memory makes termination very difficult to achieve leading to research that tries to provide termination e.g. [26].

Flooding-based algorithms (or flooding protocols) appear in areas ranging from GPUs, high performance, shared memory and parallel computing, to mobile ad-hoc networks (MANETs), Mesh Networks, Complex Networks etc [37]. Rahman et al [32] show that flooding can even be adopted as a reliable and efficient routing scheme, comparable to sophisticated point-to-point forwarding schemes, in some ad-hoc wireless mobile network applications. Adamek et al [1] and Karp and Kung [21] further offer stateless (flooding and other) solutions for routing.

This paper is structured as follows. In section 2, we prove that, for the simple case of a single message being flooded from a set of initial nodes in round $0$, all nodes receive the message at most twice and hence amnesiac flooding terminates (Theorem 2.2). This result is used to derive sharp bounds for the number of rounds it takes for flooding to terminate, in section 3 (Theorem 3.9). Amnesiac flooding is extended in section 4 to dynamic cases where multiple messages are flooded in any round. The flooding algorithms are categorized by whether a node sends a chosen received message $M_{h}$ to neighbours from which it did not receive any message in the previous round, or whether the node sends $M_{h}$ to all neighbours from which it did not receive $M_{h}$. We show that, in the first case, and also the second case if messages are ranked, no flooded message is received more than twice and therefore flooding terminates if the number of messages is finite (Theorems 4.4 and 4.8). In section 5 we present non-terminating cases of amnesiac flooding for both single-message and multiple-message flooding. Conclusions are drawn in section 6.

Sections 2 and 3 of this paper have essentially appeared earlier as conference publications at STACS 2020 [20] and PODC 2019 [18], and on Arxiv [19]. The proof of time to termination was presented for the case of a single source, but the same proof also provides the time calculation for the multi-source case simply by replacing distances $d(g_{0},g)$ of a node $g$ from the initial node $g_{0}$ by distances $d(I,g)$ of $g$ from the set of initial nodes $I$. Since those publications, Turau [40, 41] has worked on finding optimal sets of sources of a given size that minimize termination time for multi-source flooding. The parts of this paper from section 4 onwards on dynamic flooding, which require the use of a more powerful proof method, have not been published previously.

Throughout this paper, when we refer to ‘flooding’ we will mean either the amnesiac flooding of Definition 1.1 or another amnesiac version of flooding defined in context in the relevant section. In this section we prove that (amnesiac) flooding initiated from any set of initial nodes, all at once, terminates.

Clearly, if $R_{j}=\emptyset$ for some $j\geq 0$, then $R_{i}=\emptyset$ for all $i\geq j$.

We assume that ${\mathcal{R}}^{e}$ is non-empty and derive a contradiction. Let ${\mathcal{R}}^{e}_{\hat{d}}$ be the subset of ${\mathcal{R}}^{e}$ comprising sequences of minimum (even) duration $\hat{d}$, i.e.

Clearly, if ${\mathcal{R}}^{e}$ is non-empty then so is ${\mathcal{R}}^{e}_{\hat{d}}$. Let $\underline{R}^{*}\in{\mathcal{R}}^{e}_{\hat{d}}$ be the sequence with earliest start-point $\hat{s}$, i.e.

where

By (1), there exists $g\in R_{\hat{s}}\cap R_{\hat{s}+\hat{d}}$. Choose node $g^{\prime}$ which sends a message to $g$ in round $\hat{s}+\hat{d}$. As $g^{\prime}$ is a neighbour of $g$, either $g^{\prime}$ sends a message to $g$ in round $\hat{s}$ or $g$ sends a message to $g^{\prime}$ in round $\hat{s}+1$. We show that each of these cases leads to a contradiction.

Theorem 2.2 implies that $R_{i}=\emptyset$ for $i\geq 2|G|$, where $|G|$ is the number of vertices of $G$, and therefore flooding always terminates. In the next section we give sharp bounds for the number of rounds to termination, in terms of the eccentricity of initial nodes and the diameter of $G$.

The question of termination of network flooding is non-trivial when cycles are present in $G$. The simple cases when $G$ is an even cycle and when $G$ is an odd cycle, as in figure 1 (where an arrow indicates a message received by a node in the given round), display quite different termination behaviours.

The even cycle terminates remotely from the initial node $g_{0}$, after round $e$ where $e$ is the eccentricity of $g_{0}$ in $G$. On the other hand, flooding on the odd cycle returns a message to the initial node $g_{0}$ and terminates after round $2e+1$ resulting in a longer flooding process than the even cycle despite having fewer nodes and a smaller value of $e$. In this section, we show that these observations can be largely generalized to arbitrary graphs. Observe that in the even cycle every node receives the message only once, whereas in the odd cycle every node receives the message twice. We show that, in general graphs, this difference is due to the absence or presence of neighbouring nodes that are equidistant from the set of initial nodes $I$, called ‘ec nodes’ below.

For (ii), we note that the only circumstance in which a node $g$ in $D_{j}$ ($\subseteq R_{j}$ by (i)) does not send to a neighbour $g^{\prime}$ in $D_{j+1}$ in round $j+1$ is if $g$ sent a message to $g^{\prime}$ in round $j$. This would need $g$ to be in the round-set $R_{j-1}$, i.e. $g\in R_{j-1}\cap D_{j+1}$ which contradicts (i) which has $R_{j-1}\cap D_{j+1}=\emptyset$ as $j+1>j-1$.

For (iii), if $j\geq 0$ and $g\in D_{j}$ is an $ec$ node, then by Definition 3.1(ii) there is an point $g^{\prime}$ equidistant from $I$, i.e. $g^{\prime}\in D_{j}$ such that $g$ and $g^{\prime}$ are neighbours. If $j=0$ then $g,g^{\prime}\in D_{0}(=I\subseteq R_{0})$ and send a message to each other in round 1 and so $g,g^{\prime}\in R_{1}$. This means that $g^{2}\in R_{1}$, as $g$ is an initial node and $g^{1}\in R_{0}$. If $j\geq 1$ then, by (i) of this lemma, $D_{j}\subseteq R_{j}$ and so both $g$ and $g^{\prime}$ receive messages in round $j$. Also, by (i), neither sends a message in round $j$ as $R_{j-1}\cap D_{j}=\emptyset$. Thus, $g$ and $g^{\prime}$ send messages to each other in round $j+1$. As this will be the second time they receive a message we have that $g^{2}\in R_{j+1}$   

Conversely, suppose that $G$ has an $ec$ node $g$, $g\in D_{j}$ ($\subseteq R_{j}$ by Lemma 3.2(i)) say where $j\geq 1$. Then $g^{2}\in R_{j+1}$ by Lemma 3.2(iii).   

The clear separation in the termination times of bipartite and non-bipartite graphs, in the case of a single initial node, does not carry over neatly to the general case of multiple initial nodes. For the general case, it is the presence or otherwise of ec nodes that is the distinguishing property and we have defined ec-bipartite graphs for this purpose. Unlike the single node case, having ec nodes or not in the multiple initial node case cuts across the bipartite/non-bipartite boundary, i.e. bipartite graphs may have ec points and non-bipartite graphs may not. The recent work by Turau [40] looks at termination times in terms of the ‘k-flooding problem’ which aims to find a set S of size k such that amnesiac flooding when started concurrently by all nodes of S terminates in the least number of rounds.

So far, we have considered flooding of a single message which initiates at a single point in time in round 0, albeit possibly from several nodes. In this section we show that amnesiac flooding will still terminate in dynamic settings where multiple floodings are initiated from multiple nodes in multiple rounds with multiple messages, even when floodings from previous initiations have not completed. We consider floodings in which nodes receiving messages in a given round only send a single message per edge in the next round. The case of ‘parallel flooding’, where multiple floodings operate independently of each other resulting in nodes possibly sending multiple messages along an edge in a round, terminates trivially given the results in sections 2 and 3.

There are two general cases in which messages $M_{0},\ldots,M_{h},\ldots$ are being flooded by nodes $x_{i_{0}}^{0},\ldots,x_{i_{h}}^{h},\ldots$ with initial rounds $i_{0},\ldots,i_{h},\ldots$ respectively, such that at most one message per edge per round is sent. In the first case, a node that receives messages in a round sends one of the received messages $M_{h}$ to all neighbours from which it did not receive any message. In the second case, the node sends $M_{h}$ to all neighbours from which it did not receive $M_{h}$. We call these two cases ‘partial-send’ and ‘full-send’ respectively. We subdivide the second case into the subcase ‘ranked full-send’ where the messages $M_{0},\ldots,M_{h},\ldots$ are ranked and the highest ranked received message $M_{h}$ is sent on, and the subcase ‘unranked full-send’ where a random message is sent on.

In 4.1 and 4.2 below we show that, in the cases of partial-send and ranked full-send flooding of multiple messages, no node receives a given message more than twice, and so flooding terminates when the number of messages is finite. As a further extension to the basic flooding model of sections 2 and 3, both of these results hold in a dynamic setting where the graph $G$ may lose edges or nodes over time. In section 5.3, the general case of unranked full-send flooding of multiple messages is shown not to terminate even if the number of messages is finite.