The document describes flooding algorithms used to build spanning trees in distributed networks. It discusses basic flooding where each node broadcasts a message to neighbors to flood the network. This builds an implicit breadth-first spanning tree. It then presents a modified flooding algorithm that explicitly constructs the spanning tree by having nodes exchange parent and already-seen messages to establish parent-child relationships between nodes. Finally, it discusses depth-first spanning tree construction using a similar approach with explore and parent messages to build the tree in a depth-first manner.

1. Flooding Algorithm and building a spanning
Tree
• The communication network does not have a spanning tree from
before.
• Root initiates a message broadcast.
• Root sends message to all its neighbors.
• And sets the seen flag to true.

2. p1
p0
p2
p3
p5
p6
p4
p7
p8

3. p1
p0
p2
p3
p5
p6
p4
p7
p8

4. p1
p0
p2
p3
p4
p5
p4
p6
p7

5. p1
p0
p2
p3
p5
p6
p4
p7
p8

6. p1
p0
p2
p3
p5
p6
p4
p7
p8
It is possible that P1 gets
message from P0 and P2 at
the same time. In this case
p1 will choose a parent
arbitrarily

7. Basic Flooding Algorithm
• Each process maintains a single bit of state: seen-message.
• At time 0, root sets seen-message to true and sends M to all
neighbors except pj.
• Upon receiving M:
• If seen-message = false,
• seen-message ← true
• send M to all neighbors
• Else do nothing

8. Message complexity of flooding
• m = total number of communication channels
• When a processor receives a message for the first time from some
neighboring processor pj it sends the message <M> to all its neighbors
except pj.
• A processor will not send <M> more than once on any communication
channel.
• This <M> is sent at most twice on each communication channel. [hint:See
the channel between P1 and P2 in slide 9 and 10 and between P5 and P6].
• Note there are executions in which the message <M> is sent twice on all
communication channels except those on which <M> is received for the
first time.
• Thus it is possible that 2m- (n-1) messages are sent . This can be as high as
(n(n - 1))/2

9. Home work and Discussion
Refer Distributed Computing book page 17,18 [Difficulty level : easy ]
Question: Write the following Lemmas in your homework sheet along with
their proof
• Lemma 2.1
• Lemma 2.2l
• Lemma 2.3
• Lemma 2.4
And bring to next class. I will choose one person from each group to go over
the proof. First 15-20 minutes of the class will be spent in discussion.
The answers have to be written paper sheets in ink/pencil. No copy pasting
in word document and bringing printouts.

10. Modified flooding algorithm
• Each process maintains a single pointer parent, initially ⊥.
• Neighbors of a Processor need not be children but children will be its
neighbor.
• Each process has two lists - children and other [neighbors which are
not children
• In the earlier algorithm a spanning tree is not explicitly constructed.
• Use <parent> and <already>messages.

11. //Initially parent = ⊥ children = nil, other = nil . Other U children = all the neighbors
//Wake up root to send <M>. At this point root has not sent message
Upon receiving no message:
If pi = pr and parent = ⊥ then
Send <M> to all neighbors
Parent = pi
//Pj has not received <M> before.
Upon receiving <m> from neighbor pj:
If parent == ⊥then
Parent = pj
Send <parent> to pj
Send <M> to all neighbors except pj
Else send <already> to pj
Modified Flooding algorithm to construct a spanning tree. Code for processor pi 0<= I <= n-1

12. Upon receiving <parent> from neighbor pj:
Add pj to children
If children U other contains all neighbors except parent then
Terminate
Upon receiving <already> from neighbor pj:
Add pj to other
If children U other contains all neighbors except parent then
Terminate

13. p1
P0
p2
p3
<M>
<parent>
<already>

14. p1
P0
p2
p3
<M>
<parent>
<already>

15. • It will continue and broadcast the message and eventually the
algorithm will build a spanning tree.
• Question: (Bonus Points )
Prove that this algorithm will build a spanning tree
[Hint : Lemma 2.6 ]

16. Depth First Spanning Tree
• The previous flooding algorithm created a BFS spanning tree because
it sent messages to all the neighbors.
• It was done level by level .
• In DFS Each processor has two sets associated with it
• A set of children
• A set of all neighbors which is called unexplored set
• Processors send <M> , <already> , and <parent> messages to each
other
• The set of children gets populated by the recipient when <parent>
message is sent

17. Depth search spanning tree algorithm for a
specified root. Code for processor pi,0<=i<= n-1
//Initially parent = ⊥ children = nil, unexplored= all neighbors of pi
//Wake up root to send <M>. At this point root has not sent message
Upon receiving no message:
If pi = pr and parent = ⊥ then
parent = pi
explore()
//Pj has not received <M> before.
Upon receiving <m> from neighbor pj:
If parent == ⊥then
Parent = pj
Remove pj from unexplored
explore()
else
send <already> to pj
Remove pj from unexplored

18. Upon receiving <already> from pj:
explore()
Upon receiving <parent> from pj:
add pj to children
explore()
Procedure explore():
if unexplored # nil then
let pk be a processor in unexplored
remove pk from unexplored
send <M> to pk
else
if parent #pi then //This is important because the only case
//when the parent of a processor is in the
// case of root
send <parent> to parent

19. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

20. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

21. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

22. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

23. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

24. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

25. p1
po
p2
p4
p5
p3
Unexplored = Nil
Unexplored = Nil
<M>
<parent>
<already>

26. p1
po
p2
p4
p5
p3
Unexplored = Nil
<M>
<parent>
<already>

27. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

28. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

29. p1
po
p2
p4
p5
p3
<M>
<parent>
<already>

30. p1
po
p2
p4
p5
p3
Unexplored = Nil
<M>
<parent>
<already>

31. p1
po
p2
p4
p5
p3
Parent == po
<M>
<parent>
<already>

32. What is the time complexity of the DFS
spanning tree?

33. Home Work

34. http://www.concretepage.com/java/example-observer-observable-java
https://examples.javacodegeeks.com/core-java/util/observer/java-util-
observer-example/

35. DFS Spanning tree without a specified root
• Three different types of messages are sent each message is tagged
with either of the following
• leader
• already
• parent
leader
already
leader

36. Spanning tree construction: code for
processor pi 0<= i <= n-1
Initially parent = ⊥ children = nil, unexplored= all neighbors of pi
//Wake up all nodes spontaneously
Upon receiving no message:
If parent = ⊥ then
leader = id
parent = pi
explore()

37. Spanning tree construction: code for
processor pi 0<= i <= n-1
//Switch to new tree
Upon receiving <leader, new-id> from pj:
If leader < new-id then
leader = new-id
parent = pj
children = nil
unexplored = all neighbors of pj except pj
explore()
else if leader == new-id then
send <already, leader> to pj //this processor is already in the same tree
//otherwise leader > new-id and the DFS for the new-id is stalled.

38. Spanning tree construction: code for
processor pi 0<= i <= n-1
//Switch to new tree
Upon receiving <already, new-id> from pj:
If new-id == leader then
explore()

39. Spanning tree construction: code for
processor pi 0<= i <= n-1
//Switch to new tree
Upon receiving <parent, new-id> from pj:
If new-id == leader then
Add pj to children
explore()

40. Spanning tree construction: code for
processor pi 0<= i <= n-1
//Switch to new tree
procedure explore() :
If unexplored != nil then
let pk be a processor in unexplored
remove pk from unexplored
send <leader, leader> to pk
else
If parent != pi then send <parent, leader> to parent
else
terminate as root of spanning tree

41. 34
55
23 11
29
20 19
55
24

42. 34
55
23 11
29
20 19
55
24
leader
already
leader
leader
leader

43. 34
55
23
34 11
29
20 19
55
24
already
leader
Upon receiving <leader, new-id> from pj :
If leader < new-id then
leader = new-id
parent = pj
children = nil
unexplored = all neighbors of pi
except pj
explore()
else if leader == new-id then
send <already, leader> to pj

44. 34
54
23
34 11
29
20 19
55
24
already
leader
procedure explore() :
If unexplored != nil then
let pk be a processor in
unexplored
remove pk from unexplored
send <leader, leader> to pk
else
If parent != pi then send
<parent, leader> to parent
else
terminate as root of
spanning tree
The node with leader 34
belongs to a DFS with id
smaller than the maximal
identifier seen so far.
Do nothing. Stall the DFS
creation for this DFS

45. 34
54
23
34 11
29
20 19
55
24
already
leader
The node with leader 20
belongs to a DFS with id
smaller than the maximal
identifier seen so far.
Do nothing. Stall the DFS
creation for this DFS

46. 34
54
23
34
11
29
29
20 19
55
24
29
already
leader
explore

47. 34
54
23
34
11
29
29
20 19
55
24
29
already
leader
already
explore

48. 34
54
23
34
11
29
29
20
29
19
29
55
24
29
leader

49. 44
62
20
25
27
92
45
12
already
leader
62 12 20
45 92
12 20
92 25
45 44 25
62 20
62 27 44
45

50. 44
62
20
25
27
92
45
12
already
leader
62 12 20
45 92
12 20
92 25
45 44 25
62 20
62 27 44
45
44
62
45
12
92
20
27
25

51. 44
62
20
25
27
92
45
12
already
leader
12 20
92
20
25
44 25
20
27 44
45
44
62
45
12
92
20
27
25

52. 44
62
20
25
27
92
45
12
already
leader
12 20
92
20
25
44 25
20
27 44
45
44
62
45
12
92
20
27
25

53. 44
62
20
25
27
92
45
12
already
leader
12 20
92
20
25
44 25
20
27 44
4562
9292
62

54. 44
62
20
25
27
92
45
12
20
20
25
44 25
20
27 44
4562
9292
62

55. 44
62
20
25
27
92
45
12
20
20
25
44 25
20
27 44
4562
9292
62

56. 44
62
20
25
27
92
45
12
20
20
25
44 25
20
27 44
4562
9292
62

57. 44
62
20
25
27
92
45
12
12 20
92
20
25
44 25
20
27 44
4562
92
9292
92

58. 44
62
20
25
27
92
45
12
12 20
25
44 25
20
27 44
4562
92
9292
92

59. 44
62
20
25
27
92
45
12
12 20
92
20
25
44 25
20
27 44
4562
92
9292
92
92

60. 44
62
20
25
27
92
45
12
12 20
92
20
25
44 25
20
27 44
4562
92
92

61. 44
62
20
25
27
92
45
12
already
leader
62 12 20
45 92
12 20
92 25
45 44 25
62 20
62 27 44
45

62. References
• http://www.cs.yale.edu/homes/aspnes/pinewiki/Flooding.html
• https://www.youtube.com/watch?v=6EEgWmyl-IM
• GOOD
http://www.cs.yale.edu/homes/aspnes/pinewiki/Flooding.html