chapter 3 broadcast and convergecast l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 3: Broadcast and Convergecast PowerPoint Presentation
Download Presentation
Chapter 3: Broadcast and Convergecast

Loading in 2 Seconds...

play fullscreen
1 / 7

Chapter 3: Broadcast and Convergecast - PowerPoint PPT Presentation


  • 135 Views
  • Uploaded on

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

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

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
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);
slide2
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
slide3
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
slide4
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;
slide5
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
slide6
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)
slide7
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