TRAVERSAL

ALGORITHMS

D7022E - Formal methods in telecommunications engineering 

ABIOLA FAMUREWA & SAMUEL IDOWU

TABLE OF CONTENT
 Traversal algorithms
 Traversing cliques
 Traversing tori
 Traversing hypercubes
 Traversing connected networks
▪ Tarry’s algorithm
 Time complexity: depth-first search
 Classical depth-first search
 Awerbuch’s solution
 Cidon’s solution
 Depth-first search with neighbor knowledge
TRAVERSAL ALGORITHMS

Traversal algorithm is a wave algorithm with the following

properties:

 Each computation contains one initiator which starts

computation by sending one message
 when a process receives a message it either sends out one
message or decides
 The algorithm terminates in the initiator and when this
happens, each process has sent a message at least once.
F-TRAVERSAL ALGORITHM

Definition: An algorithm is an f-traversal algorithm (for

a class of networks) if ;

 It is a traversal algorithm

 In each computation at least min (N, x + 1) processes

have been visited after f (x) token passes.
IMPLEMENTATIONS OF TRAVERSAL
ALGORITHMS
The implementations of Traversal algorithm will be studied
using the followings;

 Sequential polling (Traversing cliques)

 Traversing Toris
 Traversing Hypercubes
 Tarry’s algorithm
SEQUENTIAL POLLING ALGORITHM

TRAVERSING CLIQUES
 A clique is traversed by sequential polling
 but only one neighbor of the initiator is polled at a time. i.e. only when a
reply of one neighbor has been received is the next neighbor polled

*polling process is similar to polling algorithm.

Theorem: The sequential polling algorithm is a

2x –traversal algorithm for cliques.

Topology  clique
It is centralized
Message complexity  2N - 2
Time complexity  2N – 2
TRAVERSING TORI
 The n × n torus graph is the graph G =(V, E ), where
V = Zn ×Zn ={(i, j) : 0 < i, j < n} &
E = {(i, j) (i', j’) : (i = i’∧ j’ = j’ ± 1) ∨ ( i= i’ ± 1∧j= j)}

 The torus is an halmitonian graph

It has sense of direction
The coordinate pair (i, j) are used in defining topology and its
sense f of direction
Message complexity  N
Time complexity  N

Theorem: The torus algorithm is an x -traversal algorithm for the

torus.
TRAVERSING TORI
Scenario: token moves from process p to process q by making UP-
moves and RIGHT-moves.

Algorithm details:
 The initiator initiates the process by sending token<num, 1> to
UP
 Each process receives the token <num, k>
 If k = n2 then the process decides, else
 If n/k (i.e. a multiple of k) then send <num, k+1> to UP
 Else send <num, k+1> to RIGHT

 Decision Is taken after n2 times

TRAVERSING HYPERCUBES
 The n –dimensional hypercube is a graph G = (V ,E )
 Hypercube has sense of direction
 The topological knowledge is restricted to the channel labels, and
not known to the processes

 Theorem: The hypercube algorithm is an x-traversal algorithm for

the hypercube.

 Message Complexity  N
 Time complexity  N
 Topology  Hypercube
TRAVERSING HYPERCUBES

Algorithm details

The initiator send <num, 1> token through channel n-1

For each process, upon receipt of the token <num, k>
Check if k=2n then decide
If k ≠ 2n let l be the largest number : 2l / k
Send (num, k+1) through channel l
TRAVERSING CONNECTED NETWORKS
(TARRY’S ALGORITHM)

 Tarry’s algorithm is an important algorithms for traversing

connected networks.
 Works for arbitrary networks.
 Initiator forwards token to one of neighbors, each neighbor
forwards token to all other nodes and when done returns the
token.
 A node is free to chose any node to forward token to.
 The time complexity  2|E|
 message complexity  2|E|
 Topology  Arbitrary
TARRY’S TRAVERSAL ALGORITHM

The algorithm is formulated in the following two rules:

 R1. A node never forwards the token through the same

channel twice.
 R2. A node only forwards the token to its father when there
is no other option.
TARRY’S ALGORITHM

Tarry’s algorithm is a traversal algorithm and it terminates which

can be proved with the following steps.
 The channels incident to an initiator are used once in each
direction
 For each visited process (p), all channels incident to (p) have
been used once in each direction.
 All processes have been visited and each channel has been
used once in both directions.
DEPTH-FIRST SEARCH
ALGORITHMS

Classical Depth First Search

Awerbuch’s Solution
Cidon’s Solution
Depth First Search with neighbor
Knowledge
 DEPTH-FIRST SEARCH
 A minor modification of Tarry’s algorithm i.e. restriction of the
freedom of choice of the process enables the algorithm to compute
DFS.
 DFS algorithms are those that compute spanning trees with additional
property:
Each frond edge connects two node, one of which is an ancestor of the
other.
 Frond Edge: An edge that does not belong to the spanning tree.
 Given a rooted spanning tree T of G, for each process P, ∃ T[p] denotes
the set of processes in the sub-tree of P, and ∃ A[p] denotes the
ancestors of p
q ∈ T[p] ⇔ p ∈ A[q]
DEPTH-FIRST SEARCH

 A spanning tree T of G is a DFS tree if, for each frond edge pq, q ∈
T[p] v q ∈ A[p]
 Uses: used in many graph algorithms. E.g. graphs for testing
planarity, bi-connectivity and for the construction of interval
labeling schemes.
 The resulting algorithm after the tweak on Tarry’s algorithm 
Classical Depth-first Search algorithm
 Topology of DFS is Arbitrary
 DSF algorithms are centralized since ∃ only one initiator at each
computation
Classical Depth-first Search

 Time complexity of distributed algorithms:

The maximum time taken by a computation of an algorithm
 Assumption: (correctness of algorithm doesn’t depend on
assumptions)
 T1: A process can execute any finite number of events in Zero time.
 T2: The time between sending and receipt of a message is at most
one time unit.
 Message complexity  2|E|
 Time complexity  2 |E|

 NOTE: for traversal algorithm, the time complexity equals the

message complexity since messages are exchanged serially, and
each may take one time unit.
Distributed Depth-first Search
 Classical DFS algorithm is obtained when freedom in Tarry’s
algorithm is restricted by adopting the following third rule:
R3: When a process receives the token it sends it back through
the same channel if this is allowed by R1 and R2

R1. A node never forwards the token through the same channel twice.
R2. A node only forwards the token to its father when there is no other
option.

 Theorem: The classical depth-first search algorithm computes a

depth-first search spanning tree using 2|E| messages and 2|E| time
units.
DFS Algorithm (Linear Time)

 Classical DFS is characterized by high time complexity because all

edges, tree edges and fronds are traversed serially.
 Token <tok> message traverse all frond edges and return
immediately in classical DFS
 To achieve lower time complexity:
 Token <tok> only traverses tree edges. This gives a linear time
since there are only N- 1 edges
Awerbuch’s Solution
 Algorithm include mechanism that prevents the transmission of
the token through a frond edge.

 Ensures that each process knows

 at the moment when it must forward the token.
 Which of its neighbors have been visited already.

 A process chooses an unvisited neighbor or sends the token to its

own father if no such neighbor exists.

 When process p is first visited by a <tok>, p informs each neighbor

r, except its father of the visit by sending a <vis> message to r.
Awerbuch’s Solution
 The forwarding of the token is suspended until p has received and
<ack> message from each neighbor.

 When later, the token arrives at r, r will not forward the token to P,
unless P is r’s father.

 Awerbuch’s algorithm computes a depth-first search tree in 4N – 2

time units and uses 4.|E| messages

 The sending of <vis> message can be omitted for the neighbor to

which a process forwards the token. This improvement saves 2
messages per tree edge and hence reduces the message
complexity by 2N-2 messages
Cidon’s Solution
 AIM: To improve on the time complexity of Awerbuch’s algorithm
by not sending the <ack> message used in Awerbuch.
Algorithm description
 In Cidon’s modified algorithm, the token is forwarded immediately
i.e. it cancelled the two time unit delay introduced in Awerbuch’s
algorithm(by waiting for <ack>)
Special Situation
 A process p sent a <vis> message to its neighbor r after receiving a
<tok> message
 The token later visits r, but at the moment r receives the token,
the <vis> message of p has not yet reached r.
Cidon’s Solution
 In this case, r may forward the token to p via the frond edge
(differs from Awerbuch’s because, there is a need for <ack> to be
received in Awerbuch’s solution).
 Process p records neighbors it most recently sent the token in a
variable mrsp.
 Process r receives p’s <vis> message after sending the token to p,
i.e. r, receives a <vis> message from neighbour mrsr.
 In the above case, r acts as if no token has been sent to p; r selects
a next neighbor and forwards the token.
 Cidon’s Algorith computes a DFS tree in 2N-2 time units using 4.|E|
messages.
Cidon’s Solution
 Analysis: Cidon’s algorithm sends fewer messages than
Awerbuch’s algorithm in many cases
 The above analysis of the number of messages assumes the most
pessimistic case:
 Token message is sent through each frond in both directions
 Observation: Cidon observes that even though the algorithm may
send the token to previously visited nodes, it has a better time,
communication complexity than Awerbuch’s algorithm, which
prevents such undesireable transmission.
 Suggestion: less time and fewer messages may be spent in
recovering from unnecessary actions than in avoiding these
actions.
DFS with Neighbor Knowledge

 A list L of visited processes included in a token can be used to avoid

traversal of fronds by token ⇔processes know the identity of their
neighbors.
 A process p, receiving the token with list L, does not forward the
token to a process in list L.
 The DFS algorithm with neighbor knowledge is a traversal algorithm
and computes a depth-first search tree using 2N-2 messages in 2N-2
time units.
 Observation: bit complexity is high ; if w is the no. of bits needed to
represent one identity  list L may require up to N.w bits.
summary