Algorithms for precomputing constrained widest paths and multicast trees

Abstract

We consider the problem of precomputing constrained widest paths and multicast trees in a communication network. Precomputing and storing of the relevant information minimizes the computational overhead required to determine an optimal path when a new connection request arrives. We evaluate algorithms that precompute paths with maximal bandwidth (widest paths), which in addition satisfy given end-to-end delay constraints. We analyze and compare both the worst case and average case performance of the algorithms. We also show how the precomputed paths can be used to provide computationally efficient solutions to the constrained widest multicast tree problem. In this problem, a multicast tree with maximal bandwidth (widest multicast tree) is sought, which in addition satisfies given end-to-end delay constraints for each path on the tree from the source to a multicast destination.

Full text

Page 1

1174IEEE/ACM TRANSACTIONS ON NETWORKING, VOL. 13, NO. 5, OCTOBER 2005
Algorithms for Precomputing Constrained
Widest Paths and Multicast Trees
Stavroula Siachalou and Leonidas Georgiadis, Senior Member, IEEE
Abstract—We consider the problem of precomputing con-
strained widest paths and multicast trees in a communication
network. Precomputing and storing of the relevant information
minimizes the computational overhead required to determine an
optimal path when a new connection request arrives. We evaluate
algorithms that precompute paths with maximal bandwidth
(widest paths), which in addition satisfy given end-to-end delay
constraints. We analyze and compare both the worst case and
average case performance of the algorithms. We also show how
the precomputed paths can be used to provide computation-
ally efficient solutions to the constrained widest multicast tree
problem. In this problem, a multicast tree with maximal band-
width (widest multicast tree) is sought, which in addition satisfies
given end-to-end delay constraints for each path on the tree from
the source to a multicast destination.
Index Terms—Bottleneck paths, graph theory, multicast trees,
precomputation, QoS routing, widest paths, widest trees.
I. INTRODUCTION
I
(e.g., bandwidth, end-to-end delay, and packet loss), col-
lectively known as quality of service (QoS) requirements,
introduces many challenges. In such an environment, where
a large number of new requests with widely varying QoS
requirements arrive per unit of time, it is important to develop
algorithms for the identification of paths that satisfy the QoS
requirements (i.e., feasible paths) of a givenconnection request,
with minimal computational overhead. Minimization of the
overall computational overhead can be achieved by computing
a priori (precomputing) and storing all relevant paths in a data
base. The computation of all relevant paths is also an important
intermediate step in the development of algorithms for other
problems related to networking [12], [14], [16]. Hence, it is
important to study and evaluate algorithms that specifically
address the precomputation problem.
While a large number of studies addressed the Constrained
Path Routing Problem (see [2], [3], [8], [11], [13], [15], [18],
and [22] and the references therein), there are relatively few
works addressing the specific issues related to precomputing
pathswithQoSconstraints.In[9],theproblemofprecomputing
N TODAY’S communication networks, transmission of
multimedia traffic with varying performance requirements
ManuscriptreceivedJuly18,2003;revisedMay7,2004,andOctober1,2004;
approved by IEEE/ACM TRANSACTIONS ON NETWORKING Editor R. Cohen.
This paper was presented in part at the Networking Conference, May 2004,
Athens, Greece.
The authors are with the School of School of Electrical and Computer
EngineeringDepartment,Telecommunications
UniversityofThessaloniki,Thessaloniki,
stavroula@psyche.ee.auth.gr; leonid@auth.gr).
Digital Object Identifier 10.1109/TNET.2005.857117
Department,
54124
Aristotle
(e-mail:Greece
optimal paths under hop-count constraints is investigated and
an algorithm is proposed that has superior performance than
Bellman Ford’s algorithm in terms of worst case bounds. In
[20],byconsideringthehierarchicalstructurewhichistypicalin
large-scale networks, an algorithm which offers substantial im-
provements in terms of computational complexity is presented.
These studies concentrated on the hop-count path constraint.
The algorithms in [5], [18], and [22] can be used for precompu-
tation under general QoS constraints. In [5], a subset of the “rel-
evant” (see Section II for explanation) paths are precomputed.
The algorithms in [18] and [22] are similar in spirit, however,
the one in [22] avoids steps that would compute irrelevant paths
and hence achieves better worst case performance.
In the first part of this paper, we focus on the problem of pre-
computing paths with maximal bandwidth (path bandwidth is
theminimalofthepathlinkbandwidths),whichinadditionmust
satisfygivenend-to-enddelayrequirements.Wecallthesepaths
constrained widest paths. As mentioned in [10], in order to ac-
cept as many requests as possible, it is important to select paths
with maximal bandwidth. This way, after a connection is ac-
cepted, the leftover minimum bandwidth on the path links will
be as large as possible. We examine three algorithms that pro-
videallrelevantpaths.Thefirstalgorithmisanapplicationinthe
specific context of the algorithm developed in [22] for the gen-
eral Constrained Path Routing Problem. The second is based on
an implementation of the basic algorithmic steps in [22] using
data structures that take advantage of properties of the problem
at hand. The third algorithm improves on an approach whereby
iteratively relevant paths are determined and links that are not
needed for further computation are eliminated [12]. We analyze
the worst case performance of the algorithms in terms of run-
ning time and space requirements. In addition, we compare the
average case running time and space requirements of the algo-
rithmsthroughsimulations.Theanalysisshowsthetradeoffsin-
volved in the implementation of each of the algorithms.
In the second part of this paper, we consider the constrained
widestmulticasttreeproblem.Inthisproblem,amulticasttreeis
sought with maximal bandwidth (tree bandwidth is the minimal
of the tree link bandwidths), which in addition satisfies given
end-to-end delay constraints for each path on the tree from the
source to a multicast destination. We show that, using the pre-
computed constrained widest paths, an algorithm can be devel-
oped that computes very efficiently the required tree. Hence, in
effect, by precomputing the constrained widest paths, we also
precompute all of the constrained widest multicast trees.
The remainder of this paper is organized as follows. The
problem is formulated in Section II. We present the algorithms
in Section III, and in Section IV we examine the algorithms in
1063-6692/$20.00 © 2005 IEEE

Page 2

SIACHALOU AND GEORGIADIS: ALGORITHMS FOR PRECOMPUTING CONSTRAINED WIDEST PATHS AND MULTICAST TREES1175
terms of worst case running time and memory requirements. In
Section V, we show how the precomputed paths can be used to
provide efficient computation of the constrained widest multi-
cast tree problem. Section VI presents numerical experiments
that evaluate the performance of the proposed algorithms.
Conclusions are presented in Section VII.
II. MODEL AND PROBLEM FORMULATION
In this section, we formulate the problem related to the pre-
computation of constrained widest paths and define some nota-
tion that will be used in the rest of the paper.
A network is represented by a directed graph
where
is the set of nodes and
Let
and. A link
destination node
is denoted by
of nodes
, such that
, andis the number of hops of . By , we
also denote the set of links on the path, i.e., all links of the form
. By
respectively,thesetofincomingandoutgoingneighborstonode
, that is
,
is the set of edges (links).
with origin node
. A path is a sequence
and
for all
and, we denote,
respectively.
With each link
width
delay of the path , respectively, as
, there is an associated
. We define the width and theand a delay
The set of all paths with origin node , destination node
and delay less than or equal to
of all paths fromtois denoted by
In a computer network environment,
as the free bandwidth on link
sume that a connection request has bandwidth requirements
and end-to-end delay requirement . Upon the arrival of a new
connection request with origin node
a path must be selected that joins the source to the destina-
tion, such that the connection bandwidth is smaller than the free
bandwidth on each link on the path, and the end-to-end delay of
connection packets is smaller than the path delay. It is often de-
sirable to route the connection through the path with the largest
width in
; this ensures that the bandwidth requirements of
the connection will be satisfied, if at all possible, and the delay
guarantees will be provided. Moreover, the leftover minimum
bandwidth on the path links after connection acceptance will be
as large as possible. We call such a path the “constrained widest
path.”
According to the previous discussion, upon the arrival of a
new connection request with end-to-end delay requirement ,
we must select a path
problem.
,
is denoted by. The set
.
may be interpreted
as the link delay. As-and
and destination node ,
that solves the following
Fig. 1.Example network.
Problem I: Given the source node
and a delay requirement , find a path
a destination node
that satisfies
,
for all
Note that, when
problem addressed in [9], i.e., the problem of finding a widest
path with hop count at most . Let us assume that the source
node
is fixed. In principle, in order to be able to select the ap-
propriate path for any delay requirement, one must precompute
for each destination
and each delay , an appropriate optimal
path
. At first, this may seem rather formidable, both in
terms of running time and in termsof space requirements. How-
ever, the situation is greatly simplified by the observation that
oneneedstoprecomputethepaths
delays [12], [16], [22]. Indeed, let
lution to Problem I (if no solution exists, set
canbeeasilyseenusingsimilarargumentsasin[22]that
is a piecewise-constant, right continuous, nondecreasing func-
tion with a finite number of discontinuities. Consider for ex-
ample the network in Fig. 1, where the pair
link denotes the link delay and width, respectively. As shown in
this figure, in this example, there are four paths from node
. Hence, we have
for all, Problem Ireduces tothe
for onlyasubsetofthe
be the value of the so-
). It
above each
to
Based on this, we can plot the graph of
The points
spectively. Notice that for
corresponds to the width of path
and larger width than path
in Fig. 2.
correspond to paths, re-
the optimal width
, which has smaller delay
. Hence, there is no discontinuity

Page 3

1176IEEE/ACM TRANSACTIONS ON NETWORKING, VOL. 13, NO. 5, OCTOBER 2005
Fig. 2. Plot of ? ??? for the network in Fig. 1.
at point, even though the pathis added to the set at
.
Hence, to determine the function
knowthevaluesof
the paths that cause these discontinuities—seeSection III-A). A
discontinuityof
willalsobereferredtoasadiscontinuity
of node .
In fact, from the routing perspective, the pairs
where
is a discontinuity point of
esting ones, even if one takes into account routing requirements
different than those considered in Problem I—in Section V we
present such a situation. Specifically, under our interpretation
of path delay and width, among pairs
there is a natural “preference relation.” That is, we
would like to obtain paths that have as small delay as possible
and as large width as possible. We are thus led to the following
natural definition of dominance.
Definition I (Dominance Relation): We say that pair
dominates
(orthatpathdominates
and
and
Hence,thepairsofinterestinoursetuparethoseforwhichno
other dominating pair can be found for the same origin-destina-
tion nodes. This set of paths is generally known as the nondom-
inated or the Pareto-optimal set [6], [18]. From a precomputa-
tion perspective, it is desirable to determine for each destination
, the set of nondominated pairs (and the associated paths). It
can be shown that this set is exactly the set of discontinuities of
.
we only need to
atthesediscontinuities (wealsoneed
,
are the most inter-
pair
path) if either
or
.
III. ALGORITHM DESCRIPTION
In [22], the problem of determining the function discontinu-
ities for multiple additive link costs (i.e., cost of a path is the
sum of its link costs) has been addressed. In the current setup,
the main difference is that the path width is the minimum of its
link widths (rather than the sum). However, the general algo-
rithms in [22] can be adapted to the problem under considera-
tion with minor modifications, as outlined in Section III-A. In
Sections III-B and III-C, we present two additional algorithms
that take into account the particular structure of the problem
under consideration. The first is an implementation of the al-
gorithm in [22] that uses efficient data structures. The second
usesa“natural”approachthateliminatessuccessivelyunneeded
graph edges and uses a dynamic version of Dijkstra’s algorithm
to determine all function discontinuities. Our intent is to com-
parethesealgorithmsintermsofworstcaseandaveragerunning
times and space requirements.
A. Algorithm I (ALG I)
The algorithms proposed in [22] are based on the following
facts, which carry overto thesituation at hand. In the discussion
that follows, we assume for convenience that
for any real
Hence, by convention, the source node
zero.
• For any
if
there is a
such that
and
the pair
the successor discontinuity of
.Also,
thepredecessordiscontinuityof
that the pair
is a discontinuity point, then its
“possible” successor discontinuities are pairs of the form
is defined
, and.
has a discontinuity at
is discontinuous at , then
is discontinuous at
. We call
is called
.Ifitisknown
• Ifisdiscontinuousat ,thenthereisapath
such that
• Suppose that we impose a lexicographic order relation
between pairs
is larger than
order,
or (and
Suppose also that, among all the discontinuities of
the functions
smallest ones (with respect to the lexicographic order).
Call this set
. Letbe the discontinuities in
belong to node function
The set of possible successor discontinuities of those in
, that are larger than or equal to the discontinuities in
is denoted by
. Let
and letbe the node to which this possible discontinuity
belongs. Then
is a real discontinuity for node
and the
-smallest among all the node discontinuities
of the functions
, as follows. We say that
in the lexicographic
, if and only if (iff) either
.
, we know the set of the
that
. Hence,.
,
be a smallest element of
,
, iff
(1)
The proof of correctness of the facts above is analogous to
argumentsusedin[22,Lemma2andargumentsinSection
3.1.1]. We outline the arguments leading to (1), since it is
essential for understanding the algorithm. Let
be

Page 4

SIACHALOU AND GEORGIADIS: ALGORITHMS FOR PRECOMPUTING CONSTRAINED WIDEST PATHS AND MULTICAST TREES 1177
TABLE I
GENERIC ALGORITHM FOR SOLVING PROBLEM I
the discontinuity in
also with the largest width since
Since
is larger than
order, it must hold,
dominates or is equal to
be a new real discontinuity. Assume next that
Then necessarily
nates
which contradicts the fact that
adiscontinuityof
tinuity of a node
can be shown that, if there is a node discontinuity not in
, smaller thanin the lexicographic order, then
there must also be a discontinuity
successor is larger than the discontinuities in
belongs to) and smaller than
ever, this contradicts the fact that
element of
. Hence, there is no discontinuity in
larger than and smaller than
is not dominated by any of the discontinuities in
, it must itself be a discontinuity.
Based on these facts, we can construct an algorithm for de-
termining all node discontinuities as described below. In the
following, we will need to know the node
or possible discontinuity
note this discontinuity by
we set
.ThegenericalgorithmispresentedinTableI.Steps
1–4 of Algorithm I initialize the discontinuities pairs for each
node. In step 5, having identified a real discontinuity
the algorithm creates the set of all possible discontinuities that
have
as a predecessor. If there are no possible dis-
continuities (step 6), the algorithm stops. Else, in step 7, the
smallest possible discontinuity in the lexicographic order is ex-
tracted from
. In step 8, it is examined whether the latter dis-
continuity is a real one. If it is, it is added to the appropriate set
(step 10); else the next possible discontinuity is extracted from
, i.e., the algorithm moves to step 6. A schematic diagram of
the operation, taken from [22], is given in Fig. 3.
In [22], two implementations of the generic algorithm were
proposed, which differ mainly in the manner in which the set
with the largest delay—hence,
is nondecreasing.
in the lexicographic
. If
. Hence,
, then
cannot
.
, since otherwisedomi-
is
.Usingthefactthateverydiscon-
has a predecessor discontinuity, it
inwhose
(hence
. How-
is the smallest
, and since
to which a real
belongs. For clarity, we de-
. For initialization purposes,
and
,
Fig. 3.Basic steps of Algorithm I.
is organized. In the current work, we pick the implementation
that was shown to be more efficient both in worst case and av-
erage case analysis. For our purposes, it is important to note
that the sets
are implemented as FIFO queues and that the
elements
in these queues are generated and stored in
increasingorderofboth and
thermore, in our implementation of Algorithm I, we introduce
an additional optimization that is based on the following obser-
vation in [9]: whenever a real discontinuity
and the possible discontinuities caused by
then links
with
from further consideration. This is so, since these links cannot
contribute to the creation of new discontinuities for node . In-
deed, any newfound discontinuity
create a possible discontinuity
However,
, and hence this possible discon-
tinuity cannot be a real one for node .
As usual, in order to be able to find by the end of the algo-
rithm not only the discontinuities, but paths that correspond
to these discontinuities, one must keep track of predecessor
discontinuities as well. That is, in the implementation, we
keep track of
node
is a pointer to the predecessor disconti-
nuity of
. To simplify the notation, in the description of
all algorithms, we do not explicitly denote
unless it is needed for the discussion.
asthealgorithmproceeds.Fur-
is found
are created,
can be removed
at node , will
.
, where for the source
, and for any other node
,
B. Algorithm II (ALG II)
The generic algorithm in Table I works also when lexico-
graphic order is defined as
if either
orand

Page 5

1178IEEE/ACM TRANSACTIONS ON NETWORKING, VOL. 13, NO. 5, OCTOBER 2005
In this case, the elements
are generated and stored in decreasing order of both
as the algorithm proceeds.
Algorithm II uses the lexicographic order
an extension of ideas presented in [7] to speedup computations.
The basic observations are the following.
• Suppose that link widths take
. If for link
set
. If one uses
tual width in the calculations, the resulting discontinuities
occuratthesamedelaysandforthesamepathsasiftheac-
tual widths were used. This is true since the steps in Algo-
rithm I use only comparisons between link widths; hence,
the same decisions are taken if
.
• Since a path width is the minimum of the widths of the
pathlinks, pathwidthsalways take one of thevaluesin the
set
, i.e., they take at most
values.Hence,thesameholdsforthevaluesof
the widths of all possible discontinuities.
We use these observations to speed up the computations of
Generic Algorithm I as follows. First, we use
the link widths. Next, we organize the set of possible discon-
tinuities
as follows. We create an array
where
discontinuity of the form
the width of a discontinuity as an index to
workingwith
insteadof
if
wereintegers,wewouldingeneralneedmorespace
for
since the range of the values of
than
. We also create heaps
contains the nonnull elements of
as a key the delay
of a possible discontinuity. Reference [4]
contains various descriptions of heap structures. For our pur-
poses, we need to know that the following operations can be
performed on the elements of a heap structure.
•
: creates an empty heap
• insert
: inserts element
•
: removes and returns an element
with the smallest key.
•
, where element
Fig. 4 shows the data structures used to implement the set
. With these data structures, we implement steps 5 and 7 of
Generic Algorithm I in Table I as follows. For an element
, we denote
in the FIFO queues
and
and is based on
different values
it holds
instead of the link’s ac-
,
is used in place of
different
and
in place of
, if nonnull, denotes a possible
. Note that we are able to use
, since we are
directly,even.Hadweused
would be larger
. Heap
and uses
.
to.
in
: replaces in
has a smaller key than .
elementwith
.
Step 5: Create all possible successor discontinuities of
and add them to.
/* let
, hence we have available the discontinuity
*/
1) For
do
2)
3)
4)
If
is null then
5)
insert
6)
Else
;
Fig. 4.Structures implementing the set of possible discontinuities??.
7)
8)
9)
10)
11) end do
Ifthen
;
;
In step 4, if
fornode
node
. In step 8, when
old possible discontinuity for node
nuitysince
dominates and thereforein steps9 and 10,we
replace
withboth in
way, heap
always contains at most one possible disconti-
nuity of any node . Hence, with steps 9 and 10, we avoid in-
serting unnecessary elements in the heap
the time that the get min operation takes in step 7 of Generic
Algorithm I in Table I. The tradeoff is extra memory space re-
quirements due to array
. We discuss this issue further in
Sections IV and VI.
Step 7: Among the elements
one in the lexicographic order (with respect to
element
.
/* let
, hence we have available the discontinuities
*/
The heaps
are scanned starting from the largest index and
moving to the smallest. The index of the heap currently scanned
is stored in the variable
which is initialized to
1) Find the largest
such that
2)
3) Set
to null.
4)
.
Thescanningprocess(largesttosmallest)workssince,when-
ever a possible discontinuity
possible discontinuities that already exist or might be added
is null, there is no possible discontinuity
withwidth .Hence,anewpossiblediscontinuityfor
with widthis created and placed both inand
we know that the
cannot be a real disconti-
and. Note that, in this
, thus decreasing
, find and extract the minimum
). Denote this
.
is nonempty.
.
is removed from, any