Efficient Distributed Communicationin 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 Departement d’informatique, Universite du Quebec en Outaouais, Canada.

Abstract. We present new distributed deterministic solutions to twocommunication problems in n-node ad-hoc radio networks: rumor gath-ering and multi-broadcast. In these problems, some or all nodes of thenetwork initially contain input data called rumors, which have to belearned by other nodes. In rumor gathering, there are k rumors ini-tially distributed arbitrarily among the nodes, and the goal is to col-lect all the rumors at one node. Our rumor gathering algorithm worksin O((k + n) logn) time and our multi-broadcast algorithm works inO(k log3 n+n log4 n) time, for any n-node networks and k rumors (witharbitrary k), which is a substantial improvement over the best previouslyknown deterministic solutions to these problems.As a consequence, we exponentially decrease the gap between upper andlower bounds on the deterministic time complexity of four communica-tion 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 rout-ing). Indeed, for k = O(n), our results simultaneously decrease the com-plexity gaps for these four problems from polynomial to polylogarithmicin the size of the graph. Moreover, our deterministic gathering algorithmapplied for k = O(n) rumors, improves over the best previously knownrandomized algorithm of time O(k logn + 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 forwireless communication. Multiple messages arriving at a node in the same roundinterfere with one another so that none can be heard. We use simple undirectedgraphs to represent network topologies. Each of our algorithms works for any

? The first author is supported by the NSF Grant 1016847. The second author issupported by the Engineering and Physical Sciences Research Council [grant num-bers EP/G023018/1, EP/H018816/1]. The third author is partially supported by aNSERC discovery grant and by the Research Chair in Distributed Computing at theUniversite du Quebec en Outaouais.

network topology on n nodes. The performance bounds we develop hold for allnetworks 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 ofthe network initially contain input data called rumors, which have to be learnedby other nodes. Messages are small: each of them carries at most one rumorand O(log n) additional control bits. For rumor gathering, there are k rumors,where k is an arbitrary positive integer (independent on n), initially distributedarbitrarily among the nodes, and the goal is to collect all the rumors at onenode. Multi-broadcast is related to two fundamental communication problems:gossiping and routing. In gossiping, every node is initialized with a rumor andthe goal is for all nodes to learn all rumors. In routing, k rumors distributed ar-bitrarily 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 forall the nodes to learn every rumor. This is a generalization of gossiping (initiallynot all nodes need to have a rumor) and a strengthening of routing (all nodesneed 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 twofeatures of the model of ad-hoc radio networks. On the one hand, nodes donot know the topology of the network, and on the other hand communicationalgorithms are hard to design due to possible collisions that prevent nodes fromhearing messages. In unknown topologies collisions are unavoidable, and nodesneed not even be aware of their occurrence, as they do not have the collisiondetection capability.

Our approach to overcome these problems builds on two main algorithmictechniques introduced in this paper, both of them being deterministic and fullydistributed. 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 beclustered into a logarithmic number of forests, and in each forest messages canbe propagated in parallel without causing any collision except possibly in rootsof the forest. Moreover, each path of this tree from a node to the root is splitinto an at most logarithmic number of sub-paths, each belonging to a differentforest (c.f., Section 4). Note that a DFS tree could cause a large number ofcollisions while propagating rumors within a path to the root, due to possibleshortcut 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 whentransmitting from one layer to another, and it is not even known how to constructit deterministically and in a distributed way in a sub-quadratic number of roundsin general radio networks. The second crucial technique is to efficiently propagaterumors between different forests of the constructed clustering, which we do bycomputing (again, in a deterministic and distributed way) short transmissionschedules 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 rumorson paths and how to deal with potential collisions in roots of the forests.

Our Results. Building on novel algorithmic techniques introduced in this workwe develop efficient deterministic distributed algorithms for gathering rumorsand for multi-broadcast.

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 net-works and k rumors (with arbitrary k), which is a substantial improvement overthe best previously known deterministic solutions to these problems. Indeed,the best previously known deterministic algorithms for the problems of gather-ing, 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-broadcastalgorithm (for k = n) we accomplish gossiping in O(n log4 n) time, while thebest algorithm for this problem worked in time O(n3/2 log3 n) [6]. On the otherhand, the best known deterministic lower bound for the first three problemswas Ω(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 lowerbounds on the deterministic time complexity of four communication problems:rumor gathering, multi-broadcast, gossiping and routing, in the important casewhen every node has initially at most one rumor (this is the scenario for gossip-ing and for the usual formulation of routing). Indeed, for k = O(n), our resultssimultaneously decrease the complexity gaps for these four problems from poly-nomial to polylogarithmic in the size of the graph.

Moreover, our deterministic gathering algorithm applied for k = O(n) ru-mors, improves over the best previously known randomized algorithm [3] of timeO(k log n+ n log2 n).

Relying on our multi-broadcast algorithm, every node can learn the wholenetwork topology in time O(m log3 n+n log4 n), where m is the number of edgesin the network; learning topology is a possible preparation to switching from ad-hoc 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 widelystudied in the last two decades. Both the directed graph model [4, 7, 11] andthe undirected (symmetric) graph model [2, 12] of this paper have been used.Broadcasting [1, 2, 4, 8] and various variants of many-to-many communicationprimitives [3, 5–7, 10] were considered for radio networks.

Below we give the best previously known results for four communicationproblems 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 gath-ering, 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 ap-plication of the gossip algorithm from [6] to consecutive batches of rumors, whilethe 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 techniquesfor 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 forthese problems was Ω(k + n log n) [5, 8, 10, 12].

For gossiping, the best previously known deterministic algorithm worked intime O(n3/2 log3 n) [6] and the best randomized algorithm used expected timeO(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), inwhich nodes represent stations and an edge connects two nodes that can directlytransmit to each other. There are n nodes. Each node has a unique integer labelassigned to it from the range [1, N ], for some positive integer N . We assumethat N = O(nγ) for a constant γ > 1, so that logN = O(log n), and that bothn and N are powers of 2. (The latter assumption is for convenience only andcan be easily removed.) All logarithms are to the base 2. We may assume thatthe 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 codeof an algorithm. We consider distributed algorithms for ad hoc networks, i.e.,algorithms are not supplied with any a priori information about the topology ofthe underlying network. Also the number k of rumors is not initially known.

Communication proceeds in synchronous rounds. A node can transmit orreceive one message per round. A message transmitted by a node reaches all itsneighbors in the round of the transmission. A message is said to be heard when ithas been received successfully. Radio networks are defined by the property thata node hears a message in a round precisely when the node acts as a receiver andexactly one of its neighbors transmits in this round. If at least two neighbors ofa node u transmit simultaneously in a given round, then none of the messagesis heard by u and we say that a collision occurred at u. We do not assumethat a node can distinguish between collision and ‘silence’ which occurs when noneighbor transmits.

The inputs initially available to nodes are called rumors. We assume that allrumors are of equal size, and also that all messages are of equal size (otherwise wecould pad a default sequence of bits to make them equal). In this paper we workin the model of small messages, in which it takes one whole message to carry arumor. 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 anupper 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 removedwithout increasing asymptotic complexity. The missing details and proofs aredeferred to the full version of the paper.

For an integer m > 0, the notation [m] denotes the set 1, . . . ,m. A trans-mission schedule F = (F0, . . . , F`−1) is a sequence of subsets of [N ]. We say thatF is executed in a sequence of consecutive rounds when the nodes transmittingin round i are precisely those whose labels are in Fk, where k and i are congruentmodulo `.

A sequence F(m, k) = (F0, . . . , F`−1) of subsets Fi ⊆ [m] is a (m, k)-selectivefamily of length ` if, for each subset S ⊆ [m] of at most k elements, there existsFj ∈ F(m, k) such that |Fj ∩ S| = 1. Selective families are used to produceefficient transmission schedules. It was proved in [8] that for any positive integersm ≥ k there exists an (m, k)-selective family of length O(k log(m/k)). Note thatthe round-robin transmission sequence, where all sets Fj are singletons, is aselective 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 throughneighboring nodes, starting from the root. The goal of the token is to visit all thenodes 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 issimilar to that of DFS. The difference is that in an instance of passing the tokenfrom the token’s holder to its unvisited neighbor only one edge is added to theDFS tree (i.e., the edge connecting both these nodes), while in the constructionof BTD all neighbors of the token’s holder that are outside of the current BTDtree 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 aconstruction to assign to any node v one of its neighbors; such a neighbor ofv will be referred to as the offshoot of v. Given a node v and its designatedneighbor w, it is possible to find an offshoot of v distinct from w, if there is atleast one such neighbor, by a collaboration between v and w that terminates inO(logN) time. It was shown in [12] how to accomplish locating an offshoot. Thenode w is called the witness of v in such a context.

BTD search from a designated root can be accomplished by the followingprocedure BTD Search. Nodes have status either visited or unvisited. Once anode becomes visited, its status never changes. In the beginning all nodes exceptthe root are unvisited, while the root is visited and holds the token.

Let F be a (N,n)-selective family of length cn logN ⊆ O(n log n), for someconstant c > 0, which exists by [8]. BTD Search proceeds as follows.

In the first cn logN rounds, the family F is executed by all nodes except theroot, with each node transmitting its own label. After that, the root transmits thefirst label w it heard, in order to notify this neighbor w that it has just become awitness 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 assumethat 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 itsunvisited neighbors that have not yet heard a control message select v as

their parent. From the moment when a node receives a control message forthe first time and selects its parent we call this node joined. All nodes thatselected v as their parent did it in the same time — just after v had receivedthe token for the first time and sent the control message.

– Node v holding the token cooperates with its witness w to find an offshootamong the unvisited children of v in the constructed BTD tree. This processtakes a fixed time O(logN). If there is no unvisited child of v, in which casean 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∗; oth-erwise 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∗ becomesvisited, and v becomes its witness. The node v is also a parent of v∗ in theconstructed BTD tree.

Analysis. The following property follows from the design of the procedure, fromthe 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 networkand 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 nocollisions are caused by processes propagating messages on “parallel” paths, andthere is an at most logarithmic number of paths on any branch from the root toa leaf.

3.2 Computing Weights on a Tree

Given a rooted tree D, with rumors located at nodes of this tree, we define theweight of node v as the sum of two numbers: the number of nodes in the subtreerooted at v and the number of rumors located in nodes of this subtree. Theweight of the root of tree D is called the weight of tree D. The following procedureCompute 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 isissued by the root and travels along the tree in a DFS manner, eventually comingback to the root. The token carries two counters. The first counter is initializedto 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 thefirst visit of the token from the value of the last visit. The second counter isinitialized to 0 and incremented by one each time a node is visited by the tokenfor the first time in this run. This counter is used for enumerating all nodes from0 to n− 1.

Lemma 2. Algorithm Compute Weights(D) terminates in time 2k, where k isthe 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 thatthere are |P |+ 1 nodes on the path. Let x be an upper bound on the weight ofP interpreted as a tree, which means that there are at most x− |P | − 1 rumorsin the nodes of P . We assume that each node of path P knows x, that P is givenlocally in the sense that each node in path P knows its neighbors in P , and thatone end point of path P is designated to be a root. It is also assumed that thereare 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 inevery 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 atoken that traverses all the nodes in path P and carries a tally of the alreadyvisited 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 idlethrough round x so that all nodes in P know when part one ends. Immediatelyafterwards the up-propagation part starts to take the next 4x rounds; again thenodes wait idle through round 4x if needed. The goal of this part is to deliverall rumors in P to the root of P . In round i of this part, each node with thedistance from the root congruent to 3 − i modulo 3 transmits the first packetin its transmission queue. In this queue there are packets that have not beentransmitted by this node in the previous rounds of this procedure; the queueoperates as a stack (LIFO queue). If there is no pending packet, then a nodepauses and does not transmit any messages. Nodes that are not scheduled totransmit in a round automatically listen in this round to hear transmissionsof neighbors. If a node receives a packet from a neighbor that is further awayfrom the root then the recipient node enqueues the new packet to be eventuallytransmitted in due order. When the second part is concluded then the root hasgathered all rumors. In the third part the other end of the path becomes a newroot. The third part follows: it proceeds similarly as the second part with themodification that only the rumors stored in the original root are propagatedtowards the new root. This third part is called down-propagation also takesprecisely 4x rounds, with nodes idling through round 4x if needed.

Lemma 3. Consider an execution of procedure Spread on Path(P, x). If the sumof the number of nodes in path P and the number of rumors is at most x, thenall rumors initially located in nodes of path P are delivered to all nodes of Pwithin 9x rounds.

4 Gathering Rumors

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

quickly and locally identify sufficiently long and disjoint paths, and then pipelinethe rumors along these paths without causing interference. We also show thatonly a logarithmic number of changes between paths is sufficient to transmit arumor from its source to the root of the tree.

We start with describing the clustering procedure Cluster to Gather. Next wegive the main procedure Tree Gather to gather rumors in the root of a givenBTD tree known locally, exploring the computed clustering. We conclude withthe final description of algorithm Radio Gather.

In the specification of the procedures Cluster to Gather and Tree Gather weassume that there is an exact number of rounds dedicated to each part, and eventhough the activity in some part may be finished earlier, nodes wait until theend of the specified period before starting the next part. This assumption allowsto synchronize parts of these procedures and simplify the analysis.

Clustering Procedure. We introduce a procedure Cluster to Gather(D,x), whichhas input parameters with the following properties:

G1: A rooted BTD tree D spanning V with each node knowing only its parentand children, if any, in the tree; in particular, a node knows whether it is theroot or not;

G2: An upper bound x on the sum of the number of rumors and of |V |; x isknown to every node; there is an initial allocation of at most x − |V | ≥ 1rumors among the nodes in V .

The procedure computes a clustering of a given BTD tree D in network G. Thisclustering is a generalization of heavy path decomposition (c.f., [13]) to weightedtrees in the radio network model. Together with some properties of BTD tree, theclustering allows an efficient parallelization of gathering and spreading rumors inradio networks. Assume that the properties G1-G2 are satisfied by D and by theinitial rumor allocation. To simplify the exposition, we can assume without lossof generality that x is a power of 2. Define Si, for an integer 0 ≤ i ≤ log x, to bethe set of nodes in V weighing more than 2i−1 and at most 2i in tree D. (Nodesin S0 do not have any rumor in the beginning.) Let Di be the sub-forest of theconsidered component induced by the nodes in Si; we will show later that it is acollection of paths of tree D. For each connected component of Di we define itsroot as the (only) node that does not have its parent in this component, and itssecond-in-charge node as the (only) child of the root in the component (if thecomponent has more than one node).

Procedure Cluster to Gather(D,x)

Part 1: The root in D calls procedure Compute Weights(D). Upon completionof 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]. Thispart 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 setsSi 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. Itcarries the information whether the parent of the current owner of the tokenis in the same set Si — this was computed by the sender during Part 2. Uponcompletion of this part each node knows whether it is second-in-charge insome tree-component of the corresponding forest Di or not. This part takes2x rounds.

Lemma 4. Consider an execution of the procedure Cluster to Gather(D,x). Uponits termination, which happens after 6x rounds, each node knows to which set Siit belongs, and whether it is a root or a second-in-charge node. Moreover, for any0 ≤ i ≤ log x, the set Si and the corresponding forest Di satisfy the followingproperties:

(i) Di consists of paths, each being a sub-path of some path from the root tosome leaf in the initial tree D; moreover, the sub-graph of G induced by the nodeson such a single path forms the same path (i.e., there are no shortcuts betweennodes in the path in the underlying network G);

(ii) for every two path-components of forest Di, if two nodes from differentcomponents are connected by an edge in graph G, at least one of them must bethe root of one component.

Gathering Procedure. Given a rooted tree D, we design the gathering procedurealong 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 stagesStage (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 inSi 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 aDFS manner. A node whose parent in D is in a set Sj for j 6= i is a root ofthe forest Di. Whenever a root of the forest Di receives a traversing tokenfor the first time, it keeps forwarding all its gathered rumors towards itsgrandparent in D, one after another. Each such forwarding operation takestwo rounds and goes through the parent of the token holder. After the lastrumor is delivered, the token is passed to the next node in the DFS traversalof D. This stage takes 4x rounds.

Part 3: The root of D initiates procedure Spread on Path(Slog x, x). This parttakes 9x rounds.

Lemma 5. An execution of procedure Tree Gather(D,x) results in gathering allthe rumors stored in the nodes of the tree D in the root of D, which takesO(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 adesignated sink node w:

Algorithm Radio Gather(w)

Part 1: Node w calls procedure BTD Search to create a BTD tree D spanningthe network G and rooted at w.

Part 2: Node w calls procedure Compute Weights(D), and then computes itsweight x.

Part 3: Procedure Tree Gather(D,x) is executed.

Theorem 1. Algorithm Radio Gather solves the gathering problem for any dis-tribution 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 distributedarbitrarily 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 procedureCluster to Gather(S,D) from Section 4. The differences are as follows: (i) whilepre-computing a partitioning of the nodes and a BTD tree D into sets Si andforests Di, for 0 ≤ i ≤ log n, the weight is defined only in terms of the num-ber of nodes, that is, we do not account for any rumors in the nodes; (ii) apartfrom computing by each node its weight and the weight of all its neighbors inthe network, and thus being able to recognize to which set Si the node and itsneighbors 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 setssuch that for any set A ⊆ [n] of size at most a and more than a/2 there is atleast 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 param-eter n, there is a constant β > 1, which depends only on ε, such that for every1 ≤ 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 cyclicway, 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 lengthof procedure Partial Ultra Broadcast is β ·n log n. It follows from Lemma 6, whenapplied to the neighborhood of a node, that for any node there is at least afraction 1

32 logn of the rounds of Partial Ultra Broadcast that are successful fromthe point of view of this node, in the sense that in each of these rounds there isexactly one neighbor of this node scheduled to transmit.

Computing Short Broadcast Schedules for Pipelining Rumors. This is the mostinvolved technical part of our multi-broadcast algorithm. Suppose that we aregiven a set S∗ ⊆ V and the spanning tree D of network G. We assume thateach node locally knows D and can locally check whether itself and some of itsneighbors in G are in set S∗. The aim is to construct a family Bvv∈S∗ thatis a broadcast schedule from set S∗ to set S′ of children of S∗ in the tree D.By a broadcast schedule we understand a set of transmission schedules suchthat each node in S′ eventually receives a message from some node in S∗, ifnodes 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-numbersBv ⊆ 1, 2, . . . , 64 log2 n.

The procedure is recursive with respect to the set S′ of uninformed children ofnodes in S∗ in tree D. Additionally, nodes maintain the depth of recursion, calleddepth. In the very beginning of the procedure, each node w ∈ S′ of some node inset S∗ simulates locally procedure Partial Ultra Broadcast with respect to all itsneighbors in S∗ in network G; based on this, node w computes the set of roundsRw in which it would successfully receive a message from some of its neighbors inS∗. 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 tokentraverses the whole tree D in a DFS manner, computing and updating localvalues. The goal of these parts is to find a round b ∈ 1, . . . , βn log2 n in thelocally simulated execution of procedure Partial Ultra Broadcast in which at least|S′|

32 logn 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 depthof the schedules Bvv∈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 (locallysimulated) execution of procedure Partial Ultra Broadcast. By the properties ofprocedure Partial Ultra Broadcast, set S′ shrinks by the fraction 1

32 logn . After

that, we increase depth by one and call recursively Down Hop(S∗, D) with respectto the new set S′ of uninformed children of S∗ in D. It follows that after at most64 log2 n recursive calls, set S′ becomes empty, and therefore the output schedulesBvv∈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, deliv-ers the rumors to all nodes in the network. The procedure is initiated by the root.First, all nodes in path Dlogn execute procedure Spread on Path(Slogn, n + k),so that all of them get all k rumors from the root. Then log n stages are exe-cuted sequentially. The goal of stage i, for i = log n, log n− 1, . . . , 1, is to deliverrumors gathered by each node of forest Di to every node in forest Di−1. This isachieved 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 takesO(n log3 n + k log2 n) rounds. There are log n forests, due to clustering, andtherefore 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 numberk 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 anydistribution 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 intime 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 broadcastin 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 radionetworks, SIAM Journal on Computing, 22 (1993) 875 - 887.

4. B.S. Chlebus, L. G asieniec, A.M. Gibbons, A. Pelc, and W. Rytter, Deterministicbroadcasting 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 inradio networks, Algorithmica, 54(1): 118 - 139, 2009.

6. M. Christersson, L. G asieniec, and A. Lingas, Gossiping with bounded size mes-sages in ad-hoc radio networks, in Proc., 29th International Colloquium on Au-tomata, Languages and Programming (ICALP), 2002, pp. 377 - 389.

7. M. Chrobak, L. G asieniec, and W. Rytter, Fast broadcasting and gossiping in radionetworks, Journal of Algorithms, 43 (2002) 177 - 189.

8. A.E.F. Clementi, A. Monti, and R. Silvestri, Distributed broadcasting in radionetworks of unknown topology, Theoretical Computer Science, 302 (2003) 337-364.

9. L. G asieniec, E. Kranakis, A. Pelc, and Q. Xin, Deterministic m2m multicast inradio networks, in Proc., 31st International Colloquium on Automata, Languagesand Programming (ICALP), 2004, pp. 670 - 682.

10. L. G asieniec, 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. G asieniec, T. Radzik, and Q. Xin, Faster deterministic gossiping in directedad-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 ofComputer and System Sciences, 26 (1983) 362 - 391.