exact algorithms for a bandwidth packing problem with queueing delay guarantees

7/29/2019 Exact Algorithms for a Bandwidth Packing Problem with Queueing Delay Guarantees

1/25

Exact Algorithms for a Bandwidth Packing Problemwith Queueing Delay Guarantees

Jinil HanDepartment of Industrial & Systems Engineering, Korea Advanced Institute of Science and Technology,

373-1 Guseong-dong, Yuseong-gu, Daejeon 305-701, Republic of Korea, [email protected]

Kyungsik LeeDepartment of Industrial & Management Engineering, Hankuk University of Foreign Studies, 89

Wangsan-ri, Mohyeon-myon, Yongin-si, Gyeonggi-do 449-791, Republic of Korea, [email protected]

Chungmok LeeIT Convergence Technology Research Laboratory, ETRI, 218 Gajeongno, Yuseong-gu, Daejeon 305-700,

Republic of Korea, [email protected]

Sungsoo ParkDepartment of Industrial & Systems Engineering, Korea Advanced Institute of Science and Technology,

373-1 Guseong-dong, Yuseong-gu, Daejeon 305-701, Republic of Korea, [email protected]

The bandwidth packing problem (BWP) concerns the selection of calls from a given set and

the assignment of one path to each selected call. The ultimate aim of the BWP is to maximize

profit while the routings of the selected calls observe the capacity constraints of the links.

Here, we additionally consider queueing delays in the network, which may cause in a dete-

rioration in the quality of service to users if they exceed the acceptable limits. The integer

programming formulation for the BWP with the queueing delay restriction contains a nonlin-

ear constraint that is intrinsic to the model. We apply the Dantzig-Wolfe decomposition to

this nonlinear constraint, and since the Dantzig-Wolfe decomposition has exponentially many

variables, we propose the branch-and-price procedure to find optimal solutions. We also pro-

pose a generalized Dantzig-Wolfe reformulation based on the aggregation of variables, which

makes our branch-and-price algorithm more competitive. Computational results on cases of

randomly generated networks and some real-life telecommunication networks demonstrate

that our algorithm performs well for large networks.

Key words: bandwidth packing; queueing delay; telecommunications networks; branch-and-

price procedure; integer programming

History:

1


2/25

1. Introduction

Bandwidth packing problems (BWPs) most commonly arise in the area of telecommunication

networks. When calls are made along a fixed bandwidth between a pair of communicating

nodes, the goal is to determine the selection of calls and the assignment of a single pathto each selected call, such that edge capacities are not violated and profit is maximized.

The single path requirement is common to various types of telecommunications networks,

such as video teleconferencing, but it is associated with a number of problems, not only in

the area of telecommunications, but also in transportation and production. For example, a

package flow problem that arises in express package delivery operations requires that a set

of packages with a common origin-destination pair be routed along a single path to facilitate

operations (Barnhart et al. 2000). When a call can be split among several paths, the problem

can be converted into a multicommodity flow problem, which can be solved efficiently using

the linear programming (LP) technique. The single path requirement, however, makes the

problem NP-hard (Parker and Ryan 1993). Various approaches have been proposed to

solve this problem, including a tabu search (Anderson et al. 1993, Laguna and Glover 1993),

Lagrangian relaxation (Gavish and Altinkemer 1990), genetic algorithm (Cox Jr et al. 1991),

branch and price (Parker and Ryan, 1993), and branch and price and cut (Park et al. 1996,

Barnhart et al. 2000, Villa and Hoffman 2006, Geffard 2001). For a detailed explanation of

previous approaches, the reader is referred to Villa and Hoffman (2006).

Variants of the classical bandwidth packing problem also exist. Amiri and Barkhi (2000)

extended the problem to the multi-period case and considered time-varying traffic condi-

tions. Amiri (2005) dealt with the problem that requires selected calls to be routed within

a permissible scheduling time window for a required duration. Bose (2009) proposed the

problem where the calls belong to two priority classes. Lastly, Amiri and Barkhi (2011)

extended the problem to the case in which each request that uses network resources includes

a set of calls to be routed between various pairs of nodes. If the request is accepted, then all

of its calls have to be admitted, otherwise no single call is admitted.In the study reported here, we consider not only classical BWP, but also network delay,

which has been a source of problems in telecommunications networks for many years and,

consequently, an important design and performance characteristic of telecommunications

networks. Network delay, which specifies the length of time it takes for data to travel

across the network from one node to another, can be placed into several categories, such as

2


3/25

processing delay, queueing delay, transmission delay, and propagation delay. If the network

delay reaches an unacceptable level, network users may suffer from a deterioration in the

quality of service. Therefore, the issue of network delay has to be taken into consideration

in the modeling and optimization of various network designs and routing problems.

The classical BWP consists of maximizing profit, and its solution probably has a large

number of edges whose utilizations closely approximate edge capacities. An increase in

edge utilization may cause some packets to wait in the queue for a relatively long time

before they are processed through the edge, which eventually makes a network unreliable

and degrades the quality of service. Amiri et al. (1999) and Rolland et al. (1999) assessed

this kind of queueing delay in the BWP by modeling the telecommunications network as

a network of independent M/M/1 queues. In their queueing model, edges take charge of

servers whose service rates are proportional to the edge capacities, and the arrivals of packets

follow a Poisson process, while packet lengths follow an exponential distribution. In order to

control the queueing delay of the network, Amiri et al. (1999) included a nonlinear cost term

associated with the edge queueing delay in an objective function. Rolland et al. (1999) added

a single nonlinear constraint that limits the total edge queueing delay to the predetermined

value.

In this paper, we solve a delay-constrained BWP (DCBWP), which is the same problem

as that proposed in Rolland et al. (1999). These authors applied the Lagrangian relaxation

technique to identify good solutions. The relaxed problem can be separated into two kinds ofproblems, i.e., the shortest path problem and the binary knapsack problem with a nonlinear

objective function. Because the authors developed a greedy procedure to solve the continu-

ous version of the nonlinear knapsack problem, they were not able to obtain exact solutions

of DCBWP. In this paper, we present an algorithm that can find exact optimal solutions

within a reasonable amount of time. To accomplish this, we solve the nonlinear knapsack

problem (NKP) to optimality and incorporate the solution into efficient integer program-

ming techniques. The natural integer programming formulation for the problem contains

a single nonlinear constraint intrinsically, so we apply the Dantzig-Wolfe decomposition to

linearize it. The NKP then becomes the subproblem to generate additional columns, and the

nonlinearity in the original formulation is transferred to the nonlinear knapsack subproblem.

A branch-and-price procedure is used to solve the reformulation since it has exponentially

many variables. We also extend the original Dantzig-Wolfe reformulation to a more general

form by introducing a call pattern that serves as columns of reformulation, and we show

3


4/25

that the reformulation with the aggregated call patterns can accelerate the column genera-

tion drastically compared with the original call pattern. The contributions of our study to

the field of BWP are:

Applying the Dantzig-Wolfe reformulation to the nonlinear delay-constrained band-width packing problem;

Proposing the branch-and-price procedure to obtain exact solutions, which solves the

nonlinear knapsack subproblem to optimality;

Generalizing the Dantzig-Wolfe reformulation using aggregated call patterns in order

to accelerate column generation;

Showing, based on our computational results, that our algorithm performs well for

large networks and that using aggregated call patterns is crucial to obtaining good

performance.

The paper is organized as follows. Section 2 describes the original nonlinear integer

programming formulation. The Dantzig-Wolfe reformulation is presented in Section 3 and

the solution procedures including the detailed branch-and-price algorithm and the dynamic

programming algorithm for the nonlinear knapsack problem are given in Section 4. Section 5

gives the generalized Dantzig-Wolfe reformulation. Computational test results are reported

in Section 6 and our conclusions are given in the last section.

2. Problem Statement

This section introduces an integer programming formulation for the DCBWP. The following

are notation and definitions that will be used in the formulations.

V : the set of nodes,

E : the set of undirected edges,

K : the set of calls (ordered pairs of nodes),

P(k) : the set of (s, t)-paths, where s is the origin and t is the destination of call k K,

P(k, e) : the set of paths in P(k) that traverse edge e E, k K,

be : the capacity of edge e E,

wk : the revenue of call k K,

4


5/25

rk : the demand of call k K,

: the upper limit on the queueing delay.

We assume that all data are integral without loss of generality. With the notation defined,

the following model P of the DCBWP can be developed.

(P) maxkK

pP(k)

wkypk (1)

s.t.

pP(k)

ypk 1, k K, (2)

kK

pP(k,e)

rkypk be 1, e E, (3)

eE

kK

pP(k,e) rky

p

k

be

kK

pP(k,e) rky

pk

, (4)

ypk {0, 1}, p P(k), k K, (5)

where ypk takes value 1 if call k is selected and path p is assigned to call k, 0 otherwise.

The objective function (1) maximizes total revenue by selecting the set of calls and routings

of the selected calls. Constraint set (2) means that a maximum of one path can be selected

for each call. A nonlinear constraint (4) means that the total queueing delay of the network

should be less than or equal to the given upper limit . The constraint (4) implies thatthe capacity of an edge cannot be fully utilized. Assuming all the given data are integral,

without loss of generality, constraint set (3) prevents the capacity of each edge from being

fully utilized. This path-based formulation has been widely used for the classical BWP (Park

et al., 1996; Barnhart et al., 2000; Park et al., 2003; Villa and Hoffman, 2006) since the LP

relaxation of it can be solved efficiently by the column generation technique. Note that

Rolland et al. (1999) used the formulation with arc flow variables.

The reasoning for nonlinear constraint (4) that limits the queueing delay of the network

is as follows. We regard an edge e of the network as a service facility with an exponentialservice rate be and that each call k arrives at the edge with Poisson arrival rate rk. The

edge e then behaves as an M/M/1 queue with arrival rate

kKrkxke and service rate be,

where xke takes value 1 if the path for call k traverses edge e, 0 otherwise. Given steady-state

conditions, the average waiting time per call is 1/(be

kKrkxke), and the total weighted

average waiting time at edge e is given by (

kKrkxke)/(be

kKrkx

ke). We then model the

5


6/25

network as a network of independent M/M/1 queues. In this setting, the total edge queueing

delay in the network is given by

eE(

kKrkxke)/(be

kKrkx

ke) and the path-based

version of this expression is the left-hand side of constraint (4). The interested reader may

refer to Gavish and Hantler (1983) and Kleinrock (1964) for an explanation of the validity

for this reasoning.

The number of paths in P can be exponential for the number of edges for dense networks,

which makes it impossible to directly solve the problem. In addition, state-of-the-art mixed

integer programming solvers, e.g. the latest version of CPLEX, can only handle special

types of nonlinear constraints such as convex quadratic constraints. It can be seen that the

nonlinear constraint (4) is a convex constraint, however, it cannot be handled readily by com-

mercial solvers. This makes it difficult to solve P directly with commercial solvers, although

P has a small number of path variables. Hence, Rolland et al. (1999) proposed a composite

upper and lower bounding procedure based on a Lagrangian relaxation of the problem to

obtain good feasible solutions. In the following sections, we propose the Dantzig-Wolfe re-

formulation to linearize the nonlinear delay constraint and obtain an efficient procedure to

find exact solutions.

3. Dantzig-Wolfe Reformulation

We first introduce a call pattern, which represents the set of possible calls that can be routed

through the same edge simultaneously under the given edge capacity. In other words, a call

pattern g for edge e is represented by a set K(g), such that

kK(g) rk be 1. We can

interpret this as a binary integer solution of the knapsack constraint,

kKrkxk be 1.

It was first introduced by Park et al. (2003) to solve the classical BWP. These authors

used the call pattern to enhance the bound of a LP relaxation by applying the Dantzig-

Wolfe decomposition to each knapsack inequality of the original formulation. Recently,

Lee (2009) used the call pattern to solve the robust network design problem without flow

bifurcations. The author also showed that the convex hull of the feasible solutions to each ofthe knapsack constraints can be completely described by the Dantzig-Wolfe decomposition.

By applying this concept of the call pattern to our problem, we gain the additional advantage

of linearizing the nonlinear queueing delay constraint. The following notation and definitions

are additionally used.

G(e) : the set of all possible call patterns for edge e E,

6


7/25

G(e, k) : the set of call patterns of e E containing call k K,

dge : the queueing delay of call pattern g G(e), for edge e E.

Using the notation, the following reformulation, PDW, can be developed.

(PDW) maxkK

pP(k)

wkypk

s.t.

pP(k)

ypk 1, k K, (6)

gG(e)

zge 1, e E, (7)

pP(k,e)

ypk

gG(e,k)

zge , e E, k K, (8)

eE

gG(e)

dgezge , (9)

ypk {0, 1}, p P(k), k K, (10)

zge {0, 1}, g G(e), e E, (11)

where zge takes value 1 if call pattern g of edge e is selected, 0 otherwise. Constraint set

(7) ensures that at most one call pattern can be assigned to each edge. Constraint set (8)

means that a path for call k can traverse edge e only if the call pattern containing call k is

selected for edge e. Constraint (9) limits total queueing delay to the given acceptable value

and is linearized at the expense of introducing exponentially many call pattern variables.

The queueing delay dge of call pattern g for edge e is given as (

kK(g) rk)/(be

kK(g) rk),

where

kK(g) rk is the utilization of pattern g.

The bound obtained from the LP relaxation of PDW is stronger than that of P since

it explicitly describes the convex hull of each knapsack constraint of edges with the help of

additional call pattern variables. Also, the LP relaxation of PDW is well suitable for applying

delayed column generation. In this case, we must solve two pricing subproblems to generate

both paths and call patterns. The details of the column generation procedure are presentedin the next section.

4. Branch-and-Price Algorithm

We use a branch-and-price approach, which combines column generation with a branch-and-

bound to solve our reformulation PDW of DCBWP. The LP relaxations of the reformula-

7


8/25

tion solved by the column generation procedure provide upper bounds at each node of the

branch-and-bound tree. In order to prove integer optimality, columns should be generated

throughout the tree. For an explanation of the general methodology of the branch-and-price

approach, the reader is referred to Barnhart et al. (1998) and Desaulniers et al. (2005).

4.1. Column Generation for LP Relaxation

Let P(k) be the set of paths of call k generated so far and G(e) be the set of call patterns

of edge e generated so far. The restricted master problem RMDW of PDW will then be:

(RMDW) maxkK

pP(k)

wkypk

s.t.

pP(k)

ypk 1, k K, (12)

gG(e)

zge 1, e E, (13)

pP(k,e)

ypk

gG(e,k)

zge , e E, k K, (14)

eE

gG(e)

dgezge , (15)

ypk 0 p P(k), k K,

zge 0 g G(e), e E.

Let k, e, ke and be dual variables associated with constraints (12), (13), (14), and (15)

respectively. We can solve the LP relaxation of PDW by solving several RMDWs repeatedly.

After finding an optimal solution to RMDW, we check whether there are any columns not

included in the RMDW with a positive reduced cost. If such columns exist, they are added

to the RMDW, and the process is repeated; otherwise, the current optimal solution to RM DW

is also optimal to the LP relaxation of PDW.

Let (k, e, ke , ) be the optimal dual values for the current RMDW. For each iteration,

we have to generate two kinds of columns, i.e., path and pattern. First, the reduced cost of

path p for call k is:

wk k

eE(p)

ke ,

8


9/25

where E(p) is the set of edges contained in the path p. Then we can solve the following

pricing problem to find profitable paths for each call k K.

(SP1(k)) min

eE(p)k

e (16)

s.t. p P(k). (17)

For each call k K, SP1(k) is the shortest path problem from the source node of call

k to the sink node of call k over a network with positive edge costs; therefore, it can be

efficiently solved by Dijkstras algorithm. If the optimal cost is less than wk k, a new

path for call k can be added to RMDW.

Next, the reduced cost of pattern g for edge e is:

e +

kK(g)

ke dge.

Recall that K(g) is the set of calls contained in pattern g. We now have to solve the following

second pricing problem to find profitable patterns for each edge e E.

(SP2(e)) max

kKke xk

kKrkxk

be kKrkxk(18)

s.t.kK

rkxk be 1, (19)

xk {0, 1}, k K. (20)

For each edge e E, SP2(e) is a 0-1 knapsack problem with a nonlinear objective, which

is NP-hard since the ordinary binary knapsack problem is a special case. Note that when

we apply column generation, the nonlinearity of the original problem is transferred to this

knapsack subproblem and we have to solve SP2(e) repeatedly, which seems to be somewhat

inefficient. However, we present a dynamic programming algorithm to solve SP2(e) that ispractically fast, so that it enables the nonlinear knapsack subproblem not to be a bottleneck

of the overall algorithm. If the optimal cost is greater than e, a new pattern for edge e can

be added to RMDW.

The column generation procedure can have many different variations depending on the

order of generating path and pattern columns, and the number of generated columns in one

9


10/25

iteration. In our implementation, after solving RMDW, we first try to find one path column

with a positive reduced cost for each call. Once profitable paths are found, then we add

them to RMDW and solve it again, otherwise, we then try to identify one call pattern column

with a positive reduced cost for each edge. If profitable call patterns are found, we add them

to RMDW and solve it again, otherwise the current solution is optimal to the LP relaxation

of PDW. This procedure is used at each node of the branch-and-bound tree in the branch-

and-price phase. The next subsection shows the dynamic programming algorithm for our

nonlinear knapsack problem.

4.2. Nonlinear Knapsack Problem

Let us slightly modify the nonlinear knapsack problem SP2(e) to the following form, which

is more appropriate for describing the algorithm to solve the problem.

(NKP) maxmk=1

pkxk

k rkxk

b

k rkxk(21)

s.t.mk=1

rkxk b 1, (22)

xk {0, 1}, k = 1, . . . , m . (23)

The dynamic programming (DP) algorithm for NKP can be defined as follows. For

0 < b 1, let

fj() = max {

jk=1

pkxk

b :

jk=1

rkxk = , xk {0, 1}, k = 1, . . . , j }.

Then initially,

f1() =

0 if = r1, > bp1/(p1 + ),

p1

bif = r1, bp1/(p1 + ),

if = r1.

(24)

Subsequently, for j {2, . . . , m} and {0, . . . , b 1},

fj() = max

fj1() if =

j1k=1 rkx

j1k ,

fj1( rj) + pj rj

(b)2+rj(b)b if =

j1k=1 rkx

j1k + rj,

(25)

where xj1k is a solution obtained at the (j 1)th state.

10


11/25

If the nonlinear term rj

(b)2+rj(b)b of the above recursive equation is absent, the equa-

tion is not different from the well-known DP algorithm for the ordinary knapsack problem.

The running time of the DP algorithm for NKP is O(mb), which is the same as the DP

algorithm for the ordinary knapsack problem. We can therefore solve the NKP by slightly

modifying the DP algorithm for the ordinary knapsack problem. This is the main advantage

of our algorithm in that the nonlinearity of original problem is transferred into a series of

NKPs that can be solved efficiently. For a detailed explanation of NKP, refer to Elhedhli

(2005), which contains two linearization algorithms as well as the above DP algorithm.

Proposition 1 Elhedhli (2005). The recursive equations (24) and (25) solve the (NKP)

correctly.

4.3. Branching Strategy

A proper branching strategy which is compatible with the pricing problem has to be designed

in order to successfully incorporate the column generation subproblem into the branch-and-

bound tree. This means that after branching, the structure of the pricing subproblem should

not be destroyed and that, consequently, the problem remains tractable. Here, we present

branching rules that do not change the characteristics of the column generation subproblem.

We first note that, for a given extreme point solution (y, z) to RMDW, such that y is integral,

either z is integral or a solution (y, z) exists with the same objective value such that z isintegral. This result directly follows from the fact that if z is not integral, we can construct z

such that for each e E, zge = 1 if and only ifK(g) = {k K|ykp = 1 for some p P(k; e)}.

This implies that we only need to check the integrality of the path variables.

Our branching rule consists of two stages. In the first stage, the algorithm branches on the

set of calls that are routed fractionally, choosing the call with the most fractional routes as the

call to branch on, i.e., we choose k such that k = argmaxkK{max{yk yk, yk yk}},

where yk = pP(k) ykp . We then create two nodes in the branch-and-bound tree, where

the first node enforces call k to be selected and the second node enforces call k not to beselected. This branching can easily be enforced by replacing constraint (12) for call k with

pP(k) ykp = 1 in the first node and with

pP(k) y

kp = 0 in the second node. Note that no

additional paths need to be generated for the call k at the descendant nodes of the second

node.

11


12/25

The second stage is branching on path variables, and it is adopted from Barnhart et al.

(2000), except that our network is undirected. We first choose a call k K which is assigned

to more than one fractional path. The branching rule for the second stage is based on the

dichotomy on the edges incident to the divergence node. For the purpose of the discussion,

let us assume that k is assigned to two distinct paths, then the paths differ by at least one

edge. The divergence node d is the first node from the source node s of the call k at which

the two paths split. We can easily find the divergence node of the two paths by tracing

each path one edge at a time until two different edges e1 and e2 are identified for each path.

We denote the set of all edges incident to d as E(d) and let E(d, e1) and E(d, e2) be some

partition of E(d) such that E(d, e1) contains e1 and E(d, e2) contains e2. We then create

two nodes in the branch-and-bound tree, where all edges in E(d, e1) are forbidden for k in

the first node and all edges in E(d, e2) are forbidden for k in the second node. Note that

an edge can be forbidden easily by imposing a very large cost on it in the path generation

subproblem SP1(k).

4.4. Primal Heuristic

The availability of a good feasible solution may reduce the size of the branch-and-bound tree

considerably since it provides a good lower bound to the problem. We therefore designed a

greedy heuristic that is invoked at each node of the branch-and-bound tree.

Let ykp be the optimal solution of the current node. First, if ykp = 1 for path p of call k, weassign path p to call k. Next, we sort the remaining calls in decreasing order of

pP(k) y

kp .

Each remaining call is considered, one by one, in this order by assigning path p with the

largest ykp to call k if it does not violate edge capacities and the delay constraint of the

problem. This greedy heuristic looks simple but works very well. It often finds a feasible

solution close to optimal in the early stage of the branch-and-bound procedure, which helps

reduce the size of the branch-and-bound tree.

5. Generalized Dantzig-Wolfe Reformulation

At this point it should be recalled that the call pattern represents the set of possible calls that

can flow through the edge simultaneously. We now extend our Dantzig-Wolfe reformulation

to a more general form by aggregating some calls arbitrarily and redefining the call patterns.

12


13/25

Our motivation towards a generalized form is to accelerate the column generation step, which

is supported by our computational results.

5.1. Reformulation

Let {Xj, j J} be a partition of the set of calls, K. Then, for j J, we define the demand

unit ofXj as a positive integer hj such that rk for each k Xj is a positive multiple ofhj, and

we let mj be (

kXjrk)/hj. Now, we redefine a call pattern of an edge e as an integer vector

of dimension |J| which is the feasible solution of the following bounded integer knapsack set

{x Z|J|+ :

jJ hjxj be 1, xj mj, j J}. In other words, the redefined call

pattern represents the number of demand units of Xj for all j J which can be routed

through the same edge simultaneously. Using the additional notation below, the generalized

Dantzig-Wolfe reformulation PGEN can be developed as follows.

T(e) : the set of all possible call patterns for edge e E,

T = eET(e),

P(j, e) : the set of paths for calls in Xj , which traverse edge e E,

ntj : the jth component of call pattern t T,

dte : the queueing delay of call pattern t T(e), e E.

(PGEN) maxkK

pP(k)

wkypk

s.t.

pP(k)

ypk 1, k K, (26)

tT(e)

zte 1, e E, (27)

pP(j,e)

(rkhj

)ypk tT(e)

ntjzte, e E, j J, (28)

eE

tT(e)

dtez

te , (29)

ypk {0, 1} p P(k), k K, (30)

zte {0, 1} t T(e), e E, (31)

where zte takes value 1 if call pattern t of edge e is selected, 0 otherwise. Constraint set

(26) and (27) ensure that at most one path for each call and at most one call pattern for

13


14/25

each edge can be selected. Constraint set (28) determines the paths of calls in partition j

that can traverse the edge e. In constraint (29), the delay constraint is linearized, as in the

previous reformulation. In this reformulation, we have room for flexibility upon defining the

partition of calls. In the following subsection, we therefore summarize three easily obtainable

special cases.

5.2. Special Cases

First, when each partition is composed of a single call and hj is set to be equal to the

demand value of each call, we obviously obtain the original Dantzig-Wolfe reformulation PDW

introduced previously. In this case, the number of partitions equals the number of calls, and

each call pattern corresponds to the feasible solution of the binary knapsack constraint. We

call this the original call pattern.

Second, when we consider the partition such that each subset consists of all calls with

identical demand value and then assign the hj value to this value, mj becomes the number

of calls in the subset Xj, and the call pattern denotes how many number of calls with the

same demand value can traverse the edge. We call this the reduced call pattern.

Next, we further aggregate the calls partitioned in the reduced call pattern to define a

prime call pattern, which is obtained by aggregating the calls according to the largest prime

number that divides the demand value of each call. These prime numbers are assigned to

the hj values.Let us examine three call patterns defined using an example. Suppose that we have 8 calls

with r1 = 2, r2 = 3, r3 = 3, r4 = 4, r5 = 6, r6 = 8, r7 = 8, r8 = 10, and the capacity of edge

is 25. The original call pattern then corresponds to the feasible solution of the constraint

{x {0, 1}8 : 2x1 + 3x2 + 3x3 + 4x4 + 6x5 + 8x6 + 8x7 + 10x8 24}. The reduced call pattern

corresponds to the feasible solution of the constraint {y Z6+ : 2y1 + 3y2 + 4y3 + 6y4 + 8y5 +

10y6 24, y1 1, y2 2, y3 1, y4 1, y5 2, y6 1}, and the prime call pattern

corresponds to the feasible solution of the constraint {z Z3+ : 2z1 + 3z2 + 5z3 24, z1

11, z2 4, z3 2}.

As already shown, there is a hierarchy of aggregation among the three call patterns

defined, and we can obtain different reformulations by using three different kinds of call

patterns. Note that the total number of feasible call patterns becomes smaller as we ag-

gregate the calls. Actually, our motivation to define the aggregated call pattern is that it

may generate fewer columns during the column generation procedure, thereby ultimately

14


15/25

speeding up the convergence of the algorithm. In the next subsection, we consider the three

reformulations from the algorithmic viewpoint.

5.3. Algorithmic Perspective

Note that the branch-and-price algorithm for the original Dantzig-Wolfe reformulation can

easily be applied to the generalized reformulation with minor modifications. In particular,

the pattern generation subproblem becomes a nonlinear bounded integer knapsack problem

that can be easily transformed to the binary integer cases. Therefore, we can apply the

previous DP algorithm directly.

The overall performance of the LP-based branch-and-bound algorithm is greatly influ-

enced by the strength of the LP relaxation bound. The following proposition shows the

relative strength of the LP relaxation bounds for our reformulations; this result can be

directly obtained from the definition of each call pattern.

Proposition 2 LetZoriginal, Zreduced and Zprime be the optimal values of the LP relaxations

of the reformulations with the original, reduced, and prime call pattern, respectively. Then,

we have

Zprime Zreduced Zoriginal.

Note also that there is a trade-off between the total number of feasible call patterns foreach reformulation and the strength of the LP bound.

Based on our computational experience of branch-and-price algorithms, in many cases the

major bottleneck of the overall algorithm lies in solving the master LP problems since they

contain too many columns, a situation particularly relevant to large-scale problems. The

time required for solving master problems can be expected to decrease by generating fewer

columns. Therefore, computation of the overall algorithm will be accelerated by properly

aggregating given calls although this approach may generate more nodes in the branch-and-

bound tree. The advantage of call aggregation will be demonstrated by our computational

tests in Section 6. Similar results have also been reported in the literature. For large-scale

bin packing instances, Vanderbeck (1999) reported that in a similar aggregation scheme,

the replacement of same-sized items by a single item, with demand equal to the number of

duplicates, performed better than the original algorithm. Ben Amor et al. (2006) showed that

this aggregation scheme is equivalent to requiring that the dual variables corresponding to

15


16/25

items of the same length are equal, so that it restricts the dual space and therefore stabilizes

the dual solutions.

6. Computational Results

We compared our branch-and-price algorithm with a naive linearization, which can be ob-

tained by replacing the edge capacity be 1 of the original formulation by the be 1 numbers

of binary variables, each of which is associated with a unique utilization of edge.

6.1. Naive Linearization

The reformulation Plinear is as follows.

(Plinear) maxkK

wkyk

s.t.

xkji

xkij =

yk, if i = sk;yk, if i = tk;

0, otherwise.k K, i V, (32)

xkij + xkji x

ke , k K, e = {i, j} E, (33)

kK

rkxke

be1u=1

uzue , e E, (34)

be1u=1

zue 1, e E. (35)

eE

be1u=1

(u

be u)zue , (36)

xkij {0, 1}, k K, e = {i, j} E, (37)

yk {0, 1}, k K, (38)

zue {0, 1}, u {1, . . . , be 1}, e E, (39)

where yk takes value 1 if call k is selected, xkij takes value 1 if call k is routed through

a path that uses arc ij, and zue takes value 1 if the utilization of edge e is assigned as u.

Constraint set (32) contains the flow conservation equations, and arc variable xkij and edge

variable xke are linked together in constraint set (33). The right-hand sides of the constraints

(34) represent the utilization of each edge. Constraint set (35) ensures that at most one of

the utilization values must be assigned to each edge. If none of the zue variables for edge e

16


17/25

takes value 1, the utilization of edge e is 0. In constraint (36), the delay of edge e is directly

given as u/(be u) when the utilization of edge e is u, which makes the original nonlinear

delay constraint become linear. This formulation has the advantage that it can be solved

directly using an integer programming software. However, this is not a good formulation

since there are too many z variables when edge capacities become large, making the problem

difficult to solve.

6.2. Instances

We performed several computational tests on random networks and real-life telecommunica-

tions networks from SNDlib(http://sndlib.zib.de). The algorithm was coded in C#, and all

tests were performed on a AMD X4 3.00 GHz PC with 4GB RAM. We solved mixed integer

program Plinear and master linear programs for the branch-and-price algorithm using CPLEX12.1. Our algorithm was first tested on randomly generated networks; the generation scheme

of the random networks was adopted from Rolland et al. (1999), as follows.

Given the number of nodes, we randomly generated the position of each node on a

100100 grid and assign a degree equal to 2, 3, or 4 with probability of 0.6, 0.3, and 0.1

respectively. The distance between the pair of nodes equals the Euclidean distance. We then

assign edges in a greedy manner as follows. For each node, we find the closest node with

an unsatisfied degree requirement and create an edge between the two nodes; this step is

repeated until the degree requirement of the node is satisfied. If the degree requirement ofthe node cannot be satisfied, then we connect the node to its closest node. If the network

is not connected, we create additional edges to ensure that it is connected. The capacity of

each edge is randomly chosen in the range of [10, 50].

We also generated the data for calls. Given the number of calls, we randomly determine

a source node and a sink node for each call. The demand value of each call is randomly

chosen in the range of [1, 20], and the revenue of each call is set to 10R, where R is a

randomly generated integer in the range of [10, 100].

Next, we tested our algorithm on the real-life telecommunications networks which were

taken from SNDlib (Orlowski et al. 2010). Since the original problems are network design

problems, we randomly determined the edge capacities for approximately half of calls to flow

simultaneously on the given network. The revenue of each call is determined in the same

manner as in random networks.

17


18/25

Table 1: The effect of delay limitInstance Solution % edge utilization

|V| |K| DM T otal reve nue Tot al de lay Aver age Maxim um

20 40 0.4 8570 15.03 0.33 0.650.6 9830 33.23 0.45 0.86

0.8 10440 91.89 0.59 0.97

25 50 0.4 9010 21.72 0.27 0.830.6 10800 45.43 0.39 0.850.8 11080 93.45 0.41 0.95

30 60 0.4 14340 24.00 0.33 0.680.6 16280 50.14 0.39 0.930.8 16930 133.36 0.47 0.96

35 70 0.4 9180 22.64 0.26 0.700.6 10820 63.94 0.36 0.900.8 11320 119.50 0.42 0.95

6.3. Analysis and Discussion

Table 1-5 show the results of our computational experiments. The meanings of the headings

used in the tables are summarized as follows:

|V| : the number of nodes in the network.

|K| : the number of calls.

DM : delay multiplier, the upper limit on the queueing delay = |E| DM/(1 DM).

#node : the number of generated nodes in the branch-and-bound tree.

#path : the total number of generated paths.

#ptn : the total number of generated patterns.

#lp : the total number of master LP solved.

root : the optimal value at the root node of the branch-and-bound tree.

opt : the integer optimal value.

gap : (root LP value - optimal value) 100 / (optimal value).

lp : the total time spent in solving the master LPs in seconds.

sp: the total time spent in solving the shortest path problem in seconds.

kp : the total time spent in solving the nonlinear knapsack problem in seconds.hr : the total time spent in primal heuristic in seconds.

total : the total time spent in solving the problem in seconds.

First, the effect of the delay limit is shown in Table 1 for those networks with the number

of nodes ranging from 20 to 35. The result shows the trade-off between the total revenue

earned and the quality of service to network users. When the delay limit increases, total

18


19/25

Table 2: The results on small networksInstance Branch-and-price Time

|V| |K| DM alg #node #path #ptn #lp root opt gap lp sp kp hr total

20 40 0 .6 orginal 65 245 5859 1164 10020.5 9830 1.94 11.74 0.95 2.87 0.03 22.44reduced 87 177 2847 802 10309.8 9830 4.88 3.79 0.55 1.41 0.04 7.5

prime 217 167 2637 1036 10386.0 9830 5.66 5.13 0.7 1.57 0.05 9.06linear 364 10418.3 9830 5.98 9.62

25 50 0.6 o riginal 13 321 1775 427 10917.8 10800 1.09 1.95 0.52 1.34 0.28 5.75reduced 75 322 2284 790 11091.4 10800 2.70 2.84 0.87 1.94 1.15 8.54

prime 133 268 1555 675 11119.1 10800 2.95 1.8 0.7 1.09 0.2 4.87linear 245 11177.5 10800 3.50 8.71

30 60 0.6 o riginal 37 167 2289 599 16471.1 16280 1.17 2.62 0.97 3.55 0.03 9.69reduced 107 171 2591 832 16593.4 16280 1.93 3.44 1.19 3.33 0.04 10.07

prime 157 154 2033 753 16621.4 16280 2.10 2.51 1.02 1.99 0.38 7.42linear 426 16621.7 16280 2.10 11.16

35 70 0.6 original 59 610 6159 1142 11034.8 10820 1.99 21.85 2.8 7.59 6.13 50.34reduced 281 540 4629 1727 11212.0 10820 3.62 20.82 3.48 7.67 0.14 38.55

prime 681 437 3613 2075 11350.8 10820 4.91 23.29 4.12 5.83 1.39 40.34linear 361 11702.0 10820 8.15 29.72

revenue increases at the expense of the deteriorated quality of service to users, which is

reflected in the total delay and the utilization of edges.

Table 2 reports the performance of our branch-and-price algorithm on small networks.

The number of nodes ranges from 20 to 35, and the number of calls is set to two times the

number of nodes. The delay multiplier was fixed to 0.6 in order to examine the effect of

the network size on the performance of the algorithms. For each instance, the first three

rows report the performance of the branch-and-price algorithms with three different choices

of call patterns. Also, the fourth row shows the result of CPLEX to solve Plinear directly.

Note that we used the default CPLEX parameters. This includes the generation of cuts for

general mixed integer programs and the use of primal heuristics at each branch-and-bound

node. On small-sized networks, both the branch-and-price algorithms with three kinds of

call patterns and CPLEX perform well. Note that the results also show that among the

three kinds of patterns, there is a trade-off between the number of generated call patterns

and the strength of the LP relaxation bound. We can also see that with worse LP relaxation

bound, it is necessary to generate more branch-and-bound nodes, since more branching is

required during the execution of the algorithm.

Table 3 provides the results on small networks with a large number of calls. The column

%|K| means that the number of calls is determined by the percentage of all possible calls.

For example, in a network with 30 nodes, if 80% of calls are given, the number of calls is 696

(30290.8). When the integer optimal solution is not found within 1 hour, the total time

19


20/25

Table 3: The results on small networks with large number of callsInstance Branch-and-price Time

|V| %|K| DM alg #node #path #ptn #lp root opt gap lp sp kp hr total

20 80 0.6 original 2251 892 34943 12790 23063.0 22830 0.67 3062.0 37.68 104.11 20.31 3600*reduced 713 527 4550 2825 23375.6 22910 2.03 24.3 6.6 8.4 0.4 48.9

prime 2163 627 3768 4216 23464.3 22910 2.42 67.4 9.6 8.2 1.5 100.7linear 829 23465.7 22910 2.43 39.6


prime 15317 1231 7848 10237 33418.4 32400 3.14 1029.5 128.8 97.8 14.2 1787.3linear 1361 33436.4 32400 3.20 231.0


prime 14089 1495 6240 10211 45973.4 45490 1.06 340.1 201.2 71.5 10.6 801.7linear 1720 46145.0 45490 1.44 1013.2

35 80 0.6 o riginal failed to solve the root node within 1 hourreduced 4725 3186 12394 12181 55919.1 55340 1.05 721.6 257.3 102.2 6.7 1293.3

prime 14311 6435 8058 21051 56282.5 55340 1.70 2582.4 430.5 97.4 41.7 3600*linear 5982 56308.3 55340 1.75 3600*

Note. () : Value of the best integer solution. (*) : No integer optimal solution was found within 1 hour.

in the table is expressed as 3600* and the entries in the opt column denote the values of

the best integer solutions. We can see that the branch-and-price algorithm with the original

call pattern shows a disappointing performance. The algorithm was not able to find optimal

solutions for all instances within 1 hour. Note also that with increasing network size, the

branch-and-price algorithm with reduced or prime call patterns perform better than the

CPLEX. For the problem with a large number of calls, an excessive number of original callpatterns has to be generated compared to the reduced or prime call pattern cases. The reason

for this is that many original call patterns with essentially identical symmetric structure can

be reduced to a common reduced or prime call pattern. Hence, the use of the aggregated

call pattern may disrupt the symmetry in many almost identical call patterns during the

algorithm, which facilitates fast convergence in the column generation procedure. Although

the aggregated call pattern does give worse LP relaxation bound, the advantage of generating

fewer columns far surpasses this weakness.

The results on large networks are shown in Table 4. Since the branch-and-price algorithm

with the original call pattern shows a poor performance even for small networks, the results

for the original call pattern are omitted in Table 4. This algorithm was actually not able

to solve even the root nodes within 1 hour. When the integer optimal solution is not found

within 1 hour even for all three algorithms, entries in the gap column are reported with

an () and denote gaps between the root LP value and the best integer solution obtained

20


21/25

Table 4: The results on large networksInstance Branch-and-price Time

|V| %|K| DM alg #node #path #ptn #lp root opt gap lp sp kp h r total

50 60 0.6 reduced 6135 2185 16765 14943 55451.8 54820 1.15 1233.7 425.2 145.7 10.1 2180.2prime 16084 3178 10176 22190 55642.1 54510 1.50 2110.7 638.8 136.9 55.3 3600*

linear 320 55653.1 54150 1.52 3600*

60 60 0.6 reduced 7298 4299 18595 16884 64958.1 64090 1.35 1780.5 846.8 194.0 29.6 3600*prime 21365 1652 5096 24211 65553.3 63740 2.28 1120.3 1177.6 167.0 58.0 3600*linear 24 65787.9 62850 2.65 3600*

70 60 0.6 reduced 10559 2265 9585 15967 390990.8 389710 0.33 1215.7 1048.1 243.0 34.5 3600*prime 16591 1920 5137 19287 391393.8 388960 0.43 736.1 1259.6 173.2 50.4 3600*linear failed to solve the root node within 1 hour




Note. () : Value of the best integer solution. () : Gap between the root LP value and the value of the best integer solutionobtained from the three algorithms. (*) : No integer optimal solution was found within 1 hour.

from the three algorithms. We can observe that, for the network with more than 70 nodes,

CPLEX no longer gives an integer feasible solution within 1 hour. However, the branch-

and-price algorithm with reduced or prime call patterns does give a solution which is close

to being optimal.The results for several instances from SNDlib, which are composed of networks of various

sizes, are summarized in Table 5. The number of nodes ranges from 11 to 50, and the

number of calls ranges from 22 to 780. The results and computational behaviors are not

much different from those obtained using randomly generated networks.

In summary, the proposed algorithm is effective in obtaining optimal or near optimal

solutions within a reasonable amount of time for two types of networks: random and real-life

networks with up to 100 nodes, which are quite large in terms of the size of the network

compared to the random networks with up to 40 nodes considered by Rolland et al. (1999)

to test their Lagrangian relaxation-based heuristic algorithm. It is noteworthy that our

algorithm could find good integer solutions in quite a short time while proving optimality of

them required much longer time. This suggests that our algorithm can be applicable as a

good heuristic algorithm for even larger-sized networks.

21


22/25

Table 5: Results on the SNDlib networksInstance Branch-and-price Time

name |V| |E| |K| DM alg #node #path #ptn #lp root opt gap total

di-yuan 11 42 22 0.6 reduced 33 503 135 151 2672.2 2580 3.57 0.41prime 1713 1313 209 2343 2830.0 2580 9.69 8.99

linear 20 3157.5 2580 22.38 1.14dfn-gwin 11 47 110 0.6 reduced 466 27716 14325 6925 38181.2 37895 0.76 3600*

prime 1659 10391 23233 9100 38303.5 37895 1.08 3600*linear 2435 38305.6 37895 1.08 3600*

nob el-germany 17 26 121 0.6 reduced 4290 712 1083 5063 23970.8 23780 0.80 49.34prime 27092 726 1480 28188 24009.3 23780 0.96 322.28linear 1701 24041.2 23780 1.10 47.43

nob el-eu 28 41 378 0.6 reduced 2234 2042 3715 4221 138130.1 138087 0.03 256.68prime 10937 1853 3568 13067 138133.0 138087 0.03 838.53linear 5861 138138.6 137912 0.04 3600*

pioro40 40 89 780 0.6 reduced 328 46219 10300 8098 54410.6 53874 1.00 3600*prime 138 21701 30492 6355 56766.8 52832 5.37 3600*linear 1 57102.4 51694 6.00 3600*

germany50 50 88 662 0.6 reduced 34481 7416 2424 40024 153844.9 153537 0.19 3600*prime 18588 15008 2998 30031 153833.0 153547 0.19 3600*linear 0 154140.3 - 0.39 3600*

Note. () : Value of the best integer solution. () : Gap between the root LP value and the value of the best integer solutionobtained from the three algorithms. (*) : No integer optimal solution was found within 1 hour.

7. Conclusion

In this paper, we formulated the delay-constrained bandwidth packing problem (DCBWP)

as an integer programming problem using the Dantzig-Wolfe decomposition and proposed a

branch-and-price algorithm to solve it. The nonlinearity in the original formulation is then

transferred to the nonlinear knapsack subproblem that can be efficiently solved by slightly

modifying the dynamic programming algorithm for the ordinary knapsack problem. We also

extended the Dantzig-Wolfe reformulation to a more general form by introducing aggregated

call patterns and proposed three kinds of call patterns as special cases, including the original

call pattern. Using the aggregated call patterns, we were able to obtain the optimal or almost

optimal solutions within reasonable computational time for randomly generated networks

and instances from SNDlib. The original call pattern generates an excessive number ofsymmetric columns during the algorithm, which results in the master LP problem being too

large and, consequently, performing poorly for large networks. Computational experiments

showed that the aggregated call pattern may play a role in breaking the symmetry in feasible

patterns during the algorithm, which suggests that it may be the best choice for the large-

scale networks.

22


23/25

Acknowledgments

This research was supported by Basic Science Research Program through the National Re-

search Foundation of Korea (NRF) funded by the Ministry of Education, Science and Tech-

nology (2011-0027301).

References

Amiri, A. 2005. The selection and scheduling of telecommunication calls with time windows.

Eur. J. Oper. Res. 167 243256.

Amiri, A., R. Barkhi. 2000. The multi-hour bandwidth packing problem. Comput. Oper.

Res. 27 114.

Amiri, A., R. Barkhi. 2011. The combinatorial bandwidth packing problem. Eur. J. Oper.

Res. 208 3745.

Amiri, A., E. Rolland, R. Barkhi. 1999. Bandwidth packing with queuing delay costs:

Bounding and heuristic solution procedures. Eur. J. Oper. Res. 112 635645.

Anderson, C. A., K. Fraughnaugh, M. Parker, J. Ryan. 1993. Path assignment for call

routing, an application of tabu search. Ann. Oper. Res. 41 299312.

Barnhart, C., C. A. Hane, P. H. Vance. 2000. Using branch-and-price-and-cut to solve

origin-destination integer multicommodity flow problems. Oper. Res. 48 318326.

Barnhart, C., E. L. Johnson, G. L. Nemhauser, G. L. Savelsbergh, P. H. Vance. 1998.

Branch-and-price: Column generation for solving huge integer programs. Oper. Res. 46

316329.

Ben Amor, H., J. Desrosiers, J. M. Valerio de Carvalho. 2006. Dual-optimal inequalities for

stabilized column generation. Oper. Res. 54 454463.

Bose, I. 2009. Bandwidth packing with priority classes. Eur. J. Oper. Res. 192 313325.

Cox Jr, L. A., L. Davis, Y. Qiu. 1991. Dynamic anticipatory routing in circuit-switched

telecommunications networks. Handbook of Genetic Algorithms . New York: Van Nostrand

Reinhold, 124143.

23


24/25

Desaulniers, G., J. Desrosiers, M.M. Solomon (Eds.). 2005. Column generation. Springer

Verlag.

Elhedhli, S. 2005. Exact solution of a class of nonlinear knapsack problems. Oper. Res. Lett.

33 615624.

Gavish, B., K. Altinkemer. 1990. Backbone network design tools with economic tradeoffs.

INFORMS J. Comput. 2 236252.

Gavish, B., S. Hantler. 1983. An algorithm for optimal route selection in sna networks. IEEE

T. Commun. 31 1541161.

Geffard, J. 2001. A solving method for singly routing traffic demand in telecommunication

networks. Ann. Telecommun. 56 140149.

Kleinrock, L. 1964. Communications nets: stochastic message flow and delay. New York:

Dover.

Laguna, M., F. Glover. 1993. Bandwidth packing: a tabu search approach. Management

Sci. 39 492500.

Lee, C. 2009. Robust optimization models and algorithms for the problems in telecommuni-

cation and logistics. Ph.D. thesis, Korea Advanced Institute of Science and Technology.

Orlowski, S., R. Wessaly, M. Pioro, A. Tomazewski. 2010. Sndlib 1.0 - survivable network

design library. Networks 55 276286.

Park, K., S. Kang, S. Park. 1996. An integer programming approach to the bandwidth

packing problem. Management Sci. 42 12771291.

Park, S., D. Kim, K. Lee. 2003. An integer programming approach to the path selection

problems. International Network Optimization Conference. Evry/Paris, France, 448453.

Parker, M., J. Ryan. 1993. A column generation algorithm for bandwidth packing. Telecom-

mun. Syst. 2 185195.

Rolland, E., A. Amiri, R. Barkhi. 1999. Queueing delay guarantees in bandwidth packing.

Comput. Oper. Res. 26 921935.

24


25/25

Vanderbeck, F. 1999. Computational study of a column generation algorithm for bin packing

and cutting stock problems. Math. Programming 86 565594.

Villa, C., K. Hoffman. 2006. A column-generation and branch-and-cut approach to the

bandwidth-packing problem. J. Res. NIST111

161185.

exact algorithms for a bandwidth packing problem with queueing delay guarantees

Documents