Service Engineering April 15, 1997

Last Revised January 2, 2005

REVIEW: MARKOV JUMP-PROCESS (MJP)

MJP X = {Xt , t ≥ 0} on S = {i, j, . . .} countable.

Markov property: Pr {Xt = j|Xr , r < s; Xs = i} = Pij (s, t), ∀ s < t, ∀ i, j ∈ S.
Time homogeneity: Pr {Xs+t = j|Xs = i} = Pij (t), ∀ s, t, i, j, transition probabilities.

Characterization: π 0 = initial distribution and P (t) = [Pij (t)], t ≥ 0, stochastic.

Finite-dimensional distributions:
Pr {X0 = i0 , Xt1 = i1 , . . . , Xtn = in } = π 0 (i0 )Pi0 ,i1 (t1 ) . . . Pin−1 ,in (tn − tn−1 ).

P (t) : stochastic ; P (s + t) = P (s)P (t), ∀ s, t (Chapman Kolmogorov);

 
∃ P (0) = I ; ∃ Ṗ (0) = Q = [qij ], infinitesimal generator q
j∈S ij = 0 .

Micro to Macro : Ṗ (t) = P (t)Q (= QP (t)) and P (0) = I

Forward (Backward) equations.
∞ tn
Solution : P (t) = exp[tQ] = n=0 n! Qn , t ≥ 0.

qij
Animation: i −→ j; ∀ i, j ∈ S ∃ exponential clock at rate qij , call it (i, j).
Given i, consider clocks (i, j), j ∈ S; move to the “winner” when rings.

Thus: stay at i ∼ exp(qi = j=i qij ) and switch to j with probability Pij = qij /qi
(qij = qi Pij , i = j; qii = −qi ).

Transient analysis vs. long-run/limit stability/steady-state

∃ limt↑∞ Pij (t) = πj , ∀ i; π = πP (t), ∀ t.
 
0 = πQ
Calculation via steady-state equations: Ṗ (∞) = P (∞)Q ⇒ 
i πi = 1, πi ≥ 0
 
or balance equations: i=j πi qij = −πj qjj = i=j πj qji , ∀ j.

Transition rates: πi qij = long-run average number of switches from i to j.

   
Cuts: i∈B j∈B c πi qij = i∈B c j∈B πi qij , ∀ B ⊂ S.

c B
B

1
Ergodic Theorem: Let X be irreducible (i ↔ j). Assume that there exists a solution π
to its steady-state equations. Then, X must be “unexplosive” and π must be its stationary
distribution, its limit distribution and

T 
1
SLLN • lim 0 f (Xt )dt = πi f (i) (“=”Ef (X∞ )) ; eg. f (x) = 1B (x).
T ↑∞ T
i
  
1
• lim g(Xt− , Xt ) = πi qij g(i, j), for g(x, x) = 0, ∀ x; e.g. g(x, y) = 1C (x, y).
T ↑∞ T
t≤T i j

Birth & Death Model of a Service Station (Hall, §5.4)

λ0 λ1 λ n-1 λn

0 1 2 . . . . n-1 n ...

µ1 µ2 µn µ n+1

Cuts at n↔n + 1 yield: πn λn = πn+1 µn+1 , n ≥ 0;

λn λn λn−1 λ0 λ1 . . . λ n
πn+1 = πn = πn−1 = · · · = π0 .
µn+1 µn+1 µn µ1 µ2 . . . µn+1
The required solution exists if and only if
∞
 λ0 . . . λ n
<∞.
n=0 µ1 . . . µn+1

The Ergodic Theorem then yields

⎧
⎪
⎨ πn = λ0 ...λn−1
π0 , n ≥ 0
µ1 ...µn
⎪  −1
⎩ π0 = λ0 ...λn
n≥0 µ1 ...µn+1

Measures of Performance (MOP’s), in steady-state:

L = number of customers at the service station (also denoted Ls );

Lq = number of customers in the queue;
W = sojourn time of a customer at the service station (also denoted Ws );
Wq = waiting time of a customer in the queue;

 1T
E(L) = nπn = lim L(t)dt.
T ↑∞ T 0
n≥0

2
 Let m(n) = number of active servers at state n, 0 ≤ m(n) ≤ n; the servers are
statistically identical.

E(Lq ) = [n − m(n)]πn = also long-run average, as above.
n≥0

Service rate per server is µ(n)/m(n), n ≥ 1.

 µ(n)
Average (actual) service rate: m(n)
πn = E[µ(L)/m(L)].
n≥1
E[µ(L)/m(L)]
Potential service rate of each server: E[µ(L)/m(L)|L > 0] = 1−π0
.
 
Inflow rate: λ= πn qn,n+1 = πn λ(n) = Eλ(L).
n≥0 n≥0
↑ arrival


↓ departure

Outflow rate: δ= πn qn,n−1 = πn µ(n) = Eµ(L). (Assume µ(0) = 0.)
n≥0 n≥0

Note: in steady state, πn λn = πn+1 µn+1 , ∀ n ≥ 0 ⇒ inflow rate = outflow rate.

Throughput rate: Eλ(L) = Eµ(L) (the common quantity).

λ
Example. M/M/1 . . . n n+1 . . .

λj = λ, j ≥ 0; µj = µ · 1j≥1 .

λ
ρ= µ
<1 assumed for steady state (traffic intensity).

πn = (1 − ρ)ρn , n ≥ 0. Geometric distribution!


Actual service rate = πn · µ = µ(1 − π0 ) = µ · ρ = µ · λ
µ
= λ, contrasted with
n≥1

λ λ
Potential service rate = 1−π0
= ρ
= µ , as anticipated.


1 1
Additional properties: W ∼ exp mean = µ(1−ρ)
= µ
1+ ρ
1−ρ
, geometric mixture of exp’s.
Departure process is Poisson (λ) (Burke’s Theorem).
⎧
Wq d
⎪
⎨ 0 wp 1 − ρ
=

1/µ ⎪⎩ exp mean = 1
wp ρ
1−ρ

3
 λ

Example M/M/∞ . . . n n+1 . . .

(n+1) µ

Always stable.
n
πn = e−ρ ρn! , n ≥ 0 , Poisson distribution!

1
E (# busy servers) = λ · µ
= λ
µ
= ρ.

Very useful: ∞-server models provide upper bound (e.g., Israel Electric Company).

Example M/M/S
µj = (j ∧ s)µ , λj ≡ λ ,

λ
ρ = <1 assumed, as before, to ensure stability.
sµ

ak
πk = π0 , k ≤ S,
k!
s s ρk
= π0 , k ≥ S,
s!
⎡ ⎤−1

s−1
aj as λ
π0 = ⎣ + ⎦ , where a = , offered load.
j=0 j! s!(1 − ρ) µ

Note: “Wait | Wait > 0” is exponential, having the same distribution as that in an
M/M/1 queue with arrival rate λ and service rate S · µ.

Erlang-C Formula (1917):

 aS 1
E2,S = πk = · π0 , delay probability (PASTA).
k≥s S! 1 − ρ

Example M/M/S/S

λj ≡ λ, j = 0, . . . , S − 1, µj = j · µ for j = 1, 2, . . . , S .
Always reaches steady state.
 S
ak  aj
πk = , k = 0, 1, . . . , S.
k! j=0 j!

4
Erlang-B Formula:
 S
as  aj
E1,S = πS = , loss probability (PASTA).
s! j=0 j!

λπs – rate of lost customers,

λ(1 − πs ) – effective throughput.

Note: Useful relations between the Erlang-B and Erlang-C formulae are

(S − a)E2,S E1,S
E1,S = ; E2,S = ;
S − aE2,S (1 − ρ) + ρE1,S

E2,S > E1,S , as expected: why?

The expression of E2,S in terms of E1,S will become especially useful later on.

Example M/M/S/N (S ≤ N )

λj = λ, 0 ≤ j ≤ N − 1, (λN = 0)
µj = (j ∧ S)µ, 1 ≤ j ≤ N. (µ0 = 0)

Formulae straightforward but cumbersome (simply truncate M/M/S).

Always reaches steady state.

Note: Mainly M/M/S (Erlang-C) and sometimes M/M/S/S (Erlang-B) are the prevalent
models used in the world of call centers. However, M/M/S/N is more appropriate, and
even more so M/M/S/N + Abandonment: Erlang-A.

But the following question then arises: How to model Abandonment?

5
Erlang’s Formulae
(Exact Results for M/M/m = Erlang-C, and M/M/m/m = Erlang-B)
³ ´
R
R = offered load = λ/µ = m · ρ ; ρ = m

Rm
m!
Erlang B: E1,m = Pm Rk
Probability of blocking/loss
k=0 k!

Rm 1
m! 1−ρ
Erlang C: E2,m = Pm−1 Rk m Probability of delay
k=0 k!
+ Rm! 1−ρ
1

Relations (Palm, 1943?)

- Some observations on the Erlang formulae. . . . . . . . .pg. 18

- Contributions to the Theory of Delay Systems . . . . . .pg. 37

nE1,n E1,n
1. E2,n = = for ³ ρ < 1 ´
(n − R) + RE1,n (1 − ρ) + ρE1,n
ρ = Rn
d 1
E2,n > E1,n ; dR
E2,n (n) = nE1,n (n)

R(n − 1 − R)E2,n−1
2. E2,n = for R < n − 1.
(n − 1)(n − R) − RE2,n−1
(Must have R < 1 to start with E2,1 = ρ)

RE1,n−1 ρE1,n−1
3. E1,n = = ; E1,0 = 1.
n + RE1,n−1 1 + ρE1,n−1

Recursions are useful for calculations.

For example, to calculate E2,n , it is convenient to calculate recursively E1,n via 3. and
then calculate E2,n via 1.
They will also be useful for us in asymptotic analysis of systems with many servers.
For example, to analyze the behavior of E2,n , as n ↑ ∞, it is convenient to analyze first
E1,n , and then use 1.

Recall: Erlang B/C/A formulae, and much more, are implemented in 4CallCenters that
you have been using.

21