TRAVERSAL
ALGORITHMS
D7022E - Formal methods in telecommunications engineering
ABIOLA FAMUREWA & SAMUEL IDOWU
[email protected] 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
