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);
1
• 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
2
• 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
3
• 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;
4
• 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
5
• 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)
6
– 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
7