Elsevier

Operations Research Letters

Volume 37, Issue 5, September 2009, Pages 312-316
Operations Research Letters

Instability of FIFO in a simple queueing system with arbitrarily low loads

https://doi.org/10.1016/j.orl.2009.05.001Get rights and content

Abstract

We show, using a simple example, that the First-In-First-Out (FIFO) policy can be unstable in a system with arbitrarily low load. Our proof is based on the observation that the special structure of the example we use allows us to establish stability using a much simpler queueing system.

Introduction

It is now well known that a system that has theoretically sufficient capacity to meet all the demand is not necessarily stable [1], [2]. There is a vast literature on how to establish stability of queueing systems using fluid modes or drift rate arguments; see  [3], [4]. These tools have been successfully used to establish stability of queueing systems in many different settings. Stability of FIFO has also been studied extensively; see [5], [6], [7] and the references therein. It has been shown in [5] for a stochastic queueing network and in [7] for an adversarial queue that FIFO can be unstable in arbitrarily low loads. In this paper, we prove the instability of FIFO in arbitrarily low loads using a very simple example compared to those in [5], [7].

Consider a queueing system that consists of two job classes and two server pools, see Fig. 1(a). We refer to these systems as X-systems. Let λj denote the arrival rate to class j. Let μij denote the service rate of a class j job by server i for i,j=1,2. We assume that μij>0 for all i,j=1,2. Also assume that service times and interarrival times are exponential. Define θ(μ,λ)=μ11μ12λ1μ12+λ2μ11+μ21μ22λ1μ22+λ2μ21. Our main result (Theorem 2.1) is that if θ(μ,λ)>1 the system is positive Harris recurrent (see, [3]), i.e., the underlying Markov process has a stationary distribution, and it is rate stable if θ(μ,λ)=1 and transient if θ(μ,λ)<1. From (1.1), it is not difficult to see that FIFO can be unstable even when the load on the system is very small. For example, let λ1=λ2=1, μ11=μ22=1000 and μ21=μ12=0.1 so that θ(μ,λ)0.2, hence the system is unstable. We first note that as long as server 1 is not allowed to serve class 2 jobs and server 2 is not allowed to serve class 1 jobs, the system will be stable and the utilization of the servers will be 0.01%. It is not difficult to see that the system will be unstable as long as μ21<0.5 and μ12<0.5 no matter how large μ11 and μ22 are. To illustrate, we simulate this system with μ21=μ12=0.49 and μ21=μ12=0.51 with μ11=μ22=1000. The result are shown in Fig. 1(b). The increasing curve is the number of jobs in the first queue when service rate is μ21=μ12=0.49 and the line on the bottom is for the system with μ21=μ12=0.51. The number of jobs in the second queue, which is not plotted, exhibits a similar trend.

The idea of the proof of our main result is based on the fact that, when there are jobs in a queue waiting, the class of the job a server will serve next does not depend on the system history. For instance, in the numerical example we gave in the previous paragraph, the probability that the next job belongs to either class is 50% and this is independent from the state of the system. Given this fact, it is not difficult to see that the system is unstable, since the average time server j takes to finish service is 0.5/μj1+0.5/μj2. Again, if μ12=μ21<0.5, this implies on average the service time of a job from either server is greater than 1. Since the total arrival rate is 2, the queue lengths are bound to explode. In general, the analysis of the stability of FIFO is very complicated. We prove the result by showing that the X-model under FIFO is equivalent to another system with a single queue. The stability of this new system can be established using traditional fluid models; see [8].

In [5], a similar result in a queuing system, where jobs visit each server several times and service time depends on the number of the visit, has been shown. However, unlike our example, the example used there has more and more servers as the load gets smaller and smaller. In [7], an adversarial queue in a system whose graph has to have at least a diameter O(r1log(1/r)3) if the arrival rate is r has been used to show instability of FIFO. Compared to these systems, our example is very simple. This is due to the fact that they only consider systems where each job class can only be served by a unique server. Allowing all servers to serve all the job classes simplifies the proof considerably. Such simplification is not possible, even when we add another server that can only serve one of the classes. However, it is possible to extend our result to the case with several servers and several job classes as long as all the servers can handle all the job classes.

It should be clear from our example above that the main reason why FIFO is not stable is because servers use activities, job class-server matchings, that are not very “efficient”. It is common in the literature to devise scheduling policies assuming which activities are efficient; see [9], [10] among others. This is accomplished by formulating a static planning problem (SPP) (see Section 2) and determining from its solution which activities should be used, called the basic activities, and which activities should not be used, called the non-basic activities. However, the SPP requires information about arrival rates, which is not always available. We note, however, that there are policies such as max-weight; see [11] and the references therein, that do not require the information about which activities are basic.

The rest of this paper is organized as follows. In Section 2 we present the details of the queueing system and our main result. In Section 3 we prove the main result.

Section snippets

Queuing model and main result

Consider the X-model introduced in the previous section. Assume that servers are dispatched according to a FIFO policy; when a server finishes service, that server starts serving the longest waiting job in the system if there are any. How a job is routed to servers when there is an arrival to an empty system does not matter. For concreteness, it can be assumed that a server is picked randomly with equal probability. Service times depend both on the class and the server providing service. We

Proof of Proposition 2.3

For the rest of the proof we drop “” from the notation for simplicity. We can prove Proposition 2.3 using the traditional fluid model analysis; see [8]. Note that, for stability analysis, we can assume in this system that there is only one job class and the service times in server i has exponential distribution with rate μij with probability λj/(λ1+λ2), for j=1,2 and i=1,2. Therefore, the average service time of a job in server i is mi=j=12λjλ1+λ2μij1.

Allow A(t) to denote the number of

Acknowledgment

The author would like to thank the anonymous referee for the suggestion on how to prove the main result of this paper using a simpler argument than the original one which appeared in the first version.

References (13)

  • A. Rybko et al.

    Ergodicity of stochastic processes describing the operation of open queueing networks

    Problems of Information Transmission

    (1992)
  • S. Lu et al.

    Distributed scheduling based on due dates and buffer priorities

    IEEE Transactions on Automatic Control

    (1991)
  • J.G. Dai

    Stability of Fluid and Stochastic Processing Networks

    (1999)
  • S. Meyn et al.

    Markov Chains and Stochastic Stability

    (1993)
  • M. Bramson

    Instability of FIFO queueing networks

    The Annals of Applied Probability

    (1994)
  • V. Cholvi, J. Echague, Stability of FIFO networks under adversarial models: State of the art, Computer Networks 51 (5)...
There are more references available in the full text version of this article.

Cited by (0)

View full text