Efficient Distributed Communication in Ad-Hoc

Efficient Distributed Communication in Ad-Hoc Radio Networks? Bogdan S. Chlebus1 , Dariusz R. Kowalski2 , Andrzej Pelc3 , and Mariusz A. Rokicki2 1

Department of Computer Science and Engineering, U. of Colorado Denver, USA. 2 Department of Computer Science, University of Liverpool, UK. 3 D´epartement d’informatique, Universit´e du Qu´ebec en Outaouais, Canada.

Abstract. We present new distributed deterministic solutions to two communication problems in n-node ad-hoc radio networks: rumor gathering and multi-broadcast. In these problems, some or all nodes of the network initially contain input data called rumors, which have to be learned by other nodes. In rumor gathering, there are k rumors initially distributed arbitrarily among the nodes, and the goal is to collect all the rumors at one node. Our rumor gathering algorithm works in O((k + n) log n) time and our multi-broadcast algorithm works in O(k log3 n + n log4 n) time, for any n-node networks and k rumors (with arbitrary k), which is a substantial improvement over the best previously known deterministic solutions to these problems. As a consequence, we exponentially decrease the gap between upper and lower bounds on the deterministic time complexity of four communication problems: rumor gathering, multi-broadcast, gossiping and routing, in the important case when every node has initially at most one rumor (this is the scenario for gossiping and for the usual formulation of routing). Indeed, for k = O(n), our results simultaneously decrease the complexity gaps for these four problems from polynomial to polylogarithmic in the size of the graph. Moreover, our deterministic gathering algorithm applied for k = O(n) rumors, improves over the best previously known randomized algorithm of time O(k log n + n log2 n). Keywords: radio network, distributed algorithm, gossiping, gathering, multi-broadcast, routing.

1

Introduction

Radio networks are defined by the property that one wave frequency is used for wireless communication. Multiple messages arriving at a node in the same round interfere with one another so that none can be heard. We use simple undirected graphs to represent network topologies. Each of our algorithms works for any ?

The first author is supported by the NSF Grant 1016847. The second author is supported by the Engineering and Physical Sciences Research Council [grant numbers EP/G023018/1, EP/H018816/1]. The third author is partially supported by a NSERC discovery grant and by the Research Chair in Distributed Computing at the Universit´e du Qu´ebec en Outaouais.

network topology on n nodes. The performance bounds we develop hold for all networks of a given size. Nodes are not aware of the topology of the network. We present distributed deterministic algorithms for two communication tasks: rumor gathering and multi-broadcast. In these problems, some or all nodes of the network initially contain input data called rumors, which have to be learned by other nodes. Messages are small: each of them carries at most one rumor and O(log n) additional control bits. For rumor gathering, there are k rumors, where k is an arbitrary positive integer (independent on n), initially distributed arbitrarily among the nodes, and the goal is to collect all the rumors at one node. Multi-broadcast is related to two fundamental communication problems: gossiping and routing. In gossiping, every node is initialized with a rumor and the goal is for all nodes to learn all rumors. In routing, k rumors distributed arbitrarily among the nodes must be delivered each to its designated destination. The problem of multi-broadcast, considered in this work, is defined as follows: some k rumors are distributed arbitrarily among the nodes and the goal is for all the nodes to learn every rumor. This is a generalization of gossiping (initially not all nodes need to have a rumor) and a strengthening of routing (all nodes need to learn each rumor, not only the destination node for a given rumor). The challenge of the considered problems is due to the combination of two features of the model of ad-hoc radio networks. On the one hand, nodes do not know the topology of the network, and on the other hand communication algorithms are hard to design due to possible collisions that prevent nodes from hearing messages. In unknown topologies collisions are unavoidable, and nodes need not even be aware of their occurrence, as they do not have the collision detection capability. Our approach to overcome these problems builds on two main algorithmic techniques introduced in this paper, both of them being deterministic and fully distributed. First, we build a tree to gather and spread rumors (c.f., Section 3.1). This tree, called a Breadth-Then-Depth tree, has the property that it can be clustered into a logarithmic number of forests, and in each forest messages can be propagated in parallel without causing any collision except possibly in roots of the forest. Moreover, each path of this tree from a node to the root is split into an at most logarithmic number of sub-paths, each belonging to a different forest (c.f., Section 4). Note that a DFS tree could cause a large number of collisions while propagating rumors within a path to the root, due to possible shortcut edges, which disallows any parallelism in the general case. A BFS tree, in turn, could cause a problem with a potentially large number of collisions when transmitting from one layer to another, and it is not even known how to construct it deterministically and in a distributed way in a sub-quadratic number of rounds in general radio networks. The second crucial technique is to efficiently propagate rumors between different forests of the constructed clustering, which we do by computing (again, in a deterministic and distributed way) short transmission schedules between the roots and leaves of neighboring forests (c.f., Section 5). We also resolve a number of technical obstacles, such as how to propagate rumors on paths and how to deal with potential collisions in roots of the forests.

Our Results. Building on novel algorithmic techniques introduced in this work we develop efficient deterministic distributed algorithms for gathering rumors and for multi-broadcast. Our rumor gathering algorithm works in O((k + n) log n) time and our multibroadcast algorithm works in O(k log3 n + n log4 n) time, for any n-node networks and k rumors (with arbitrary k), which is a substantial improvement over the best previously known deterministic solutions to these problems. Indeed, the best previously known deterministic algorithms for the problems of gathering, multi-broadcast and routing worked in time O(min{(k + n)n1/2 log3 n, (k + n5/2 ) log3 n}) [6, 9]. In the case of the gossiping problem, using our multi-broadcast algorithm (for k = n) we accomplish gossiping in O(n log4 n) time, while the best algorithm for this problem worked in time O(n3/2 log3 n) [6]. On the other hand, the best known deterministic lower bound for the first three problems was Ω(k + n log n) [5, 8, 10, 12], while the best lower bound for gossiping was Ω(n log n) [10]. As a consequence, we decrease exponentially the gap between upper and lower bounds on the deterministic time complexity of four communication problems: rumor gathering, multi-broadcast, gossiping and routing, in the important case when every node has initially at most one rumor (this is the scenario for gossiping and for the usual formulation of routing). Indeed, for k = O(n), our results simultaneously decrease the complexity gaps for these four problems from polynomial to polylogarithmic in the size of the graph. Moreover, our deterministic gathering algorithm applied for k = O(n) rumors, improves over the best previously known randomized algorithm [3] of time O(k log n + n log2 n). Relying on our multi-broadcast algorithm, every node can learn the whole network topology in time O(m log3 n + n log4 n), where m is the number of edges in the network; learning topology is a possible preparation to switching from adhoc algorithms to centralized ones. The best previous algorithm for this task, based on gossip from [6], guaranteed only O((m + n)n1/2 log3 n) time. Related Work. Algorithmic aspects of radio communication have been widely studied in the last two decades. Both the directed graph model [4, 7, 11] and the undirected (symmetric) graph model [2, 12] of this paper have been used. Broadcasting [1, 2, 4, 8] and various variants of many-to-many communication primitives [3, 5–7, 10] were considered for radio networks. Below we give the best previously known results for four communication problems in ad hoc radio networks with which we are concerned in this paper: gathering, gossiping, routing and multi-broadcast. The best previously known deterministic algorithm for the problems of gathering, routing and multi-broadcast worked in time O(min{(k+n)n1/2 log3 n, (k+ n5/2 ) log3 n}) [6, 9], where the first part of the formula follows from a direct application of the gossip algorithm from [6] to consecutive batches of rumors, while the second part of the formula comes from learning the network topology (i.e., O(n2 ) edges) by gossiping from [6] and then applying multi-broadcast techniques for known topology graphs as in [9]. The best randomized algorithm used ex-

pected time O((k + n log n) log n) [3]. The best deterministic lower bound for these problems was Ω(k + n log n) [5, 8, 10, 12]. For gossiping, the best previously known deterministic algorithm worked in time O(n3/2 log3 n) [6] and the best randomized algorithm used expected time O(n log2 n) [3]. The best deterministic lower bound was Ω(n log n) [10].

2

Preliminaries

We model a radio network as a simple undirected connected graph G = (V, E), in which nodes represent stations and an edge connects two nodes that can directly transmit to each other. There are n nodes. Each node has a unique integer label assigned to it from the range [1, N ], for some positive integer N . We assume that N = O(nγ ) for a constant γ > 1, so that log N = O(log n), and that both n and N are powers of 2. (The latter assumption is for convenience only and can be easily removed.) All logarithms are to the base 2. We may assume that the nodes know only an upper bound on the number of nodes that is O(n). Here ‘knowledge’ means that the respective information can be part of code of an algorithm. We consider distributed algorithms for ad hoc networks, i.e., algorithms are not supplied with any a priori information about the topology of the underlying network. Also the number k of rumors is not initially known. Communication proceeds in synchronous rounds. A node can transmit or receive one message per round. A message transmitted by a node reaches all its neighbors in the round of the transmission. A message is said to be heard when it has been received successfully. Radio networks are defined by the property that a node hears a message in a round precisely when the node acts as a receiver and exactly one of its neighbors transmits in this round. If at least two neighbors of a node u transmit simultaneously in a given round, then none of the messages is heard by u and we say that a collision occurred at u. We do not assume that a node can distinguish between collision and ‘silence’ which occurs when no neighbor transmits. The inputs initially available to nodes are called rumors. We assume that all rumors are of equal size, and also that all messages are of equal size (otherwise we could pad a default sequence of bits to make them equal). In this paper we work in the model of small messages, in which it takes one whole message to carry a rumor. A message is capable of carrying up to O(log n) additional control bits. All procedures and algorithms, as well as their analysis, are given assuming an upper bound polynomial in n on the number k of rumors known to the nodes. This assumption is only for the sake of simplicity, and can be easily removed without increasing asymptotic complexity. The missing details and proofs are deferred to the full version of the paper. For an integer m > 0, the notation [m] denotes the set {1, . . . , m}. A transmission schedule F = (F0 , . . . , F`−1 ) is a sequence of subsets of [N ]. We say that F is executed in a sequence of consecutive rounds when the nodes transmitting in round i are precisely those whose labels are in Fk , where k and i are congruent modulo `.

A sequence F(m, k) = (F0 , . . . , F`−1 ) of subsets Fi ⊆ [m] is a (m, k)-selective family of length ` if, for each subset S ⊆ [m] of at most k elements, there exists Fj ∈ F(m, k) such that |Fj ∩ S| = 1. Selective families are used to produce efficient transmission schedules. It was proved in [8] that for any positive integers m ≥ k there exists an (m, k)-selective family of length O(k log(m/k)). Note that the round-robin transmission sequence, where all sets Fj are singletons, is a selective family but it is not efficient, since N is polynomial in n.

3

Building Blocks

We begin by developing building blocks for our target algorithms. 3.1

Breadth-Then-Depth Search (BTD)

We design a new token traversal of the network. The token is propagated through neighboring nodes, starting from the root. The goal of the token is to visit all the nodes and return to the root. We call the traversal breadth-then-depth (BTD) and the resulting tree is called a BTD tree. The concept of a BTD traversal is similar to that of DFS. The difference is that in an instance of passing the token from the token’s holder to its unvisited neighbor only one edge is added to the DFS tree (i.e., the edge connecting both these nodes), while in the construction of BTD all neighbors of the token’s holder that are outside of the current BTD tree get connected by an edge to the token’s holder, and thus to the tree. In order to implement the BTD traversal in a radio network, we rely on a construction to assign to any node v one of its neighbors; such a neighbor of v will be referred to as the offshoot of v. Given a node v and its designated neighbor w, it is possible to find an offshoot of v distinct from w, if there is at least one such neighbor, by a collaboration between v and w that terminates in O(log N ) time. It was shown in [12] how to accomplish locating an offshoot. The node w is called the witness of v in such a context. BTD search from a designated root can be accomplished by the following procedure BTD Search. Nodes have status either visited or unvisited. Once a node becomes visited, its status never changes. In the beginning all nodes except the root are unvisited, while the root is visited and holds the token. Let F be a (N, n)-selective family of length cn log N ⊆ O(n log n), for some constant c > 0, which exists by [8]. BTD Search proceeds as follows. In the first cn log N rounds, the family F is executed by all nodes except the root, with each node transmitting its own label. After that, the root transmits the first label w it heard, in order to notify this neighbor w that it has just become a witness of the root. Next, the following procedure is repeated until termination. Suppose that node v holds a token and w is its (neighbor) witness; we assume that v is visited. If v is not the root then v also has a designated parent. – Node v holding the token transmits a control message in order to let all its unvisited neighbors that have not yet heard a control message select v as

their parent. From the moment when a node receives a control message for the first time and selects its parent we call this node joined. All nodes that selected v as their parent did it in the same time — just after v had received the token for the first time and sent the control message. – Node v holding the token cooperates with its witness w to find an offshoot among the unvisited children of v in the constructed BTD tree. This process takes a fixed time O(log N ). If there is no unvisited child of v, in which case an offshoot is not selected, and v is the root then the procedure terminates. – If an offshoot v ∗ has been selected then node v passes the token to v ∗ ; otherwise v passes the token to its parent in the constructed BTD tree. – If a joined node v ∗ , selected as an offshoot, receives a token, then v ∗ becomes visited, and v becomes its witness. The node v is also a parent of v ∗ in the constructed BTD tree. Analysis. The following property follows from the design of the procedure, from the logarithmic time bound on locating an offshoot [12], and from the O(n log n) length of the selective family [8] used for choosing a witness of the root. Lemma 1. Procedure BTD Search performs a BTD search on the whole network and spans a BTD tree rooted at the initiating node in O(n log n) rounds. It can be shown that a BTD tree can be clustered into paths so that no collisions are caused by processes propagating messages on “parallel” paths, and there is an at most logarithmic number of paths on any branch from the root to a leaf. 3.2

Computing Weights on a Tree

Given a rooted tree D, with rumors located at nodes of this tree, we define the weight of node v as the sum of two numbers: the number of nodes in the subtree rooted at v and the number of rumors located in nodes of this subtree. The weight of the root of tree D is called the weight of tree D. The following procedure Compute Weights(D) computes the weight of each node of D locally at this node. The input tree D is given locally: each node knows only its parent and children (if any) in the tree. The procedure is initiated by the root of tree D: a token is issued by the root and travels along the tree in a DFS manner, eventually coming back to the root. The token carries two counters. The first counter is initialized to 0 and is incremented by r + 1 at each first visit of a node carrying r rumors. Each node computes its weight by subtracting the value of the counter of the first visit of the token from the value of the last visit. The second counter is initialized to 0 and incremented by one each time a node is visited by the token for the first time in this run. This counter is used for enumerating all nodes from 0 to n − 1. Lemma 2. Algorithm Compute Weights(D) terminates in time 2k, where k is the number of nodes of D.

3.3

Rumor Spreading on a Path

For a simple path P , let its length |P | be equal the number of edges, so that there are |P | + 1 nodes on the path. Let x be an upper bound on the weight of P interpreted as a tree, which means that there are at most x − |P | − 1 rumors in the nodes of P . We assume that each node of path P knows x, that P is given locally in the sense that each node in path P knows its neighbors in P , and that one end point of path P is designated to be a root. It is also assumed that there are no links connecting any two nodes in path P that are not neighbors in P . We develop a procedure called Spread on Path(P, x) whose execution results in every node in path P receiving all rumors originally located in the nodes on P . The procedure consists of three parts. In the first part the root initiates a token that traverses all the nodes in path P and carries a tally of the already visited nodes. This allows each node in P to learn its distance from the root of P . The first part takes up to x rounds, but if less than x then the nodes wait idle through round x so that all nodes in P know when part one ends. Immediately afterwards the up-propagation part starts to take the next 4x rounds; again the nodes wait idle through round 4x if needed. The goal of this part is to deliver all rumors in P to the root of P . In round i of this part, each node with the distance from the root congruent to 3 − i modulo 3 transmits the first packet in its transmission queue. In this queue there are packets that have not been transmitted by this node in the previous rounds of this procedure; the queue operates as a stack (LIFO queue). If there is no pending packet, then a node pauses and does not transmit any messages. Nodes that are not scheduled to transmit in a round automatically listen in this round to hear transmissions of neighbors. If a node receives a packet from a neighbor that is further away from the root then the recipient node enqueues the new packet to be eventually transmitted in due order. When the second part is concluded then the root has gathered all rumors. In the third part the other end of the path becomes a new root. The third part follows: it proceeds similarly as the second part with the modification that only the rumors stored in the original root are propagated towards the new root. This third part is called down-propagation also takes precisely 4x rounds, with nodes idling through round 4x if needed. Lemma 3. Consider an execution of procedure Spread on Path(P, x). If the sum of the number of nodes in path P and the number of rumors is at most x, then all rumors initially located in nodes of path P are delivered to all nodes of P within 9x rounds.

4

Gathering Rumors

In the problem of gathering, there are k different rumors distributed arbitrarily among n nodes of the network and the goal is to gather all the rumors in one designated node called the sink. The gathering problem is handled by introducing and exploring a clustering based on newly defined BTD search trees and a weighing method. The key underlying property of this approach is that we can

quickly and locally identify sufficiently long and disjoint paths, and then pipeline the rumors along these paths without causing interference. We also show that only a logarithmic number of changes between paths is sufficient to transmit a rumor from its source to the root of the tree. We start with describing the clustering procedure Cluster to Gather. Next we give the main procedure Tree Gather to gather rumors in the root of a given BTD tree known locally, exploring the computed clustering. We conclude with the final description of algorithm Radio Gather. In the specification of the procedures Cluster to Gather and Tree Gather we assume that there is an exact number of rounds dedicated to each part, and even though the activity in some part may be finished earlier, nodes wait until the end of the specified period before starting the next part. This assumption allows to synchronize parts of these procedures and simplify the analysis. Clustering Procedure. We introduce a procedure Cluster to Gather(D, x), which has input parameters with the following properties: G1: A rooted BTD tree D spanning V with each node knowing only its parent and children, if any, in the tree; in particular, a node knows whether it is the root or not; G2: An upper bound x on the sum of the number of rumors and of |V |; x is known to every node; there is an initial allocation of at most x − |V | ≥ 1 rumors among the nodes in V . The procedure computes a clustering of a given BTD tree D in network G. This clustering is a generalization of heavy path decomposition (c.f., [13]) to weighted trees in the radio network model. Together with some properties of BTD tree, the clustering allows an efficient parallelization of gathering and spreading rumors in radio networks. Assume that the properties G1-G2 are satisfied by D and by the initial rumor allocation. To simplify the exposition, we can assume without loss of generality that x is a power of 2. Define Si , for an integer 0 ≤ i ≤ log x, to be the set of nodes in V weighing more than 2i−1 and at most 2i in tree D. (Nodes in S0 do not have any rumor in the beginning.) Let Di be the sub-forest of the considered component induced by the nodes in Si ; we will show later that it is a collection of paths of tree D. For each connected component of Di we define its root as the (only) node that does not have its parent in this component, and its second-in-charge node as the (only) child of the root in the component (if the component has more than one node). Procedure Cluster to Gather(D, x) Part 1: The root in D calls procedure Compute Weights(D). Upon completion of this part each node in V locally computes its weight, which is in the range [x], and its number in the traversal route, which is in the range [n]. This part takes 2x rounds. Part 2: The root in D initiates a token to traverse the tree D in a DFS manner. The token propagates the weight of the current owner of the token computed

during Part 1. Upon completion of this part each node knows in which sets Si are its children and its parent in tree D. This part takes 2x rounds. Part 3: The root in D initiates a token to traverse the tree D in a DFS manner. It carries the information whether the parent of the current owner of the token is in the same set Si — this was computed by the sender during Part 2. Upon completion of this part each node knows whether it is second-in-charge in some tree-component of the corresponding forest Di or not. This part takes 2x rounds. Lemma 4. Consider an execution of the procedure Cluster to Gather(D, x). Upon its termination, which happens after 6x rounds, each node knows to which set Si it belongs, and whether it is a root or a second-in-charge node. Moreover, for any 0 ≤ i ≤ log x, the set Si and the corresponding forest Di satisfy the following properties: (i) Di consists of paths, each being a sub-path of some path from the root to some leaf in the initial tree D; moreover, the sub-graph of G induced by the nodes on such a single path forms the same path (i.e., there are no shortcuts between nodes in the path in the underlying network G); (ii) for every two path-components of forest Di , if two nodes from different components are connected by an edge in graph G, at least one of them must be the root of one component. Gathering Procedure. Given a rooted tree D, we design the gathering procedure along this tree as follows: Procedure Tree Gather(D, x) Part 1: Procedure Cluster to Gather(D, x) is executed. Part 2: for i = 1 to log x do: perform the stages Stage (a): Each node v second-in-charge in Si initiates Spread on Path(P, x) as the root of path P which is defined as follows. A node is in P , if it is in Si and is a descendant of v in the tree D. This stage takes 9x rounds. Stage (b): The root of D initiates the token, which is sent along tree D in a DFS manner. A node whose parent in D is in a set Sj for j 6= i is a root of the forest Di . Whenever a root of the forest Di receives a traversing token for the first time, it keeps forwarding all its gathered rumors towards its grandparent in D, one after another. Each such forwarding operation takes two rounds and goes through the parent of the token holder. After the last rumor is delivered, the token is passed to the next node in the DFS traversal of D. This stage takes 4x rounds. Part 3: The root of D initiates procedure Spread on Path(Slog x , x). This part takes 9x rounds. Lemma 5. An execution of procedure Tree Gather(D, x) results in gathering all the rumors stored in the nodes of the tree D in the root of D, which takes O(x log n) rounds, if x is an upper bound on the sum of the number of nodes |V | and the number of rumors initially stored in S.

Algorithm. Finally we specify an algorithm for the gathering problem, with a designated sink node w: Algorithm Radio Gather(w) Part 1: Node w calls procedure BTD Search to create a BTD tree D spanning the network G and rooted at w. Part 2: Node w calls procedure Compute Weights(D), and then computes its weight x. Part 3: Procedure Tree Gather(D, x) is executed. Theorem 1. Algorithm Radio Gather solves the gathering problem for any distribution of k rumors in a n-node network, using O((k + n) log n) rounds.

5

Multi-Broadcast

Multi-broadcast is a generalization of gossiping: there are k rumors distributed arbitrarily among nodes and the goal is for all the nodes to learn every rumor. Graph Clustering. Procedure Cluster to Spread(S, D) is similar to procedure Cluster to Gather(S, D) from Section 4. The differences are as follows: (i) while pre-computing a partitioning of the nodes and a BTD tree D into sets Si and forests Di , for 0 ≤ i ≤ log n, the weight is defined only in terms of the number of nodes, that is, we do not account for any rumors in the nodes; (ii) apart from computing by each node its weight and the weight of all its neighbors in the network, and thus being able to recognize to which set Si the node and its neighbors belong, each node v computes a specific subset Rv of its neighbors. Dense Broadcast Schedules. Define a (n, a, ε)-ultra-selector to be a family of sets such that for any set A ⊆ [n] of size at most a and more than a/2 there is at least a ε fraction of the sets in the family that intersect A on a single element, for a given 1 ≤ a ≤ n and 0 < ε ≤ 1. Lemma 6. For any given constant 0 < ε ≤ 1/32 and sufficiently large parameter n, there is a constant β > 1, which depends only on ε, such that for every 1 ≤ a ≤ n there exists a (n, a, ε)-ultra-selector of length at most β · a log(2n/a). Procedure Partial Ultra Broadcast is composed of log n interleaved threads, where in the i-th thread the (n, 2i , 1/32)-ultra-selector is executed in a cyclic way, for 0 ≤ i ≤ log n − 1; in thread log n the round robin procedure on range [n] is run (observe that the round robin transmission scheme corresponds to a (n, n, 1/32)-ultra-selector). The length of each thread is bounded by β · n, where β and the ultra-selectors are as specified in Lemma 6. Therefore, the whole length of procedure Partial Ultra Broadcast is β · n log n. It follows from Lemma 6, when applied to the neighborhood of a node, that for any node there is at least a 1 fraction 32 log n of the rounds of Partial Ultra Broadcast that are successful from the point of view of this node, in the sense that in each of these rounds there is exactly one neighbor of this node scheduled to transmit.

Computing Short Broadcast Schedules for Pipelining Rumors. This is the most involved technical part of our multi-broadcast algorithm. Suppose that we are given a set S ∗ ⊆ V and the spanning tree D of network G. We assume that each node locally knows D and can locally check whether itself and some of its neighbors in G are in set S ∗ . The aim is to construct a family {Bv }v∈S ∗ that is a broadcast schedule from set S ∗ to set S 0 of children of S ∗ in the tree D. By a broadcast schedule we understand a set of transmission schedules such that each node in S 0 eventually receives a message from some node in S ∗ , if nodes in S ∗ follow the schedule. The following Procedure Down Hop(S ∗ , D), for any subset S ∗ ⊆ S, outputs in each node v a subset of round-numbers Bv ⊆ {1, 2, . . . , 64 log2 n}. The procedure is recursive with respect to the set S 0 of uninformed children of nodes in S ∗ in tree D. Additionally, nodes maintain the depth of recursion, called depth. In the very beginning of the procedure, each node w ∈ S 0 of some node in set S ∗ simulates locally procedure Partial Ultra Broadcast with respect to all its neighbors in S ∗ in network G; based on this, node w computes the set of rounds Rw in which it would successfully receive a message from some of its neighbors in S ∗ . The first 2n log(βn log2 n) communication rounds are split into log(βn log2 n) consecutive parts, each consisting of 2n communication rounds in which a token traverses the whole tree D in a DFS manner, computing and updating local values. The goal of these parts is to find a round b ∈ {1, . . . , βn log2 n} in the locally simulated execution of procedure Partial Ultra Broadcast in which at least |S 0 | 0 ∗ 32 log n nodes in S would receive a message from some of their neighbors in S . ∗ Consequently, all nodes in S that were scheduled to transmit in round b during procedure Partial Ultra Broadcast are set as transmitters in round depth of the schedules {Bv }v∈S ∗ output by procedure Down Hop(S ∗ , D), i.e., depth ∈ Bv for any v ∈ S ∗ that was scheduled to transmit in round b of the (locally simulated) execution of procedure Partial Ultra Broadcast. By the properties of 1 procedure Partial Ultra Broadcast, set S 0 shrinks by the fraction 32 log n . After ∗ that, we increase depth by one and call recursively Down Hop(S , D) with respect to the new set S 0 of uninformed children of S ∗ in D. It follows that after at most 64 log2 n recursive calls, set S 0 becomes empty, and therefore the output schedules {Bv }v∈S ∗ are well defined. The length of the procedure is O(log2 n · n log n) ⊆ O(n log3 n). Pipelining Rumors from a Source. We specify procedure Tree Spread(D, k) which, given a BTD spanning tree D and k rumors gathered in the root of the tree, delivers the rumors to all nodes in the network. The procedure is initiated by the root. First, all nodes in path Dlog n execute procedure Spread on Path(Slog n , n + k), so that all of them get all k rumors from the root. Then log n stages are executed sequentially. The goal of stage i, for i = log n, log n − 1, . . . , 1, is to deliver rumors gathered by each node of forest Di to every node in forest Di−1 . This is achieved by applying twice procedure Down Hop and procedure Spread on Path. The whole propagation of rumors from nodes in Di to all nodes in Di−1 takes O(n log3 n + k log2 n) rounds. There are log n forests, due to clustering, and therefore the whole cost of procedure Tree Spread(D, k) is O(n log4 n + k log3 n).

Multi-Broadcast Algorithm. We use the leader election algorithm described in [7] (Radio Leader), to find a leader in time O(n log3 n) using O(log n)-bit messages. Algorithm Radio Multi Broadcast Part 1: Run algorithm Radio Leader to elect a leader w. Part 2: Gather all the rumors in w by calling algorithm Radio Gather(w). Create a BTD tree D, spanning network G and rooted at w, and distribute the number k of rumors gathered in w. Part 3: Node w calls procedure Tree Spread(V, D, k). Theorem 2. Algorithm Radio Multi Broadcast completes multi-broadcast for any distribution of k rumors in a n-node radio network in time O(k log3 n+n log4 n). Corollary 1. Routing k rumors in a n-node network can be accomplished in time O(k log3 n+n log4 n), and gossiping can be accomplished in time O(n log4 n).

References 1. N. Alon, A. Bar-Noy, N. Linial, and D. Peleg, A lower bound for radio broadcast, Journal of Computer and System Sciences, 43 (1991) 290 - 298. 2. R. Bar-Yehuda, O. Goldreich, and A. Itai, On the time complexity of broadcast in radio networks: An exponential gap between determinism and randomization, Journal of Computer and System Sciences, 45 (1992) 104 - 126. 3. R. Bar-Yehuda, A. Israeli, and A. Itai, Multiple communication in multi-hop radio networks, SIAM Journal on Computing, 22 (1993) 875 - 887. 4. B.S. Chlebus, L. Gasieniec, A.M. Gibbons, A. Pelc, and W. Rytter, Deterministic , broadcasting in ad hoc radio networks, Distributed Computing, 15 (2002) 27 - 38. 5. B. S. Chlebus, D. R. Kowalski, and T. Radzik, Many-to-many communication in radio networks, Algorithmica, 54(1): 118 - 139, 2009. 6. M. Christersson, L. Gasieniec, and A. Lingas, Gossiping with bounded size mes, sages in ad-hoc radio networks, in Proc., 29th International Colloquium on Automata, Languages and Programming (ICALP), 2002, pp. 377 - 389. 7. M. Chrobak, L. Gasieniec, and W. Rytter, Fast broadcasting and gossiping in radio , networks, Journal of Algorithms, 43 (2002) 177 - 189. 8. A.E.F. Clementi, A. Monti, and R. Silvestri, Distributed broadcasting in radio networks of unknown topology, Theoretical Computer Science, 302 (2003) 337-364. 9. L. Gasieniec, E. Kranakis, A. Pelc, and Q. Xin, Deterministic m2m multicast in , radio networks, in Proc., 31st International Colloquium on Automata, Languages and Programming (ICALP), 2004, pp. 670 - 682. 10. L. Gasieniec, I. Potapov, Gossiping with unit messages in known radio networks, , in Proc., 2nd International Conference on Theoretical Computer Science (TCS), 2002, pp. 193 - 205. 11. L. Gasieniec, T. Radzik, and Q. Xin, Faster deterministic gossiping in directed , ad-hoc radio networks, in Proc., 9th Scandinavian Workshop on Algorithm Theory (SWAT), 2004, pp. 397 - 407. 12. D.R. Kowalski, and A. Pelc, Broadcasting in undirected ad-hoc radio networks, Distributed Computing, 18 (2005) 43 - 57. 13. D.D. Sleator and R.E. Tarjan, A data structure for dynamic trees, Journal of Computer and System Sciences, 26 (1983) 362 - 391.