Multiple Server SRPT with speed scaling is competitive

TL;DR

This paper demonstrates that multi-server SRPT with speed scaling can achieve a constant competitive ratio for flow time plus energy, depending only on power functions, not on job or server count.

Contribution

It proves multi-server SRPT with speed scaling is constant competitive, unlike in the no-speed-scaling case, and identifies optimal routing strategies under various conditions.

Findings

Multi-server SRPT with speed scaling is constant competitive.

Round-robin routing is optimal for unit job sizes.

Greedy dispatch policies lack constant competitiveness.

Abstract

Can the popular shortest remaining processing time (SRPT) algorithm achieve a constant competitive ratio on multiple servers when server speeds are adjustable (speed scaling) with respect to the flow time plus energy consumption metric? This question has remained open for a while, where a negative result in the absence of speed scaling is well known. The main result of this paper is to show that multi-server SRPT can be constant competitive, with a competitive ratio that only depends on the power-usage function of the servers, but not on the number of jobs/servers or the job sizes (unlike when speed scaling is not allowed). When all job sizes are unity, we show that round-robin routing is optimal and can achieve the same competitive ratio as the best known algorithm for the single server problem. Finally, we show that a class of greedy dispatch policies, including policies that route to the least loaded or the shortest queue, do not admit a constant competitive ratio. When job arrivals are stochastic, with Poisson arrivals and i.i.d. job sizes, we show that random routing and a simple gated-static speed scaling algorithm achieves a constant competitive ratio.

Equations

$$c=P(2-1/m)\left(2+\frac{2}{P^{-1}(1)}\max (1,P(\bar{s}))\right),$$

$$C=\int n(t)dt+\int \sum _{k=1}^{m}P(s_k(t))dt.$$

$${\mathsf{c}}_A(\sigma )=\underset{\sigma }{\max }\frac{C_A(\sigma )}{C_{\mathsf{OPT}}(\sigma )},$$

$${\mathsf{c}}^{\star }=\underset{A}{\min }{\mathsf{c}}_A(\sigma ).$$

$${\mathsf{c}}_A=\frac{\mathbb{E}\left[C_A\right]}{\mathbb{E}\left[C_{\mathsf{OPT}}\right]},$$

$$s_k(t)=\{\begin{array}{ll}& P^{-1}\left(\frac{n(t)}{m}\right)\text{if}n(t)\ge m,\\ & P^{-1}(1),\text{otherwise}.\end{array}$$

$$c=P(2-1/m)\left(2+\frac{2}{P^{-1}(1)}\max (1,P(\bar{s}))\right).$$

$$d(t,q)=\max \left\{0,\frac{n(t,q)-n_o(t,q)}{m}\right\}.$$

$$\Phi (t)={\Phi }_1(t)+{\Phi }_2(t),$$

$${\Phi }_1(t)=c_1{\int }_0^{\infty }f\left(d(t,q)\right)dq,$$

$$f(\frac{i}{m})=f(\frac{i-1}{m})+\Delta (\frac{i}{m}),$$

$${\Phi }_2(t)=c_2{\int }_0^{\infty }(n(t,q)-n_o(t,q))dq,$$

$$n(t)+\sum_{k\in A(t)}P(s_{k}(t))+\frac{d\Phi(t)}{dt}\leq c\biggl{(}n_{o}(t)+\sum_{k\in O(t)}P({\tilde{s}}_{k}(t))\biggr{)}$$

$$\displaystyle\int\biggl{(}n(t)$$

$$\displaystyle\leq\int c\biggl{(}n_{o}(t)+\sum_{k\in O(t)}P({\tilde{s}}_{k}(t))\biggr{)}dt,$$

$$c=3+\frac{2}{2-\alpha }.$$

$$d{\Phi }_1/dt\le$$

$$d{\Phi }_1/dt$$

$$+c_2\sum _{k\in O}\max \{P(\bar{s}),P({\tilde{s}}_k)\}$$

$$\stackrel{(a)}{\le }$$

$$-c_{2}m{P}^{-1}(1)+c_2\sum _{k\in O}\max \{P(\bar{s}),P({\tilde{s}}_k)\}$$

$$\le$$

$$+\left[c_1\left(\frac{m-1}{2}\right)-c_{2}m{P}^{-1}(1)\right]$$

$$\stackrel{(b)}{\le }$$

$$\stackrel{(a)}{\le }$$

$$+c_2\sum _{k\in O}\max \{P(\bar{s}),P({\tilde{s}}_k)\}$$

$$\le$$

$$\stackrel{(b)}{\le }$$

$$c=c_1+c_2\max (1,P(\bar{s}))=\left(2+\frac{2}{P^{-1}(1)}\max (1,P(\bar{s}))\right).$$

$$s_j\delta +s_i\left(\frac{1}{s_j}-\delta \right)=r.$$

$$c(m-1)w+c\sum _{k=1}^w{k}^{1-1/\alpha }\ge c(m-1)w+c^{\prime }{w}^{2-1/\alpha },$$

$$c\sum _{k=1}^{w/m}{k}^{1-1/\alpha }+c(m-1)\left[w+\sum _{k=2}^{w/m+1}{k}^{1-1/\alpha }\right]$$

$$\le c^{\prime \prime }m{\left(\frac{w}{m}\right)}^{2-1/\alpha }+cmw$$

$$C=\mathbb{E}\left[T\right]+\mathbb{E}\left[E\right],$$

$$\lambda C$$

Full text

I Introduction

How to route and schedule jobs are two of the fundamental problems in multi-processor/multi-server settings, e.g. microprocessors with multiple cores. Microprocessors also have the flexibility of variable speed of operation, called speed scaling, where to operate at speed $s$, the power utilization is $P(s);$ typically, $P(s)=s^{\alpha}$, with $2\leq\alpha\leq 3$. Speed scaling is also available in modern queuing systems where servers can operate at variable service rates with an appropriate cost function $P(.)$.

Increasing the speed of the server reduces the response times (completion minus arrival time) but incurs a larger energy cost. Thus, there is a natural tradeoff between the the flow time (defined as the sum of the response times across all jobs) and the total energy cost, and a natural objective is to minimize a linear combination of the flow time and total energy, called flow time plus energy.

In this paper, we consider the online problem of routing, scheduling, and speed scaling in a multi-server setting to minimize the flow time plus energy, where jobs arrive (are released) over time and decisions have to be made causally. On the arrival of a new job, a centralized controller needs to make a causal decision about which jobs to process on which server and at what speed, where preemption and migration is allowed. By migration, we mean that a job can be preempted on one server and restarted on another server later. The model, however, does not allow job splitting, i.e., a job can only be processed on a single server at any time.

For this problem, both the stochastic and worst case analysis is of interest. In the stochastic model, the input (job sizes and arrival instants) is assumed to follow a distribution, and performance guarantees in expectation are derived. In the worst case analysis, the input can be generated by an adversary, and the performance metric is the competitive ratio, that is defined as the maximum of the ratio of the cost of the online algorithm and the optimal offline algorithm (that knows the entire input sequence ahead of time).

I-A Prior Work

I-A1 Single Server

For a single server, it is known that Shortest Remaining Processing Time (SRPT) is an optimal scheduling policy, and the only decision with speed scaling is the optimal dynamic speed choice. There is a large body of work on speed scaling in the single server setting [1, 2, 3, 4, 5, 6, 7, 8] both in the stochastic as well as worst case settings, where mostly $P(s)=s^{\alpha}$ is used, under various assumptions, e.g. bounded speed $s\in[0,S]$ [9], with and without deadlines [10, 11, 12], etc.

In the stochastic model, [6] showed that a simple fixed speed policy (called gated static) that depends only on the load/utilization and is independent of the current number of unfinished jobs/sizes has a constant multiplicative gap from the ‘unknown’ optimal policy. Further work in this direction can be found in [13, 14], where [14] derived the mean response time under the SRPT algorithm. For the worst case, there are many results [1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 15, 8]. A key result in this space was proved in [15], where an SRPT-based speed scaling algorithm is proved to be $(3+\epsilon)$-competitive algorithm for an arbitrary power function $P(\cdot)$. In [8], using essentially the same ideas as in [15], but with a more careful analysis, a slightly modified SRPT-based speed-scaling algorithm is shown to be $(2+\epsilon)$-competitive algorithm, also for an arbitrary power function.

In the worst case setting, when considering speed scaling, two classes of problems are studied: (i) unweighted and (ii) weighted, where in (i) the delay that each job experiences is given equal weight in the flow time computation, while in (ii) it is scaled by a weight that can be arbitrary. The weighted setting is fundamentally harder that the unweighted one, and it is known that constant-competitive online algorithms are not possible [16] in the weighted setting, even for a single server, while constant competitive algorithms are known for the unweighted case, even for arbitrary energy functions, e.g., the $(2+\epsilon)$-competitive algorithm proposed in [8]. To circumvent the negative result for the weighted case, typically, the online algorithm is allowed a speed augmentation of $1+\delta$ compared to the optimal offline algorithm, in which case algorithms with $O(1)$ competitive ratios are possible, where $O(1)$ depends on $\delta$.

I-A2 Multiple Servers

With multiple servers without speed scaling (when the server speeds are fixed), to minimize just the flow time, a well known negative result from [17] states that the SRPT algorithm (which always processes the $m$ smallest jobs with $m$ servers) that requires both preemption and job migration has a competitive ratio that grows as the logarithm of the ratio of the largest and the smallest job size and the logarithm of the ratio of the number of jobs and the number of servers. Moreover, [17] also showed that no online algorithm can do better than SRPT when server speeds are fixed.

With multiple servers, one critical aspect is whether job migration is allowed or not. With job migration, a preempted job can be processed by any of the servers and not necessarily by the server where it was partially processed first. Remarkably in [18], a non-migratory algorithm that only requires preemption is proposed that achieves the same competitive ratio as SRPT. A more positive result for SRPT is that if it is allowed a speed augmentation of $(2-1/m)$ (respectively, $(1+\delta)$) over the offline optimal algorithm, then it has a constant competitive ratio of $1$ (respectively, a constant constant depending on $\delta$); see [19, 20].

The problem to minimize flow time and energy with speed scaling in the presence of multiple servers has been studied in [21, 22, 23, 24, 25, 26] under the worst case scenario. The homogenous server case was studied in [24, 22, 26], i.e., $P(.)$ is identical for all servers, while the heterogenous case was addressed in [23, 25], where $P(.)$ is allowed to be different for different servers.

For the unweighted flow time and energy problem under the homogenous server case, a variant of the round robin algorithm without migration has been shown to have a competitive ratio of $O(1)$ [21] with $(1+\delta)$ augmentation with bounded server speeds. This result was extended in [22] for the weighted flow time plus energy using a randomized server selection algorithm that also does not use migration.

For the heterogenous server setting with $(1+\delta)$ augmentation, [23, 25], derived algorithms that assigns job to server that cause least increase in the projected future weighted flow and a variant of processor sharing, respectively, that are $O(1)$ competitive in unweighted and weighted flow time plus energy. Moreover, if for server $k$, $P_{k}(s)=s^{\alpha_{k}}$, then the algorithm in [23, 26] has a competitive ratio dependent on $\alpha$ without any need for speed augmentation.

In the stochastic setting, for multiple servers, the flow time plus energy problem with multiple servers is studied under a fluid model [27, 28] or modelled as a Markov decision process [29], and near optimal policies are derived.

Our focus in this work is on the unweighted flow time plus energy under the homogenous server setting, where in the context of the prior work we want to answer the following open questions: (i) under the worst case setting, is it possible to achieve a constant competitive ratio with algorithms simpler than the ones proposed [23, 25], that require resource augmentation, or [26] that is computationally expensive. In particular, can SRPT do so, since it is a widely used and simple to implement algorithm? This question is also directly related to the limitation of SRPT without speed scaling as shown in [17], and whether SRPT with and without speed scaling are fundamentally different. (ii) For the stochastic setting, can simple algorithms achieve near optimal performance without the need of fluid limit approximations?

I-B Our Contributions

Let the number of (homogenous) servers be $m.$

• •

The SRPT algorithm, with speed chosen as $P^{-1}\left(\frac{n}{m}\right)$ if $n\geq m$ and $P^{-1}(1)$ if $n<m$, where $n$ is the number of unfinished jobs, is shown to be $c$-competitive, where

[TABLE]

where $\bar{s}$ is a constant associated with the function $P(\cdot).$ This means the above algorithm is constant-competitive, with a competitive ratio that is independent of the number of servers as well as the workload sequence.111While $m$ does appear in the expression for the competitive ratio, note that $2-1/m$ is trivially upper bounded by 2. This result is proved under mild regularity assumptions on the power function $P(\cdot),$ which can be further relaxed using standard arguments [15]. For the special case $P(s)=s^{\alpha},$ where $\alpha\in(1,2)$ , we derive another bound of $3+\frac{2}{2-\alpha}$ on the competitive ratio; this bound is tighter than the previous one for $\alpha$ smaller than $2.$ Similar to the algorithm proposed in [23, 26], the competitive ratio of the our SRPT-based policy also depends on $\alpha$. However, the algorithm proposed here is much simpler, and comes with a lower implementation complexity.

• •

An important conclusion to draw from this result is that SRPT with speed scaling is fundamentally different as compared to the case when speed scaling is not allowed; in the latter setting, the competitive ratio depends on the number of jobs and their sizes [17]. Thus, allowing for speed scaling, the ever popular SRPT is shown to be robust in the multiple server setting.

• •

With speed scaling, we also derive some lower bounds for the immediate dispatch case when the job has to be assigned to a server instantaneously on its arrival and cannot be migrated across servers, though preemption within a server is allowed. Under this setting, we show that greedy routing policies, that assign a new job to the currently least loaded server or to the historically least loaded server have a competitive ratio of at least $\Omega(m^{1-1/\alpha})$ no matter how the speed is chosen. Moreover, even when immediate dispatch is not necessary (i.e., jobs can wait in a common queue), but job migration across servers is not allowed, we show that the competitive ratio of SRPT is at least $\Omega(m^{1-1/\alpha})$.

• •

For the special case where all jobs have unit size, we show that round robin (RR) routing is optimal, and the best known competitive ratio results on speed scaling to minimize the flow-time plus energy in the single server setting apply in the multiple server setting as well.

• •

We also consider the stochastic setting, where jobs arrive according to a Poisson process with i.i.d. sizes. This case turns out to be significantly easier than the worst case; we show that with $P(s)=s^{\alpha}$ ($\alpha>1$), random routing and a simple gated-static speed scaling algorithm achieves a constant competitive ratio, e.g., $2$ for $P(s)=s^{2}.$

II System Model

Let the input consist of $J$ jobs, where job $j$ arrives (is released) at time $a_{j}$ and has work/size $w_{j}$. There are $m$ homogenous servers, each with the same power function $P(s),$ where $P(s)$ denotes the power consumed while running at speed $s$. Any job can be processed by any of the $m$ servers.

The speed $s$ is the rate at which work is executed by any of the server, and $w$ amount of work is completed in time $w/s$ by any server if run at speed $s$ throughout time $w/s$. A job $j$ is defined to be complete at time $c_{j}$ if $w_{j}$ amount of work has been completed for it, possibly by different servers. We assume that preemption is allowed, i.e., a job can be suspended and later restarted from the point at which it was suspended. Moreover, we also assume that job migration is allowed, i.e., if a job is preempted it can be processed later at a different server than the one from which it was preempted. Thus, a job can be processed by different servers at different intervals, but at any given time it can be processed by only server, i.e., no job splitting is allowed. The flow time $f_{j}$ for job $j$ is $f_{j}=c_{j}-a_{j}$ (completion time minus the arrival time) and the overall flow time is $F=\sum_{j}f_{j}$. From here on we refer to $F$ as just the flow time. Note that $F=\int n(t)dt$, where $n(t)$ is the number of unfinished jobs at time $t$. Thus, flow time can also be interpreted as the cumulative holding cost, where instantaneous holding cost at time $t$ equals $n(t).$

Let server $k$ run at speed $s_{k}(t)$ at time $t$. The energy cost is defined as $\sum_{k=1}^{m}P(s_{k}(t))$ summed over the flow time. Choosing larger speeds reduces the flow time, however, increases the energy cost, and the natural objective function that has been considered extensively in the literature is the sum of flow time and energy cost (see, for example, [4, 8, 22, 24]), which we define as222It is also natural to take the objective to be a linear combination of flow time and energy, i.e., $\int n(t)dt+\beta\int\sum_{k=1}^{m}P(s_{k}(t))dt,$ where $\beta>0$ weighs the energy cost relative to the delay cost. However, note that since the factor $\beta$ may be absorbed into the power function, we will work with the objective (1) without loss of generality.

[TABLE]

Any online algorithm only has causal information, i.e., it becomes aware of job $j$ only at time $a_{j}$. Any online algorithm with multiple servers has to make two causal decisions: routing; that specifies the assignment of jobs to servers, and scheduling; that specifies a job to be processed by each server and at what speed at each time. Let the cost (1) of an online algorithm $A$ be $C_{A}$. Moreover, let the cost of (1) for an offline optimal algorithm that knows the job arrival sequence $\sigma$ (both $a_{j}$ and $w_{j}$) in advance be $C_{\mathsf{OPT}}$. Then the competitive ratio of the online algorithm $A$ for $\sigma$ is defined as

[TABLE]

and the objective function considered in this paper is to find an online algorithm that minimizes the worst case competitive ratio

[TABLE]

We will also consider stochastic input $\sigma$ where both $a_{j}$ and $w_{j}$ are chosen stochastically, in which case our definition for competitive ratio for $A$ will be

[TABLE]

where the expectation is with respect to the stochastic input; see Section V for the details. Correspondingly, the goal is to come up with an online algorithm that minimizes ${\mathsf{c}}_{A}.$

In Sections III to IV, we study the worst-case setting, and present the results for the stochastic setting in Section V.

III Worst Case Competitive Ratio: Upper Bounds

In this section, we present our results on constant competitive policies for scheduling and speed scaling in a multi-server environment. We propose an online policy that performs SRPT scheduling, where the instantaneous speed of each server is a function of the number of outstanding jobs in the system. We prove that this policy is constant competitive for a broad class of power functions. Specifically, our upper bounds on the competitive ratio depend only on the power function, but not on the number of jobs, their sizes, or the number of servers.

III-A SRPT Algorithm

In this section, we consider the SRPT algorithm for scheduling and routing, and analyze its competitive ratio when the server speeds are chosen as follows. Let $n(t)$ and $n_{o}(t)$ denote the number of unfinished jobs with the SRPT algorithm and $\mathsf{OPT}$ (the offline optimal algorithm) respectively, at time $t.$ Moreover, let $A(t)$ and $O(t)$ be the set of active jobs with the SRPT algorithm and $\mathsf{OPT},$ respectively. Recall that the SRPT algorithm maintains a single queue and serves the $\min\{m,n(t)\}$ shortest jobs at any time $t.$

The speed for job $k\in A(t)$ with the SRPT algorithm is chosen as

[TABLE]

Idle servers, i.e., servers not processing any job, are run at speed 0. The above speed scaling rule can be interpreted as follows. Under (5), $\sum_{k\in A(t)}P(s_{k}(t))=n(t),$ i.e., the instantaneous power consumption is matched to the instantaneous job holding cost. This type of energy-proportional speed scaling has be shown to be near-optimal in the single server setting [8], where the basic motivation for this choice of speed is local optimality—it is the optimal speed choice at time $t$ assuming no future job arrivals after time $t$.

Our main result (Theorem 1) is proved under the following assumptions on the power function.

Assumption 1**.**

$P:\mathbb{R}_{+}\rightarrow\mathbb{R}_{+}$* with $P(0)=0$ is differentiable, strictly increasing, and strictly convex function, which implies $\lim_{s\rightarrow\infty}P(s)=\infty,$ and $\bar{s}:=\inf\{s>0\ |\ P(s)>s\}<\infty$.*

Assumption 2**.**

For $x,y>0,$ $P(xy)\leq P(x)P(y).$

Assumptions 1 and 2 are satisfied by power functions of the form $P(s)=cs^{\alpha},$ where $\alpha>1$ and $c\geq 1.$333Our main result (see Theorem 1) can also be proved under the following assumption, that is weaker than Assumption 2: There exists $\gamma\geq 1$ such that $P(xy)\leq\gamma P(x)P(y)$ for all $x,y>0.$ In this case, the upper bound on the competitive ratio would depend on $\gamma.$ We are now ready to state our main result, which shows that our SRPT algorithm is constant competitive.

Theorem 1**.**

Under Assumptions 1 and 2, the SRPT algorithm with speed scaling (5) is $c$-competitive, where

[TABLE]

Taking $P(s)=s^{\alpha}$ for $\alpha>1,$ the competitive ratio equals $4(2-1/m)^{\alpha}.$ To prove Theorem 1, we use a potential function argument, where the potential function is defined as follows. Let $n_{o}(t,q)$ and $n(t,q)$ denote the number of unfinished jobs under $\mathsf{OPT}$ and the algorithm, respectively, with remaining size at least $q$. In particular, $n_{o}(t,0)=n_{o}(t)$ and $n(t,0)=n(t)$. Let

[TABLE]

We consider the potential function

[TABLE]

where $\Phi_{1}(\cdot)$ and $\Phi_{2}(\cdot)$ are defined as follows.

[TABLE]

where $c_{1}$ is a positive constant whose value will be specified later. The function $f:\{i/m:\ i\in\mathbb{Z}_{+}\}\rightarrow\mathbb{R}_{+}$ is defined as follows: $f(0)=0,$ and for $i\geq 1,$

[TABLE]

where $\Delta(x):=P^{\prime}(P^{-1}(x)).$

[TABLE]

where $c_{2}$ is another positive constant whose value will be specified later.

The $\Phi_{1}(t)$ part of the potential function is a multi-server generalization of the potential function in [15], while the $\Phi_{2}(t)$ part is novel. Specifically, $\Phi_{2}(t)$ ensures that the potential function has the requisite ‘drift’ (see the condition (7) below) at times when the algorithm has fewer than $m$ servers active.

Let the speed of job $k\in O(t)$ under $\mathsf{OPT}$ at time $t$ be ${\tilde{s}}_{k}(t)$. Suppose we can show that for any input sequence $\sigma,$

[TABLE]

almost everywhere (in $t,$ with respect to the Lebesgue measure), where $c>0$ does not depend of $\sigma,$ and that $\Phi(t)$ satisfies the following boundary conditions (proved in Proposition 5; see Appendix A):

Before any job arrives and after all jobs are finished, $\Phi(t)=0$, and 2. 2.

$\Phi(t)$ does not have a positive jump discontinuity at any point of non-differentiability.

Then, integrating (7) with respect to $t$, we get that

[TABLE]

which is equivalent to showing that $C_{SRPT}(\sigma)\leq c\ C_{\mathsf{OPT}}(\sigma)$ for any input $\sigma$ as required.

The intuition for the form of the competitive ratio in Theorem 1 is as follows.

Definition 1** (Speed Augmentation).**

Consider the problem of minimizing flow time $m$ servers that have fixed speed. With speed augmentation, an online algorithm is allowed to use $m$ servers with fixed speed $\beta>1$, while the $\mathsf{OPT}$ is restricted to use $m$ servers with fixed speed $1$.

The following result summarizes the power of speed augmentation with the SRPT algorithm for minimizing the flow time

Lemma 1**.**

[19]** For flow time minimization problem with $m$ servers with fixed speed, the flow time of SRPT algorithm with speed augmentation of $\beta=(2-1/m)$ is at most the flow time of the $\mathsf{OPT}$ with $m$ speed-$1$ servers.

Remark 1**.**

In this paper, we do not consider speed augmentation, but speed scaling, where both the online algorithm and the $\mathsf{OPT}$ have access to identical servers, but whose speeds can be varied with an associated energy cost. In Lemma 2, we show how we can use the speed augmentation result (Lemma 1) for analyzing the speed scaling problem.

Definition 2**.**

Consider an SRPT-restricted optimal offline algorithm for minimizing the flow time plus energy with variable speed servers (1), that we call $\mathsf{OPT}$-$SRPT$ ($OS$). $OS$ has non-causal knowledge of the complete job arrival sequence $\sigma$, but is required to follow the SRPT discipline at each time $t$, i.e., schedule the $m$ jobs with the shortest remaining sizes. Given the SRPT restriction, $OS$ can choose speeds at each time that minimizes the flow time plus energy (1) knowing the future job arrival sequence.

Note that we neither know the optimal speed choice of the $\mathsf{OPT}$ nor of the $OS$ algorithm.

Lemma 2**.**

Algorithm $OS$ is $P(2-1/m)$-competitive with respect to $\mathsf{OPT}$ for minimizing (1).

Proof.

Let the speed at time $t$ chosen by $\mathsf{OPT}$ be $s_{\mathsf{OPT}}(t)$. The claim follows from Lemma 1, since $OS$ can choose speed $(2-1/m)s_{\mathsf{OPT}}(t)$ at time $t$, and get exactly the same flow-time as the $\mathsf{OPT}$. Increasing speed for $OS$ only results in an extra multiplicative energy cost of $P(2-1/m)$ over $\mathsf{OPT}$. Thus, the flow time plus energy cost of $OS$ is at most $P(2-1/m)$ times the flow time plus energy cost of the $\mathsf{OPT}$. ∎

For proving Theorem 1, we will show that the SRPT algorithm with speed scaling (5) is $c$ competitive with respect to $OS$ for some $c$, which implies that the SRPT algorithm with speed scaling (5) is $cP(2-1/m)$ competitive with respect to $\mathsf{OPT}$ itself.

For smaller values of $\alpha,$ the result of Theorem 1 can be further improved for the special case of power-law power functions, as described in the next theorem.

Theorem 2**.**

With $P(s)=s^{\alpha}$ and for any $\alpha\in(1,2)$, the SRPT-based algorithm with speed scaling (5) is $c$-competitive, where

[TABLE]

The proof of Theorem 2 is similar in spirit to that of Theorem 1, but without assuming that $\mathsf{OPT}$ follows SRPT. It also uses the same potential function $\Phi$ (see (6)), and directly tries to bound the increase in $\Phi$ because of processing of the jobs by the algorithm and $\mathsf{OPT}$. The limitation on $\alpha$ appears because without enforcing that $\mathsf{OPT}$ follows SRPT, we cannot apply a technical lemma (Lemma 9) jointly on the change made to $\Phi$ by the algorithm and the $\mathsf{OPT}$, but individually. While the competitive ratio stated in Theorem 2 grows unboundedly as $\alpha\uparrow 2$, it is less than the competitive ratio established in Theorem 1 when $\alpha$ is close to 1. This is because our argument for Theorem 2 does not enforce $\mathsf{OPT}$ to follow SRPT, thereby saving on the penalty of $(2-1/m)^{\alpha}.$ The proof of Theorem 2 is provided in Appendix C, while the remainder of this section is devoted to the proof of Theorem 1.

Proof of Theorem 1.

To prove the theorem we will show that the SRPT algorithm with speed scaling (5) is $c$-competitive with respect to the $OS$ algorithm (Definition 2), which together with Lemma 2 implies that the SRPT algorithm with speed scaling (5) is $cP(2-1/m)$ competitive with respect to $\mathsf{OPT}$. For the rest of the proof, subscript $o$ refers to quantities for $OS$ algorithm.

In the following, we show that (7) is true for a suitable choice of $c.$ To show (7), we bound $d\Phi/dt$ via individually bounding $d\Phi_{1}/dt$ and $d\Phi_{2}/dt$ in Lemmas 3 and 4 below. Note that it suffices to show that (7) holds at any instant $t$ which is not an arrival or departure instant under the algorithm or $OS$. For the remainder of this proof, consider any such time instant $t.$ For ease of exposition, we drop the index $t$ from $n(t,q),n(t,q_{o}),n(t),n_{o}(t),s_{k}(t)$ and ${\tilde{s}}_{k}(t),$ since only a fixed (though generic) time instant $t$ is under consideration.

Lemma 3**.**

For $n\geq m$,

[TABLE]

while for $n<m,$

[TABLE]

Lemma 4**.**

$d\Phi_{2}/dt\leq-c_{2}\min(m,n)P^{-1}(1)$**

[TABLE]

Remark 2**.**

*The basic idea behind the expressions derived in Lemmas 3 and 4 is to upper bound the drift or the derivative of potential function (which counts the difference of work remaining with the proposed algorithm and the $OS$ algorithm). Both the proposed algorithm and the $OS$ algorithm are working on their respective $m$ shortest jobs, and thereby decreasing and increasing the potential function, respectively. For the specific speed choice, (5), we show that the rate of change of the potential function is at most a (negative) constant times the number of the remaining jobs with the proposed algorithm plus a (positive) constant times the holding cost of the $OS$ algorithm. Since the instantaneous holding cost for the algorithm is $n(t)+P(s(t))=2n(t)$ from (5), this bound on the drift, as we show next, is sufficient to show (7) for some $c$. *

Using Lemmas 3 and 4 (proved in Appendix B), we now prove (7) by considering the following two cases:

[Case 1: $n\geq m.$] $n+\sum_{k\in A}P(s_{k})+d\Phi(t)/dt$

[TABLE]

Here, $(a)$ follows from Lemmas 3 and 4, and since $P(s_{k})=n/m$ when $n\geq m$ (see (5)), while $(b)$ follows by setting $c_{1}=2$ and $c_{2}\geq 1/P^{-1}(1).$

[Case 2: $n<m.$] $n+\sum_{k\in A}P(s_{k})+d\Phi(t)/dt$

[TABLE]

Once again, $(a)$ follows from Lemmas 3 and 4, and since $P(s_{k})=1$ when $n<m$ (see (5)), while $(b)$ follows by setting $c_{2}=2/P^{-1}(1).$

This proves (7) for

[TABLE]

∎

In the next section, we consider a special case when all jobs have unit size, but their arrival instants are still worst case, for which we can improve the competitive ratio guarantees.

III-B Equal Sized Jobs

Assume that all jobs have equal size, which is taken to be $1$ without loss of generality. There are $m$ servers and jobs are assigned on arrival to one of the $m$ servers for service. $\mathsf{OPT}$ refers to the offline optimal policy. We propose the following policy ${\cal U}$. Each job on its arrival is assigned to servers in a round-robin fashion, and each server $k$ uses speed $s_{k}(t)=P^{-1}(n_{k}(t))$, where $n_{k}(t)$ is the number of unfinished jobs that have been assigned to server $k$.

Theorem 3**.**

With unit job sizes, under Assumption 1, ${\cal U}$ is $2$-competitive.

Proof.

In Proposition 1, we show that when all jobs are of unit size, $\mathsf{OPT}$ follows round robin scheduling. Thus, ${\cal U}$ and $\mathsf{OPT}$ see the same set of arrivals on each server. The result follows from [8], which shows that choosing speed $s_{k}(t)=P^{-1}(n_{k}(t))$ for a single server system is $2$-competitive. ∎

Proposition 1**.**

With unit job sizes, under Assumption 1, $\mathsf{OPT}$ performs round robin dispatch across servers.

Proof.

Let us assume that $\mathsf{OPT}$ can hold arriving jobs in a central queue before dispatch to one of the $m$ servers. It suffices to show that even in this expanded space of policies, $\mathsf{OPT}$ can be assumed to perform round robin dispatch without loss of optimality (WLO).

From the convexity of the power function, it follows that $\mathsf{OPT}$ serves each job at a constant speed. Labeling jobs in the order of their arrival, let $s_{j}$ denote the speed at which job $j$ is served. 2. 2.

Once in service, a job is not interrupted until it completes. (Indeed, it can be shown via a simple interchange argument that it is not beneficial to interrupt a job in service to begin service on another, when all jobs are of the same size to begin with.) 3. 3.

WLO, we may assume that $\mathsf{OPT}$ dispatches jobs for service in a FCFS manner.

Claim 1: WLO, $\mathsf{OPT}$ completes jobs in the order of their arrival.

It follows from Claim 1 that $\mathsf{OPT}$ can be assumed to perform round robin WLO. Indeed, Claim 1 implies that job completions from servers would occur in the same order as the order of dispatch, allowing for a cyclic (round robin) dispatch across servers.

Proof of Claim 1: Let $a_{l}$ denote the time when job $l$ begins service and let $d_{l}$ denote the time when the same job completes service. Suppose the claim does not hold, i.e., there exist $i,j$ where $i<j$ such that $d_{j}<d_{i}.$ We now demonstrate an alternative power allocation that is strictly better for $\mathsf{OPT}$.

Note that $a_{i}\leq a_{j}.$ Let $r\leq 1$ denote the remaining work of job $i$ at time $a_{j}.$ Clearly, $d_{j}<d_{i}$ implies that $s_{j}>s_{i}.$ Fix $\delta\in(0,1/s_{j}]$ such that

[TABLE]

Consider the following power allocation:

Starting at time $a_{j},$ job $i$ is served at speed $s_{j}$ for $\delta$ time units, and at speed $s_{i}$ for $\frac{1}{s_{j}}-\delta$ time units 2. 2.

Starting at time $a_{j},$ job $j$ is served at speed $s_{j}$ for $\frac{1}{s_{j}}-\delta$ time units, and at speed $s_{i}$ for $\frac{r}{s_{i}}-\frac{1}{s_{j}}+\delta$ time units

From (8), it is not hard to see that under this new power allocation, the departure instants of jobs $i$ and $j$ are interchanged, i.e., job $i$ completes at time $d_{j},$ whereas job $j$ completes at time $d_{i}.$ Moreover, under the above power allocation, the cost of $\mathsf{OPT}$ remains unchanged. Indeed, the increase in the delay cost of job $j$ is exactly compensated by the decrease in the delay cost of job $i.$ Moreover, the energy cost remains unchanged, and the cost associated with all remaining jobs remains unchanged as well (we simply interchange all subsequent dispatches between the servers serving jobs $i$ and $j$).

Now, from the convexity of the power function, it follows that we can strictly decrease the energy cost of $\mathsf{OPT}$ by running jobs $i$ and $j$ at constant speeds from time $a_{j}$, such that the completion times remain unchanged.

This gives us a contradiction, and completes the proof of the claim. ∎

IV Worst Case Competitive Ratio: Lower bounds

In the previous section, we showed that while SRPT scheduling is not constant-competitive in a multi-server environment without speed scaling, it can be made constant-competitive when speed scaling is allowed. However, one issue with implementing SRPT on multiple servers is the need for job migration. In this section, we show that a broad class of greedy non-migratory policies is not constant-competitive.

For deriving lower bounds, we consider $P(s)=s^{\alpha}$ in the rest of the section for brevity. We begin by stating the following preliminary result.

Lemma 5**.**

On a single server, consider a single burst of $n$ jobs, with sizes $x_{n}\leq x_{n-1}\leq\cdots\leq x_{1}.$ The cost incurred by $\mathsf{OPT}$ in processing this burst equals $c\sum_{k=1}^{n}x_{k}k^{1-1/\alpha},$ where the constant $c$ depends on $\alpha.$

The proof of Lemma 5 follows by direct computation of the optimal speeds for each job that minimize the flow time plus energy cost (1).

IV-A Greedy algorithms

The main idea in deriving lower bounds on a class of non-migratory online algorithms is to construct an arrival sequence $\sigma$ for which that class of algorithms exhibits poor performance because of the inability to migrate jobs between servers once assigned (given that those assignments were made based on only causal information about $\sigma$). In contrast, $\mathsf{OPT}$ can have much lower cost than the online algorithm, even without migration, by exploiting its non-causal information about $\sigma.$

Lemma 6**.**

Consider the class of policies that routes an incoming job to a server with the least amount of unfinished workload. All policies in this class have a competitive ratio that is $\Omega(m^{1-1/\alpha}).$

Proof.

Consider the following instance: A burst of $m-1$ jobs, each having size $w$ arrives at time [math], and another burst of $w$ jobs, each having size 1 arrives at time $0^{+}.$

Any workload-based greedy policy would assign the first $m-1$ jobs of size $w$ to $m-1$ different servers, and the $w$ jobs of size 1 to the remaining server. By Lemma 5, the cost incurred by any such algorithm is at-least (for some $c$ depending only on $\alpha$)

[TABLE]

for some constant $c^{\prime}$.

Consider now an algorithm $A$ that assigns the first $m-1$ jobs of size $w$ to $m-1$ different servers and then distributes the $w$ jobs of size 1 uniformly among all $m$ servers. The algorithm $A$ then performs scheduling and speed scaling on each server as per single server $\mathsf{OPT}$. The cost incurred by $A$ (which upper bounds the cost under $\mathsf{OPT}$) equals (using Lemma 5)

[TABLE]

Now, setting $w=m^{d}$ for large enough $d,$ $(d>1/(1-1/\alpha))$ we see that the competitive ratio of any workload-based greedy policy is $\Omega(m^{1-1/\alpha}).$ ∎

It follows from the proof of Lemma 6 that the competitive ratio of any policy that routes an incoming job to a server that has been assigned the least aggregate workload so far (including completed as well as queued workload) is also $\Omega(m^{1-1/\alpha}).$

Lemma 7**.**

Consider the class of policies that route an incoming job to a server with the least number of queued jobs (join the shortest queue (JSQ)). All policies in this class have a competitive ratio that is $\Omega(m^{1-1/\alpha}).$

Proof.

Consider the following instance: $m^{2}$ jobs arrive in quick succession, causing any JSQ-based policy to perform round robin routing. Every $m$th arriving job has size $w,$ while all remaining jobs have size 1.

Thus, under any JSQ-based policy, one server would get $m$ jobs of size $w$ routed to it, whereas all other servers would get $m$ jobs of size 1. Thus, the cost under any such policy is at least $cw\sum_{k=1}^{m}k^{1-1/\alpha}+c(m-1)\sum_{k=1}^{m}k^{1-1/\alpha}\geq c^{\prime}wm^{2-1/\alpha}+c^{\prime}(m-1)m^{2-1/\alpha}$.

Consider an algorithm $A$ that routes the jobs uniformly across the servers, such that each server gets $m-1$ jobs of size 1, and one job of size $w.$ Post routing, $A$ performs scheduling and speed scaling on each server as per single server $\mathsf{OPT}$. The cost incurred by $A$ (which upper bounds the cost of $\mathsf{OPT}$) is thus $m\left[cw+c\sum_{k=1}^{m-1}k^{1-1/\alpha}\right]\leq c^{\prime\prime}\left[mw+m^{3-1/\alpha}\right]$.

Now, setting $w=m^{d}$ for large enough $d,$ we see that the competitive ratio of any JSQ-based policy is $\Omega(m^{1-1/\alpha}).$ ∎

It is also clear from the above proof that any policy that performs round robin routing would have a competitive ratio that is $\Omega(m^{1-1/\alpha}).$

IV-B SRPT-based algorithms

In this section, we consider the following class of non-migratory SRPT-based policies: Let $y_{j}(t)$ denote the least remaining processing time among all jobs queued at server $j.$ If server $j$ is idle at time $t$, then set $y_{j}(t)=0.$ Consider now a job of size $x$ arriving into the system at time $t.$ If the set $\{j:\ y_{j}(t)>x\}$ is non-empty, then the job is assigned to a server from this set. Else, the job is assigned to any server, or held in a central queue. Each server may preempt between jobs queued at that server. But jobs once assigned to a certain server must complete service at that server, i.e., migration is not allowed.

Lemma 8**.**

Consider the class of non-migratory SRPT-based policies described above. All policies in this class have a competitive ratio that is $\Omega(m^{1-1/\alpha}).$

Proof.

Consider the following instance: $m-1$ jobs of size 1 arrive at time 0, and $m$ jobs of sizes $w,w-\epsilon,\cdots,w-(m-1)\epsilon$ arrive in quick succession right after.

Any non-migratory SRPT-based policy would route the $m-1$ jobs of unit size to $m-1$ different servers, and the next $m$ jobs to the remaining server. Thus, the cost incurred is at least $(w-m\epsilon)c\sum_{k=1}^{m}k^{1-1/\alpha}\geq c^{\prime}(w-m\epsilon)m^{2-1/\alpha}$.

Consider next a policy $A$ that routes the first $m-1$ unit sized jobs to $m-1$ different servers, and distributes the next $m$ jobs across all servers. Post routing, $A$ performs scheduling and speed scaling on each server as per single server $\mathsf{OPT}$. The cost incurred by $A$ (which upper bounds the cost of $\mathsf{OPT}$) is thus at most $mc\left(w+2^{1-1/\alpha}\right)$. Now, setting $w=m^{d}$ for large enough $d,$ we see that the competitive ratio of any non-migratory SRPT-based policy is $\Omega(m^{1-1/\alpha}).$ ∎

V Stochastic Input

In this section, we consider a stochastic model for the job arrivals. Jobs arrive according to a Poisson process of rate $\lambda,$ and have i.i.d. sizes. Let $X$ denote a generic job size. We assume that $\mathbb{E}\left[X\right]<\infty.$ The load, which is the rate at which work is submitted to the system, is given by $\Lambda=\lambda\mathbb{E}\left[X\right].$

The performance metric under consideration is the stationary variant of the flow time plus energy metric considered for the worst-case analysis, i.e.,

[TABLE]

where $T$ denotes the steady state response time, and $E$ denotes the energy required to serve a job in steady state.444Of course, for this metric to be meaningful, we restrict attention to policies that are regenerative, and thus have a meaningful steady state behavior. We also note that it is straightforward to extend the results of this section to a metric that is a linear combination of $\mathbb{E}\left[T\right]$ and $\mathbb{E}\left[E\right].$ In the present section, we restrict attention to power functions of the form $P(s)=s^{\alpha},$ where $\alpha>1.$

In the following, we generalise a result proved in [6] for the single server setting to the multi-server setting. Specifically, we show that a policy that routes each job randomly, and runs each server at a constant speed $s^{*}(\Lambda)$ when active, is constant competitive. Note that the speed chosen depends on the load $\Lambda,$ which needs to be known or learnt. Policies of this type are referred to in [6] as gated static policies.

Specifically, the proposed algorithm $\mathcal{S}$ is the following: Arriving jobs are routed to any server uniformly at random. Each server performs processor sharing (PS) scheduling using a fixed speed $s^{*}(\Lambda),$ which is the optimal static speed to minimize the metric (9) on that (single) server.

We begin our analysis by deriving a lower bound on the performance of any routing and speed scaling policy.

V-A Lower Bound

Let $s_{i}$ denote the time-averaged speed of server $i.$ We have

[TABLE]

where $(a)$ follows from an application of the Jensen’s inequality, while $(b)$ follows from the convexity of the power function $P$, given that $\sum_{i=1}^{m}\mathbb{E}\left[s_{i}\right]=\Lambda$ (for stability).

Next, we derive an alternate lower bound on $C$. Consider the case when only a single job of size $X$ arrives. This job is run at a constant speed $s^{\star}$ that minimizes its response time plus energy consumption, i.e., $s^{\star}=\arg\inf_{s>0}\frac{X}{s}+\frac{X}{s}P(s)=\left(\frac{1}{\alpha-1}\right)^{1/\alpha}.$ This yields the following lower bound on the performance of any algorithm

[TABLE]

Combining (10) and (11) gives us

[TABLE]

Next, we characterize the performance of the proposed policy and bound its competitive ratio.

V-B Performance under policy $\mathcal{S}$

Under random routing, each server sees a Poisson arrival process with rate $\lambda/m.$ Thus, the performance under metric (9) when operating each server at speed $s$ when active with PS scheduling is given by

[TABLE]

Choosing $s^{*}(\Lambda)=\operatornamewithlimits{argmin}_{s>0}C(s),$ we get that the cost (9) of the algorithm $\mathcal{S}$ is given by $C(s^{*}(\Lambda)).$

Theorem 4**.**

In the stochastic input setting, the competitive ratio of the algorithm $\mathcal{S}$ is upper bounded by a constant that depends on $\alpha$ but not on $\lambda,$ the job size distribution, or $m$.

Remark 3**.**

The basic idea of the proof is to compare the two lower bounds on the cost (9) derived in (10) and (11), with the upper bound on the cost (9) of $\mathcal{S}$, the random routing and gated static policy, derived in (13).

Proof.

The proof follows by comparing the performance $\mathcal{S}$ with the lower bound (12) that holds for any algorithm.

Indeed, for any algorithm $A,$

[TABLE]

∎

The above bound can be tightened for the case $\alpha=2,$ since $s^{*}(\Lambda)$ can be computed explicitly in this case.

Corollary 1**.**

For $\alpha=2$, in the stochastic input setting, the competitive ratio of the algorithm $\mathcal{S}$ is at most $2$.

Proof.

For $\alpha=2$, from (13), we get $s^{*}(\Lambda)=1+\frac{\Lambda}{m},$ and thus, the performance $C_{\mathcal{S}}$ under the algorithm satisfies

[TABLE]

Now, from (12), $\lambda C_{A}\geq\max\{\Lambda^{2}/m,2\Lambda\}$ under any algorithm $A$, which implies the statement of the corollary. ∎

VI Concluding Remarks

In this paper, we show that SRPT can be made constant competitive in the multi-server speed scaling environment with respect to the flow time plus energy metric. This presents an interesting contrast to the case when server speeds are constant, where it is known that SRPT has an unbounded competitive ratio with respect to the flow time metric. We also show that the multi-server speed scaling problem is easy in the absence of job size variability; simple round robin dispatch in conjunction with a single-server speed scaling rule is near-optimal. Finally, we show that a broad class of policies based on greedy non-migratory dispatch rules do not admit a constant competitive ratio.

In contrast, in the stochastic setting, we show that random routing, along with a gated static speed setting is constant competitive. However, the required speed is a function of the load, which needs to be learnt.

While SRPT is a well studied scheduling policy in the multiple server setting, one issue with implementing SRPT in practice is the need for migration. Considering that there is a cost associated with migration of a job across servers in practice, a natural generalization would be to include this cost of migration in the performance metric. How to optimally tradeoff flow time, energy consumption, and migration costs is an interesting open problem for the future. However, it is easy to bound the performance of the SRPT-based speed scaling algorithm proposed in this paper accounting for migration costs. Indeed, in a job sequence consisting of $J$ jobs, SRPT performs at most $J$ migrations. Thus, assuming a fixed cost of each migration, our SRPT-based algorithm remains constant competitive with respect to the flow time plus energy plus migration cost metric if one assumes a lower bound on the size of each job; in this case, the migration cost is at most a constant factor of the flow time.

Finally, we note that while there is a considerable literature on speed scaling in parallel multi-server environments, we are not aware of any work on speed scaling in tandem queueing systems, and more generally, on a queueing network. Coming up with constant competitive speed scaling algorithms in these settings is an interesting avenue for future work.

Appendix A Proof of Proposition 5

Proposition 5**.**

$\Phi(\cdot)$* as defined in (6) satisfies boundary conditions 1) and 2).*

Proof.

Note that Condition 1 is satisfied; before any job is released and after all jobs are finished, $\Phi(t)=0,$ since $n(t,q)=n_{o}(t,q)=0$ for all $q.$ Whenever a new job arrives/is released, $n(t,q)-n_{o}(t,q)$ and $d(t,q)$ do not change for any $q$, so $\Phi$ remains unchanged. Similarly, whenever a job is completed by the algorithm or $\mathsf{OPT}$, $d(t,q)$ or $n(t,q)-n_{o}(t,q)$ is changed for only a single point of $q=0,$ which does not introduce a discontinuity in $\Phi(t).$ Thus, Condition 2 is also satisfied. ∎

Appendix B Proof of Lemmas 3 and

4

To prove Lemmas 3 and 4 we need the following technical lemma from [15].

Lemma 9**.**

[Lemma 3.1 in [15]] For $s_{k},{\tilde{s}}_{k},x\geq 0$,

[TABLE]

We now give the proofs of Lemmas 3 and 4.

Proof of Lemma 3.

Let $q(i)$ and $q_{o}(i)$ denote, respectively, the size of the $i^{th}$ shortest job in service under the algorithm and $OS.$

Case 1: $n\geq m.$ Suppose that $OS$ is serving $r$ jobs, where $r\leq m.$ Define $\tilde{n}(q)=\max(n(q),n-r)$, and $\tilde{n}_{o}(q)=\max(n_{o}(q),n_{o}-r)$. We assume for now that all jobs under the algorithm and $OS$ have distinct remaining sizes. We later point out how our argument generalizes when this assumption is relaxed. Now, given the preceding assumption, the function $g(q):=\tilde{n}(q)-\tilde{n}_{o}(q)$ satisfies the following properties.

$g(0)=n-n_{o},$ $g(q)\rightarrow n-n_{0}$ as $q\rightarrow\infty,$ 2. 2.

$g$ is piecewise constant and left-continuous, with a downward jump of 1 at $q=q(i),$ $1\leq i\leq r,$ and an upward jump of 1 at $q=q_{o}(i),$ $1\leq i\leq r.$

Consider the change in $\Phi_{1}$ due to $OS$ ($n_{o}(q)\rightarrow n_{o}(q)-1$ for $q=q_{o}(1),\cdots,q_{o}(r)$):

[TABLE]

In writing $(a)$ we take $\Delta(i/m)=0$ for $i\leq 0.$ $(b)$ holds since $\tilde{n}_{o}(q_{o}(i))=n_{o}(q(i))$ for $1\leq i\leq r,$ and $\tilde{n}(q)\geq n(q)\ \forall\ q.$

Next, consider the change in $\Phi_{1}$ due to the algorithm ($n(q)\rightarrow n(q)-1$ for $q=q(1),\cdots,q(m)$):

[TABLE]

Here, $(a)$ holds because $n(q(i))=\tilde{n}(q(i))$ for $1\leq i\leq r,$ and $\tilde{n}_{o}(q)\geq n_{o}(q)$ for all $q.$ $(b)$ follows since $n(q(i))\geq n-i+1.$555$n(q(i))=n-i+1$ if the algorithm has exactly one job with remaining size $q(i).$ If multiple jobs have the same remaining size $q(i)$ under the algorithm, then we have $n(q(i))\geq n-i+1.$

We now combine (14) and (15) to capture the overall change in $\Phi_{1}.$ In doing so, we make the following crucial observation.

Claim 1: For each $i\in\{1,2,\cdots,r\},$ there exists a unique $j\in\{1,2,\cdots,r\}$ such that $g(q(i))\geq g(q_{o}(j))+1.$

To see that this claim is true, note that at each job with remaining size $q(k)$ ($1\leq k\leq r$) being served by the algorithm contributes a down-tick of magnitude 1 in $g$ at $q(k).$ Similarly, each job with remaining size $q_{o}(k)$ ($1\leq k\leq r$) being served by $OS$ contributes an up-tick of magnitude 1 in $g$ at $q_{o}(k).$666The magnitude of the discontinuity in $g$ at $q$ thus equals $|\{j\in R:\ q_{o}(j)=q\}|-|\{j\in R:\ q(j)=q\}|$, where $R=\{1,2,\cdots,r\}.$ It is therefore clear that each down-tick from $l$ to $l-1$ can be mapped to an unique up-tick from $l-1$ to $l.$ Moreover, at the downtick, say at $q(i),$ we have $g(q(i))\geq l$ (because $g$ is left-continuous), and at the corresponding up-tick, say at $q_{o}(j),$ we have $g(q_{o}(j))\leq l-1,$ implying $g(q_{o}(j))+1\leq l,$ (again, because $g$ is left-continuous). This proves the claim.

Based on the above observation, combining (14) and (15), we can now bound the overall change in $\Phi_{1}$ as follows.777Note that until now, we took $\tilde{s}_{i}$ to be the speed of the $i$th shortest job under $OS.$ However, once we match drift terms between the algorithm and $OS$, the indices $i$ can get shuffled. To maintain notational simplicity, we do not make this re-labelling explicit. The indices $i$ will be understood to span the active jobs/servers under the algorithm/$OS.$

[TABLE]

Invoking Lemma 9, terms in the first summation of (16) can be bounded as

[TABLE]

since $s_{k}=P^{-1}\left(\frac{n}{m}\right)\geq P^{-1}\left(\frac{g(q(i))}{m}\right)$. Lemma 9 can also be used to bound the terms of the second summation of (16) as

[TABLE]

(taking $\tilde{s}_{k}$ in the statement of Lemma 9 to be zero). Combining the above bounds, we arrive at $d\Phi_{1}/dt$

[TABLE]

Finally, noting that $g(q(i))\geq n-i+1-n_{o}$ for $1\leq i\leq r,$ we conclude that

[TABLE]

This proves the bound on $d\Phi_{1}/dt$ claimed in the statement of Lemma 3 for the case $n\geq m.$

Remark 4**.**

We now remark how the preceding argument generalizes if multiple jobs under the algorithm and/or $OS$ have identical remaining size. Suppose the algorithm has $k$ active jobs with remaining size $\hat{q},$ and $OS$ has $\ell$ active jobs, also with remaining size $\hat{q}.$ If these $k+\ell$ jobs are not being operated at the same speed, we simply disregard the change in $\Phi_{1}$ at that instant of time; after all, it suffices to prove (7) almost everywhere in time. On the other hand, if all $k+\ell$ jobs are being served at the same speed, say $\hat{s},$ the change in $\Phi_{1}$ is captured as follows.

Suppose that $k\geq\ell.$ Note that $g$ has a downward jump of $k-\ell$ at $\hat{q}.$ The change in $\Phi_{1}$ due to the $k+\ell$ jobs with remaining size $\hat{q}$ in service is given by:

[TABLE]

The $k-\ell$ terms in the first sum above (which correspond to the downward jump of $k-\ell$ in $g$ at $\hat{q}$) can be matched to $k-\ell$ up-ticks in $g$ due to $OS$ as in Claim 1. The $\ell$ terms in the second sum make zero contribution to the change in $\Phi_{1},$ but can still be bounded using Lemma 9, so that the steps after (16) can be followed to arrive at the final bound on $d\Phi_{1}/dt.$

A similar argument can be made if $k<\ell.$

Case 2: $n<m.$ Let $r$ denote the number of jobs in service under $OS.$ Define $h(q):=n(q)-n_{o}(q).$ As in Case 1, we assume for simplicity of exposition that all jobs under the algorithm and $OS$ have distinct remaining sizes. The general case can be handled as was pointed out in the proof of Case 1. The rate of change of $\Phi_{1}$ can be expressed as follows:

[TABLE]

Claim 2: For each $i\in\{1,2,\cdots,n_{o}\}$ such that $h(q_{o}(i))\geq 0,$ one can find a unique $j\in\{1,2,\cdots,n\}$ such that $h(q(j))\geq h(q_{o}(i))+1.$

The proof of the above claim follows along the same lines as the proof of Claim 1 for $n\geq m.$ Note that $h$ is piecewise constant and left-continuous, with $h(0)=n-n_{o},$ $h(q)=0$ for large enough $q,$ has upward jumps at $q_{o}(i)$ $(i\leq n_{o})$ at downward jumps at $q(i)$ $(i\leq n).$ Thus, any uptick in $h(\cdot)$ from $l-1$ to $l$ for $l\geq 1$ can be mapped to a unique downtick from $l$ to $l-1.$ The rest of the argument is identical to that of Claim 1.

Based on the above observation, suppose that a subset $J$ of algorithm terms are matched with $OS$ terms.

[TABLE]

Applying Lemma 9 as before,

[TABLE]

∎

Proof of Lemma 4.

The rate of change in $\Phi_{2}$ is

[TABLE]

The bounding of the first term above uses $s_{k}\geq P^{-1}(1).$ The bounding of the second term is based on: (i) $\tilde{s}_{k}\leq P(\bar{s})$ when $\tilde{s}_{k}\leq\bar{s},$ and (ii) $\tilde{s}_{k}\leq P(\tilde{s}_{k})$ when $\tilde{s}_{k}>\bar{s}.$ ∎

Appendix C Proof of Theorem 2

Unlike in the proof of Theorem 1, we now make no assumptions on the scheduling of $\mathsf{OPT}.$ We use the same potential function $\Phi$ as before (see (6)), and show that (7) holds for a suitable $c.$ Note that it suffices to show that (7) holds at any instant $t$ which is not an arrival or departure instant under the algorithm or $\mathsf{OPT}.$ For the remainder of this proof, consider any such time instant $t.$ For ease of exposition, we drop the index $t$ from $n(t,q),n(t,q_{o}),n(t),n_{o}(t),s_{k}(t)$ and ${\tilde{s}}_{k}(t),$ since only a fixed (but generic) time instant $t$ is under consideration.

Our proof is based on the following lemmas.

Lemma 10**.**

For $n\geq m$,

[TABLE]

while for $n<m,$

[TABLE]

Lemma 11**.**

$d\Phi_{2}/dt\leq-c_{2}\min(m,n)+c_{2}\sum_{k\in O}P({\tilde{s}}_{k})$**

Using Lemmas 10 and 11, we now prove (7) by considering the following two cases:

Case 1: $n\geq m.$

[TABLE]

Here, $(a)$ follows by setting $c_{1}=\frac{2}{2-\alpha},$ and $c_{2}\geq 1.$

Case 2: $n<m.$

[TABLE]

Here, $(a)$ follows setting $c_{1}=\frac{2}{2-\alpha},$ and $c_{2}=3.$

This proves (7) for $c=c_{1}+c_{2}=3+\frac{2}{2-\alpha}.$ It now remains to prove Lemmas 10 and 11.

Proof of Lemma 10.

Let $q(i)$ denote the size of the $i^{th}$ shortest job in service under the algorithm. Note that since the algorithm performs STPT scheduling, $q(i)$ is also the size of the $i^{th}$ shortest job in the system under the algorithm. Let $q_{o}(i)$ denote the size of the $i^{th}$ largest job in service under $\mathsf{OPT}.$

Case 1: $n\geq m$. When $n\geq m,$ since the algorithm processes the $m$ shortest jobs, the change in $\Phi_{1}$ because of the algorithm ($n(q)\rightarrow n(q)-1$ for $q=q(1),\cdots,q(m)$) is

[TABLE]

In writing $(a)$ we take $\Delta(i/m)=0$ for $i\leq 0.$ $(b)$ follows since $n(q(k))\geq n-k+1$, and $n_{o}(q(k))\leq n_{o}$ for all $k.$ Next, we bound the terms of (18) using Lemma 9. For those terms where the argument of $\Delta(\cdot)$ is non-negative, Lemma 9 implies that

[TABLE]

take $\tilde{s}_{k}=0$ and note that

[TABLE]

The bound (19) also holds for those terms where the argument of $\Delta(\cdot)$ is negative; in this case, the left hand side of the inequality is zero, and the right hand side is positive. This yields the bound

[TABLE]

We now consider the change in $\Phi_{1}$ due to $\mathsf{OPT}.$

[TABLE]

where $(a)$ follows since $n(q_{o}(k))\leq n,$ and $n_{o}(q_{o}(k))\geq k.$888The reader should verify that the bound on $n_{o}(q_{o}(i))$ applies even if multiple active jobs under $\mathsf{OPT}$ have identical sizes. Applying Lemma 9 with $s_{k}=0,$ we get that the change in $\Phi_{1}$ because of $\mathsf{OPT}$ is

[TABLE]

since $P^{-1}(i)P^{{}^{\prime}}(P^{-1}(i))-i=(\alpha-1)i.$ Finally, since $|O|\leq m,$ we have that the change in $\Phi_{1}$ because of $\mathsf{OPT}$ satisfies

[TABLE]

Combining (20) and (22), the overall change in $\Phi_{1}$ satisfies

[TABLE]

Case 2: $n<m.$ Our approach in capturing the change in $\Phi_{1}$ due to the algorithm is the same as that in Case 1, except that the summations in (17) and (18) only run from $k=1$ to $k=n.$ An application of Lemma 9 as before implies that the component of $d\Phi_{1}/dt$ because of the algorithm satisfies

[TABLE]

The analysis of the impact of $\mathsf{OPT}$ on $\Phi_{1}$ also proceeds as in Case 1, except that the summation in (21) only runs from $k=1$ to $k=n;$ note that the remaining terms in the sum are zero. An application of Lemma 9 as before implies that the component of $d\Phi_{1}/dt$ because of $\mathsf{OPT}$ satisfies

[TABLE]

Combining (23) and (24), the overall change in $\Phi_{1}$ is bounded as

[TABLE]

∎

Proof of Lemma 11.

The proof is similar to that of Lemma 4, except that we exploit the specific form of the power function.

[TABLE]

In the above bound, we use the fact that for $P(s)=s^{\alpha},$ the minimum speed utilized by any algorithm is $P^{-1}(1)=1.$ Thus, $s_{k},\tilde{s_{k}}\geq 1,$ and $\tilde{s_{k}}\leq P(\tilde{s_{k}}).$ ∎