Chapter 3: Broadcast and Convergecast

1. Chapter 3: Broadcast and Convergecast • Broadcast Operation • fundamental to distributive computing • used extensively • basic definition: • broadcast (from single source) – initiated by a single source processor, p; p has a message which needs to reach all vertices in the network • broadcasting lower bounds (for an n-vertex network G): • message complexity >= n-1 since at least one message will arrive at all vertices (except the initiator, p); • time complexity >= rad(p,G) since we need to reach the farthest destination (which is a distance of rad(p,G);

2. Tree Broadcast - broadcasting via a spanning tree on the network • spanning tree assumed given • if not, one can be constructed using any broadcast algorithm: • define broadcast source as root • parent of a vertex is the neighbor from which it receives a message first • message complexity = n-1 • time complexity = depth(tree) • some trees have a depth larger than the network diameter, so use a breadth first search tree: • a spanning tree such that for each vertex v, the path from v to the root is the minimum length possible • message complexity = same as spanning tree • time complexity <= diam(G) since the depth is now at most equal to the network’s diameter

3. Flooding algorithm – assuming no other network structures, forward the message over all links • algorithm • source vertex – send the message to all neighbors • other vertices – if vertex v receives its first message from vertex u, then send the message to all neighbors except u; otherwise do nothing; • message complexity = Θ(|edges|) since each edge delivers the message either once or twice • time complexity = Θ(rad(p,G)) since we must reach all vertices • in the synchronous model, the spanning tree created by the flood algorithm is a breadth first search tree with depth rad(p,G) • the asynchronous model may have depth up to n-1

4. Convergecast – collecting information “upwards” from the spanning tree after a broadcast • algorithm • after receipt of the message at vertex v: • if v is a leaf then it forwards “ack” to its parent; • otherwise, v must collect “ack” messages from all children before sending “ack” to its parent • message complexity = n-1 • time complexity <= depth(tree) • adding convergecast to broadcast will achieve “broadcast with echo” and only increase broadcast’s time/message complexities by a constant factor • for flooding algorithm • since flooding constructs a spanning tree, use the tree for convergecast • can add convergecast by having each vertex v send “ack” to its parent only after v’s subtree has been constructed and v’s children have received the message;

5. complexities (for flooding with convergecast) • message complexity = Ο(|edges|) • time complexity = O(diameter) for synchronous and O(n) for asynchronous • Global function computation • each vertex v holds an input Xv and we wish to compute global function f(Xv1,…,Xvn) using these inputs • a function f is a semigroup function if • f(Y) is defined for any subset Y of X = {Xv1,…,Xvn} • f is associative and commutative • f(X)’s representation is “relatively short” with respect to that of the inputs • converge procedure – compute f using the convergecast process • instead of “ack” send f(Yv) where Yv are the X values of vertex v’s children

6. if f(X) can be represented in O(p) bits (for a subset Y of X), then complexities for converge(f,X) are • message complexity = O(np/logn) • time complexity = O(depth(tree) * p/logn) • f is globally sensitive if for each input X and each vertex v, changing Xv causes a change in f(X) • for any such function f, the computation of f on a tree has: • message complexity = Ω(n) • time complexity = Ω(depth(tree)) • Pipelined broadcasts and convergecasts • vertices store data of different types • wish to perform separate convergecasts on each type of data • computing a result at each vertex (sequentially on k data elements) then computing at the next-highest vertex in the tree results in a time complexity of O(k * depth(tree)

7. pipeline the computations instead • each vertex v sends the result of the computation on each data element • if the data set is 1 <= i <= k then for each i, we compute a result at v and then send it to v’s parent; as opposed to computing all k elements and then sending • time complexity = depth(tree) + k • synchronous: because each v consecutively sends to its parents • asynchronous: because the values arrive in first-in-first-out order; thus each vertex can match the values of the ith type when it receives them from its children