Downcasts and Upcasts

1
Chapter 4

• Downcasts and Upcasts

2
4.1 Downcasts

• At first we assume the case where the root has m
  distinct items A m1, , mm, each destined to
  one specific vertex in the tree.
• Lemma 4.1.1
• Downcasting m distinct messages on T requires W
  (Depth(T)) time in the worst cast for every tree
  T.
• Downcasting m distinct messages on arbitrary tree
  requires W(m) time in the worst case.
• To each children of the root simply sends the
  messages destined to the subtree by one on the
  edge in arbitrary order.
• And the intermediate vertex in the tree receives
  at most one message at each step and passes it
  on.
• Lemma 4.1.2
• Algorithm DOWNCAST performs downcasting of m
  distinct messages on the tree T in time
  O(mDepth(T)).
• Proof is in page 41

3
4.2 Upcasts

• We suppose that m data items A m1, , mm are
  initially stored at some of the vertices of the
  tree T. Items can be replicated, namely, each
  item is stored in one or more vertices.
• Lemma 4.2.1
• For every tree T, upcasting m distinct messages
  on T requires W (Depth(T)) time in the worst
  cast.
• Upcasting m distinct messages on arbitrary tree
  requires W(m) time in the worst case.
• The upcasting is not the simple convergecast
  process of downcasting, since the items are sent
  up to the root individually. In the upcast
  operation the different messages converge to a
  single spot on the tree, hence they tend to
  disrupt each other more and more.
• Though at last we know the result that upcast
  operation can be performed in time m Depth(T) ,
  the algorithms of it are totally difference from
  downcast operation.
• Simply rolling the execution tape backwards
  will give us a feasible schedule for the upcast
  operation
• We give out three possible settings of
  assumptions regarding the given items.

4
4.2.1 Ranked items

• The first assumptions is the items are taken from
  an ordered set, and each item is marked by its
  rank in the set. (the items are given in the form
  of pairs (i, m) such that mi ? mi1 for 1 ? i ?
  m).
• Algorithm RANKED_UPCAST
• Lemma 4.2.2
• If the ith item is Mv, then at the end of round
  it is stored at v.
• This immediately guarantees that by time Depth(T)
  m, all items are collected at the root.
• Corollary 4.2.3
• Upcast of m ranked items on a tree T can be
  performed in time Depth(T) m.

5
4.2.2 Ordered items

• The second assumptions is the slightly more
  general case where the items are taken from an
  ordered set, but their ranks are not marked.
• It is impossible to tell the position of a
  particular item in the complete list by
  inspecting the item and it is possible to compare
  them and decide which is the larger of the two.
• Algorithm ORDERED_UPCAST
• In this situation, we still can prove Lemma
  4.2.2.
• Corollary 4.2.4
• Upcast of m ordered items on a tree T can be
  performed in time Depth(T) m.

6
4.2.3 Unrdered items

• The third assumptions is the case where the items
  are entirely incomparable. It is the most
  general case.
• Algorithm UNORDERED_UPCAST
• In this setting, Lemma 4.2.2 no longer holds. We
  need the following claim.
• Lemma 4.2.5 (proof is in page 44)
• Consider a vertex v and an integer t. Suppose
  that for every 1 ? i ? k, at the end of round
  tI, v stored at least I items. Then at the end
  of round tk1, vs parent w has received from v
  at least k items.
• Lemma 4.2.6 (proof is in page 44)
• For ever 1 ? I ? Mv, at the end of round
  , at least i items are stored at v.
• Corollary 4.2.7
• Upcast of m unordered items on a tree t can be
  performed in time Depth(T) m.

7
4.3 Applications
4.3.1 Smallest k-of-m

• The traditional way to do this is, first, find
  the minimum element and inform all the vertices
  by broadcasting it throughout the tree. Then
  find the next smallest element by the same method
  and so on. The should take O(kDepth(T)) time.
• An alternative and faster method would be the
  following. At any given moment along the
  execution, every vertex keeps the elements it
  knows of in an ordered list. In each step, each
  vertex sends to its parent the smallest element
  that hasnt been sent yet.
• Lemma 4.3.1
• Upcasting the k smallest elements on a tree T can
  be performed in Depth(T) k time.

8
4.3.2 Information gathering and dissemination

• Suppose that m data items are initially stored at
  some of the vertices of the tree T. Items can be
  replicated, namely, each item is stored in one or
  more vertices.
• The goal is to end up with each vertex knowing
  all the items.
• The natural way is to collect the items at the
  root of the tree and then broadcast them one by
  one.
• We can do upcast operation to collecting the
  information and downcast operation to broadcast
  the information to every leaves.
• Hence the total time should be O(mDepth(T)).

9
4.3.3 Route-disjoint matching

• Suppose we are given a network in the form of a
  rooted tree T (with each vertex knowing the edge
  leading to its parent and the edges leading to
  its children in T)
• A set of 2k vertices Ww1, , w2k for k ? ?n/2?
  is initially marked in the tree.
• Our goal is to find a matching of these vertices
  into pairs (wi1, wi2) for 1? i ? k, such that the
  unique routes Yi connecting wi1, to wi2 in T are
  all edge-disjoint.
• Lemma 4.3.2
• For every tree T and for every set W as above,
  there exists an edge-disjoint matching as
  required.
• Furthermore, this matching can be found by a
  distributed algorithm on T in time O(Depth(T)).

10
4.3.4 Token distribution

• n token are initially distributed among the n
  vertices of the tree with no more than K at each
  site
• The goal is redistributing the tokens so that
  each processor will have exactly one token.
• The cost of the entire redistribution process
  equals the sum of the distances traversed by the
  tokens in their way to their destinations.
• P ?u?ro pu, where su is the number of tokens
  in the subtree Tu, nu is the number of vertices
  in the subtree Tu, pu su nu is the number of
  token that need to be transferred out of Tu
• Lemma 4.3.3
• There exists a distributed algorithm for
  performing token distribution on a tree using an
  optimal number of messages P and O(n) time, after
  a preprocessing stage requiring O(Depth(T)) time
  and O(n) messages.