An efficient dynamic routing technique for computation of
shortest path tree
Shanita Roy
Abstract—( in today’s Internet, datagram is forwarded by a router
based on a forwarding table. Routing protocols are employed to
exchange topology information among routers to facilitate the
construction of forwarding tables. Examples of widely used link-state
based routing protocols include Open Shortest Path First (OSPF) and
IS-IS.
Open Shortest Path First (OSPF):
A routing protocol that determines the best path for routing IP traffic
over a TCP/IP network. OSPF is an interior gateway protocol (IGP),
which is designed to work within an autonomous system. It is also a
link state protocol that provides less router-to-router update traffic
than the RIP protocol (distance vector protocol) that it was designed
to replace.
Features:
Load balancing: distributing traffic equally among routes
Supports multicasting and authentication.
Separate routes can be calculated for each IP type of service.
IS-IS (Intermediate System to Intermediate System): This is an ISO
protocol that provides dynamic routing between routers. IS-IS is an
interior gateway protocol (IGP) and link state protocol.
With these routing protocols, each link is associated with a cost
(weight) and routers exchange link state information so that each
router in a routing area (e.g., an OSPF area) has a complete
description of the network topology. Using the link costs, each router
computes a path with minimum cost from itself to other router in the
area, yielding a shortest path tree (SPT). The corresponding SPT is
then used to build a forwarding table that contains routing information
for forwarding a datagram to its destination along the shortest path.
The Open Shortest Path First (OSPF) and IS-IS(Intermediate SystemIntermediate System) routing protocols are widely used in today’s
Internet to compute a shortest path tree (SPT) from each router to
other routers in a routing area. Many existing routers recompute an
SPT from scratch following changes in the link states of the network.
Such recomputation of an entire SPT is inefficient and may consume a
considerable amount of CPU time. Moreover, as there may coexist
multiple SPTs in a network with a set of given link states,
recomputation from scratch causes frequent unnecessary changes in
the topology of an existing SPT and may lead to routing instability. In
this project, we want to present new dynamic SPT algorithms that
make use of the structure of the previously computed SPT and
implement some new functionality to recompute the path. Besides
efficiency, our algorithm design objective is to achieve routing
stability by making minimum changes to the topology of an existing
SPT when some link states in the network have changed. )
We put our effort to establish an algorithmic framework that allows us
to characterize a variety of dynamic SPT algorithm including dynamic
versions of the well-known Bellman-Ford algorithm. The theoretical
asymptotic complexity of our new dynamic algorithm is also
considered and treated accordingly.
The existing technique:
The topology in a routing area may change due to following
reasons
A link may fail or it may change its routing cost or it may be due to
recovery. When such changes occur every router in the area is notified
of the change. After updating the corresponding topology changes in
data structure, each router recomputes its SPT. Usually this
recomputation is done by deleting the current SPT and recomputing it
from the very beginning by using the well-known Dijkstra algorithm.
Dijkstra's Algorithm to be elaborated
Dijkstra's algorithm can be expressed formally as follows:
G - arbitrary connected graph
v0 - is the initial beginning vertex
V - is the set of all vertices in the graph G
S - set of all vertices with permanent labels
n - number of vertices in G
D - set of distances to v0
C - set of edges in G
Dijkstra Algorithm (graph G, vertex v0)
{
S={v0}
For i = 1 to n
D[i] = C[v0,i]
For i = 1 to n-1
Choose a vertex w in V-S such that D[w] is minimum
Add w to S
For each vertex v in V-S
D[v] = min(D[v], D[w] + C[w,v])
}
There are many different operations that can be done on graphs.
However, if the distance (cost) between two given vertices needed to
be calculated, an alternate method would be required. Dijkstra's
algorithm determines the distances (costs) between a given vertex and
all other vertices in a graph. This may be useful to determine
alternatives in decision-making. For example, a telephone company
may miss the decision to install a new telephone cable in a rural area
when presented with the option of installing the same cable in a city,
reaching twice the people at half the cost.
The algorithm begins at a specific vertex and extends outward within
the graph, until all vertices have been reached. More simply, Dijkstra's
algorithm stores a summation of minimum cost edges.
Dijkstra's algorithm creates labels associated with vertices. These
labels represent the distance (cost) from the source vertex to that
particular vertex. Within the graph, there exists two kinds of labels:
temporary and permanent. The temporary labels are given to vertices
that have not been reached. The value given to these temporary labels
can vary. Permanent labels are given to vertices that have been
reached and their distance (cost) to the source vertex is known. The
value given to these labels is the distance (cost) of that vertex to the
source vertex. For any given vertex, there must be a permanent label
or a temporary label, but not both.
Vertex A has a temporary label with a distance of 0
a permanent label with a distance of 5
Vertex B has
The algorithm begins by initializing any vertex in the graph (vertex
A, for example) a permanent label with the value of 0, and all other
vertices a temporary label with the value of 0.
The algorithm then proceeds to select the least cost edge connecting
a vertex with a permanent label (currently vertex A) to a vertex with a
temporary label (vertex B, for example). Vertex B's label is then
updated from a temporary to a permanent label. Vertex B's value is
then determined by the addition of the cost of the edge with vertex A's
value.
The next step is to find the next least cost edge extending to a vertex
with a temporary label from either vertex A or vertex B (vertex C, for
example), change vertex C's label to permanent, and determine its
distance to vertex A.
This process is repeated until the labels of all vertices in the graph
are permanent.
Disadvantage of Static Dijkstra Algorithm
This technique proves to be inefficient because when the link
changes occurs the available information of the existing SPT is
totally deleted and the recomputation starts from the beginning to
reconstruct the new SPT, so considerable amount of CPU time is
consumed and other critical routing function is also prevented in
their execution. So in order to enhance the efficiency of
computation of SPT it will be meaningful to compute the SPT
using as little CPU time as possible.
Further the handling of the complexity of SPT computation would
be easier. A larger routing area (e.g., an OSPF area) can be brought
into consideration, as the reduction of the complexity of SPT
computation is possible using the new technique. The conventional
technique simply limits the size of the routing area.
Next static algorithms suffer from the possibility of routing errors or
routing failures because of the following reasons. Multiple routes of
the same shortest distance from one router to another exist. A different
route of the same minimum distance to forward its packets may
therefore result. This in turn may cause the router to change many
entries in its forwarding table frequently. Unnecessary changes in the
SPT also cause undesirable fluctuation of traffic load on a given route.
New Implementation
In the present work, we want to find out an algorithm that can
dynamically create a new SPT after observing changes in the link
states. This dynamic algorithm will use all the available information
of the existing SPT and updates only the part of the SPT that is
affected by the change. We shall follow the two steps as given below
to fulfill our design objectives.
The first step is to minimize the computational complexity required to
update an SPT.
The second step is to maintain routing stability by making minimal
changes to the topology of an existing SPT.
Purpose
The purpose of our work is restricted to dynamic SPT algorithm that
can be used in link-state protocols. A complete topology database
(such as the link-state database in OSPF) is required and it will be
implemented using the new algorithm in a centralized processor.
Unlike previous work on dynamic SPT algorithms that is based on the
static Dijkstra algorithm only, we shall present an algorithmic
framework that also yields dynamic versions of well-known static
SPT algorithms such as Bellman-Ford. This framework allows us to
characterize dynamic SPT algorithms in a unified way and to establish
proofs of correctness for these algorithms.
Bellman-Ford Algorithm
The Bellman-Ford algorithm solves the single-source shortest-paths
problem in the more general case in which edge weights can be
negative. Given a weighted, directed graph G = (V, E) with source s
and weight function
Bellman-Ford algorithm returns a
boolean value (value TRUE or FALSE) indicating whether or not
there is a negative-weight cycle that is reachable from the source. If
there is such a cycle, the algorithm produces the shortest paths and
their weights (s, v). The algorithm returns TRUE if and only if the
graph contains no negative weight cycles that are reachable from the
source.
Like Dijkstra's algorithm, the Bellman-Ford algorithm uses the
technique of relaxation, progressively decreasing an estimate d [v] on
the weight of a shortest path from the source s to each vertex v V
until it achieves the actual shortest-path weight (s, v).
Algorithm
BELLMAN-FORD (G, w, s)
1 INITIALIZE-SINGLE-SOURCE(G, s)
2 for i 1 to |V[G]| -1
3 do for each edge (u, v) E[G]
4 do RELAX(u, v, w)
5 for each edge (u, v) E[G]
6 do if d[v] > d[u] + w(u, v) then
7 return FALSE
8 return TRUE
Figure: The execution of the Bellman-Ford algorithm.
Explanation
In this figure the source is vertex z. The d values are shown within the
vertices and the other edges indicate the values (for example in
figure (b) we see that the predcessor of the vertex u and x is vertex z:
therefore [u] = z in [x] = z). In this particular example, each pass
relaxes the edges in lexicographic order:
(u, v), (u, x), (u, y), (v, u), (x, v), (x, y), (y, v), (y, z), (z, u), (z, x).
(a) The situation just before the first pass over the edges.
(b)-(e) The situation after each successive pass over the edges. The d
and values in part (e) are the final values.
The Bellman-Ford algorithm returns TRUE in this example.
Figure 25.7 shows how the execution of the Bellman-Ford algorithm
works on a graph with 5 vertices. After performing the usual
initialization, the algorithm makes |V] - 1 passes over the edges of the
graph (line 1). Each pass is one iteration of the for loop of lines 2-4
and consists of relaxing each edge of the graph once. Figures 25.7(b)(e) show the state of the algorithm after each of the four passes over
the edges. After making |V| - 1 passes lines 5-8 check for a negativeweight cycle and return the approriate boolean value.
In particular, within our framework, we propose an incremental
method to transform static algorithms into the dynamic version.
The incremental method yields new dynamic algorithms that are faster
on average. Furthermore, with the incremental method, the resulting
dynamic algorithm will make the minimum number of changes to the
SPT topology following a link-state update, thus improving routing
stability.
Related Works
The problem of routing in data networks has been a subject of
continual research interest for the past two decades and many routing
protocols have been studied and used in practical networks. The
stability issues in Internet routing have attracted much attention. In
fact, our interest in dynamic SPT algorithms was partly motivated by
the problem of routing instability in the Internet.
To the best of our knowledge, the earliest work on dynamic SPT
algorithms that appears is the work that proves a lower-bound
complexity for the worst-case scenario.The first efficient dynamic
SPT algorithm that we know is the Dijkstra algorithm.
Definitions and Notations
We now define some notation to be used in the rest of the project. The
notations are based on the basic graph theoretic definitions.
Let G = (V,E) denote a directed graph where V is the set of nodes and
E is the set of edges in the graph.
Let Source (G) ∈V denotes the root or source node of G.
For each directed edge e∈E we use W (e) to denote the weight
(distance) associated with e, S(e) and E1(e) to denote respectively the
source node and the end node of e. The length or distance of a
directed path is the sum of weights of the edges on the path.
Given a set of nodes N⊆V, we associate with it two sets of edges:
I(N) ={e ∈ E | E1(e) ∈ N} (the set of edges directed into the nodes
inN) and 0(N’) = { e ∈ E | |S(e) ∈ N}(the set of edges directed out of
the nodes in N). These parameters only depend on the topology of the
network, and their values do not change during the execution of the
algorithm.
A rooted tree T is a subgraph of G such that Source (G) is in T and
every node in T is reachable from Source(G) through a unique
directed path using only edges in T.
A node x is a parent node of y in T if x is the source node and y is the
end node of an edge in T. We associate with each node n in a tree T
the following attributes: P (n, T) is the parent node of n and D (n, T) is
the distance attribute of n. Since T is a tree, invoking P(n, T)
recursively determines a unique path from Source (G) to any node in
T.
The descendents of a node n in T are all the nodes that are reachable
by n. We use B(n, T) to denote a subset that includes n and some
descendents of n in tree T. As we will see later, an execution of the
algorithm involves the distance update of the subset B(n, T) for
various nodes n. The different ways the subset B(n, T) can be chosen
for each node n will lead to different incremental methods for
computing the SPT.
The notation Bmax(E(e),T1) denotes the set having the end node of
edge e and all its descendents in T1.
Algorithm Framework
In this section, we present a broad class of algorithm that can compute
an SPT from a source node to every other node in the graph. This
class of algorithm is presented in a unified framework as the basic
algorithm. Depending on the initialization procedure the basic
algorithm includes as special cases for some well-known static SPT
algorithms, such as Bellman-Ford, Dijkstra as well as their dynamic
versions.
A tree data structure, denoted by T1, is maintained by the basic
algorithm to keep track of an existing potential SPT. In particular,
every node n in the graph G is present in T1 (along with its parent
attribute P (n, T1) and distance attribute D (n, T1)). This data structure
T1 changes progressively during the computation, and when the
execution of the algorithm is completed, it will represent an SPT.
The basic algorithm also maintains a list Q that contains a subset of
nodes and their parent and distance attributes temporarily. In
particular, each element in Q is of the form {n, (p, d)}, where p and d
respectively denote the parent of n and the potential distance of n from
the source node with respect to some tree.
ENQUEUE(Q, {n, (p, d)}) adds one more element to Q; if node n is
already in Q with attributes Pold and dold, the new attributes (p, d) will
replace the old ones only if the new distance d is less than dold. At any
instant, only one set of attributes is maintained for each node in Q.
EXTRACT(Q) instruction :When it is executed a single element is
selected and removed from Q.
The basic algorithm also makes use of arithmetic using the symbol for
infinity (∞). By this term, we refer to any number that is much larger
than the distance of the longest path in the network. It is also the
largest number we can have.
The basic algorithm contains an initialization procedure (step 1) and
an iterative loop (steps 2-4). The following pseudocode formally
describes the algorithm. An informal description of the algorithm will
follow after the pseudocode.
step 1: Initialization
A) Static Version
∀(n ∈ V)
P(n,T1) ← 0
D(n,T1) ← ∞
ENQUEUE(Q,{Source(G),(0,0)})
/* the initialization enqueues only Source(G) with shortest path
being 0.As any node is a descendent of the source node Source(G)
with respect to any SPT tree any set containing Source(G) is a
complete set. */
B) Dynamic Version(an outdated SPT exists)
Case 1: Edge e increases its weight by ∆
W(e) ← W(e) + ∆
If e is in T1
∀ n ∈ V=Bmax(E(e),T1)
D (n, T) ← D (n, T) + ∆
∀e′ ∈ I (N)
/* Increase distance of each
descendent of E (e) and itself by ∆
*/
/* Consider all edges directed into
all descendents of E (e) and itself
*/
if D (E (e′), T1)>D (S (e′), T1) + W (e′)
/* If the increased
distance of a node is larger
than its distance in another
path the smaller distance
(new potential distance)
update the node with the
new distance and the new
parent in the list Q*/
newdist=D (S (e′), T1)+W (e′)
ENQUEUE (Q, {E (e′), (S (e′), newdist)})
Case 2(Edge e decreases its weight by ∆)
W (e) ← W (e) - ∆
If D (S (e), T1) + W (e) < D (E (e), T1)
/* If the reduced
weight of e yields a
smaller distance for E (e)
*/
∆′ ← [D (S (e), T1) + W (e)] – D (E (e), T1) /* Keep track of the
difference */
P (E (e), T1) ← S (e)
/* Set the patent attribute
of the end node */
∀ n ∈ V=Bmax (E (e), T1)
D (n, T1) ← D (n, T) + ∆′
∀ e′ ∈ 0(N)
/* Reduce the distance
of each descendent of
E(e) and itself by the
difference */
/* Consider all edges
directed out of the
descendent of E(e) and
itself */
if D (E (e′), T1)>D (S (e′), T1) + W (e′)
newdist ← D (S (e′), T1) W (e′)
/* If the reduced
distance of a node
also reduces the
distance of another
node */
/* choose the smaller
distance as the new
potential distance */
ENQUEUE (Q, {E (e′), S (e′), newdist)})
/* Update the node
with the new distance
and new parent in the
list Q */
Step 2: Node Selection
If Q=0
Terminate
Else
{y, (x, d)} ← EXTRACT (Q)
/* Select and remove an
element from the list */
∆ ← (d – D (y, T1))
/* Compute the difference
between new and old
distances of the selected
node */
if ∆ ≥ 0
/* if there is no
improvement in distance
discard the information */
Go to step 2
/* and go back to step 2 to
extract an other node */
P (y, T1) ← x
/* otherwise update the
parent attribute of the
selected node */
N ← B (y, T1)
/* Consider the selected node
and a selected subset of its
descendents */
Step 3: Distance Update
∀e∈N
D (n, T) ← D (n, T1) + ∆
/* Update the distance of the
selected node and each
descendent considered */
Step 4:Node Search
∀e ∈O(N)
/* Consider all edges directed
out of the selected subset of
nodes */
if D (E (e), T1)> D (S (e), T1) + W (e)
/* If the reduced
distance of the selected
node also reduces the
distance of another
node */
newdist ← D (S (e), T1) + W (e)
/* choose the smaller
distance as the new
potential distance */
ENQUEUE (Q, {E (e), (S (e), newdist})
/* Update the node with
the new distance and
new parent in the list Q
*/
Go to step 2
10
9
2
3
2
3
8
7
14
13
4
9
12
2
4
17
5
6
11
5
6
5
2
2
7
5
9
7
4
3
9
6
5
2
15
16
8
8
1
7
0
Fig. 1. Initialization after a link failure.
A. Informal Discussion of the Algorithm
To understand the basic algorithm, here is a brief description of
its executions. As the execution is the same for the static
versions and the dynamic versions after initialization, we shall
only discuss the dynamic version.
1. First, the goal of the initialization phase is to identify those
nodes that may be affected by the change in the link state. The
potentially affected nodes are those that are no longer
connected to the root through the same shortest path as before.
Moreover, in the initialization, we only want to select a
minimal set of such nodes whose changes in distance will be
subsequently propagated to their descendents in the original
tree, which can be updated.
In case 1, after updating the changed edge e with the new
increased weight, we check if the edge is in the existing SPT.If
it is, we select its end node E(e) and all descendent nodes of
E(e) that are reachable in the existing SPT. All such nodes will
be included in a set N for further updating. The intuition is that
the set N covers all the affected nodes. Now for each node that
is attached to a link directed into a node in N, we compute the
potential distance newdist by adding the distance of the parent
node and the weight of the edge connecting the two nodes.
In case 2, after updating edge e with the new decreased weight,
we update the distance of all its descendents (the set N) using
the same difference change δ’. For every edge e originating
from nodes in N we compute the potential new distance newdist
of its end node E (e) by adding the distance of its source node S
(e) and the new weight W(e). If this potential new distance is in
fact smaller than the old distance of E (e), the node E (e) is
inserted in the list Q.
in step 2 any element (the exact procedure is determined by the
specific algorithm) is extracted from the list Q. This selected node is
then updated (if the new distance is better) with its new parent
indicated in Q and the structure of T is modified accordingly to reflect
the new child-parent relation.
in step 3, the selected node together with any (to be specified by the
method used) of its descendent nodes (denoted by the set N) in the
existing tree T will now have their correct distances updated as their
old distances incremented by ∆.
Finally, in step 4, we consider each node E (e) that is attached to an
edge e directed out of a node S (e) in N. If the potential new distance
newdist of E (e) [which is equal to W (e) plus the distance of S (e)] is
smaller than its old distance, we then enqueue in the list Q the node E
(e). After this step is completed, the execution of steps 2 and 3 will be
repeated until the list Q is empty.
At each iteration, a new node and possibly some of its descendents are
updated with a better distance and a better parent that reflects that
distance. In this manner a change in a link-state will propagate along
the old SPT until a new valid SPT is constructed.
B. Multiple Link Weight Changes
When there are several link weight changes occurring at once, it is
always possible to run the algorithm sequentially for each weight
changed. However, some optimization can be achieved by updating
several of these changes together. Even though a separate
initialization needs to be done for every weight change, the main body
of the algorithm needs to be executed only twice. We now describe
how such optimization can be realized. First of all, we initialize all
the weight increases. For each link whose weight increases, the first
four lines of the code for Case 1 are executed. This ensures that all the
affected nodes have updated their distance attributes in T1. Then, we
execute the next four lines of the code in Case 1 for a set N that
includes all the nodes previously updated. This ensures that all the
necessary nodes are enqueued in the list Q. The rest of the algorithm
(steps 2-4) is then executed in a normal way.
After the SPT is updated with all the weight increments, we update it
again for all the weight decrements. As before, the first six lines of the
initialization (Case 2) are executed for each weight decrement, and
then the last four lines are executed with a set N which includes all the
nodes previously updated. After the initialization, the rest of the
algorithm (steps 2-4) is executed normally.
C. Special Cases of the Basic Algorithm
Here we will show how the best-known static algorithms can be
viewed as special cases of our basic algorithm. For these cases, the
static version of the initialization procedure in our basic algorithm is
used. The branching function B (n, T) in the static case is defined as
B (n, T) = {n} ∀n ∈ V. (1)
In this way, the new SPT is constructed in T by changing the
attributes of one node at a time during each iteration. This method is
used in several well-known static algorithms for computing the SPT.
The only difference between these algorithms consist in the different
ways in which the temporary list Q is implemented.
Queue List Implementation
A. Bellman-Ford Algorithm
The simplest way of implementing the list Q is by using a FIFO
queue. New nodes and their attributes are enqueued at bottom
of the queue and extracted from the top of the queue. When
this queuing discipline is used in the static method, it gives rise
to the Bellman-Ford algorithm.
B. Dijkstra Algorithm
Yet another way of implementing Q is by using a priority queue
where the node enqueued with the smallest distance attribute is
always extracted first. When the static version of the initialization
procedure is used, this algorithm is equivalent to the Dijkstra
algorithm.
To implement the priority queue, one can use a linked list where
inserted nodes can be placed anywhere. The node with the smallest
distance attribute can then be extracted by searching through the
linked list sequentially. The resulting algorithm will be referred to
as the static Linear Dijkstra algorithm.
Dynamic Algorithm transformation
This is basically an incremental method leading to dynamic algorithm
from its static version.
Dynamic algorithm can be obtained by changing the branching
function B (y, T) used in Step 2 of the basic algorithm so that it
includes as many descendents as possible. For optimization purposes,
the only nodes that should not be included in B (y, T) are those that
will be directly affected by some node extraction from Q (there is no
point in updating a node that we know will be later updated with a
smaller distance once it is extracted from Q). Likewise, every node
included in B (n, T) should be removed from Q (there is no point in
keeping a node with a known nonoptimal distance in Q). To specify
exactly how the selection of the nodes is done, we present the
following algorithm that defines the set N = B (y, T1) in Step 2 of the
basic algorithm. The instruction DEQUEUE (n, Q) removes node n
and its attributes from Q. The notation B1 (k, T1) denotes the set
including node k and its children in T.
K ← {y}
/* The temporary queue
starts with node y */
N←0
/* The branch set is
initially empty */
Step i
If K=0
/* If the temporary queue is
empty */
Stop
/* done. N contains the
desired output */
Else
k ← EXTRACT(K)
/* pick any node from the
temporary queue */
N← {N, k}
*/ add this node to the output
set */
step ii)
∀n ∈ B1 (k, T1)
/* For all the immediate
children of k */
if n∈Q
if D (n, T1) + ∆≤ D (n, Q)
DEQUEUE (n, Q)
K ← {K, n}
/* if the child is in the
candidate list */
/* and if the new
flooded distance for the
child is better */
/* then remove it from
the candidate list */
/* add the child node n to
the temporary queue */
Else
K ← {K, n}
Go to step I
/* else add the child node n to
the temporary queue. */
10
9
2
13
14
1
2
3
8
4
12
1
2
1
1
17
11
6
1
5
1
7
3
15
16
2
1
0
Fig.New SPT following incremental method in Dijkstra algorithm.
(after a link failure).
10
9
13
14
1
2
3
8
1
12
4
17
11
1
6
2
1
1
5
1
7
1
3
15
16
2
1
0
Fig. New SPT following incremental method in Dijkstra algorithm.
(after a link cost improvement).
The incremental method is less conservative since at each iteration an
entire branch of T1 changes its attributes.
For example, Fig. 7 shows how the Incremental Dijkstra algorithm
obtains a new SPT after the initialization in Fig. 1. First, node 7 is
extracted from Q with node 2 as its parent attribute. All the
descendents of node 7 have their distance attributes updated. Then
node 8 is extracted with node 5 as its parent attribute; all its
descendents have their distance attributes updated. Finally, node 9 is
extracted with node 4 as its parent attribute. Each node is extracted at
most once from Q (there are only three extractions in this case). Since
the distance updates, some nodes (8 and 9) are visited more than once
by the algorithm.
Advantage of Incremental Method
The advantage of this incremental method is that even though some
nodes are visited more than once, fewer iterations take place, the list
Q is much smaller and simpler, fewer search operations are needed,
and most visited nodes only require a simple distance attribute update.
Another advantage of the incremental method is that it guarantees that
the minimum number of parent attributes will be changed. In other
words, a link is removed from the current SPT tree T only if that link
cannot be part of any possible SPT. In this example, node 13
maintains node 12 as its parent attribute and does not change it to
node 8. Fig. 8 shows the new SPT calculated by the Incremental
Dijkstra algorithm after the initialization stage of the basic algorithm.
As seen from the figure, a minimum number of parent attribute
changes are made.
Extension of this Incremental Dynamic Method
This method has been found to provide shortest path tree with least
change in the topology of network in case of Dijkstra Algorithm. A
direct advantage obtained through the application of this Incremental
Method is less computer processing work and less time consuming.
However it is contemplated that extension of the method may be
effective in finding shortest path tree in case of Bellman-Ford
Algorithm. In my future work I shall put effort to analyze Shortest
Path Tree using the Incremental Dynamic Method.
Algorithmic Complexity
The complexity of the algorithm occurs due to involvement of
•
Total number of comparisons made between the distances of
two nodes;
•
Total number of comparisons made between two elements in
the list Q;
•
Total number of times the nodes are extracted or dequeued from
the list Q.
Glossary of Terms
Acyclic graph - A graph that contains no cycles
Adjacent edges - Two distinct edges are said be adjacent if they have
at least one vertex in common
Adjacent vertices - Two distinct vertices are said be adjacent if there
is an edge connecting them
Algorithm - A step-by-step procedure for solving a problem or
accomplishing some task
Complete graph - A simple graph in which every pair of distinct
vertices are adjacent
Connectedness - Describes a graph in which for any given vertex in
the graph, all the other vertices are reachable from it
Cycle (or circuit) - A path that begins and terminates in the same
vertex
Degree of a vertex - The number of edges incident to a given vertex
Digraph (or directed graph) - A graph in which every edge is directed
Distance - The length of a minimum path length from one specific
vertex to another vertex.
Edge (or arc) - A connection made between two vertices in a graph
Elementary path - A path in which all the vertices are distinct
Elementary cycle - A cycle through a graph that does not visit any
vertex more than once
Graph - Consists of a set of vertices and a set of edges
Incident - An edge that joins two specified vertices is said to be
incident to them
Indegree - The number of edges terminating in a given node in a
directed graph
Isolated vertex - A vertex of degree zero (no edges going in or out of
it)
Length - The number of edges appearing in the sequence of a path
Loop (or sling) - Where an edge joins a vertex to itself
Minimum path length - The path of minimum length between two
vertices those are reachable from one another
Mixed graph - A graph that consists of both directed and undirected
edges
Multigraph - A graph with multiple edges between the same vertices
Null graph (or totally-disconnected graph) - A graph that contains
only isolated vertices (a graph with no edges)
Outdegree - The number of edges originating from a given vertex in a
directed graph
Parallel - Where there is more than a single edge connecting two
given vertices
Path - A sequence of edges that begins at an initial vertex and ends at
a terminal vertex
Reachability - Describes a relationship between two vertices in which
one vertex is reachable from the other via a path
Simple graph - A graph that contains no loops or parallel edges
Simple path - A path in a directed graph in which all the edges are
distinct
Strongly-connected - Describes the connectedness of a simple directed
graph in which, for any two vertices, both vertices are reachable from
the other
Subgraph - If every edge of graph A is also an edge of graph B, then
graph A is a subgraph of graph B
Terminal vertex (or endpoint) - A vertex of degree one
Total degree - The sum of the indegree and outdegree of a vertex
Transport network - A connected, directed graph (with no self loops)
that has only one vertex of indegree zero (the source), and one vertex
of outdegree zero (the sink). Each edge is associated to a number,
which represents the limit to the rate of transportation of the product
(called the capacity).
Tree - A connected graph in which there is only one path connecting
each pair of vertices
Undirected graph - A graph in which every edge is undirected
Unilaterally-connected - Describes the connectedness of a simple
directed graph in which, for any two vertices, at least one vertex is
reachable from the other of the pair
Vertex - A point or node in a graph
Weakly-connected - Describes the connectedness of a simple directed
graph in which the direction of the edges is disregarded
Weight - A number assigned to an edge
Weighted graph - A connected graph in which a positive real number
has been assigned to each edge
Conclusion
In this report we have reviewed various routing techniques both in
static and dynamic situation. Within this algorithmic framework, we
have proposed a specific approach that transforms known static SPT
algorithms to new dynamic ones. This incremental method gives rise
to the best practical or average running times.
References
[1] C. Baransel, W. Dobosiewicz, and P. Gburzynski, “Routing in
multihop packet switching networks: Gb/s challenge,” 1EEE
Network, vol. 9, pp. 38-61, May/June 1995.
[2] R. Bellman, “On a routing problem,” Q. Appl. Math., vol. 16, pp.
87-90, 1958.
[3] D.Bertsekas, Linear Network Optimization: Algorithms and
Codes, MA, Cambridge: MIT Press, 1991.
[4] L. Breslau and D. Estrin, “Design of inter-administrative domain
routing protocols,”in Proc. S1GCOMM’90, Sept., pp. 231-241.
[5] T. Cormen, C. Leiserson, and R. Rivest, Introduction to
Algorithms. Cambridge, MA: MIT Press, 1990.
[6] S. Deering and D. Cheriton, “Multicast routing in datagram
internet- works and extended LANs,” ACM Trans. Comput. Syst.,
vol. 8, no. 2, pp. 85-110, May 1990.
[7] E. Dijkstra, “A note two problems in connection with graphs,”
Numerical Math., vol. 1, pp. 269-271, 1959.
[8] E. Feuerstein and A. Marchetti-Spaccamela, “Dynamic algorithms
for shortest paths in planar graphs,” Theoretical Comput. Sci., vol.
116, pp. 359-371, 1993.
[9] P. Franciosa, D. Frigioni, and R. Giaccio, “Semi-dynamic shortest
paths and breadth-first search in digraph,” in Proc. 14th Annu. Symp.
Theoretical Aspects of Computer Science, Mar. 1997, pp. 33-46.
[10] D. Frigioni, A. Marchetti-Spaccamela, and U. Nanni, “Fully
dynamic output bounded single source shortest path problem,” in
Proc. 7th Annu. ACM-SIAM Symp. Discrete Algorithms, Atlanta, GA,
1998, pp. 212-221.
[11] “Incremental algorithms for single-source shortest path trees,” in
Proc. Foundations of Software Technology and Theoretical Computer
Science, Dec. 1994, pp. 113-124.
[12] J.J. Garcia-Luna-Aceves and S. Murthy, “A path finding
algorithm for loop-free routing,” 1EEE/ACM Trans. Networking, pp.
148-160, Feb. 1997.
[13] C. Huitema, Routing in the lnternet. Englewood Cliffs, NJ:
Prentice- Hall, 1995.