# Queuing Systems Lecture 4

Shared by:
Categories
-
Stats
views:
17
posted:
4/16/2010
language:
English
pages:
18
Document Sample

```							Queuing Systems: Lecture 4

Amedeo R. Odoni
October 22, 2001
Quiz #1: October 29

• Open book, 85 minutes (start 10:30)
• Chapter 4 coverage: Sections
4.1through 4.7 (inclusive); Section 4.9
(skim through 4.9.4)
• Review Problem Set 3
• Review some old quizzes
• A simpler (than in the book) derivation of
the expression for L for M/G/1 systems is
provided in a note on the website; it
assumes FIFO service
• A derivation of expression (4.113) in the
book for M/M/1 queuing systems with
preemptive priorities and two classes of
customers is provided in another note on
the website
• We shall skip Section 4.8 in the book except
for a brief discussion at end of this lecture;
you may wish to skim through the section
Lecture Outline
• Introduction to systems with priorities
• Representation of a priority queuing system
• The M/G/1 non-preemptive priority system
• An important optimization theorem
• … and an important corollary
• Brief mention of other priority systems
• Bounds for G/G/1 systems
• A numerical example
Background and observations

• W, L, W q and Lq are not affected as long as the
queue discipline does not give priority to
certain classes of customers
•   WFIFO = WSIRO = WLIFO (what about the
corresponding variances?)
•   Things may change, however, in systems
where customers are assigned to various
priority classes, if different classes have
different service-time characteristics
•   Preemptive vs. non-preemptive priority
systems
•   Preemptive-resume vs. preemptive-repeat
A queuing system with r priority
classes
λ1            x x    1

λ2          x x x   2

λ k−1
x   k-1
Service

λk                    k      Facility

λ k+1        xxx x    k+1

λr             xx     r
M/G/1 system with non-preemptive
priorities: background
• r classes of customers; class 1 is highest
priority, class r is lowest
• Poisson arrivals for each class k; rate λk
• General service times, Sk , for each class;
fSk(s); E[Sk]=1/µk; E[Sk2]
• FIFO service for each class
• Infinite queue capacity for each class
• Define: ρk = λk /µk
• Assume for now that: ρ = ρ1 + ρ2 +….+ ρr <1
Expected time in queue of customer of
class k who has just arrived at system
k                 k −1
1         1
Wqk = W0 + ∑ ⋅ Lqi + ∑ ⋅ M i
µ
i =1 i
µ
i =1 i
W0 = expected remaining time in service of the customer who
occupies the server when the new customer (from class k) arrives

Lqi = expected no. of customers of class i who are already waiting
in queue at the instant when the newly arrived customer (from class
k) arrives

Mi = expected number of customers of class i who will arrive while
the newly arrived customer (from class k) is waiting in queue
Expressions for the constituent parts

E[ Si2 ]      µ i ⋅ E[ S i2 ]
(W0 | i) =              =                   [random incidence, see (2.66)]
2 ⋅ E[ S i ]         2

r
ρ i ⋅ µ i ⋅ E[ S i2 ] r λi ⋅ E[ Si2 ]
r
è   W0 = ∑ ρ i ⋅ (W0 | i ) = ∑                         =∑                 (1)
i =1                i =1
2            i =1
2

Lqi = λi ⋅ Wqi                                                        (2)

M i = λi ⋅ Wqk                                                        (3)
A closed-form expression

k                       k −1
Wqk = W0 + ∑ ρ i ⋅ Wqi + Wqk ⋅ ∑ ρ i [from (1), (2) and (3)]
i =1                      i =1
k
W0 + ∑ ρ i ⋅ Wqi
è       Wqk =           i =1              for k = 1, 2,......, r
k −1
(4)
1−   ∑ ρi
i =1

and solving (4) recursively, for k=1, k=2,….., we obtain (5):
k
W0
Wqk =                            for k = 1, 2,......, r      where a k = ∑ ρ i
(1 − a k −1 )(1 − a k )                                               i =1
A generalization

• Let p be an integer between 1 and r such that
ρ1 + ρ2 +….+ ρp <1   while      ρ1 + ρ2 +….+ ρp + ρp+1 ≥ 1
• Then customers in classes 1 through p experience
steady-state conditions, while those in p+1 through r
suffer unbounded in-system (or waiting) times
• Customers in classes 1 through p occupy the server a
fraction ρk of the time each (k = 1, 2, …, p); customers in
class p+1 occupy the server a fraction 1- ap ;and the other
classes do not have any access
• The expression (5) for Wqk can be modified accordingly
by writing the correct expression for W0 in the numerator
Generalized expression

2
p
ρ i ⋅ E[ S i2 ]     (1 − a p ) ⋅ E[ S p +1 ]
∑ 2 ⋅ E[ S i ]
+
2 ⋅ E[ S p +1 ]
Wqk = i =1                                                   for k ≤ p
(1 − a k −1 )(1 − a k )

Wqk = ∞ k > p
Minimizing total expected cost

ck = cost per unit of time that a customer of class k
spends in the queuing system (waiting or being served)
• Suppose we wish to minimize the expected cost (per
unit of time) of the total time that all customers spend in
the system:
r            r           r
C = ∑ ci ⋅ Li = ∑ ci ⋅ ρ i + ∑ ci ⋅ λi ⋅ Wqi   (6)
i =1         i =1        i =1

• For each class k compute the ratio
ck
fk =          = ck ⋅ µ k
E[ S k ]
Optimization theorem and corollary

• Theorem: To minimize (6), priorities
should be assigned according to the
ratios fk : the higher the ratio, the higher
the priority of the class.

• Corollary: To minimize average time in the
system for all customers, priorities should
be assigned according to the expected
service times for each customer class: the
shorter the expected service time, the
higher the priority of the class.
Cost inflow and outflow in a
priority queuing system
Cost (\$)                    Cost
inflow

c(t)
Cost
outflow

ck
ck

t1   t2                           Time
Other priority systems

• Simple closed-form results also exist for
several other types of priority systems;
examples include:
_   Non-preemptive M/M/m queuing systems with r classes
of customers and all classes of customers having the
same service rate µ
_   Preemptive M/M/1 queuing systems with r classes of
customers and all classes of customers having the
same service rate µ (see below expression for W k)
k
(1 µ )
Wk =                           for k = 1, 2,......, r   where a k = ∑ ρ i
(1 − a k −1 )(1 − a k )                                        i =1
A general upper bound for G/G/1
systems
• A number of bounds have been obtained for more
general cases (see Section 4.9)
• A good example is an upper bound for the waiting time at
G/G/1 systems:
λ ⋅ (σ X + σ S )
2       2
(7)
Wq ≤                     ( ρ < 1)
2 ⋅ (1 − ρ )

where X and S are, respectively, the r.v.’s denoting inter-
arrival times and service times
• Under some fairly general conditions, such bounds can
be tightened and perform extremely well
Better bounds
for a (not so) special case
• For G/G/1 systems whose inter-arrival times have the
property that for all non-negative values of t0,
1
E[ X − t 0 | X > t 0 ] ≤   (what does this mean, intuitively?)
λ

it has been shown that:

1+ ρ            λ ⋅ (σ 2 + σ S )2
B−      ≤ Wq ≤ B =         X           ( ρ < 1)       (8)
2λ                2 ⋅ (1 − ρ )

• Note that the upper and lower bounds in (8) differ by,
at most, 1/λ and that the percent difference between
the upper and lower bounds decreases as ρ increases!

```
Related docs