Greed Works -- Online Algorithms For Unrelated Machine Stochastic Scheduling

TL;DR

This paper presents new combinatorial online algorithms for stochastic unrelated machine scheduling that achieve competitive ratios comparable to previous methods, with performance bounds depending on job variability.

Contribution

It introduces purely combinatorial online algorithms for stochastic unrelated machine scheduling, extending dual fitting techniques to this stochastic, nonpreemptive setting.

Findings

Competitive ratio of 4 for deterministic processing times without release times.

Competitive ratio of 7.216 for deterministic processing times with release times.

Performance bounds depend linearly on the squared coefficient of variation.

Abstract

This paper establishes performance guarantees for online algorithms that schedule stochastic, nonpreemptive jobs on unrelated machines to minimize the expected total weighted completion time. Prior work on unrelated machine scheduling with stochastic jobs was restricted to the offline case, and required linear or convex programming relaxations for the assignment of jobs to machines. The algorithms introduced in this paper are purely combinatorial. The performance bounds are of the same order of magnitude as those of earlier work, and depend linearly on an upper bound on the squared coefficient of variation of the jobs' processing times. Specifically for deterministic processing times, without and with release times, the competitive ratios are 4 and 7.216, respectively. As to the technical contribution, the paper shows how dual fitting techniques can be used for stochastic and nonpreemptive scheduling problems.

Figures

Equations

$$\displaystyle\sum_{r\in{\mathbb{Z}}_{\geq 0}}\mbox{$\mathbb{P}[X>r]$}$$

$$\mathbb{CV}[X{]}^2:=\mathbb{V}\mathrm{ar}[X]/\mathbb{E}[X{]}^2,$$

$$\mathsf{ALG}\le \alpha \mathsf{OPT}.$$

$$\displaystyle y_{ijs}=\sum_{t=0}^{s}x_{ijt}\,\mbox{$\mathbb{P}[P_{ij}>s-t]$}\enspace.$$

$$\sum _{j\in J}{y}_{ijs}\le 1\text{for all i∈M, s∈Z≥0.}$$

$$\sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}\frac{y_{ijs}}{\mathbb{E}[P_{ij}]}=1\text{for all j∈J}.$$

$$\displaystyle C_{j}^{\ref{sto}}:=\sum_{i\in M}\sum_{s\in{\mathbb{Z}}_{\geq 0}}\left(\frac{y_{ijs}}{{\mathbb{E}}[P_{ij}]}\,\bigl{(}s+\tfrac{1}{2}\bigr{)}+\frac{1-\mathbb{CV}[P_{ij}]^{2}}{2}\,y_{ijs}\right)\qquad\text{for all~{}$j\in J$\,,}$$

$$C_j^{\text{ref}sto}\ge \sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}{y}_{ijs}\text{for all j∈J.}$$

$$\begin{array}{rl}\min & z^{\text{ref}sto}=\sum _{j\in J}{w}_j{C}_j^{\text{ref}sto}\\ \text{s.t.}& \text{eqrefeq:LPy:mach-cap, eqrefeq:LPy:assignment, eqrefeq:LPy:compl-time, eqrefeq:LPy:additional}\\ & y_{ijs}\ge 0\text{for all j∈J, i∈M, s∈Z≥0.}\end{array}$$

$$\displaystyle C_{j}^{\ref{det}}=\sum_{i\in M}\sum_{s\in{\mathbb{Z}}_{\geq 0}}\left(\frac{y_{ijs}}{{\mathbb{E}}[P_{ij}]}\,\bigl{(}s+\tfrac{1}{2}\bigr{)}+\frac{y_{ijs}}{2}\right)\qquad\text{for all~{}$j\in J$.}$$

$$\begin{array}{rl}\min & z^{\text{ref}det}=\sum _{j\in J}{w}_j{C}_j^{\text{ref}det}\\ \text{s.t.}& \text{eqrefeq:LPy:mach-cap, eqrefeq:LPy:assignment, eqrefeq:LPy:simple-compl-time}\\ & y_{ijs}\ge 0\text{for all j∈J, i∈M, s∈Z≥0.}\end{array}$$

$$\Delta :=\underset{i,j}{\max }\mathbb{CV}[P_{ij}{]}^2.$$

$$H(\mathbf{y}):=\sum _{j\in J}{w}_j\sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}{y}_{ijs}.$$

$$H({\mathbf{y}}^{\text{ref}sto})=\sum _{j\in J}{w}_j\sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}{y}_{ijs}^{\text{ref}sto}\le \sum _{j\in J}{w}_j{C}_j^{\text{ref}sto}=z^{\text{ref}sto}({\mathbf{y}}^{\text{ref}sto})\le \mathsf{OPT}.$$

$$z^{\ref{det}}\leq\bigl{(}1+\frac{\Delta}{2}\bigr{)}z^{\ref{sto}}\,.$$

$$\displaystyle\begin{split}z^{\ref{det}}=z^{\ref{det}}(y^{\ref{det}})&\leq z^{\ref{det}}(y^{\ref{sto}})\\ &=z^{\ref{sto}}(\boldsymbol{y}^{\ref{sto}})+\sum_{j\in J}w_{j}\sum_{i\in M}\sum_{s\in{\mathbb{Z}}_{\geq 0}}\frac{\mathbb{CV}[P_{ij}]^{2}}{2}y_{ijs}^{S}\\ &\leq z^{\ref{sto}}(\boldsymbol{y}^{\ref{sto}})+\frac{\Delta}{2}H(\boldsymbol{y}^{\ref{sto}})\\ &\leq\bigl{(}1+\frac{\Delta}{2}\bigr{)}z^{\ref{sto}}(\boldsymbol{y}^{\ref{sto}})\,.\end{split}$$

$$z^{\ref{det}}\leq\bigl{(}1+\frac{\Delta}{2}\bigr{)}{\mathsf{OPT}}\,.$$

$$\begin{array}{rl}\max & z^{\text{ref}dual}=\sum _{j\in J}{\alpha }_j-\sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}{\beta }_{is}\\ \text{s.t.}& \frac{{\alpha }_j}{\mathbb{E}[P_{ij}]}\le {\beta }_{is}+w_j\left(\frac{s+\frac{1}{2}}{\mathbb{E}[P_{ij}]}+\frac{1}{2}\right)\text{ for all }i\in M,j\in J,s\in {\mathbb{Z}}_{\ge 0},\\ & {\beta }_{is}\ge 0\text{ for all }i\in M,s\in {\mathbb{Z}}_{\ge 0}.\end{array}$$

$$H(j,i):=\{k\in J\mid w_k/\mathbb{E}[P_{ik}]>w_j/\mathbb{E}[P_{ij}]\}\cup \{k\in J\mid k\le j,w_k/\mathbb{E}[P_{ik}]=w_j/\mathbb{E}[P_{ij}]\}.$$

$$\mbox{$\textup{cost}(j\to i)$}:=w_{j}\biggl{(}\sum_{k\to i,k\leq j,k\in H(j,i)}{\mathbb{E}}[P_{ik}]\biggr{)}\ +\ {\mathbb{E}}[P_{ij}]\sum_{k\to i,k<j,k\in L(j,i)}w_{k}\,.$$

$$\alpha_{j}:=\mbox{$\textup{cost}(j\to m(j))$}\quad\text{for all }j\in J\,.$$

$${\beta }_{is}:=\sum _{j\in A_i(s)}{w}_j,$$

$$\frac{{\alpha }_j}{\mathbb{E}[P_{ij}]}\le {\beta }_{is}+w_j\left(\frac{s}{\mathbb{E}[P_{ij}]}+1\right)$$

$$\frac{{\alpha }_j}{\mathbb{E}[P_{ij}]}$$

$$\mathsf{ALG}=\sum _{j\in J}{\alpha }_j=\sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}{\beta }_{is}.$$

$$\frac{{\alpha }_j^f}{\mathbb{E}[P_{ij}]}$$

$$\frac{{\alpha }_j}{\mathbb{E}[P_{ij}]}\le {\beta }_{is}^f+w_j\left(\frac{f\cdot s}{\mathbb{E}[P_{ij}]}+\frac{f}{2}\right).$$

$$\frac{{\alpha }_j}{\mathbb{E}[P_{ij}]}\le {\beta }_{is}^f+w_j\left(\frac{f\cdot s}{\mathbb{E}[P_{ij}]}+1\right).$$

$$z^{\text{ref}dual}({\mathbf{\alpha }}^f,\frac{1}{f}{\mathbf{\beta }}^f)=\sum _{j\in J}{\alpha }_j^f-\frac{1}{f}\sum _{i\in M}\sum _{s\in {\mathbb{Z}}_{\ge 0}}{\beta }_{is}^f=\frac{f-1}{f}{\mathsf{ALG}}^f=\frac{f-1}{f^2}\mathsf{ALG}.$$

$$p_{ij}=\{\begin{array}{ll}1& \text{ if }i\le \ell ,\\ \infty & \text{ otherwise}.\end{array}$$

Full text

\NatBibNumeric\TheoremsNumberedThrough\EquationsNumberedThrough\TITLE

Greed Works – Online Algorithms For Unrelated Machine Stochastic Scheduling \ARTICLEAUTHORS\AUTHORVarun Gupta \AFFUniversity of Chicago, Chicago (IL), U.S.A. varun.gupta@chicagobooth.edu, \AUTHORBenjamin Moseley \AFFCarnegie Mellon University, Pittsburgh (PA), U.S.A. moseleyb@andrew.cmu.edu \AUTHORMarc Uetz \AFFUniversity of Twente, Enschede, The Netherlands m.uetz@utwente.nl \AUTHORQiaomin Xie \AFFMassachusetts Institute of Technology, Cambridge (MA), U.S.A. qxie@mit.edu \ABSTRACT This paper establishes performance guarantees for online algorithms that schedule stochastic, nonpreemptive jobs on unrelated machines to minimize the expected total weighted completion time. Prior work on unrelated machine scheduling with stochastic jobs was restricted to the offline case, and required linear or convex programming relaxations for the assignment of jobs to machines. The algorithms introduced in this paper are purely combinatorial. The performance bounds are of the same order of magnitude as those of earlier work, and depend linearly on an upper bound on the squared coefficient of variation of the jobs’ processing times. Specifically for deterministic processing times, without and with release times, the competitive ratios are 4 and 7.216, respectively. As to the technical contribution, the paper shows how dual fitting techniques can be used for stochastic and nonpreemptive scheduling problems.

The point is, ladies and gentlemen, that greed, for lack of a better word, is good. Greed is right, greed works (Gordon Gekko in Wall Street [41])

1 Introduction.

Scheduling jobs on multiple, parallel machines is a fundamental problem both in combinatorial optimization and systems theory. There is a vast amount of different model variants as well as applications, which is testified by the existence of the handbook [25]. A well studied class of problems is scheduling a set of $n$ nonpreemptive jobs that arrive over time on $m$ unrelated machines with the objective of minimizing the total weighted completion time. In the unrelated machines model the matrix that describes the processing times of all jobs on all machines can have any rank larger than 1. The offline version of the problem is denoted \textup{R}\,|\,\textup{r_{j}}\,|\,\textup{\sum w_{j}C_{j}} in the three-field notation of Graham et al. [11], and the problem has been a cornerstone problem for the development of new techniques in the design of (approximation) algorithms, e.g. [4, 16, 24, 38].

This paper addresses the online version of the problem where jobs sizes are stochastic. In the online model jobs arrive over time, and the set of jobs is unknown a priori. For pointers to relevant work on online models in scheduling, refer to [19, 34]. In many systems, the scheduler may not know the exact processing times of jobs when the jobs arrive to the system. Different approaches have been introduced to cope with this uncertainty. If jobs can be preempted, then non-clairvoyant schedulers have been studied that do not know the processing time of a job until the job is completed [33, 5, 22, 12, 17]. Unfortunately, if preemption is not allowed then any algorithm has poor performance in the non-clairvoyant model, as the lower bound for the competitive ratio against the offline optimal schedule is $\Omega(n)$. This is even true if we consider the special case where all jobs have the same unit weight $w_{j}$.

This lower bound suggests that the non-clairvoyant model is too pessimistic for non-preemptive problems. Even if exact processing times are unknown to the scheduler, it can be realistic to assume that at least an estimate of the true processing times is available. For such systems, a model that is used is stochastic scheduling. In the stochastic scheduling model the jobs’ processing times are given by random variables. A non-anticipatory scheduler only knows the random variable that encodes the possible realizations of a job’s processing time. If the scheduler starts a job on a machine, then that job must be run to completion non-preemptively, and it is only when the job completes that the scheduler learns the actual processing time of the job. With respect to the random processing times, both the scheduler and the optimal solution are required to be non-anticipatory, which means that only the (conditional) distribution of a job’s processing time may be used at any point in time. Stochastic scheduling has been well-studied, including fundamental work such as by Möhring et al. [30, 31] and approximation algorithms, e.g. [32, 40, 28, 39, 36].

This paper considers online scheduling of non-preemptive, stochastic jobs in the unrelated machine model to minimize the total weighted completion time. This is the same problem as considered in the paper [28] by Megow et al., but here we address the more general unrelated machines model. In the stochastic unrelated machine model, the scheduler is given machine-dependent probability distributions that describe a job’s potential processing time for each of the machines. For a given job the processing times across different machines need not be independent, but the processing times of different jobs are assumed to be independent.

Identical machines, special processing time distributions. Restricting attention to non-preemptive policies, when all machines are identical, perhaps the most natural algorithm is Weighted Shortest Expected Processing Time (WSEPT) first. When a machine is free, WSEPT always assigns the job to be processed that has the maximum ratio of weight over expected size. When all jobs have unit weight, this algorithm boils down to the SEPT algorithm that greedily schedules jobs with the smallest expected size. When there is a single machine and all jobs arrive at the same time, WSEPT is optimal [35]. For multiple machines with equal weights for all jobs, if the job sizes are deterministic and arrive at the same time, SEPT is optimal [15]. For multiple identical machines with equal weights for all jobs, SEPT is optimal if job sizes are exponentially distributed [6, 45], or more generally, are stochastically comparable in pairs [44]. Some extensions of these optimality results to the problem with weights exist as well [23]. For more general distributions, simple solutions fail [42], and our knowledge of optimal scheduling policies is limited.

Identical machines, arbitrary processing times. To cope with these challenges, approximation algorithms have been studied. With the notable exception of [20], all approximation algorithms have performance guarantees that depend on an upper bound $\Delta$ on the squared coefficient of variation of the underlying random variables. Möhring, Schulz and Uetz [32] established the first approximation algorithms for stochastic scheduling on identical machines via a linear programming relaxation. Their work gave a $(3+\Delta)$-approximation when jobs are released over time (yet known offline), and they additionally showed that WSEPT is a $(3+\Delta)/2$-approximation when jobs arrive together111The ratio is slightly better, but for simplicity we ignore the additive $\Theta(1/m)$ term. . These results have been built on and generalized in several settings [40, 29, 28, 36, 39, 21], notably in [28, 36] for the online setting. The currently best known result when jobs are released over time (yet known offline) is a $(2+\Delta)$-approximation by Schulz [36]. In the online setting Schulz gives an algorithm with performance guarantee of $(2.309+1.309\Delta)$ [36]. These results build on an idea from Correa and Wagner [10] to use a preemptive, fast single machine relaxation, next to the relaxation of [32]. The work of Im, Moseley and Pruhs [20] gave the first results independent of $\Delta$ showing that there exist poly-logarithmic approximation algorithms under some assumptions. All these papers address problems with identical machines.

Unrelated machines, arbitrary processing times. For some 15 years after the results of Möhring et al. [32] for the identical machines case, no non-trivial results were known for the unrelated machines case despite being a target in the area. Recently Skutella, Sviridenko and Uetz [39] gave a $(3+\Delta)/2$-approximation algorithm for the unrelated machines model when jobs arrive at the same time, and a $(2+\Delta)$-approximation when jobs are released over time (yet known offline). Central to unlocking an efficient approximation algorithm for the unrelated machines case was the introduction of a time-indexed linear program that lower bounds the objective value of the optimal non-anticipatory scheduling policy. It is this LP that allows the authors to overcome the complexities of the stochastic unrelated machines setting.

The work introduced in this present paper targets the more realistic online setting for scheduling stochastic jobs on unrelated machines. A priori, it is not clear that there should exist an algorithm with small competitive ratio for this problem. Prior work for the offline problem requires sophisticated linear [39] or convex [3] programming relaxations. Good candidates for online algorithms that might also have practical impact are desired to be simple and combinatorial, but even discovering an offline approximation algorithm that is simple and combinatorial has remained an open problem for (stochastic) scheduling on unrelated machines.

Related work for deterministic processing times. For special cases and deterministic processing times, approximation algorithms have been known to exist. For example for the online unrelated machine case with deterministic processing times, Hall, Schulz, Shmoys and Wein [14] obtain an $8$-competitive algorithm. Their algorithm is based on the idea to partition time into geometrically increasing intervals, and then maximizing the total weight of (available) jobs that can be scheduled in these intervals. Algorithms with better competitive ratios have been obtained by Chakrabarti et al. [7] by using randomization in the definition of these intervals, and resulting in a randomized 5.78-competitive algorithm. As far as we know, this is the state of the art when it comes to competitive analysis for the online problem with release times and on unrelated machines. The deterministic greedy algorithm proposed in this paper is 6-competitive.

For the offline problem with deterministic processing times, the following is known. When there are no release times and processing times are deterministic, the currently best known approximation algorithms have performance bounds slightly below $3/2$, based on semidefinite relaxations [4] and more recently also on linear relaxations [26]. For the offline case with release times, the $(2+\varepsilon)$-approximation of [37] was the best known until recently Im and Li [18] gave a $1.878$-approximation algorithm. The problem has also been looked at through the lens of game theory, and for the offline problem without release times, Cole et al. [8] show that when machines follows the WSPT rule, Nash equilibria of selfish jobs that minimize their own completion time yield schedules which are at most a factor 4 above optimum. Interestingly, our paper shows that the same approximation guarantee can be obtained online by a simple greedy algorithm. We note that the work of [8] is offline, and moreover their algorithm and analysis differs from that of this paper.

With respect to lower bounds on performance guarantees of online algorithms, we are aware of only one lower bound on the competitive ratio of any online algorithm, which is the $1.309$ lower bound of Vestjens [43]; this lower bound holds for the problem on identical machines with deterministic processing times.

Results. This paper suggests two combinatorial online algorithm for stochastic scheduling on unrelated machines that have a performance guarantee of order $\textup{O}(\,\Delta\,)$, where $\Delta$ is an upper bound on the squared coefficient of variation of the processing time distributions $P_{ij}$. More specifically, in the online-list model where jobs arrive online (at time 0) and must be assigned to a machine immediately upon arrival, this paper establishes a performance guarantee of $(4+2\Delta)$. For this problem the algorithm assigns jobs to machines so as to minimize the expected contribution to the objective function, while per machine the jobs are sequenced by largest ratio $w_{i}/{\mathbb{E}}[P_{ij}]$ first. For deterministic processing times, the proposed greedy algorithm has a competitive ratio of 4, and the paper also gives a lower bound instance showing that the analysis is tight. Arguably more relevant is the online-time model where jobs arrive over time at individual release times. Here, the paper establishes a performance guarantee of $(7.216+3.608\Delta)h(\Delta)$, where $h(\Delta)=1+\sqrt{\Delta}/2$ for $\Delta\leq 1$, and $h(\Delta)=1+\Delta/(\Delta+1)$ for $\Delta\geq 1$. Observe that $h(\cdot)$ is a concave, increasing function of $\Delta$ which is bounded from above by $2$. Here, the greedy assignment of jobs to machines is the same, but the sequencing per machine is augmented by possibly introducing forced idle time. The idea is to work with a “nominal” schedule based on expected processing times, and never start processing a job before its nominal starting time. For deterministic processing times $\Delta=0$ and $h(\Delta)=1$, hence the competitive ratio equals $7.216$. As the algorithm is a deterministic algorithm, this improves upon the competitive ratio $8$ from [14], but falls slightly behind the randomized $5.78$-competitive algorithm that was proposed in [7].

Even though the performance bounds for the case with nontrivial release times are most probably not tight, we believe our results are interesting for the following reasons: (1) It is the first analysis of a combinatorial algorithm for stochastic scheduling on unrelated machines, and the first result for stochastic online scheduling in the unrelated machine model. (2) Even for the deterministic setting, it is the first time to analyze an (arguably) intuitive combinatorial algorithm that simply assigns jobs to machines where their expected contribution is minimal. (3) The analysis uses the idea of dual fitting, hence we demonstrate that this technique can be used for bounding the performance of scheduling policies in non-preemptive and stochastic scheduling. (4) The performance bounds, even where not tight, have the same order of magnitude as those of earlier results in the literature, while considering a more general problem.

We now briefly discuss the proposed algorithms in relation to prior work. The algorithms rest on the following ingredients to solve the machine assignment and the scheduling problem. Generally speaking, at any point in time a job with highest ratio $w_{j}/{\mathbb{E}}[P_{ij}]$ is scheduled from the set of jobs that are assigned to and available on machine $i$. This is the well known WSEPT rule. For the case with release dates, however, jobs possibly have to wait for “artificial” release times before they are declared available for processing. The necessity of such forced idle time is well known whenever jobs are released over time, even for single machine problems [27]. Next to this standard manipulation of release times, we work with a “nominal” schedule that is based on expected processing times, and never allow jobs to be started before their nominal starting times. The assignment of jobs to machines is solved by greedily assigning jobs to the machines where (a proxy for) the expected increase of the objective is minimal. Comparable greedy-type algorithms have been used also before, e.g. in [2, 27, 28], however not for an unrelated machine setting. Note that the $\Omega(\Delta)$ lower bound for fixed assignment policies in [39] yields that our results are asymptotically tight in $\Delta$ among policies that must irrevocably assign jobs to machines at the time of their release. As mentioned above, the analysis proposed in this paper uses dual fitting techniques. The technique has been used e.g. in [1] for deterministic and preemptive scheduling problems.

2 Notation & Preliminaries.

The input to the problem consists of a set of unrelated parallel machines $M$ of cardinality $m$. The set of jobs $J$, of cardinality $n$, is unknown and only disclosed gradually over time. Each job needs to be executed on exactly one (and any one) of the machines in $M$, and each machine can process at most one job at a time. The jobs are nonpreemptive. This means that a job, once started, must not be interrupted until its completion.

This paper considers two online models. In the first model, known as online-list, the scheduler is presented the jobs $j\in J$ one after the other. Whenever a job is presented, the algorithm has to assign it to one of the machines before the next job is presented. The decision when the job begins being processed can be deferred until all jobs have arrived. It is unknown how many jobs will arrive, but once all jobs in $J$ have arrived, the jobs assigned to any one of the machines must be sequenced on that machine in some order. In the second model, known as online-time, time progresses and jobs appear over time at their individual release times. Let $r_{j}$ denote the release time of job $j$. At the moment of arrival $r_{j}$, or possibly at a later point in time, a job must be assigned to a machine. Once assigned to a machine, the job may possibly wait until an even later point in time to be processed.

The jobs are stochastic, meaning that each job $j$’s processing time is revealed to the scheduler at the point of arrival in the form of a random variable $P_{ij}$ for every machine $i\in M$. If job $j$ is assigned to machine $i$, its processing time will be random according to $P_{ij}$. It is allowed that certain jobs $j\in J$ cannot be processed on certain machines $i\in M$, in which case ${\mathbb{E}}[P_{ij}]=\infty$.

In the stochastic scheduling model, the realization of the processing time of a job $j$ becomes known at the moment that the job completes. This paper considers designing a non-anticipatory scheduling policy $\Pi$ that minimizes the expected total weighted completion time {\mathbb{E}}\bigl{[}\sum_{j}w_{j}C_{j}\bigr{]}, where $C_{j}$ denotes the random variable for the completion time of job $j$ under policy $\Pi$.

We assume that the random variables $P_{ij}$ are discrete and integer valued. This can be assumed at the cost of a multiplicative factor of $(1+\varepsilon)$ in the final approximation ratio, for any $\varepsilon>0$ [39]. Our analysis will make use of the following facts about first and second moments of discrete random variables; these facts also appear in [39].

Lemma 2.1

Let $X$ be an integer-valued, nonnegative random variable. Then,

[TABLE]

Definition 2.2

Let $X$ be a nonnegative random variable. The squared coefficient of variation is defined as the scaled variance of $X$. That is,

[TABLE]

where ${\mathbb{V}\rm ar}[X]={\mathbb{E}}[X^{2}]-E[X]^{2}$.

2.1 Stochastic Online Scheduling & Policies

The setting considered in this paper is that of stochastic online scheduling as defined in [28]. This means that (the existence of) a job $j$ is unknown before it arrives, and upon arrival at time $r_{j}$, only the distribution of the random variables $P_{ij}$ for the possible processing times on machines $i=1,\dots,m$ are known to the scheduler. At any given time $t$, a non-anticipatory online scheduling policy is allowed to use only the information that is available at time $t$. In particular, it may anticipate the (so far) realized processing times of jobs up to time $t$. For example, a job that has possible sizes 1, 3 or 4 with probabilities 1/3 each, and has been running for 2 time units, will have a processing time 3 or 4, each with probability 1/2. It is well known that adaptivity over time is needed in order to minimize the expectation of the total weighted completion time, e.g. [42]. We refer the reader to [28] for a more thorough discussion of the stochastic online model.

For simplicity of notation, denote ${\mathsf{OPT}}$ as the expected total weighted completion time of an optimal, non-anticipatory scheduling policy for the problem where the set of jobs, their release times $r_{j}$ and their processing time distributions $P_{ij}$ are known in advance. That is to say, the benchmark that we compare our algorithms to, knows the set of jobs and their parameters, but not the actual realizations of processing time distributions $P_{ij}$.

We seek to find a non-anticipatory online scheduling policy (an algorithm) ${\mathsf{ALG}}$ with expected performance ${\mathsf{ALG}}$ close to ${\mathsf{OPT}}$. For convenience, and in a slight abuse of notation we use the same notation for both the algorithm and its expected performance. That is to say, both ${\mathsf{ALG}}$ and ${\mathsf{OPT}}$ denote the expected performance of non-anticipatory scheduling policies, and by linearity of expectation we have ${\mathsf{ALG}}=\sum_{j}w_{j}{\mathbb{E}}[C_{j}^{{\mathsf{ALG}}}]$ and ${\mathsf{OPT}}=\sum_{j}w_{j}{\mathbb{E}}[C_{j}^{{\mathsf{OPT}}}]$.

Definition 2.3

A scheduling policy is said to have a (multiplicative) performance guarantee $\alpha\geq 1$, if for every possible input instance,

[TABLE]

We remark that ${\mathsf{OPT}}$ is not restricted to assigning jobs to machines at the time of their arrival. The only restriction on ${\mathsf{OPT}}$ is that it must schedule jobs non-preemptively, and that it is non-anticipatory. Note that our approximation guarantees hold against an adversary who knows all the jobs and their release times $r_{j}$, as well as the processing time distributions $P_{ij}$ in advance, but not the actual realizations of $P_{ij}$. That implies that the model generalizes the classic offline stochastic scheduling model (assuming all paramaters are disclosed to the scheduler, too), as well as traditional competitive analysis (assuming deterministic processing times).

Finally, we may assume w.l.o.g. that no pair of job and machine exists with ${\mathbb{E}}[P_{ij}]=0$. That said, we may further assume that ${\mathbb{E}}[P_{ij}]\geq 1$ for all machines $i$ and jobs $j$, by scaling.

3 Linear Programming Relaxations.

This section introduces a linear programming relaxation for the problem. This relaxation was previously discussed in [39, §8]. The LP uses variables $y_{ijs}$ to denote the probability that job $j$ is being processed on machine $i$ within the time interval $[s,s+1]$, under some given and fixed scheduling policy. It is known that $y_{ijs}$ can be linearly expressed in terms of the variables $x_{ijt}$, which denote the probability that job $j$ is started at time $t$ on machine $i$, as follows

[TABLE]

The fact that any machine can process at most one job at a time can be written as

[TABLE]

Moreover, by the fact that scheduling policies are non-anticipatory we know that whenever a job $j$ is started on a machine $i$ at time $t$, it will in expectation be processed for time ${\mathbb{E}}[P_{ij}]$, so its expected completion time is $t+{\mathbb{E}}[P_{ij}]$. Now, conditioning on a job being processed on machine $i$, making use of (1) and the first part of Lemma 2.1, together with the fact that each job must be completely processed, gives the constraint that $\sum_{s\in{\mathbb{Z}}_{\geq 0}}\frac{y_{ijs}}{{\mathbb{E}}[P_{ij}]}=1$. Unconditioning on the machine assignment yields the following constraints

[TABLE]

Finally, with the help of (1) and the second part of Lemma 2.1, the expected completion time of a job $j$ can be expressed in $y_{ijs}$ variables as

[TABLE]

where we labeled the expected completion time variables with a superscript S for “stochastic”, for reasons that will become clear shortly. For completeness, equation (4) is proved in Lemma 8.1 (Appendix 8).

For the analysis to follow, we also need to express the fact that the expected completion time of a job cannot be smaller than its expected processing time, which is generally not implied by (4).

[TABLE]

The following LP relaxation for the unrelated machine scheduling problem can be derived with these observations. This LP extends the LP given in [39] by adding the constraints (5).

[TABLE]

The analysis in this paper will work with the dual of this relaxation. However the term $-\mathbb{CV}[P_{ij}]^{2}$ in the primal objective would appear in the dual constrains. As we do not know how to deal with this negative term in the analysis that is to follow, we are going to factor it out.

To that end, define a simpler, i.e., deterministic version for the expected completion times (4), labeled with “P” to distinguish it from the previous formulation, by letting

[TABLE]

Consider the following linear programming problem

[TABLE]

This corresponds to a time-indexed linear programming relaxation for a purely deterministic, unrelated machine scheduling problem where the random processing times are fixed at their expected values ${\mathbb{E}}[P_{ij}]$. Also note that we have dropped constraints (5).

In the following, a relationship between these two relaxations is established. To begin, define an upper bound on the squared coefficient of variation by

Definition 3.1

Define $\Delta$ as a universal upper bound on the squared coefficient of variation of the processing time of any job on any machine, that is

[TABLE]

Observe that $\Delta=0$ for deterministic processing times, and $\Delta=1$ for processing times that are NBUE (new better than used in expectation), that is, the expected remaing processing time of a job never exceeds its total expected processing time. Specifically, $\Delta=1$ for exponential distributions. Next, for any given solution $\boldsymbol{y}$ of (S) or (P), define

[TABLE]

Let $\boldsymbol{y}^{\ref{sto}}$ denote an optimal solution to (S) and recall that ${\mathsf{OPT}}$ is the expected total weighted completion time of an optimal non-anticipatory scheduling policy. By constraints (5),

[TABLE]

The following lemma establishes the relation between the two relaxations and is crucial for our analysis.

Lemma 3.2

The optimal solution values $z^{\ref{det}}$ and $z^{\ref{sto}}$ of the linear programming relaxations (P) and (S) fulfill

[TABLE]

Proof 3.3

Proof. Let $\boldsymbol{y}^{\ref{det}}$ be an optimal solution to (P) and $\boldsymbol{y}^{\ref{sto}}$ be an optimal solution to (S). Clearly, $\boldsymbol{y}^{\ref{sto}}$ is a feasible solution also for (P) which is less constrained. Hence we get the following, where $z^{\ref{det}}(\boldsymbol{y}^{\ref{det}})$ is the value of $\boldsymbol{y}^{\ref{det}}$ on LP (P).

[TABLE]

Note that the second-to-last inequality only uses the definitions of $\Delta$ and $H(\cdot)$. The last inequality holds because $H(\boldsymbol{y}^{\ref{sto}})\leq z^{\ref{sto}}(\boldsymbol{y}^{\ref{sto}})$. \halmos

Recalling that (S) is a relaxation for the stochastic scheduling problem, we conclude the following.

Corollary 3.4

The optimal solution value $z^{\ref{det}}$ of the linear programming relaxation (P) is bounded by the expected performance of an optimal scheduling policy by

[TABLE]

The dual program of (P) will have unconstrained variables $\alpha_{j}$ for all $j\in J$ and nonnegative variables $\beta_{is}$ for all $i\in M$ and $s\in{\mathbb{Z}}_{\geq 0}$:

[TABLE]

Like the analysis in [1], we will define a feasible solution for the dual (D), such that this solution corresponds to the schedule created by an online greedy algorithm for the original stochastic scheduling problem. Similar greedy algorithms have been used before, both in deterministic and stochastic scheduling on parallel machines, e. g. in [2, 27, 28].

4 Greedy Algorithm & Analysis for the Online-List Model.

In this section the online-list model is considered. Assume without loss of generality that the jobs are presented in the order $1,2\dots,|J|$. On any machine $i$, let $H(j,i)$ denote the jobs that have priority no less than that of job $j$ according to the ratios $w_{k}/{\mathbb{E}}[P_{ik}]$, breaking ties by index. That is,

[TABLE]

Note that $j\in H(j,i)$. Also let $L(j,i):=J\setminus H(j,i)$. Further let $k\to i$ denote that a job $k$ has been assigned to machine $i$ by the algorithm.

Greedy Algorithm (Online List Model).

Whenever a new job $j\in J$ is presented to the algorithm, compute for each of the machines $i\in M$ the instantaneous expected increase in the cost if job $j$ is assigned to machine $i$, and all jobs already present on $i$ are scheduled in non-increasing order of the ratios weight over expected processing time. Since the expected completion time of the new job $j$ will be determined by the sum of expected processing times of all jobs in $H(j,i)$, and all the jobs in $L(j,i)$ will be delayed in expectation by an additional time ${\mathbb{E}}[P_{ij}]$, this cost increase equals

[TABLE]

The greedy algorithm assigns the job to one of the machines where this quantity is minimal. That is, a job is assigned to machine m(j):=\text{argmin}_{i\in M}\{\mbox{\textup{cost}(j\to i)}\}; ties broken arbitrarily. Once all jobs have arrived and are assigned, the jobs assigned to a fixed machine are sequenced in non-increasing order of their ratio of weight over expected processing time. This WSEPT ordering is optimal conditioned on the given assignment [35].

The analysis of this greedy algorithm will proceed by defining a dual solution $(\alpha,\beta)$ in a way similar to that done in [1]. Let

[TABLE]

That is, $\alpha_{j}$ is defined as the instantaneous expected increase in the total weighted completion time on the machine job $j$ is assigned to by the greedy algorithm. Let

[TABLE]

where $A_{i}(s)$ is defined as the total set of jobs assigned to machine $i$ by the greedy algorithm, but restricted to those that have not yet been completed by time $s$ if the jobs’ processing times were their expected values ${\mathbb{E}}[P_{ij}]$. In other words, $\beta_{is}$ is exactly the expected total weight of yet unfinished jobs on machine $i$ at time $s$, given the assignment (and sequencing) of the greedy algorithm.

It is now shown that these dual variables are feasible for the dual linear program. Later this fact will allow us to relate the variables to the optimal solution’s objective.

Lemma 4.1

The solution $(\boldsymbol{\alpha}/2,\boldsymbol{\beta}/2)$ is feasible for (D).

Proof 4.2

Proof. This proof shows that

[TABLE]

holds for all $i\in M$, $j\in J$, and $s\in{\mathbb{Z}}_{\geq 0}$. This implies the feasibility of $(\boldsymbol{\alpha}/2,\boldsymbol{\beta}/2)$ for (D). Fix a job $j$ and machine $i$, and recall that $k\to i$ denotes a job $k$ being assigned to machine $i$ by the greedy algorithm. By definition of $\alpha_{j}$ and by choice of $m(j)$ as the minimizer of $\textup{cost}(j\to i)$, for all $i$ it is the case that

[TABLE]

Next, we are going to argue that the right-hand-side of (9) is upper bounded by the right-hand side of (8), from which the claim follows. Observe that the term $w_{j}$ cancels. Observe that any job $k\to i$, $k\neq j$, can appear in the right-hand side of (9) at most once, either with value $w_{k}$, namely when $k\in L(j,i)$, or with value $w_{j}{\mathbb{E}}[P_{ik}]/{\mathbb{E}}[P_{ij}]\leq w_{k}$ when $k\in H(j,i)$. We show that each of these values in the right-hand-side of (9) is accounted for in the right-hand side of (8), for any $s\geq 0$.

Fix any such job $k\to i$. First consider the case that the time $s$ is small enough so that our job $k\to i$ is still alive at time $s$, so $s<\sum_{\ell\to i,\ell\in H(k,i)}{\mathbb{E}}[P_{i\ell}]$. Then, $w_{k}$ is accounted for in the definition of $\beta_{is}$.

Now consider the case that $s\geq\sum_{\ell\to i,\ell\in H(k,i)}{\mathbb{E}}[P_{i\ell}]$, which means that job $k$ is already finished at time $s$. In this case, we distinguish two cases.

Case 1* is $k\in L(j,i)$: In this case, job $k$ contributes to the right-hand side of (9) a value of $w_{k}$, but as $s\geq\sum_{\ell\to i,\ell\in H(k,i)}{\mathbb{E}}[P_{i\ell}]$, the term $w_{j}({s}/{{\mathbb{E}}[P_{ij}]})$ in the right-hand side of (8) contains the term $w_{j}({\mathbb{E}}[P_{ik}]/{\mathbb{E}}[P_{ij}])\geq w_{k}$.*

Case 2* is $k\in H(j,i)$: In this case, job $k$ contributes to the right-hand side of (9) a value of $w_{j}({\mathbb{E}}[P_{ik}]/{\mathbb{E}}[P_{ij}])$, which is exactly what is also contained in the term $w_{j}({s}/{{\mathbb{E}}[P_{ij}]})$, because $s\geq\sum_{\ell\to i,\ell\in H(k,i)}{\mathbb{E}}[P_{i\ell}]$. \halmos*

In the following lemma, the online algorithm’s objective is expressed in terms of the dual variables, which follows more or less directly from the definition of the dual variables $(\boldsymbol{\alpha},\boldsymbol{\beta})$. Let us denote by ${\mathsf{ALG}}$ the total expected value achieved by the greedy algorithm.

Lemma 4.3

The total expected value of the greedy algorithm is

[TABLE]

Proof 4.4

Proof. For the first equality, recall that $\alpha_{j}$ is the instantaneous increase in ${\mathsf{ALG}}$’s expected total weighted completion time. Summing this over all jobs gives exactly the total expected value of ${\mathsf{ALG}}$’s objective. For a formal proof of this, see for example [28, Lemma 4.1] for the case of parallel identical machines. That lemma and its proof can directly be applied to the case of unrelated machines.

The second equality follows from the fact that the (expected) total weighted completion time of any schedule can be alternatively expressed by weighting each period of time by the total weight of yet unfinished jobs. The equality is true here, because $\boldsymbol{\beta}$ was defined on the basis of the same distribution of jobs over machines as given by ${\mathsf{ALG}}$, and because each job $k$’s weight $w_{k}$, given $k\to i$, appears in $\beta_{is}$ for all times $s$ up to a job $k$’s expected completion time, given jobs’ processing times are fixed to their expected values. This is exactly what happens in computing the expected completion times under the greedy algorithm, because it is a “fixed assignment” algorithm that assigns all jobs to machines at time [math], and sequences the jobs per machine thereafter. \halmos

5 Speed Augmentation & Analysis

The previous analysis of the dual feasible solution $(\boldsymbol{\alpha}/2,\boldsymbol{\beta}/2)$ yields a dual objective value equal to [math] by Lemma 4.3. This is of little help to bound the algorithm’s performance. However following [1], define another dual solution which has an interpretation in the model where all machines run at faster speed $f\geq 1$, meaning in particular that all (expected) processing times get scaled (down) by a factor $f$.

Define ${\mathsf{ALG}}^{f}$ as the expected solution value obtained by the same greedy algorithm, except that all the machines run at a speed increased by a factor of $f$, where $f\geq 1$ is an integer. Note that ${\mathsf{ALG}}=f{\mathsf{ALG}}^{f}$, by definition. We denote by $(\boldsymbol{\alpha}^{f},\boldsymbol{\beta}^{f})$ the exact same dual solution that was defined before, only for the new instance with faster machines. The following establishes feasibility of a slightly modified dual solution.

Lemma 5.1

Whenever $f\geq 2$, the solution $(\boldsymbol{\alpha}^{f},\frac{1}{f}\boldsymbol{\beta}^{f})$ is a feasible solution for the dual (D) in the original $($unscaled $)$ problem instance.

Proof 5.2

Proof. By definition of $(\boldsymbol{\alpha}^{f},\frac{1}{f}\boldsymbol{\beta}^{f})$, to show feasibility for (D) it suffices to show the slightly stronger constraint that

[TABLE]

for all $i,j,s$. Indeed, in the above inequality we have only dropped the nonnegative term ${w_{j}}/{(2{\mathbb{E}}[P_{ij}])}$ from the right-hand side of (D), hence the above implies the feasibility of $(\boldsymbol{\alpha}^{f},\frac{1}{f}\boldsymbol{\beta}^{f})$ for (D). By definition of $\boldsymbol{\alpha}$ we have $\alpha_{j}=f\alpha_{j}^{f}$. So the above is equivalent to

[TABLE]

As the assumption was that $f\geq 2$, (10) is implied by

[TABLE]

Now observe that $\beta^{f}_{is}=\beta_{i(f\cdot s)}$ (and recall that $f$ is integer), so (11) is nothing but inequality (8) with variable $s$ replaced by $f\cdot s$. The validity of (11) therefore directly follows from (8) in our earlier proof of Lemma 4.1 to demonstrate the feasibility of $(\boldsymbol{\alpha}/2,\boldsymbol{\beta}/2)$ for (D). \halmos

The first main theorem of the paper is now established.

Theorem 5.3

The greedy algorithm has a performance guarantee of $(4+2\Delta)$ for online scheduling of stochastic jobs on unrelated machines to minimize the expectation of the total weighted completion times ${\mathbb{E}}[\sum_{j}w_{j}C_{j}]$. That is, ${\mathsf{ALG}}\leq(4+2\Delta){\mathsf{OPT}}$.

Proof 5.4

Proof. We know from Corollary 3.4 that z^{\ref{dual}}(\boldsymbol{\alpha}^{f},\frac{1}{f}\boldsymbol{\beta}^{f})\leq z^{\ref{dual}}=z^{\ref{det}}\leq\bigl{(}1+\frac{\Delta}{2}\bigr{)}{\mathsf{OPT}}\,, given that $f\geq 2$. Next, recall that ${\mathsf{ALG}}^{f}=\sum_{j\in J}\alpha^{f}_{j}=\sum_{i\in M}\sum_{s\in{\mathbb{Z}}_{\geq 0}}\beta^{f}_{is}$ by Lemma 4.3, and ${\mathsf{ALG}}=f{\mathsf{ALG}}^{f}$. The theorem now follows from evaluating the objective value of the specifically chosen dual solution $(\boldsymbol{\alpha}^{f},\frac{1}{f}\boldsymbol{\beta}^{f})$ for (D), as

[TABLE]

Putting together this equality with the previous inequality yields a performance bound equal to $\frac{f^{2}}{f-1}(1+\frac{\Delta}{2})$, where we have the constraint that $f\geq 2$. This term is minimal and equal to $(4+2\Delta)$, exactly when we choose $f=2$. \halmos

We end this section with the following theorem, which we believe was unknown before.

Theorem 5.5

The greedy algorithm for the deterministic online scheduling problem has competitive ratio 4 for minimizing the total weighted completion times $\sum_{j}w_{j}C_{j}$ on unrelated machines, and there is a tight lower bound of $4$ for the performance of the greedy algorithm.

Proof 5.6

Proof. The upper bounds follows as a special case of Theorem 5.3 as $\Delta=0$. As to the lower bound, we use a parametric instance from [9], which we briefly reproduce here for convenience. The instances are denoted $I^{k}$, where $k\in\mathbb{N}$. There are $m$ machines, with $m$ defined large enough so that $m/h^{2}\in\mathbb{N}$ for all $h=1,\dots,k$. There are jobs $j=(h,\ell)$ for all $h=1,\dots,k$ and all $\ell=1,\dots,m/h^{2}$. The processing times of a job $j=(h,\ell)$ on a machine $i$ is defined as

[TABLE]

In other words, job $j=(h,\ell)$ can only be processed on machines $1,\dots,\ell$. All jobs have weight $w_{j}=1$. As jobs have unit length on the machines on which they can be processed, we assume that the greedy algorithm breaks ties on each machine so that jobs with larger second index $\ell$ go first.

The optimal schedule is to assign all jobs $j=(h,\ell)$ to machine $\ell$, resulting in $m/h^{2}$ jobs finishing at time $h$, for $h=1,\dots,k$, and hence a total cost $m\sum_{h=1}^{k}1/h$. Now assume that the online sequence of jobs is by decreasing order of their second index. Then, as this is the same priority order as on each of the machines, the greedy algorithm assigns each job at the end of all previously assigned jobs. That means that the greedy algorithm assigns each job $j$ to one of the machines that minimizes its own completion time $C_{j}$. Here we assume that ties are broken in favour of lower machine index. It is shown in [9] that the resulting schedule, which is in fact a Nash equilibrium in the game where jobs select a machine to minimize their own completion time, has a total cost at least 4m\sum_{i=1}^{k}1/i-\mbox{\textup{O}(,m,)}. The lower bound of $4$ follows by letting $k\to\infty$. \halmos

6 The Online Time Model.

This section addresses the online-time model where jobs arrive over time; that is, a job $j$ arrives at release time $r_{j}\geq 0$. In particular, the presence of job $j$ is unknown before time $r_{j}$. Upon At time $r_{j}$, the job becomes available and the processing times distributions $P_{ij}$ become known, for all machines $i=1,\dots,m$. We may assume w.l.o.g. jobs are indexed such that $r_{j}\leq r_{k}$ for $j<k$.

The difficulty in analyzing the problem where jobs arrive over time lies in jobs that block a machine for a long time, while shortly after, other jobs might be released that cannot be scheduled. This is a well known problem for the total weighted completion time objective in general, even for a single machine [27]. In order to counter that effect, a job $j$ is only started after an additional, forced delay that depends on its own expected processing time. For example for identical machine problems, [27] and [28] work with modified release times of the form $r_{j}^{\prime}:=\max\{r_{j},c{\mathbb{E}}[P_{j}]\}$, for some parameter $c>0$. Another idea to counter the same effect has been used in [36], namely to start a job no earlier than its (expected) starting time in a preemptive relaxation on a single machine that works $m$ times faster. For the unrelated machine problem that we consider here, we use a combination of these two ideas. The assignment of jobs to machines will follow the same idea as for the case without release dates, namely to assign a job to a machine where (an approximation of) the expected increase of the objective value is minimal. Once assigned to a machine, for the stochastic case the modified release times will be defined on the basis of a “nominal” schedule where processing times $P_{ij}$ are fixed at their expected values ${\mathbb{E}}[P_{ij}]$. For that reason, this section first considers the deterministic problem where the processing times are defined by $p_{ij}:={\mathbb{E}}[P_{ij}]$ for all jobs $j$ and machines $i$.

6.1 Nominal Schedule: Online Time Model with Deterministic Processing Times.

Let us first describe the greedy algorithm that is used to assign jobs to machines and schedule jobs on machines. Per machine, it is actually the same greedy WSPT rule that prefers to schedule jobs with highest ratios weight over processing time $w_{j}/p_{ij}$, with the only difference that we also take into account modified release times. The assignment of jobs to machines is done greedily, too.

Greedy Algorithm (Online Time Model for Deterministic Processing Times).

Consider any fixed job $j$ that is is released at time $t=r_{j}$ with processing times $p_{ij}$ on machines $i=1,\dots,m$. Then we proceed as follows.

Define modified release times: On machine $i$ the release time of job $j$ is modified to $r_{ij}:=\max\{r_{j},c\cdot p_{ij}\}$; we will optimize parameter $c$ later. 2. 2.

Let $U_{i}(t)$ denote the jobs which have been assigned to machine $i$ at time $t$ and that have not been started yet (excluding the fixed job $j$). 3. 3.

To decide on the assignment of job $j$ to a machine, we define $\textup{cost}(j\to i)$ as an upper bound on the additional cost of job $j$, when included into a hypothetical greedy WSPT schedule of jobs $U_{i}(r_{j})$ on machine $i$. The reason to work with an upper bound instead of the exact value, is potential jobs that could be released in the interval $(r_{j},r_{ij})$. These could delay the earliest possible start time of job $j$ beyond $r_{ij}$. In defining $\textup{cost}(j\to i)$, we account for the maximum additional delay that such jobs could impose on $j$; see Lemma 6.2 below. 4. 4.

Among all machines $i\in\{1,\dots,m\}$, assign job $j$ to a machine $m(j)$ that minimizes $\textup{cost}(j\to i)$, ties broken arbitrarily. 5. 5.

On each machine $i$, we schedule jobs following the greedy weighted shortest processing time rule (WSPT) with modified release times $r_{ij}$. That is, as soon as a machine falls idle at time $t$, we schedule among all unscheduled jobs $k$ assigned to machine $i$ with $r_{ik}\leq t$, any job $j$ with maximal ratio $w_{k}/p_{ik}$.

Analysis.

We now show that this greedy online algorithm is 7.216-competitive. This is interesting in its own right because it improves on the best prior algorithm that was known to be $8$-competitive [14]. As before, let us denote by ${\mathsf{ALG}}$ the total value achieved by the greedy algorithm, and ${\mathsf{OPT}}$ to be the optimal solution value.

Definition 6.1

For job $j$ and machine $i$, define

[TABLE]

Lemma 6.2

If $m(j)$ is the machine to which job $j$ got assigned by the greedy algorithm, then

[TABLE]

Proof 6.3

*Proof. Let $X_{i}(t)$ be the remaining processing time of a job that is in process on machine $i$ at time $t$, with $X_{i}(t)=0$ if no such job exists. Consider a fixed job $j$’s contribution to $\sum_{j}w_{j}C_{j}$. When job $j$ is released at time $r_{j}$, it is assigned to a machine that minimizes $\textup{cost}(j\to i)$. We estimate the latest starting time of job $j$ on machine $i$, given the jobs $U_{i}(r_{j})$ that have been assigned to the same machine: First, job $j$ can be started no earlier than time $r_{ij}$, and at time $r_{ij}$, the machine might be blocked for another $X_{i}(r_{ij})$ time units by some job $h$. Note that such job $h$ could even get released later than $r_{j}$, in time interval $(r_{j},r_{ij})$. Independent of this, $j$’s start can be further delayed by “high priority jobs” $k$ from $U_{i}(r_{j})$, meaning that $w_{k}/p_{ik}\geq w_{j}/p_{ij}$. Finally, job $j$ could in turn delay the “low priority jobs” from $U_{i}(r_{j})$.

Hence, the increase of $\sum_{j}w_{j}C_{j}$, caused by job $j$ being assigned to machine $i$, is at most*

[TABLE]

To see why the inequality is true, let $h$ be the potential job in process at time $r_{ij}$, then

[TABLE]

*The claim now follows by summing over all jobs $j\in J$, and because of the following observation: In time interval $(r_{j},r_{ij})$, even more “high priority jobs” $k$ could get released, and such jobs $k$ cause $j$’s start being delayed even further. But the delay that these jobs will impose on $j$, will be accounted for in the term $\textup{cost}(k\to i)$. The set of all “low priority jobs” that could get released in interval $(r_{j},r_{ij})$, can cause $j$’s start being delayed by at most $X_{i}(r_{ij})$.

\halmos*

Theorem 6.4

The greedy algorithm for the deterministic online scheduling problem with release times has competitive ratio ${7.216}$ for minimizing the total weighted completion times $\sum_{j}w_{j}C_{j}$ on unrelated machines. That is, ${\mathsf{ALG}}\leq{7.216}\,{\mathsf{OPT}}$.

Proof 6.5

*Proof. Let $m({j})$ be the machine to which job ${j}$ got assigned. Define *

[TABLE]

By definition of $\alpha$, $\beta$, and by Lemma 6.2 we then have

[TABLE]

For this analysis, we again consider a speed scaled problem instance, but now we need to modify both the release times and the processing times by a factor $f$ as follows.

[TABLE]

Consider the same greedy algorithm on the scaled instance. Observe that the machine assignment in the speed scaled instance is the same as in the original instance. In fact, the speed scaled instance just scales time by a factor of $f$. Define, $\alpha_{j}^{f}$ analogously as the upper bound on the increase in total weighted completion time due to the presence of job $j$ in the speed scaled instance, and $\beta^{f}_{i,s}$ as the weight of the unfinished jobs on machine $i$ at time $s$ in the speed scaled instance. Then

[TABLE]

(Here we assume w.l.o.g. that all job sizes and release times are integer multiples of $f$, which can be achieved by scaling.) Also, let us denote by ${\mathsf{ALG}}^{f}$ the value achieved by the greedy algorithm for the speed scaled instance, and note that ${\mathsf{ALG}}^{f}=\sum_{i,s}\beta_{i,s}^{f}={\mathsf{ALG}}/f{\leq\sum_{j}\alpha_{j}^{f}}$.

In the next section we are going to prove Lemma 6.6 which gives a lower bound on the optimal solution value ${\mathsf{OPT}}$, again via some feasible solution for the dual of a linear programming relaxation of the form $\left(\frac{\boldsymbol{\alpha}^{f}}{a},\frac{\boldsymbol{\beta}^{f}}{b}\right)$ for constants $(a,b)$, which will yield that

[TABLE]

or

[TABLE]

Now setting parameters $c=2/3$, $a=32/23,b=16/3$, and speed $f=23/6$ are feasible choices for using Lemma 6.6, which gives ${\mathsf{ALG}}\leq{(7+11/51)\cdot{\mathsf{OPT}}<7.216}\cdot{\mathsf{OPT}}$. \halmos

6.2 Linear Programming Relaxation and Dual Lower Bound.

Analogous to the earlier linear programming relaxation (S), we can define the same LP relaxation for the instance with release times $r_{j}$. We omit repeating this LP relaxation here as it is exactly the same as (S), except that the variables $y_{ijs}$ are defined only for times $s\geq r_{j}$. Let us refer to this modified LP relaxation for the problem with release dates $(\textup{S}_{r})$, and its optimal solution value $z^{S_{r}}$. Similarly, analogous to (P) we can define an LP relaxation for the deterministic version of the same problem with deterministic processing times ${\mathbb{E}}[P_{ij}]$, by dropping all terms $-\mathbb{CV}[P_{ij}]^{2}$ from the relaxation $(\textup{S}_{r})$, and eliminating constraints (5). Let us refer to this deterministic LP relaxation $(\textup{P}_{r})$ with optimal solution value $z^{P_{r}}$. Lemma 3.2 and Corollary 3.4 apply to this linear programming relaxation in exactly the same way as before. That is, when ${\mathsf{OPT}}$ denotes the expected value of an optimal stochastic scheduling policy for the unrelated machine scheduling problem with release dates, we have that

[TABLE]

Specifically, for the purpose of the proof of Theorem 6.4, observe that for the case of deterministic processing times where $\Delta=0$, the optimal LP solution value $z^{P_{r}}$ is simply a lower bound for ${\mathsf{OPT}}$.

Dual Lower Bound.

By duality, we can lower bound the optimal solution value $z^{P_{r}}$ for LP relaxation $(\textup{P}_{r})$ by any feasible solution to its dual linear program, which is:

[TABLE]

Lemma 6.6

With $\boldsymbol{\alpha}^{f}$ and $\boldsymbol{\beta}^{f}$ as defined in (12), the values $(\frac{\boldsymbol{\alpha}^{f}}{a},\frac{\boldsymbol{\beta}^{f}}{b})$ are a feasible solution for the dual ($\textup{D}_{r}$), given that $af\geq 2(2+c)$, $1/c\leq f(a-1)$, and $af\geq b$. Specifically for $c=2/3$, $a=32/23,b=16/3$, and speed $f=23/6$, the objective function value of the dual solution yields $z^{D_{r}}(\frac{\boldsymbol{\alpha}^{f}}{a},\frac{\boldsymbol{\beta}^{f}}{b})\ {\geq\ \frac{{\mathsf{ALG}}}{f}(\frac{1}{a}-\frac{1}{b})\ =\ \frac{{\mathsf{ALG}}}{7+11/51}}$.

Proof 6.7

Proof. We are only left to show the feasibility of the solution $(\frac{\boldsymbol{\alpha}^{f}}{a},\frac{\boldsymbol{\beta}^{f}}{b})$. For convenience, let us write $p_{ij}$ for ${\mathbb{E}}[P_{ij}]$. Then the dual constraints require that, for all jobs $j$ and machines $i$, and for all times $s\geq r_{j}$

[TABLE]

Let us fix job $j$ and machine $i$. Plugging in the values $\alpha^{f}_{j}/a$ and $\beta^{f}_{is}/b$, we need to show

[TABLE]

for all $s\geq r_{j}$. Equivalently, noting that $\boldsymbol{\alpha}^{f}=\boldsymbol{\alpha}/f$, we have to show that

[TABLE]

Since $\beta^{f}_{is}=\beta_{i,fs}$ (the version with machines’ speeds scaled by $f$ is just scaling down time by factor of $f$), and replacing $s+\frac{1}{2}$ by $s$, it therefore suffices to show

[TABLE]

for all $s\geq r_{j}$. Due to Lemma 6.2, and our choice of $\alpha_{j}$ as minimizer of $\textup{cost}(j\to i)$ we have for all machines $i$

[TABLE]

Hence it suffices to show that the right hand side in (18) is upper bounded by the right hand side in (17). To that end, we even show a slightly stronger inequality is true: Recall that $\beta_{i,fs}$ is the total weight of jobs $k$ assigned to machine $i$ and unfinished at time $fs$ but with $r_{k}\leq fs$. As long as $f\geq 1$, and since $r_{j}\leq s$, we have $r_{j}\leq fs$. Hence, $\beta_{i,fs}\geq\sum_{k:m(k)=i,r_{k}\leq r_{j},C_{k}\geq fs}w_{k}\geq\sum_{k\in U_{i}(r_{j}),C_{k}\geq fs}w_{k}$. Therefore it suffices to show that the right hand side of (18) is bounded from above by

[TABLE]

Multiplying everything with $p_{ij}$, we therefore need to argue that the following inequality is true

[TABLE]

Let us rewrite this more conveniently as

[TABLE]

The following observations and conditions are sufficient for the above inequality to be true.

$I\leq I^{*}$*: Distinguish two cases. When $r_{ij}=r_{j}$, we have $I=(1+\frac{1}{c})r_{ij}+p_{ij}=r_{j}+\frac{r_{j}}{c}+p_{ij}$. Moreover, since $s\geq r_{j}$, $I^{*}=(fs(a-1)+r_{j})+p_{ij}\cdot\frac{af}{2}\geq r_{j}+f(a-1)r_{j}+p_{ij}\cdot\frac{af}{2}$. Therefore, we get that $I\leq I^{*}$ under the conditions that $1/c\leq f(a-1)$, and $af\geq 2$. On the other hand, when $r_{ij}=cp_{ij}$, we get $I=(2+c)p_{ij}$, and we get that $I\leq I^{*}$ under the condition that $2(2+c)\leq af$, whenever $a\geq 1$. Summarizing, we get that $I\leq I^{*}$ for both cases, conditioned on $1/c\leq f(a-1)$ and $2(2+c)\leq af$. * 2. 2.

$II\leq II^{*}$* : We have by definition of $U_{i}(r_{j})$ that*

[TABLE]

Therefore, under the condition that $\frac{af}{b}\geq 1$, we get that $II\leq II^{*}$, because then

[TABLE]

\halmos

6.3 Online Time Model with Stochastic Processing Times.

Let us first describe how we modify the greedy algorithm from the preceding section for the case with stochastic processing times.

Greedy Algorithm (Online Time Model with Stochastic Processing Times).

When job sizes are stochastic, we use exactly the same greedy assignment of jobs to machines as we used in the preceding section for the deterministic case using processing times $p_{ij}:={\mathbb{E}}[P_{ij}]$.

The only difference lies is the scheduling of jobs per machine, which works by restricting jobs to start no earlier than in the “nominal” schedule with deterministic processing times $p_{ij}={\mathbb{E}}[P_{ij}]$. Specifically, the jobs assigned to any machine $i$ are scheduled exactly in the same order as in the nominal schedule, with the $\ell$th job to start on machine $i$ starting at time

[TABLE]

Here, $s_{i,\ell}$ denotes the deterministic starting time of the $\ell$th job in the nominal schedule where $p_{ij}={\mathbb{E}}[P_{ij}]$ for all jobs $j$ and machines $i$. Here, note that the identity of the $\ell$th job to be scheduled on machine $i$ is the same in both cases. Also note that for the greedy algorithm for the stochastic case, the assignment of jobs to machines is deterministic, and not dependent on the realized processing times of jobs. The following two remarks are probably helpful.

1. Remark 1.

One may wonder if and how the algorithm can actually be executed online? This simply works by concurrently building the greedy WSPT schedule with deterministic processing times $p_{ij}:={\mathbb{E}}[P_{ij}]$. Consider any job $j$ that was released at time $r_{j}$. For the assignment of job $j$ to its correct machine $i=m(j$), indeed only information is needed that is available at time $r_{j}$. Also observe that it may be the case that neither the value $s_{i,j}$ is necessarily known at time $r_{j}$, nor which of the jobs are the predecessors of job $j$ on machine $i$. But this is not necessary, as job $j$ is simply blocked for processing as long as the same job has not started being processed in the corresponding deterministic schedule. 2. Remark 2.

Observe that we may introduce forced idleness before the processing of any job $j$. That is, even if the machine $i=m(j)$ is idle, we might not process any of the available jobs, and this delay depends on the nominal schedule for the underlying deterministic instance with $p_{ij}={\mathbb{E}}[P_{ij}]$. One may wonder why this forced idleness is actually necessary? Apart from the analysis that is to come, the reason to do that can most easily be seen by considering the following example: There are $n^{2}$ “bad” jobs of weight $\epsilon\ll 1$ released at time 0 with i.i.d. processing requirements $P_{bad}=0$ with probability $1-1/n^{2}$ and $P_{bad}=n$ with probability $1/n^{2}$, and one “good” job released at time 1 with weight 1 and deterministic processing time of 1. With the proposed algorithm that never starts a job before its starting time in the nominal schedule, we can schedule at most $n$ bad jobs before the good job is released, because ${\mathbb{E}}[P_{bad}]=1/n$. That yields {\mathbb{E}}[C_{good}]=\mbox{\textup{O}(,1,)}. However without the this forced idle time, a greedy algorithm would keep scheduling bad jobs until there are none (if all are of size 0), or a rare long bad job is encountered. That yields ${\mathbb{E}}[C_{good}]=\Omega(n)$, which is problematic.

The analysis of the greedy algorithm for the stochastic setting is based on a comparison with the nominal schedule, as expressed in the following lemma.

Lemma 6.8

The expected starting time of a job $j$ on machine $i$ in the stochastic case is bounded in terms of its starting time in the underlying nominal schedule222We write $S_{i,j}$ to indicate that job $j$ was assigned to machine $i$, only for notational convenience. As the assignment of jobs to machines is deterministic, observe that $S_{j}=S_{i,j}$. by ${\mathbb{E}}[S_{i,j}]\leq h(\Delta)s_{i,j}$, where

[TABLE]

Observe that $h(\,\cdot\,)$ is a concave, increasing function of $\Delta$, that $h(\Delta)\leq 2$ for all $\Delta\geq 0$, and $h(0)=1$. Specifically, Lemma 6.8 implies the weaker bound ${\mathbb{E}}[S_{i,j}]\leq 2s_{i,j}$.

Proof 6.9

Proof. For simplicity of notation, let us say that the jobs $k=1,\dots j$ are the jobs that have been assigned to machine $i$, in this order. By definition of the algorithm for the stochastic setting, and by the fact that both the assignment to machines and the sequencing per machine is identical to the nominal schedule, the following equality holds per realization of the processing times.

[TABLE]

Noting that the function $F_{i,j}$ is non-decreasing, Lipschitz continuous with coefficient 1 in each of its coordinates, and $F_{i,j}({\mathbb{E}}[P_{i,1}],\cdots,{\mathbb{E}}[P_{i,j-1}])=s_{i,j}$, we have:

[TABLE]

The last inequality holds since for the nominal schedule, the $j$th job can not begin before time $\sum_{k=1}^{j-1}{\mathbb{E}}[P_{ik}]$, which means that $s_{i,j}\geq\sum_{k=1}^{j-1}{\mathbb{E}}[P_{ik}]$. \halmos

We conclude with the main theorem of this section.

Theorem 6.10

The greedy algorithm has a performance guarantee of $(7.216+3.608\Delta)h(\Delta)$ for online scheduling of stochastic jobs with release times on unrelated machines to minimize the expectation of the total weighted completion times ${\mathbb{E}}[\sum_{j}w_{j}C_{j}]$. That is, ${\mathsf{ALG}}\leq{(7.216+3.608\Delta)}h(\Delta){\mathsf{OPT}}$.

Proof 6.11

Proof. Let us denote by $C_{j}^{P}$ the completion time of job $j$ in the nominal schedule as computed by the greedy algorithm as described in Section 6.1, where $p_{ij}={\mathbb{E}}[P_{ij}]$. Let us denote by ${\mathsf{ALG}}_{P}=\sum_{j}w_{j}C_{j}^{P}$ the objective value achieved by that nominal schedule. Also, let us denote by ${\mathsf{ALG}}=\sum_{j}w_{j}{\mathbb{E}}[C_{j}^{S}]$ the expected performance of the greedy algorithm for the stochastic case as described in this section.

It follows from Lemma 6.8 that the expected completion time of any job $j$ under the greedy algorithm for the stochastic case fulfils ${\mathbb{E}}[C_{j}]\leq h(\Delta)C_{j}^{P}$, and therefore

[TABLE]

What we have shown in Lemma 6.6 is that there exists a solution to the dual LP relaxation $(\textup{D}_{r})$ with value ${\geq{\mathsf{ALG}}_{P}/(7+11/51)>{\mathsf{ALG}}_{P}/7.216}$. Therefore by LP duality we get that ${\mathsf{ALG}}_{P}\leq{7.216}z^{P_{r}}$, with $z^{P_{r}}$ being the optimal solution value for the LP relaxation $(\textup{P}_{r})$. That yields

[TABLE]

Here, the third inequality follows by (13). \halmos

7 Conclusions

The performance guarantees for the greedy algorithm obtained in this paper are in the order $\textup{O}(\,\Delta\,)$, which is the same order of magnitude as earlier results that have been obtained for offline problems on unrelated machines [39], and of the same order of magnitude as earlier bounds for the online identical machines setting [28]. Getting results independent of $\Delta$ is an interesting open problem.

We also believe that the presented competitive analyses for the online deterministic problems are interesting in their own right, even if better competitive ratios can be obtained. We think so because the proposed greedy algorithm is (arguably) simple and intuitive, and hence practical. Finding a (matching) lower bound for the case with release times would be interesting.

Another direction for future work is the derivation of genuine lower bounds on the approximability of the optimal expected performance of efficiently computable policies for stochastic scheduling problems, even in the offline setting. This would allow to separate the computational complexity of stochastic problems from the corresponding deterministic special cases.

Acknowledgements.

This work was started while all four authors were with the Simons Institute for the Theory of Computing at UC Berkeley. The authors wish to thank the institute for the financial support and the organizers of the semester on “Algorithms & Uncertainty” for providing a very stimulating atmosphere. A conference publication with preliminary results appeared in the proceedings of IPCO 2017 [13]. B. Moseley was employed at Washington University in St. Louis while some of this research was conducted. B. Moseley was supported in part by a Google Research Award, a Yahoo Research Award and NSF Grant CCF-1830711, 1824303, and 1733873. All authors wish to express their gratitude to the referees for their helpful comments and for challenging us to improve the results. Special thanks to Sven Jäger from TU Berlin, for pointing out a flaw in one of the proofs in a previous version of this paper.

8 Auxiliary Lemmas

Lemma 8.1

We focus on a single machine and job. Let $P$ denote the random variable for the processing time with support ${\mathbb{Z}}_{>0}$. Let $x_{t}$ denote the probability that the job starts processing on the machine at time $t$ $(t=0,1,\ldots)$. For a given set of $\{x_{t}\}$ variables, let $y_{s}$ denote the probability that the job is being processed on the machine during time slot $s$. Then, the expected completion time of the job is given by

[TABLE]

Proof 8.2

Proof. It follows from the fact that policies are non-anticipatory that in terms of $\{x_{t}\}$ variables, the expected completion time is

[TABLE]

Further, from (1),

[TABLE]

which also gives

[TABLE]

Consider the summation

[TABLE]

or,

[TABLE]

Adding $\sum_{t=0}^{\infty}x_{t}{\mathbb{E}}[P]=\sum_{s=0}^{\infty}y_{s}$ to the above, gives

[TABLE]

\halmos

Lemma 8.3

Let $X$ be a non-negative random variable with mean $\mu$ and squared coefficient of variation $\Delta$. Then,

[TABLE]

Proof 8.4

Proof. We consider the problem of finding the measure on $\mathbb{R}_{+}$ for $X$ that maximizes ${\mathbb{E}}[(X-\mu)^{+}]$. Assuming $X$ has a density, this can be written as an infinite dimensional linear program. Using duality, we provide these bounds by exhibiting feasible solutions to its dual. It is instructive to follow this path, and later we argue that the bound holds for any distribution of $X$. We note that the bounds are in fact tight which can be easily proved by analyzing the distributions in the duality-based proof, but we omit this step here.

We begin with the primal problem of finding the extremal measure on $\mathbb{R}_{+}$ as an infinite dimensional LP, assuming the extremal measure has density $f(\cdot)$).

[TABLE]

The dual problem to the above is:

[TABLE]

Case $\Delta\geq 1$. We begin by making a guess about the extremal distribution $f(\cdot)$. Namely, that it is a parametric distribution with as limiting case two atoms, one of which is at [math]. Under this assumption, one observes that \mbox{\mathbb{P}[X=0]}=\frac{\Delta}{\Delta+1} and \mbox{\mathbb{P}[X=\mu(\Delta+1)]}=\frac{1}{\Delta+1} yields the desired conditions that ${\mathbb{E}}[X]=\mu$, ${\mathbb{E}}[X^{2}]=\mu^{2}(\Delta+1)$ and ${\mathbb{E}}[(X-\mu)^{+}]=\mu\frac{\Delta}{\Delta+1}$. For the given guess, complementary slackness implies:

[TABLE]

The first of the above gives $\alpha=0$, and the second gives the dual objective value of $\mu\frac{\Delta}{\Delta+1}$. It now remains to verify dual feasibility. Dual feasibility is met if the gradient of the quadratic function $\alpha+\beta x+\gamma x^{2}$ at $x=0$ is non-negative, and it is tangent to $(x-\mu)^{+}$ at $x=\mu(\Delta+1)$. The latter implies,

[TABLE]

which together with (22) gives, $\beta=\frac{\Delta-1}{\Delta+1}$ and $\gamma=\frac{1}{\mu(\Delta+1)^{2}}$. The non-negativity of gradient at $x=0$ is true if and only if $\beta\geq 0$. Therefore if $\Delta\geq 1$, then $\alpha=0,\beta=\frac{\Delta-1}{\Delta+1},\gamma=\frac{1}{\mu(\Delta+1)^{2}}$ is a feasible dual solution with objective value $\mu\frac{\Delta}{\Delta+1}$.

To turn this idea into a formal proof, we claim that for any $x\geq 0$ and $\Delta\geq 1$, we have

[TABLE]

This follows from $(x-\mu(\Delta+1))^{2}\geq 0$ by adding $2x=(\Delta+1)x+(\Delta-1)x$ to both sides. Then basic algebra yields that $(x-\mu)\leq(\Delta-1)x/(\Delta+1)+x^{2}/(\mu(\Delta+1)^{2})$, where we assume w.l.o.g. that $\mu>0$. Therefore, for any random variable $X\geq 0$ with ${\mathbb{E}}[X]>0$ we have

[TABLE]

Substituting ${\mathbb{E}}[{X}]=\mu,{\mathbb{E}}[{X^{2}}]=\mu^{2}(1+\Delta)$, we get

[TABLE]

which proves the second case of (20).

Case: $\Delta\leq 1$.* The constraints of the dual suggest that we should look for a quadratic function $\alpha+\beta x+\gamma x^{2}$ which is tangent to $(x-\mu)^{+}$ at two points, one of which must be in the interval $[0,\mu]$. Therefore, $\alpha+\beta x+\gamma x^{2}=\gamma(x-\nu_{1})^{2}$ for some $0\leq\nu_{1}\leq\mu$. Let this quadratic be tangent to $(x-\mu)$ at $\nu_{2}\geq\mu$. The tangency conditions give*

[TABLE]

which together imply $\gamma=\frac{1}{4(\mu-\nu_{1})}$. Thus, the dual minimization problem becomes the following single parameter optimization problem over $\nu_{1}$:

[TABLE]

The minimizer is $\nu_{1}^{*}=\mu(1-\sqrt{\Delta})$ which is indeed in the interval $[0,\mu]$ for $\Delta\leq 1$ as desired for dual feasibility.

As before, we can turn this into a formal proof by showing that for any $x\geq 0$, and $0\leq\Delta\leq 1$,

[TABLE]

where we have defined $\nu=\mu(1-\sqrt{\Delta})$. Then for any random variable $X\geq 0$ with ${\mathbb{E}}[X]>0$,

[TABLE]

After substituting ${\mathbb{E}}[{X}]=\mu,{\mathbb{E}}[{X^{2}}]=\mu^{2}(1+\Delta)$ this gives

[TABLE]

This completes the proof for the first case of (20).

Remark:* It was pointed out to us by one of the referees that the bound for the case $\Delta\leq 1$ follows even simpler by observing ${\mathbb{E}}[{(X-\mu)^{+}}]=\frac{1}{2}{\mathbb{E}}[{|X-\mu|_{2}}]\leq\frac{1}{2}\sqrt{{\mathbb{E}}[(X-\mu)^{2}]}=\frac{\mu\sqrt{\Delta}}{2}$. Here, the first equality follows because $X-\mu$ has mean zero, and the inequality is by Jensen’s inequality. The linear programming argument however is constructive in the sense that it also gives tight examples. \halmos*