Multiple Communication in Multi-Hop Radio Networks

Transcription

1 Multiple Communication in Multi-Hop Radio Networks Reuven Bar-Yehuda 1 Amos Israeli 2 Alon Itai 3 Department of Computer Department of Electrical Department of Computer Science Engineering Science Technion - Israel Institute of Technology, Haifa, 32000, ISRAEL. ABSTRACT Two tasks of communication in a multi-hop synchronous radio network are considered: point-to-point communication and broadcast (sending a message to all nodes of a network). Efficient protocols for both problems are presented. Even though the protocols are probabilistic, it is shown how to acknowledge messages deterministically. Let n, D, and be the number of nodes, the diameter and the maximum degree of our network, respectively. Both protocols require a setup phase in which a BFS tree is constructed. This phase takes O ((n + Dlogn)log ) time. After the setup, k point-to-point transmissions require O ((k +D)log ) time on the average. Therefore the network allows a new transmission every O (log ) time slots. Also, k broadcasts require an average of O ((k +D)log logn) time. Hence the average throughput of the network is a broadcast every O(log logn) time slots. Both protocols pipeline the messages along the BFS tree. They are always successful on the graph spanned by the BFS tree. Their probabilistic behavior refers only to the running time. Using the above protocols the ranking problem is solved in O (nlognlog ) time. The performance analysis of both protocols constitutes a new application of queueing theory. Keywords: Radio networks, broadcast, point-to-point routing, distributed algorithms, average case analysis, Queueing Theory. A preliminary version of this paper was presented in the Symposium on Principles of Distributed Computing, Edmonton, Canada, Partially supported by Technion V.P.R. Fund - Albert Einstein Research Fund. 2 Partially supported by the Technion V.P.R. Fund, New York Metropolitan Fund and the Japanese TS Research Fund. 3 Partially supported by Technion V.P.R. Fund.

2 1 1. Introduction A radio network is a network of processors which communicate using radio. An important feature of radio communication is that if a receiver is in the range of two or more transmitting stations then due to interferences some messages might not be received. A radio communication network is single-hop if all nodes are in transmission range of each other. Otherwise it is multi-hop. Thus, sending a message between two stations in a multi-hop network might involve transmissions through intermediate stations. Most real life radio networks for data communication are quite limited. In fact, most such networks are single-hop and most existing multi-hop networks resort to the tree topology. This situation looks rather odd considering the ease in which radio networks can be initiated and the flexibility and modularity of their operation. A new approach for controlling the activity in multi-hop radio networks was presented in the work of [3], where an efficient broadcast protocol is presented. Their method gives a new way of looking at radio networks. However, they do not provide protocols for many important network tasks. In the present work we use some of the ideas presented in [3], together with some new ideas to get very efficient protocols for two important and practical tasks. The tasks are k point-to-point transmission and k-broadcast. Point-to-point transmission is the task of sending a message from one station to another. Broadcast is a task initiated by a single station called the source, which transmits a message to all stations in the network. A k-point-to-point transmission (k-broadcast) is a task which consists of k point-to-point transmissions (k-broadcasts). Besides the theoretical interest, these tasks constitute a major part of real-life multi-hop radio network. 1.1 Model Description Our model consists of an undirected graph whose nodes represent stations (i.e., processors) and whose edges indicate possible communication, (i.e., an edge between two nodes implies that the corresponding processors are within range and within line of sight of each other). The processors have distinct IDs. Initially, each processor knows its local neighborhood (i.e. the identity of its neighbors) the size of the network, n, and an upper bound on the maximum degree of the network. It need not have any additional information of the topology of the network.

3 2 The processors may transmit and receive messages of length O (logn) and communicate in synchronous time-slots subject to the following rules. In each time-slot, each processor acts either as a transmitter or as a receiver. A processor acting as a receiver is said to receive a message in time-slot t if exactly one of its neighbors transmits in time-slot t. The message received is the one sent. Since communication is synchronous the only difficulty in routing messages, in this model, is the possibility of conflicts; that is, situations when several neighbors of a processor transmit simultaneously and it receives nothing. More specifically, we assume that there is no conflict detection, (see [4]). Throughout the paper, n denotes the actual number of processors, the maximum degree and D the diameter of the network. 1.2 Main Results Efficient protocols for k-point-to-point communication and k-broadcast are presented. Even though the protocols are probabilistic, it is shown how to acknowledge messages deterministically. Both protocols require a setup phase in which a BFS tree is constructed. This phase takes O ((n + Dlogn)log ) time. After the setup, k point-to-point transmissions require O ((k +D)log ) time on the average. Therefore the network allows a new transmission in every sequence of O (log ) time slots. Also, k broadcasts require an average of O ((k +D)log logn) time. Hence the average throughput of the network is a broadcast in every sequence of O (log logn) time slots. Both protocols pipeline the messages along the edges of a BFS tree. They are always successful on the graph spanned by this tree. Their probabilistic behavior refers only to the running time. The performance analysis of both protocols constitutes a new application of queueing theory. 1.3 Previous Work Chlamtac and Kutten [7] showed that, given a network and a designated source, finding an optimal broadcast schedule (i.e., broadcasting schedule which uses the minimum number of time-slots) is NP-Hard. They also routed messages through a (not necessarily BFS) tree, and discussed "implicit acknowledgements". Their acknowledgments are conducted in the absence of conflicts, which is achieved at the cost of increasing the time of a single point-to-point communication to O (D ). Chlamtac and Weinstein [8] presented a polynomial-time (centralized) algorithm for constructing a broadcast schedule which uses O (Dlog 2 n) time-slots. This centralized algorithm can be implemented in a

4 3 distributed system assuming the availability of special control channels, but the number of control messages sent may be quadratic in the number of nodes of the network [16]. In a different context, Y. Birk [2] independently discovered an acknowledgement mechanism similar to ours. Bar-Yehuda et al. [3] described a randomized single-source broadcast protocol. To ensure that with probability 1 ε all nodes receive the message the protocol requires O ((D + log ε n )log ) time slots. For D =2, they have also shown an Ω(n) lower bound for deterministic protocols. Thus, for this problem there exist randomized protocols that are much more efficient than any deterministic one. For D =2, Alon et al. [1] showed an Ω(log 2 n) lower bound, which matches the upper bound of [8] and [3]. In [4] Bar-Yehuda et al. discuss several models of radio communication and show how to detect conflicts and simulate a single hop network. Thus they show how to use protocols designed for the ETHER- NET in a multi-hop network [6, 1]. 1.4 Protocol Outline Both protocols depend on the existence of a BFS tree of the graph which is constructed in a setup phase. In the beginning of the setup part, a leader is chosen. Once the leader is chosen, it initiates the construction of a BFS tree whose root is the leader. For this purpose the protocols of [3] and [4] are used. The setup phase is conducted only once, after which any series of point-to-point transmissions or broadcasts might be performed. The broadcast process is reactive (continuous), it is invoked whenever a source originates a message to broadcast. It consists of two subprotocols: collection sending the messages from the sources to the root of the BFS tree and distribution sending the messages from the root to all the processors of the network. The point-to-point transmission is also reactive. It is invoked whenever a processor wishes to send a message. A message from node u to v travels first up the tree. Once the message reaches a common ancestor of u and v it continues downwards towards v. The protocols for both directions are very similar to the collection protocol and are fully described in Section 5. Since both protocols are reactive, it is not possible to wait until all the messages have finished to travel upwards, and only then start their journey downwards. Therefore, in both protocols the collection and

5 4 distribution subprotocols are conducted concurrently, either by using separate channels or by multiplexing: the odd time slots are dedicated to the upward traffic (collection) and the even ones to the downwards traffic. We shall not elaborate further and assume separate channels. All our protocols make use of a basic protocol, Decay [3] for passing messages from one layer to the next. In the sequel we use the term send whenever Decay is used. procedure Decay (m); repeat at most 2log times transmit m to all neighbors; flip coin R {0,1} until coin = 0. Decay is a probabilistic protocol, with the following properties: (1) It lasts 2log time slots. (2) If several neighbors of a node v use Decay to send messages then with probability greater than 1 2 the node v receives one of the messages. Several of our protocols require that all successfully sent messages be acknowledged. We show that though there is positive probability that a message is not received, every message that has actually been received is acknowledged with certainty. The overhead of the acknowledgement mechanism is minimal it slows down the protocol by a factor of 2. As a result the point to point transmission is always successful on the graph spanned by the BFS tree. 1.5 Organization Section 2 describes the setup phase. Since it relies on previous work we only show how to modify it for our needs. All the other results are entirely new. Section 3 describes the acknowledgement mechanism, Section 4 the collection protocol and its analysis, Section 5 the point-to-point transmission protocol and Section 6 the distribution protocol. An application, ranking, is described in Section 7. Concluding remarks appear in Section The Setup Phase Our protocols require the existence of a basic communication subnetwork. This network consists of a leader which is a root of a BFS tree. Bar-Yehuda et al. [4] described how to find a leader in O ((loglogn). (D + log ε n )log ) time.

6 5 In [3] Bar-Yehuda et al. describe how to find a BFS tree. Their algorithm assumes that all nodes wake up at time 0. It requires O (Dlog log ε n ) time slots and succeeds with probability 1 ε. Since we have assumed that all the IDs are distinct and n is known to all the nodes, the leader election and BFS can be modified so that they always succeed, only the running time is random: First, choose ε = 1/n, thus with probability 1 n 1 the leader election and the BFS protocol succeed. To ensure that the protocol always succeeds, when joining the tree each node sends a message to the root using the collection protocol of Section 4 below. This protocol only uses already constructed edges of the BFS tree, always succeeds and requires an average of O (nlog ) time slots to send all these messages. If the root does not receive all the messages by twice the expected time, the algorithm is aborted and the entire setup phase is reinvoked. Note that since all nodes know when the invocation should terminate, different invocations by the same processor cannot exist concurrently. Since the probability of reinvocation is less than 1 2, the entire modified setup protocol lasts O ((n +Dlogn)log ) time slots on the average Preventing collisions from different levels. An advantage of the BFS tree is that a collision at a node v at level i can occur only by messages sent from levels i 1, i and i +1. Collisions of messages sent from different levels are prevented by using time multiplexing: We require that a node at level i transmits a message at time slot t only if t i mod 3. This increases the duration of our protocols by a factor of 3. Henceforth, we assume that this mechanism has been built into all our protocols. 3. The Acknowledgement Protocol. The protocols of sections 4 and 5 use messages which are each designated to a single processor. These protocols require that every message be acknowledged. We now show how to conduct acknowledgements deterministically. The odd time slots are dedicated to the original protocol and the even ones to acknowledgements. Namely, every node that receives a message sends an acknowledgement on the next time slot. The next theorem shows the correctness of this protocol. The theorem depends on the fact that each message has a unique destination and that the destinations of different messages successfully received at the

7 6 same time slot are distinct. Theorem 3.1: Let v be a node that received a message from node u using the above protocol, then u receives an acknowledgement. Proof: Suppose that v received the message from u at time slot t and that u did not receive the acknowledgement. According to the protocol, v sent an acknowledgement at time slot t +1. Since u did not receive the acknowledgement there must have been a conflict at u. I.e., at time slot t +1 another node, v, connected to u also sent an acknowledgement (see Figure 1). According to the protocol, v would not send an acknowledgement unless it received a message designated to it at time slot t. However, since the message sent by u was designated to v v and v acknowledges only messages designated to it, v received its message from a node u u. Therefore, at time slot t both u and u sent messages, and since v is connected to both of them, a conflict occurred at v (at time slot t) and v did not successfully receive any message. This contradicts the assumption that v successfully received a message at time slot t. 4. Collection The purpose of the collection protocol is to send messages from the sources to the root of the BFS tree. Since no source knows the number and IDs of the other sources this is done concurrently and independently by all of them. Messages are sent, using Decay, via the BFS tree from BFS-children to their parents. To each message we append the ID of the node v which sent the message and the ID of v s BFS-parent. This information enables a node to figure out whether the message was sent by its BFS-child, by its BFS-parent or by another v u v Figure 1 u

8 7 node. The nodes will make use of this information and we shall omit the details of this The collection protocol Every node has a buffer of unacknowledged messages. Initially, all buffers except those of the sources are empty. The protocol proceeds in phases. In the odd time slots of each phase every node whose buffer is not empty executes Decay to send a message from its buffer to its BFS-parent. The even time slots are dedicated to acknowledgements as explained in Section 3. Every such message is resent until an acknowledgement is received. Whereupon, it is removed from the sender s buffer. When a message is received it is put on its receiver s buffer. Since the acknowledgement occurs immediately after sending, messages exist on exactly one buffer and proceed from child to parent Analysis of the collection protocol Transmission between adjacent levels We first estimate how fast messages move from level to level. Theorem 4.1 Let i 1 be a level containing messages at the beginning of a phase. There is probability µ def = e 1 (1 e 1 ) that during the phase a message from level i is successfully received by its BFS parent. Before sketching the proof, note the difference between this theorem and property (2) of Decay. Suppose node u is sending a message to its neighbor v and node u to its neighbor v. If u is connected also to v and u to v, then property (2) is satisfied even when v gets the message of u or v gets that of u. In contrast, here we insist that each message arrives at its correct destination. Proof sketch: A phase consists of a single invocation of Decay. At any given time, the nodes which still want to transmit are called live. At each time slot each live processor first transmits and then with probability 1 2 dies. Therefore, on the average, half of the live nodes die at each time slot. Let TRY i be the set of nodes of level i who are live at time t =0. Consider two cases: Case 1, TRY i : The analysis of Decay [3] implies that with probability 1 2 there exists a time slot with exactly one live processor u of TRY i. Hence, the BFS parent of u receives u s message.

9 8 Case 2, TRY i > : The probability that a node v TRY i is live at time t 0 = def log is 1/. The probability that TRY i contains a live node at time t 0 is 1 (1 1 ) TRY i 1 (1 1 ) 1 e 1. Let u be the first such node in some fixed arbitrary order, w its BFS-parent and S = {v TRY i (v,w) E} \ {u} (the transmitting neighbors of w not including u). If at time t 0, S contains no live nodes, then w receives u s message. The existence of a live node in S is independent of the behavior of u. The probability that at time t 0, S contains no live node is at least (1 1 ) S (1 1 ) 1 S /( 1). Since S 1 the above probability is e 1. Therefore, the probability of a successful transmission is Prob ( TRY i contains a live node at time t 0 ) Prob ( at time t 0 all nodes in S dead) (1 e 1 ) e Outline of the analysis. In the remainder of the section we shall show an upper bound on expected completion time of the collection protocol. We shall go through a series of models and show that when moving from one model to the next the expected completion time can only increase. In this subsection we describe the models, a formal proof follows in subsequent subsections. The first model is the previously discussed radio network which contains a BFS-tree of depth D and k messages arbitrarily placed on the nodes of the tree. In Theorem 4.1 we have shown that there is probability µ =e 1 (1 e 1 ) that among all the messages placed in the nodes of level i at least one moves to level i 1. The second model consists of a path of D +1 nodes. All the messages in the ith level of the previous model reside in node i of the path. The root of the tree is now node 0. We also stipulate that in a single step at most one message can move from node i to node i 1 and the probability for that is exactly µ. In the third model the messages are not already present in the system at time = 0, but their arrival is a Bernoulli event with parameter λ<µ, i.e., for every time t there is probability λ that a new message appears at node D. The last model we introduce (model 4) is identical to the third but we assume that it is already in steady state in the sense of Queueing Theory (see [14]) and we define the expected completion time to be the expected

10 '& (,! 9 time for k additional messages to arrive at node D and then proceed to the root (node 0) A tandem queue of Bernoulli servers. We now use Queueing Theory to analyze the performance of model 4: The model consists of D servers connected in series, with the output of the ith server being the input to the i 1st. We first analyze the behavior of a single level. A Bernoulli server with parameter µ is a discrete server (i.e., it operates in discrete time steps) such that if at any time step the queue of incoming customers is nonempty then with probability µ during that time step exactly one customer is served (removed from the incoming queue and placed on the outgoing queue). The arrival rate λ is the probability that a new customer (i.e., message) appears in the incoming queue during a phase. The departure process is the process by which customers are served by the server. Following Burke [B 56], Hsu and Burke [HB 76] analyzed the behavior of the departure process when λ < µ. Theorem 4.2: [HB 76] Consider the departure process of the above server (with λ < µ), i.e., let δ(t) = 1 if at time t a customer was processed, and δ(t) = 0 otherwise. Then δ converges to a Bernoulli process with parameter λ. and They also showed that the probability that at time t the length of the queue is j approaches a limit p j p 0 = 1 "#" λ, p µ 1 = $ $%$%$%$%$%$%$ λ p (1 λ)µ 0, p j = Thus the expected queue length is N-- = * + ) )%)%)%)%)%)%) λ(1 µ) µ(1 λ) j 1 p 1. Σ jp j =..%.%.%.%.%.%. λ(1 λ). By Little s result [K 75 p. 17], in steady state the j 0 µ λ (*) average time in the queue is, E (T) = λ N// /0/ = 1 1%1%1%1 1 λ. µ λ We now return to model 4, a steady state network of D Bernoulli processors connected in series each with parameter µ and the arrival rate to the Dth server is λ<µ. The major observation is that since the output of the ith server is the input to the i 1st, the input to all servers is Bernoulli with parameter λ. Using this observation we get the following theorem

11 : 2 10 Theorem 4.3 The expected completion time of model 4 is 343 k + 565%5%5%5 1 λ D. λ µ λ Proof: Suppose that at time t 0 the queueing system is in steady state and a message m 0 arrives. Let T denote the time the message spends in the queues. Consider the k messages m 1,..., m k preceding message m 0. Let X i denote the interarrival time between message m i and the next message, m i 1. Define Q k = T + X 1 + X X k. Q k is the time for k messages to pass through the queueing system of model 4. The expected time is E (Q k ) = E (T) + E (X 1 ) + E (X 2 ) E (X k ). The theorem follows from the fact that E (X i ) = λ and from the previous discussion which showed that E (T) = 868%8%8%8 1 λ :; D. 9 µ λ In Theorem 4.15 we shall show that the expected completion time of model 1 is less than or equal to that of model 4. Thus the performance of model 4 constitutes an upper bound for the radio network. Substituting λ = 1 <=<%<%< 1 µ satisfies λ<µ and yields that the expected number of phases required for k messages to reach the root is at most 2(1 + >?>%>%> 1 µ )µ 1 (k + D). Since each phase lasts twice the time of Decay and µ = e 1 (1 e 1 ), we get the following theorem Theorem 4.4 The expected number of time slots for k messages to reach the root is bounded by 32.27(k +D)log. This constant can be improved using the techniques of [11] The expected completion time of model 3 is not greater than model 4. The difference between model 3 and 4 is that model 3 stipulates that initially all queues are empty, whereas in model 4 the queue in each node has reached steady state, in particular there is nonnegative probability that the queues are not empty. In this subsection we prove the intuitively clear point that adding messages to the queues can only increase the expected completion time. Consider partitions of messages between the levels, i.e., (D +1)-vectors a = (a 1,..., a D +1 ) such that a i 0. A move vector is a (D +1)-vector of nonnegative integers, m = (m 1,..., m D +1 ). Partition

12 @ 11 a = Move(a,m) is obtained by moving m i messages from level i to level i 1, (if m i > a i then only a i messages are moved). Formally, the number of messages moved from level i is δ i = min(a i,m i ), i =1,..., D, δ D +1 = m D +1. Therefore, a i = a i δ i + δ i +1. A move sequence is an infinite series M = (m 1,m 2,... ) of move vectors. Move * (a,m, t) is the result of making t moves according to M, i.e., Move * (a,m, 0) Move * (a,m, t +1) = a = Move(Move * (a,m, t),m t +1 ). Define a partial order between partitions, such that a b if and only if there exists a move sequence M and an integer t such that a = Move * (b,m, t). (Also, a<b if a b and a b.) A move vector m is a singleton if exactly one of its components is 1 and all the other components are zero; the singleton whose i-th component is 1 is denoted e i. The following lemma shows that we can simulate any move vector by a move sequence of lexicographically nonincreasing singletons. Lemma 4.5: For every move vector m there is a singleton move sequence E m such that for every a, Move (a,m) = Move * (a,e m, Σ D m i ). i =1 Proof: Let E m = (e m 1,e m 2,... ) such that e m t = e j, where j is the first nonzero component of m t 1 t Σ 1 em. i =1 BC BA Corollary 4.6: a b if and only if there exist an integer t and a move sequence E consisting only of singletons such that a = Move * (b,e, t). Lemma 4.7: If a b then for any move vector m, Move(a,m) Move(b,m). Proof: Lemma 4.5 and Corollary 4.6 imply that it suffices to prove the lemma for m = e j and a=move(b,e i ). If i j +1 then Move(a,e j ) = Move(Move(b,e i ),e j ) = Move((b,e j ),e i ), implying Move(a,e j ) Move(b,e j ). Also if b i =0 then a=b. Thus we assume that i =j +1 and b i >0. If b j =0 then b = Move (b,e j ) and Move(a,e j ) = Move(Move(b,e j +1 ),e j ). From the definition of, Move(Move(b,e j +1 ),e j ) b = Move(b,e j ). Otherwise (b j 0), Move(a,e j ) = Move(Move(b,e j +1 ),e j ) = Move (Move (b,e j ),e j +1 ) Move (b,e j ). EF ED

13 d G d 12 The completion time of a partition a w.r.t. a move sequence M is T (a,m) = min{t : Move (a,m, t) = (0,0,..., 0)}. (For some M s the completion time may be infinite.) Lemma 4.8: If a b then for all M, T(a,M) T(b,M). Proof: Let b be the least partition for which there exists a move sequence M and a partition a such that a<b while T (a,m)>t (b,m). Let M satisfy, T (b,m ) = Min{T (b,m) : T (b,m) < T (b,m)}. Let M = (m 1,m 2,... ). The minimalilty of M implies that Move(b,m 1 ) < b. Define M =(m 1,m 2,... ). By Lemma 4.7 Move (a,m 1 ) Move (b,m 1 ), thus by the minimality of b, T (Move (a,m 1 ),M ) T (Move (b,m 1 ),M ). Hence, T(a,M ) 1 + T (Move (a,m 1 ),M ) 1 + T (Move (b,m 1 ),M ) = T(b,M ). Consider an arbitrary probability distribution on the move sequences. In a tandem queue of Bernoulli servers with parameter µ and arrival rate λ, P(m t t i =1) = µ, i =1,..., D and P(m D +1 =1) = λ. Let p t (a) be the probability that T (a,m) = t. The average completion time is E (T(a)) = Σ tp t (a) = t =1 Σ Σ p j (a). t =1j =t Lemma 4.9 a b implies that E (T (a)) E (T (b)). Proof: Let a b. Thus by Lemma 4.8, {M : T(a,M) t} {M : T(b,M) t}. Taking probabilities P({M : T(a,M) t}) P({M : T(b,M) t}). In other words, Σ t p j (a) Σ t p j (b). j =0 j =0 The last condition defines that T (a) is stochastically greater than T(b) [15]. In this case,

14 I H 13 E(T(a)) = Σ Σ p j (a) Σ Σ p j (b) = E (T (b)). t =1j =t t =1j =t Lemma 4.10 The expected completion time of model 3 is less than or equal to that of model 4. Proof: In model 4 the expected completion time depends both on the distribution of the initial partition and on the move sequences. Let a=(a 1,..., a D,a D +1 ) be an initial partition. a 1,..., a D are the lengths of the queues at the nodes, while a D +1 = k since the completion time of model 4 is the time k additional messages appear at node D and reach the root. In model 3 the initial partition is k = (0,0,..., 0,k). k a since for M = ((a 1,..., a D,0), (a 2,..., a D,0, 0),..., (a D,0,..., 0), (0,..., 0),...), k = Move * (a,m,d). By Lemma 4.9, E(T (k)) E(T (a)). Our result follows since this holds for every initial partition of model 4. KL KJ The expected completion time of model 2 is not greater than model 3. Lemma 4.11 The expected completion time of model 2 is less than or equal to that of model 3. Proof: In model 3 the initial partition is k = (0,0,..., 0,k), while in model 2 it is b = (b 1,..., b D,0), such that k = Σ b i. Obviously, b k, so the result follows, as before from Lemma 4.9. NO NM The expected completion time of model 2 is not smaller than model 1. The difference between model 1 and 2 is in the move vectors. In model 2, m i t {0,1} and P (m t t i = 0) = 1 µ, while in model 1, m i can assume any nonnegative integer value and P (m t i = 0) = 1 µ. The actual movements of the messages depend on the topology. To prove that the expected completion time of model 2 is not greater than that of model 1 we need to consider the effect of changing the move vectors. A move vector m = (m 1,m 2,..., m D +1 ) dominates the move vector m = (m 0,m 2,..., m D +1 ) if for all i, m i m i.

15 Q P 14 Lemma 4.12: If m dominates m and a b then Move (a,m) Move(b,m ). Proof: Let E m and E m be the singleton move sequences corresponding to m and m (Lemma 4.5). Let t and t be the respective lengths. Since E m is a subsequence of E m, by repeated use of Lemma 4.7 we can show that Move * (a,e m,t) Move * (a,e m,t ). Thus, by Lemma 4.5, Move(a,m) = Move * (a,e m,t) Move * (a,e m,t ) By Lemma 4.7, Move * (b,e m,t ) = Move(b,m ). A move sequence M(m 1,m 2,... ) dominates M (m 1,m 2,... ) if for all j, m j dominates m j. Lemma 4.13: If M dominates M and a b then T(a,M) T (b,m ). ST Proof: By induction on T (a,m) and using lemma SR Lemma 4.14: The expected completion time of model 1 is less than or equal to that of model 2. Proof: Consider an instance a 1,a 2,..., a T of model 1, i.e., the completion time is T and a i t is the number of messages at level i at time t T. Define the move sequence M = (m 1,m 2,... ) as follows: m i t is the number of messages that moved from level i to level i 1 at time t. When a i t > 0 then by Theorem 4.1, P (m i t 1) µ. However, when a i t = 0 then m i t = 0, so obviously, P (m i t 1) = 0, violating the probabilistic assumptions of model 2. We therefore define the move sequence U?U M = (m VWV 1,m X X 2,... ): if a t t i > 0 then myy i = t mi, otherwise (a t t t \?\ i = 0), mz Z i = 1. By Theorem 4.1 and the construction P (m[[ i 1) µ. Since M and M differ only when a i t = 0, for every t T, Move * (a,m, t) = Move * (a,m]=],t). Thus the completion times T (a,m^?^ ) = T(a,M) = T. Construct a move sequence M = (m i,..., m T,... t t t ): (m i {0,1}). If m i 1 then m i = 1 with probabil- P (m t i 1) µ t ity ` `%`%`%`%`%`%`%`%`%`%` P (m t, otherwise m i i 1) less than or equal to that of M. = 0. Since a=a M dominates M, by Lemma 4.13, the completion time of b=b M is By the construction of M,

16 c 15 t t t t P (m i = 0) = P (md d i = 0) + P (me e i > 0 and m i = 0) t t t = P (mf f i = 0) + P (mg g i > 0) jkj%j%j%j%j%j%j%j%j%j%j P (mi i i > 0) µ t P (mhh i > 0) t t = (1 P (ml l i > 0)) + (P (mm m i > 0) µ) = 1 µ. Thus, the distribution of M is identical to the distribution of the move sequences of model 2. The required result follows by taking expectations. op on We summarize the above reductions with the following theorem Theorem 4.15: The expected completion time of model 1 is less than or equal to that of model Point to Point Transmission As mentioned before, this protocol consists of two subprotocols: the upward direction subprotocol from the initiator of the message u to a common ancestor w of u and the destination v and the downward direction subprotocol from w to v. However, in order to conduct these protocols, the network should first execute a preparation protocol. This protocol is executed only once. 5.1 Preparation This protocol is executed during the set up phase (Section 2) before starting any point to point transmission. In Section 2 we described how the BFS tree is constructed, here we describe how additional information, the BFS parent, the BFS descendants and on which subtree each descendant belongs, is conveyed to each node. The BFS protocol of Section 2 enables each node to know the ID of its BFS parent, and its depth (distance from the root). The descendant information can be found once the BFS tree is constructed: As soon as a node joins the BFS tree, it sends its ID to the root via all its ancestors. During the BFS protocol, each node can record its parent, thus, to send a message to the root, it is sufficient to send it to that parent and ask it to send the message further. Whenever a node receives such a message from one of its children, it adds the ID of the originator of the message to the list of IDs of descendants. Conveying all the descendant information requires the collection of n 1 messages, i.e., O ((n 1+D)log ) = O (nlogn) time. To record all this information each node must have sufficient storage to keep O (n) IDs. To save space (and time) we propose the following scheme [13]: After the BFS tree is completed, a depth-first-search (DFS) is conducted on the BFS tree. Henceforth, each node uses its DFS number as its

17 q 16 address. Since the DFS numbers of the descendants of a node constitute a consecutive range, it suffices that each node remember the DFS number of each of its children and the maximum DFS number of all the descendants. Thus, each node v needs only O (deg (v)logn) bits of local memory. Using a token, DFS can be implemented in O (n) time: First the token conducts a DFS of the graph, each node sends the token to the largest neighbor not yet in the DFS tree and when all the neighbors are exhausted it is sent to the parent. Whenever a node sends the token it broadcasts its own ID together with the ID of its BFS-parent. Thus all the neighbors of a node know when the node joins the DFS-tree, and the token is not sent to nodes already in the tree (except when the DFS backtracks from a child to its parent). There are no conflicts, since only the node holding the token can transmit, also the entire traversal requires 2n 2 time, since the token traverses once in each direction of each tree-edge. After the first DFS is completed, each node knows the parents of all its neighbors, in particular it knows which of its neighbors are its BFS-children. Thus we can conduct a second DFS traversal this time on the BFS tree. This traversal also costs O (n) and after it is completed each node knows the DFS-number of all its BFS-children and its maximum descendant. Note that we required that each node knows the IDs of all its neighbors only in order to conduct the first DFS-traversal The upward subprotocol This protocol is essentially identical to the collection protocol, except that messages do not go all the way to the root but only to the least common ancestor of the originator and the destination which are included in the message. When the message reaches a BFS tree ancestor of the destination, the downward protocol is invoked The downward subprotocol This protocol is also very similar to the collection protocol. The messages are prepended with the ID of their final destination. Every node sends messages designated to its BFS children and keeps a buffer of unacknowledged downgoing messages. Here we also use Decay. On each phase a message is sent, according to that protocol. Messages are resent until an acknowledgement is received. A node w receiving a message designated to u processes it only if u is a BFS-tree descendant of w. To process a message, w acknowledges it and if w u it is put on w s downgoing buffer.

18 r Performance analysis The setup phase requires O (n + Dlog ) time after which passing k messages requires an average of O ((k +D)log time. When k the average time per message is O (log ). 6. Broadcast To broadcast a message a node first sends the message to the root using the collection subprotocol of Section 4. Then the message is sent to all the nodes of the network using the distribution subprotocol to be described below. In the distribution protocol every message has several destinations, therefore, the acknowledgement mechanism of Section 3 can no longer be used. In principle the message can be sent using the BFS protocol. However, each message would require 2Dlog logn time to reach all the nodes with probability 1 ε. A better idea is to use pipelining: Send the i +1-st message before the i-th one reaches its destination. The protocol consists of superphases each consisting of 4log logn time slots (we allow an error of ε=1/n 2 ). At superphase t the root sends the tth message and all the nodes of level i repeatedly send the t ith message (using the Decay protocol 2logn times). Let v be a node of level i and t a superphase in which the nodes of level i 1 send the message m. By property (2) of Decay, in each invocation of Decay, there is probability 1 2 that v receives a message. Since there can be no interference by messages sent from different levels (Section 2.2), if v receives any message it must be from level i 1 and since all the nodes of that level send the same message, with probability 1 2 v receives the message m. Since a superphase consists of 2logn invocations of Decay there is probability 1 1/n 2 that v receives m during the superphase. The probability, that m is passed successfully to all the nodes of the network is 1 1/n. For each message the above protocol may fail with finite probability. If the number of messages is unbounded then eventually the protocol will fail. This failure can be prevented by changing the protocol as follows: The root appends consecutive numbers to the messages. Every node v examines these numbers and when v encounters a gap it realizes that it did not receive a message. Thereupon, v sends a message to the root requesting it to resend the missing message.

19 s 18 a factor of Since on the average no more than 1/n of the messages will be resent, the extra load on the network is Σ t t%t 1 i =0 n i = uu%u%u%u n. Moreover, the time spent in each layer is O (log logn), thus the effective rate in n 1 which messages leave the root is O ( vv%v%v%v n log logn) = O (log logn). Also, each message requires an aver- n 1 age of O (Dlog logn) time slots to reach all the nodes. The previous change causes another problem, the message numbers are unbounded. An additional change can correct this problem. The messages are numbered mod 3n 2. After message number n 2 is received each node sends an acknowledgement to the root. The expected time that all these messages reach the root is O ((n +D)log ). Thus the expected time that all the acknowledgements reach the root is O ((Dlogn+n)log ). Let c be the implied constant in the above expression. If the root does not receive acknowledgements from all the nodes by 2c(Dlogn+n)log ) time slots after it sent the n 2 th message it resends the last n 2 messages. It can be shown that the probability that the n 2 th message has to be resent is less than 1 2, thus this last correction increases the load of the system by at most a factor of Ranking Our protocols can be used for additional problems, such as ranking in expected time O (nlognlog ): The problem Given n processors with distinct IDs id 1,..., id n, renumber the processors, id 1,..., id n such that 1 id i n and id i <id j if and only if id i <id j. The protocol Use point-to-point communication to send all the IDs to the root. It calculates the destination of each of the new IDs and sends them to the nodes. There is a total of 2n 2 messages, which require O (nlog ) time (not including the setup costs of Section 2). 8. Remarks and Open Problems (1) If n is not known but only an upper bound N, we can still find a BFS tree with probability 1 ε in expected time O (Dlog ε N w0w log ). This setup time is sufficient for k-broadcast. However, point-to-point transmissions still require O (n + Dlog ε N x0x log ) time to acquire the descendant information.

20 y 19 (2) If there are no IDs then the processors can randomly choose sufficiently long IDs such that with probability 1 ε all the IDs are distinct. (3) Suppose that we change the model such that in case of a conflict the receiver may get one of the messages. In this model our deterministic acknowledgement mechanism is no longer valid. A more complicated, less reliable and slower protocol exists also for this case. (4) In some "real life" situations processors can detect that a conflict occurred. We have not postulated this ability since we do not know how to use it. (5) Our protocols route messages through a spanning tree causing congestion at the root. Are there efficient communication protocols that avoid this problem? ACKNOWLEDGEMENTS It is a pleasure to thank Shay Kutten and Moshe Sidi for helpful discussions and an anonymous referee for suggesting using DFS numbers to improve the memory requirements.

21 z 20 REFERENCES [1] Alon N., Bar-Noy A., Linial N. and Peleg D., "A lower bound for radio broadcast", to appear in J. Computer and System Science, also in STOC [2] Birk Y., "Concurrent communication among multi-transceiver stations over shared media" Ph.D. Thesis, Tech. report CSL-TR , Stanford University, Stanford, CA. [3] Bar-Yehuda R., Goldreich O. and Itai A., "On the time-complexity of Broadcast in Radio Networks: An Exponential Gap Between Determinism and Randomization", to appear in J. Computer and System Science, also in PODC [4] Bar-Yehuda R., Goldreich O. and Itai A., Efficient Emulation of Single-Hop Radio Network with Collision Detection on Multi-Hop Radio Network with no Collision Detection, Distributed Computing, Vol. 5, 1991, pp [5] Burke, P.J. "The Output of a Queuing System", Operations Research, 4, (1956). [6] Capetanakis, J., "Generalized TDMA: The multi-accessing tree protocol", IEEE Trans. Commun., Vol. COM-27, , (1979). [7] Chlamtac, I. and Kutten, S., "On Broadcasting in Radio Networks- Problem Analysis and Protocol Design", IEEE Transactions on Communications, December (1985), Vol COM-33, No. 12. [8] Chlamtac, I. and Weinstein O., "The wave expansion approach to broadcasting in multi-hop radio networks", INFOCOM, , (April 1987). [9] Digital-Intel-Xerox, "The Ethernet data link layer and physical layer specification 1.0" (Sept. 1980). [1] Gallager, R., "A perspective on multiaccess channels", IEEE Trans. on Inf. Theory, Vol. IT-31 (1985), [11] Hofri, M., "A Feedback-less Distributed Broadcast Algorithm for Multihop Radio Networks with Time-varying Structure", 2nd ACM Intr. MCPR Workshop, Rome (May 1987). Also available as TR-451, Computer Science Dept., Technion, Haifa, Israel (March 1987). [12] Hsu and P.J. Burke, "Behavior of Tandem Buffers with Geometric Input and Markovian Output", IEEE Trans. on Comm., COM-24, , (1976). [13] Itai, A. and Rodeh, M., The Multi-Tree Approach to Reliability in Distributed Systems, Proceedings of the 25 Symposium on Foundations of Computer Science, , (Oct. 1984). Also in Information and Computation, vol. 79(1), 43-59, (Oct 1988). [14] L. Kleinrock, Queueing Systems, Volume 1: Theory, John Wiley and Sons, (1975). [15] Stoyan, D., Comparison Method for Queues and other Stochastic Models, J. Wiley & Sons, [16] Weinstein O., "The wave expansion approach to broadcasting in multihop radio networks", M.Sc. Thesis, Computer Science Dept., Technion, Haifa, Israel, (1987).

22 { 21 [17] Willard D.E., "Log-logarithmic selection resolution protocols in a multiple access channel", SIAM J. on Comput. 15(2), , (1986).