Chapter 3: Broadcast and Convergecast

1 / 7

# Chapter 3: Broadcast and Convergecast - PowerPoint PPT Presentation

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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Chapter 3: Broadcast and Convergecast' - martina

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Chapter 3: Broadcast and Convergecast
• 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);
• 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
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
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;
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
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)
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