Scheduling Jobs with Random Resource Requirements in Computing Clusters

TL;DR

This paper addresses the challenge of scheduling jobs with diverse and potentially infinite resource requirements in distributed computing clusters, proposing algorithms that achieve significant throughput without prior knowledge of workload distributions.

Contribution

It introduces oblivious scheduling algorithms capable of handling infinite resource requirement types and characterizes fundamental throughput limits in such high-dimensional settings.

Findings

Algorithms achieve at least 1/2 of maximum throughput

Algorithms achieve at least 2/3 of maximum throughput

Simulation results confirm effectiveness on synthetic and real data

Abstract

We consider a natural scheduling problem which arises in many distributed computing frameworks. Jobs with diverse resource requirements (e.g. memory requirements) arrive over time and must be served by a cluster of servers, each with a finite resource capacity. To improve throughput and delay, the scheduler can pack as many jobs as possible in the servers subject to their capacity constraints. Motivated by the ever-increasing complexity of workloads in shared clusters, we consider a setting where the jobs' resource requirements belong to a very large number of diverse types or, in the extreme, even infinitely many types, e.g. when resource requirements are drawn from an unknown distribution over a continuous support. The application of classical scheduling approaches that crucially rely on a predefined finite set of types is discouraging in this high (or infinite) dimensional setting. We first characterize a fundamental limit on the maximum throughput in such setting, and then develop oblivious scheduling algorithms that have low complexity and can achieve at least 1/2 and 2/3 of the maximum throughput, without the knowledge of traffic or resource requirement distribution. Extensive simulation results, using both synthetic and real traffic traces, are presented to verify the performance of our algorithms.

Equations

$$\sum _{j\in {\mathcal{H}}_{\ell }(t)}{R}_j\le 1,\forall \ell \in \mathcal{L},t=0,1,\cdots .$$

$$\mathcal{Q}(t+1)=\mathcal{Q}(t)\cup \mathcal{A}(t)-\mathcal{D}(t),$$

$$Q(t+1)=Q(t)+A(t)-D(t).$$

$$\displaystyle\rho^{\star}=\sup\Big{\{}\rho\in\mathbb{R}_{+}:\rho\bm{P}<\sum_{\ell\in{\mathcal{L}}}\mathbf{x}^{\ell},\mathbf{x}^{\ell}\in\rm Conv(\overline{\mathcal{K}}),\ell\in{\mathcal{L}}\Big{\}}$$

$$⟨\mathbf{k},\mathbf{Q}⟩=\sum _{j=1}^J{k}_j{Q}_j.$$

$$\displaystyle I_{2m}=\Big{(}\frac{2}{3}\frac{1}{2^{m}},\frac{1}{2^{m}}\Big{]},\ m=0,\cdots,J-1$$

$$\displaystyle I_{2m+1}=\Big{(}\frac{1}{2}\frac{1}{2^{m}},\frac{2}{3}\frac{1}{2^{m}}\Big{]},\ m=0,\cdots,J-1.$$

$$2^m{\mathbf{e}}_{2m},$$

$$3\cdot 2^{m-1}{\mathbf{e}}_{2m+1},$$

$${\mathbf{e}}_1+\lfloor 2^m/3\rfloor {\mathbf{e}}_{2m},$$

$${\mathbf{e}}_1+2^{m-1}{\mathbf{e}}_{2m+1},$$

$${\mathbf{k}}^{\star }({\tau }_i^{\ell })=\underset{\mathbf{k}\in {\mathcal{K}}_{RED}^{(J)}}{\mathrm{argmax}}⟨\mathbf{k},\mathbf{Q}({\tau }_i^{\ell })⟩=\underset{\mathbf{k}\in {\mathcal{K}}_{RED}^{(J)}}{\mathrm{argmax}}\sum _{j=0}^{2J-1}{k}_j{Q}_j.$$

$${\mathbf{k}}^{\ell }(t)={\mathbf{k}}^{\star }({\tau }_i^{\ell }),{\tau }_i^{\ell }\le t<{\tau }_{i+1}^{\ell }.$$

$$⟨\mathbf{k},\mathbf{Q}⟩\ge \frac{2}{3}⟨{\mathbf{k}}^{(X)},{\mathbf{Q}}^{(X)}⟩,\forall {\mathbf{k}}^{(X)}\in {\mathcal{K}}^{(X)},$$

$$\sum _{i\in Z_j}{Q}_i^{(X)}=Q_j.$$

$$Q_{2m}\ge 2U/3\times 1/2^m,m=0,\cdots ,J-1$$

$$Q_{2m+1}\ge U/2\times 1/2^m,m=1,\cdots ,J-1$$

$$\displaystyle\begin{aligned} &U=\sum_{m=0}^{J-1}\sum_{i_{0}\in Z_{2m}}{k}_{i_{0}}^{(X)}Q_{i_{0}}^{(X)}+\sum_{m=1}^{J-1}\sum_{i_{1}\in Z_{2m+1}}{k}_{i_{1}}^{(X)}Q_{i_{1}}^{(X)}\stackrel{{\scriptstyle(a)}}{{<}}\\ &\Big{(}\sum_{m=0}^{J-1}\sum_{i_{0}\in Z_{2m}}{k}_{i_{0}}^{(X)}\frac{2}{3}\frac{1}{2^{m}}+\sum_{m=1}^{J-1}\sum_{i_{1}\in Z_{2m+1}}{k}_{i_{1}}^{(X)}\frac{1}{2}\frac{1}{2^{m}}\Big{)}U\stackrel{{\scriptstyle(b)}}{{<}}\\ &\Big{(}\sum_{m=0}^{J-1}\sum_{i_{0}\in Z_{2m}}{k}_{i_{0}}^{(X)}\xi_{i_{0}}+\sum_{m=1}^{J-1}\sum_{i_{1}\in Z_{2m+1}}{k}_{i_{1}}^{(X)}\xi_{i_{1}}\Big{)}U\stackrel{{\scriptstyle(c)}}{{\leq}}1\times U,\end{aligned}$$

$$Q_{2m}\ge U^{\prime }/(3\cdot 2^{m-2}),m=2,\cdots J-1$$

$$Q_{2m+1}\ge U^{\prime }/(3\cdot 2^{m-1}),m=1,\cdots J-1,$$

$$\displaystyle\begin{aligned} &U^{\prime}=\sum_{m=2}^{J-1}\sum_{i_{0}\in Z_{2m}}{k}_{i_{0}}^{(X)}Q_{i_{0}}^{(X)}+\sum_{m=1}^{J-1}\sum_{i_{1}\in Z_{2m+1}}{k}_{i_{1}}^{(X)}Q_{i_{1}}^{(X)}\stackrel{{\scriptstyle(a)}}{{<}}\\ &2U^{\prime}\Big{(}\sum_{m=2}^{J-1}\sum_{i_{0}\in Z_{2m}}{k}_{i_{0}}^{(X)}\frac{2}{3}\frac{1}{2^{m}}+\sum_{m=1}^{J-1}\sum_{i_{1}\in Z_{2m+1}}{k}_{i_{1}}^{(X)}\frac{1}{3}\frac{1}{2^{m}}\Big{)}\stackrel{{\scriptstyle(b)}}{{<}}U^{\prime}\end{aligned}$$

$$⟨\mathbf{k},\mathbf{Q}⟩$$

$$\ge Q_1+U^{\prime }/3\ge 2Q_1/3+U/3\ge 2U/3$$

$$⟨\mathbf{k},\mathbf{Q}⟩$$

$$\ge Q_1+U^{\prime }/3\ge 2Q_1/3+U/3\ge 2U/3$$

$${\pi }_i:=\text{mathds}P\left(R\in I_i^{(n)}\right)=\frac{1}{2^{n+1}},i=1,\cdots ,m_n.$$

$$L\sum _{\mathbf{k}\in \overline{\mathcal{K}}}{p}_{\mathbf{k}}\mathbf{k}>{\mathbf{\rho }}_1,\sum _{\mathbf{k}\in \overline{\mathcal{K}}}{p}_{\mathbf{k}}=1.$$

$$L\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{q}_{\mathbf{k}}\mathbf{k}>{\mathbf{\rho }}_2,\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{q}_{\mathbf{k}}=1.$$

$$L\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{p}_{\mathbf{k}}\mathbf{k}>\frac{\overline{\rho }(X^{(n)})}{2^{n+1}}\left(1_{m_n}-{\mathbf{e}}_{m_n}\right),$$

$$L{p}_{{\mathbf{e}}_{m_n}}{\mathbf{e}}_{m_n}>\frac{\overline{\rho }(X^{(n)})}{2^{n+1}}{\mathbf{e}}_{m_n}.$$

$$L\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{q}_{\mathbf{k}}\mathbf{k}>\frac{\underline{\rho }(X^{(n)})}{2^{n+1}}(1_{m_n}-{\mathbf{e}}_{m_n}).$$

$$L\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{p}_{\mathbf{k}}\mathbf{k}=\frac{{\overline{\rho }}^{\star }(X^{(n)})}{2^{n+1}}\left(1_{m_n}-{\mathbf{e}}_{m_n}\right)$$

$$L{p}_{{\mathbf{e}}_{m_n}}{\mathbf{e}}_{m_n}=\frac{{\overline{\rho }}^{\star }(X^{(n)})}{2^{n+1}}{\mathbf{e}}_{m_n}.$$

$$L\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{q}_{\mathbf{k}}\mathbf{k}=\frac{{\underline{\rho }}^{\star }(X^{(n)})}{2^{n+1}}(1_{m_n}-{\mathbf{e}}_{m_n}).$$

$$\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{p}_{\mathbf{k}}=1-p_{{\mathbf{e}}_{m_n}},\sum _{\mathbf{k}\in \overline{\mathcal{K}}\setminus \{{\mathbf{e}}_{m_n}\}}{q}_{\mathbf{k}}=1,$$

$${\underline{\rho }}^{\star }(X^{(n)})=\frac{{\overline{\rho }}^{\star }(X^{(n)})}{1-\frac{{\overline{\rho }}^{\star }(X^{(n)})}{L{2}^{n+1}}}$$

Full text

I Introduction

Distributed computing frameworks (e.g., MapReduce [1], Spark [2], Hive [3]) have enabled processing of very large data sets across a cluster of servers. The processing is typically done by executing a set of jobs or tasks in the servers. A key component of such systems is the resource manager (scheduler) that assigns incoming jobs to servers and reserves the requested resources (e.g. CPU, memory) on the servers for running jobs. For example, in Hadoop [1], the resource manager reserves the requested resources, by launching resource containers in servers. Jobs of various applications can arrive to the cluster, which often have very diverse resource requirements. Hence, to improve throughput and delay, a scheduler should pack as many jobs (containers) as possible in the servers, while retaining their resource requirements and not exceeding server’s capacities.

A salient feature of resource demand is that it is hard to predict and cannot be easily classified into a small or moderate number of resource profiles or “types”. This is amplified by the increasing complexity of workloads, i.e., from traditional batch jobs, to queries, graph processing, streaming, machine learning jobs, etc., that rely on multiple computation frameworks, and all need to share the same cluster. For example, Figure 1 shows the statistics of memory and CPU resource requirement requested by jobs in a Google cluster [4], over the first day in the trace. If jobs were to be divided into types according to their memory requirement alone, there would be more than $700$ types. Moreover, the statistics change over time and these types are not sufficient to model all the job requirements in a month, which are more than $1500$. We can make a similar observation for CPU requirements, which take more than $400$ discrete types. Analyzing the joint CPU and memory requirements, there would be more than $10,000$ distinct types. Building a low-complexity scheduler that can provide high performance in such a high-dimensional regime is extremely challenging, as learning the demand for all types is infeasible, and finding the optimal packing of jobs in servers, even when the demand is known, is a hard combinatorial problem (related to Bin Packing and Knapsack problems [5]).

Despite the vast literature on scheduling algorithms, their theoretical study in such high-dimensional setting is very limited. The majority of the past work relies on a crucial assumption that there is a predefined finite set of discrete types, e.g. [6, 7, 8, 9, 10, 11]. Although we can consider every possible resource profile as a type, the number of such types could be formidably large. The application of scheduling algorithms, even with polynomial complexity in the number of types, is discouraging in such setting. A natural solution could be to divide the resource requests into a smaller number of types. Such a scheduler can be strictly suboptimal, since, as a result of mapping to a smaller number of types, jobs may underutilize or overutilize the resource compared to what they actually require. Moreover, in the absence of any prior knowledge about the resource demand statistics, it is not clear how the partitioning of the resource axis into a small number of types should be actually done.

Our work fulfills one of the key deficiencies of the past work in the modeling and analysis of scheduling algorithms for distributed server systems. Our model allows a very large or, in the extreme case, even infinite number of job types, i.e., when the jobs’ resource requirements follow a probability distribution over a continuous support. To the best of our knowledge, there is no past work on characterizing the optimal throughput and what can be achieved when there are no discrete job types. Our goal is to characterize this throughput and design algorithms that: (1) have low complexity, and (2) can provide provable throughput guarantees without the knowledge of the traffic or the resource requirement statistics.

I-A Related Work

Existing algorithms for scheduling jobs in distributed computing platforms can be organized in two categories.

In the first category, we have algorithms that do not provide any throughput guarantees, but perform well empirically or focus on other performance metrics such as fairness and makespan. These algorithms include slot-based schedulers that divide servers into a predefined number of slots for placing tasks [12, 13], resource packing approaches such as [14, 15], fair resource sharing approaches such as [16, 17], and Hadoop’s default schedulers such as FIFO [18], Fair scheduler [19], and Capacity scheduler [20].

In the second category, we have schedulers with throughput guarantees, e.g., [6, 8, 9, 10, 11]. They work under the assumption that there is a finite number of discrete job types. This assumption naturally lends itself to MaxWeight algorithms [21], where each server schedules jobs according to a maximum weight configuration chosen from a finite set of configurations. The number of configurations however grows exponentially large with the number of types, making the application of these algorithms discouraging in practice. Further, their technique cannot be applied to our setting which can include an infinite number of job types.

There is also literature on classical bin packing problem [22], where given a list of objects of various sizes, and an infinite number of unit-capacity bins, the goal is to use the minimum number of bins to pack the objects. Many algorithms have been proposed for this problem with approximation ratios for the optimal number of bins or waste, e.g. [23, 24, 25]. There is also work in a setting of bin packing with queues, e.g. [26, 27, 28], under the model that an empty bin arrives at each time, then some jobs from the queue are packed in the bin at that time, and the bin cannot be reused in future. Our model is fundamentally different from these lines of work, as the number of servers (bins) in our setting is fixed and we need to reuse the servers to schedule further jobs from the queue, when jobs depart from servers.

I-B Main Contributions

Our main contributions can be summarized as follows:

• 1.

Characterization of Maximum Achievable Throughput. We characterize the maximum throughput (maximum supportable workload) that can be theoretically achieved by any scheduling algorithm in the setting that the jobs’ resource requirements follow a general probability distribution $F_{R}$ over possibly infinitely many job types. The construction of optimal schedulers to approach this maximum throughput relies on a careful partition of jobs into sufficiently large number of types, using the complete knowledge of the resource probability distribution $F_{R}$.

• 2.

Oblivious Scheduling Algorithms. We introduce scheduling algorithms based on “Best-Fit” packing and “universal partitioning” of resource requirements into types, without the knowledge of the resource probability distribution $F_{R}$. The algorithms have low complexity and can provably achieve at least $1/2$ and $2/3$ of the maximum throughput, respectively. Further, we show that $2/3$ is tight in the sense that no oblivious scheduling algorithm, that maps the resource requirements into a finite number of types, can achieve better than $2/3$ of the maximum throughput for all general resource distributions $F_{R}$.

• 3.

Empirical Evaluation. We evaluate the throughput and queueing delay performance of all algorithms empirically using both synthetic and real traffic traces.

II System Model and Definitions

Cluster Model

We consider a collection of $L$ servers denoted by the set $\mathcal{L}$. For simplicity, we consider a single resource (e.g. memory) and assume that the servers have the same resource capacity. While job resource requirements are in general multi-dimensional (e.g. CPU, memory), it has been observed that memory is typically the bottleneck resource [20, 29]. Without loss of generality, we assume that each server’s capacity is normalized to one.

Job Model

Jobs arrive over time, and the $j$-th job, $j=1,2,\cdots$, requires an amount $R_{j}$ of the (normalized) resource for the duration of its service. The resource requirements $R_{1},R_{2},\cdots$ are i.i.d. random variables with a general cdf (cumulative distribution function) $F_{R}(\cdot):(0,1]\to[0,1]$, with average $\bar{R}=\mathds{E}(R)$. Note that each job should be served by one server and its resource requirement cannot be fragmented among multiple servers. In the rest of the paper, we use the terms job size and job resource requirement interchangeably.

Queueing Model

We assume time is divided into time slots $t=0,1,\cdots$. At the beginning of each time slot $t$, a set ${\mathcal{A}}(t)$ of jobs arrive to the system. We use $A(t)$ to denote the cardinality of ${\mathcal{A}}(t)$. The process $A(t)$, $t=0,1,\cdots$, is assumed to be i.i.d. with a finite mean $\mathds{E}[A(t)]=\lambda$ and a finite second moment.

There is a queue ${\mathcal{Q}}(t)$ that contains the jobs that have arrived up to time slot $t$ and have not been served by any servers yet. At each time slot, the scheduler can select a set of jobs ${\mathcal{D}}(t)$ from ${\mathcal{Q}}(t)$ and place each job in a server that has enough available resource to accommodate it. Specifically, define ${\mathcal{H}}(t)=({\mathcal{H}}_{\ell}(t),\ \ell\in{\mathcal{L}})$, where ${\mathcal{H}}_{\ell}(t)$ is the set of existing jobs in server $\ell$ at time $t$. At any time, the total size of the jobs packed in server $\ell$ cannot exceed its capacity, i.e.,

[TABLE]

Note that jobs may be scheduled out of the order that they arrived, depending on the resource availability of servers. Let $D(t)$ denote the cardinality of ${\mathcal{D}}(t)$ and $Q(t)$ denote the cardinality of ${\mathcal{Q}}(t)$ (the number of jobs in the queue). Then the queue ${\mathcal{Q}}(t)$ and its size $Q(t)$ evolve as

[TABLE]

Once a job is placed in a server, it completes its service after a geometrically distributed amount of time with mean $1/\mu$, after which it releases its reserved resource. This assumption is made to simplify the analysis, and the results can be extended to more general service time distributions (see Section VIII for a discussion).

Stability and Maximum Supportable Workload

The system state is given by $({\mathcal{Q}}(t),{\mathcal{H}}(t))$ which evolves as a Markov process over an uncountably infinite state space 111The state space can be equivalently represented in a complete separable metric space, as we show in Section -B. We investigate the stability of the system in terms of the average queue size, i.e., the system is called stable if $\lim\sup_{t}\mathds{E}[Q(t)]<\infty$. Given a job size distribution $F_{R}$, a workload $\rho:=\lambda/\mu$ is called supportable if there exists a scheduling policy that can stabilize the system for the job arrival rate $\lambda$ and the mean service duration $1/\mu$.

Maximum supportable workload is a workload $\rho^{\star}$ such that any $\rho<\rho^{\star}$ can be stabilized by some scheduling policy, which possibly uses the knowledge of the job size distribution $F_{R}$, but no $\rho>\rho^{\star}$ can be stabilized by any scheduling policy.

III Characterization of Maximum Supportable Workload

In this section, we provide a framework to characterize the maximum supportable workload $\rho^{\star}$ given a job resource distribution $F_{R}$. We start with an overview of the results for a system with a finite set of discrete job types.

III-A Finite-type System

It is easy to characterize the maximum supportable workload when jobs belong to a finite set of discrete types. In this case, it is well known that the supportable workload region is the sum of convex hull of feasible configurations of servers, e.g. [6, 8, 9, 10, 11], which are defined as follows.

Definition 1** (Feasible configuration).**

Suppose there is a finite set of $J$ job types, with job sizes $r_{1},\cdots,r_{J}$. An integer-valued vector $\mathbf{k}=\left(k_{1},\cdots,k_{J}\right)$ is a feasible configuration for a server if it is possible to simultaneously pack $k_{1}$ jobs of of type $1$, $k_{2}$ jobs of type $2$, $\dots$, and $k_{J}$ jobs of type $J$ in the server, without exceeding its capacity. Assuming normalized server’s capacity, any feasible configuration $\mathbf{k}$ must therefore satisfy $\sum_{j=1}^{J}k_{j}r_{j}\leq 1$, $k_{j}\in\mathbb{Z}_{+}$, $j=1,\cdots,J$. We use $\overline{\mathcal{K}}$ to denote the (finite) set of all feasible configurations.

We define $P_{j}\triangleq\mathbb{P}(R=r_{j})$ to be the probability that size of an arriving job is $r_{j}$, $\bm{P}=(P_{1},\cdots,P_{J})$ to be the vector of such arrival probabilities, and $\rho=\lambda/\mu$ to be the workload. We also refer to $\rho\bm{P}$ as the workload vector. As shown in [6, 8, 9, 10], the maximum supportable workload $\rho^{\star}$ is

[TABLE]

where $\rm Conv(\cdot)$ is the convex hull operator, and the vector inequality is component-wise. Also $\sup$ (or $\inf$) denotes supremum (or infimum). Hence any $\rho<\rho^{\star}$ is supportable by some scheduling algorithm, while no $\rho>\rho^{\star}$ can be supported by any scheduling algorithm.

The optimal or near-optimal scheduling policies then basically follow the well-known MaxWeight algorithm [21]. Let $Q_{j}(t)$ be the number of type-$j$ jobs waiting in queue at time $t$. At any time $t$ for each server $\ell$, the algorithm maintains a feasible configuration $\mathbf{k}(t)$ that has the “maximum weight” [8, 9] (or a fraction of the maximum weight [11]), among all the feasible configurations $\overline{\mathcal{K}}$. The weight of a configuration is formally defined below.

Definition 2** (Weight of a configuration).**

Given a queue size vector $\bm{Q}=(Q_{1},\cdots,Q_{J})$, the weight of a feasible configuration $\mathbf{k}=\left(k_{1},\cdots,k_{J}\right)$ is defined as the inner product

[TABLE]

III-B Infinite-type System

In general, the support of the job size distribution $F_{R}$ can span an infinite number of types (e.g., $F_{R}$ can be a continuous function over $(0,1]$). We introduce the notion of virtual queue which is used to characterize the supportable workload for any general distribution $F_{R}$.

Definition 3** (Partition and Virtual Queues (VQs)).**

Define a partition ${X}$ of interval $(0,1]$ as a finite collection of disjoint subsets $X_{j}\subset(0,1]$, $j=1,\cdots,J$, such that $\cup_{j=1}^{J}X_{j}=(0,1]$. If the size of an arriving job belongs to $X_{j}$, we say it is a type-$j$ job. For each type $j$, we consider a virtual queue $\rm{VQ}_{j}$ which contains the type-$j$ jobs waiting in the queue for service.

As in the finite-type system, given a partition $X$, we can define the probability that a type-$j$ job arrives as $P^{(X)}_{j}\triangleq{\mathbb{P}}\left(R\in X_{j}\right)$, the arrival probability vector as $\bm{P}^{(X)}=(P_{1},\cdots,P_{J})$, and the workload vector as $\rho\bm{P}^{(X)}$. However, under this definition, it is not clear what configurations are feasible, since the jobs in the same virtual queue can have different sizes, even though they are called of the same type. Hence we make the following definition.

Definition 4** (Rounded VQs).**

We call $\rm{VQs}$ “upper-rounded $\rm{VQs}$”, if the sizes of type-$j$ jobs are assumed to be $r_{j}=\sup{X_{j}}$, $j=1,\cdots,J$. Similarly, we call them “lower-rounded $\rm{VQs}$”, if the sizes of type-$j$ jobs are assumed to be $r_{j}=\inf{X_{j}}$, $j=1,\cdots,J$.

Given a partition ${X}$, let $\overline{\rho}^{\star}({X})$ and $\underline{\rho}^{\star}({X})$ be respectively the maximum workload $\lambda/\mu$ under which the system with upper-rounded virtual queues and the system with the lower-rounded virtual queues can be stabilized. Since these systems have finite types, these quantities can be described by (4) applied to the corresponding finite-type system with workload vector $\rho\bm{P}^{(X)}$.

Let also $\overline{\rho}^{\star}=\sup_{{X}}\overline{\rho}^{\star}({X})$ and $\underline{\rho}^{\star}=\inf_{{X}}\underline{\rho}^{\star}({X})$ where the supremum and infimum are over all possible partitions of interval $(0,1]$. Next theorem states the result of existence of maximum supportable workload.

Theorem 1**.**

Consider any general (continuous or discontinuous) probability distribution of job sizes with cdf $F_{R}(\cdot)$. Then there exists a unique $\rho^{\star}$ such that $\overline{\rho}^{\star}=\underline{\rho}^{\star}=\rho^{\star}$. Further, given any $\rho<\rho^{\star}$, there is a partition ${X}$ such that the associated upper-rounded virtual queueing system (and hence the original system) can be stabilized.

Proof.

The proof of Theorem 1 has two steps. First, we show that $\overline{\rho}^{\star}({X})\leq\rho^{\star}\leq\underline{\rho}^{\star}({X})$ for any partition $X$. Second, we construct a sequence of partitions, that depend on the job size distribution $F_{R}$, and become increasingly finer, such that the difference between the two bounds vanishes in the limit.

Full proof can be found in Appendix -A. ∎

Theorem 1 implies that there is a way of mapping the job sizes to a finite number of types using partitions, such that by using finite-type scheduling algorithms, the achievable workload approaches the optimal workload as partitions become finer. However, the construction of the partition crucially relies on the knowledge of the job size distribution $F_{R}$, which may not be readily available in practice. Further, the number of feasible configurations grows exponentially large as the number of subsets in the partition increases, which prevents efficient implementation of discrete type scheduling policies (e.g. MaxWeight) in practice.

Next, we focus on low-complexity scheduling algorithms that do not assume the knowledge of $F_{R}$ a priori, and can provide a fraction of the maximum supportable workload $\rho^{\star}$.

IV Best-Fit Based Scheduling

The Best-Fit algorithm was first introduced as a heuristic for Bin Packing problem [22]: given a list of objects of various sizes, we are asked to pack them into bins of unit capacity so as to minimize the number of bins used. Under Best-Fit, the objects are processed one by one and each object is placed in the “tightest” bin (with the least residual capacity) that can accommodate the object, otherwise a new bin is used. Theoretical guarantees of Best-Fit in terms of approximation ratio have been extensively studied under discrete and continuous object size distributions [23, 24, 25].

There are several fundamental differences between the classical bin packing problem and our problem. In the bin packing problem, there is an infinite number of bins available and once an object is placed in a bin, it remains in the bin forever, while in our setting, the number of bins (the equivalent of servers) is fixed, and bins have to be reused to serve new objects from the queues as objects depart from the bins, and new objects arrive to the queue. Next, we describe how Best-Fit (BF) can be adapted for job scheduling in our setting.

IV-A BF-J/S* Scheduling Algorithm*

Consider the following two adaptations of Best-Fit (BF) for job scheduling:

• •

BF-J (Best-Fit from Job’s perspective):

List the jobs in the queue in an arbitrary order (e.g. according to their arrival times). Starting from the first job, each job is placed in the server with the “least residual capacity” among the servers that can accommodate it, if possible, otherwise the job remains in the queue.

• •

BF-S (Best-Fit from Server’s perspective):

List servers in an arbitrary order (e.g. according to their index). Starting from the first server, each server is filled iteratively by choosing the “largest-size job” in the queue that can fit in the server, until no more jobs can fit.

BF-J and BF-S need to be performed in every time slot. Under both algorithms, observe that no further job from the queue can be added in any of the servers. However, these algorithms are not computationally efficient as they both make many redundant searches over the jobs in the queue or over the servers, when there are no new job arrivals to the queue or there are no job departures from some servers. Combining both adaptations, we describe the algorithm below which is computationally more efficient.

• •

BF-J/S (Best-Fit from Job’s and Server’s perspectives):

It consists of two steps:

Perform BF-S only over the list of servers that had job departures during the previous time slot. Hence, some jobs that have not been scheduled in the previous time slot or some of newly arrived jobs are scheduled in servers.

• 2)

Perform BF-J only over the list of newly arrived jobs that have not been scheduled in the first step.

IV-B Throughput Guarantee

The following theorem characterizes the maximum supportable workload under $\mathrm{BF}$-J/S.

Theorem 2**.**

Suppose any job has a minimum size $u$. Algorithm $\mathrm{BF}$-J/S can achieve at least $\frac{1}{2}$ of the maximum supportable workload $\rho^{\star}$, for any $u>0$.

Proof.

We present a sketch of the proof here and provide the full proof in Appendix -B. The proof uses Lyapunov analysis for Markov chain $({\mathcal{Q}}(t),{\mathcal{H}}(t))$ whose state includes the jobs in queues and servers and their sizes. The Markov chain can be equivalently represented in a Polish space and we prove its positive recurrence using a multi-step Lyapunov technique [30] and properties of $\mathrm{BF}$-J/S. We use a Lyapunov function which is the sum of sizes of all jobs in the system at time $t$. Given that jobs have a minimum size, keeping the total size bounded implies the number of jobs is also bounded.

The key argument in the proof is that by using $\mathrm{BF}$-J/S as described, all servers operate in more than “half full”, most of the time, when the total size of jobs in the queue becomes large. To prove this, we consider two possible cases:

• •

*The total size of jobs in queue with size $\leq\frac{1}{2}$ is large:

*In this case, these jobs will be scheduled greedily whenever the server is more than half empty. Hence, the server will always become more than half full until there are no such jobs in the queue.

• •

*The total size of jobs in queue with size $>\frac{1}{2}$ is large:

*If at time slot $t$, a job in server is not completed, it will complete its service within the next time slot with probability $\mu$, independently of the other jobs in the server. Given the minimum job size, the number of jobs in a server is bounded so it will certainly empty in a finite time. Once this happens, jobs will be scheduled starting from the largest-size one, and the server will remain more than half full, as long as there is a job of size more than $1/2$ to replace it. This step is true because of the way Best-Fit works and does not hold for other bin packing algorithms like First-Fit.

See the full proof in Appendix -B. ∎

V Partition Based Scheduling

$\mathrm{BF}$-J/S demonstrated an algorithm that can achieve at least half of the maximum workload $\rho^{\star}$, without relying on any partitioning of jobs into types. In this section, we propose partition based scheduling algorithms that can provably achieve a larger fraction of the maximum workload $\rho^{\star}$, using a universal partitioning into a small number of types, without the knowledge of job size distribution $F_{R}$.

V-A Universal Partition and Associated Virtual Queues

Consider a partition of the interval $(1/{2^{J}},1]$ into the following $2J$ subintervals:

[TABLE]

We refer to this partition as partition $I$, where $J>1$ is a fixed parameter to be determined shortly. The odd and even subintervals in $I$ are geometrically shrinking. Figure 2 gives a visualization of this partition.

Jobs in queue are divided among virtual queues (Definition 3) according to partition $I$. Specifically, when the size of a job falls in the subinterval $I_{j}$, $j=0,\cdots,2J-1$, we say this job is of type $j$ and it is placed in a virtual queue $\mathrm{VQ}_{j}$, without rounding its size. Moreover, jobs whose sizes fall in $(0,1/2^{J}]$ are placed in the last virtual queue $\mathrm{VQ}_{2J-1}$, and their sizes are rounded up to $1/2^{J}$.

We use $Q_{j}(t)$ to denote the size (cardinality) of $\mathrm{VQ}_{j}$ at time $t$ and use $\mathbf{Q}(t)$ to denote the vector of all VQ sizes.

V-B VQS* (Virtual Queue Scheduling) Algorithm*

To describe the VQS algorithm, we define the following reduced set of configurations which are feasible for the system of upper-rounded $\mathrm{VQ}$s (Definition 4)

Definition 5** (Reduced feasible configuration set).**

The reduced feasible configuration set, denoted by ${\mathcal{K}}^{(J)}_{RED}$, consists of the following $4J-4$ configurations:

[TABLE]

where $\mathbf{e}_{j}\in\mathbb{Z}^{2J}$ denotes the basis vector with a single job of type $j$, $j=0,\cdots,2J-1$, and zero jobs of any other types.

Note that each configuration $\mathbf{k}=(k_{0},\cdots,k_{2J-1})\in{\mathcal{K}}^{(J)}_{RED}$ either contains jobs from only one $\mathrm{VQ}_{j}$, $j=0,\cdots,2J-1$, or contains jobs from $\mathrm{VQ}_{1}$ and one other $\mathrm{VQ}_{j}$.

The “VQS algorithm” consists of two steps: (1) setting active configuration, and (2) job scheduling using the active configuration:

Setting active configuration:

Under $\mathrm{VQS}$, every server $\ell\in{\mathcal{L}}$ has an active configuration $\mathbf{k}^{\ell}(t)\in{\mathcal{K}}^{(J)}_{RED}$ which is renewed only when the server becomes empty. Suppose time slot $\tau^{\ell}_{i}$ is the $i$-th time that server $\ell$ is empty (i.e., it has been empty or all its jobs depart during this time slot). At this time, the configuration of server $\ell$ is set to the max weight configuration among the configurations of $\mathcal{K}^{(J)}_{RED}$ (Definitions 2 and 5), i.e.,

[TABLE]

The active configuration remains fixed until the next time $\tau^{\ell}_{i+1}$ that the server becomes empty gain, i.e.,

[TABLE]

• 2.

Job scheduling:

Suppose the active configuration of server $\ell$ at time $t$ is $\mathbf{k}\in{\mathcal{K}}^{(J)}_{RED}$. Then the server schedules jobs as follows:

1. (i)

If $k_{1}=1$, the server reserves $2/3$ of its capacity for serving jobs from $\mathrm{VQ}_{1}$, so it can serve at most one job of type $1$ at any time. If there is no such job in the server already, it schedules one from $\mathrm{VQ}_{1}$. 2. (ii)

Any configuration $\mathbf{k}\in{\mathcal{K}}^{(J)}_{RED}$ has at most one $k_{j}>0$ other than $k_{1}$. The server will schedule jobs from the corresponding $\mathrm{VQ}_{j}$, starting from the head-of-the-line job in $\mathrm{VQ}_{j}$, until no more jobs can fit in the server. The actual number of jobs scheduled from $\mathrm{VQ}_{j}$ in the server could be more than $k_{j}$ depending on their actual sizes.

Remark 1*.*

The reason for choosing times $\tau_{i}^{\ell}$ to renew the configuration of server $\ell$ is to avoid possible preemption of existing jobs in server (similar to [6, 9]). Also note that active configurations in ${\mathcal{K}}^{(J)}_{RED}$ are based on upper-rounded $\mathrm{VQ}$s. Since jobs are not actually rounded in $\mathrm{VQ}$s, the algorithm can schedule more jobs than what specified in the configuration.

V-C Throughput Guarantee

The $\mathrm{VQS}$ algorithm can provide a stronger throughput guarantee than BF-J/S. A key step to establish the throughput guarantee is related to the property of configurations in the set $\mathcal{K}^{(J)}_{RED}$, which is stated below.

Proposition 1**.**

Consider any partition $X$ which is a refinement of partition $I$, i.e., any subset of $X$ is contained in an interval $I_{j}$ in (6). Given any set of jobs with sizes in $(1/2^{J},1]$ in the queue, let $\bm{Q}$ and $\mathbf{Q}^{(X)}$ be the corresponding vector of $\mathrm{VQ}$ sizes under partition $I$ and partition $X$. Then there is a configuration $\mathbf{k}\in\mathcal{K}_{RED}^{(J)}$ such that

[TABLE]

where ${\mathcal{K}}^{(X)}$ is the set of “all” feasible configurations based on upper-rounded $\mathrm{VQ}$s for partition $X$.

Proof.

For simplicity of description, consider $X$ to be a partition of $(1/2^{J},1]$ into $N$ subintervals $(\xi_{i-1},\xi_{i}]$, $i=1,\cdots,N$. The proof arguments are applicable to any other types of subsets of $(1/2^{J},1]$ as long as each subset is contained in an interval $I_{j}$ in (6).

Given the proposition’s assumption, we can define sets $Z_{j}$, $j=0,\cdots,2J-1$, such that $i\in Z_{j}$ iff $\xi_{i}\in I_{j}$. Any job in $\mathrm{VQ}^{(X)}_{i}$, $i\in Z_{j}$, under partition $X$, belongs to $\mathrm{VQ}_{j}$ under partition $I$, therefore

[TABLE]

Let $\langle{\mathbf{k}}^{(X)},\mathbf{Q}^{(X)}\rangle=U$. Note that in any feasible configuration ${\mathbf{k}}^{(X)}\in{\mathcal{K}}^{(X)}$, $\sum_{i\in Z_{1}}{k}^{(X)}_{i}$ can be [math] or $1$. To show (10), we consider these two cases separately:

Case 1. $\sum_{i\in Z_{1}}{k}^{(X)}_{i}=0$:

We claim at least one of the following inequalities is true

[TABLE]

If the claim is not true, we reach a contradiction because

[TABLE]

where $(a)$ is due to the assumption that none of inequalities in (12) hold and using the fact that $Q_{i}^{(X)}\leq Q_{j}$ if $i\in Z_{j}$, $(b)$ is due to the fact $\xi_{i}>\inf{I_{j}}$ if $i\in Z_{j}$, and $(c)$ is due to the server’s capacity constraint for feasible configuration ${\mathbf{k}}^{(X)}$.

Hence, one of the inequalities in (12) must be true. If $Q_{2m}\geq 2U/3\times 1/2^{m}$ for some $m=0,\cdots,J-1$, then (10) is true for configuration ${\mathbf{k}}=2^{m}\mathbf{e}_{2m}$, while if $Q_{2m+1}\geq U/2\times 1/2^{m}$ for some $m=1,\cdots,J-1$, then (10) is true for configuration ${\mathbf{k}}=3\cdot 2^{m-1}\mathbf{e}_{2m+1}$.

Case 2. $\sum_{i\in Z_{1}}{k}^{(X)}_{i}=1$:

In this case $\sum_{i\in Z_{0}}{k}^{(X)}_{i}=0$. We further distinguish three cases for $Q_{1}$ compared to $U$: $Q_{1}\geq\frac{2U}{3}$, $\frac{2U}{3}>Q_{1}\geq\frac{U}{2}$, and $\frac{U}{2}>Q_{1}$. In the second case, we further consider two subcases depending on $\sum_{i\in Z_{2}}k_{i}^{(X)}$ being [math] or $1$. Here we present the analysis of the case $\frac{2U}{3}>Q_{1}\geq\frac{U}{2}$, $\sum_{i\in Z_{2}}k_{i}^{(X)}=0$. The rest of the cases are either trivial or follow a similar argument and can be found in Appendix -C.

Let $U^{\prime}:=U-Q_{1}$, then one of the following inequalities has to be true

[TABLE]

otherwise, we reach a contradiction, similar to Case 1, i.e.,

[TABLE]

where $(a)$ is due to the assumption that none of inequalities in (13) hold, and $(b)$ is due to the constraint that the jobs in the configuration $\mathbf{k}^{(X)}$, other than the job types in $Z_{1}$, should fit in a space of at most $1/2$ (the rest is occupied by a job of size at least $1/2$). It is then easy to verify that if $Q_{2m}\geq U^{\prime}/(3\cdot 2^{m-2})$ for some $m\in[2,\cdots J-1]$ then inequality (10) is true for configuration $\mathbf{e}_{1}+\lfloor 2^{m}/3\rfloor\mathbf{e}_{2m}$ as

[TABLE]

Similarly if $Q_{2m+1}\geq U^{\prime}/(3\cdot 2^{m-1})$ for some $m\in[1,\cdots J-1]$ then inequality (10) is true for configuration $\mathbf{e}_{1}+2^{m-1}\mathbf{e}_{2m+1}$ as

[TABLE]

∎

The following theorem states the result regarding throughput of $\mathrm{VQS}$.

Theorem 3**.**

$\mathrm{VQS}$* achieves at least $\frac{2}{3}$ of the optimal workload $\rho^{\star}$, if arriving jobs have a minimum size of at least $1/2^{J}$.*

Proof.

The proof uses Proposition 1 and multi-step Lyapunov technique (Theorem 1 of [30]), The proof can be found in Appendix -D. ∎

Hence, given a minimum job’s resource requirement $u>0$, $J$ has to be chosen larger than $\log_{2}(1/u)$ in the VQS algorithm. Theorem 3 is not trivial as it implies that by scheduling under the configurations in ${\mathcal{K}}^{(J)}_{RED}$ (7), on average at most $1/3$ of each server’s capacity will be underutilized because of capacity fragmentations, irrespective of the job size distribution $F_{R}$. Moreover, using ${\mathcal{K}}^{(J)}_{RED}$ reduces the search space from $O(\mathrm{Exp}(J))$ configurations to only $4J-4$ configurations, while still guaranteeing $2/3$ of the optimal workload $\rho^{\star}$.

A natural and less dense partition could be to only consider the cuts at points $1/2^{j}$ for $j=0,\cdots,J$. This creates a partition consisting of $J$ subintervals $\widetilde{I}_{j}=I_{2j}\cup I_{2j+1}$. The convex hull of only the first $J$ configurations of $\mathcal{K}^{(J)}_{RED}$ contains all feasible configurations of this partition. Using arguments similar to proof of Theorem 3, we can show that this partition can only achieve $1/2$ of the optimal workload $\rho^{\star}$. One might conjecture that by refining partition $I$ (6) or using different partitions, we can achieve a fraction larger than $2/3$ of the optimal workload $\rho^{\star}$; however, if the partition is agnostic to the job size distribution $F_{R}$, refining the partition or using other partitions does not help. We state the result in the following Proposition.

Proposition 2**.**

Consider any partition $X$ consisting of a finite number of disjoint sets $X_{j}$, $\cup_{j=1}^{N}X_{j}=(0,1]$. Any scheduling algorithm that maps the sizes of jobs in $X_{j}$ to $r_{j}=\sup{X_{j}}$ (i.e., schedules based on upper-rounded $\mathrm{VQ}$s) cannot achieve more than $2/3$ of the optimal workload $\rho^{\star}$ for all $F_{R}$.

Proof.

See Appendix -E for the proof. ∎

Theorem 3 assumed that there is a minimum resource requirement of at least $1/2^{J}$. This assumption can be relaxed as stated in the following corollary.

Corollary 1**.**

Consider any general distribution of job sizes $F_{R}$. Given any $\epsilon>0$, choose $J$ to be the smallest integer such that $F_{R}(1/2^{J})<\epsilon$, then the $\mathrm{VQS}$ algorithm achieves at least $(1-\epsilon)\frac{2}{3}$ of the optimal workload $\rho^{\star}$.

Proof.

See Appendix -F for the proof. ∎

Since the complexity of $\mathrm{VQS}$ algorithm is linear on $J$, it is worth increasing it if that improves maximum throughput. An implication of Corollary 1 is that this can be done adaptively as estimate of $F_{R}$ becomes available.

VI $\mathrm{VQS}$-$\mathrm{BF}$: Incorporating Best-Fit in $\mathrm{VQS}$

While the $\mathrm{VQS}$ algorithm achieves in theory a larger fraction of the optimal workload than $\mathrm{BF}$-J/S, it is quite inflexible compared to $\mathrm{BF}$-J/S, as it can only schedule according to certain job configurations and the time until configuration changes may be long, hence might cause excessive queueing delay. We introduce a hybrid $\mathrm{VQS}$-$\mathrm{BF}$ algorithm that achieves the same fraction of the optimal workload as $\mathrm{VQS}$, but in practice has the flexibility of $\mathrm{BF}$. The algorithm has two steps similar to $\mathrm{VQS}$: Setting the active configuration is exactly the same as the first step in $\mathrm{VQS}$, but it differs in the way that jobs are scheduled in the second step. Suppose the active configuration of server $\ell$ at time $t$ is $\mathbf{k}\in{\mathcal{K}}^{(J)}_{RED}$, then:

• (i)

If $k_{1}=1$, the server will try to schedule the largest-size job from $\mathrm{VQ}_{1}$ that can fit in it. This may not be possible because of jobs already in the server from previous time slots. Unlike $\mathrm{VQS}$, when jobs from $\mathrm{VQ}_{1}$ are scheduled, they reserve exactly the amount of resource that they require, and no amount of resource is reserved if no job from $\mathrm{VQ}_{1}$ is scheduled.

• (ii)

Any configuration $\mathbf{k}\in{\mathcal{K}}^{(J)}_{RED}$ has at most one $k_{j}>0$ other than $k_{1}$. Server attempts to schedule jobs from the corresponding $\mathrm{VQ}_{j}$, starting from the largest-size job that can fit in it. Depending on prior jobs in server, this procedure will stop when either the number of jobs from $\mathrm{VQ}_{j}$ in the server is at least $k_{j}$, or $\mathrm{VQ}_{j}$ becomes empty, or no more jobs from $\mathrm{VQ}_{j}$ can fit in the server.

• (iii)

Server uses BF-S to possibly schedule more jobs in its remaining capacity from the remaining jobs in the queue.

The performance guarantee of $\mathrm{VQS}$-$\mathrm{BF}$ is the same as that of $\mathrm{VQS}$, as stated by the following theorem.

Theorem 4**.**

If jobs have a minimum size of at least $1/2^{J}$, $\mathrm{VQS}$-$\mathrm{BF}$ achieves at least $\frac{2}{3}\rho^{\star}$. Further, for a general job-size distribution $F_{R}$, if $J$ is chosen such that $F_{R}(1/{2^{J}})<\epsilon$, then $\mathrm{VQS}$-$\mathrm{BF}$ achieves at least $(1-\epsilon)\frac{2}{3}\rho^{\star}$.

Proof.

The proof is similar to that of Theorem 3. However, the difference is that the configuration of a server (jobs residing in a server) is not predictable, unless it empties, at which point we can ensure that it will schedule at least the jobs in the max weight configuration assigned to it, for a number of time slots proportional to the total queue length. The fact that the scheduling starts from the largest job in a virtual queue is important for this assertion, similarly to the importance of Best Fit in the proof of Theorem 2.

In case $J$ is chosen such that $F_{R}(1/2^{J})<\epsilon$, the arguments in Corollary 1 are applicable here as well.

The full proof is provided in Appendix -G. ∎

VII Evaluation Results

VII-A Synthetic Simulations

VII-A1 Instability of $\mathrm{VQS}$ and tightness of $2/3$ bound.

We first present an example that shows the tightness of the $2/3$ bound on the achievable throughput of $\mathrm{VQS}$. Consider a single server where jobs have two discrete sizes $0.4$ and $0.6$. The jobs arrive according to a Poisson process with average rate $0.014$ jobs per time slot and with each job size being equally likely. Each job completes its service after a geometric number of time slots with mean $100$. Observe that by using configuration $(1,1)$ (i.e., 1 spot per job type) any arrival rate below $0.02$ jobs per time slot is supportable. This is not the case though for $\mathrm{VQS}$ that schedules based on configurations ${\mathcal{K}}^{(J)}_{RED}$, so it can either schedule two jobs of size $0.4$ or one job of size $0.6$. This results in $\mathrm{VQS}$ to be unstable for any arrival rate greater than $2/3\times 0.02\approx 0.013$. Both of the other proposed algorithms, BF-J/S and VQS-BF, circumvent this problem. The evolution of the total queue size is depicted in Figure 3(a)

VII-A2 Instability of $\mathrm{BF}$-J/S

We present an example that shows BF-J/S is not stable while VQS can stabilize the queues. Consider a single server of capacity $10$ and that job sizes are sampled from two discrete values $2$ and $5$. The jobs arrive according to a Poisson process with average rate $0.0306$ jobs per time slot, and job of size $2$ are twice as likely to appear than jobs of size $5$. Each job completes its service after a fixed number of $100$ time slots . The evolution of the queue size is depicted in Figure 3(b). This shows an example where $\mathrm{VQS}$ is stable, while both $\mathrm{BF}$-J/S and $\mathrm{VQS}$-$\mathrm{BF}$ are not.

To justify the behavior of the latter two algorithms, we notice that under both the server is likely to schedule according to the configuration $(2,1)$ that uses two jobs of size $2$ and one of size $5$. Because of fixed service times, jobs that are scheduled at different time slots, will also depart at different time slots. Hence, it is possible that the scheduling algorithm will not allow the configuration $(2,1)$ to change, unless one of the queues empties. However, there is a positive probability that the queues will never get empty since the expected arrival rate is more than the departure rate for both types. The arrival rate vector is $\bm{\lambda}=(0.0204,0.0102)$ while the departure rate vector $\bm{\mu}=(0.02,0.01)$.

$\mathrm{VQS}$ on the other hand will always schedule either five jobs of size $2$ or two of size $5$. The average departure rate in the first configuration is $\bm{\mu}_{1}=(0.05,0)$, and in the second configuration $\bm{\mu}_{2}=(0,0.02)$. The arrival vector is in convex hull of these two vectors as $\bm{\lambda}<4/9\bm{\mu}_{1}+5/9\bm{\mu}_{2}$ and therefore is supportable.

VII-A3 Comparison using Uniform distributions

To better understand how the algorithms operate under a non-discrete distribution of job sizes, we test them using a uniform distribution. We choose $L=5$ servers, each with capacity $1$. We perform two experiments: the job sizes are distributed uniformly over $[0.01,0.19]$ in the first experiment and uniformly over $[0.1,0.9]$ in the second one. Hence $\bar{R}$ is $0.1$ in the first experiment and $0.5$ in the second one.

The service time of each job is geometrically distributed with mean $1/\mu=100$ time slots so departure rate is $\mu=0.01$. The job arrivals follow a Poisson process with rate $\mu L/\bar{R}\times$ jobs per time slot (and thus $\rho=\alpha L/\bar{R}$), where $\alpha$ is a constant which we refer to as “traffic intensity” and $L=5$ is the number of servers in these experiments. A value of $\alpha=1$ is a bound on what is theoretically supportable by any algorithm. In each experiment, we change the value of $\alpha$ in the interval $[0.85,0.99]$. The results are depicted in Figure 5.

Overall we can see that $\mathrm{VQS}$ is worse than other two algorithms in terms of average queue size. Algorithms $\mathrm{BF}$-J/S and $\mathrm{VQS}$-$\mathrm{BF}$ look comparable in the first experiment for traffic intensities up to $0.95$, otherwise $\mathrm{BF}$-J/S has a clear advantage. An interpretation of results is that $\mathrm{VQS}$ and $\mathrm{VQS}$-$\mathrm{BF}$ have particularly worse delays when the average job size is large, since large jobs cannot be scheduled most of the time, unless they are part of the active configuration of a server. That makes these algorithm less flexible compared to $\mathrm{BF}$-J/S for scheduling such jobs.

VII-B Google Trace Simulations

We test the algorithms using a traffic trace from a Google cluster dataset [4]. We performed the following preprocessing on the dataset:

• •

We filtered the tasks and kept those that were completed without interruptions/errors.

• •

All tasks had two resources, CPU and memory. To convert them to a single resource, we used the maximum of the two requirements which were already normalized in $[0,1]$ scale.

• •

The servers had two resources, CPU and memory, and change over time as they a updated or replaced. For simplicity, we consider a fixed number of servers, each with a single resource capacity normalized to $1$.

• •

Trace events are in microsec accuracy. In our algorithms, we make scheduling decisions every $100$ msec.

• •

We used a part of the trace corresponding to about a million task arrivals spanning over approximately 1.5 days.

We compare the algorithms proposed in this work and a baseline based on Hadoop’s default FIFO scheduler [1]. While the original FIFO scheduler is slot-based [18], the FIFO scheduler considered here schedules jobs in a FIFO manner, by attempting to pack the first job in the queue to the first server that has sufficient capacity to accommodate the job. We refer to this scheme as FIFO-FF which should perform better than the slot-based FIFO, since it packs jobs in servers (using First-Fit) instead of using predetermined slots.

We scale the job arrival rate by multiplying the arrival times of tasks by a factor $\beta$. We refer to $1/\beta$ as “traffic scaling” because larger $1/\beta$ implies that more jobs arrive in a time unit. The number of servers was fixed to $1000$, while traffic scaling varied from $1$ to $1.6$. The average queue sizes are depicted in Figure 5. As traffic scaling increases, $\mathrm{BF}$-J/S and $\mathrm{VQS}$-$\mathrm{BF}$ have a clear advantage over the other schemes, with $\mathrm{VQS}$-$\mathrm{BF}$ also yielding a small improvement in the queue size compared to $\mathrm{BF}$-J/S. It is interesting that $\mathrm{VQS}$-$\mathrm{BF}$ has a consistent advantage over $\mathrm{BF}$-J/S at higher traffic, albeit small, although both algorithms are greedy in the way that they pack jobs in servers.

VIII Discussion and Open Problems

In this work, we designed three scheduling algorithms for jobs whose sizes come from a general unknown distribution. Our algorithms achieved two goals: keeping the complexity low, and providing throughput guarantees for any distribution of job sizes, without actually knowing the prior distribution.

Our results, however, are lower bounds on the performance of the algorithms and simulation results show that the algorithms $\mathrm{BF}$-J/S and $\mathrm{VQS}$-$\mathrm{BF}$ may support workloads that go beyond their theoretical lower bounds. It remains as an open problem to tighten the lower bounds or construct upper bounds that approach the lower bounds.

In addition, we made some simplifying assumptions in our model but results indeed hold under more general models. One of the assumptions was that the servers are homogeneous. $\mathrm{BF}$-J/S and our analysis can indeed be easily applied without this assumption. For $\mathrm{VQS}$ and $\mathrm{VQS}$-$\mathrm{BF}$, the scheduling can be also applied without changes when servers have resources that differ by a power of $2$ which is a common case. As a different approach, we can maintain different sets of virtual queues, one set for each type of servers.

Another assumption was that service durations follow geometric distribution. This assumption was made to simplify the proofs, as it justifies that a server will empty in a finite expected time by chance. Since this may not happen under general service time distributions (e.g. one may construct adversarial service durations that prevent server from becoming empty), in all our algorithms we can incorporate a stalling technique proposed in [11] that actively forces a server to become empty by preventing it from scheduling new jobs. The decision to stall a server is made whenever server operates in an “inefficient” configuration. For $\mathrm{BF}$-J/S that condition is when the server is less than half full, while for $\mathrm{VQS}$ and $\mathrm{VQS}$-$\mathrm{BF}$, is when the weight of configuration of a server is far from the maximum weight over ${\mathcal{K}}^{(J)}_{RED}$.

Finally we based our scheduling decisions on a single resource. Depending on workload, this may cause different levels of fragmentation, but resource requirements will not be violated if resources of jobs are mapped to the maximum resource (e.g. like our preprocessing on Google trace data). A more efficient approach is to extend $\mathrm{BF}$-J/S to multi-resource setting, by considering a Best-Fit score as a linear combination of per-resource occupancies. It has been empirically shown in  [14] that the inner product of the vector of the job’s resource requirements and the vector of server’s occupied resources is a good candidate. We leave the theoretical study of scheduling jobs with multi-resource distribution as a future research.

-A Proof of Theorem 1

We first prove the theorem for continuous probability distributions, then show how to handle discontinuities in general distributions.

Define partition ${X}^{(n)}$ to be the collection of $m_{n}=2^{n+1}$ intervals $X_{i}^{(n)}:(\xi_{i-1}^{(n)},\xi_{i}^{(n)}]$, such that $\xi_{0}^{(n)}=0$, $\xi_{2^{n+1}}^{(n)}=1$, and $F_{R}(\xi_{i}^{(n)})=\frac{i}{2^{n+1}}$, for $i=1,\cdots,2^{n+1}-1$. This construction is possible since $F_{R}$ is an increasing continuous function, hence $F_{R}(x)=c$ always has a unique solution $x\in[0,1]$ if $c\in[0,1]$. Subsequently,

[TABLE]

In the rest of the proof, we use the following notations. $\mathbf{1}_{N}$ is a vector of all ones of length $N$. $\mathbf{e}_{i}$ is a basis vector with value $1$ in its $i$th entry and [math] elsewhere. $\rho^{\star}$ is the maximum workload that can be supported by any algorithm with the given distribution of job sizes $F_{R}$. Also $\overline{\rho}^{\star}({X}^{(n)})$ is the maximum supportable workload when upper-rounded queues are used under partition ${X}^{(n)}$ and $\underline{\rho}^{\star}({X}^{(n)})$ the respective maximum workload, when lower-rounded queues are used.

Under upper-rounded or lower-rounded virtual queues, job sizes have $2^{n+1}$ discrete values, which makes the problem equivalent with scheduling $2^{n+1}$ job types. For notational purpose, we define the workload vector $\bm{\rho}=\rho\bm{\pi}$ where $\bm{\pi}=\left(\pi_{i},i=1,\cdots,m_{n}\right)$ is the vector of probabilities of the types and $\rho$ is the workload of the system. Hence, under upper-rounded queues, the workload vector is $\bm{\rho}_{1}=\frac{\overline{\rho}({X}^{(n)})}{2^{n+1}}\mathbf{1}_{m_{n}}$.

Using lower-rounded virtual queues is equivalent to using upper-rounded virtual queues, but the workload vector is instead $\bm{\rho}_{2}=\frac{\underline{\rho}({X}^{(n)})}{2^{n+1}}(\mathbf{1}_{m_{n}}-\mathbf{e}_{m_{n}})$. This is because we can essentially ignore the jobs whose sizes are rounded to 0 and no job size can be rounded to $1$.

With discrete job types whose sizes are $\xi^{(n)}_{i}$ for $i=1,\ldots m_{n}$, we can extend the notion of feasible configuration in Definition 1 to jobs of a continuous distribution. In this case, configuration $\mathbf{k}$ is a $m_{n}$-dimensional vector and the set of feasible configurations is denoted by $\mathcal{\bar{K}}$. The workload is supportable if it is in the convex hull of set of feasible configurations, as in (4). With the upper-rounded queues, and given all $L$ servers are the same and have the same set of feasible configurations, there should exist $p_{\mathbf{k}}\geq 0$, $\mathbf{k}\in\overline{\mathcal{K}}$, such that

[TABLE]

Similarly, with lower-rounded virtual queues, there should exist $q_{\mathbf{k}}\geq 0$, $\mathbf{k}\in\overline{\mathcal{K}}$, such that

[TABLE]

Jobs of size $1$ can be served only by configuration $\mathbf{e}_{m_{n}}$, i.e., server is filled with a single job of size $1$. Hence we can split the first equation of (16) into

[TABLE]

Also given that with lower-rounded virtual queues there are no jobs of size $1$, the first equation of (17) becomes:

[TABLE]

Now if we replace $\overline{\rho}({X}^{(n)})$ with $\overline{\rho}^{\star}({X}^{(n)})$ and $\underline{\rho}({X}^{(n)})$ with $\underline{\rho}^{\star}({X}^{(n)})$, inequalities in (18) and (19) must hold with equality by definition, i.e.,

[TABLE]

Notice that the direction of vectors $\sum_{\mathbf{k}\in\overline{\mathcal{K}}\setminus\{\mathbf{e}_{m_{n}}\}}p_{\mathbf{k}}\mathbf{k}$ and $\sum_{\mathbf{k}\in\overline{\mathcal{K}}\setminus\{\mathbf{e}_{m_{n}}\}}q_{\mathbf{k}}\mathbf{k}$ is the same. Given a solution $p_{\mathbf{k}}$, $\mathbf{k}\in\overline{\mathcal{K}}$, to (20), it is sufficient to choose $q_{\mathbf{k}}$ to be proportional to $p_{\mathbf{k}}$. Assuming $p_{\mathbf{k}}$ and $q_{\mathbf{k}}$ are proportional, and noting that by definition,

[TABLE]

it should hold that $p_{\mathbf{k}}=\left(1-p_{\mathbf{e}_{m_{n}}}\right)q_{\mathbf{k}}$ and hence $\overline{\rho}^{\star}({X}^{(n)})=\left(1-p_{\mathbf{e}_{m_{n}}}\right)\underline{\rho}^{\star}({X}^{(n)})$. From the second equation of (18) we get $\overline{\rho}^{\star}({X}^{(n)})=2^{n+1}Lp_{\mathbf{e}_{m_{n}}}$. Using these two equations, we can write $\underline{\rho}^{\star}({X}^{(n)})$ as a function of $\overline{\rho}^{\star}({X}^{(n)})$, i.e.,

[TABLE]

which implies

[TABLE]

By construction, $\underline{\rho}^{\star}({X}^{(n)})$ is a decreasing sequence in $i$, so it is bounded from above by $\underline{\rho}^{\star}({X}^{(0)})$ and from below by [math]. Similarly $\overline{\rho}^{\star}({X}^{(n)})$ is an increasing sequence with the same bounds. By the monotone convergence theorem, the limits of both exist and by construction $\underline{\rho}^{\star}({X}^{(n)})-\overline{\rho}^{\star}({X}^{(n)})>0$. Then assuming $n$ is large enough so that $2^{n+1}L>\underline{\rho}^{\star}({X}^{(0)})$,

[TABLE]

and $\lim_{n\to\infty}\overline{\rho}^{\star}({X}^{(n)})=\overline{\rho}^{\star}=\lim_{n\to\infty}\underline{\rho}^{\star}({X}^{(n)})=\underline{\rho}^{\star}=\rho^{\star}.$

General Probability Distribution: The proof for a general probability distribution follows similar arguments but the sequence of partitions has to change to include points of discontinuity. Specifically, let the points of discontinuity be $x_{j}$ and their probability $P_{j}\equiv\mathds{P}(r=x_{j})$, $0<x_{j}\leq 1$, $j\in\mathds{N}$ (since $F_{R}$ is monotone, we know that the number of discontinuities is countable). Define the partial sum of probabilities $S_{N}\equiv\sum_{j=0}^{N}P_{j}$. Sequence of partial sums is certainly convergent, as it is bounded above by $1$ and is increasing, so let its limit be $\lim_{N\to\infty}S_{N}=P.$ By the convergence property, there exists $M_{n}$ such that

[TABLE]

Following this, we can define the continuous part of $F_{R}$ to be

[TABLE]

By definition we have $F_{R}^{(c)}(1)=1-P$. As a result, we can define, similarly to the proof of continuous case, the $2^{n+1}$ intervals $X_{i}^{(n)}:(\xi_{i-1}^{(n)},\xi_{i}^{(n)}]$ with $\xi_{0}^{(n)}=0$, $\xi_{2^{n+1}}^{(n)}=1$, and $F_{R}^{(c)}(\xi_{i}^{(n)})=\frac{i(1-P)}{2^{n+1}}$ for $i=1,\ldots,2^{n+1}-1$. Compared to the proof of continuous case though, we need to change the partition ${X}^{(n)}$ to be the following $2^{n+1}+M_{n}+2$ sets

[TABLE]

The virtual queue corresponding to set $\left\{x_{i}:i>M_{n}\right\}$ is different from the rest in the way that rounding is done when working with upper-rounded or lower-rounded virtual queues. In the former case, we round up its jobs to $1$, and in the latter we round down its jobs to [math]. While this diverges from Definition 4, it is convenient to round the job sizes in this special queue to $1$ and [math] rather than to $\sup$ and $\inf$.

Next we use symbol $\|$ to describe concatenation of two vectors, e.g. if $\mathbf{x}=(x_{1},\cdots x_{M})$ and $\mathbf{y}=(y_{1},\cdots y_{N})$ then $(\mathbf{x}\|\mathbf{y})=(x_{1},\cdots x_{M},y_{1},\cdots y_{N})$.

The configurations will now have $m_{n}=2^{n+1}+M_{n}+1$ types. When upper-rounded virtual queues are used, the workload vector is

[TABLE]

and when lower-rounded virtual queues are used,

[TABLE]

The vectors $\bm{\rho}_{1}$ and $\bm{\rho}_{2}$ have the same direction if one ignores the last index that corresponds to job types of size $1$. If $m_{n}$ is that index, with similar arguments as in the proof of continuous case, we can conclude $\overline{\rho}\left({X}^{(n)}\right)=(1-p_{\mathbf{e}_{m_{n}}})\underline{\rho}\left({X}^{(n)}\right)$ and $\overline{\rho}\left({X}^{(n)}\right)=\frac{Lp_{\mathbf{e}_{m_{n}}}}{\frac{1-P}{2^{n+1}}+(P-S_{M_{n}})}\geq 2^{n}Lp_{\mathbf{e}_{m_{n}}}$, and, equivalently to (23),

[TABLE]

The rest of the arguments is the same as in the continuous distribution case.

-B Proof of Theorem 2

The state of our system at time slot $t$ is

[TABLE]

Recall that $\mathcal{Q}(t)$ is the set of jobs in queue and its cardinality is $|\mathcal{Q}(t)|=Q(t)$, and $\bm{\mathcal{H}}(t)=(\mathcal{H}_{\ell}(t),\ell\in\mathcal{L})$ is the set of scheduled jobs in servers $\mathcal{L}$. We will denote the set of all feasible states as $\mathcal{S}$.

An equivalent description of the state assuming all job sizes are in $(0,1]$ is through a cumulative function of job sizes. For a set of jobs (job sizes) $\mathcal{A}$, define a function $f_{\mathcal{A}}:[0,1]\to\mathds{N}$ as

[TABLE]

If we know $f_{\mathcal{A}}(s)$ for any $s\in(0,1]$ then we also know $\mathcal{A}$. To describe ${S}(t)$ in our case, we can use its equivalent representation using functions $f_{\mathcal{Q}(t)}(s)$ and $f_{\mathcal{H}_{\ell}(t)}(s)$ for $\ell\in\mathcal{L}$. The space of those functions is a Skorokhod space [31], for which, under the appropriate topology, we can show it is a Polish space [32]. Our space is the product of $L+1$ of those Polish spaces and under the product topology, is also a Polish space.

The evolution of states over time defines a time homogeneous Markov chain, for which we can prove its stability, by applying Theorem 1 of [30], which we repeat next for convenience.

Subtheorem 1**.**

Let $\mathcal{X}$ be a Polish space and $V:\mathcal{X}\to\mathds{R}_{+}$ be a measurable function with $\sup_{x\in\mathcal{X}}V(x)=\infty$, which we will refer to as Lyapunov function. Suppose there are two more measurable functions $g:\mathcal{X}\to\mathds{N}$ and $h:\mathcal{X}\to\mathds{R}$ with the following properties:

[TABLE]

Suppose the drift of $V$ satisfies the following property in which $\mathds{E}_{x}[\cdot]$ is the conditional expectation, given $X(t)=x$,

[TABLE]

We define the return time to set $\mathcal{X}_{N}=\{x\in\mathcal{X}:V(x)<N\}$ to be

[TABLE]

Given the above, it follows that there is $N_{0}>0$, such that for any $N>N_{0}$ and $x\in\mathcal{X}$, we have that $\mathds{E}_{x}[\tau_{N}]<\infty$

The theorem states that under certain conditions, the chain is positive recurrent to a certain subset of states for which Lyapunov function is bounded. From this, it can be inferred that the expected value of that function as time goes to $\infty$ is bounded [30].

In our proof, we pick as Lyapunov function the sum of sizes of jobs in the system divided by $\mu$. Proving that the size of jobs in system is bounded implies that the number of jobs is also bounded under the theorem’s assumption that job sizes have a lower bound. If $R_{i}$ is the size of a job $i$, then the Lyapunov function is defined as

[TABLE]

Consider a time interval $[t_{0},t_{0}+g({S}(t_{0}))]$ and that the state ${S}(t_{0})$ is known. We want the drift to be negative over this time interval, for $V(t_{0})$ large enough. Next we specify a function $g({S}(t_{0}))$ and a function $h({S}(t_{0}))$, that ensure conditions in Subtheorem 1 hold. For $g({S}(t_{0}))$ it is sufficient to assume its value is constant, so in what follows we will have to specify this value which we will denote by $N_{2}$.

We start by defining an event based on which we will differentiate the states with negative expected drift over $N_{2}$ time slots.

Definition 6**.**

$E_{{S}(t_{0}),N_{1},N_{2}}$* is the event that in time interval $[t_{0},t_{0}+N_{2}]$, every server will become less than half full for at most $N_{1}$ time units, for some $N_{1},N_{2}\in\mathds{N}$, given the initial state ${S}(t_{0})$.*

Next, we will pick the values $N_{1},N_{2}$ such that the event $E_{{S}(t_{0}),N_{1},N_{2}}$ is almost certain when the total size of jobs in queue is large enough.

Let $t_{a,\ell}$ be the first time slot after $t_{0}$ that the server $\ell$ is less than half full and $t_{e,\ell}$ be the time after $t_{0}$ that the server empties. Also define $Z_{\leq 1/2}(t)=\sum_{j\in\mathcal{Q}(t)|R_{j}\leq 1/2}R_{j}$ to be the sum of resource requirements of jobs in queue, whose resource is not larger than $1/2$ and respectively $Z_{>1/2}(t)$ is defined as the sum of resource requirements of the rest of the jobs in the queue.

The probability of $E_{{S}(t_{0}),N_{1},N_{2}}$ can be bounded as

[TABLE]

The logic behind the bound is that $E_{{S}(t_{0}),N_{1},N_{2}}$ will be certainly true in one of the following two cases:

If $(Z_{\leq 1/2}(t_{0})>LN_{2})$ then the server will be more than half full in next $N_{2}$ time slots. This is because if a server is less than half full, there will be at least one job whose resource will be less that $1/2$ that can fit in the server and those jobs are enough so that there will be at least one job available in next $N_{2}$ time slots. 2. 2.

Once a server gets empty, it will start serving all jobs of size more than $1/2$ that are in queue at that time. While there is a job of that kind that fits, the server will be more than half full. That will always be true in a time window of $N_{2}$ time slots after time $t_{0}$ if $Z_{>1/2}(t_{0})>LN_{2}$. That guarantees that all servers will have access to at least $L(N_{2}-T)$ jobs of size greater than $1/2$ at time slot $t_{0}+T$. If they schedule the largest one at that time slot, after getting empty, they will be able to schedule at least the largest one out of the jobs that remain, in the next time slot. In this case we only need to bound $\mathds{P}\left(t_{e,\ell}-t_{a,\ell}<N_{1}\right)$ which is the probability that the server will become empty in $N_{1}$ time slots after being half empty.

Note that if $\sum_{j\in\mathcal{Q}(t)}R_{j}>2LN_{2}$, then, by (34), $\mathds{P}\left(E_{{S}(t_{0}),N_{1},N_{2}}\right)\geq\prod_{\ell\in\mathcal{L}}\mathds{P}\left(t_{e,\ell}-t_{a,\ell}<N_{1}\right)$. Next, we compute a lower bound on $\mathds{P}\left(t_{e,\ell}-t_{a,\ell}<N_{1}\right)$.

Given that each job in service may depart during a time slot with probability $\mu$ and there are at most $\lfloor 1/u\rfloor=K_{max}$ in a server, we have the following bound:

[TABLE]

If we want $\mathds{P}\left(E_{{S}(t_{0}),N_{1},N_{2}}\right)>1-\epsilon_{1}$ it suffices to choose $N_{1}$ such that

[TABLE]

Using the inequality $(1-x)^{n}>1-nx$ for $n>0$ and $x<1$, we therefore need

[TABLE]

Next we give an upper bound on the maximum supportable workload, which we will use for comparison to the maximum workload supported by $\mathrm{BF}$.

Lemma 1**.**

The maximum value of $\rho^{\star}$ is at most $\frac{L}{\bar{R}}$.

Proof.

Let $U(t)$ to be the total sum of the job sizes (job resource requirements) in the system at time $t$, i.e.,

[TABLE]

It is easy to check that $\mathbb{E}[U(t+1)-U(t)|{\mathcal{Q}}(t),{\mathcal{H}}(t)]\geq\lambda\bar{R}-\mu L$, where we have used the fact that the total sum of the job sizes in all the servers in the cluster is at most $L$. The system will certainly be unstable in the sense that $U(t)\to\infty$, with probability one, if $\lambda\bar{R}-\mu L>0$ or equivalently $\rho>\frac{L}{\bar{R}}$ (see e.g. Theorem 11.3 in [33]). This in turn implies that $Q(t)\to\infty$ as $Q(t)\geq U(t)$ and that the system is unstable for any $\rho>\frac{L}{\bar{R}}$ . ∎

Next we will show that for any $\epsilon>0$, the workload $\rho$ will be supportable by our algorithm if $\rho<(1-\epsilon)\frac{L}{2\bar{R}}$. This essentially proves that the best supportable workload is at least half of the optimal.

The drift of the Lyapunov function over $N_{2}$ time slots, given the initial state ${S}(t_{0})$, is the difference between the sizes of jobs that arrive and the size of jobs that depart normalized by a factor $1/\mu$. The expected average size of arrivals in one step is $\lambda\bar{R},$ where $\lambda$ is the average number of arrivals and $\bar{R}$ the average job size. Further, the expected size of departures at time $t$ given initial state ${S}(t_{0})$ is \mathds{E}\Big{[}\sum_{\ell\in\mathcal{L}}\sum_{j\in\mathcal{H}_{\ell}(t)}R_{j}|{S}(t_{0})\Big{]}\mu. Hence, we can compute the drift as

[TABLE]

According to Subtheorem 1 we want to find $h({S}(t_{0}))$ such that $-h({S}(t_{0}))\geq\mathds{E}[V(t_{0}+N_{2})-V(t_{0})|{S}(t_{0})]$. Obviously we can choose this function $h({S}(t_{0}))$ such that $\inf_{{S}(t_{0})}h({S}(t_{0}))=\inf_{{S}(t_{0})}\mathds{E}[V(t_{0}+N_{2})-V(t_{0})|{S}(t_{0})]\geq-N_{2}\rho\bar{R}>-\infty$. Now given $V(t_{0})>\frac{2LN_{2}}{\mu}$ we have

[TABLE]

where (a) is due to the fact that for a duration of at least $(N_{2}-LN_{1})$ time slots, all servers will be at least half full, which is a consequence of Definition 6. Therefore, for $V(t_{0})>\frac{2LN_{2}}{\mu}$, $h({S}(t_{0}))$ is given by

[TABLE]

Now if we need $h({S}(t_{0}))>\delta$ when $V(t_{0})>\frac{2LN_{2}}{\mu}$, it suffices that

[TABLE]

from which it follows

[TABLE]

Earlier we required that $\rho<(1-\epsilon)\frac{L}{2\bar{R}}$, so from Equation (43) we get the following sufficient condition for the drift to be negative:

[TABLE]

We can choose parameters $\epsilon_{1},N_{2},\delta$ so that (44) is true. The choice is not unique but the following are sufficient:

[TABLE]

This gives the following expressions for $g({S}(t_{0}))$ and $h({S}(t_{0}))$.

[TABLE]

-C All Subcases of Proof of Proposition 1

We will analyze the remaining subcases that were not analyzed in the main proof. They all fall under the assumption that $\sum_{i\in Z_{1}}{k}^{(X)}_{i}=1$. We also notice that in this case $\sum_{i\in Z_{0}}{k}^{(X)}_{i}=0$, otherwise capacity constraints are not satisfied.

We further distinguish three cases for the relative size of $Q_{1}$ compared to $U$: $Q_{1}\geq 2U/3$, $2U/3>Q_{1}\geq U/2$ and $U/2>Q_{1}$

Case 2.1. $Q_{1}\geq 2U/3$: Consider any $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$ such that $k_{1}=1$. For that $\mathbf{k}$, it follows that

[TABLE]

This means that (10) is satisfied for such a choice of $\mathbf{k}$.

Case 2.2. $2U/3>Q_{1}\geq U/2$:

For this case we need to further consider two different outcomes for the value of $\sum_{i\in Z_{2}}k_{i}^{(X)}$ which can be either [math] or $1$. The first case was analyzed in the main proof so the analysis for $\sum_{i\in Z_{2}}k_{i}^{(X)}=1$ follows here.

If $Q_{2}\geq U/3$ then configuration $2\mathbf{e}_{2}$ has weight more than $2U/3$ and is the configuration we are looking for. If not let $U^{\prime}=U-Q_{1}-Q_{2}$. Then at least one of the following has to be true

[TABLE]

If this is not the case, then we reach a contradiction as follows

[TABLE]

In the last inequality, we applied the capacity constraint that the jobs in configuration other than the type-$1$ and type-$2$ should fit in a space of at most $1/6$ (as the rest is covered by the aforementioned jobs that we know they appear once in configuration). In other words:

[TABLE]

The configurations that satisfy inequality (10) depend on which of the inequalities in (48) is true.

If $Q_{2m}\geq U^{\prime}/2^{m-2}$ for some $m\in[2,\cdots,J-1]$ then inequality (10) is true either for configuration $2\mathbf{e}_{2}$ if $Q_{2}\geq U/3$ or for configuration $\mathbf{e}_{1}+\lfloor 2^{m}/3\rfloor\mathbf{e}_{2m}$ otherwise as

[TABLE]

Similarly if $Q_{2m+1}\geq U^{\prime}/(3\cdot 2^{m-1})$ for some $m\in[1,\cdots J-1]$ then inequality (10) is true either for configuration $2\mathbf{e}_{2}$ if $Q_{2}\geq U/3$ or for configuration $\mathbf{e}_{1}+2^{m-1}\mathbf{e}_{2m+1}$ as

[TABLE]

[TABLE]

Case 2.3. $Q_{1}<U/2$:

At least one of the following inequalities is true:

[TABLE]

The conditions are the same as those of (12) except that $Q_{0}$ is not included now. We can again use proof by contradiction as in (V-C) and get

[TABLE]

Again the last inequality is due to the capacity constraint of the server under the assumption that $\sum_{i\in Z_{0}}{k}_{i}^{(X)}=0$ and $\sum_{i\in Z_{1}}{k}_{i}^{(X)}=1$.

Now if $Q_{2m}\geq 2U/3\times 1/2^{m}$ for some $m=1,\cdots,J-1$ then configuration $2^{m}\mathbf{e}_{2m}$ will satisfy (10) while if $Q_{2m+1}\geq U/2\times 1/2^{m}$ for some $m=1,\cdots,J-1$ then configuration $3\cdot 2^{m-1}\mathbf{e}_{2m}$ will satisfy (10).

-D Proof of Theorem 3

We need to show that for any $\rho$ such that $\rho<2/3\rho^{\star}$ the system is stable. For this we will first prove the following Lemma which is a consequence of Proposition 1.

Lemma 2**.**

If $\rho<2/3\rho^{\star}$, then there is $\mathbf{x}\in\mathrm{Conv}({\mathcal{K}}_{RED}^{(J)})$ and $\epsilon>0$, such that $\bm{\rho}<(1-\epsilon)L\mathbf{x}$, where $\bm{\rho}=\rho\bm{P}^{(I)}$, $I$ is the partition (6) and $L$ is the number of servers.

Proof.

In the proof of Theorem 1 we constructed a sequence of partitions $X^{(n)}$, $n\in\mathds{N}$, whose maximum supportable workload approaches $\rho^{\star}$. In this proof we will consider the partitions $X^{+(n)}$ generated from partitions $X^{(n)}$ the way described next. To simplify description we provide the definition of $X^{+(n)}$ only for the case of continuous probability distribution function although definition and result can be generalized. As a reminder, for the continuous probability distribution case of Theorem 1, $X^{(n)}$ is a collection of intervals $X^{(n)}_{i}:(\xi_{i-1}^{(n)},\xi_{i}^{(n)}]$ for $i=1,\ldots,2^{n+1}$. Partition $X^{+(n)}$, $n\in\mathds{N}$ will be a collection of $c_{n}$ intervals $X_{i}^{+(n)}:(\xi_{i-1}^{+(n)},\xi_{i}^{+(n)}]$ where $\xi_{0}^{+(n)}=0$, $\xi_{c_{n}}^{+(n)}=1$ and $\xi_{i}^{+(n)}$ is the $i$-th largest element in the set $\{\xi_{i^{\prime}}^{(n)},i^{\prime}=1,\ldots,2^{n+1}-1\}\cup\{1/2^{m},m=0,\cdots,J-1\}\cup\{2/3\times 1/2^{m},m=0,\cdots,J-1\}$ for $i=1,\ldots,c_{n}-1$.

The partition $X^{+(n)}$ is finer than $X^{(n)}$ so $\overline{\rho}^{\star}({X^{(n)}})\leq\overline{\rho}^{\star}({X^{+(n)}})$ and

[TABLE]

Consider now any $\rho<\overline{\rho}^{\star}({X^{+(n)}})$ so the workload vector $\rho\bm{P}^{(X^{+(n)})}$ is supportable under the assumption of upper-rounded virtual queues.

Next we define sets similar to sets $Z_{j}$ of Proposition 1 which we denote by $Z_{j}^{+(n)}$ for $j=1,\ldots,2J$, $n\in\mathds{N}$. We will have that for $i=1,\ldots,c_{n}$, $i\in Z_{j}^{+(n)}$ iff $\xi^{+(n)}_{i}\in I_{j}$ where $I_{j}$ are the intervals defined in (6). We also define $\underline{i}_{j}=\arg\min_{i\in Z_{j}^{+(n)}}\xi^{(n)}_{i}$ and the probability vector $\bm{\underline{P}}^{(X^{+(n)})}$ as

[TABLE]

We see that the workload vector $\rho\bm{\underline{P}}^{(X^{+(n)})}$ is supportable if $\rho\bm{P}^{(X^{+(n)})}$ is supportable. This is because the original workload $\rho\bm{P}^{(X^{+(n)})}$ is equivalent to $\rho\bm{\underline{P}}^{(X^{+(n)})}$ if job sizes of all arriving job are modified the following way. Jobs that join the $\rm{VQ}_{i}$, where $i\in Z_{j}^{+(n)}$ and $i\neq\underline{i}_{j}$, reduce their size such that they join $\rm{VQ}_{\underline{i}_{j}}$ instead, while if $i=\underline{i}_{j}$ job sizes remain unchanged. Since all job sizes are reduced or remain the same and system is stable without this change, then system should also be stable with this modification.

Similarly to (58), let $\bm{\underline{Q}}^{(X^{+(i)})}$ be defined as

[TABLE]

If $\overline{\mathcal{K}}^{+(n)}$ is the set of feasible configurations under upper-rounded virtual queues assumption for partition $X^{+(n)}$, we should also have

[TABLE]

If now $\rho<2/3\rho^{\star}$, it means

[TABLE]

because of (57). Eventually we have

[TABLE]

Equality (a) follows from the fact that vectors $\bm{P}^{(I)}$ and $\bm{\underline{P}}^{(X^{+(n)})}$ are identical, if [math] entries are ignored in the latter vector, while the same property is true for vectors $\mathbf{Q}^{(I)}$ and $\mathbf{\underline{Q}}^{(X^{+(n)})}$. Then (b) follows from (61) and in (c) we used $\bm{x}$ from (60). Given that $\mathrm{Conv}(\overline{\mathcal{K}}^{+(n)})$ is a convex set, there should be a $\mathbf{k}^{(X^{+(n)})}\in\overline{\mathcal{K}}^{+(n)}$ such that

[TABLE]

and eventually because of Proposition 1, there is a ${\mathbf{k}}\in{\mathcal{K}}_{RED}^{(J)}$ such that

[TABLE]

Using (62), (63) and (64), it follows that for any virtual queue size vector $\mathbf{Q}^{(I)}$ under partition $I$, there exists $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$ such that

[TABLE]

As a result, $\rho\bm{P}^{(I)}$ is in the interior of $\mathrm{Conv}({\mathcal{K}}_{RED}^{(J)})$ so there is $\mathbf{x}\in\mathrm{Conv}({\mathcal{K}}_{RED}^{(J)})$ and $\epsilon>0$ such that

[TABLE]

∎

The state of our system at time slot $t$ is

[TABLE]

$\bm{\mathcal{Q}}(t)$ is a vector of sets of jobs in queues which is equal to $(\mathcal{Q}_{j}(t),j=0,\cdots,2J-1)$. The cardinality of each set of jobs is equal to the corresponding queue size, i.e. $|\mathcal{Q}_{j}(t)|=Q_{j}(t)$. $\bm{\mathcal{H}}(t)=(\mathcal{H}_{\ell}(t)\quad\ell\in\mathcal{L})$ is the vector of sets of scheduled jobs in servers.

We will structure our proof again around the result of Subtheorem 1. The Lyapunov function that we use is

[TABLE]

Given state ${S}(t_{0})$ at a reference time $t_{0}$ is known, we want to describe functions $g({S}(t_{0}))$ and $h({S}(t_{0}))$ that satisfy the conditions of Subtheorem 1. Function $g({S}(t_{0}))$ will be fixed and equal to $N_{2}$. The value of $N_{2}$ as well as the function $h({S}(t_{0}))$ will be specified later.

Given that $h({S}(t_{0}))$ has to be eventually negative we will differentiate the initial states for which this will happen based on the following event. Given the state of the system ${S}(t_{0})$, we define the event $E_{{S}(t_{0}),N_{1},N_{2},\gamma}$ to be the event that in time interval $[t_{0},t_{0}+N_{2}]$, every server will be scheduling according to a configuration whose weight is at most $\gamma$ fraction of that of maximum weight configuration in $\mathcal{K}^{(J)}_{RED}$, for at most $N_{1}$ time units, for some $N_{1},N_{2}\in\mathds{N}$. In all the following results we assume $\gamma\in(0,1)$ so it can be arbitrarily close to $1$, but strictly less than that. The next lemma states the conditions under which event $E_{{S}(t_{0}),N_{1},N_{2},\gamma}$ is almost certain.

Lemma 3**.**

We can ensure $\mathds{P}(E_{{S}(t_{0}),N_{1},N_{2},\gamma})>1-\epsilon$, if $N_{1}>\frac{\log{(\epsilon/(2L))}}{\log{\left(1-\mu^{K_{max}}\right)}}$ and $\left\|\mathbf{Q}(t_{0})\right\|>B_{\gamma}\frac{N_{2}}{\epsilon}$ where $B_{\gamma}$ some constant and $\left\|\cdot\right\|$ the Euclidean norm.

Proof.

Let $t_{e_{\ell}(i)}$ denote the $i$th time that server $\ell$ gets empty between time slots $t_{0}$ and $t_{0}+N_{2}$. We notice that we can bound event $E_{{S}(t_{0}),N_{1},N_{2},\gamma}$, by the event that $t_{e_{\ell}(1)}-t_{0}<N_{1}$ and for the next $N_{2}-t_{e_{\ell}(1)}$ time slots, the weight of configuration will always be greater that $\gamma$ fraction of the optimal.

[TABLE]

where $t\in[t_{0},t_{0}+N_{2}]$, $i_{n}$ the latest time slot less than $t$ that the server got empty and $\mathbf{k}^{\star}(t)$ is the max-weight configuration at time slot $t$.

A bound for the first term is

[TABLE]

When a server becomes empty for the $i$th time, the following inequality holds

[TABLE]

The condition $\langle\mathbf{k}(t_{e_{\ell}(i_{n})}),Q(t)\rangle-\langle\gamma\mathbf{k}^{\star}(t),Q(t)\rangle>0$ will be violated if for at least one $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$,

[TABLE]

As a result, for this particular $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$, we have,

[TABLE]

Given that $\mathbf{A}[t_{1},t_{2}]$ is the vector of arrivals per type in time interval $[t_{1},t_{2})$, $A[t_{1},t_{2}]$ the absolute number of arrivals in the same interval and $\mathbf{D}[t_{1},t_{2}]$, ${D}[t_{1},t_{2}]$ the respective values for departures, then

[TABLE]

Setting

[TABLE]

we can as a result claim that

[TABLE]

Combining Equations (70) and (76), if we need $\mathds{P}\left(E_{{S}(t_{0}),N_{1},N_{2},\gamma}\right)>1-\epsilon$, it suffices to have

[TABLE]

or

[TABLE]

which implies

[TABLE]

and

[TABLE]

which implies

[TABLE]

The Lemma is true for $B_{\gamma}=\frac{4L(\lambda+\mu K_{max}L)}{B_{\gamma 1}}$ ∎

The change of $V(t)$ in one time slot, will be

[TABLE]

In one time slot we also have $\mathds{E}(A_{j}[t+1,t])=\lambda_{j}=\lambda p_{j}$ and $\mathds{E}(D_{j}[t+1,t])=\mu\sum_{\ell\in\mathcal{L}}k^{(\ell)}_{j}(t)$ where $k^{(\ell)}_{j}(t)$ is the number of jobs in server $\ell$ at time slot $t$, that come from $\mathrm{VQ}_{j}$. Setting $\lambda_{j}/\mu=\rho_{j}$, the following holds when it comes to computing the expected change in the Lyapunov function,

[TABLE]

where

[TABLE]

and $\textrm{Var}(\cdot)$ is the variance. As a first step, it is obvious from (83) that the expected change is bounded, when all queue sizes at time slot $t$ are bounded. Specifically if we ignore the effect of departures we can use the following bound when drift is considered over a number of $N_{2}$ times slots:

[TABLE]

When $\left\|\mathbf{Q}(t)\right\|$ is large enough we can use the following lemma to derive a stricter bound.

Lemma 4**.**

If at a given time slot $t$, the weight of all configurations $\mathbf{k}^{\ell}$, $\ell\in\mathcal{L}$ is at least $\gamma$ times the weight of all configurations of $\mathcal{K}^{(J)}_{RED}$ and workload $\rho$ satisfies $\rho<2/3\rho^{\star}$ then the following is true:

[TABLE]

for some constant $B_{\alpha}>0$.

Proof.

If $\rho<2/3\rho^{\star}$ then there is $\gamma<1$ such that $\rho<2/3\gamma\rho^{\star}$. Then because of Lemma 2, there is an $\mathbf{x}\in Conv({\mathcal{K}}_{RED}^{(J)})$, such that $\bm{\rho}<(1-\epsilon)\gamma L\mathbf{x}$, where factor $L$ is due to $L$ identical servers.

Let $\tilde{\mathbf{k}}^{\ell}(t)$ be the active configuration of server $\ell$ at time slot $t$. Under the claim that $k^{(\ell)}_{j}(t)\geq\tilde{k}^{(\ell)}_{j}(t)$ when $Q_{j}(t)>0$, which is true because of the way algorithm works, we should also have

[TABLE]

Using this result

[TABLE]

where

[TABLE]

In the above derivation we show that $B_{\alpha}$ is strictly positive and that can be done using that the expression $\left\|\mathbf{k}^{\star}(t)\right\|\cos\left(\mathbf{k}^{\star}(t),\mathbf{Q}(t)\right)$ is at least $\frac{1}{\sqrt{2J}}$. That can be shown by noticing that maximum of $\left\|\mathbf{k}\right\|\cos\left(\mathbf{k},\mathbf{Q}(t)\right)$ over all configurations $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$ is at least the maximum of $\cos\left(\mathbf{k},\mathbf{Q}(t)\right)$ over the same set of configurations, since $\left\|\mathbf{k}\right\|\geq 1$ for all $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$.

Lastly one can think of the expression $\cos\left(\mathbf{k},\mathbf{Q}(t)\right)$ as the projection of a unit queue vector onto a configuration $\mathbf{k}\in{\mathcal{K}}_{RED}^{(J)}$ Given that the set of configurations ${\mathcal{K}}_{RED}^{(J)}$ spans a space of $2J$ dimensions, the largest cosine will have a value of at least $\frac{1}{\sqrt{2J}}$. ∎

In the last part of our proof, we will give the conditions under which the drift over $N_{2}$ time slots is negative or equivalently $h({S}(t_{0}))$ can be chosen to be positive.

Lemma 5**.**

We will have that $\mathds{E}[V(t_{0}+N_{2})-V(t_{0})|{S}(t_{0})]<-\delta<0$, if

[TABLE]

[TABLE]

Proof.

First we provide a bound for $\mathds{E}[V(t_{0}+N_{2})-V(t_{0})|{S}(t_{0})]$, based on Lemmas 3 and 4,

[TABLE]

To ensure $\mathds{E}[V(t_{0}+N_{2})-V(t_{0})|{S}(t_{0})]<-\delta<0$, it suffices that (91) holds. The inequality is true provided the denominator is negative, so a sufficient choice of parameters is $\epsilon<\frac{B_{\alpha}}{B_{\alpha}+\left\|\bm{\rho}\right\|}$ and $N_{2}$ given by (90). ∎

We have eventually proven that conditions of Theorem 1 are true for the state space of our problem, when Lyapunov function is the one in Equation (68) and $h({S}(t_{0}))$, $g({S}t_{0})$ are given by

[TABLE]

where $B_{\alpha}$ is defined in (89), $B_{\beta}$ in (84) and $Q_{t}$ is the maximum of expressions (81) and (91).

-E Proof of Proposition 2

Since the partitions are countable, we can choose an $\epsilon\in(0,1/3)$ such that both of the values $1/2-\epsilon$ and $1/2+\epsilon$ are in the interior of a subinterval of the partition. This assertion alone prevents an oblivious configuration based scheduling algorithm to schedule jobs of size $1/2-\epsilon$ and $1/2+\epsilon$ in the same server at the same time, even though they can fit together perfectly in it.

To complete the proof, it suffices to consider a single server of capacity one and assume that jobs have one of the two resource requirements, $1/2-\epsilon$ and $1/2+\epsilon$, with equal probability. We will now analyze the case in which the two values are in the interior of different subintervals, as the case in which they fall in the same one is clearly worse.

In what follows, for compactness, we define all the vectors to be $2$-dimensional with each dimension corresponding to a type, although the number of subintervals can be much larger. In other words, we omit the entities of the vector that correspond to subintervals with zero arrivals. Thus, the arrival rate vector is given by $\lambda(1/2,1/2)$. Under an oblivious algorithm, the possible maximal feasible configurations (configurations that cannot be increased and still be feasible) are $(2,0)$ and $(0,1)$. In particular, configuration $(2,0)$ is feasible in a best case scenario where jobs of size $1/2-\epsilon$ are mapped to a subinterval with the end-bound in $(1/2-\epsilon,1/2]$.

It is on the other hand obvious that the configuration $(1,1)$ is also feasible for the job types considered in this example. Hence a workload $\rho=\lambda/\mu$ should be feasible if $\mu(1,1)>\lambda(1/2,1/2)$ or $\rho=\frac{\lambda}{\mu}<2$. So $\rho^{\star}=2$. However under the partition assumption, the following conditions should hold for any feasible $\rho$

[TABLE]

The maximum $\rho$ is obtained in this case by choosing $p_{1}=1/3$ and $p_{2}=1/3$. That is equivalent with $\rho\leq 4/3=2/3\rho^{\star}$.

-F Proof of Corollary 1

We consider the following $4$ systems which differ in the way that they process jobs of size less than $1/2^{J}$:

The jobs are completely discarded from queue and are not processed further 2. 2.

Jobs join the queue without any changes 3. 3.

Jobs join the queue and have their resource requirement rounded to $1/2^{J}$ 4. 4.

Jobs join the queue and have their resource requirement re-sampled from the distribution $F_{R}$ until their resource value becomes more than $1/2^{J}$.

We denote the maximum workload achieved in each of the $4$ systems by $\rho^{\star}_{1},\rho^{\star}_{2},\rho^{\star}_{3},\rho^{\star}_{4}$. The relation between the job sizes in the systems is increasing. Also the distribution of job sizes in the first and last system is the same, but in the latter the arrival rate of the jobs is increased by a factor of $1/(1-\epsilon)$. It follows that the following relationship must hold between the optimal workload of these $4$ systems:

[TABLE]

The bound of VQS algorithm from Theorem 3 is valid for the third system, so let $\rho^{\star}_{VQS}$ be the maximum supportable workload by $VQS$. It then follows from that theorem and inequality (95) that

[TABLE]

-G Proof of Theorem 4

To prove the throughput result for $\mathrm{VQS}$-$\mathrm{BF}$, the fundamental change compared to the proof of Theorem 3, is that the proof of Lemma 3 needs to make use of new assumptions. We restate the Lemma next and prove it under the assumptions of the algorithm $\mathrm{VQS}$-$\mathrm{BF}$.

Lemma 6**.**

We can ensure $\mathds{P}(E_{{S}(t_{0}),N_{1},N_{2},\gamma})>1-\epsilon$ when scheduling under $\mathrm{VQS}$-$\mathrm{BF}$, if $N_{1}>\frac{\log{(\epsilon/(2L))}}{\log{\left(1-\mu^{K_{max}}\right)}}$ and $\left\|\mathbf{Q}(t_{0})\right\|>B_{\gamma}\frac{N_{2}}{\epsilon}$ for some constant $B_{\gamma}$.

Proof.

The first part can be proven under the assumption that once the configuration of a server becomes less than $\gamma$ of max-weight configuration, it will become empty in at most $N_{1}$ time slots for an appropriate value of $N_{1}$. The analysis of this part is the same as the one in Lemma 3

The other condition we need to justify is that a server that becomes active, will schedule according to a configuration that has weight at least $\gamma$ times the optimal, for at least $N_{2}$ time slots, unless it gets empty again.

We need to distinguish 2 cases for that depending on whether the active configuration of server has a job from $\mathrm{VQ}_{1}$ or not. In what follows we highlight only the changes compared to proof of Lemma 3.

No job from $\mathrm{VQ}_{1}$: In this case the server will have $k_{j^{\star}}$ jobs of type-$j^{\star}$ in its active configuration for some $j^{\star}\in[0,2J-1]$. Given that the jobs in $\mathrm{VQ}_{j^{\star}}$ are scheduled from largest to smallest, then the jobs in server will be a superset of those in configuration if $Q_{j^{\star}}(t_{0})>K_{max}N_{2}$ or $k_{j^{\star}}Q_{j^{\star}}(t_{0})>K_{max}^{2}N_{2}$. Since

[TABLE]

a sufficient condition can be

[TABLE]

Given this condition, the weight of scheduled configuration in the next $N_{2}$ time slots will be at least the weight of the active configuration. As a next step we need the weight of active configuration to be at least $\gamma$ times the maximum weight for the following $N_{2}$ time slots, so later arguments are the same as in proof of Lemma 3.

One job from $\mathrm{VQ}_{1}$: Under this condition we will further distinguish two cases depending on the length of the other VQ in configuration which we will assume to be $\mathrm{VQ}_{j^{\star}}$. Let $U=Q_{j^{\star}}(t_{0})k_{j^{\star}}+Q_{1}(t_{0})$ be the weight of the max weight configuration.

$(\gamma+1)U/2>Q_{1}\geq U/2$: That implies $Q_{j^{\star}}(t_{0})k_{j^{\star}}>(1-\gamma)U/2$. A sufficient condition for this and previous condition to happen is, following the procedure for the case of ”no jobs from $\mathrm{VQ}_{1}$” is

[TABLE]

Then the weight of scheduled configuration will be at least the weight of the active configuration. As a next step we need the weight of active configuration to be at least $\gamma$ times the maximum weight for the following $N_{2}$ time slots, so later arguments are the same as in proof of Lemma 3. 2. 2.

$Q_{1}\geq(\gamma+1)U/2$: In this case we can at least ensure that if

[TABLE]

the $\mathrm{VQ}_{1}$ will never empty, but at the same time we need to consider the weight of server’s configuration assuming that only job of type-$1$ will be in it at all times. For this we consider our configuration has only one job of type-$1$ for which we can claim as opposed to equation (71) that

[TABLE]

This leads to the following equivalent of equation (73)

[TABLE]

with the equivalent of equation (75) being

[TABLE]

Later analysis is the same as in proof of Lemma 3 with only the constant $B_{\gamma 1}$ being different.

∎