# Approximate analysis of single-server tandem queues with finite buffers

## Abstract

In this paper, we study single-server tandem queues with general service times and finite buffers. Jobs are served according to the Blocking-After-Service protocol. To approximately determine the throughput and mean sojourn time, we decompose the tandem queue into single-buffer subsystems, the service times of which include starvation and blocking, and then we iteratively estimate the unknown parameters of the service times of each subsystem. The crucial feature of this approach is that in each subsystem successive service times are no longer assumed to be independent, but a successful attempt is made to include dependencies due to blocking by employing the concept of Markovian Arrival Processes. An extensive numerical study shows that this approach produces very accurate estimates for the throughput and mean sojourn time, outperforming existing methods, especially for longer tandem queues and for tandem queues with service times with a high variability.

## Keywords

Blocking Decomposition Finite buffer Flow line Markovian arrival process Matrix-analytic methods## 1 Introduction

The subject of this paper is the approximative analysis of single-server tandem queues with general service times and finite buffers. The blocking protocol is Blocking-After-Service (BAS): if the downstream buffer is full upon service completion the server is blocked and has to wait until space becomes available before starting to serve the next job (if there is any). Networks of queues (and in particular, tandem queues) with blocking, have been extensively investigated in the literature; see e.g. Buzacott et al. (1995), Colledani and Tolio (2011), Dallery and Gershwin (1992), Perros and Altiok (1986), Perros (1989, 1994). In most cases, however, queueing networks with finite buffers are analytically intractable and therefore the majority of the literature is devoted to approximate analytical investigations. The approximation developed in this paper is based on decomposition, following the pioneering work of Gershwin (1987): the tandem queue is decomposed into single-buffer subsystems, the parameters of which are determined iteratively. In each subsystem, the “actual” service time, starvation and blocking are aggregated in a single service time, and these aggregate service times are typically assumed to be successively independent. However, these aggregate service times are not independent. For instance, knowledge that the server is blocked after service completion (resulting into a long aggregate service time) makes it more likely that the server will also be blocked after the next service. Especially in longer tandem queues with small buffers and in tandem queues with service times with high variability, dependencies of successive aggregate service times may have a strong impact on the performance. In this paper, an approach is proposed to include such dependencies in the aggregate service times.

*L*consisting of

*N*servers and

*N*−1 buffers in between. The servers (or machines) are labeled

*M*

_{ i },

*i*=0,1,…,

*N*−1. The first server

*M*

_{0}acts as a source for the tandem queue, i.e., there is always a new job available for servicing. The service times of server

*M*

_{ i }are independent and identically distributed, and they are also independent of the service times of the other servers;

*S*

_{ i }denotes the generic service time of server

*M*

_{ i }, with rate

*μ*

_{ i }and squared coefficient of variation \(c^{2}_{S_{i}}\). The buffers are labeled

*B*

_{ i }and the size of buffer

*B*

_{ i }is

*b*

_{ i }(i.e.,

*b*

_{ i }jobs can be stored in

*B*

_{ i }). We assume that each server employs the BAS blocking protocol. An example of a tandem queue with 4 machines is illustrated in Fig. 1.

The approximation is based on decomposition of the tandem queue into subsystems, each one consisting of a single buffer. To take into account the relation of buffer *B* _{ i } with the upstream and downstream part of the tandem queue, the service times of the server in front of buffer *B* _{ i } and the one after buffer *B* _{ i } are adapted by aggregating the “real” service times *S* _{ i−1} and possible starvation of *M* _{ i−1} before service, and *S* _{ i } and possible blocking of *M* _{ i } after service. The aggregate service processes of *M* _{ i−1} and *M* _{ i } are described by employing the concept of Markovian Arrival Processes (MAPs; see e.g. Neuts 1989), the parameters of which are determined iteratively. It is important to note that Markovian Arrival Processes can be used to describe dependencies between *successive* service times. Although decomposition techniques for single-server queueing networks have also been widely used in the literature, see e.g. Gershwin (1987), Helber (2005), Kerbache and MacGregor Smith (1987), Perros (1994), van Vuuren et al. (2005), van Vuuren and Adan (2009), the distinguishing feature of the current approximation is the inclusion of dependencies between successive (aggregate) service times by employing Markovian Arrival Processes.

The paper is organized as follows. In Sect. 2 we describe the decomposition of the tandem queue in subsystems. Section 3 presents the iterative algorithm. The service processes of each subsystem are explained in detail in Sects. 4 and 5, after which the subsystem is analyzed in Sect. 6. Numerical results can be found in Sect. 7 and they are compared to simulation and other approximation methods. Finally, Sect. 8 contains some concluding remarks and gives suggestions for further research.

## 2 Decomposition

*L*is decomposed into

*N*−1 subsystems

*L*

_{1},

*L*

_{2},…,

*L*

_{ N−1}. Subsystem

*L*

_{ i }consists of buffer

*B*

_{ i }of size

*b*

_{ i }, an arrival server \(M_{i}^{a}\) in front of the buffer, and a departure server \(M_{i}^{d}\) after the buffer. Figure 2 displays the decomposition of line

*L*of Fig. 1.

The arrival server \(M_{i}^{a}\) of subsystem *L* _{ i } is, of course, server *M* _{ i−1}, but to account for the connection with the upstream part of *L*, its service times are different from *S* _{ i−1}. The random variable *A* _{ i } denotes the service time of the arrival server \(M_{i}^{a}\) in subsystem *L* _{ i }. This random variable aggregates *S* _{ i−1} and possible starvation of *M* _{ i−1} before service because of an empty upstream buffer *B* _{ i−1}. Accordingly, the random variable *D* _{ i } represents the service time of the departure server \(M_{i}^{d}\) in subsystem *L* _{ i }; it aggregates *S* _{ i } and possible blocking of *M* _{ i } after service completion, because the downstream buffer *B* _{ i+1} is full. Note that successive service times *D* _{ i } of departure server \(M_{i}^{d}\) are *not independent*: a long *D* _{ i } induced by blocking is more likely to be followed by again a long one. The same holds for long service times *A* _{ i } induced by starvation. We try to include dependencies between successive aggregate service times in the modeling of *D* _{ i }, but they will be ignored in *A* _{ i }. The reason for modeling *A* _{ i } and *D* _{ i } differently is that starvation occurs before the service start and blocking after service completion, so there is an “asymmetry” in the available information at the end of *A* _{ i } and *D* _{ i }, respectively. In the subsequent sections we construct an algorithm to iteratively determine the characteristics of *A* _{ i } and *D* _{ i } for each *i*=1,…,*N*−1.

## 3 Iterative method

This section is devoted to the description of the iterative algorithm to approximate the performance of tandem queue *L*. The algorithm is based on decomposition of *L* in *N*−1 subsystems *L* _{1},*L* _{2},…,*L* _{ N−1} as explained in the previous section.

*Step 0: Initialization*

The first step of the algorithm is to initially assume that there is no blocking. This means that the random variables *D* _{ i } are initially assumed to be equal to *S* _{ i }.

*Step 1: Evaluation of subsystems*

We subsequently evaluate each subsystem, starting from *L* _{1} and up to *L* _{ N−1}. First we determine new estimates for the first two moments of *A* _{ i }, before calculating the equilibrium distribution of *L* _{ i }.

*(a) Service process of the arrival server*

*L*

_{1}, the service time

*A*

_{1}is equal to

*S*

_{0}, because server

*M*

_{0}cannot be starved. For the other subsystems we proceed as follows in order to determine the first two moments of

*A*

_{ i }. Define \(p_{i,b_{i}+2}\) as the long-run fraction of time arrival server \(M_{i}^{a}\) of subsystem

*L*

_{ i }is blocked, i.e., buffer

*B*

_{ i }is full, \(M_{i}^{d}\) is busy, and \(M_{i}^{a}\) has completed service and is waiting to move the completed job into

*B*

_{ i }. By Little’s law we have for the throughput

*T*

_{ i }of subsystem

*L*

_{ i }, By substituting in (1) the estimate \(T_{i-1}^{(k)}\) for

*T*

_{ i }, which is the principle of conservation of flow, and \(p^{(k-1)}_{i,b_{i}+2}\) for \(p_{i,b_{i}+2}\) we get as new estimate for \(\mathbb{E}[A_{i}]\), where the superscripts indicate in which iteration the quantities have been calculated. The second moment of

*A*

_{ i }cannot be obtained by using Little’s law. Instead we calculate the second moment using (3).

*(b) Analysis of subsystem* *L* _{ i }

Based on the new estimates for the first two moments of *A* _{ i }, we translate subsystem *L* _{ i } to a Markov process and calculate its steady-state distribution as described in Sect. 6.

*(c) Determination of the throughput of* *L* _{ i }

Once the steady-state distribution is known, we determine the new throughput \(T^{(k)}_{i}\) according to (7).

*Step 2: Service process of the departure server*

From subsystem *L* _{ N−2} down to *L* _{1}, we adjust the parameters to construct the distribution of *D* _{ i }, as will be explained in Sect. 5. Note that *D* _{ N−1}=*S* _{ N−1}, because server *M* _{ N−1} can never be blocked.

*Step 3: Convergence*

*k*−1)-th and

*k*-th iteration. When

## 4 Service process of the arrival server

In this section, we model the service process of arrival server \(M_{i}^{a}\) of subsystem *L* _{ i } (cf. Step 1(a) in Sect. 3). As an approximation, we act as if the service times *A* _{ i } are independent and identically distributed, thus ignoring dependencies between successive service times *A* _{ i }.

*B*

_{ i }, i.e., a job being served by \(M_{i}^{a}\) moves to buffer

*B*

_{ i }when space becomes available, corresponds to a departure from \(M_{i-1}^{d}\) in the upstream subsystem

*L*

_{ i−1}. Just after this departure, two situations may occur: subsystem

*L*

_{ i−1}is empty with probability (w.p.) \(q^{e}_{i-1}\), or it is not empty with probability \(1-q^{e}_{i-1}\). By convention, we do not count the job at \(M_{i-1}^{a}\) as being in

*L*

_{ i−1}. So subsystem

*L*

_{ i−1}is empty whenever there are no jobs in

*B*

_{ i−1}and \(M_{i-1}^{d}\). In the former situation,

*M*

_{ i−1}has to wait for a residual service time of arrival server \(M_{i-2}^{a}\) of subsystem

*L*

_{ i−1}, denoted as

*RA*

_{ i−1}, before the actual service

*S*

_{ i−1}can start. In the latter situation, the actual service

*S*

_{ i−1}can start immediately. Hence, since the service time

*A*

_{ i }of arrival server \(M_{i}^{a}\) includes possible starvation of

*M*

_{ i−1}before the actual service

*S*

_{ i−1}, we have

*A*

_{ i }. Based on \(q_{i-1}^{e}\) and the first two moments of

*RA*

_{ i−1}, the determination of which is deferred to Sect. 6 (cf. (8)), we obtain the second moment \(\mathbb{E}[A_{i}^{2}]\) as

## 5 Service process of the departure server

*L*

_{ i }in detail (cf. Step 2 in Sect. 3). To describe

*D*

_{ i }we take into account the occupation of the last position in buffer

*B*

_{ i+1}(or server \(M_{i+1}^{d}\) if

*b*

_{ i+1}=0). A job served by \(M_{i}^{d}\) may encounter three situations in downstream subsystem

*L*

_{ i+1}on departure from

*L*

_{ i }, or equivalently,

*on arrival at*

*L*

_{ i+1}; see Fig. 3. The situation encountered on arrival has implications for possible blocking of the next job served by \(M_{i}^{d}\), as will be explained below.

- (i)The arrival is triggered by a service completion of departure server \(M_{i+1}^{d}\) of
*L*_{ i+1}, i.e., server \(M_{i+1}^{a}\) was*blocked*because the last position in*B*_{ i+1}was occupied, and waiting for \(M_{i+1}^{d}\) to complete service. Then the next service of \(M_{i}^{d}\) (if there is a job) and \(M_{i+1}^{d}\) start simultaneously and buffer*B*_{ i+1}is full. We denote the time elapsing till the next service completion of departure server \(M_{i+1}^{d}\) by \(D^{b}_{i+1}\), which is equal to the time the last position in*B*_{ i+1}will be occupied before it becomes available again. Hence, in this situation, the next service time*D*_{ i }of \(M_{i}^{d}\) is equal to the maximum of*S*_{ i }and \(D^{b}_{i+1}\), if \(M_{i}^{d}\) can immediately start with the next service. Otherwise, if \(M_{i}^{d}\) is starved just after the departure,*D*_{ i }is equal to the maximum of*S*_{ i }and the*residual time*of \(D^{b}_{i+1}\) at the service start of \(M_{i}^{d}\). - (ii)
Just before the arrival there is only one position left in buffer

*B*_{ i+1}. So, right after this arrival,*B*_{ i+1}is full. Now we denote the time elapsing till the next service completion of departure server \(M_{i+1}^{d}\) by \(D^{f}_{i+1}\), which is again the time the last position in*B*_{ i+1}will stay occupied. Thus*D*_{ i }is equal to the maximum of*S*_{ i }and the residual time of \(D^{f}_{i+1}\) at the service start of \(M_{i}^{d}\). - (iii)
Finally, when neither of the above situations occurs, the arrival does not fill up buffer

*B*_{ i+1}, because there are at least two positions available in*B*_{ i+1}. Hence, the last position in*B*_{ i+1}stays empty and the next service time*D*_{ i }is equal to*S*_{ i }.

Note that only in situation (i) and (ii) the next job to be served by \(M_{i}^{d}\) can be possibly blocked at completion of *S* _{ i }. If a departure from *L* _{ i } encounters situation (i), (ii), or (iii) in *L* _{ i+1}, then what is the probability that the next departure from *L* _{ i } encounters one of these situations? Now we are not going to act as if the probability that the next departure from *L* _{ i } encounters either of the three situations is independent of the past. This would imply that successive service times *D* _{ i } are independent (and they are not). Instead, we are going to introduce transition probabilities between the above three situations, i.e., the probability that a departure encounters situation (i), (ii) or (iii) depends on the situation encountered by the previous one. Hence, the service process of \(M_{i}^{d}\) will be described by a Markov chain.

If a departure from *L* _{ i } sees situation (i), and \(M_{i}^{d}\) can immediately start with the next *S* _{ i } and finishes before \(M^{d}_{i+1}\) finishes \(D^{b}_{i+1}\), then the next departure from *L* _{ i } sees again (i). However, if \(M_{i+1}^{d}\) finishes first, then on completion of *S* _{ i } by \(M_{i}^{d}\), both (ii) or (iii) may be seen. We denote by \(p^{b,nf}_{i+1}\) the probability that \(M_{i+1}^{d}\) completes at least two services before the next arrival at *L* _{ i+1}, given that \(M_{i+1}^{d}\) completes at least one service before the next arrival. So, if \(M_{i+1}^{d}\) finishes first, then the next departure from *L* _{ i } sees (iii) with probability \(p^{b,nf}_{i+1}\), and (ii) otherwise. We assumed that \(M_{i}^{d}\) can immediately start service after a departure. If, on the other hand, \(M_{i}^{d}\) is starved and has to wait for the next job to arrive, then \(D^{b}_{i+1}\) should be replaced by the residual time of \(D^{b}_{i+1}\) at the service start of \(M_{i}^{d}\).

The transitions are the same from situation (ii), except that \(D^{b}_{i+1}\) should be replaced by \(D^{f}_{i+1}\). So, if a departure from *L* _{ i } sees situation (ii), and \(M_{i}^{d}\) finishes before *M* _{ i+1} (i.e., \(S_{i} < D^{f}_{i+1}\)), then the next departure from *L* _{ i } certainly sees (i). If \(S_{i} > RD^{f}_{i+1}\), then the next departure from *L* _{ i } sees (iii) with probability \(p^{f,nf}_{i+1}\) and (ii) otherwise.

*L*

_{ i }will never see (i). It will see (ii) with probability \(p^{nf,f}_{i+1}\) and (iii) otherwise, where \(p^{nf,f}_{i+1}\) is defined as the probability that, on an arrival at

*L*

_{ i+1}, there is exactly one position left in the buffer of

*L*

_{ i+1}. The different situations and possible transitions are summarized in Table 1, where we assume that \(M_{i}^{d}\) can immediately start with the next service after a departure. If this is not the case, then \(D^{b}_{i+1}\) and \(D^{f}_{i+1}\) should be replaced by their residual times at the start of the next service of \(M_{i}^{d}\) (since \(D^{b}_{i+1}\) and \(D^{f}_{i+1}\) will always start at the moment of a departure).

Different situations and possible transitions of the service process of departure server \(M_{i}^{d}\)

Service starts in | Aggregate service time | Next service starts in | ||
---|---|---|---|---|

(i) | \(\max(S_{i},D_{i+1}^{b})\) | if \(S_{i}<D_{i+1}^{b}\): | (i) | |

if \(S_{i}>D_{i+1}^{b}\): | (ii) | w.p. \(1-p_{i+1}^{b,nf}\) | ||

(iii) | w.p. \(p_{i+1}^{b,nf}\) | |||

(ii) | \(\max(S_{i},D_{i+1}^{f})\) | if \(S_{i}<D_{i+1}^{f}\): | (i) | |

if \(S_{i}>D_{i+1}^{f}\): | (ii) | w.p. \(1-p_{i+1}^{f,nf}\) | ||

(iii) | w.p. \(p_{i+1}^{f,nf}\) | |||

(iii) | | (ii) | w.p. \(p_{i+1}^{nf,f}\) | |

(iii) | w.p. \(1-p_{i+1}^{nf,f}\) |

This completes the description of the service processes of the arrival and departure servers of *L* _{ i }. In the next section, we translate subsystem *L* _{ i } to a Quasi-Birth-Death (QBD) process; see Latouche and Ramaswami (1999).

## 6 Subsystem

In this section, we describe the analysis of a subsystem *L* _{ i } (cf. Steps 1(b) and 1(c) in Sect. 3). For ease of notation, we drop the subscript *i* in the sequel of this section. In order to translate *L* to a Markov process, we will describe the random variables introduced in the foregoing sections in terms of exponential phases, commonly referred to as phase-type distributed random variables (see e.g. Tijms 1994). In Sect. 6.1, we first explain how to fit phase-type distributions on the first and second moment. By employing this concept, we translate subsystem *L* to a Quasi-Birth-and-Death process (QBD) in Sect. 6.2. Based on the steady-state distribution of this QBD, we derive performance measures, which can be used to model the service process of the arrival server succeeding the subsystem and the service process of the departure server preceding the subsystem.

### 6.1 Fitting phase-type distributions on the first two moments

*X*with mean \(\mathbb{E}[X]\) and second moment \(\mathbb{E}[X^{2}]\). The squared coefficient of variation \(c^{2}_{X}\) is defined as

*k*=2,3,…, then the mean and squared coefficient of variation of the Erlang

_{ k−1,k }distribution with density

*p*and

*μ*are chosen as

*X*in terms of a random sum of

*k*−1 or

*k*independent exponential phases, each with rate

*μ*. The phase diagram of the Erlang

_{ k−1,k }distribution is illustrated in the left part of Fig. 4. Alternatively, if \(c^{2}_{X}>1\), then the Hyper-Exponential

_{2}distribution with density

*p*,

*μ*

_{1}and

*μ*

_{2}are chosen as

*X*can be represented in terms of a probabilistic mixture of two exponential phases with rates

*μ*

_{1}and

*μ*

_{2}, respectively. The phase diagram of the Hyper-exponential

_{2}distribution is illustrated in the right part of Fig. 4.

*X*is said to have a Coxian

_{ k }distribution if it has to go through at most

*k*exponential phases, where phase

*i*has rate

*ν*

_{ i },

*i*=1,…,

*k*. It starts in phase 1 and after phase

*i*,

*i*=1,…,

*k*−1, it enters phase

*i*+1 with probability

*p*

_{ i }, and otherwise, it exits with probability 1−

*p*

_{ i }. Phase

*k*is the last phase, so

*p*

_{ k }=0. Clearly, the Erlang

_{ k−1,k }distribution is a Coxian

_{ k }distribution with

*ν*

_{ i }=

*μ*for all

*i*and

*p*

_{ i }=1 for

*i*=1,…,

*k*−2 and

*p*

_{ k−1}=1−

*p*. The Hyper-exponential

_{2}distribution is a Coxian

_{2}distribution with

*μ*

_{1}≥

*μ*

_{2}. This representation of Erlang and Hyper-exponential distributions in terms of Coxians will be convenient for the description of the service processes of the arrival and departure server in Appendices A and B.

It is also possible to use phase-type distributions matching the first three (or even higher) moments; see e.g. van der Heijden (1993), Osogami and Harchol-Balter (2003). Obviously, there exist many phase-type distributions matching the first two moments. However, numerical experiments suggest that the use of other distributions does not essentially affect the results, cf. Johnson (1993).

### 6.2 Subsystem analysis

We apply the recipe of Sect. 6.1 to represent each of the random variables *A*, *S*, *D* ^{ b } and *D* ^{ f } in terms of exponential phases. The status of the service process of the arrival server *M* ^{ a } can be easily described by the service phase of *A*. The description of the service process of the departure server *M* ^{ d } is more complicated. Here we need to keep track of the phase of *S* and the phase of *D* ^{ b } or *D* ^{ f }, depending on situation (i), (ii) or (iii). The description of this service process is illustrated in the following example.

### Example

*S*can be represented by two successive exponential phases,

*D*

^{ b }by three phases and

*D*

^{ f }by a single phase, where each phase possibly has a different rate. Then the phase-diagram for each situation (i), (ii), and (iii) is sketched in Fig. 5. States

*a*,

*b*and

*c*are the initial states for each situation. The gray states indicate that either

*S*,

*D*

^{ b }or

*D*

^{ f }has completed all phases. A transition from one of the states

*d*,

*e*,

*f*,

*g*and

*h*corresponds to a service completion of departure server

*M*

^{ d }(i.e., a departure from subsystem

*L*); the other transitions correspond to a phase completion, and do not trigger a departure. The probability that a transition from state

*e*is directed to initial state

*a*is equal to 1; the probability that a transition from state

*d*is directed to initial state

*a*,

*b*and

*c*is equal to 0, 1−

*p*

^{ b,nf }and

*p*

^{ b,nf }, respectively. The transition probabilities from the other states

*f*,

*g*and

*h*can be found similarly.

In Fig. 5 it is assumed that *M* ^{ d } can immediately start with the next service *S* after a departure. However, if *M* ^{ d } is starved, then *S* will not immediately start but has to wait for the next arrival at *L* (i.e., service completion of the arrival server *M* ^{ a }). However, *D* ^{ b } or *D* ^{ f } will immediately start completing their phases, and may even have completed all their phases at the start of *S*.

From the example above, it will be clear that the service process of *M* ^{ d } can be described by a Markovian Arrival Process (MAP): a finite-state Markov process with generator *Q* _{ d }. This generator can be decomposed as *Q* _{ d }=*Q* _{ d0}+*Q* _{ d1}, where the transitions of *Q* _{ d1} correspond to service completions (i.e., departures from *L*) and the ones of *Q* _{ d0} correspond to transitions not leading to departures. The dimension *n* _{ d } of *Q* _{ d } can be large, depending on the number of phases required for *S*, *D* ^{ b } and *D* ^{ f }. Similarly, the service process of *M* ^{ a } can be described by a Markovian Arrival Process with generator *Q* _{ a }=*Q* _{ a0}+*Q* _{ a1} of dimension *n* _{ a }. For an extensive treatment of MAPs, we refer the reader to Neuts (1989). The specification of the generators *Q* _{ a } and *Q* _{ d } is deferred to Appendices A and B, respectively.

*L*can be described by a QBD with states (

*i*,

*j*,

*l*), where

*i*denotes the number of jobs in subsystem

*L*, excluding the one at the arrival server

*M*

^{ a }. Clearly,

*i*=0,…,

*b*+2, where

*i*=

*b*+2 indicates that the arrival server is blocked because buffer

*B*is full. The state variables

*j*and

*l*denote the state of the arrival and departure process, respectively. To specify the generator

**Q**of the QBD we use the Kronecker product: If

*A*is an

*n*

_{1}×

*n*

_{2}matrix and

*B*is an

*n*

_{3}×

*n*

_{4}matrix, the Kronecker product

*A*⊗

*B*is defined as

*levels*, where level

*i*=0,1,…,

*b*+2 is the set of all states with

*i*jobs in the system. Then

**Q**takes the form:

**Q**. The transition rates from levels 1≤

*i*≤

*b*are given by where

*I*

_{ n }is the identity matrix of size

*n*. The transition rates are different for the levels

*i*=0 and

*i*=

*b*+2. At level

*b*+2 the arrival server

*M*

^{ a }is blocked, so where

*P*(

*x*,:) is the

*x*-th row of matrix

*P*and

*P*(:,

*y*) is the

*y*-th column of

*P*. To specify the transition rates to level 0, we introduce the transition rate matrix

*Q*

_{ s }of dimension

*n*

_{ s }, describing the progress of the phases of

*D*

^{ b }or

*D*

^{ f }while the departure server

*M*

^{ d }is starved. Further, the

*n*

_{ d }×

*n*

_{ s }matrix \(\bar{Q}_{d1}\) contains the transition rates from states in

*Q*

_{ d }, that correspond to a departure, to the initial states in

*Q*

_{ s }. Finally, \(\bar{I}_{n_{s},n_{d}}\) is the 0-1 matrix of size

*n*

_{ s }×

*n*

_{ d }that preserves the phase of

*Q*

_{ s }(i.e., the phase of

*D*

^{ b }or

*D*

^{ f }) when the departure server

*M*

^{ d }starts serving the next job after having been starved. Then we obtain This concludes the specification of

**Q**.

*i*by

*π*

_{ i }. Then

*π*

_{ i }has the matrix-geometric form

*R*is the minimal nonnegative solution of the matrix-quadratic equation

*R*and \(\hat{R}\) can be efficiently determined by using an iterative algorithm developed in Naoumov et al. (1997). The vectors

*π*

_{0},

*x*

_{1},

*x*

_{ b+1}and

*π*

_{ b+2}follow from the balance equations at the boundary levels 0,1,

*b*+1 and

*b*+2, Substitution of (6) for

*π*

_{1}and

*π*

_{ b+1}in the above equations yields a set of linear equations for

*π*

_{0},

*x*

_{1},

*x*

_{ b+1}and

*π*

_{ b+2}, which together with the normalization equation, has a unique solution. This completes the determination of the equilibrium probabilities vectors

*π*

_{ i }. Once these probability vectors are known, we can easily derive performance measures and quantities required to describe the service times of the arrival and departure server.

*Throughput:*

*Service process of the arrival server:*

*q*

^{ e }that the system is empty just after a departure and the first two moments of the residual service time

*RA*of the arrival server at the time of such an event. The probability

*q*

^{ e }is equal to the mean number of departures per time unit leaving behind an empty system divided by the mean total number of departures per time unit. So

*RA*can be easily obtained, once the distribution of the phase of the service time of the arrival server, just after a departure leaving behind an empty system, is known. Note that component (

*j*,

*k*) of the vector

*π*

_{1}

*B*

_{10}is the mean number of transitions per time unit from level 1 entering state (

*j*,

*k*) at level 0. By adding all components with

*j*=

*l*and dividing by

*π*

_{1}

*B*

_{10}

*e*, i.e., the mean total number of transitions per time unit from level 1 to 0, we obtain the probability that the arrival server is in phase

*l*just after a departure leaving behind an empty system. Further, if the service time

*A*of the arrival server is represented by a Coxian distribution with

*n*

_{ a }phases, where phase

*j*has rate

*ω*

_{ j }and exit probability 1−

*p*

_{ j },

*j*=1,…,

*n*

_{ a }, then the first two moments of the residual service time

*RA*given that the service time

*A*is in phase

*l*are given by Summation of the conditional moments multiplied by the probability of being in phase

*l*yields the moments of

*RA*.

*Service process of the departure server:*

*D*

^{ b }and

*D*

^{ f }and the transition probabilities

*p*

^{ b,nf },

*p*

^{ f,nf }and

*p*

^{ nf,f }. This requires the distribution of the initial phase upon entering level

*b*+1 due to a departure (or arrival). Clearly, component (

*j*,

*k*) of

*π*

_{ b+2}

*C*

_{01}is equal to the number of transitions per time unit from level

*b*+2 entering state (

*j*,

*k*) at level

*b*+1. Hence,

*π*

_{ b+2}

*C*

_{01}/

*π*

_{ b+2}

*C*

_{01}

*e*yields the distribution of the initial phase upon entering level

*b*+1 due to a departure. Defining

*D*

^{ b }(1) and

*D*

^{ b }(2) as the time till the first, respectively second, departure and

*A*

^{ b }(1) as the time till the first arrival, from the moment of entering level

*b*+1, it is straightforward to calculate the moments of

*D*

^{ b }(1)≡

*D*

^{ b }and the probabilities Pr[

*D*

^{ b }(1)<

*A*

^{ b }(1)] and Pr[

*D*

^{ b }(2)<

*A*

^{ b }(1)]. Transition probability

*p*

^{ b,nf }now follows from

*D*

^{ f }and transition probability

*p*

^{ f,nf }proceeds along the same lines, where the distribution of the initial phase upon entering level

*b*+1 due to an arrival is given by

*π*

_{ b }

*A*

_{0}/

*π*

_{ b }

*A*

_{0}

*e*. Finally,

*p*

^{ nf,f }satisfies

## 7 Numerical results

In order to investigate the quality of the current method we evaluate a large set of examples and compare the results with discrete-event simulation. We also compare the results with the approximation of van Vuuren and Adan (2009), a recent and accurate approximation. The crucial difference between the two methods lies in the modeling of the departure service process: the current method attempts to take into account dependencies between successive service times. In each example we assume that only mean and squared coefficient of variation of the service times at each server are known, and we match, both in the approximation and discrete-event simulation, mixed Erlang or Hyper-exponential distributions to the first two moments of the service times, depending on whether the coefficient of variation is less or greater than 1; see (4) and (5) in Sect. 6. Then we compare the throughput and the mean sojourn time (i.e., the mean time that elapses from the service start at server *M* _{0} until service completion at server *M* _{ N−1}) produced by the current approximation and the ones in van Vuuren and Adan (2009) with the ones produced by discrete-event simulation. Each simulation run is sufficiently long such that the widths of the 95% confidence intervals of the throughput and mean sojourn time are smaller than 1%.

We use the following set of parameters for the tests. The mean service times of the servers are all set to 1. We vary the number of servers in the tandem queue between 4, 8, 16, 24 and 32. The squared coefficient of variation (SCV) of the service times of each server is the same and is varied between 0.5, 1, 2, 3 and 5. The buffer sizes between the servers are the same and varied between 0, 1, 3 and 5. We will also test three kinds of *imbalance* in the tandem queue. We test imbalance in the mean service times by increasing the average service time of the ‘even’ servers from 1 to 1.2. The effect of imbalance in the SCV is tested by increasing the SCV of the service times of the ‘even’ servers by 0.5. Finally, imbalance in the buffer sizes is tested by increasing the buffers size of the ‘even’ buffers by 2. This leads to a total of 800 test cases.

Overall results for tandem queues with different buffer sizes

Buffer sizes | Error (%) in the throughput | Error (%) in mean sojourn time | ||||||||
---|---|---|---|---|---|---|---|---|---|---|

Avg. | 0–2 | 2–4 | >4 | VA | Avg. | 0–2 | 2–4 | >4 | VA | |

0,0,… | 1.41 | 88 | 10 | 2 | 7.22 | 3.94 | 53 | 19 | 28 | 11.66 |

1,1,… | 3.99 | 46 | 36 | 18 | 4.60 | 2.89 | 59 | 30 | 11 | 7.14 |

3,3,… | 3.32 | 56 | 28 | 16 | 3.85 | 2.03 | 75 | 25 | 0 | 4.61 |

5,5,… | 2.23 | 75 | 20 | 5 | 3.69 | 2.25 | 66 | 32 | 2 | 3.89 |

0,2,… | 1.56 | 89 | 11 | 0 | 4.70 | 2.38 | 75 | 23 | 2 | 6.76 |

1,3,… | 3.36 | 58 | 27 | 15 | 3.95 | 2.41 | 69 | 31 | 0 | 4.94 |

3,5,… | 2.71 | 66 | 21 | 13 | 3.63 | 1.88 | 77 | 22 | 1 | 3.88 |

5,7,… | 1.88 | 79 | 21 | 0 | 3.53 | 2.50 | 66 | 30 | 4 | 3.70 |

Overall results for tandem queues with different SCVs of the service times

SCVs | Error (%) in the throughput | Error (%) in mean sojourn time | ||||||||
---|---|---|---|---|---|---|---|---|---|---|

Avg. | 0–2 | 2–4 | >4 | VA | Avg. | 0–2 | 2–4 | >4 | VA | |

0.5,0.5,… | 0.77 | 100 | 0 | 0 | 1.03 | 2.37 | 70 | 21 | 9 | 2.67 |

1,1,… | 1.22 | 100 | 0 | 0 | 1.27 | 2.18 | 75 | 19 | 6 | 2.83 |

2,2,… | 1.85 | 90 | 10 | 0 | 3.09 | 2.24 | 76 | 20 | 4 | 4.95 |

3,3,… | 2.90 | 51 | 49 | 0 | 5.53 | 2.40 | 75 | 23 | 2 | 7.20 |

5,5,… | 5.58 | 15 | 45 | 40 | 9.64 | 3.29 | 48 | 45 | 7 | 10.31 |

0.5,1,… | 0.88 | 100 | 0 | 0 | 1.60 | 2.53 | 70 | 23 | 7 | 3.08 |

1,1.5,… | 1.22 | 100 | 0 | 0 | 1.85 | 2.26 | 73 | 21 | 6 | 3.20 |

2,2.5,… | 2.00 | 85 | 15 | 0 | 3.74 | 2.23 | 76 | 20 | 4 | 5.60 |

3,3.5,… | 3.19 | 41 | 59 | 0 | 6.18 | 2.40 | 75 | 23 | 2 | 7.75 |

5,5.5,… | 5.96 | 14 | 40 | 46 | 10.06 | 3.43 | 38 | 51 | 11 | 10.63 |

Overall results for tandem queues with different mean service times

Mean service times | Error (%) in the throughput | Error (%) in mean sojourn time | ||||||||
---|---|---|---|---|---|---|---|---|---|---|

Avg. | 0–2 | 2–4 | >4 | VA | Avg. | 0–2 | 2–4 | >4 | VA | |

1,1,… | 2.65 | 68 | 23 | 9 | 4.23 | 2.50 | 69 | 26 | 5 | 5.71 |

1,1.2,… | 2.46 | 71 | 21 | 8 | 4.57 | 2.57 | 67 | 27 | 6 | 5.93 |

Overall results for tandem queues of different length

Servers in line | Error (%) in the throughput | Error (%) in mean sojourn time | ||||||||
---|---|---|---|---|---|---|---|---|---|---|

Avg. | 0–2 | 2–4 | >4 | VA | Avg. | 0–2 | 2–4 | >4 | VA | |

4 | 2.26 | 69 | 29 | 2 | 0.57 | 1.77 | 83 | 17 | 0 | 0.95 |

8 | 2.68 | 66 | 27 | 7 | 2.87 | 1.82 | 81 | 18 | 1 | 2.80 |

16 | 2.68 | 68 | 21 | 11 | 5.30 | 1.63 | 88 | 9 | 3 | 5.39 |

24 | 2.55 | 72 | 17 | 11 | 6.41 | 2.65 | 66 | 26 | 8 | 8.38 |

32 | 2.61 | 73 | 16 | 11 | 6.84 | 4.80 | 19 | 62 | 19 | 11.59 |

From the tables we can conclude that the current method performs well and better than van Vuuren and Adan (2009). The overall average error in the throughput is 2.56% and the overall average error in the mean sojourn time is 2.54%, while the corresponding percentages for van Vuuren and Adan (2009) are 4.40% and 5.82%, respectively.

In Table 2 it is striking that in case of zero buffers the current method produces the most accurate estimates, while the method of van Vuuren and Adan (2009) produces the least accurate results. A possible explanation is that for each subsystem the current method keeps track of the status of the downstream server while its departure server is starved; this is not done in van Vuuren and Adan (2009). Both methods seem to be robust to variations in buffer sizes along the line. Table 3 convincingly demonstrates that especially in case of service times with high variability the current approximation performs much better that van Vuuren and Adan (2009). Remarkably, Table 5 shows that, while van Vuuren and Adan (2009) performs better for short lines, the average error in the throughput of the current method does not seem to increase for longer lines, a feature not shared by the approximation of van Vuuren and Adan (2009).

Throughput for four-server lines with exponential service times

| | Throughput | ||||||||
---|---|---|---|---|---|---|---|---|---|---|

0 | 1 | 2 | 3 | 1 | 2 | 3 | Exact | App | Buz | Per |

1 | 1.1 | 1.2 | 1.3 | 1 | 1 | 1 | 0.710 | 0.702 | 0.700 | 0.694 |

1 | 1.2 | 1.4 | 1.6 | 1 | 1 | 1 | 0.765 | 0.759 | 0.756 | 0.751 |

1 | 1.5 | 2 | 2.5 | 1 | 1 | 1 | 0.861 | 0.858 | 0.855 | 0.853 |

1 | 2 | 3 | 4 | 1 | 1 | 1 | 0.929 | 0.929 | 0.927 | 0.927 |

Throughput for three-server lines with general service times

| \(c^{2}_{S_{i}}\) | | Throughput | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|

0 | 1 | 2 | 0 | 1 | 2 | 1 | 2 | Sim | App | Buz | Alt |

0.5 | 0.5 | 0.5 | 0.75 | 0.75 | 0.75 | 2 | 2 | 0.385 | 0.383 | 0.385 | 0.368 |

0.5 | 0.5 | 0.5 | 2 | 2 | 2 | 2 | 2 | 0.322 | 0.317 | 0.312 | 0.338 |

0.5 | 0.5 | 0.5 | 2 | 2 | 2 | 2 | 9 | 0.360 | 0.353 | 0.349 | 0.368 |

## 8 Conclusions

In this paper, we developed an approximate analysis of single-server tandem queues with finite buffers, based on decomposition into single-buffer subsystems. The distinguishing feature of the analysis is that dependencies between successive aggregate service times (including starvation and blocking) are taken into account. Numerical results convincingly demonstrated that it pays to include such dependencies, especially in case of longer tandem queues and service times with a high variability. The price to be paid, of course, is that the resulting subsystems are more complex and computationally more demanding.

We conclude with a remark on the subsystems. There seems to be an asymmetry in the modeling of the service processes of the arrival and departure server. The service times of the arrival server are assumed to be independent and identically distributed, whereas the service times of the departure server are modeled by a Markovian arrival process, carefully taking into account dependencies between successive service times. Investigating whether a similar Makovian description of the service process of the arrival server is also feasible (and rewarding) seems to be an interesting direction for future research.

## Notes

### Open Access

This article is distributed under the terms of the Creative Commons Attribution Noncommercial License which permits any noncommercial use, distribution, and reproduction in any medium, provided the original author(s) and source are credited.

## References

- Altiok, T. (1989). Approximative analysis of queues in series with phase-type service times and blocking.
*Operations Research*,*37*, 601–610. CrossRefGoogle Scholar - Buzacott, J. A., Liu, X. G., & Shanthikumar, J. G. (1995). Multistage flow line analysis with the stopped arrival queue mode.
*IIE Transactions*,*27*, 444–455. CrossRefGoogle Scholar - Colledani, M., & Tolio, T. (2011). Performance evaluation of transfer lines with general repair times and multiple failure modes.
*Annals of Operations Research*,*182*, 31–65. CrossRefGoogle Scholar - Cumani, A. (1982). On the canonical representation of Markov processes modeling failure time distributions.
*Microelectronics and Reliability*,*22*, 583–602. CrossRefGoogle Scholar - Dallery, Y., & Gershwin, B. (1992). Manufacturing flow line systems: a review of models and analytical results.
*Queueing Systems*,*12*, 3–94. CrossRefGoogle Scholar - Gershwin, S. B. (1987). An efficient decomposition algorithm for the approximate evaluation of tandem queues with finite storage space and blocking.
*Operations Research*,*35*, 291–305. CrossRefGoogle Scholar - van der Heijden, M. C. (1993).
*Performance analysis for reliability and inventory models*. PhD Thesis, Vrije Universiteit, Amsterdam. Google Scholar - Helber, S. (2005). Analysis of flow lines with Cox-2-distributed processing times and limited buffer capacity.
*OR-Spektrum*,*27*, 221–242. CrossRefGoogle Scholar - Johnson, M. A. (1993). An empirical study of queueing approximations based on phase-type distributions.
*Communications in Statistics. Stochastic Models*,*9*, 531–561. CrossRefGoogle Scholar - Kerbache, L., & MacGregor Smith, J. (1987). The generalized expansion method for open finite queueing networks.
*The European Journal of Operations Research*,*32*, 448–461. CrossRefGoogle Scholar - Latouche, G., & Ramaswami, V. (1999).
*ASA-SIAM series on statistics and applied probability: Vol.**5*.*Introduction to matrix analytic methods in stochastic modeling*CrossRefGoogle Scholar - Naoumov, V., Krieger, U. R., & Wagner, D. (1997). Analysis of a multiserver delay-loss system with a general Markovian Arrival Process. In A. S. Alfa & S. R. Chakravarthy (Eds.),
*Lecture notes in pure and applied mathematics*.*Matrix-analytic methods in stochastic models*(pp. 43–66). New York: Marcel Dekker. Google Scholar - Neuts, M. F. (1989).
*Structured stochastic matrices of M/G/1-type and their applications*. New York: Marcel Dekker. Google Scholar - Osogami, T., & Harchol-Balter, M. (2003). Closed form solutions for mapping general distributions to minimal PH distributions.
*Performance Evaluation*,*63*, 524–552. CrossRefGoogle Scholar - Perros, H. G., & Altiok, T. (1986). Approximate analysis of open networks of queues with blocking: tandem configurations.
*IEEE Transactions on Software Engineering*, 450–461. Google Scholar - Perros, H. G. (1989). A bibliography of papers on queueing networks with finite capacity queues.
*Performance Evaluation*,*10*, 255–260. CrossRefGoogle Scholar - Perros, H. G. (1994).
*Queueing networks with blocking*. Oxford: Oxford University Press. Google Scholar - Tijms, H. C. (1994).
*Stochastic models: an algorithmic approach*. Chichester: Wiley. Google Scholar - van Vuuren, M., Adan, I. J. B. F., & Resing-Sassen, S. A. (2005). Performance analysis of multi-server tandem queues with finite buffers and blocking.
*OR-Spektrum*,*27*, 315–339. CrossRefGoogle Scholar - van Vuuren, M., & Adan, I. J. B. F. (2009). Performance analysis of tandem queues with small buffers.
*IIE Transactions*,*41*, 882–892. CrossRefGoogle Scholar