QoS Aware and Fair Resource Allocation Scheme in Transport Networks Mihály Bárász†, Zsolt Fekete†, Alpár Jüttner†‡, Márton Makai†, Jácint Szabó† † Department of Operations Research, Eötvös University, Budapest, Pázmány P. s. 1/C, Hungary H-1117. ‡ Ericsson Research, Hungary,Budapest Laborc u. 1. H-1071 e-mail: {barasz, fezso, alpar, marci, jacint}@cs.elte.hu ABSTRACT This paper presents a QoS aware fair routing and bandwidth management method for transport networks. We consider a variant of the maximum concurrent multicommodity flow problem where only paths of bounded length are allowed to carry flow. We show two possible approaches to the problem. First, we give a column generation method, where the Bellman-Ford algorithm provides the path of bounded length with minimum reduced cost. Then we present an ε -approximation scheme to the problem, applying the method of Garg and Könemann with new ideas for speedup. Finally the computational experience is presented. Keywords: approximation method, multicommodity flow, QoS, faire routing, bandwidth management 1. INTRODUCTION A basic building block of static network resource allocation schemes is mapping the logical data carrying channels (demands) to the physical layer of a network taking the capacity limits and other technological constraints into account. Such an algorithm assigns a single path or multiple paths to each commodity given by its source, destination and the amount of traffic to be carried. This task leads to solving different versions of multicommodity flow problems with additional constraints (see [6]). This paper considers the Length Bounded Concurrent Flow Problem (see Section 2 for an exact formulation) and provides efficient methods for solving it. This model takes three important aspects of QoS enabled network dimensioning into account. The first one is the transportation time of data (traffic delay). This is a fundamental factor to be considered when providing QoS, and it is particularly important in mobile access and transport networks since voice applications have very strict delay requirements and the mobile technologies themselves consume a large part of the available time frame. We handle this problem by limiting the maximum length of the routing paths. The second aspect is the difficulty arising in predicting the exact amount of traffic. To provide a robust and reliable resource allocation we use a flexible provisioning model referred as concurrent flow problem in the literature. In this model the demands can be over-provisioned if the network resources enable. If the network is short of available capacity, then the goal is to satisfy as much portion of the demands as it is possible. The third goal is to establish fairness in bandwidth provisioning. It is also achieved by concurrency i.e. by satisfying the same portion (possibly more than 100%) of each demand. This paper focuses on fractional flows, which means that the traffic between a source and a destination can be shared among multiple paths. Similarly to the case of Maximum Concurrent Flow Problem[7], the principle of “ekvivalence of separation and optimization” (see [5]) shows that the Length Bounded Concurrent Flow Problem can be solvable in polynomial time. However, in many applications the need of a fast solution can exceed the claim to an optimal solution. Hence this paper shows two different fast approximation algorithms for the Length Bounded Concurrent Flow Problem. First, Section 2 presents a path-flow formulation based column generation method using the Bellman-Ford algorithm (see e.g. [3]) to generate to column of the linear program. Then, Section 4 shows a fully polynomial time ε -approximation scheme (FPTAS) to the problem. An FPTAS is an algorithm finding an ε -approximate solution in time polynomial in the size of the input and 1 / ε . Our FPTAS is a modification of the method of Garg and Könemann[4] with new ideas for speedup. Finally Section 5 presents some computational experiences. The Garg-Könemann algorithm performs much better than column generation, but even with the speedups we use, the approximation slows down when it is close to the optimum. As the results show, the most efficient approach is a combination of the two algorithms: in the beginning use the Garg-Könemann method and then, when it slows down, switch to column generation.  The work reported in this paper was supported by COST293 and by the Mobile Innovation Center, Hungary. 2. Problem formulation Let us consider a directed graph G = (V,E) representing the network topology, and denote the capacity of an arc e ∈ E by ce . Let C denote the set of commodities. A source si ∈ V , a sink ti ∈V , a demand di > 0 and a length constraint Li ∈ N are given for each i ∈ C . With these notations, briefly, the Length Bounded Concurrent Flow Problem is to find the maximum λ for which it is possible to carry λdi unit of traffic from si to ti keeping the capacity constraints and the property that the length of the routing paths are at most Li for each i ∈ C . An exact formulation is the following. Path-flow formulation. Let Pi denote the set of si ti -paths with at most Li edges for i ∈ C , and let P := ∪i∈C Pi . The path-flow linear program of the Length Bounded Concurrent Flow Problem with exponentially many variables is formulated as follows. maxλ ∑x ∑x ≤ c e , ∀e ∈ E p p s.t. ≥ λd i , ∀ i ∈ C (1) λ, x ≥ 0 From the theory of linear programming we know that the optimum value of (1) is equal to the optimum of the following dual linear program. min ∑l e ∑c l s.t. e e − π i ≥ 0, ∀i ∈ C, p ∈ Pi ∑ πi di ≥ 1, (2) l,π ≥ 0 3. Column generation method The idea of column generation is the following. Instead of putting the whole enormous linear program (1) to an LP solver, we choose only a small subset P' of the columns and solve this reduced size linear program. Consider the optimal primal and dual solutions x and l,π . Obviously, x is also a feasible solution to (1) after adding 0's. Now let us check whether the obtained dual solution l,π is feasible to (2). If it is dual feasible, than x and l,π must be optimal solution pair to the full problem. If l,π is not feasible, then we choose some columns for which the dual feasibility fails and add them to P' and repeat these steps until the optimal solution is found. Checking dual feasibility and finding wrong inequality if it is not feasible boils down to checking if distl (si ,ti ) ≥ πi holds for each i ∈ C . So we have to solve a bounded shortest path problem. One can solve this problem with the Bellman-Ford algorithm in time O (Li m ) , where m denotes the number of edges. Moreover, if the dual solution is not feasible, the columns belonging to the minimizing paths with length less than πi are those which we can add to the problem. Let us mention two techniques that can be used to speed-up the computations thus making it possible to apply the algorithm for practical problems. Keep the LP program small. During the sequential generation of new columns the LP can grow up enormously, therefore by removing idle columns we must keep the LP small. As it is usual in column and row generation methods joint to the simplex method, we consider a column to be idle, if it does not appear in the last say 15 bases. Generate more paths at the same time. The sequential generation of paths can be sped up if the weight function is perturbed and multiple almost shortest paths are generated between two simplex iterations (there are fast approximating algorithms for finding bounded shortest paths). The number of generated paths can be adjusted adaptively according to the proportion of the measured time of LP iteration and measured time of column generation. ( ) ( ) ( ) ( ) 4. A fully polynomial time approximation scheme Now we present a fully polynomial time ε -approximation scheme (FPTAS) to the problem. Our FPTAS is a modification of the method of Garg and Könemann[4], developed for the Maximum Concurrent Flow Problem. This algorithm iteratively sends flows on l -shortest paths and update the dual solution l based on the found path. The pseudocode of our version of the method is the following (see [4] for more details on the original version). procedure Garg-Könemann( G,c,{si ,ti , d i : i ∈ C} ) for each e ∈ E let l (e ) := 1 / ce for each p ∈ P let x p := 0 let λ' = 0 while (1+ ε )λ' < D(l ) / α (l ) do begin for each i ∈ C let d'i := d i while d'i > 0 do begin let p be an l -shortest si ti -path u := min{d i' ,mine∈P ce } , x p := x p + u and d'i := d'i −u for each e ∈ p let l (e ) := l (e )(1+ εu / ce ) let end end let ξ = maxe∈E end procedure e∈ p∈P ∑ xp ce and λ' = mini∈C ∑ p∈Pi xp (ξdi ) We also introduced and tested the following simple but efficient improvement. Demand scaling. During the algorithm we redefine the demands, i.e. we set di := min{2λ ' , D(l ) / α (l ) }d i where λ' is the current primal objective value, D(l ) := ∑ cele and α(l ) := ∑ distl (si ,ti )di . This scaling helps avoiding making a lot of small increments in the flow value instead i of a single big one. 5. Computational Results We implemented and tested our algorithms on several networks. For the test purposes we used two kinds of networks: specifically constructed networks in which flow computations are “difficult”, and scale-free networks designed to simulate real-world access networks. We used Barabási model [2] to generate scale-free networks. The demands in these networks also mimic the real-world behavior: we chose a significant number of low degree nodes (these represent the end-users or DSLAMs) and a smaller number of high degree nodes (these represent the servers or BASes) and generate a demand between every pair of them. Figure 2: Comparison between the original and the improved versions of the FPTAS algorithm. (Axes. x: time in seconds, y: duality gap in %.) Figure 1: Garg-Könemann and column generation for a medium size and difficult problem. With the combined method we could save as much as 30 seconds out of 56. Both algorithm was implemented in C++ using the LEMON[1] library. The numerical computations mentioned in this section were conducted on PC with AMD Athlon 1800+ CPU and 1 gigabyte of RAM with Debian GNU/Linux and the and GNU G++ 4.1.0 compiler. The original Garg-Könemann algorithm is often very inefficient because it uses “small” steps even in the beginning, when the gap between the primal and dual solution is still very high. Using the demandscaling we achieved significant improvements in the running time (Figure 1). On the other hand, if the approximation is close to the optimum (usually around 10-30%) the improved algorithm also slows down and the improvement is not so significant. Because of this the most efficient approach is to combine the two algorithms: in the beginning use the Garg—Könemann method and then, when it slows down, switch to column generation (see Figure 2). For the simple problems both algorithms scale well in the size of the network and in the number of commodities. But for the more difficult problems the Figure 3: Garg-Könemann and column generation for a column generation method produces very poor large and difficult problem. The column generation results (see Figure 3). This is not surprising, as it is method did not get near the optimum in the first 20 essentially an augmenting path flow algorithm for minutes, while the FPTAS achieved 30% approximation. every commodity. For such problems only the FPTAS approach could be used. Acknowledgement The authors wish to thank Gyula Pap for useful discussions and for Balázs Dezsı to provide an appropriate implementation of Bellman-Ford algorithm in LEMON. REFERENCES [1] LEMON, a C++ Library for Efficient Models and Optimization in Networks. http://lemon.cs.elte.hu. [2] A.-L. Barabási, R. Albert, and H. Jeong. Scale-free characteristics of random networks: the topology of the world-wide web. Physica A, Statistical Mechanics and its Applications, 281:69–77, June 2000. [3] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein. Introduction to Algorithms. MIT Press and McGraw-Hill, 2001. [4] N. Garg and J. Könemann. Faster and simpler algorithms for multicommodity flow and other fractional packing problems. In IEEE Symposium on Foundations of Computer Science, pages 300–309, 1998. [5] M. Grötschel, L. Lovász, and A. Schrijver. The ellipsoid method and its consequences in combinatorial optimization. Combinatorica, 1(2):169–197, 1981. [6] M. Pióro and D. Medhi. Routing, Flow, and Capacity Design in Communication and Computer Networks. Morgan Kaufmann Publishers, 2004. [7] F. Shahrokhi and D. W. Matula. The maximum concurrent flow problem. J. Assoc. Comput. Mach., 37(2):318–334, 1990.