A basic algorithm for

1
A basic algorithm for constructing network
partitions
2

• Introduction
• In this chapter we will describe a simple
  distributed implementation for Algorithm
  Basic_Part presented in section 11.5 for
  constructing sparse partition of a given
  unweighted graph
• G (V,E).
• This will serve as an illustration for the basic
  distributed techniques discussed so far and as
  an illustration to the topic of efficient
  distributed construction methods for covers,
  partitions and decompositions, which will be
  discussed later.
• Also we will illustrate the potential
  applicability of locality-preserving graph
  representations in the area of distributed
  network algorithms.

3

• The overall structure of the algorithm
• This Algorithm is called DIST_PART and it follows
  the Algorithm BASIC_PART presented in
  section11.5.
• This Algorithm is based on a single thread of
  computation in which at any given time there is a
  single vertex serving as the locus of activity
  and running the execution.
• This is true only in high level flow of the
  Algorithm,but in the lower level, there are
  various components of the construction that are
  performed in a truly distributed manner, so it is
  accurate to say that at any given time in the
  execution, all vertices actively participating at
  that moment are with in a distance of 2? 2of
  each other, where ? is the parameter governing
  the cluster growth rate in the Algorithm.
• The distributed applications of sparse partitions
  requires having a partition and an explicitly
  marked intercluster edge between any two adjacent
  clusters, so in this chapter we well select such
  representative intercluster edges.
• This selection is done truly in a distributed
  fashion.

4

• The Algorithm DIST_PART
• Here is the Algorithm of DIST_PART
• A procedure CLUSTER_CONS for constructing a
  cluster around a chosen center ?.
• A procedure NEXT_CTR for selecting the next
  center ? around which to grow a cluster
• A procedure REP_EDGE for selecting a
  representative intercluster edge between any two
  adjacent clusters.

5

• The cluster construction procedure CLUSTER_CONS
• We invoke this procedure at the center ? which
  will simultaneously construct both the cluster
  and a BFS tree at ? spanning it.
• This is done by employing a variant of Algorithm
  DIST_DIJK described in section 5.2.This
  algorithm is based on growing the cluster and the
  tree iteratively adding a new layer each
  iteration.But we need to do two main changes to
  that algorithm
• 1-In the global BFS algorithm the exploration
  message are sent by each vertex to all its
  neighbors except those known to belong to the
  tree.In our procedure CLUSTER_CONS there are
  additional vertices to be ignored, namely, all
  those known to belong to previously constructed
  clusters.
• 2-Here in our procedure, the BFS is grown only
  to a limited depth, which is the result of
  growing the new layers tentatively, based on the
  condition specified in the procedure itself.
• This is performed as follows.Before we decide to
  expand the tree by adding new layer, we first
  perform a count of the number of new vertices in
  that layer, which is done by convergecast
  process, invoking the procedure
  CONVERGE(S,?,Leaves).

6

• The cluster construction procedure CLUSTER_CONS
  continue
• This CONVERGE(S,?,Leaves) Procedure works as
  follows
• Each leaf w sets ?w to number of the new children
  attached to it in the new layer, and these
  numbers are added up and passed on by
  intermediate tree vertices.The root ? can then
  compare the final count ? ? with the total number
  of vertices already in the tree known to it from
  the previous phase and compare the ration of
  these two numbers.
• If the ratio is greater than n 1/? , then ?
  broadcasts the next Pulse message, which confirms
  the addition of the new layer and starts the next
  phase.Otherwise the root broadcasts a message
  Reject, indicating the rejection of the new layer
  and the completion of the current cluster.
• In the final broadcast, the cluster is marked
  with a unique name in which all the vertices will
  be informed of.This information will be used to
  define the borders of the cluster .

7

• The next center selection procedure NEXT_CTR
• The center of activity in the algorithm is
  always located at the currently constructed
  cluster, so it is a good idea is to choose a
  vertex adjacent to the cluster, namely one of the
  vertices in the rejected layer, as the center of
  the next cluster.
• Again, the choice can be made through a
  convergence process, invoking Procedure
  CONVERGENCE(Arb,Y,Leave), in which each leaf w
  sets Yw to an arbitrary neighbor from the
  rejected layer and Arb is a function selecting
  one of its arguments arbitrarily.
• There is a disadvantage in this approach which is
  that it does not necessarily specify what to do
  if the next layer turns out to be empty, since if
  it is empty then that does not signify the
  completion of the entire process, as it may be
  that some yet unclustered vertices still exit
  elsewhere in the graph.Because of this problem
  its necessary to search throughout the graph and
  verify that thee are no forgotten unclustered
  vertices.For this purpose, the previous Procedure
  CLUSTER_CONS, must be used within a global search
  procedure, namely,Algorithm DIST_DFS of section
  5.4.

8

• The next center selection procedure
  NEXT_CTR(cont)
• The DFS process progresses on the tree of
  constructed cluster. It starts at some originator
  vertex r0 and employs the cluster construction
  procedure CLUSTER_CONS to construct the first
  cluster.
• When ever the rejected layer of a constructed
  cluster is not empty, the algorithm chooses one
  of the vertices in that layer as the center for
  the next cluster.
• Each center of the new cluster remembers the
  previous cluster which it was selected from,as
  its parent in the cluster DFS tree.
• If the search can not progress forward from some
  cluster due to an empty next layer, the DFS
  posses backtracks from the current cluster to the
  previous one and tries to find an available
  center among its neighboring vertices.If no
  neighbors are available, the process backtracks
  in the usual DFS fashion on the cluster DFS tree.
• This process continues until it backs up all the
  way up to the originating vertex r0 and can no
  longer continue to new unclustered vertices.
• In the previous process , it might happen that
  the DFS process visits a certain cluster C more
  than once and each time it visits C the search
  for a new potential center must be conducted
  again.

9

• The intercluster edge selection procedure
• REP_EDGE
• In this procedure, we need to select one
  representative intercluster edge between every
  two adjacent clusters.
• Let E(C,C) be the set of edges connecting two
  clusters C and C.
• These edges are known to their endpoints in C
  since all the nodes in C knows the
  cluster-residence of each of their
  neighbors.Therefore we can select the
  representative edge from the set of edges E(C,C)
  by the convergecast process.
• In order to make sure that both C and C will
  select the same edge, we define a unique ordering
  of the edges in the set E and then we pick the
  minimum edge of that ordering.
• .

10

• The intercluster edge selection procedure
• REP_EDGE (Continue)
• Let us define ID-weight of an edge e (?,w),
  where ID(?) ltID(w), as the pair (ID(?), ID(?)),
  and lets order the edges lexicographically by
  their ID-weight.
• Doing so will ensure distinct weights,since we
  have different vertex identifiers, and also will
  allow consistent selection of intercluster edges,
  and because of this rule,different clusters can
  proceed with their selection process in parallel
• The problem with the selection process described,
  is that it must be carried out at cluster C for
  every adjacent cluster C individually, and one
  way of doing so is to pipeline the individual
  processes.

11
Theorem 20.5.1 Given an n-vertex unweighted graph
G (V,E) and an integer ? ? 1, the distributed
Algorithm DIT_PART requires Time(DIST_PART) O(n
?) and Message(DIST_PART) O(n2)
12

• Improvements(1)
• In order to reduce the complexity of our
  Algorithm DIST_PART we can do some modifications
  to it.
• First we can modify the procedure NEXT_CTR by
  doing the following
• 1-Lets start the whole Algorithm by computing a
  spanning tree T for the entire network, which can
  be done by flooding with complexities Time O(n)
  and Message O(E).
• 2-The DFS procedure for searching for a new
  center for the next cluster can be executed on T
  rather than on the formed cluster graph.This
  process starts from the root of T, ?1, which is
  selected as the 1st center.So whenever a vertex
  ?i is chosen as a new center, the DFS process is
  halted until the cluster constructed around ?i by
  the procedure CLUSTER_CONS, is completed.

13

• Improvements (2)
• 3-After the completion, the DFS process can
  proceed searching T until it finds a vertex
  ?i1that does not belong to any of the clusters
  already constructed.
• The process is iterated until the entire tree T
  is traversed. Thus the procedure NEXT_CTR is
  reduced to Time(NEXT_CTR ) Message(NEXT_CTR )
  O(n).
• Second, we can modify the procedure REP_EDGE for
  selecting the intercluster edges.This whole
  procedure can be deleted if we allow more than
  one single intercluster edge for two adjacent
  clusters.This can be done as follows in the
  CLUSTER_CON procedure
• 1- When ever the Procedure CLUSTER_CONS
  completes the construction of the cluster C, each
  vertex in the rejected layer selects the edge on
  which it was contacted in the exploration stage
  and marks it as intercluster edge.

14

• Improvements(3)
• 2-If ? has received a number of exploration
  messages, then it selects one of the connecting
  edges arbitrarily
• That procedure just described does not entail any
  extra cost in time or communication.
• Compared to our old implementation, in this one
  we might have two clusters that are connected by
  more than one intercluster edge which makes the
  outcome of this improved Algorithm a cluster
  multigraph rather than a cluster graph.However
  the analysis proves that the total number of
  intercluster edges in the resulting cluster
  multigraph is still bounded by O(n 11/ ? ).
• It turned out that the behavior of a number of
  applications of such partitions are not affected
  by the improvement changes.

15

• Improvements(4)
• Theorem 20.6.1 Given an n-vertex unweighted graph
  G (V,E) and an integer ? ? 1, the modified
  implementation of the distributed Algorithm
  DIST_PART requires Time(DIST_PART) O(n) and
  Message(DIST_PART) O(En?)
• In fact, the message complexity of the Procedure
  CLUSTER_CONS can be reduced to O(E), which
  reduced the complexity of the Algorithm to
  O(E).
• Given the connection between basic spanners and
  partitions captured in section 16.1 we get the
  following
• Corollary 20.6.2 Given an n-vertex unweighted
  graph G (V,E) and an integer ? ? 1, there exits
  a distributed algorithm for constructing a
  ?-spanners for G with O(n 11/ ? ) edges in Time
  O(n) and Message O(E)