Queuing systems with non-standard service policies and server vacations

(1)

Queueing systems with non-standard service

policies and server vacations

Rocco van Vreumingen

November 1, 2019

Master thesis Mathematics Supervisor: dr. J.L. Dorsman

Korteweg-de Vries Institute for Mathematics Faculty of Sciences

(2)

Abstract

We investigate the response time of generalized SOAP systems. A SOAP system is a queuing system with an arbitrary scheduling policy among a class of almost all policies used in literature. More precisely, we derive the Laplace-Stieltjes transform and mean of the tagged customer’s response time. The generalizations we consider are server vacations and interruptions of customers by those who have higher priority. A special kind of dependent server vacations we consider, are those in polling systems. Under heavy-traffic assumptions (where the workload tends to 1) we even give closed-form expressions of the Laplace-Stieltjes transform.

Title: Queueing systems with non-standard service policies and server vacations Authors: Rocco van Vreumingen, rocco.vanvreumingen@student.uva.nl, 10519270 Supervisor: dr. J.L. Dorsman,

Second grader: dr. prof. M.R.H. Mandjes, End date: November 1, 2019

Korteweg-de Vries Institute for Mathematics University of Amsterdam

Science Park 904, 1098 XH Amsterdam http://www.kdvi.uva.nl

(3)

1 Introduction

Analysing the response time (sojourn time) of a M/G/1 queue under some scheduling policy has been the focus in thousands of papers over the past half century. Examples of scheduling policies are

• first-come, first-served (FCFS), which serves customers nonpreemptively in the order they arrive;

• shortest expected remaining processing time (SERPT), which preemptively serves the customer with the least expected remaining time;

• foreground-background (FB), which preemptively serves the customer that has re-ceived the least service so far; and

• processor sharing (PS), which serves all customers simultaneously at the same rate. In 2018, Scully et al. gave the Laplace-Stieltjes (LS) transform and mean of the response time under a very general policy, called Schedule Ordered by Age-based Priority (SOAP). It is a policy where the customer with lowest rank is preemptively served. The rank is a function of the customer’s age and unchangeable information about the customer itself when it arrives at the queue, e.g. its priority or size distribution. The policy includes almost all specific policies used in the literature as well as variants and unimaginable forms. Also the Gittins-index policy ([14], [15]) is included, of which it is known to minimize overall mean response time in the M/G/1 queue when customer service sizes (service times) are not known.

In Chapter 2 we cover [2], and in later chapters we use that to give the LS-transform and mean of the response time in yet more general settings where we add some delay elements. Specifically, in Chapter 3 we suppose that the server takes a vacation as soon as he becomes idle. After deriving the response time LS transform and mean, we use that to compare mean response times under two different situations. The first one is the M/G/1 queue with the Gittins index policy and server vacations. The second M/G/1 queue does not have server vacations and has another scheduling policy, so is known to yield a higher mean response time if the first queue would have no server vacations (as the service sizes of customers are unknown). It is then natural to ask what vacation distributions in the first queue still yield a lower response time, because there must be a boundary at which the vacation makes the second queue to have a lower response time. This boundary says something about the difference in response times between both queues and about the behaviour of the vacation when it makes the second queue more advantageous.

(6)

Another sort of delay that we discuss in that chapter is when the server takes a break every time that a customer interrupts another one due to higher priority. Such a pause could occur e.g. when the server has to adapt his settings in order to appropriately serve the customer with higher priority, or when the server cannot temporarily stop service immediately. However, this setting is hard to handle, so for this sort of delay we limit the discussion to special cases within SOAPs and only do mean value analysis.

In Chapter 4 we apply the theory from the earlier chapters to polling systems. A polling system is a multi-queue single-server system in which the server visits the queues in some order to serve customers. The delay element in this case is thus the time that the server is not present in the queue where the tagged customer, of which we want to analyse the response time, arrives.

Applications of polling systems can be found in e.g. computer-communication sys-tems, production-inventory systems and robotics. See [16] for an extensive overview. For production-inventory systems, service order scheduling proved its worth [19]. Other real-life examples in which the service order is not FCFS are Bluetooth R _{and 802.11}

protocols, scheduling policies at routers, and I/O subsystems in web servers [20],[21]. So it may be useful to do response time analysis for a large class of policies in some fixed queue in a polling system, and this may be used e.g. to determine which local policy among this large class minimizes the mean response time, or to determine optimizing results in terms of tails.

Within a polling system, a number of decisions have to be made: • the order in which to serve the queues;

• how many customers to serve during each visit to a queue; • the order in which customers within each queue are served.

We will investigate the influence of the third decision to the response time, but limit the results to the case where the first and second decision are most common: cyclic service order and exhaustive, gated or globally gated service. There are a lot of articles which focus on the first two decisions, but the third one has received little attention. The articles which we will use, do focus on the third decision, but only cover specific local orders (like FCFS, LCFS, PS etc.) In this thesis the local service of the queue where the tagged customer arrives, is an arbitrary SOAP system.

We will give expressions for the response time LS-transform and mean, after which we also give simple expressions for the LS-transform under heavy-traffic assumptions, which shortly means that the total workload in the polling system goes to 1.

There are several reasons to work with these HT-limits. First, when the workload is close to 1, the proper operation of the system is particularly critical. To improve the system performance, optimizing the local service order is effective. Second, as the LS-transform expression is quite simple when the workload tends to 1, this helps to

(7)

understand the behaviour of the polling system under more general settings. Third, HT asymptotics form an excellent basis for developing simple approximations of the performance measures (distributions, moments, tail probabilities) for stable systems.

(8)

2 SOAP systems

In this chapter we cover an article from Z. Scully et al. [2] briefly, for the ease of reference. The topic is a queue where the scheduling policy is arbitrarily chosen from a large class of policies, including almost all policies that are known in the literature. Given this arbitrary choice, the aim is to determine the LS-transform and expectation of the response time, i.e. the time between the customer’s arrival moment and its moment of finishing service. In other articles, response time results only hold for simple and specifically chosen policies.

We consider an M/G/1 queue, i.e. a queue where the arrivals form a Poisson-stream, the service times are generally distributed and there is exactly one server. Since the arrivals form a Poisson-stream, we can use the PASTA-property [1]. Let λ be the arrival rate and X the random variable for the customer’s service size (which we alternatively call service time). We assume that the system is stable, i.e. λEX < 1, we also assume that the server is always ready to serve the customers if there are any, and that our model is always preempt-resume, meaning preemption and processor sharing are permitted without penalty or loss of work.

The large class will consist of so-called SOAP-policies. In this class customers are served if they have lowest rank among all other customers in the system. This rank is not only different per customer, in addition it depends on its age, i.e. how long he has already had service. Now the rank is a parameter that fixes the order in which the customers are served. We do not even assume that the rank is monotonically decreasing with respect to age. This makes the class so large that it includes almost all policies used in the literature as well as more unimaginable forms.

2.1 Definition of SOAP

We will define a SOAP scheduling policy, where SOAP is an acronym for Schedule Or-dered by Age-based priority. It is a preemptive priority policy where the customer’s priority depends on its descriptor and age. The descriptor is an element d from a set D, i.i.d. chosen for each of the customers according to a fixed distribution D. If an en-tering customer has some descriptor d, this will never change, and it determines its size distribution Xd. Its age a ∈ R≥0 is the amount of time it has already received service,

so does change when getting service. Note that we can thus not model a SOAP system as a non-preemptive policy, since the age would then have no role. For determining how big the customer’s priority is, we have

• R, an arbitrary set of ranks,

(9)

• the rank function r : D × R≥0 → R, depending on the descriptor in D and age in

R≥0.

Now the customer with minimal rank has priority over all others. If there are two cus-tomers with the same rank, then the one who first arrived in the system has higher priority.

A customer outranks another customer if it has priority over it.

Furthermore, we need to define a SOAP as a limiting policy, where an approximated policy is obtained by approximated rank functions of the formP∞

i=0ri1[0,i·), where we

mean

1_[0,i·)(x) = (

1 if x ∈ [0, i · ) 0 else,

and where > 0 is a small discretization increment and ri ∈ R. We do this to handle

difficult situations where we want to justify that the server shares service between mul-tiple customers. For example, let two customers A and B both have a strictly increasing rank function with respect to age, and suppose that they are at a moment that they have the same rank. In that case, once the server serves A, then B immediately outranks A and thus the server has to switch infinitely many times in an arbitrarily small period.

For a more specific example, let customers A and B have rank function rA(d, a) = a

and rB(d, a) = 2a respectively. If they are at the same age, then the processor shares

service, but it would be reasonable that it serves A twice as fast as B.

Let us approximate these two rank functions by step functions, both with some small discretization increment > 0. More formally, for customer A we take the approximation

r,A = ∞

X

i=0

i · 1·[i,i+1)

and for B we take

r,B = ∞

X

i=0

2i · 1·[i,i+1).

Then it follows that the server has to switch service very often, but serves A twice as much as B. So in the corresponding limiting SOAP policy, he indeed shares service such that he serves A twice as fast as B, as desired.

A SOAP is well-defined under some regularity conditions:

• to make it possible to determine when and how to share the processor between multiple customers in general, we assume the following conditions. With respect to age, r is piecewise monotonic and piecewise differentiable, and any bounded region of R≥0 contains only finitely many boundary points between pieces;

(10)

• with respect to the descriptor, r must be piecewise continuous to ensure that certain expectations are well-defined. For example, if D is a continuous random variable, then EXD is well-defined by this piecewise continuity. If D is discrete,

then d 7→ r(d, (·)) is automatically piecewise continuous as the pieces are exactly the elements of D;

• strictly speaking, with respect to age, upwards jump discontinuities in r must be continuous from the right. To see why, consider the following example. Let a customer A with descriptor d1 have rank function r(d1, x) = 0 for x ≤ 2 and x − 1

otherwise. Let a second customer B with descriptor d2 arrive when A has an age

< 2, and let B have constant rank 1/2. Now we cannot give a time at which B outranks A. It is not when A has age 2, but at any other age a > 2 then A has already been outranked. Also, we cannot answer the question which rank A has when he gets outranked.

We remark that the problem can be remedied with a little abuse of notation, namely by saying that A’s age when getting outranked equals 2 + and its rank equals 1 − , where > 0 is arbitrarily small, i.e. for it holds that 0 < < x for all x > 0.

We close this section with a few examples of SOAP and non-SOAP systems.

Example 2.1.1. The FCFS policy is a SOAP. The rank-function r(d, a) = −a or any other strictly decreasing rank-function can be taken. We see that the descriptor does not have a role here.

Example 2.1.2. Consider a system with customer types 1, 2 . . . , n where customers with the same type are served in FCFS order but type (i) has priority over type (j) if i < j. The preemptive priority and even the nonpreemptive priority policies are SOAP policies, though a SOAP itself is a preemptive model. In both cases we can take the descriptor set D = {1, . . . , n} and a type (i) customer has descriptor i.

• In the preemptive case, the rank-function can be e.g. r(d, a) = d, because the customer with lowest rank is the customer with the lowest type;

• in the nonpreemptive case, the rank-function can be r(d, a) = (−a, d). Now the rank-function outputs values in R2 and we assume it is ordered lexicographically. The primary rank −a prevents preemption, the secondary rank d ensures that the next customer served is the one with the lowest type.

Unfortunately there are also important policies which are not SOAP systems.

Example 2.1.3. Again consider the system with n types of customers where for i < j it holds that type (i) has priority over type (j). For this example it does not matter whether it is a preemptive or nonpreemptive system. However, suppose now that the next arrival’s type depends on the previously arrived customer’s type. Now we cannot give a descriptor set such that the customers get i.i.d. descriptors, but this is required by the definition of a SOAP.

(11)

Example 2.1.4. At the Random Order of Service (ROS) policy, the next customer in the queue to be served is chosen randomly. This could have been a SOAP policy with rank-function r(d, a) = −a if the customers with the same current rank, that is, with age 0, would have had FCFS service instead of random service. Namely, in the definition of a SOAP it is included that the FCFS rule holds among customers with the same current rank.

A similar story holds for the LCFS (Last-Come First-Served) policy, where the LCFS rule holds among customers with the same rank.

2.2 New and old customers

We take an arbitrary tagged customer J . Of course J ’s response time depends on the other customers, but it depends differently on those who come after J , which we will call the new customers, and those who where already in the queue before J came, the old ones. To give a hint why this is so, old customers in general had a time of service that J did not have to wait for, because J was simply not in the queue yet. In other words, waiting for old customers is always when the old customer has age > 0. However, when new customers get service J has to wait for, then this always includes the waiting time from when the new customer has age zero.

Note that there can be no customer arriving at exactly the same moment as J (or oth-ers), because the arrival process is Poisson(λ). So each customer other than J is old or new. In the sequel, an arbitrary tagged customer is always denoted by J , an old customer is denoted by I, a new customer by K and unspecified customers other than J , by L. We call the amount of time J has to wait caused by L having service, J ’s delay due to L.

2.3 Pessimism principle

In this section we will give an adapted rank-function of J that does not affect its response time if J would have this adapted rank-function instead of its current one. An important property will be that the adapted rank-function is decreasing with respect to age, and this allows us to give derivations that could not have been done without this extra assumption.

Let J denote a tagged customer with service time x and descriptor d, and let rJ,d,x be

J ’s rank function with respect to age. Sometimes we skip writing one of the subscripts J, x or d if it is clear from the context or not important. Now we define the new rank-function. In terms of notation it will just mean that we add a superscript to rJ,d,x, and

that the subscripts J, d or x may again be skipped if they are not important to mention. Definition 2.3.1. The worst future rank of a customer J with descriptor d, age a and service size x is

rworst_J,d,x(a) = sup

a≤b<x

(12)

More informally, J ’s worst future rank at age a is its highest rank it will ever get in the rest of its service time.

Figure 2.1: J ’s rank imagined as a blue graph and its worst future rank as a dashed, purple graph. (From [2].)

Now for J to get at its age belonging to its worst future rank, then if I is in the system, I must complete service or have a rank r_J,d,xworst(0). As soon as this happens, J will get service until it has rank rworst

J,d,x(0) without having further delay from I. Moreover,

there is no delay anymore from I even until J completes, because J ’s rank will never get higher than rworst_J,d,x(0), at which J already had priority over I. Further, let aJ be J ’s

age when K arrives. A quite similar story holds then, but J has to wait the time that K got service until it has rank rworst_J,d,x(aJ) or completes (no strict inequality because

of the FCFS rule at ties). This is called the pessimism principle.

Remark 2.3.1. The inequalities in the above are true if the supremum in the above display is always attained. However, there are two cases where the supremum in the definition of the worst future rank is not attained by some age a. Firstly it may occur when the maximum is at a jump discontinuity, secondly it is the case when the maximum is at the open boundary a = x. Then I is served until it completes or has rank sup_a≤b<xr(d, b), so this time no strict inequality.

In this case we remedy it by defining the worst future rank as follows, with a slight abuse of notation:

rworst_J,d,x(a) = sup

a≤b<x

r(d, b) − ,

where > 0 is arbitrarily small. So then the worst future rank is “a fraction below the supremum”, whence it follows that “ sup_a≤b<xr(d, b) − ” means the same as “ sup_a≤b<xr(d, b)” and thus we can still use the strict inequality.

We can now determine the distribution of J ’s delay due to an arbitrary new customer K, because this immediately follows from the pessimism principle: J ’s delay due to K is the minimum of the time until K completes and the time until its rank gets over

(13)

r_J,d,xworst(aJ), where aJ denotes J ’s age when K arrives. We write this more formally as

follows. Recall that r(d, a) is the rank-function, where d ∈ D is a descriptor and a ∈ R≥0

in an age. Also recall that r_J,d,xworst(a) is the worst future rank of J with descriptor d and size x when it has age a.

Definition 2.3.2. Let D be a random vector with the descriptor distribution. The new r-work Xnew[r] = X_Dnew[r] is a random variable with the following properties. We write X_dnew[r] = X_Dnew[r]|(D = d). Now we define X_dnew[r] := min{Xd, cd[r]}, where r ∈ R

and cd[r] is the cutoff-age, defined by inf{a ≥ 0 : r(d, a) r}.

Let aJ be the age of J at which some K arrives. Then by the pessimism principle we

get that J ’s delay due to K is Xnew[rworst_J,d,x (aJ)].

2.4 The vacation transformation

Now that we have seen an expression for J ’s delay due to an arbitrary new customer, we go to the old ones. As mentioned, these in general already have had a time of service when J arrives, so they can have any age at J ’s arrival moment. This is different com-pared to the new customers, whose service start when J is in the system, which was one thing to make it easy to use the pessimism principle approach in the previous section. To handle the old customers, we will do something else. We will adapt the queuing system such that the delay due to all old customers together, is the same as the waiting time (time from arrival moment until first service moment) in the adapted queue. The adapted queue will have the FCFS policy, which is useful for derivations which are only valid for FCFS queues. For this, we need some definitions.

We split the old customers in three different types: • a discarded customer currently has rank rworst

J,d,x(0). We will see that these do not

delay J ;

• an original customer currently has rank rworst

J,d,x(0) and has never been discarded;

• a recycled customer currently has rank rworst

J,d,x(0) but had an earlier age at which

it was discarded.

We can also use a slightly different definition: a customer is discarded with respect to r if he currently has rank r, and we similarly define original and recycled customers with respect to r. But if we call customers discarded, recycled and original without specifying with respect to which rank, then we automatically mean that it is with respect to r = rworst_J,d,x(0).

Definition 2.4.1. Let r := rworst_J,d,x(0). The i-old r-work for i ∈ N0 is the amount of time

that a customer with descriptor d gets service while he is recycled for the i-th time. For i = 0 this is defined as the time that he is original. We denote the i-old r-work by X_i,dold[r].

(14)

If this customer will never be i-recycled, then X_i,dold[r] outputs 0. We call a customer who is recycled for the i-th time, an i-recycled customer. We further define i-old r-work when the descriptor is a random variable and denote this by X_iold[r] := X_i,Dold[r], like we did in an earlier definition for new customers.

We are now ready to make a transformed queue, derived from our original one such that the delay due to all old customers of J in the original queue is the same as the wait-ing time in the transformed queue. Note that we thus not look for a random variable for J ’s delay due to an individual old customer I, but the old customers altogether.

To start, J will arrive in the original queue, illustrated in Figure 2.2 by a block scheme. Note that there are no new customers yet, because this is about the queue when J did not arrive yet. The states of the server, i.e. which customers he serves or being empty, are in the blocks:

• at state “originals”, “recycled” and “discarded”, the server serves the original, recycled and discarded customers respectively;

• at state “empty” the system is empty, which is the same here as that the server serves no customers (by work-conservation).

Note that the states are only meaningful for J ’s perspective, as these depend on r_J,d,xworst(0). The arrows indicate from what state to another the server can go, or more precisely, those of which we do not exclude that the transition can occur. We see that from each state to another one there is an arrow, except for the one from “empty” to “recycled”, and we exclude this transition as follows. If the server’s queue is empty, then after the empty state there is an arrival moment, but a customer who just arrived cannot be recycled by definition.

In this queue we can view the customers as several customers, namely the parts at which he is original, discarded for the i-th time where i ∈ N and recycled for the i-th time. Thus we will pretend that when a customer becomes in another such part, then one customer leaves and another arrives. For example, when a customer is original and becomes discarded, then we will pretend that an original one leaves and a discarded one arrives.

Remark 2.4.1. For convenience we assume that the original customers still follow a Poisson(λ)-stream, also if an arrival is immediately discarded. In this case the time of being original is 0.

(15)

Figure 2.2: A block scheme of all server states in a SOAP policy before J ’s arrival moment.

Next, we can adapt this queue a bit without affecting J ’s delay due to old customers. We use the fact that only the old customers together yield this delay, but the order in which the old customers are served does not matter. So now we make the following change: the original customers and the recycled customers together are served in FCFS order. Thus if for example a recycled customer has service while an original customer arrives, then regardless of his rank he has to wait until the recycled customer is done, that is, until he is finished or become a discarded customer. For clarity, if there are no recycled or original customers present, then the server still looks for the discarded ones. As a consequence, the arrow from “original” to “recycled” can be removed by the following reason. An arrival of a recycled customer is by definition at the moment of the server’s transition from “discarded” to “recycled”. When the recycled customer is served, it can by the FCFS assumption not be outranked by an original or recycled customer, and of course also not by a discarded one. So the recycled customer gets service until it completes, and during this service there is thus no transition from state “original” to “recycled”. We thus get the following figure:

Figure 2.3: A block scheme of all server states in a SOAP policy with the adaptation that the originals and recycled customers are served in FCFS order.

Next, we remark that when the server serves a discarded customer, then as soon as J arrives, he is immediately ready to serve J just like when he is empty. This is because J has a lower rank than the one being served by definition of “discarded”, say the currently served customer has rank r r_Jworst(0), and at that moment there are no customers with

(16)

rank ≺ r. In other words, J sees no difference between the server serving the discarded customers and really being empty. This yields the following block scheme:

Figure 2.4: A block scheme of all server states from J ’s perspective.

Let us mention and discuss properties of the queue derived from Figure 2.4. Note that these properties are about the queue when J did not arrive yet.

• It is convenient to see the server serving the recycled customers as the server being on vacation, i.e. out of its service box and thus not available to serve any customers. We call these the recycled-vacations;

• let rJ := rJ,d,xworst(0). The only arrivals now are the original customers, since we do

not count the recycled customers anymore as real customers. The originals form a Poisson(λ)-stream and have service size X₀old[rJ]. So now we have an M/G/1

queue with server vacations;

• the originals are still served in FCFS order, so the whole queue is in FCFS order before J arrives. From now on we assume that it is also in FCFS order after J arrives, because that does not affect J ’s delay due to the old customers;

• the FCFS rule between the recycled and the original customers in Figure 2.3 yield the following consequences for Figure 2.4: the server may go on vacation for a while, but only when the system is empty, and the recycled-vacation does not finish if (original) customers arrive;

• the vacation consists of serving exactly one recycled customer, as we will show now by showing that there can be no recycled arrival while the server is on vacation. By definition of a recycled customer, its arrival is a moment at which he leaves his state of being discarded. When this happens in Figure 2.3, then a server’s transition from “discarded” to “recycled” happens, and then in Figure 2.4 this is a transition from “empty” to “recycled”, that is, taking a vacation;

• if a recycled vacation corresponds to serving a customer who is recycled for the i-th time, we call it a type i vacation. A type i vacation occurs with stationary proba-bility λE(Xold

i [rJ]) = ρoldi [rJ] and takes time ∼ Xiold[rJ], where rJ := rworstJ,d,x(0);

• J ’s delay due to old customers in the queue belonging to Figure 2.2 is the same as that of Figure 2.4 (which includes the recycled-vacation). Furthermore, J ’s waiting

(17)

time in Figure 2.4 is the same as its delay due to old customers. Indeed, J has to wait for work due to recycled-vacations or originals, and by the holding FCFS rule in this queue, J does not have to wait for new customers. Combining these claims implies that J ’s waiting time in the queue from Figure 2.4 is the same as J ’s delay due to the old customers in Figure 2.2 and thus in the original SOAP system. When J enters this queue, then the FCFS rule still holds as already mentioned. One may wonder what happens when J gets service (when J ’s waiting time is done). We do not have to concern about this, because we only use this queue for waiting time calculations, so the time after J getting service is not important.

Definition 2.4.2. We call the queue belonging to Figure 2.4 the Vacation transformed queue for SOAPs, or SOAPVT.

Remark 2.4.2. Later on, a second vacation transformation will be considered, so that is why we call it a SOAPVT instead of simply a VT.

Remark 2.4.3. In the literature of queuing theory, the words ‘busy’ and ‘idle’ are often used. Maybe the recycled-vacation makes the terms ‘busy’ and ‘idle’ misleading, so to clarify: we always use the word busy for if the server is serving, and idle means that the system is empty but the server immediately starts serving as soon as a customer arrives. It depends on the context whether we count taking recycled-vacations/serving the recycled customers as being busy. If we consider this being a vacation then the server is not busy, and else if we consider this being service, then it does count as being busy.

2.5 Response time of SOAP policies

Consider the original SOAP system, so the system before any adaptations. We denote Td,x for the response time of a tagged customer J with descriptor d and size x, i.e.

the time between arriving and leaving the system. It consists of two parts, namely the waiting time T_d,xwait, which is the time between arriving and first getting service, and the residence time T_d,xres, which is the time between first getting service and finishing service. In the next section we will show that some change of J ’s rank function with respect to age can be made without affecting Td,x. Only the two parts Td,xwait and Td,xres will be

affected.

2.6 Rank-substituted tagged customer

We will give a justification of the claim that we can replace J ’s rank by its worst future rank without affecting Td,x. We call J with its adjusted rank the rank-substituted tagged

customer.

Let systems A and B be SOAP-systems where also J arrives in, where in B the only difference is that J is scheduled according to its worst future rank. We say that two systems synchronize at time t if they then contain the same customers at the same ages (including the completed customers, whose age is their age of completion). It suffices

(18)

to show that A and B synchronize at J ’s exit time, i.e. contain the same customers at same ages when J finishes in A and B respectively.

At J ’s arrival moment, system A and B synchronize. We let w0 = 0 and vn+1 = x

(that is, J ’s service size), and (vi, wi) the i-th interval of ages such that J ’s rank (with

respect to age) in A equals that of B.

We show that if systems A and B synchronize when J is served at age vi, then they

synchronize when J reaches age wi. Assume that A and B synchronize when J has

service at age vi, that is, as soon as J gets age > vi. Its rank in (vi, wi) is the same for

A and B, whence it follows that synchronization still holds at this interval.

Figure 2.5: J ’s rank imagined as a blue graph and its rank-substitution as a dashed, purple graph. These are equal on the intervals [vi, wi]. (From [2].)

Let wi−1 be the age that J just reached and suppose that systems A and B now

synchronize. We will show that when J is served at age vi, then A and B synchronize.

Let L be a customer that delays J in the meantime, by which we mean the time between reaching wi−1and getting served at age vi. Since vi is an age at which J is at its worst

future rank, it holds by the pessimism principle that L gets service until it completes or has rank rworst_J (wi−1) or rworstJ (wi−1), depending on whether L is old or new. So

if in systems A and B the number of arrivals in the meantime is the same, then they synchronize when J is served at age vi.

We denote by tA and tB the time that J gets served at age vi in system A and B

respectively. Suppose for the sake of contradiction that there are more arrivals in system A in the meantime. Since the arrival sequence is the same for both systems, this in first instance implies that tA > tB. But we can also combine it with the following. At age

wi−1, then A and B synchronize, so the old customers at wi−1 in A have the same age

as in B. In the above we applied the pessimism principle to determine when the old customers stop delaying J . From this we can conclude that the old customers delay J for the same amount of time in A and B. This also holds for the new customers, as they are arrivals and thus start at age 0, and on which the pessimism principle has been applied in the same way. Now we conclude that tA= tB.

(19)

In the sequel, by T_d,xwait and T_d,xres we mean these with respect to J after its rank-substitution.

2.7 Waiting time

In the original SOAP system, we can think of waiting time as a busy period with initial work equal to J ’s delay due to old customers. Namely, J has to wait until they are finished, but in the meantime new customers may arrive for which J also has to wait, and again new customers may arrive while J waits for these and so forth. Recall that J ’s delay due to old customers in the original SOAP system is the same as its waiting time in the SOAPVT. We will make it more formal and precise in the following. Definition 2.7.1. Let r ∈ R. The new r-work busy period, written Bnew[r], is the length of a busy period in an M/G/1 system with arrival rate λ and customer size distribution Xnew[r].

Its LS-transform satisfies e

Bnew[r](s) = eXnew[r](s + λ(1 − eBnew[r](s))).

More generally, the new r-work busy period started by work W , written B_Wnew[r], is the length of a busy period in the same M/G/1 system with a random initial amount of work W . It has transform

e

B_Wnew[r](s) = fW (s + λ(1 − eBnew[r](s))). (2.1) Letting r := rworst_J,d,x(0), then it holds that T_d,xwait = B_Wnew[r], where W is J ’s delay due to old customers. Indeed, while J arrives, in first instance it has to wait until the old customers complete or become discarded. This is exactly the delay due to the old customers. Meanwhile, new customers arrive for which J has to wait. While J is waiting, its rank r does not change, because it gets no service yet. So its delay due to K is Xnew[r]. As already mentioned, J ’s delay due to the old customers can be found by determining its waiting time in the SOAPVT.

Further notations we will use are the fractions that the server serves the new, i-recycled and old customers respectively with respect to rank r ∈ R. These fractions are:

ρnew[r] := λE[Xnew[r]] ρold_i [r] := λE[Xiold[r]]

ρold_Σ [r] :=

∞

X

i=0

ρold_i [r].

Finally, let Y_iold[r] be the equilibrium distribution, or length-biased sample, of X_iold[r]. It has transform e Y_iold[r](s) = 1 − eX old i [r](s) sE[Xiold[r]] .

(20)

2.7.1 Distributional version of Little’s law and Fuhrmann-Cooper decomposition

The derivation of eT_d,xwait(s) makes use of the distributional form of Little’s law [5]. We give a somewhat weakened version, i.e. the original theorem holds under less specific conditions.

Theorem 2.7.1. (Distributional version of Little’s law [5])

Let S be an ergodic queuing system and let S∗ be either equal to S or the subsystem of S where the customers are until their waiting time is done. Let eNS∗(·) and eT_S∗(·)

be the probability generating function of the ergodic number of customers in S∗ and the LS-transform of the time spent in S∗ respectively. Then under the regularity conditions below, the following equation holds:

e

NS∗(z) = eT_S∗(λ − λz).

Conditions:

• the arrivals into S∗ form a Poisson(λ)-stream;

• each customer enters S∗ _{and leaves S}∗ _{one at a time in order of arrival;}

• for any time t, the arrival process into S∗ _{after t and the time spent in S}∗ _{by any}

customer before t are independent.

The derivation of eT_d,xwait(s) also makes use of the Fuhrmann-Cooper decomposition [5]. For purposes later on, we want it to be valid for a lot of M/G/1/FCFS queues with va-cations, not only the SOAPVT. (Recall that this is the queue derived from Figure 2.4.) The decomposition and its assumptions are described in [5], but for ease of reference we will cover this here, taking into account that we are only interested in the M/G/1/FCFS queue with vacations and so only consider that case.

We first give some preparations. By the service box we mean the part of the system where customers stay when their waiting time is done but their residence time is not. We call the remaining part of the system the queue. So in the following theorem it is important to distinguish the word queue from system.

Theorem 2.7.2. (Fuhrmann-Cooper decomposition [5])

Under the regularity conditions below, the number of customers in the queue of an M/G/1/FCFS system with vacations is distributed as the sum of two independent random variables:

• the number in the queue given that the service box is empty;

• the number in the queue of the same M/G/1/FCFS system but without vacations, but with the same arrival rate λ and the service size equal to the residence time in the M/G/1/FCFS system with vacations.

(21)

Conditions:

• the distributional version of Little’s law holds;

• in the system with vacations, the waiting time and residence time of a customer are independent.

2.8 Main results

With the settings above, we are able to derive the LS-transform and mean of J ’s waiting time, residence time and response time in the original SOAP system after taking J ’s rank substitution. From this we get J ’s response time without the rank substitution, because that does not affect it (recall Section 2.6). However, apart from a few exceptions we will only give the results and omit the derivations. Instead, in the next chapters we will extend the settings in different ways and give a derivation corresponding to the generalized models.

For the current case, the LS-transform of J ’s waiting time with descriptor d and service size x equals e T_d,xwait(s) = 1 − ρ old Σ [r] + P∞

i=1ρoldi [r] eYiold[r](σ)

1 − ρold₀ [r] eY₀old[r](σ) , (2.2) where r = r_d,xworst(0) and σ = s + λ(1 − eBnew[r](s)).

The mean can then be determined by calculating − eT_d,xwait0(0), whence it follows that

ETd,xwait=

λP∞

i=0E[(Xiold[r])2]

2(1 − ρold₀ [r])(1 − ρnew_[r]). (2.3)

The LS-transform of J ’s residence time is

e T_d,xres(s) = exp − λ Z x 0

(1 − eBnew[r_d,xworst(a)](s))da

e−sx. (2.4)

We have to remark however that in [2] another expression is given. We claim that the factor e−sx is missing. Although this section was only meant to give results, we must now give a proof of this claim, and we will do that by giving a proof of our expression. Proof. By definition of a (limiting) SOAP policy, we can do the following. We approxi-mate J ’s rank substitution function a 7→ r(a) by the functions

rδ= x/δ

X

i=1

r(iδ)1δ·[i−1,i),

where x/δ ∈ N, and calculate what eT_d,xworst(s) would be with this rank approximation function. Then we take limδ→0Te_d,xworst(s).

(22)

Since the rank substitution function r is decreasing, then also the approximations r

are decreasing. It follows that there is no delay due to old customers. By the pessimism principle, when J has an age in δ · [i − 1, i), then its delay due to each new customer equals Xnew[r(δ(i − 1))]. Also, each new customer arrives with rate λ. Now we can see J ’s time in ages δ · [i − 1, i) as a busy period started by initial work δ, whence we get the LS-transform from (2.1) with W = δ. This equals

exp(−δ(s + λ(1 − eBnew[r(δ(i − 1))](s))).

J ’s time in all age intervals δ · [i − 1, i) : i = 1, . . . x/δ are independent, because the arrival process is Poisson. So the residence time, which is the sum of all these times, has LS-transform

x/δ

Y

i=1

exp(−δ(s + λ(1 − eBnew[r(δ(i − 1))](s))) (2.5)

= exp(−δλ

x/δ

X

i=1

(1 − eBnew[r(δ(i − 1))]e−sx). (2.6)

As δ → 0, the result follows. The mean residence time equals

E(Td,xres) =

Z x

0

1

1 − ρnew_[r(a)]da, (2.7)

where r(a) = rworst_d,x (a).

The LS-transform of J ’s response time is just eTd,x(s) = eTd,xwait(s) · eTd,xres(s), since Td,xwait

and T_d,xres are independent. This is because the arrival process is Poisson and J has a decreasing rank(substitution) function with respect to age, so its interruptions are only due to the new arrivals. Thus eT_d,xres(s) does not depend on eT_d,xwait(s).

The mean is of course just

E(Td,xwait) + E(Td,xres) =

λP∞

i=0E[(Xiold[r])2]

2(1 − ρold 0 [r])(1 − ρnew[r]) + Z x 0 1

(23)

We verified the mean by simulation for the following values, where rJ,d,x(a) denotes

J ’s rank if it has descriptor d, service size x and age a: D = {0, 1}, P(D = 0) = 0.7, P(D = 1) = 0.3, X0 = ( 0.2 with probability (w.p.) 0.25 0.4 w.p. 0.75, X1 = ( 0.4 w.p. 0.2 0.6 w.p. 0.8, rJ,0,x(a) =            1 if a < 0.1 3 if 0.1 ≤ a < 0.2 1 if 0.2 ≤ a < 0.3 2 else, rJ,1,x(a) =            4 if a < 0.1 1 if 0.1 ≤ a < 0.2 2 if 0.2 ≤ a < 0.3 3 else, λ = 0.5.

In the simulation we use small time frames. In each of them there is a small proba-bility that a customer arrives. In this way we approximate a Poisson-stream. Each time frame, the server determines which of the customers to serve by looking at their ranks. We explicitly use non-monotonic rank-functions for each of the customers, as these are the most challenging to handle when determining J ’s response time, and thus especially need verification by simulation. For the full code see

(24)

3 SOAP systems with vacations

In this chapter we will cover a generalised version of the model described in Chapter 2. There we had an original SOAP system and its derived vacation transformation. We assumed so far that the SOAP system was work-conserving. In [2] the authors write that they are optimistic that techniques similar to our Pessimism Principle and Vacation Transformation could help analyze the response times of scheduling policies in more complex M/G/1 settings, such as systems with setup times or server vacations. This motivates us to turn to cases where the server goes on vacation at certain conditions and to apply the pessimism principle and a vacation transformation again.

Specifically, in sections 3.2, 3.3, 3.4 and 3.5 we will look at the case that the server takes a vacation as soon as he gets idle. In the first three chapters we use the same tools as in Chapter 2 to give J ’s response time LS-transform and mean, and in the latter section we give a heuristic derivation without using the pessimism principle or using an adapted queue such as the vacation transformation. Hereafter, in Section 3.6, we will look at the case that the server only takes a vacation when he gets idle and before getting idle he was busy (and not back from vacation). A final case, in Section 3.7, will be that the server takes a vacation as soon as a new customer arrives who immediately outranks the currently served customer. In practice this may mean e.g. that there is a switch time, that certain adaptations are needed to get ready for the customer with higher priority, or that the server cannot break serving the currently served customer immediately. However, to keep an overview we will only cover this sort of vacations for a specific case that there are only two types of customers and where the rank does not depend on the age. Finally, to get a feel of the consequence of vacations to the response time, in Section 3.8 we will compare several policies and wonder which one yields a lower expected response time. Hereto, we will choose for policies of which the one would yield a lower response time than the other if there are no vacations. However, we will suppose that this one does have server vacations and look for which vacation distributions the response time is still lower.

3.1 Model description of a SOAPIV system: a SOAP

system with vacations

Suppose now that in a SOAP system, as soon as the server is idle he takes another sort of vacation, which takes time ∼ S. We call this the idle vacation, and let us call the resulting SOAP system the SOAPIV (SOAP with idle vacations). So customers may arrive and have to wait until the server comes back. We assume that S depends on the preceding busy periods and vacations, but does not depend on everything else. In the

(25)

next chapter we will need these assumptions explicitly. A consequence is for example that in general ES2/(2ES) is not equal to the mean of the equilibrium distribution of S. We also assume that ES < ∞.

3.2 A new vacation transformation: SOAPIVVT

The first thing in the setting of Chapter 2 we must change, is the subsection about the vacation transformation. We will make a new adapted queue, this time such that in the SOAPIV system, the delay due to the old customers together with the remaining part of the idle vacation while J is present, is the same as the waiting time in this new queue. We call this remaining part J’s delay due to the idle vacation.

We start with an adaptation of Figure 2.2. In that figure we imagined that the cus-tomers were split up in the parts original, i-recycled an discarded and we were interested in how the corresponding queue looked like when J had not been arrived yet.

In the current case, the only thing that changes is the empty state, which is now the state where the server takes an idle vacation. The empty state does not exist anymore, because as soon as the server gets idle, he takes his idle vacation. So Figure 2.2 is in this case changed as follows:

Figure 3.1: A block scheme of all server states in a SOAPIV policy before J ’s arrival moment.

In this figure we can see that there is no arrow from state “idle vacation” to “recycled”. Indeed, the first customer to serve after an idle vacation must have arrived while the server was on vacation, so just after that vacation the customer could not have received service. Therefore this customer cannot be recycled.

Again, we next make the change that the server serves the originals and recycled customers in FCFS order. At first, this again implies that J ’s delay due to the old customers is unaffected. Secondly, this has also no effect on the length of the busy periods (in the original SOAPIV system), hence the time intervals of being busy and being on idle vacation are the same. It follows that there is no effect on J ’s delay due to the idle vacation.

(26)

As in the previous chapter, one arrow can thus be removed, which yields the following figure:

Figure 3.2: A block scheme of all server states in a SOAPIV policy with the adaptation that the originals and recycled are served in FCFS order.

We are left with J ’s perspective. This time, again it holds that if the server is serving the discarded customers, then J sees this as if the server is idle. However, J does see the server being on idle vacation. So the third figure looks like this:

Figure 3.3: A block scheme of all server states in the SOAPIV case from J ’s perspective.

Let us mention and discuss properties of the queue corresponding to Figure 3.3: • we may view the state “recycled” as a state where the server is on recycled vacation.

So then it is important to be aware of the fact that there are now two sorts of vacations: the recycled vacation and the idle vacation;

• let rJ := r_J,d,xworst(0). The only arrivals now are the original customers, since we do

not count the recycled customers anymore as real customers. The originals form a Poisson(λ)-stream and have service size Xold

0 [rJ]. So now we have an M/G/1

queue with server vacations;

• the originals are served in FCFS order, so the whole queue is in that order before J arrives. We further assume that it is in FCFS also after J arrives, as this does not affect J ’s delay due to the old customers and due to the idle vacations;

(27)

• the server can only take a recycled vacation if he is idle (in J ’s perspective). This is immediately seen from the picture, as there is only one arrow to “recycled”, but it is also clear by the arguments we already used why the server cannot go to this state from the states “originals” and “idle vacation”;

• the server can only take an idle vacation if (or as soon as) he is idle. To show this, we look at the three figures separately. In Figure 3.1, the server indeed only takes his idle vacation as soon as he gets idle. In Figure 3.2 this is still the case, because the FCFS rule there does not affect that. Indeed, as long as there are original or recycled customers, they get served. If there are no such customers, then the server looks for discarded and if there are not there, he takes his idle vacation. In Figure 3.3 the state “discarded” has the other name “idle”, only for the purpose of J ’s perspective. So here the story is slightly different: as long as there are originals or recycled, they get served. If there are no such customers, then the server is idle (instead of looking for the discarded) and otherwise he takes his idle vacation; • both the recycled and the idle vacations will not finish if customers (which are

original) arrive. For the idle vacation, this is because it does not depend on arriving originals, and by the property of a Poisson-arrival that it cannot arrive exactly at the moment that the idle vacation finishes;

• the following shows that recycled-vacations consist of serving exactly one recycled customer. Similarly to the previous chapter, it holds that if a recycled customer arrives in Figure 3.2 (and 3.3), then in Figure 3.3 a server’s transition occurs from “idle” to “recycled”, which is starting a recycled vacation;

• if a recycled vacation corresponds to serving a customer who is recycled for the i-th time, we call it a type i vacation. A type i vacation occurs with stationary probability λE(Xiold[r]) = ρoldi [r] and takes time ∼ Xiold[r], where r := rJ,d,xworst(0);

• we claim that J ’s delay due to the old customers and the idle vacation together in the original SOAP system is the same as J ’s waiting time in the queue from Figure 3.3. At first, J ’s delay due to old customers and due to the idle vacation together, in the queue belonging to Figure 3.1, is the same as this delay in Figure 3.3. Second, we will show that J ’s waiting time in Figure 3.3 is the same as its delay due to old customers and the idle vacation in the same figure. Our main claim then follows by combining these two claims. The second claim is shown as follows. We have that all the delay that J experiences, happens before J gets served (thus in its waiting time). This is because in the FCFS order it holds that once J gets service, it gets service until its finish. In that delay no new customers are included, again by the FCFS rule.

(28)

Remark 3.2.1. Let r := r_J,d,xworst(0). The number of customers in the SOAPIVVT (and in SOAPVT) includes those with r(d, 0) r, in which case they have Xold

0 [r] = 0 and

hence leave the system immediately. So the arrival process is still Poisson(λ) and we do not need to scale the parameter λ.

3.3 Rest of the adapted setting

In the SOAPIV system we can still replace J ’s rank by its rank-substitution as in Sec-tion 2.6 without affecting its response time. To show this, we again let systems A and B be SOAPIVs with the exception that J has the rank-substitution in system B. The systems synchronize when J arrives. If at that moment J does not see the server on idle vacation, then the same justification as in the previous chapter applies. If J does see an idle vacation, then the two systems synchronize when the server is back, and from then on the same justification as the previous chapter applies.

The remaining of the setting we have to consider is Section 2.7. No adaptations are needed up to the equality T_d,xwait= B_Wnew[r], where W is J ’s delay due to the old customers and r := rworst_J,d,x(0). This time the equality is true for W equal to J ’s delay due to the old customers and its delay due to the idle vacation together (in the SOAPIV). Recall that this is equal to the waiting time in the SOAPIVVT.

3.4 Response time derivation

Now that we have made an adapted setting for SOAPIVs, we can start derivations for the LS-transform of J ’s waiting time, residence time and response time after its substitution, whence also the expected values follow. Recall that though the rank-substitution does not affect J ’s response time, it may affect its waiting time and residence time.

3.4.1 Stationary probabilities

We will determine the stationary probability of the server being on idle vacation, the server working on discarded customers and the server working on an i-recycled or original customer, both in the SOAPIV and in the SOAPIVVT (where in the SOAPIVVT the state “discarded” is in fact “idle”). For this, we need to add ∞ in the set of ranks R, which is defined such that r ∈ R ⇒ ∞ r.

Remark 3.4.1. For stationary probabilities in M/G/1 queues, note that the PASTA property holds. So if the fraction of time that the server is in some state equals the probability that an arbitrary arrival sees that.

In SOAPIV, the fraction of time the server is on idle vacation is 1 − ρold₀ [∞] by the following reason. We claim that ρold₀ [∞] is the fraction of time that the server is working, which is often denoted by ρ, but to avoid notation confusion we denote it like

(29)

this. There do not exist recycled customers with respect to ∞, so we can forget about them. In addition, as long as the tagged customer J has not arrived yet, there are no new customers. So the fraction of time the server is working is the fraction it serves the original customers (with respect to rank ∞). The rank ∞ also means that the customers go on getting served until they complete. We conclude that ρold₀ [∞] is indeed the fraction of time the server is working. As soon as the server gets idle, he takes an idle vacation. So if the server is not working, he is on idle vacation, the fraction of which is thus 1 − ρold₀ [∞].

The adaptations from Figure 3.1 to Figure 3.3 do not change the fraction of time the server is on idle vacation, so also in SOAPIVVT the idle vacation fraction is 1 − ρold₀ [∞].

We next show that in SOAPIV the fraction of time the server serves the discarded customers with respect to rank r is ρold₀ [∞] − ρold_Σ [r]. The first term is the fraction of the server working, so the only thing to do is to subtract the fraction it works on non-discarded customers, i.e. the recycled and the original customers. The fraction of work on originals (with respect to r) is ρold₀ [r] and the fraction of work on an i-recycled is ρold_i [r], whence our expression follows.

The adaptation from Figure 3.1 to 3.2 does not change the fraction of time serving the discarded customers. In Figure 3.3, this is the idle state. So in the SOAPIVVT, the fraction of time being idle is ρold₀ [∞] − ρold_Σ [r]. Further, it is easily seen that the fraction of time serving an original or i-recycled customer remains the same in the SOAPIVVT, namely ρold₀ [r] and ρold_i [r] respectively.

Remark 3.4.2. The fraction of time in SOAPIVVT that the server is idle, that is ρold₀ [∞] − ρold_Σ [r], is maybe paradoxically a constant. If the server has a period in which he often leaves his state “idle” by taking a vacation, and/or these vacations take a long time, then one may think that this leads to a small fraction of being idle. However, this is not the case. Instead of it, the number of discarded customers in SOAPIV increase then. So in SOAPIVVT, if the server comes back from vacation he has to catch up all these, that is, he has a longer time of being idle in the SOAPIVVT.

3.4.2 Application of the Fuhrmann-Cooper decomposition to the SOAPIVVT system

To get something to know about the waiting time of the SOAPIVVT system, the Fuhrmann-Cooper decomposition can help. The SOAPIVVT is an M/G/1/FCFS queue with server vacations, and it is easily seen that all the conditions of the Fuhrmann-Cooper decomposition apply. The only non-trival condition is that the waiting time is independent of the residence time, so we explain it now. It follows from the fact that in a SOAPIVVT, the residence time equals the service size, which is independent of the waiting time. Indeed, the FCFS rule yields that there is no interruption during a service due to any customer. There is also no interruption due to a server vacation, because those only occur when the server is or gets idle. So all conditions are satisfied.

(30)

The number of customers in the queue of the SOAPIVVT system, let us denote this by N , is thus distributed as the sum of the following two independent random variables:

• the number N_V of customers in the queue given that the service box is empty; • the number NQ of customers in the queue of the same SOAPIVVT system but

without vacations, but same arrival rate λ and the service size being the same residence time.

Since in a SOAPIVVT the service size is the same as the residence time, it follows that we can shorten the second item by just saying that NQ is the number in the system

without vacations. In the first item we rather want a condition in terms of a non-busy server, because this is useful since we know something about the stationary probability of being non-busy. The condition in the first item is the same as the condition that the server is non-busy. Indeed, if he is non-busy and the service box is not empty, then the server must be on vacation and hence the customer to be served was once interrupted by this vacation. Conversely, if the service box is empty then the server can of course not be busy. So the number of customers in the queue of a SOAPIVVT system is distributed as the sum of the following independent random variables:

• the number NV in the queue given that the server is non-busy;

• the number N_Q in the queue of the system without vacations.

Next we will derive eNQ and eNV, the probability generating functions of NQ and NV

respectively. Let r := rworst_J,d,x(0). For the derivation of eNQ, note that the SOAPIVVT

without vacations is just the M/G/1/FCFS queue with arrival rate λ and service size X₀old[r]. So eNQ is well-known, e NQ = 1 − ρold₀ [r] 1 − ρold₀ [r] eY₀old[r](λ(1 − z)). (3.1) e

NV is a bit more complicated. In the SOAPIVVT, a customer arriving to a non-busy

server observes NV as one of the following:

• with probability ρold

i [r], the server is in the middle of a type i vacation. In this

case, the number of customers in the queue is the number of Poisson arrivals at rate λ during time Y_iold[r], where Y_iold[r] is defined as the equilibrium distribution of X_iold[r] and thus has LS-transform

e Y_iold[r](s) = 1 − eX old i [r](s) sEXold i [r] .

This follows by the property that the server can only take a vacation if he is (or as soon as he gets) idle. So when the server goes on vacation, there are no customers, and after a time ∼ Y_iold[r], then J arrives and sees all the customers that came during that time.

(31)

The probability generating distribution of this number can be determined by ap-plying the distributional version of Little’s law in the SOAPIVVT (it is easily seen that all the regularity conditions apply). It is

s 7→ eY_iold[r](λ(1 − s));

• if the server is on an idle vacation, which happens with probability 1 − ρold 0 [∞],

then similarly the number of customers present is the number of Poisson arrivals at rate λ during time Seq, the equilibrium distributed random variable of S, so has probability generating function

s 7→ eSeq(λ(1 − s));

• if the server is idle (still in the SOAPIVVT), which happens with probability ρold₀ [∞] − ρold_Σ [r], then there are no customers present.

We only measure NV when a customer arrives to a non-busy server, which happens

with probability being the sum of all probabilities above, 1 − ρold₀ [r]. Now we get

e NV(s) =

1 1 − ρold₀ [r]

(1 − ρold₀ [∞]) eSeq(λ(1 − s)) + (ρold₀ [∞] − ρold_Σ [r])

+ ∞ X i=1 ρold_i [r] eY_iold[r](λ(1 − s)) . (3.2)

So the number of customers in the queue has probability generating function eNQ(s) ·

e

NV(s). Then we get the LS-transform of the waiting time in SOAPIVVT by again

applying the distributional version of Little’s law, that is, replacing s by λ(1 − s). This yields e NQ(λ(1 − s)) · eNV(λ(1 − s)) = (1 − ρ old 0 [∞]) eSeq(s) + (ρold0 [∞] − ρoldΣ [r]) + P∞

i=1ρoldi [r] eYiold[r](s)

1 − ρold₀ [r] eY₀old[r](s) . (3.3)

3.4.3 Final derivation

Lemma 3.4.1. Under any SOAPIV policy, the LS-transform of waiting time T_d,xwait for a rank-substituted tagged customer with descriptor d and service size x is

e

T_d,xwait(s) = 1

1 − ρold₀ [r] eY₀old[r](σ)

(1 − ρold₀ [∞]) eSeq(σ) + (ρold₀ [∞] − ρold_Σ [r])

+

∞

X

i=1

ρold_i [r] eY_iold[r](σ),

(32)

Proof. Call the rank-substituted tagged customer J . Recall that we have T_d,xwait = B_Wnew[r], where W is J ’s delay due to old customers and the idle vacation. This means that eTwait

d,x (s) = eBWnew[r] = fW (σ), and we will compute fW (σ).

The waiting time of J in the SOAPIVVT has the same distribution as W , so we are left with determining the LS-transform of this waiting time, which is (3.3). So fW (σ) follows.

The LS-transform eT_d,xresremains the same as in the unadapted setting (i.e. SOAP sys-tems without vacations), because the rank-substituted tagged customer can only be interrupted by new customers, who arrive in a Poisson(λ)-stream.

We still have that eT_d,xwait and eT_d,xres are independent, by using the same argument as in the unadapted setting. So it holds that

e

Td,x(s) = eTd,xwait(s) · eTd,xres(s)

= 1

1 − ρold₀ [r] eY₀old[r](σ)

(1 − ρold₀ [∞]) eSeq(σ) + (ρold₀ [∞] − ρold_Σ [r])

+ ∞ X i=1 ρold_i [r] eY_iold[r](σ) · exp− λ Z x 0

(1 − ˜Bnew[rworst_d,x (a)](s))da

e−sx, (3.4)

with the notation as in (2.4) and Lemma 3.4.1.

Since ETd,x is just the sum ETd,xwait+ ETd,xres, the mean of the response time Td,x can be

derived by taking ETd,xwait= − eTwait

0

d,x (0) and ETd,xres= − eTres

0 d,x(0). It is E(Td,x) = λP∞ i=0EXiold[r]2 2(1 − ρold 0 [r])(1 − ρnew[r]) + (1 − ρ old 0 [∞]) (1 − ρold 0 [r])(1 − ρnew[r]) · ESeq + Z x 0 1 1 − ρnew_[r(a)]da (3.5)

We verified (3.5) for S ∼ exp(1) and the values used in the simulation for SOAPs. In

https://github.com/RoccovVr/masterthesis/blob/master/ wachtrij vakantie.py

we assume i.i.d. vacations. In this case it holds that ESeq= ES2/(2ES). In

https://github.com/RoccovVr/masterthesis/blob/master /wachtrij vakantie afh.py

we still assume that S ∼ exp(1) but all vacations have the same duration. In this case we thus have ESeq= ES/2. This is to express dependence.

(33)

3.5 Alternative derivation for the SOAPIV waiting time

In the conclusion of [2] the authors write that they are optimistic that techniques similar to the pessimism principle and vacation transformation could help analyse the response times of scheduling policies in more complex M/G/1 settings, such as systems with setup times or server vacations. Indeed, we used these techniques and got new formulas.

For the case that the server vacations are independent, we will now show another derivation of eT_d,xwait(s) for the rank substituted customer J . We will approximate the SOAPIV by viewing the idle vacation as extra customers in the original SOAP. Let −∞ and ∞ be added ranks such that ∞ r −∞ ∀r ∈ R. Since the workload ρold₀ [∞] must be < 1, it is unavoidable that the server will have a fraction of being idle, which thus does not yield a SOAPIV. However, we will let ρold₀ [∞] be a value close to 1 by taking the arrival rate for the extra customers as high as possible, and then argue that in the limit we do get a SOAPIV. Then for the SOAPs we can evaluate new values in the existing formula for eTd,x(s) and ETd,x.

Let a SOAPIV and all the used notation be given (λ for the arrival rate, ρold

0 for the

workload etc.) Consider the corresponding SOAP by removing the idle vacation, i.e. by assuming that if the server gets idle, then he does not take a vacation (thus the system is now work-conserving). Instead of the idle vacation of size S, suppose now that next to the normal customers we add an extra Poisson-stream of rate λextra consisting of extra

customers with service size S and rank

r(d, a) = (

∞ if a = 0 −∞ if a > 0.

So this means that the server will only start serving the extra customers if there are no others, and once an extra customer is in service, he gets his service without interruptions. The newly formed SOAP, which we call the SOAP with Extra Customers or SOAPEC, now almost has the property of SOAPIV, with the exception that the server may stop taking a new idle vacation once he just finished one. However, the larger λextra, the less

probability that this happens.

Let us look which values change in the formula (2.2) for eT_d,xwait, given that J is not an extra customer. We write x ← y for if the value x is replaced by y. Note that the extra customers are discarded when they have age 0, and when they get served they are 1-recycled. So they are never originals nor i-recycled customers for i > 1 and thus for i ∈ N0\ {1} it holds that

ρold_i [r] ← ρold_i [r] and eY_iold[r] ← eY_iold[r].

Further, the workload for the 1-recycled is now added by the workload for the extra customers, so

(34)

Next we show that σ ← σ. Of course we have λ ← λ + λextra. Further, in this case,

Bnew[r] becomes a busy period B with arrival rate λ + λextra and service size

(

0 if it is an extra customer Xnew[r] if it is a normal customer.

To explain the “0”, an extra customer can never entry the service box if someone is served.

Without affecting B, this can also be seen as a busy period with starting amount of work as in the display, arrival rate λ and next service sizes Xnew[r]. So with the probability λextra/(λ + λextra) that a new customer is extra, the starting amount of work

is 0 and thus B is also 0, and with the probability that a new customer is normal, B is just Bnew[r]. Hence we get

e Bnew[r] ← λ λ + λextra e Bnew[r] + λextra λ + λextra .

We can now make a newly formed σ by evaluating the display above and λ ← λ + λextra,

and this turns out to be the same σ as before.

We have determined which values in formula (2.2) change, and by evaluating them we are close to the formula in Lemma 3.4.1 if 1 − ρ is small, where ρ is the total workload in the SOAPEC. The remainder only has to do with taking the limit as ρ → 1, where this is only due to increasing λextra. Let us call the random variable corresponding to

the LS-transform we get by evaluating our new values, T_d,x,ρwait. If the service size and descriptor are evident, we can also call it T_ρwait. First we will give a heuristic for the following lemma.

Lemma 3.5.1. T_d,x,ρwait converges in distribution to T_d,xwait in Lemma 3.4.1, as ρ → 1. To do that, for the SOAPEC we split the whole time that the system exists in periods P . We let this period start at the moment that the server begins to be in a period that he is idle or serves the extra customers, and end it at the next moment that this happens. So the whole time that the server exists, is a partition of these periods. We denote P = Pf ull if P is a period in which the server does not have any moment of being

idle, and P = Pidle if there does exist such a moment.

For SOAPIV we talk about a period P to mention a period from a moment that the server starts and idle vacation to the next such moment.

Our heuristic is as follows. Let J arrive at period P . If P = Pf ull, then J sees no

difference between the SOAPIV and the SOAPEC. To check this, let us compare the properties at an arbitrary period P of SOAPIV and a period Pf ull of SOAPEC (from

J ’s perspective). To start with SOAPIV:

• at the start of P , the server is on idle vacation and there are no customers in the system;