Implementation and Performance Evaluation of a Multi-Path Incremental Shortest Path Algorithm in Quagga Routing Software V. Eramo, M. Listanti, A. Cianfrani University of Roma “La Sapienza”, INFOCOM Dept. Via Eudossiana 18, 00184 Roma-Italy e-mail:
[email protected] Abstract— In this paper a multi-path incremental shortest path algorithm has been proposed allowing a quick reconfiguration of a routing table when a network topological change occurs. After evaluating the algorithm complexity, we have implemented it in Quagga, one of the most popular open source routing software. In order to evaluate the algorithm performance, we have realized a test-bed allowing the shortest path computation time to be calculated for any network. The results obtained show that the algorithm allows the shortest path computation time to be reduced of about the 97% with respect to the case in which the classical Dijkstra’s algorithm is adopted. Keywords: Dijkstra’s algorithm, Multi-path Incremental Shortest Path, Open Source Code, Quagga Routing Software, OSPF.
I.
INTRODUCTION
OSPF [1] and IS-IS [2] are the most used intra AS (Autonomous System) routing protocols in today Internet; they use the well-know Djikstra algorithm to compute shortest paths to all AS destinations (SPT: Shortest Path Tree) and so to construct router routing table. SPT is a tree having as root the router calculating Djikstra algorithm and as nodes other routers and networks of AS. This algorithm is inefficient in today Internet because of the growth of new real-time services, such as VoIP; these services require high performance in term of delay and jitter and so when a topological change happens the routing protocols have to ensure a quick reconfiguration of routing tables. Djikstra algorithm recomputes all SPT after a topological modification not using old SPT information; in reality consecutive SPTs are often equal or really similar as demonstrated in [3]: in this way there are unnecessary resources use and performance decreasing. It is really important to use an incremental algorithm that re-computes the only part of SPT influenced by topological changes: computing resources are saved and new best paths are available first. In the past years, incremental algorithms [4-8] for the single-source shortest path problem have been presented. In [4] Ramalingam and Reps introduce the output complexity model, in which the cost of a dynamic algorithm is evaluated as a function of the number of output updates determined by each input modification; the algorithm they propose maintain for each node of the SPT distance and outdegree attributes, but not the information to evaluate the sequence of nodes representing
This work has been partially supported by the Italian Research Ministry under the PRIN BORA-BORA grant.
the shortest paths from root to each node. In [5] Frigioni et al. propose a dynamic algorithm which maintain for each node a parent and a set of children attributes besides distance one but does not support multi-path. In [6,7] Narvaez et al. propose two different dynamic algorithms, the first is a Djikstra modification and the second one is based on a Ball-and-string model; these algorithms reacts to edge weight modifications and do not support multi-path aspect. In this paper we present an incremental algorithm that supports multi-path and reacts to link deletion and insertion; the multi-path support allows to calculate all possible shortest paths to each destination, so routers can perform load balancing for some destinations through paths of minimum equal cost; the decision of react to link deletion and insertion depends on real behaviour of an intra AS routing protocol, in which link failure and insertion are the most common events, as mentioned in [3]. To evaluate the performance of the algorithm proposed, we have implemented it in Quagga, one of the most popular open source routing software. A test-bed has been realized and the shortest path computation time of the proposed algorithm has been evaluated as a function of the main parameters of an emulated network. The obtained results have been compared to the ones taken on a CISCO commercial router. The paper is organized into four sections. An example of the proposed algorithm in a link failure scenario is described in Section 2. The test methodology to evaluate the performance of the incremental algorithm, implemented on the Quagga open source routing software, is illustrated in Section 3. The main numerical results showing the performance of the incremental algorithm are illustrated in Section 4. The conclusions and further research items are illustrated in Section 5. II.
MULTIPATH INCREMENTAL SHORTEST PATH ALGORITHM
In this section we introduce our multi-path incremental algorithm and show its behaviour in a link failure scenario. Our algorithm is a dynamic version of Djikstra static algorithm which react to single link deletion and insertion; its relevant characteristic is how it make use of multi-path information to speed up SPT computation. The algorithm is composed by an initialization phase, different for link deletion and insertion, and a main phase.
Initialization phase in case of link insertion and main phase are modified versions of the same phases presented in [7,8]: they have been modified to support multi-path and new data structures our algorithm uses. The initialization phase in case of link deletion is really innovative because allows to minimize number of nodes affected by link deletion thanks to multipath information.
15 10
q 10
25
10
i
10
5
10
h
l
15
f 10
25
10
e
25
20
d
5
10
10 20
w
v
10
a)
20
15
c
5
b
10
a
10
30
30 20
10 30
20
p z x
10 10 10
r
w
s 15
t
10
n
q 10
20
20
20
10 10
25
10
i
10 10
h
15
f
10
e
25
20
d
5
10
l
25 5
10
10
20
b)
g 10
20
v
15
c
5
b
10
a
10
30
30 20
10 20
Figure 1(a) shows a network graph, where each link is bidirectional and weighted: for simplicity the two edges of the same bidirectional link have the same cost. The solid thick arrows are all the SPT links while the thin dashed ones do not belong to SPT.
p z x
10 10 10
r
w
s 15
t
10
n
q 10
20
20
20
10 10
Let us suppose that link from node p to node v fails. In the initialization phase of the incremental algorithm it is first checked if link deleted belongs to SPT, otherwise the algorithm stops, and then all nodes affected by failure are checked: this set of nodes is represented in Figure 1(b) with the dashed curve and contains all v descendents D(v), nodes belonging to sub-tree having v as root.
The last thing to do in the initialization phase is to find new shortest paths for node affected, through nodes external to D(v). In particular all external incoming edges have to be evaluated.
20
20
20
10 10
Before describing the example, we have to introduce some notations regarding a network graph, in particular data structures used to maintain SPT information on each node. A node v has different attributes: P(v) is the set of v parents, C(v) is the set of v children , D(v) is the set of v descendents, d(v) is v distance and NH(v) is the set of v next-hops. The algorithm also 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 v distance.
The algorithm has to evaluate v set of parents to find possible multi-paths: in fact if v has other parents and so other paths of minimum cost, the algorithm only has to remove the deleted path for v and recomputed next-hop attribute for all its descendents. In this case the only parent of v is p so v is unreachable. The search of external multi-path is performed for all v descendents, scanned in an ordered way. For node l there are not external multi-paths while for node i there is an external multi-path, with e as parent: i is deleted from D(v), its set of parents now contains the only node e and its distance remains 40. The SPT at this time is represented in Figure 1(c). Scanning v descendents, the algorithm find an external equal cost path for node t too. It has two parent: l, a v descendent, and i, just removed from set of v descendents. So t is in turn removed from D(v), its distance is not changed and its set of parents contains the only node i. The last v descendents is s and for it there are not external multi-path 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). After initialization phase the algorithm produces the SPT represented in Figure 1(d).
g
s t n
25
10
i
10 10
h
15
f
10
e
25
20
d
5
10
l
25 5
10
10
20
v
10
c)
g
20
15
c
a
30
30 20
10 30
5
b
10
20
p z x
10 10 10
r
w
s 15 10
t n
q 10
20
20
20
10 10
25
10
i
10 10
f
10
e
h
15
25
20
d
5
10
l
25
10
5
10
20
v
10
20
15
c
d)
g
a
30
30 20
10 30
5
b
10
20
p z x
10 10 10
r
w
s 15 10
t n
q 10
20
20
20
10 10
25
10
i
10 10
f
10
e
h
15
25
20
d
5
10
l
25
10
5
10
20
v
10
e)
g
20
15
c
b
10
a
5 30
30 10
30
20
p z x
10 10 10
r
Figure 1. Example of edge deletion. a) Network graph with only a subset of edges with their cost; the solid thick arrows represents all the SP(G) edges. b) Set of affected nodes after edge deletion. c) and d) SP(G) during the initialization phase of the algorithm; because of the multi-path, shortest paths to i and t exist and the nodes i and t can be deleted from the set D(v). e) Final SP(G) after that the operations of the algorithm have been performed.
In this case for node v the best path has a as parent and a cost equal to 35, so the element (v, a, 35) is enqueued in Q, for node l it has t as parent and a cost equal to 70, (l, t, 70) is enqueued in Q, and for node s it has q as 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 to be 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 present one (infinite) so all its attributes, except 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 v descendents have to be updated, so d(l) = 45, NH(l) = p, d(s) = 65 and NH(s) = p. The second element extracted is s: its new possible distance is equal to its distance, updated 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 node s through two different next-hop routers and so it can balance 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 so the algorithm stops. Final SPT is represented in Figure 1(e). III.
PERFORMANCE INDEXES AND TEST METHODOLOGIES
Because a complexity classical analysis characterizes an algorithm in the worst case scenario, we have decided to evaluate behavior of our algorithm in a real environment, implementing it in a routing protocol, OSPF, and measuring protocol performance indexes in different topology scenario. To implement incremental algorithm we have used a routing software with an open code (Open-source routing software), Quagga [9]. 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 an open-source routing software is its flexibility that allows evaluation of new routing feature, such as our algorithm. We have implemented incremental algorithm in OSPF code of Quagga software so that every time an edge deletion or insertion happened, incremental algorithm, instead of Djikstra one, is performed. OSPF performance indexes and methodologies for their evaluation has been defined by IETF RFCs [10-12]; the most interesting performance index to characterize our algorithm is SPF computation time, time needed for a router to complete SPF computation. To evaluate this index we have used the test configuration reported in Fig. 2: DUT (Device Under Test) can be either a market router or a PC based router. The network topology is made up of two real routers (a testing PC and the DUT) and a variable number of fictitious routers and networks, so that the DUT will have to find the shortest paths to all the vertexes of the emulated network, a vertex being either a network or a router. The testing PC is running a C++ software allowing: i) any network topology to be generated; ii) Link State Advertisements (LSA) describing the network topology to be generated and sent to the DUT.
EmulatedNetwork LSA DUT
Testing PC
Figure 2. Test-bed for the evaluation of the SPF computation time in a Device Under Test (DUT). The DUT can be either a market router or a PCbased router. The testing PC is equipped with a C++ code allowing both a network topology to be generated and the LSAs describing the emulated network to be sent to the DUT.
According to IETF specifications we describe the procedure allowing the measuring of SPF computation time. To understand the test methodology proposed, we remember that OSPF routers use to schedule the instant in which SPF computation starts to avoid to perform the calculation too many times when receiving Update LSAs [13]. So, when an Update LSA arrives, notifying for example an edge deletion or insertion in an emulated network link, the SPF computation start time is scheduled with a fixed delay, a timer is set and the SPF calculation starts only when the timer expires. Moreover, another timer enforces a lag between two consecutive SPF computations. In particular the following two timers are defined in [13]: -
spf_delay: time between receiving an Update LSA and starting the SPF computation; spf_hold_time: time between two consecutive SPF computations.
The SPF computation time measurement consists of two different steps, with different settings of these two timers. First, as shown in Fig. 3, we set both the timers to 0, so forcing the DUT to immediately start the SPF computation when it receives an Update LSA.
Figure 3. Time measure TtotSPF. The spf_delay and spf_hold_time router timers are set to zero and the SPF computation is performed.
In Fig. 3 we denote with RTT the Round Trip Time and further we assume that the propagation time is the same for the two directions Testing PC-DUT and DUT-Testing PC. The first step of the test consists in loading the emulated network into the DUT and in sending an Update LSA at time tsend_u followed after a little delay by a Duplicate LSA at time tsend_d. The DUT processes the Update LSA in the time interval Tu_Lsa and starts to execute the SPF algorithm. Once begun, the SPF process cannot be interrupted, and goes on till its end. Then the DUT processes the Duplicate LSA in the time interval Td_Lsa and sends back immediately, according to the OSPF protocol rules, its Acknowledge (Ack) LSA. Thus we can use the Ack
LSA of the Duplicate LSA to understand when the SPF computation ends. In particular in this first test we measure the time TtotSPF, which represents the time difference between the sending of the Update LSA at time tsend_u and the receiving of the Acknowledge LSA of the Duplicate LSA at time tack_d. As shown in Fig. 3, the TtotSPF time can be expressed as follows:
TtotSPF = RTT + Tu _ Lsa + TSPF + Td _ Lsa = Tov + TSPF (4.1) wherein
links. All of the link costs have been set to 10. The SPF computation time in an incremental algorithm depends on link position and on type of change occurring, so we have chosen to measure this time when the deletion and the insertion of each single link of the Verio’s network occur. The SPF computation time is reported in Figs. 5 and 6 in the case of deletion and insertion respectively, as a function of the link interested. In both the figures we also report the time that the DUT takes to run the Dijkstra’s algorithm. Obviously this time is constant and independent of the link position in which failure or restoration occurs.
- RTT is the Round Trip Time between Testing PC and DUT;
70 Incremental Algorithm (CISCO 2801)
- Tu_Lsa is the Update LSA processing time;
Dijkstra's Algorithm (CISCO 2801) 60
- Td_Lsa is the Duplicate LSA processing time;
- Tov = RTT + Tu_Lsa + Td_Lsa Hence in the performed measure we are able to evaluate TtotSPF but we are interested in evaluating TSPF. In order to make this we evaluate Tov and subtract it from TtotSPF obtaining TSPF: (4.2)
SPF Computation Time (ms)
Dijkstra's Algorithm (Quagga)
- TSPF is the SPF computation time
TSPF = TtotSPF − Tov
Incremental Algorithm (Quagga)
50
40
30
20
10
So in order to obtain TSPF we estimate Tov by performing a second test where we set both the SPF spf_delay and spf_hold_time timers to high values (60 sec). This time the DUT receives the Update LSA and schedules the SPF computation start time but does not execute it because the timers are too high. Instead the DUT goes on processing the Duplicate LSA and sends back the Ack LSA of the Duplicate LSA as illustrated in Fig. 4. The time difference between the sending of the Update LSA and the receiving of the Duplicate LSA Ack is exactly Tov.
0 0
1000
2000
3000
4000
Link Identification
Figure 5. Performance comparison of the incremental algorithm implemented in CISCO 2801 and Quagga in the case of link failure. The SPF computation is reported as a function of the link position.
70 Incremental Algorithm (CISCO 2801) Dijkstra's Algorithm (CISCO 2801) 60
Incremental Algorithm (Quagga)
Figure 4. Time measure Tov. The spf_delay and spf_hold_time router timers are set to high values (60 sec) and the SPF computation is not performed.
IV.
SPF Computation Time (ms)
Dijkstra's Algorithm (Quagga) 50
40
30
20
NUMERICAL RESULTS
The incremental algorithm implemented in Quagga has been compared to the one implemented in CISCO 2801. In case of Quagga has been used a PC with 2,6 GHz processor and 512 MB RAM, while CISCO 2801 is an access router with 128 MB RAM. The comparison has been carried out by emulating on the DUT real network topologies measured within the Rocketfuel project [14]. In particular we have considered the topology of Verio, an USA Internet Service Provider whose network is composed by 893 routers and 4150
10
0 0
1000
2000
3000
4000
Link Identification
Figure 6. formance comparison of the incremental algorithm implemented in CISCO 2801 and Quagga in the case of link restoration. The SPF computation is reported as a function of the link position.
Observing Figs. 5,6 you can notice that though CISCO 2801 takes a time lower than modified Quagga 0.98 to run Dijkstra’s algorithm, in particular 34 ms. against 52 ms., the incremental algorithm implemented in Quagga is more efficient than the one implemented in CISCO 2801. In fact the average SPF computation time is 9,5 ms. and 1.5 ms in CISCO 2801 and Quagga respectively. Furthermore the incremental algorithm implemented in CISCO 2801 allows only a saving of about 72% in processing time with respect the case in which the shortest paths would be evaluated by using the Dijkstra’s algorithm, while Quagga saves about 95% in processing time. The measure performed on CISCO 2801 shows that there are some links whose failure causes an SPF computation time higher than the one obtained when the Dijkstra’s algorithm is applied. For example in Fig. 5, that occurs for the link 1206 whose failure determines an SPF computation time equal to 48 ms against the 34 ms needed when the Dijkstra’s algorithm is applied. This strange behaviour never happens in the incremental algorithm implemented in Quagga. V.
CONCLUSIONS
The aim of our work was to propose and evaluate the performance of a multi-path incremental shortest path algorithm implemented in the Quagga routing software. A testbed ha been realized and SPF computation time of the new version of Quagga has been measured. The realized implementation performs well and allows SPF computation time lower than in Cisco 2801 to be obtained. In future topics, the proposed algorithm will be modified so that multiple changes are supported.
REFERENCES [1] [2] [3] [4]
[5]
[6]
[7]
[8]
[9] [10] [11] [12] [13] [14]
J. Moy, “OSPF Version 2” , Request for Comments 2328, April 1998 Callon, R.W., "Use of OSI IS-IS for routing in TCP/IP and dual environments", RFC 1195, December 1990 D. Watson, F. Jahanian, Craig Labovitz. “Experiences With Monitoring OSPF on a Regional Service Provider Network”, ICDCS’03, May 2003. G. Ramalingam and T. Reps. On the computational complexity of dynamic graph problems, Theoretical Computer Science, vol. 158, pp. 233–277, 1996. D. Frigioni, A. Marchetti-Spaccamela, and U. Nanni, Fully dynamic algorithms for maintaining shortest paths trees, Journal of Algorithms, vol. 34, pp 251-281, February 2000. P. Narvaez, K.-Y. Siu, and H.-Y. Tzeng, “New dynamic algorithms for shortest path tree computation”, IEEE Transaction on Networking, vol. 8, pp. 734-746, 2000 P. Narvaez, K.-Y. Siu, and H.-Y. Tzeng, “New dynamic SPT algorithm based on a Ball-and-String model”, IEEE Transaction on Networking, vol. 9, pp. 706-718, 2001 J. McQuillan, I. Richer, and E. Rosen, “The new routing algorithm for the ARPANET”, IEEE Transaction on Communication., vol. 28, pp. 711-719, 1980 GNU “Quagga.” [Ondine]. Available http://www.quagga.net V. Manral, R. White, A. Shaikh, “Benchmarking Basic OSPF Single Router Control Plane Convergence”, RFC 4061, April 2005 V. Manral, R. White, A. Shaikh, “OSPF Benchmarking Terminology and Concepts”, RFC 4062, April 2005 V. Manral, R. White, A. Shaikh, “Consideration When Using Basic OSPF Convergence Benchmarks,” RFC 4063, April 2005 ”Rocketfuel Project.” [Ondine]. Available http://www.cs. washington.edu/research/networking/rocketfuel/ OSPF Conformance and Performance Testing, Ixia Communication, http://www.ixiacom.com/test_plans/ pdfs/ospf.pdfJ. Clerk Maxwell, A Treatise on Electricity and Magnetism, 3rd ed., vol. 2. Oxford: Clarendon, 1892, pp.68–73.
