Management Science: Performance Bounds For Flexible Systems Requiring Setups

MANAGEMENT SCIENCE
Vol. 53, No. 6, June 2007, pp. 9911004

issn0025-1909[ eissn1526-5501[ 07[ 5306[ 0991
informs
doi 10.1287/mnsc.1060.0639
2007 INFORMS
Performance Bounds for Flexible
Systems Requiring Setups
Mahender P. Singh
MIT Center for Transportation and Logistics, Massachusetts Institute of Technology, Room E40-363,
77 Massachusetts Avenue, Cambridge, Massachusetts 02139, msingh@mit.edu
Mandyam M. Srinivasan
College of Business Administration, The University of Tennessee, 611 Stokely Management Center,
Knoxville, Tennessee 37996, msrini@utk.edu
M
any organizations use product variety as one possible strategy for increasing their competitiveness. They
have installed exible manufacturing systems because these systems offer a powerful means for accom-
modating production and assembly of a variety of products. However, increased product variety comes at a
cost. For instance, if the resource requires to be set up each time it switches to operate on a new product, the
resulting delays and costs could negate the intended benets of increased product variety. Analyzing these ex-
ible resources for optimal design and operation is therefore very important. To address such issues, we model
a exible resource, serving multiple products, using a queueing modelmore precisely, a polling model. In this
model, a single server attends to multiple service centers (queues) at which requests arrive and queue up for
service, performing a setup at a polled queue only if that queue is nonempty. This is the state dependent (SD)
polling model.
Exact analysis of the SD polling model is inherently very complex. This paper presents a very efcient
procedure to compute a hierarchy of successively improving bounds on the values of performance measures
obtained from the SD polling model with the exact solution as its limit. This procedure can be applied to quickly
estimate performance measures for large SD polling models previously deemed analytically intractable.
Key words: polling models; descendant sets technique; state-dependent service; cyclic service
History: Accepted by Wallace J. Hopp, stochastic models and simulation; received October 4, 2004. This paper
was with the authors 8
1
2
months for 2 revisions.
1. Introduction
Many organizations are using exibility as a weapon
in an increasingly competitive economy. They have
acquired the capability to offer a large variety of
products at a short notice by installing sophisticated
exible resources. However, unless these resources
are properly designed and operated, the benets of
increased product variety could be offset by increased
costs and cycle time delays. Models for analyzing
these systems for effective design and operation are
therefore important. Queueing models, more speci-
cally, polling models, enable such analysis. These mod-
els are used to analyze a system of multiple service
centers (queues) attended to by one or more servers
that attend to requests arriving at these centers by
polling (visiting) them in a pre-specied manner.
Polling models have many other real-world appli-
cations. They are used to analyze computer networks,
telephone switching systems, and manufacturing and
material handling systems, to name a few. Real-world
systems that can be analyzed with polling models
continue to grow as new applications and technology
are introduced. For example, token ring networks and
networks using the ber distributed data interface
(FDDI) protocol are readily analyzed using polling
models. The use of radio frequency data communica-
tion (RFDC) in warehouse management and material
handling systems provides a more recent application
for polling models because RFDC allows the servers
(material handlers) to poll storage locations to deter-
mine whether there is any handling needed at these
locations. Consequently, there is a large body of liter-
ature on polling models that has continued to grow
since the late 1960s when they were rst studied; see
Takagi (1990, 1997) for comprehensive surveys.
In this paper, we focus on a special class of polling
models known as the state dependent (SD) polling mod-
els. In the SD polling model, a single server attends to
the requests waiting at the different queues, perform-
ing a setup only when there are customers waiting for
service at the polled queue. Although the SD model
nds many applications in the real world, it does
not lend itself to easy analysis. Consequently, even
though it is a more appropriate model, the SD polling
991
Singh and Srinivasan: Performance Bounds for Flexible Systems Requiring Setups
992 Management Science 53(6), pp. 9911004, 2007 INFORMS
model is typically approximated by the SI polling
model in which the server is assumed to perform a
setup (or, alternately, never performs a setup) at a
polled queue regardless of its state. Such an approx-
imation is acceptable when the system is so highly
loaded that the server will always nd the polled
queue nonempty. However, from a practical stand-
point, it is usually not desirable to utilize the server
at such high levels because customers will experience
unusually large waiting times.
The inherent complexity in the SD polling model
arises from the fact that the analysis requires addi-
tional information to be maintained on the state of
all queues in the system at all times. Most of the
research on polling models has thus been conned to
the state independent (SI) polling model. To our knowl-
edge, there are very few exact procedures available
for obtaining the moments of the waiting times and
the number of customers for the SD polling model.
Gupta and Srinivasan (1996) obtained these measures
for the special case of a 2-queue model. Eisenberg
(1999) presented an exact analysis for the general N
queue model. Singh and Srinivasan (2001) and Srini-
vasan and Singh (2006) present detailed algorithms
to compute these performance measures for the gen-
eral N queue model. Although exact procedures exist
for analyzing the SD model, these procedures are not
computationally efcient. The computational effort
grows exponentially with the number of queues in the
system.
A number of papers provide approximate analy-
sis of the SD model to estimate the expected waiting
times and these include the work by Altman et al.
(1994), Bradlow and Byrd (1987), Ferguson (1986),
Gnalay and Gupta (1997), Lennon (1995), Olsen
(2001), and Yehia (1998). These papers do not provide
bounds on the expected waiting times and so it is dif-
cult to determine the accuracy of these estimates.
Our intent in this paper is to promote the use of
SD polling models for analyzing real-world systems
by presenting a fast and computationally efcient
method that determines tight bounds on the values of
performance measures critical to the design and eval-
uation of production systems. This method, the perfor-
mance bound hierarchies technique, develops a hierarchy
of successively more accurate bounds on the wait-
ing time moments with the exact solution as its limit.
We motivate the discussion by presenting examples
of manufacturing systems that are more appropriately
analyzed using the SD polling model rather than with
the simpler SI polling model.
2. Manufacturing Applications
We present two different scenarios that can be mod-
eled and analyzed with the SD model. The rst sce-
nario is discussed in greater detail.
Figure 1 Schematic Representation of the RFDC-Enabled Material
Handling System
Store 1
Line 1
Line 3
Line 2
Production Zone I
Cell 1
S
3
S
2
S
1
R
1
R
2
R
3
Cell 2
Store 2
Store 3
Cell 3
2.1. A Material Handling System
Consider a material handling systempossibly a
manual forklift, a person, or an automated guided
vehiclethat moves seminished products from
three production lines in a production center to stor-
age locations positioned close to various other pro-
duction cells for further processing. The schematic of
the material handling system is provided in Figure 1.
In this scenario, the server is the material handling
system and the customers are the seminished prod-
ucts that wait in their respective queues for the server.
The server visits the stationsproduction linesin a
cyclic manner and polls each one to ascertain the state
of that station. If there are customers waiting at the
polled station, the server performs service as follows:
stops in front of the polled station,
picks up seminished parts, one at a time, from
the queue,
scans the part to update necessary records main-
tained in a database, and
places the part in an empty container available
at that location.
This process is repeated until there are no more
parts at the station. After serving (picking up, scan-
ning, and placing in container) all the customers
(seminished parts), including customers that arrive
during the service period (this is the exhaustive service
discipline), the server departs from the polled station
to the storage area designated for the production cell.
It is assumed that the container is large enough to
store all the seminished parts present at the station.
After depositing the full container at the store, the
server picks up an empty container from that loca-
tion and takes it back to the station. The server now
places the empty container at the station and proceeds
to the next station. Parts waiting at the station when
the server returns are transported in the next cycle.
If the polled station is empty, the server directly pro-
ceeds to the next station (in an RFDC enabled system,
the server knows the state of the system immediately
on arriving at the station, so there is no need for the
Management Science 53(6), pp. 9911004, 2007 INFORMS 993
server to come to a halt to establish the state of that
station).
Let us examine the servers activities in more detail
to understand the modeling nuances for this system.
The time required by the server to move from sta-
tion i to station i 1 is the switchover time, denoted
by
i
, i = 1, 2, 3, in Figure 1. The time spent mov-
ing the lled container to the respective store and to
bring back an empty container is treated as the setup
time, denoted by S
i
in Figure 1. This setup activity
is different from the typical setup in the sense that
the server executes it after completing service at the
station instead of performing a setup activity before
starting service. Indeed, for the SD polling model we
analyze in this paper, a setup is assumed to be com-
pleted before the service period begins. However, our
methodology accommodates the alternate setup activ-
ity assumed for the model of the above material han-
dling system simply by modifying one expression in
the standard SD polling model (see Remark 1 in 4).
2.2. A Flexible Manufacturing System
Now consider a exible manufacturing system that
processes multiple products. A workcenter in this
exible manufacturing system must have the exi-
bility to cater to multiple product types, each one
of which might require the workcenter to perform
a setup to prepare itself for service. Following the
description of the model in Figure 1, it is easy to
see that the exhaustive service SD model presents
a very effective modeling framework for analyzing
such exible systems for their desired measures of
performance such as capacity analysis, waiting time
distributions, and so on. The exhaustive service strat-
egy may, for instance, be the appropriate model to
use when switchover and/or setup times are high,
but it should be pointed out that more general service
strategies can be analyzed within the framework of
this paper. Choosing an optimal service strategy is,
however, far from trivial. Therefore, fast algorithms
that can allow us to search more easily across differ-
ent strategies would be of value in this regard.
3. The Model and Preliminaries
The classical polling model considers a system in
which multiple queues are served by a single server
traveling from queue to queue in a prescribed se-
quence. Note that, in isolation, each queue is an ordi-
nary A,G,1 queue, but because they share a single
server they interact in complex ways, and their perfor-
mance measures are strongly dependent on each other.
We assume that customers arrive at various queues
following Poisson processes and the server adopts
the exhaustive service discipline (the server contin-
ues to serve customers until the queue is empty).
We only consider the exhaustive service discipline
in this paper, but our model can accommodate any
service discipline that allows a multitype branching
process interpretation (Resing 1993). We assume that
the server serves the queues in a cyclic order. The
methodology described below can be adapted to ana-
lyze models where the server uses a polling table
(Eisenberg 1972) to switch between queues, switches
between queues in a random manner (Boxma and
Weststrate 1989, Kleinrock and Levy 1988, Srinivasan
1991), or uses fractional service policies (see, for
instance, Levy 1991).
Although we explicitly include switchover times,
our model allows for zero switchover times so long
as at least one queue has a nonzero setup time. Alter-
nately, the model can accommodate systems with
zero setup times and at least one nonzero switchover
time (this is the simple SI model). We note, in
passing, that most real-world systems have nonzero
switchover times. Certainly, the material handling
system described in the 2 has fairly signicant
switchover times, and if the polling model is used
to analyze a production facility processing multiple
products (see, for instance, Kreig and Kuhn 2004),
then again the facility will need a nite amount of
time to switch between products. Even computer
communication systems, which arguably motivated
the development of polling models, have switchover
times that can be nontrivial relative to service times.
We also note that Levy and Kleinrock (1991) model
and analyze the zero switchover time model as a lim-
iting case of the nonzero switchover time model.
3.1. Notation
A single server serves a sequence of N innite-
capacity queues in a cyclic order. The arrival process
at queue i is Poisson with rate \
i
. The time required to
serve a customer at queue i is denoted by 8
i
and the
busy period at queue i is O
i
. The switchover time from
queue i (the time required for the server to travel from
queue i to queue i 1) is denoted by
i
. The setup time
at queue i (the preparation time at a queue prior to the
beginning of a service period) is denoted by S
i
, and
it is incurred if one or more customers are present at
queue i at the instant this queue is polled. The arrival
processes, service times, setup times, and switchover
times are all mutually independent. The trafc inten-
sity at queue i is j
i
\
i
||8
i
], and the server utilization
is j

N
i=1
j
i
. For the polling system to be stable, j
must be less than one, and this is assumed to be the
case. The waiting time at queue i (the time a customer
waits to receive service) is denoted by W
i
.
Unless otherwise stated, the Laplace-Stieltjes trans-
form (LST) of a nonnegative random variable , de-
ned as ||exp(s)], is denoted by

(s); and when
is discrete, its probability generating function (PGF),
dened as ||z
], is denoted by (z). Multivariate

LSTs and PGFs are dened similarly. It is assumed
that the index used for a summation over the queues
is (a) reset to one if it increases to N 1, and (b) reset
to N if it drops to zero.
We will refer to the time at which the server
polls queue i as an i-polling epoch. Let X
i
denote
the number of customers present at queue at an
i-polling epoch, and let
i
(z
1
, . . . , z
N
)
i
( z) denote
the (multivariate) PGF of (X
1
i
, . . . , X
N
i
). In particular,
i
(1, . . . , 1, z
i
, 1, . . . , 1) denotes the (univariate) PGF
of X
i
i
. Let ]
i
(0) denote the probability that queue i
is empty at an i-polling epoch. Then, the LST of the
waiting time for customers at queue i is (Gupta and
Srinivasan 1996)
W
i
(\
i
\
i
z
i
) =
1
\
i
||C]|
8
i
(\
i
\
i
z
i
)z
i
]
(1
i
(1,...,1,z
i
,1,...,1)
S
i
(\
i
\
i
z
i
)
]
i
(0)(1

S
i
(\
i
\
i
z
i
))), (1)
where C is the cycle time, which is the time required
by the server to complete a scan of all the queues. The
expression for the expected cycle time is
||C] =
||]
N
i=1
(1 ]
i
(0))||S
i
]
(1 j)
, (2)
where ||] is the expected total switchover time re-
sulting from a complete scan of all the queues.
3.2. The Descendent Sets Technique Approach
Konheim et al. (1994) proposed the descendant sets
technique that provides an expression for the (uni-
variate) PGF of the queue-length distribution at a
pre-specied queue at various polling instants. While
this technique can analyze a wide variety of polling
models, it cannot be used to analyze models such as
the SD model that require computation of the joint
queue-length distribution at polling instants. We will
refer to this technique as the univariate descendant sets
(UDS) technique. To address the shortcoming of the
UDS technique, its multidimensional version, the mul-
tidimensional descendant sets (MDS) technique, is intro-
duced in Singh and Srinivasan (2001).
A key difference between the UDS technique and
the MDS technique is the availability of the com-
plete state description of the whole system at all times
in the MDS technique. A pure application of the
MDS technique is computationally intense and very
slow. Srinivasan and Singh (2006) present a hybrid
approach that utilizes both the MDS and the UDS
techniques. The hybrid procedure results in a much
better performance and provides a typical improve-
ment of three times or more over the pure proce-
dure. However, even the hybrid procedure is limited
in its ability to analyze models of larger real-world
systems rapidly. Thus, while the hybrid procedure can
be readily used to analyze descriptive models with a
relatively small number of stations, it would not be
as useful for analyzing models with a large number
of stations, as it would require a very large amount of
memory and computational effort. Furthermore, the
hybrid procedure would be impractical to use within
the context of a prescriptive algorithm that could
require the evaluation of a number of alternate model
congurations. In such a situation, a bounding tech-
nique that provides upper and lower bounds on the
values of performance measures would be extremely
valuable.
Thus, although exact procedures typically result in
a better understanding of the model and the system
being modeled, the increased computational effort
often negates their benets. In most cases, a proce-
dure that quickly provides reasonably tight bounds
on the exact values may be adequate. To that end, we
develop a new iterative procedure to generate hier-
archies of successively improving (tighter) bounds on
the waiting time moments for the SD model with
N >2 queues. The new bounding method offers an
efcient way to analyze large, complicated polling
models. To motivate the discussion, we rst provide
a brief review of the UDS and MDS techniques below.
3.3. The Univariate Descendant Sets (UDS)
Technique
The UDS technique (Konheim et al. 1994) starts by
(re)numbering the N queues in the given polling
model, starting with the queue under consideration,
labeled as queue 1. Dene a cycle time as the elapsed
time between two successive 1-polling epochs. At
queue 1, dene a reference point by considering a ran-
domly selected 1-polling epoch that corresponds to
the initiation of a cycle with cycle index c =1. Then,
the number of customers at queue 1 at the reference
point is X
1
1
.
The UDS technique expresses each customer pres-
ent at a polling epoch in terms of contributions
from customers that arrived in all previous cycles.
Following this approach, to determine all the cus-
tomers represented by X
1
1
, we look back in time and
consider the cth cycle prior to the reference point,
where c =0, 1, . . . . Denote a type-i customer, who is
served during the cth cycle, as a
i, c
customer, and
dene the immediate offspring of a customer as the
set of all customers that arrive to the system (at all
queues) during its service period. Then, the descendant
set of a
i, c
customer is dened as the set consisting
of this
i, c
customer, its offspring (if any), and the
descendants of its offspring.
Let |
i, c
be the number of waiting customers at
queue 1 at the reference point that are in the descen-
dant set of a
i, c
customer, and let |
i, c
(z) denote
its PGF. |
i, c
can be interpreted as the contribution
to X
1
1
from a
i, c
customer. Every waiting customer
(if any) at queue 1 at the reference point contributes a
count of exactly 1 to X
1
1
; none of the customers wait-
ing at the other queues at this instant contribute to X
1
1
.
Thus, |
1, 1
=1, |
i, 1
=0 for i >1, and so |
1, 1
(z) =z,
with |
i, 1
(z) =1 for i >1. For c 0, the PGF of |
i, c
is
now recursively expressed in terms of the PGF of the
contributions to X
1
1
made by customers who arrive
during the service to a
i, c
customer. Customers that
arrive at a queue >i while a
i, c
customer is being
served are, by denition,
, c
customers. Customers
that arrive at a queue -i during the service to a
i, c
customer are, by denition,
, c1
customers because
they are served in the next cycle, which is cycle c 1.
Therefore, it follows that
|
i, c
(z
1
) =

O
i
_
N
_
=i1
\
|1|
,c
(z
1
)]
i1
_
=1
\
|1|
,c1
(z
1
)]
_
,
i =1, . . . , N, c 0. (3)
The index on the right-hand side of (3) does not
cover queue i because the contribution from the
ith queue is implicitly accounted for by the busy
period (O
i
).
3.4. The multidimensional Descendant Sets
(MDS) Technique
The MDS technique (Singh and Srinivasan 2001,
Srinivasan and Singh 2006) is based on the descendent
sets technique proposed in Konheim et al. (1994) in
the sense that it expresses
1
( z) solely in terms of
1
()
at previous 1-polling epochs. In principle, it follows
the basic idea of the UDS technique and goes back in
time, relating X
1
1
to customers present at each of the
1-polling epochs in previous cycles, until the contri-
butions from customers present at a 1-polling epoch
becomes negligible.
There is, however, one key difference between the
UDS and the MDS techniques. To highlight this dif-
ference, denote the presence or absence of a setup
at a polled queue as an outcome, and use the term
sample path to denote the sequence of possible out-
comes experienced by the server as it continues to poll
the queues. The UDS technique works with a single
sample path. More precisely, it relates the
i, c
cus-
tomers contribution to X
1
1
using a single expression
for |
i, c
(z
1
). However, for the SD polling model, there
are multiple sample paths depending on the outcomes
at each queue at each cycle. Each sample path results
in a unique expression for the contribution from a
i, c
customer (to X
1
1
). In this respect, the MDS technique
is reminiscent of the buffer occupancy approach
(Eisenberg 1972), which requires the moments of X
i
.
To address the issue of multiple sample paths, the
MDS technique uses a multidimensional PGF, A
i, c
( z).
In its generic form, the expression for A
i, c
( z) is simi-
lar to the expression for |
i, c
(z
1
):
A
i, c
( z) =

O
i
_
N
_
=i1
\
|1A
,c
( z)]
i1
_
=1
\
|1A
,c1
( z)]
_
,
i =1, . . . , N, c 0. (4)
The A
i, c
() terms are key to the execution of the
MDS technique because they are used to carry the
sample path information. This is explicated in Singh
and Srinivasan (2001), but to clarify the point to the
reader of this paper, consider a model with N = 3
queues and consider the sequence of outcomes as the
server moves from a 1-polling epoch in cycle c 1
to a 1-polling epoch in cycle c (with the descendent
sets approach, as we move forward in time, each
succeeding cycle has a lower cycle index). Denote
the presence or absence of a setup at each queue
by a one or a zero, respectively. When we relate a
1-polling epoch in cycle c 1 to a 1-polling epoch in
cycle c, there are 2
3
=8 possible outcomes to consider,
(1, 1, 1), (0, 1, 1), (1, 0, 1), . . . , (0, 0, 0) (the rightmost
position changes the slowest). In general, it is conve-
nient to capture these outcomes by a vector,

p
, p =
1, . . . , 2
N
, where for each p,

p
is an N 1 vector of
N binary switches. Let
p
() denote the th element
of this vector. For instance, with three queues, if

p
=
(1, 0, 1), then
p
(1) =
p
(3) =1 and
p
(2) =0.
To explicitly capture each outcome sequence, let
A
p
i, c
() denote the contribution of a
i, c
customer
(just like |
i, c
(z) in the UDS technique) resulting from
the pth binary switch conguration, p =1, . . . , 2
N
. The
case p = 2
N
describes a situation where
p
() = 0 for
all , that is, the server found each queue empty dur-
ing that cycle. For this case, there are no such con-
tributions, and so we simply set A
2
N
i, c
( z) = 0. Thus,
using (4), A
p
i, c
( z) is evaluated as follows:
A
p
i, c
( z) =
_
_
0,
p
(i) =0,
O
i
_
N
_
=i1
\
|1 .
p
, c
( z)]
i1
_
=1
\
|1 .
p
, c1
( z)]
_
, otherwise,
(5)
where, for any c,
.
p
i, c
( z) =
_
_
_
0 if
p
(i) =0,
A
p
i, c
( z) if
p
(i) =1.
A fundamental property of A
p
i, c
( z) (Theorem 1 in
Singh and Srinivasan 2001) is that if we initialize
the iteration with, say, .
p
i, c
( z) = 0, and c = 1, and
continue to iteratively express A
p
i, c
( z) using (5), then
it converges monotonically to a unique, nonnegative
value, p
p
i
1. That is, lim
c~
A
p
i, c
( z) = p
p
i
1, inde-
pendent of z. In particular, for the case p =1, where
p
() = 1 for all , we have lim
c~
A
1
i, c
( z) p
1
i
= 1
for all i. Note that, by denition, p
p
i
= 0 whenever
p
(i) =0, and p
p
i
=0 for all i when p =2
N
.
4. Performance Bound Hierarchies
The performance bound hierarchies (PBH) technique
develops a sequence of bounds on the waiting time
moments by developing a corresponding sequence of
upper and lower bounds on
i
( z), with the exact solu-
tion as its limit. In this section, we rst present the
expression for
i
( z) obtained in Singh and Srinivasan
(2001) and show how the bounds on this expression
are obtained.
Let

c
( z) =|
i, c
( z)], .
p
c1
( z) =|.
p
i, c1
( z)], x
p
c1
( z, |) =
|x
p
i, c1
( z, |)], and j
p
c1
( z, |) = |j
p
i, c1
( z, |)], i = 1, . . . ,
N, denote N 1 vectors. The expression for
1
() in
cycle c is (Singh and Srinivasan 2001)
1
(

c
( z)) =
2
N
_
p=1
_
1
( .
p
c1
( z))
|=1
|
|
( x
p
c1
( z, |))
|
( j
p
c1
( z, |))]
_
, (6)
where
|
( j
p
c1
( z, |)) =
_
_
_
|
( j
p
c1
( z, |)), if
p
(|) =1,
1
|
( j
p
c1
( z, |)), if
p
(|) =0,
|
( j
p
c1
( z, |)) =

S
|
_
N
_
=1
|\
j
p
, c1
( z, |)]
_
,
|
( x
p
c1
( z, |)) =

|
_
N
_
=1
|\
x
p
, c1
( z, |)]
_
,
and .
p
i, c1
( z), j
p
i, c1
( z, |), and x
p
i, c1
( z, |) are dened
for i =1, . . . , N as follows:
.
p
i, c1
( z) =
_
_
_
0, if
p
(i) =0,
A
p
i, c1
(

c
( z)), if
p
(i) =1,
x
p
i, c1
( z, |) =
_
_
0, if
p
(i) =0 and i >|,
i, c
( z), if i |,
A
p
i, c1
(

c
( z)), otherwise,
and
j
p
i, c1
( z, |) =
_
_
0, if
p
(i) =0 and i >|,
i, c
( z), if i -|,
A
p
i, c1
(

c
( z)), otherwise.
Equation (6) relates the number of customers pre-
sent at a 1-polling epoch in cycle c in terms of the
number of customers present at a 1-polling epoch
in cycle c 1. To provide some qualitative insight
into (6), the 2N terms on the right-hand side of (6)
represent the 2N possible states of the system when
the server polls queue 1 in cycle c 1. Each possi-
ble state is appropriately weighted by its respective
probability and the contributions made by customers
arriving during all switchovers, any setups, and busy
periods at each one of the queues during the previ-
ous complete cycle. Note that there will always be a
switchover from each queue, and these are captured
by the
|
() terms associated with each
1
() term on
the right-hand side of the equation. The setups (or the
absence of setups) are captured by the
|
() terms. If
queue | has one or more customers present when it
is polled during this cycle, then there is a setup at the
queue resulting in
|
() =
|
(). Otherwise, if queue
| is empty at a polling instant, there is no setup and
|
() =1
|
().
Remark 1. If the setup is performed after the com-
pletion of service, as in the model discussed in 2
(represented graphically in Figure 1), customers arriv-
ing at queue i during the performance of this setup
will not be served in the present cycle. Instead, these
customers will be served in the next cycle when the
server polls queue i again. To reect this change, we
only need to modify the right-hand side of the expres-
sion for j
p
i, c1
in (6) as follows:
j
p
i, c1
( z, |) =
_
_
0, if
p
(i) =0 and i >|,
i, c
( z), if i |,
A
p
i, c1
(

c
( z)), otherwise.
4.1. Basic Concept for the PBH Technique
The PBH technique starts with the user specifying a
bound level, n (the level-n bound), where a higher
n indicates a higher degree of accuracy. It then applies
(6) iteratively, n 1 times. The rst application pro-
duces an expression for
1
( z) with 2
N
terms on the
right-hand side of the expression. Each term consists
of an unknown,
1
(), with an associated weight
involving the coefcients
|
() and
|
(). One of these
unknowns is
1
(
0), which represents the case where

every queue was empty at the 1-polling epoch. The
remaining 2
N
1 unknowns have at least one of
their arguments nonzero and we refer to these as the
nonzero-argument terms. The arguments for these terms
are either 0 or A
p
i, c1
() for p = 1, . . . , 2
N
. In particu-
lar, one of these terms is
1
(A
1
1, c1
( z), . . . , A
1
N, c1
( z))
1
(

A
1
c1
( z)), which represents the situation where
every queue is nonempty at the 1-polling instant. We
refer to such a term as a pure term.
If n > 1, then (6) is applied to express the 2
N
1
nonzero-argument
1
() terms iteratively, in terms
of new
1
() terms. A second application of (6) on
the nonzero-argument terms results in a total of
2
N
(2
N
1) 1 terms, which now include 2
N
1 new
terms involving
1
(
0) in addition to the
1
(
0) term
in the original equation. Thus, there are (2
N
1) 1
terms with
1
(
0), and (2
N
1)
2
nonzero-argument
1
() terms. After n such applications of (6), there
will be (2
N
1)
n
nonzero-argument
1
() terms and
n1
=0
(2
N
1)
terms involving
1
(
0).
The PBH technique now obtains an upper bound
on this expression for
1
( z) by replacing the (2
N
1)
n
nonzero-argument
1
() terms with a pure term.
For the lower bound, the PBH technique replaces
all nonzero-argument
1
() terms except the pure
term with
1
(
0). Thus following the replacement, the

desired bound on
1
() is expressed using just a pure
term and
1
(
0). Theorem 1 shows that these replace-

ments provide the desired bounds.
Theorem 1. For any cycle c 0,
1
(

c
( z))
1
(

A
1
c1
( z))
2
N
1
_
p=1
N
|=1
{
|
( x
p
c1
( z, |))
|
( j
p
c1
( z, |))]
1
(
0)
N
|=1
_
|
_
x
2
N
c1
( z, |)
_
|
_
j
2
N
c1
( z, |)
__
, and (7)
1
(

c
( z))
1
(

A
1
c1
( z))
N
|=1
{
|
( x
1
c1
( z, |))
|
( j
1
c1
( z, |))]
1
(
0)
2
N
_
p=2
N
|=1
{
|
( x
p
c1
( z, |))
|
( j
p
c1
( z, |))]. (8)
Proof. The expression for
1
(

c
( z)) in Equation (6),
reproduced below, is
1
(

c
( z))
=
2
N
_
p=1
_
1
( .
p
c1
( z))
N
|=1
|
|
( x
p
c1
( z, |))
|
( j
p
c1
( z, |))]
_
.
Recall that the superscript p in the expression for
.
p
i, c1
( z) corresponds to the conguration of binary
switches. In particular, when p =1, we have
1
(i) =1
for all i (all binary switches are set equal to one) and
when p = 2
N
, we have
2
N (i) = 0 for all i. Thus, to
prove Theorem 1, we need to show that
1
( .
1
c1
( z))
1
( .
p
c1
( z))
1
( .
2
N
c1
( z)), p =2, 3, . . . , 2
N
1.
We will prove the rst inequality for p = 2, which
corresponds to the conguration in which the rst
binary switch is a zero with all other binary switches
set to one. To prove that the inequality holds, it is
enough to show that
1
(z
1
, . . . , z
N
)
1
(0, z
2
, . . . , z
N
).
By denition,
1
( z) =
~
_
n
1
=0

~
_
n
N
=0
{z
n
1
1
z
n
N
N
P
1
(n
1
, . . . , n
N
)]. (9)
Equation (9) can be rewritten as
1
( z) =
~
_
n
1
=1
~
_
n
2
=0

~
_
n
N
=0
{z
n
1
1
z
n
2
2
z
n
N
N
P
1
(n
1
, n
2
, . . . , n
N
)]
1
(0, z
2
, . . . , z
N
). (10)
Because
~
_
n
1
=1
~
_
n
2
=0

~
_
n
N
=0
_
z
n
1
1
z
n
2
2
z
n
N
N
P
1
(n
1
, n
2
, . . . , n
N
)
_
is a partial PGF, it is a nonnegative number, and so,
1
( z)
1
(0, z
2
, . . . , z
N
). The same reasoning applies
to show that the rst inequality holds for all other
values of p. The proof of the second inequality follows
directly because
1
(
0) =
1
(0, . . . , 0) =P
1
(0, . . . , 0).
The PBH technique now goes back in time, itera-
tively expressing the upper or lower bound for
1
( z)
using just the pure term and
1
(
0), for increasing val-

ues of c. Unlike the hybrid technique which generates
2
N
1 new unknowns at each succeeding iteration,
the PBH technique generates exactly two unknown
terms.
In the limit, as c ~, it can be shown (simi-
lar to Cooper and Murray 1969, VI) that A
1
i, c
( z)
A
1
i, ~
( z) =1. (Intuitively, the contribution from a cus-
tomer served c cycles ago approaches 0 as c ~.) At
this point in time, all
1
(

A
1
c
( z))
1
(1, . . . , 1) =1, and
the upper (lower) bound for
1
( z) is now expressed
entirely as a sum of a large number of
|
() and
|
() terms and
1
(
0). The technique now obtains a

tight upper (lower) bound for
1
(
0) to obtain the
desired bound on
1
( z).
Corollary 1.
1
( z) RS
1
( z)
RS
1
(0)
1 RS
2
(0)
RS
2
( z) und (11)
1
( z) RS
3
( z)
RS
3
(0)
1 RS
4
(0)
RS
4
( z), (12)
where RS
m
( z) and RS
m
(0), m = 1, . . . , 4, are constants
involving
|
() and
|
(), | =1, . . . , N.
Proof. We will prove the corollary only for the
upper bound. The proof for the lower bound follows
in an identical manner. Let
RS(

c
( z)) =
2
N
1
_
p=1
N
|=1
{
|
( x
p
c1
( z, |))
|
( j
p
c1
( z, |))] and
(

c
( z)) =
N
|=1
{
|
( x
2
N
c1
( z, |))
|
( j
2
N
c1
( z, |))].
Then, from Theorem 1,
1
(

c
( z))
1
(

A
1
c1
( z))RS(

c
( z))
1
(
0)(

c
( z)). (13)
Replacing
1
(

A
1
c1
( z)) in Equation (13) with
1
(

A
1
c2
( z))
preserves theupper bound. So, if weiterateon this pure
term for increasing values of c, the resulting expres-
sion will provide an upper bound. As we continue
to iterate in this fashion, lim
c~
A
1
i, c
( z) = 1 for i =
1, . . . , N, and so
lim
c~
1
(

A
1
c
( z)) = lim
c~
1
(A
1
1, c
( z), . . . , A
1
N, c
( z))
=
1
(1, . . . , 1) =1.
As a result, the upper bound for
1
(

c
( z)) ultimately
has the form
1
(

c
( z)) RS
1
(

c
( z))
1
(
0)RS
2
(

c
( z)), (14)
where RS
1
(

c
( z)) is the sum of all RS(

c
( z)) terms,
associated with the pure term, over all cycles, and
RS
2
(

c
( z)) is the sum of all (

c
( z)) terms associ-
ated with
1
(
0). We ignore the exact specication of

RS
1
(

c
( z)) and RS
2
(

c
( z)) because they are not rel-
evant to the proof, but emphasize that they can be
computed in a relatively straightforward manner.
Set
i, c
( z) = 0 for i = 1, . . . , N in (14). Solving the
resulting expression for
1
(
0),
1
(
0)
RS
1
(0)
1 RS
2
(0)
, (15)
where RS
1
(0) and RS
2
(0) are the values of RS
1
(

c
( z))
and RS
2
(

c
( z)) obtained by setting z
i
= 0, i = 1, . . . ,
N. From (14) and (15), we get the desired expression
for the upper bound.
4.2. Bounds for the Waiting Time Moments
After expressing
1
( z) using only the
|
() and
|
()
terms, waiting time moments are obtained by differ-
entiating this expression the appropriate number of
times. The nth moment of the waiting time requires
i
( z) to be differentiated n 1 times. We now show
how to apply the PBH technique to obtain bounds on
the expected waiting time.
4.2.1. Computing Bounds on the Expected Wait-
ing Time. Let ]
i
denote the rst factorial moment of
the number of customers present at queue i at an
i-polling epoch, and let ]
(n)
i
denote the nth factorial
moment of this number. Let ]
i
(0) denote the empty
station i probability at an i-polling epoch. Differenti-
ating (1) twice with respect to z
i
and letting z
i
1,
we get the expression for the expected waiting time
at queue i:
||W
i
] =
]
(2)
i
2\
i
]
i
||S
i
] \
2
i
||S
2
i
](1 ]
i
(0))
\
2
i
||C](1 j
i
)
\
i
||8
i
]
2(1 j
i
)
. (16)
The expressions for ]
1
and ]
(2)
1
, required to compute
||W
1
], are (Srinivasan and Singh 2006)
]
1
=
~
_
c=0
N
_
i=1
_
||
i
])
i, c
||S
i
])
i1, c
]
i
(0)||S
i
])
i1, c
_
(17)
and
]
(2)
1
=
~
_
c=0
N
_
i=1
_
||
2
i
])
(2)
i,c
||S
2
i
])
(2)
i1,c
2||
i
]||S
i
])
i,c
)
i1,c
_
~
_
c=0
N
_
i=1
_
]
i
(0)||S
(2)
i
])
(2)
i1, c
2]
(0)
i
||S
i
])
i1, c
_
2
~
_
c=0
N
_
i=1
{||
i
])
i, c
||G
i, c
]]||S
i
])
i1, c
, (18)
where ]
(0)
i
=
N
=1
||X
i[0
], with X
i [ 0
denoting the num-
ber of customers present at queue at an i-polling
epoch that found queue i empty. (By denition,
X
i
i [ 0
=0.) In these equations, ||
i
], ||S
i
], ||
2
i
], ||S
2
i
],
)
i1, c
, )
(2)
i, c
, and ||G
i, c
] are constants that are either data
or terms that can be easily computed using the UDS
technique. For instance, )
i1, c
and )
(2)
i, c
are computed
as follows:
)
i, c
=
N
_
=i1
\
o
, c
i1
_
=1
\
o
, c1
, c 0, (19)
)
(2)
i, c
=
N
_
=i1
\
o
(2)
, c
i1
_
=1
\
o
(2)
, c1
, c 0, (20)
where o
i, c
and o
(2)
i, c
are calculated using Equations
(21), (22), and (23):
o
i, c
=
||8
i
]
(1 j
i
)
_
N
_
=i1
\
o
, c
i1
_
=1
\
o
, c1
_
, c 0, (21)
o
(2)
i,c
=
||8
2
i
]
(1j
i
)
3
_
N
_
=i1
\
o
(2)
,c
i1
_
=1
\
o
(2)
,c1
_
, c 0, (22)
o
1,1
=o
(2)
11
=1, o
,1
=o
(2)
,1
=0, 2 N. (23)
To compute bounds on the expected waiting times,
we partition the terms needed to compute ]
i
and ]
(2)
i
into two categories: terms that can be computed
exactly using the UDS technique and terms that
require the PBH technique. The only unknowns com-
puted using the PBH technique are ]
i
(0) and ]
(0)
i
. The
term ]
i
(0) is computed readily from the expression for
1
( z) simply by setting z
=0 for all ,=i. To compute

the terms, ||X
i [ 0
], =1, . . . , N, needed to evaluate ]
(0)
i
,
we set z
i
= 0 in the expression for
i
( z) and differen-
tiate it with respect to . In expressions (17) and (18),
the terms containing ]
i
(0) and ]
(0)
i
have a negative
sign in front of them. Hence, to apply the bounds
obtained from Corollary 1, an upper (lower) bound on
]
1
is obtained by using a lower (upper) bound on the
]
i
(0) terms. Asimilar observation holds for the bounds
on ]
(2)
1
. Corollary 2, presented below without proof,
summarizes these characteristics.
Corollary 2. Differentiating the expression for the
upper (lower) bound obtained from Corollary 1 results in
a lower (upper) bound on ]
1
. Similarly, an upper (lower)
bound on ]
1
is obtained by differentiating the expression
for the lower (upper) bound obtained from Corollary 1.
4.2.2. Algorithm BOUNDS. Algorithm BOUNDS
produces a hierarchy of successively improving
bounds on the expected waiting time. A similar ap-
proach applies for computing higher waiting time
moments. Similar to the hybrid procedure (Srinivasan
and Singh 2006), all terms that can be computed using
the UDS technique (the [S] terms) are computed
exactly in Algorithm BOUNDS. For the rest of the
terms (the [P] terms), Algorithm BOUNDS com-
putes upper and lower bounds using (11) or (12).
The user species the bound level as n 1, where
a higher value of n indicates a higher degree of
accuracy. The algorithm rst evaluates the terms,
p
p
i
=lim
c~
A
p
i, c
( z), i =1, . . . , N, p =1, . . . , 2
N
. These
terms are determined regardless of the bound level.
The algorithm then applies Equation (6) n 1 times
before replacing the nonzero-argument
1
() terms
with the pure term or
1
(
0). To elaborate, for the

level-n upper bound, the algorithm expresses
1
( z)
in terms of (2
N
1)
n
nonzero-argument
1
() terms.
(Recall from 4.1 that these are all the
1
() terms
except
1
(
0).) It then replaces each of these nonzero-

argument
1
() terms with the pure term. In the
same way, for the level-n lower bound, the algorithm
replaces all the nonzero-argument
1
() terms except
the pure term with
1
(
0). The bounds on

1
( z) are
now determined using Corollary 1, providing the data
necessary to determine bounds on expected waiting
times. Obviously, the bounds are tighter if we perform
more iterations using (6), before making the replace-
ment. However, at the same time, the computational
effort increases signicantly if a higher number of iter-
ations are rst performed using (6), as we show in the
following section on complexity analysis.
Algorithm BOUNDS
(A) Evaluate the category |S] terms using the UDS
technique.
(B) Compute bounds on category |P] terms using
the PBH technique as follows:
(I) Compute the limiting values for the A
i, c
( z)
terms by rst generating the vectors,

p
, p =1, . . . , 2
N
.
For each p {1, . . . , 2
N
], do Steps (1) through (3)
below:
(1) Set c to some arbitrary value, say, c =0, and
initialize A
p
, c
() =0, =1, . . . , N.
(2) For each i in the order, N, N 1, . . . , 1, if
p
(i) =0, then set A
p
i, c1
() =0, else evaluate A
p
i, c1
()
using (4), with the current values of A
p
, c
(), =
1, . . . , N.
(3) If [A
p
i, c1
() A
p
i, c
()[ e for all i, for some
tolerance level, e, then return the limiting values, p
p
i
=
A
p
i, c
(). Otherwise, set c = c 1 and repeat Steps (2)
and (3).
(II) Determine n, the bound level. Use (6) to
express
1
( z) iteratively, n times. The resulting expres-
sion has (2
N
1)
n
nonzero-argument
1
() terms.
(III) Replace all nonzero-argument
1
() terms
except the pure term with either the pure term or
1
(
0), depending on whether a lower or an upper

bound is being computed. (Equation (13) presents the
form of the resulting expression for the upper bound.)
With the resulting expression for
1
( z), continue the
iteration on c until the pure term converges to one.
(Equation (14) presents the form of the expression for
the upper bound on
1
( z) at this stage.) Now set z
i
=0
for all i in the resulting expression to solve for
1
(
0).
(Equation (15) presents the form of the expression for
the upper bound on
1
(
0).) Now use either (11) or (12)

to obtain the upper or lower bound on
1
( z). (See
Corollary 1.)
(C) After obtaining bounds on all
i
( z), i = 1, . . . ,
N, compute ]
i
(0), i =1, . . . , N, simply by setting z
i
=0
and z
= 1 for all ,= i in the expression for the

bound on
1
( z). Obtain ||X
i [ 0
] for i = 1, . . . , N and
=1, . . . , N, by analytically differentiating the appro-
priate bound for
i
(z
1
, . . . , z
i1
, 0, z
i1
, . . . , z
N
) with
respect to z
for ,=i.
The procedure for computing the desired bounds
on
1
( z) is initiated with arbitrary nonzero values for
z
i
-1. These bounds on
1
( z) are necessary for obtain-
ing any waiting time moment bounds.
4.3. Complexity Analysis
We describe the computational effort required by the
PBH algorithm to compute bounds on
i
( z) for any
queue, say, queue i = 1. Bounds on waiting time
moments are then obtained in a fairly straightfor-
ward manner with relatively little effort. The algo-
rithm rst applies the UDS technique to compute
all terms that can be evaluated with this technique.
This step requires O(N log
j
e) operations, where j is
the utilization of the server and e is the tolerance
(see Konheim et al. 1994). It next computes p
p
i
, i =
1, . . . , N, p = 1, . . . , 2
N
. Determining a p
p
i
term also
requires O(N log
j
e) operations. Because there are a
total of N2
N1
N such terms, computing all the
p
p
i
requires O(N
2
2
N
log
j
e) operations. (Note that the
number of p
p
i
s to be evaluated is not N2
N
because
p
p
i
=0 if
p
(i) =0, and p
1
i
=1 for all i.)
Now consider the recursion on
1
( z) using (6). For
ease of exposition, consider rst the level-1 upper
bound. After the rst application of (6), initialized
with c =0, applying the PBH technique results in an
upper bound with the following form (see (13)):
1
( z)
1
(

A
1
1
())
2
N
1
_
p=1
N
|=1
|
( x
p
1
())
|
( x
p
1
())
1
(
0)
N
|=1
|
_
x
2
N
1
()
_
|
_
x
2
N
1
()
_
.
Computing the
|
() and
|
() terms associated
with
1
(

A
1
1
()) in the above equation requires O(N2
N
)
operations, and computing the corresponding coef-
cients of
1
(
0) requires O(N) operations. Hence, this

step requires O(N2
N
) operations. The pure term is
now repeatedly expressed using (6) until its argu-
ments all converge to one. At each iteration, the new
coefcients generated require O(N2
N
) operations to
evaluate, just as before. Because the iterations con-
tinue until the A
p
i, c
() terms converge to one, the num-
ber of iterations performed is O(log
j
e) and so the
required computational effort is O(N2
N
log
j
e). Thus,
for the level-1 bound, the level of effort is deter-
mined by the step that computes the p
p
i
s, which is
O(N
2
2
N
log
j
e).
For the higher-level bounds, the step that deter-
mines the order of effort is the one that rst expresses
1
( z) iteratively using (6) n times, before replacing
all the nonzero-arguments with pure term or with
1
(
0). It can be veried that for the level-n bound,

this requires O((N2
N
)
n
) operations. Now, following
the same logic as used to determine the complexity of
the level-1 bounds, the computational effort required
for the level-n bound, n 2, is O((N2
N
)
n
log
j
e).
It is instructive to compare the computational com-
plexity of the PBH algorithm with that of the hybrid
procedure (Srinivasan and Singh 2006). The hybrid
procedure also applies the UDS technique to compute
all terms that can be evaluated with the UDS tech-
nique (O(N log
j
e) operations), and computes p
p
i
, i =
1, . . . , N, p =1, . . . , 2
N
(O(N
2
2
N
log
j
e) operations). At
this stage, it could apply (6) on the
1
( z) terms until
the A
p
i, c
() arguments converge to their limiting val-
ues. However, when the arguments converge, they do
so to p
p
i
which is not equal to one unless p =1. Hence,
each
1
() term converges to a
1
(

p
r
), r {1, . . . , 2
N
],
where

p
r
= |p
r
1
, . . . , p
r
N
], and so that leaves many
unknowns still to be determined. To overcome this
difculty, the hybrid algorithm instead initializes the
iterations using (6) with z =

p
r
for some r {1, . . . , 2
N
]
and iterates until it results in an expression for
1
(

p
r
) in terms of
1
(

p
p
), p = 1, . . . , 2
N
. That essen-
tially amounts to expressing
1
( z) using (6) O(log
j
e)
times, requiring O((N2
N
)
log
j
e
) operations to evaluate
all coefcients in the resulting expression. Repeating
this process for every r {1, . . . , 2
N
] results in a set
of 2
N
equations for the 2
N
unknowns,
1
(

p
r
). Obtain-
ing these 2
N
equations thus requires O(2
N
(N2
N
)
log
j
e
)
operations. Solving them involves O(2
3N
) operations.
The hybrid procedure now uses (6) again to express
1
( z) in terms of
1
() terms. It now continues to iterate
until the
1
() terms converge to their limiting
1
(

p
p
i
)
values. At this stage,
1
( z) is expressed entirely in
terms of the
1
(

p
p
i
)s (now known constants), and the
|
() and
|
() terms. This step requires O((N2
N
)
log
j
e
)
operations. Thus, the overall level of computational
effort required by the hybrid procedure to compute
1
( z) is O(2
N
(N2
N
)
log
j
e
). We remark that log
j
e can be
a fairly large number. Note that to determine
1
( z)
accurately, we had to use e 10
5
. Note, too, that
log
j
e is very sensitive to j, the system utilization.
Thus, when j =0.7, log
j
e >30.
5. Numerical Results
The primary intent of this paper is to provide a hier-
archy of improving bounds on
1
( z) that converge to
the exact values. Once the upper and lower bounds
on
1
( z) are computed, we can compute correspond-
ing bounds on the expected waiting time as well
as higher moments in a relatively straightforward
manner. We were interested, though, in seeing how
effective the bounding scheme was in generating the
hierarchy of bounds on the expected waiting time.
To this end, numerous experiments were conducted
on a number of alternate model congurations. We
rst wanted to identify how the bound hierarchy pro-
gressed toward the exact values of expected waiting
time, and the computational effort required to achieve
these bounds. The results presented in Table 1 pro-
vide level-1, level-2, and level-4 bounds on expected
waiting time for models with j = 0.3 and j = 0.7.
The mean service, switchover, and setup times were
all set equal to one for every model tested. Differ-
ent levels of variation were assumed for the service,
switchover, and setup times, with the coefcient of
variation (CV) ranging from 0 to 9.85. Some of these
CVs, for example, the CV of 9.85, were generated
using 2-point distributions (see Gupta and Srinivasan
1996 for examples). The exact expected waiting times
obtained using the hybrid procedure are provided for
comparison. Table 1 also presents an approximation
for the expected waiting time obtained by averaging
the level-1 upper and lower bounds. All times (in sec-
onds) in the table are rounded to the nearest integer.
The results provided in Table 1 suggest that the
level-1 bounds on expected waiting time are fairly
tight, and that a simple average of the upper and lower
level-1 bounds produces an estimate of the expected
waiting time that is generally very close to the exact
value, at least for the cases considered. Because the
SD model is very complex, it is not possible for us
Table 1 Expected Waiting Time: Bound Hierarchy and Exact Results
Data set l
1
|h
1
] l
2
|h
1
] l
4
|h
1
] l|h
1
] l
1
|
h
1
] CPU
1
CPU
2
CPU
4
CPU
3SLEVC-UB 50.68 50.39 50.38 50.38 50.38 0.0 1.0 1.0 7.0
-LB 50.07 50.13 50.24
3SHEEE-UB 29.46 27.57 27.51 27.41 27.44 0.0 0.0 0.0 7.0
-LB 25.41 27.23 27.30
3AHCCE-UB 16.07 16.02 16.01 16.01 16.01 0.0 7.0 11.0 19.0
-LB 15.95 16.00 16.01
5SHEHC-UB 15.62 15.41 15.40 15.39 15.43 0.0 114.0 152.0 254.0
-LB 15.23 15.38 15.39
5AHCCC-UB 31.30 28.41 28.30 28.18 28.16 0.0 524.0 639.0 700.0
-LB 25.02 27.89 28.01
7SLEEE-UB 2.51 2.25 2.24 2.23 2.23 0.0 2,390.0 3,033.0 3,978.0
-LB 1.96 2.21 2.22
Explanation of columns:
Column 1 (#abcde):
#: Number of stations in the model.
a: SSymmetric or AAsymmetric. b: Station utilizationL (p =0.3) and H (p =0.7).
c/d/e: CV of the service/switchover/setup time distributionsC =0, E =1.0, H =3.49, and V =9.85.
UB: Upper bound. LB: Lower bound.
Columns 210:
l
i
|h
1
]: Level-i upper and lower bounds on the expected waiting time, i =1, 2, 4.
l|h
1
]: Exact expected waiting time.
l
1
|
h
1
]: Approximate value of l|h
1
] =Average of level-1 upper and lower bounds.
CPU
i
: CPU time in seconds to compute l
i
|h
1
], i =1, 2, 4 (computing l
1
|h
1
] took less than 0.5 seconds).
CPU: CPU time in seconds to compute l|h
1
].
to determine a priori as to when the bounds would
be tight, or how much computational effort would
be required to produce upper and lower bounds on
the expected waiting time, that were within a given
percentage range of the exact value. Therefore, we
next ran many experiments to determine when these
bounds would be tight, when they would not perform
well, and when the midpoint approximation would
not perform very effectively.
To undertake a systematic study, we restricted the
experiments to models with ve queues, at various
levels of utilizations (j = 0.1, 0.3, 0.7, and 0.9) and
only computed level-1 bounds. We experimented with
different CVs for the service times, the switchover
times, and setup times, using CVs of 0, 1.0, 1.25, 1.5,
1.75, 2.0, 3.49, and 9.85. As before, we set the mean
service, switchover, and setup times all equal to one.
The number of queues in these experiments ranged
from N =3, 5, 7 to 10 queues. We experimented with
symmetric and asymmetric systems. For asymmet-
ric systems, while we retained the average service,
switchover, and setup times equal to one, the arrival
rates at each queue were different.
These experiments also suggested that the level-1
bounds were reasonably tight for many cases and, fur-
thermore, the average of the upper and lower level-1
bounds were within 5% of the actual values for a
majority of the cases. However, the bounds were rel-
atively loose, with a corresponding decrease in the
accuracy of the midpoint approximation when there
was a high degree of asymmetry. They were also rel-
atively loose for models with a high switchover time
CV (of 3.49 or higher) and relatively high utilizations
(j =0.7), although this was not uniformly, true across
all such models. No doubt, with real-world appli-
cations, it is highly unlikely to nd systems with a
switchover time CV of 9.85. We chose models with
this CV because they readily produce some counter-
intuitive behavior as discussed next. Table 2 presents
some of these results. The criteria used to decide on
which experimental results were included in the table
are presented following the discussion on the coun-
terintuitive behavior.
Because the SD model does not lend itself to easy
analysis, its performance is often approximated by
the simpler SI model in which the server is assumed
to perform a setup (or, alternately, never performs
a setup) at a polled queue, regardless of its state.
Indeed, common sense dictates that the performance
of the SD model should be at least as good as that
of its SI counterpart in which a setup is assumed
to take place at each polled queue regardless of its
state. Based on this reasoning, the SI model has been
used to provide a conservative bound on the cor-
responding SD model (Ferguson 1986). Strangely, this
common-sense intuition is not always correct. As
originally pointed out by Sarkar and Zangwill (1991)
and by numerous other papers subsequently, increas-
ing setup times can sometimes reduce the expected
waiting times.
Table 2 PBH Technique Performance Evaluation
Data set p l|h
1
] $l l|h
1
] l
1
|h
1
] l|
h
1
] Error (%) Perf Imp
SMHC-UB 0.1 8.55 9.99 11.48 10.70 7.06 14
-LB 8.87 9.92
A
1
MHM-UB 0.1 8.59 9.84 11.55 10.66 8.35 10
-LB 8.82 9.78
A
2
MCM-UB 0.3 6.75 5.43 6.98 6.13 12.99 55
-LB 3.47 5.29
SCCC-UB 0.3 6.93 5.86 6.01 5.86 0.00 116
-LB 3.57 5.70
SCCV-UB 0.3 31.18 18.43 18.96 18.54 0.60 Inf
-LB 3.57 18.11
SCVC-UB 0.3 31.18 50.83 51.92 49.94 1.75 Inf
-LB 52.08 47.96
SEVC-UB 0.3 31.40 50.90 52.16 50.27 1.24 Inf
-LB 52.30 48.37
SEVE-UB 0.3 31.65 51.03 52.22 50.39 1.25 Inf
-LB 52.30 48.55
SVCV-UB 0.3 51.98 37.49 37.63 37.50 0.03 Inf
-LB 24.36 37.37
SVVC-UB 0.3 51.98 73.55 73.51 73.40 0.20 Inf
-LB 72.87 73.29
SCCC-UB 0.7 15.50 15.38 15.57 15.36 0.13 96
-LB 8.33 15.15
SCVC-UB 0.7 39.76 43.81 60.05 49.21 12.33 85
-LB 56.85 38.36
SEVC-UB 0.7 40.92 46.28 61.86 51.04 10.29 110
-LB 58.01 40.21
SEVE-UB 0.7 41.17 47.18 62.13 51.49 9.12 103
-LB 58.01 40.84
SVCV-UB 0.7 152.95 145.45 146.12 145.40 0.03 Inf
-LB 121.53 144.67
SCVV-UB 0.7 64.01 64.22 70.98 64.54 0.50 147
-LB 56.85 58.09
SCCC-UB 0.9 45.50 45.50 45.52 45.50 0.00 8
-LB 25.00 45.48
SEGC-UB 0.9 50.56 50.04 50.14 50.05 0.00 7
-LB 29.50 49.95
SMHC-UB 0.9 49.67

50.44 49.70

-LB 32.21 48.96
Column 1 (abcd):
a: SSymmetric or AAsymmetric. For asymmetric systems, mean
waiting times are presented only for queue 1.
A
1
: '
1
=0.02, '
2
=0.005, '
3
=0.063, '
4
=0.01, '
5
=0.002. A
2
: '
1
=
0.1, '
2
=0.05, '
3
=0.06, '
4
=0.01, '
5
=0.08.
b/c/d: CV of the service/switchover/setup time distributionsC =0, M=
0.5, E =1.0, G =1.5, H =3.49, and V =9.85.
Columns 38:
l|h
1
] $l: Upper and lower bounds on the expected waiting time using
SI approximation.
l|h
1
]: Exact expected waiting time using algorithm HYBRID.
l
1
|h
1
]: Level-1, upper and lower bounds on the expected waiting time.
l|
h
1
1
] =Average of level-1 upper and lower
bounds.
Error (%): % Error between l|h
1
] and l|
h
1
].
Perf Imp: Factor improvement in CPU time = CPU
Exact
,CPU
Level-1
(Inf if
CPU
Level-1
=0).
Exact waiting time not determined because CPU time was unduly long.
We report a select number of cases in Table 2 where
either the level-1 bounds were relatively loose, or the
upper bound from the SI model exhibits counterintu-
itive behavior in the sense that this bound is lower
than the exact value (often signicantly lower), or
the SI bounds were so loose as to have no practical
value. It is noted that not all such cases are reported
in the table. For the upper SI bound, we use an SI
model and assume that a setup takes place at each
polled queue, regardless of its state. For the lower
SI bound, we use an SI model and assume that no
setups take place at any queue (i.e., the setup times
are zero).
Table 2 shows that with high switchover time
variances, the common-sense bounds are completely
unpredictable. For example, with model SMHC with
j =0.1 and a CV of 3.49, the upper SI bound is sig-
nicantly less than the exact value, and is actually
lower than the lower SI bound. Similarly, for SCVC
with j =0.3, the upper SI bound is much lower than
the exact value, while the lower SI bound is larger
than the exact value. When the service time or the
setup time has a very high CV, often both bounds
are below the exact value. We also note that for some
models with a low CV for switchover time, with high
setup time variances the SI bounds are so loose as to
have no practical utility.
We note at this point that the SI model produces
counterintuitive behavior even with switchover time
CVs as low as 1.75, although we do not report it here
because they were obtained for models with N =3
queues. In general, the experiments we conducted
seem to suggest that for models with a smaller num-
ber of queues, such counterintuitive behavior occurs
with lower CVs. More detailed sets of experiments
are, however, needed before such a conclusion can
be made.
As we have remarked in the introduction section,
a number of papers provide approximation schemes
for the expected times for several variants of the
SD model. The model analyzed in this paper is a vari-
ant which includes both switchover and setup times.
It is possible to modify our model to specialize it
to the other variants proposed in the past, and one
can also undertake an extensive numerical compari-
son of the accuracy of the approximations. However,
because the focus in this paper is on providing a
hierarchy of bounds on the moments of the waiting
time, we did not undertake such a comparison in this
paper.
In general, based on the numerous experiments we
conducted, we suggest the following approach. If the
level-1 upper bound (UB) is fairly close to the level-1
lower bound (LB), say if (UB LB)/average - 5%,
where average is the simple average, then use the aver-
age. Otherwise, obtain the level-2 bound, take the
Table 3 Expected Waiting Time Level-1 Bounds
Data set l
1
|h
1
] CPU
1
l
1
|
h
1
]
7SHEHC-UB 44.11 2.0 44.10
-LB 44.09 2.0
7SLEEC-UB 25.23 1.0 18.26
-LB 11.29 1.0
7AHEEE-UB 16.27 1.0 16.23
-LB 16.19 1.0
10SLEEC-UB 13.61 16.0 11.88
-LB 10.15 16.0
10SMCCC-UB 42.21 66.0 37.54
-LB 32.87 62.0
15SMEEE-UB 27.66 2,163.0 25.13
-LB 22.60 2,136.0
Column 1 (#abcde): See the explanation provided in Table 1.
Columns 24:
l
1
|h
1
]: Level-1, upper and lower bounds on the expected
waiting time.
CPU
1
: CPU time in seconds to compute l
1
|h
1
].
l
1
|
h
1
1
] = Average of level-1
upper and lower bounds.
average of these bounds, and apply the same rule. We
note that the level-1 bounds are computed quickly,
even for models with a relatively large number of
queues (as high as 15 queuessee Table 3). Inciden-
tally, from a practical perspective, it seems unlikely
that that a single server would attend to such a large
number of queues, at least in a manufacturing set-
ting. On the other hand, the higher-level bounds take
considerable computational effort even with seven
queues, as can be observed for the 7-queue example
in Table 1.
In Table 3, we present level-1 bounds for various
large SD models. In general, for models of this size,
obtaining the exact values for the expected waiting
times is either not possible or highly time consum-
ing. As before, we also compute an approximate value
|
1
|

W
1
] simply by averaging the level-1 upper and
lower bounds. When the level-1 bounds are tight, the
experiments conducted above suggest that the aver-
age should present a fairly reliable estimate of the
exact value so long as the switchover time CVs are
not extremely high. We remind the reader that if the
level-1 bounds are not very tight, then the level-2 or
higher level bounds may be applied.
6. Conclusions
Despite its ability to represent real-world systems
more accurately, the SD polling model is not well
studied. The inherent complexity of the SD polling
model has limited research in this area, and the easier-
to-analyze SI polling model is often used as a surro-
gate. However, in many instances, using the SI model
in place of the more realistic SD model can result in
questionable values for the desired performance mea-
sures, as demonstrated in 5. That provides a moti-
vation for developing techniques to compute desired
performance measures for the SD model more easily.
The descendant sets technique offers a convenient
platform for analyzing the SD model. The technique
not only facilitates the modeling process, it also
allows us to explain the model in an intuitive manner.
For instance, when we discussed two manufactur-
ing scenarios, one of which required a new deni-
tion of the setup time, the technique allowed us to
accommodate this alternate denition easily, and in
a fairly intuitively manner. Tackling this modica-
tion using other mathematical approaches could have
presented additional challenges. The descendant sets
approach also facilitated the development of the PBH
technique which obtains a hierarchy of increasingly
tighter bounds on the waiting time moments for the
SD model with increased computational effort.
The PBH technique allows for quick computation
of bounds on waiting time moments. In particular, for
expected waiting times, level-1 bounds are computed
very quickly and are usually fairly tight, particularly
for symmetric models and models where the CV of
the switchover time is not very high. The memory and
computational effort required to compute level-1 and,
often, even level-2 bounds are relatively minimal and
so we can obtain tight bounds for large polling mod-
els. The model can be used to quickly determine, for
instance, the affect of adding another product (queue)
to the existing product portfolio. The exact analysis of
such models using available techniques would have
either taken an extremely long time, or would not
have been possible.
References
Altman, E., H. Blanc, A. Khamisy, U. Yechiali. 1994. Gated-type
polling systems with walking and switch-in times. Stochastic
Models 10 741763.
Boxma, O. J., J. A. Weststrate. 1989. Waiting times in polling sys-
tems with Markovian server routing. G. Stiege, J. S. Lie, eds.
Messung, Modellierung und Bewertung von Rechensystemen und
Netzen. Springer, Berlin, Germany, 89104.
Bradlow, H. S., H. F. Byrd. 1987. Mean waiting time evaluation
of packet switches for centrally controlled PBXs. Performance
Evaluation 7 309327.
Cooper, R. B., G. Murray. 1969. Queues served in cyclic order. Bell
Systems Tech. J. 48 675689.
Eisenberg, M. 1972. Queues with periodic service and changeover
times. Oper. Res. 20 440451.
Eisenberg, M. 1999. The polling system with state-dependent
changeover times. INFORMS Conf., Cincinnati, OH.
Ferguson, M. J. 1986. Mean waiting time for a token ring with
station-dependent overheads. R. L. Pickholtz, ed. Local Area and
Multiple Access Networks. Computer Science Press, New York,
4367.
Gnalay, Y., D. Gupta. 1997. Polling systems with a patient server
and state-dependent setup times. IIE Trans. 29 469480.
Gupta, D., M. M. Srinivasan. 1996. Polling systems with state-
dependent setup times. Queueing Systems 22 403423.
Kleinrock, L., H. Levy. 1988. The analysis of random polling sys-
tems. Oper. Res. 36 716732.
Konheim, A. G., H. Levy, M. M. Srinivasan. 1994. Descendant set:
An efcient approach for the analysis of polling systems. IEEE
Trans. Comm. 42 12451253.
Kreig, G. N., H. Kuhn. 2004. Analysis of multi-product kanban sys-
tems with state-dependent setups and lost sales. Ann. Oper.
Res. 125 141166.
Lennon, T. 1995. Response-time approximations for multi-server,
multi-class production systems with signicant setups. Techni-
cal report, University of Michigan, Ann Arbor, MI.
Levy, H. 1991. Binomial-gated service: A method for effective oper-
ation and optimization of polling systems. IEEE Trans. Comm.
39 13411350.
Levy, H., L. Kleinrock. 1991. Polling systems with zero switch-over
periods: A general method for analyzing expected delay. Per-
formance Evaluation 13 97107.
Olsen, T. L. 2001. Approximations for the waiting time distribution
in polling models with and without state-dependent setups.
Oper. Res. Lett. 28 113123.
Resing, J. A. C. 1993. Polling systems and multitype branching pro-
cesses. Queueing Systems 13 409426.
Sarkar, D., W. I. Zangwill. 1991. Variance effects in cyclic production
systems. Management Sci. 37 443453.
Singh, M. P., M. M. Srinivasan. 2001. Exact analysis of the state-
dependent polling model. Queuing Systems 41 371399.
Srinivasan, M. M. 1991. Nondeterministic polling systems. Manage-
ment Sci. 37 667681.
Srinivasan, M. M., M. P. Singh. 2006. An efcient exact procedure
for analyzing the state dependent polling model. IIE Trans. 38
153158.
Takagi, H. 1990. Queueing analysis of polling models: An update.
H. Takagi, ed. Stochastic Analysis of Computer and Communi-
cation Systems. North-Holland, Amsterdam, The Netherlands,
267318.
Takagi, H. 1997. Queueing analysis of polling models: Progress in
19901994. J. H. Dshalalow, ed. Frontiers in Queueing: Models
and Applications in Science and Engineering. CRC Press, Boca
Raton, FL, 119146.
Yehia, R. 1998. Polling models: Decomposition of waiting times
and effects of switchover and setup times. Ph.D. dissertation,
Florida Atlantic University, Boca Raton, FL.

Management Science: Performance Bounds For Flexible Systems Requiring Setups

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Management Science: Performance Bounds For Flexible Systems Requiring Setups

Загружено:

Авторское право:

Доступные форматы

MANAGEMENT SCIENCE

Vol. 53, No. 6, June 2007, pp. 9911004

], is denoted by (z). Multivariate

0), which represents the case where

0). Thus following the replacement, the

0). Theorem 1 shows that these replace-

0), for increasing val-

0). The technique now obtains a

0). We ignore the exact specication of

=0 for all ,=i. To compute

0). To elaborate, for the

0).) It then replaces each of these nonzero-

0). The bounds on

0), depending on whether a lower or an upper

0).) Now use either (11) or (12)

= 1 for all ,= i in the expression for the

0) requires O(N) operations. Hence, this

0). It can be veried that for the level-n bound,

Вам также может понравиться