Multi-Path Dynamic Algorithm for SPT Calculation and
Its Performance Evaluation.
Miss Punam S Karadge
Department of Electronics & telecommunication,
D Y Patil college of Engg & Technology, Kolhapur.
Mr. A. A. Dum.
Department of Electronics Technology,
Shivaji University, Kolhapur.
ABSTRACT
This paper analyzes intra-domain routing
protocols improvements to support new features
required by real-time services. The Open Shortest
Path First (OSPF) and IS-IS routing protocols are
intra-domain routing protocol widely used in
today’s Internet. To compute a shortest path tree
(SPT) from each router to other routers in a
routing area above protocol most of time uses
Dijkstra algorithm. Many existing commercial
routers recomputed an SPT from scratch, due to
changes happened in the state of link in the
network. Such re-computation of an entire SPT is
inefficient and may consume a considerable
amount of CPU time. Moreover, as there may co-
exist multiple SPTs in a network with a set of
given link states, re-computation from scratch
causes frequent unnecessary changes in the
topology of an existing SPT and may lead to
routing instability. For that presented a new multi-
path dynamic algorithm which uses multipath
information and the structure of the previously
computed SPT to make a fast determination about
the new shortest paths when a link failure occurs,
reducing this way the network re-convergence
time. In particular paper introduces Open Shortest
Path Fist (OSPF) with Fast Convergence and
highlights the advantage of using a dynamic
algorithm instead of the static Dijkstra one to
compute the shortest paths. Objective of proposed
Multi path Dynamic Routing Algorithm is not only
efficiency of algorithm but this algorithm design
objective is to achieve routing stability by making
minimum changes to the topology of an existing
SPT when only some link states in the network
have changed.
Keywords: Open Shortest Path First (OSPF),
SPT, Dynamic algorithm, network stability.
1. Introduction
OPEN Shortest Path First (OSPF) [1]
and Intermediate System-to Intermediate
1
Mr. Md S Alam
Department of Electronics Technology,
Shivaji University, Kolhapur.
Mr. Anil Mohite
Department of Electronics Technology,
Shivaji University, Kolhapur.
System (IS-IS) [2] are the most used intra-
Autonomous System (AS) routing protocols in
today’s Internet. They are link-state protocols
and use the well know Dijkstra algorithm to
construct the router routing table. Their
performance can be characterized by the
convergence time, which represents the time
for a network to reconfigure itself when a
topological event happens. The convergence
time is influenced by three different phases
performed by routing protocols: detection,
flooding and Shortest Path First (SPF)
computation. The detection phase consists in
an identification of a topological change and,
if no hardware detection mechanism is
provided, depends upon a Hello messages
exchange between routers. The propagation
phase consists of an exchange of Update
messages between the router that discovers
the modification and every other network
router, through flooding mechanism; the SPF
computation is the phase in which the
shortest paths to all destinations are
evaluated using the Dijkstra algorithm. In the
last years there has been a great interest in
realtime services as VoIP and distributed
gaming. The delay and jitter constraints
make impossible the use of the TCP protocol
to reduce the packet loss for these services
when a node and/or a link failure occurs [3].
For this reason the network convergence time
must be reduced so that fewer data packets
are lost.
In particular convergence time has to
be significantly reduced from the actual 40-
50 seconds to 100-200 ms. As described in
[4]–[7] to obtain low failure and restoration
times, OSPF optimizations must be
supported. The network convergence time
may be accelerated by improving the
following OSPF procedures: i) hardware
detection of failures: a router promptly
detects failures and immediately informs
OSPF protocol about it; ii) higher rate of the
hello packets so that link failure in networks
interconnecting the routers may be
immediately detected; iii) faster
announcement of failures throughout the
network: once a failure has been quickly
discovered, a new LSA packet describing
topological modification is created and
flooded across the network; the flooding may
be optimized to limit the process to less than
a few milliseconds; iv) reduction of the OSPF
timers to a few milliseconds; the stability is
not compromised because an exponential
back-off timer mechanism is introduced to
control how fast the router reacts to a specific
event. Initially, the timers are set to a few
milliseconds so that the reaction is almost
immediate, but if events occur too often, the
timers are increased to preserve stability: v)
accelerated computation of the new shortest
paths: upon failure notification, all routers
must run the Dijkstra algorithm on the entire
topology to compute the shortest paths; a
dynamic algorithm [8]–[11] may be used to
reduce the SPF computation time, instead of
the Dijkstra one. Most dynamic routing
algorithms proposed in literature do not
support multi-path and hence they are not
able to determine all of the shortest paths
between source and destination. Only one of
these paths is computed. Dynamic routing
algorithms are not suitable to be adopted in
OSPF routing protocol because that needs
Equal Cost Multi-path Path (ECMP) support
[12], which is the computation of all paths of
minimum cost from a source to a destination;
ECMP allows routers to perform packet
forwarding through a larger number of
minimum equal cost paths. Today ECMP is
considered an important feature because
allows higher network reliability. In fact, due
to multi-path support, the network may
forward packets on alternative paths when a
link failure occurs. Multi-path support also
allows to customize paths for different
applications [13] and to improve TCP
performance: in particular the works in [14]–
[16] demonstrate that transport-layer
performance can be increased by some TCP
modifications, performed to support path
diversity.
2
In this paper we propose a new
dynamic routing algorithm that supports
multi-path. It uses multi-path information to
quickly calculate the new shortest paths
when a link failure occurs. To evaluate the
introduced algorithm performance, we
implemented it on one of the open source
routing software. The performance evaluation
is performed measuring the SPF computation
time index of an OSPF router [18]. The two
measurement types allowed us to compare
the proposed multi-path dynamic algorithm
performance to one of the dynamic algorithm
proposed in [19] and then to one of the most
important uni-path dynamic algorithm
proposed in literature [10].
2. DYNAMIC ALGORITHM
 Motivations
The key element of a link-state
routing protocol is an algorithm that
evaluates the shortest paths from a source to
all destinations. Actual intra AS routing
protocols, such as OSPF and IS-IS, make use
of Dijkstra algorithm: when a topological
change happen, all the Shortest Paths (SP)
are calculated from scratch and not using the
old shortest paths information. The SP
computation, performed by Dijkstra
algorithm, is the hardest operation for a
router, because the entire CPU is used, and it
is also the most problematic. In fact when a
topological change occurs and SP
computation procedure is executing, the used
routing table does not reflect the real network
topology. In this way data packets can pass
through sub-optimal paths or even through
paths that are not available any more, hence
they can be lost, degrading the network
performance.
This scenario can happen whenever
there is a link failure, which represents the
most dangerous event for a network. In the
last years some studies has been done to
characterize the evolution of a network
topology, analyzing routing protocols
messages and SP successions. In particular
the work presented in [21], where an
Internet Service Provider (ISP) has been
analyzed for a year, demonstrates as 65% of
SP computations produces the same SP that
was used before the topological event and in
the other cases the SP calculated is really
similar to the last one. These results highlight
that Dijkstra algorithm is inefficient in a real
scenario where only few operations have to
be done to calculate new SP instead of a full
computation. These motivations have led to
the introduction of a new class of algorithms
for the computation of the shortest paths, the
dynamic ones [8]–[11]. They make use of
the previous SP to calculate the new one, re-
computing only the shortest paths influenced
by the topological event. In this way dynamic
algorithms meet real network requirements:
computing resources are saved, best paths
are available first, and therefore network
convergence time can be highly reduced.
 Dynamic algorithms in a routers. These last elements represent the
networking scenario
Dynamic algorithms described before
cannot be directly used in a routing protocol
because in a real networking scenario they
have to satisfy specific requirements. First of
all a dynamic algorithm has to be developed
to react to the most common events in a
network. As discussed in [21] link failure and
restoration are the most frequent topological
changes, while link metric modifications are
quite rare. A deeper analysis, presented in
[22], demonstrates that 70% of unplanned
events involve single links. We can conclude
that failure and restoration of a single edge
have to be events the algorithms react to. In
this way algorithms proposed previously
cannot be used as they have been presented,
they must be modified in a way that failure
and restoration events can be considered. A
really important characteristic that a routing
protocol algorithm must have is multi-path
support. OSPF protocol needs ECMP support,
which represents the possibility for routers to
split, through a per-flow or a per-packet
differentiation, packets directed to the same
destination among minimum equal cost paths
[12]. In fact, due to multi-path support, the
network may forward packets on alternative
paths when a link failure occurs. Motivations
for flexible multi-path routing are reported in
[13]. The main advantages are:
• To customize to application performance
requirements:
Different applications have different needs. If
multiple paths exists VoIP traffic can use a
low-delay path, while data traffic uses a high-
3
throughput path. In addition, an application
can access more bandwidth by using multiple
paths simultaneously.
• To improve end-to-end reliability:
If multiple paths exist, traffic can switch
quickly to an alternate path when either a
link or a router fails.
• To avoid congested paths:
When multiple paths are available, traffic can
move an alternate path to circumvent
congestion.
Multi-path is a feature of the static
Dijkstra algorithm while it is not supported by
the previous algorithms. Another aspect to be
considered is that the algorithm has to
maintain information needed to update the
routing table, for example the next-hop
first routers in the paths from root to
destination node and they are just the next-
hop routers to be inserted in the routing
table. The weak point of the algorithm
discussed in [8] is that for each node it
maintains only distance and out-degree
information, and not the useful information to
calculate the sequence of nodes representing
the shortest paths from root to every
topology node. After a new SP computation
has been performed, information about next
hop routers must be stored in the routing
table for each computed shortest path. This
operation may be executed in low
computation time only if the SP data
structure is defined so to allow a fast next-
hop router computation for each shortest
path. Finally, a dynamic algorithm suitable
for a networking scenario has to react to
single edge deletion and insertion, to support
multi-path and to create specific data
structures. In the next section we propose a
new dynamic routing algorithm. Its
advantage is twofold: to support multi-path
and to exploit multi-path information in order
to make fast the determination of the new
shortest paths when a link failure occurs,
reducing the network convergence time.
3. MULTI-PATH DYNAMIC ALGORITHM
In this section we introduce our multi-
path dynamic algorithm and show its
behaviour in a link failure scenario. Our
algorithm is a dynamic version of Dijkstra
static algorithm which reacts to single link
deletion and insertion; its relevant
characteristic is the way it makes use of
multi-path information to speed up SP
computation. Before describing our algorithm
we have to introduce some notations used in
network graphs.
 Terminology required
Let G (V, E) denote a weighted
directed graph where V is the set of nodes
and E is the set of edges. The data structure
representing the graph G (V, E) is an
adjacency list. Let r (G) denotes the root
node of G. For each directed edge e ∈ E, let S
(e), E (e) and w (e) denote respectively its
source node, its end node and its weight. A
path from a node x to a node y is a sequence
of edges connecting x with y; a cost equal to
the sum of the paths edges weights is
associated to each path in the graph. The
Shortest Path SP (G) is the set of all shortest
paths from r (G) to other nodes of the graph
and it is unique. Because we take into
account the multi-path, there are more
minimum cost paths from r (G) to a node w
in SP (G). SP (G) is represented by
introducing three attributes for each node v ∈
V: P (v), C (v) and d (v). P (v) is the set of
parents of v (a node p is a parent of node v if
S (e) = p, E (e) = v and e ∈ SP (G)), C (v) is
the set of v’s children (a node c is a child of
node v if S (e) = v, E (e) = c and e ∈ SP (G)),
d (v) is v’s distance. Moreover an extra
attribute is needed for each node, NH (v), the
set of next-hops for v (a node p is a next-hop
for v if there is a path in SP (G) from r (G) to
v, for which p is the first node after r (G). We
need to introduce the attribute NH (v) of a
node v because in an Internet routing
protocol a root node, in order to update its
routing table, needs to know, for every path
to v, which one is the first node to reach v.
NH(v) can be easily calculated from the next-
hop attribute of all parents of v, so if P(v) =
{p1, ......., pn} then NH(v) = ∪p∈P(v)NH(p)
= NH(p1) ∪ .....∪ NH (pn). The NH(v)
attribute needs to be recalculated even if,
after a topology change, v does not change
any other attribute but a node of which v is a
descendent has changed its parents attribute.
During algorithm execution it will be
useful to be able to easily detect the
descendents of a particular node (a node p is
4
a descendent of node v if a path in SP (G)
exists, in which the node v precedes the node
p), so that the set D (v) is introduced. D (v)
is computed at the beginning of the algorithm
whenever an insertion/deletion procedure
begins, or every time a node is extracted
from the candidate list Q in main procedure.
For this reason D (v) updating is not needed
but re-computation is performed during the
execution of the algorithm. D (v) is
represented by means of a linked list. As it
will be clear later on, the algorithm correctly
works if descendents of v are stored in D (v)
so that any element appears before any of its
children. This operation can be accomplished
in two steps at O (|D(v)|max) computation
cost, |D(v)|max being the maximum
cardinality of the set D(v). In the first step all
of the children of v are inserted. Afterwards,
children of the v’s children are inserted and
so on.
The algorithm uses two sets of edges:
I (D(v)), all edges incoming into the set of
descendents of v, and O(D(v)), all edges
outgoing from the set of descendents of v.
The sets I(D(v)) and O(D(v)) are not stored,
they are computed every time they need.
Those links may be easily evaluated because
it is only needed to scan the elements in D
(v) and for each of them the incoming and
outgoing links are immediately determined by
the adjacency list representing the network
graph G (V, E). The algorithm maintains a
data structure, the candidate list Q, that
contains nodes whose attributes must be
updated. An element in Q is the triple (v,P,
dnew), where v is the node to be updated, P
is the new set of parents and dnew is the new
distance of v. Two operations can be
performed on Q: EXTRACT and ENQUEUE.
The first one extracts from Q the element
with the smallest dnew field.
 Algorithm description
The dynamic algorithm is divided in
two phases: the initialization phase, in which
all nodes directly affected by deletion or
insertion of edge are updated, and the main
phase, in which candidate heap nodes are
dequeued and inserted in SP (G). The formal
description of the algorithm is reported
below.
The initialization phase is different for
edge deletion and insertion. Let us start
describing the initialization phase when an
edge e insertion happens, denoting E (e) = v
and S (e) = p. First it is checked, step-1, if
the path containing e as its last edge is a
shortest one: if the path has a cost higher
than d (v) the algorithm stops, because the
insertion of the edge e does not allow any
shorter path to be found. If the cost of the
new path is equal to d(v), step-2, the new
path has to be added to previous shortest
paths of node v so that just the parent-child
relationship between p and v has changed,
adding p to the set of parents of v and v to
the set of children of p. Then for every
descendent of v the next-hop attribute is
recalculated. If new path cost is smaller than
d(v), step-3, the new path is the only
shortest path of node v and all v attributes
are changed: d(v) is now equal to new path
cost, p is the only parent of v and NH (v) is
equal to NH (p). Moreover v is added to the
set of children of p and it is deleted from the
old sets of its parents’ children. Then v
descendents distances are updated and they
are marked using the marv() attribute. These
way parent-child relationships between
descendents of v and node that are external
to D (v) are modified. In this scenario every
descendent of v has in its set of parents only
v descendents nodes, in other words nodes
belonging to D (v) are reachable only through
v and so their next-hop attribute is the same
of the v’s one. Finally all the edges outgoing
to v and D (v) arescanned, in order to find
new possible shortest paths for nodes that
are external to D(v). The flow charts of the
insertion are illustrated in Fig. 1.
Now we describe the initialization
phase (figure 2) of our algorithm when an
edge deletion happens. The first thing to do
is to check if edge e belongs to SP (G). If it is
not, the algorithm stops because the edge
deletion does not change SP (G). If e is an SP
(G) edge, some preliminary steps are
performed: p is deleted from the set of
parents of v and v from the set of children of
p. So we checked if other paths of minimum
cost exist, evaluating P (v). If other minimum
cost paths are found, step-2, the algorithm
uses this multi-path information to easily re-
compute SP (G): the only change is in the
nexthop attribute for v and all its
descendents.
Figure 1: flow charts of initialization
phase when edge insertion happens
If no other paths of minimum cost are
found, step 3, the algorithm tries to reduce
the number of affected nodes using the
multi-path information. First v passes in an
unreachable state: its distance is set to
infinite, sets of parents, children and next-
hop are set to empty and the marv()
attribute of its descendents is set to 1. For
every descendent of v the set of parents is
evaluated, in order to find possible multi-path
not involving edge e. If at least one external
path is found, the descendent is deleted from
the set D (v), its marv() attribute is set to 0,
its set of parents is ”reduced” with the only
external parents and next-hop attribute is
updated. If there are no external paths, the
descendent is put in an unreachable state
without deleting its set of parents and it
continues to belong to D (v), adding it to the
sets of children of its parents, composed by
only ”internal” nodes. In this way the set of v
descendents, for which the old parent-child
relationships are maintained, is reduced to a
subset of nodes that has to increase their
distance, while nodes with external multi-
paths are quickly updated. Finally all edges
incoming into v and D (v) are scanned to find
new shortest paths for node that are internal
to D (v). Notice that the distance of these
nodes has been set to infinite.

5
 Figure 3: flow charts of main phase

Figure 2: Figure 1: flow charts of

initialization phase when edge deletion  Example of edge deletion
happens We can explain with an example
referring to a simple network how our
The last part (Figure 3) of the dynamic algorithm works. Figure 4 shows a
algorithm is Q elements extraction and network graph, where each link is
handling. If Q is not empty its”best” element bidirectional and weighted: for simplicity the
(v, P, dnew) is extracted and a check to two edges of the same bidirectional link have
determine if dnew is either smaller than v the same cost. The solid thick arrows are all
distance or the two distances are equal is the SP (G) edges while the thin dashed ones
performed. In the first case, step-1, new do not belong to SP (G). Let us suppose that
paths have to be considered so the algorithm the edge from node p to node v fails.
only adds P to P(v), v to the sets of children
of new parents and it recalculates next-hop
attribute for v and its descendents. In the
other case, step-2, new paths are the better
ones so v distance and relationship between
v and its parents are changed: P is the new
set of parents of v, v is deleted from the sets
of children of old parents and it is added to
the sets of children of new parents, next-hop
attribute is recalculated.
The same operations are performed
for every descendent of v, deleting parent-
child relationship between it and nodes that
are external to D (v). Finally, step-3, all
possible new shortest paths for external Figure 4: Network graph with subset
nodes are evaluated. of edges and their cost

In the initialization phase of the

dynamic algorithm it is first checked if the
deleted edge belongs to SP (G) and then all

6
nodes affected by failure are checked: this
set of nodes is represented in Figure 5 by the
dashed curve. The algorithm has to evaluate
the set of parents of v to find possible multi-
paths: the only parent of v is p so v is
unreachable and its attributes are changed (d
(v) = ∞, P (v) = {φ}, NH (v) = {φ}).The
search for external multi-path is performed
for all descendents of v, scanned in an
ordered way. For node l there are no external
multi-paths while there is one for node i, with
e as a parent: i is deleted from D (v), its set
of parents now contains the only node e and
its distance remains 40. The SP (G) at this
time is represented in Figure 6. Scanning the
descendents of v, the algorithm finds an
external equal cost path for node t too. It has
got two parents: l, a v descendent, and i, just
removed from D (v).
Figure 5: Set of affected nodes after edge
detection
Figure 6: During initialization phase (a)
So t is in turn removed from D (v), its
distance is not changed and its set of parents
7
contains the only node i. The last descendent
of v is s and for it there are no external
multi-paths so it is set to an unreachable
state. The unreachable nodes maintain their
parent-child relationships (C (v) = l, P (l) =
v, C (l) = s, P(s) = l).
Figure 7: During initialization phase (b)
After initialization phase the algorithm
produces the SP (G) represented in Figure 7.
The last thing to do in the initialization phase
is to find new shortest paths for affected
nodes, through nodes that are external to
D(v). In particular all external incoming
edges must be evaluated. In this case the
best path for node v has got a as a parent
and a cost equal to 35, so that the element
(v, a, 35) is enqueued in Q. For node l the
best path has got t as a parent and a cost
equal to 70, (l, t, 70) is enqueued in Q. For
node s the best path has got q as a parent
and a cost equal to 65, (s, q, 65) is enqueued
in Q. Notice as during the initialization phase
the set of affected nodes has been reduced
from five to three elements, using multi-path
information.
In the main phase of the algorithm,
the first element extracted from Q is v: its
new possible distance (35) is obviously better
than the actual one (infinite) so all its
attributes, except for the set of children, are
changed (d (v) = 35, P (v) = a, NH (v) =
{p}); node v will certainly not be modified
during the last part of the algorithm, as
explained in the correctness analysis. All
descendents of v have to be updated, so d (l)
= 45, NH (l) = p, d(s) = 65 and NH(s) = p.

Figure 8: Final SP (G)
The second element extracted is s: its
new possible distance is equal to its distance,
up-dated in the first step, so the algorithm
simply stores this new equal cost path adding
q to P(s) and z to NH(s). Considering equal
cost multi-path, the router r can reach the
node s through two different next-hop
routers, balancing the traffic. The last
element extracted from Q is l but its new
possible distance is bigger than the present
one, so nothing has to be done. The
candidate heap is empty and the algorithm
stops. Final SP (G) is represented in Figure 8.
4. PERFORMANCE EVALUATION
Evaluation of the algorithm behavior is
done in a real environment, implementing it
in a routing protocol, OSPF, and measuring
protocol performance indexes in different
topology scenarios. To implement dynamic
algorithm a routing software with an open
code (Open-source routing software), Quagga
is used. Quagga is designed for Unix
operating systems (Linux, BSD and Solaris)
and it provides TCP/IP based routing
protocols, including OSPF, RIP and BGP. The
most interesting aspect of open-source
routing software is its flexibility that allows
for evaluation of new routing features, such
as our algorithm. Implemented dynamic
algorithm in the OSPF code of the Quagga
software that every time an edge deletion or
insertion happens, dynamic algorithm,
instead of Dijkstra one, is performed. OSPF
performance indexes and methodologies for
their evaluation have been defined by IETF
RFCs [23]–[25]. The most interesting
performance index to characterize our
8
algorithm is SPF computation time [26] time
needed for a router to complete SPF
computation.
Figure 9: Performance comparison of the
dynamic algorithm implemented in Cisco
2801 and Quagga in the case of link failure
Observing Figure 9 you can notice that
the dynamic algorithm is more efficient than
the Dijkstra one, in both Cisco 2801 and
Quagga. In fact the average SPF computation
time for dynamic algorithm is 9.5 ms and 0.9
ms for Cisco 2801 and Quagga respectively
while for Dijkstra algorithm is 34 ms and 9
ms respectively. Hence the dynamic
algorithm in Quagga allows for 8 ms
reduction in the SPF computation time. That
means avoiding to loose 80 millions bit in the
case of a 10 Gbit/s link, if a link failure
happens.
We compare in Figure 13 for Verio
topology our multi-path dynamic algorithm to
that proposed by Ramalingam-Reps [8]. To
the best knowledge of the authors, this
algorithm is the only one supporting the
multi-path. From Figure 13 we can notice
that the Ramalingam-Reps algorithm
performs much worse than our algorithm, in
particular the SPF computation time is eight
times higher for the worst cases. Before
analyzing results we must highlight that
implementation of the Ramalingam- Reps
algorithm inside a routing protocol has been
really hard because of aspects discussed in
Section II-C. First of all SP(G) is implemented
[8] by means of an adjacency list. The most
delicate issue is next-hop computation
because the Ramalingam-Reps algorithm
does not make use of a nexthop attribute for
each node; in this way it is not possible to
compute next-hop routers of a node as the
union of the sets of next-hop routers of its
parents.
Fig. 13. Performance comparison of the
Ramalingam-Reps and praposed dynamic
algorithm in the case of link failure
The only way to compute the next-hop
routers of a node is to use adjacency list
representing SP(G): in particular for each
shortest path of the node all its predecessors
in SP(G) need to be scanned until the next-
hop router is reached. This operation, which
has to be performed each time a vertex is
updated during dynamic algorithm, involving
so only affected nodes, is much more
complex than next-hop computation in our
algorithm and depends heavily on the
number of shortest paths of a node: in fact
for each shortest path the SP(G) has to be
crossed back to detect its next-hop router. It
is clear that such a procedure is not really
efficient, especially when a lot of nodes are
involved by topological modification and a lot
of minimum equal cost multi-paths exist, as
shown in Figure 13.
We can summarize that the bad
performance of the Ramalingam-Reps
algorithm is due to the fact that the
objective of the algorithm is to evaluate in an
optimized way the new node distance when
deletion and insertion of an edge occur. To
support a routing protocol instead, the
routing algorithm must be able to evaluate in
an optimized way both new node distance
and next-hop nodes. Finally we have
analyzed our algorithm performance when
the link costs are not equal.
9
4. Conclusion
Many existing commercial routers uses
static Dijastra algorithm to recompute an SPT
from scratch, due to changes happened in the
state of link in the network. Such re-
computation of an entire SPT is inefficient
and may consume a considerable amount of
CPU time. Static Dijkstra algorithm is
inefficient in a real scenario where only few
operations have to be done to calculate new
SP instead of a full computation. As a
solution, this paper introduces a new class of
algorithms called Multipath dynamic
algorithm for the computation of the shortest
paths that dynamic ones. They make use of
the previous SP to calculate the new one, re-
computing only the shortest paths influenced
by the topological event. Along with that it
takes advantage of multipath information
which offers alternative path for data when
one link failure occurs in network.
Finally we evaluated the performance
of a new multipath dynamic shortest path
algorithm which supports multi-path and
exploits multi-path information to allow lower
network convergence time with respect to a
uni-path algorithm. The algorithm
performance has been compared to the
performance of two different algorithms: the
first one proposed by Cisco, the second one,
of uni-path type, proposed in [11]. Praposed
algorithm has been also compared to the
algorithm in [8], the dynamic algorithm
supporting multi-path. The obtained results,
proposed algorithm performs better in all
case studies, especially in a link failure
scenario.
References
[1] J. Moy, “OSPF Version 2,” Request for
Comments 2328, Apr. 1998.
[2] R. Callon, “Use of OSI IS-IS for routing in
TCP/IP & dual environment,” RFC 1195,Dec. 1990.
[3] C. Boutremans, G. Iannaccone, and C. Diot,
“Impact of link failures on VoIP performance,” in
Proc. ACM NOSSDAV, May 2002, pp. 63-71.
[4] C. Alaettinoglu, V. Jacobson, and H. Yu,
“Towards milli-second IGP convergence,” IETF
Internet Draft, Nov. 2000.
[5] A. Basu and J. G. Riecke, “Stability issues in
OSPF routing,” in Proc. ACM Sigcomm, Aug. 2001.
[6] P. Francois, and O. Bonaventure, “Achieving
subsecond IGP convergence in large IP networks,”
SIGCOMM Comput. Commun. vol. 35, July 2005.
[7] C. Filsfils, “Calculating new routes faster,” [25] V. Manral, R. White, and A. Shaikh,
Packet Magazine, vol. 16,Third Quarter 2004. “Consideration when using basic OSPF
[8] G. Ramalingam and T. Reps, “On the convergence benchmarks,” RFC 4063, Apr. 2005.
computational complexity of dynamic graph [26] V. Eramo, E. Cipollone, “Performance and
problems,” Theoretical Computer Science, vol. flexibility of open source routing software,” in
158, no. 1-2, May 1996, pp. 233277. Proc. NTMS May 2007.
[9] D. Frigioni, U. Nanni, “Fully dynamic
algorithms for maintaining shortest paths trees,”
Journal of Algorithms, vol. 34, no. 2, Feb. 2000.
[10] P. Narvaez, K.-Y. Siu, and H.-Y. Tzeng, “New
dynamic algorithms for SPT computation,” IEEE
Trans. Networking, vol. 8, Dec. 2000.
[11] P. Narvaez, K.-Y. Siu, and H.-Y. Tzeng, “New
dynamic SPT algorithm based on a ball-and-string
model,” IEEE Trans. Networking, vol. 9, no. 2,
Dec. 2001, pp. 706-718.
[12] D. Thaler and C. Hopps, “Multipath issues in
unicast and multicast next-hop selection,” RFC
2991, Nov. 2000.
[13] J. He and J. Rexford, “Toward Internet-wide
multipath routing,” IEEE Network, vol. 22, no. 2,
Mar./Apr. 2008, pp. 16-21.
[14] H. Han, S. Shakkottai, C. V. Hollot, R.
Srikant, and D. Towsley, “Multipath TCP: a joint
congestion control and routing scheme to exploit
path diversity in the Internet,” IEEE/ACM
Transactions on Networking, vol. 14, Dec. 2006.
[15] Y. Lee, I. Park, and Y. Choi, “Improving TCP
performance in multipath packet forwarding
networks,” J. Commun. and Networks, June 2002.
[16] P. Key, L. Massoulie, and D. Towsley,
“Combining multipath routing and congestion
control for robustness,” in Proc. CISS Mar. 2006.
[17]Quagga [Online] Available www.quagga.net.
[18] V. Eramo, M. Listanti, and A. Cianfrani, “OSPF
performance and optimization of open source
routing software,” International J. Computer
Science and Applications, vol. 4, no. 1, June 2007.
[19] Cisco System Inc., http://www.cisco.com.
[20] D. Frigioni, and G. Pasqualone, “Experimental
analysis of dynamic algorithms for the single
source shortest path problem,” ACM J.
Experimental Algorithms, vol. 3, no. 5, 1998.
[21] D. Watson, F. Jahanian, and C. Labovitz,
“Experiences with monitoring OSPF on a regional
service provider network,” in Proc. ICDCS 2003,
May 2003.
[22] A. Markopoulou, G. Iannaccone, S.
Bhattacharyya, C. N. Chuah, and C. Diot,
“Characterization of failures in an IP backbone,” in
Proc. IEEE Infocom 2004, vol. 4, Mar. 2004.
[23] V. Manral, R. White, and A. Shaikh,
“Benchmarking basic OSPF single router control
plane convergence,” RFC 4061, Apr. 2005.
[24] V. Manral, R. White, and A. Shaikh, “OSPF
benchmarking terminology and concepts,” RFC
4062, Apr. 2005.

10