Maximizing Online Utilization with Commitment

TL;DR

This paper develops and analyzes online algorithms for scheduling jobs on parallel machines with commitment constraints, aiming to maximize total accepted processing time, and demonstrates their competitive ratios and improvements over greedy policies.

Contribution

It introduces new deterministic online algorithms with near-optimal competitive ratios for both preemptive and non-preemptive cases in parallel machine scheduling with commitment.

Findings

Deterministic preemptive algorithm achieves near-tight competitive ratio for any number of machines.

Non-preemptive algorithm guarantees competitive ratio close to the optimal for single machine.

Competitive ratios improve exponentially with the number of machines, especially for small epsilon.

Abstract

We investigate online scheduling with commitment for parallel identical machines. Our objective is to maximize the total processing time of accepted jobs. As soon as a job has been submitted, the commitment constraint forces us to decide immediately whether we accept or reject the job. Upon acceptance of a job, we must complete it before its deadline $d$ that satisfies $d \geq (1+\epsilon)\cdot p + r$, with $p$ and $r$ being the processing time and the submission time of the job, respectively while $\epsilon>0$ is the slack of the system. Since the hard case typically arises for near-tight deadlines, we consider $\varepsilon\leq 1$. We use competitive analysis to evaluate our algorithms. Our first main contribution is a deterministic preemptive online algorithm with an almost tight competitive ratio on any number of machines. For a single machine, the competitive factor matches the optimal bound $\frac{1+\epsilon}{\epsilon}$ of the greedy acceptance policy. Then the competitive ratio improves with an increasing number of machines and approaches $(1+\epsilon)\cdot\ln \frac{1+\epsilon}{\epsilon}$ as the number of machines converges to infinity. This is an exponential improvement over the greedy acceptance policy for small $\epsilon$. In the non-preemptive case, we present a deterministic algorithm on $m$ machines with a competitive ratio of $1+m\cdot \left(\frac{1+\epsilon}{\epsilon}\right)^{\frac{1}{m}}$. This matches the optimal bound of $2+\frac{1}{\epsilon}$ of the greedy acceptance policy for a single machine while it again guarantees an exponential improvement over the greedy acceptance policy for small $\epsilon$ and large $m$. In addition, we determine an almost tight lower bound that approaches $m\cdot \left(\frac{1}{\epsilon}\right)^{\frac{1}{m}}$ for large $m$ and small $\epsilon$.

Equations

$$m\cdot (1+\epsilon )\cdot \left({\left(\frac{1+\epsilon }{\epsilon }\right)}^{\frac{1}{m}}-1\right).$$

$$\lfloor m\cdot (1+\epsilon )\rfloor \cdot \left({\left(\frac{1+\epsilon }{\epsilon }\right)}^{\frac{1}{m}}-1\right).$$

$$m\cdot {\left(\frac{1+\epsilon }{\epsilon }\right)}^{\frac{1}{m}}+1.$$

$$m\cdot {\left(\frac{1}{\epsilon }\right)}^{\frac{1}{m}}$$

$$\sum _{j=i+1}^{m+i}{\left(\frac{1+\epsilon }{\epsilon }\right)}^{\frac{j}{m}}$$

$$f(m,\epsilon )$$

$$V_{min}(\tau ){|}_t$$

$$d_j$$

$$V_{min}(\tau ){|}_t$$

$$V_{min}(\tau ){|}_{t^{\prime }}$$

$$V_{min}(\tau ){|}_{t^{\prime }}-V_{min}(d_{min}{|}_{t^{\prime }})$$

$$m$$

$$\frac{V_{min}(\tau ){|}_t}{\tau -t}$$

$$V_{min}(\tau ){|}_{t^{\prime }}-V_{min}(d_{min}{|}_{t^{\prime }})$$

$$<(\tau -d_{min}{|}_t)\cdot f(m,\epsilon )$$

$$<(\tau -d_{min}{|}_{t^{\prime }})\cdot f(m,\epsilon ).$$

$$V_{\Delta }{|}_{t^{\prime }}+V_{min}(\tau ){|}_{t^{\prime }}$$

$$\le \frac{\tau -t^{\prime }}{\tau -t}\cdot \left(V_{min}(\tau ){|}_t+V_{\Delta }{|}_t\right)$$

$$<\frac{\tau -t^{\prime }}{\tau -t}\cdot \left((\tau -t)\cdot f(m,\epsilon )\right)$$

$$<(\tau -d_{min}{|}_{t^{\prime }})\cdot f(m,\epsilon ).$$

$$\displaystyle V(x):=\left\{\begin{array}[]{ll}x\cdot f(m,\varepsilon)&\mbox{ for }x\geq 1\\ \sum\limits_{i=0}^{h}\left(\frac{\varepsilon}{1+\varepsilon}\right)^{\frac{m-i}{m}}+x\cdot(m-h-1)&\mbox{ for }1\leq x\leq\frac{\varepsilon}{1+\varepsilon}\\ x\cdot m&\mbox{ for }\frac{\varepsilon}{1+\varepsilon}\geq x\geq 0\end{array}\right.$$

$$V(x_1)$$

$$m\ge \frac{V(x_1)}{x_1}$$

$$V_{min}(\tau ){|}_t$$

$$V_{min}(\tau ){|}_{t^{\prime }}$$

$$\stackrel{Eq.(\text{ref}eq:V_{c}on{d}_{b}ottom)}{\le }(\tau -t^{\prime })\cdot \frac{d_{min}{|}_t-t}{\tau -t}\cdot V\left(\frac{\tau -t}{d_{min}{|}_t-t}\right)$$

$$\stackrel{Eq.(\text{ref}eq:V{x}_{m}onotony)}{\le }(\tau -t^{\prime })\cdot \frac{d_{min}{|}_t-t^{\prime }}{\tau -t^{\prime }}\cdot V\left(\frac{\tau -t^{\prime }}{d_{min}{|}_t-t^{\prime }}\right)$$

$$\le (d_{min}{|}_t-t^{\prime })\cdot V\left(\frac{\tau -t^{\prime }}{d_{min}{|}_t-t^{\prime }}\right).$$

$$d_{min}^{new}\ge \frac{V_{min}^{new}(d_{min})+V_{\Delta }}{f(m,\epsilon )}$$

$$=d_{min}+\frac{d_{min}}{(1+\epsilon )\cdot f(m,\epsilon )}$$

$$\stackrel{Eq.(\text{ref}eq:mi{n}_{p}arameter)}{=}{d}_{min}\cdot {\left(\frac{1+\epsilon }{\epsilon }\right)}^{\frac{1}{m}}$$

$$V_{min}^{new}(\tau )$$

$$\stackrel{Eq.(\text{ref}eq:V_{c}on{d}_{b}ottom)}{\le }{d}_{min}\cdot V\left(\frac{\tau }{d_{min}}\right)+\tau -d_{min}\cdot \frac{\epsilon }{1+\epsilon }$$

$$\stackrel{Eq.(\text{ref}eq:V{x}_{d}efinition)}{\le }{d}_{min}\cdot \sum _{i=0}^h{\left(\frac{\epsilon }{1+\epsilon }\right)}^{\frac{m-i}{m}}+$$

$$+d_{min}\cdot y\cdot (m-h-1)\cdot {\left(\frac{\epsilon }{1+\epsilon }\right)}^{\frac{m-h}{m}}+$$

$$+d_{min}\cdot \left(y\cdot {\left(\frac{\epsilon }{1+\epsilon }\right)}^{\frac{m-h}{m}}-\frac{\epsilon }{1+\epsilon }\right)$$

$$\le d_{min}\cdot \sum _{i=1}^h{\left(\frac{\epsilon }{1+\epsilon }\right)}^{\frac{m-i}{m}}+$$

Full text

Our first main contribution is a deterministic preemptive online algorithm with an almost tight competitive ratio on any number of machines. For a single machine, the competitive factor matches the optimal bound $\frac{1+\varepsilon}{\varepsilon}$ of the greedy acceptance policy. Then the competitive ratio improves with an increasing number of machines and approaches $(1+\varepsilon)\cdot\ln\frac{1+\varepsilon}{\varepsilon}$ as the number of machines converges to infinity. This is an exponential improvement over the greedy acceptance policy for small $\varepsilon$.

In the non-preemptive case, we present a deterministic algorithm on $m$ machines with a competitive ratio of $1+m\cdot\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{1}{m}}$. This matches the optimal bound of $2+\frac{1}{\varepsilon}$ of the greedy acceptance policy for a single machine while it again guarantees an exponential improvement over the greedy acceptance policy for small $\varepsilon$ and large $m$. In addition, we determine an almost tight lower bound that approaches $m\cdot\left(\frac{1}{\varepsilon}\right)^{\frac{1}{m}}$ for large $m$ and small $\varepsilon$.

††journal: Journal of Scheduling

1 Introduction

We consider an online resource allocation and scheduling problem modeled as follows. Given a set of $m$ identical machines, we process a sequence of jobs in an online fashion. Each job has a release date $r_{j}$, a deadline $d_{j}$, and a processing time $p_{j}$. Our objective is to maximize the total utilization of the system, that is the sum of the processing times of all completed jobs, subject to a commitment guarantee. Due to this guarantee we must decide immediately upon submission of a job, whether to accept or reject it. In case of acceptance, we must complete it before its deadline and cannot accept any other job that would prevent us from doing so.

This problem has received a significant amount of attention and tight algorithms with competitive ratios depending on $\Delta=\log\frac{\max p_{j}}{\min p_{j}}$ are known for a single machine without further assumptions on the input LiT94 ; GPS00 . To obtain more meaningful results, a number of papers use a slack parameter $\varepsilon>0$ and require $d_{j}\geq(1+\varepsilon)\cdot p_{j}+r_{j}$ for all jobs. Typically, the hard case arises for small slack ($\varepsilon\rightarrow 0$).

We consider the preemptive and the non-preemptive versions of the problem for small slack values $\varepsilon\leq 1$. In case of preemption, we allow migration and assume no penalty for preemption and migration.

We use the common approach of competitive analysis to measure the performance of online algorithms, that is, we determine the competitive ratio. Since we are facing a maximization problem, the strict competitive ratio is the maximum value of $\frac{\text{OPT}({\mathcal{J}})}{\text{ALG}({\mathcal{J}})}$ over all input sequences ${\mathcal{J}}$, with $\text{OPT}({\mathcal{J}})$ and $\text{ALG}({\mathcal{J}})$ being the objective values of an optimal offline algorithm and the examined online algorithm, respectively.

1.1 Our Contribution

We show upper and lower bounds on the competitive ratio of utilization maximization with commitment in dependence of the slackness parameter $\varepsilon$. Specifically:

• •

For $m$ machines supporting preemption and migration, we give a deterministic algorithm with a strict competitive ratio of

[TABLE]

This bound decreases with increasing $m$, approaching $(1+\varepsilon)\cdot\ln(\frac{1+\varepsilon}{\varepsilon})$ as $m$ tends to infinity and matching the competitive ratio $\frac{1+\varepsilon}{\varepsilon}$ of the optimal greedy algorithm for $m=1$.

• •

We provide an almost matching lower bound of

[TABLE]

• •

For $m$ machines without preemption, we give a deterministic algorithm with a strict competitive ratio of

[TABLE]

For $m>\ln{\frac{1+\varepsilon}{\varepsilon}}$, we apply partitioning to improve this competitive ratio. In particular, we obtain a competitive ratio $e\ln\frac{1+\varepsilon}{\varepsilon}+1$ for integral values $\ln\frac{1+\varepsilon}{\varepsilon}$ and $m=i\cdot\ln\frac{1+\varepsilon}{\varepsilon}$, $i\in\mathbb{N}$. For small slack $\varepsilon$, these results significantly improve over the state of the art greedy algorithm with a competitive ratio of $2+\frac{1}{\varepsilon}$.

• •

For the non-preemptive machine environment, we also give the first lower bounds that are asymptotically greater than $1$ for any number of machines. In particular, for large $m$ and $\varepsilon\leq 1$, our lower bound approaches

[TABLE]

which is almost tight (up to a $(1+\varepsilon)^{1/m}$ factor and the additive value 1).

1.2 Related Work

Using the three field notation of Graham et al. Graham , the $P|pmtn,r_{j}|\sum(1-U_{j})w_{j}$ problem admits a pseudopolynomial time algorithm, see Lawler Lawler90 , and a FPTAS due to a technique by Pruhs and Woeginger PruhsW07 . We are not aware of any simplifications when assuming $w_{j}=p_{j}$. For preemption without migration, these ideas were further extended to admit a $2+\varepsilon$ approximation AwerbuchAFLR01 . A reduction from preemptive to non-preemptive due to Kalyanasundaram and Pruhs KaP01 yields a $6+\varepsilon$ approximation. Recently, Alon et al. AAB18 analyzed the gap between schedules with a bounded number of $k$ preemptions and an unbounded number of preemptions. They show that the utilization ratio is at most $O(\log_{k+1}n,\log_{k+1}\frac{\max p_{j}}{\min p_{j}})$, which is asymptotically optimal.

Variants of the online problem have been studied in real-time scheduling. Without commitment and assuming preemptions, there exists a tight $4$-competitive deterministic algorithm on a single machine for a class of well-behaved payoff functions including $w_{j}=p_{j}$, see, for instance, Baruah et al. BKMMRRSW92 and Wöginger Woe94 . Kalyanasundaram and Pruhs KaP03 gave a $O(1)$ competitive randomized algorithm for maximizing the number of completed jobs and showed that no constant competitive deterministic algorithm exists. For general pay-off functions in a non-preemptive environment, several authors CaI98 ; KoS94 ; Por04 showed finite competitive ratios of $O(\min(\log\frac{\max p_{j}}{\min p_{j}},\log\frac{\max w_{j}}{\min w_{j}})$ if $d_{j}=r_{j}+p_{j}$ holds. For slack111In literature, the stretch $f=1+\varepsilon$ is often used instead. The two notions are equivalent. $\varepsilon>0$, Lucier et al. LMNY13 proposed an algorithm with competitive ratio $2+\Theta\left(\frac{1}{\sqrt[3]{1+\varepsilon}-1}\right)+\Theta\left(\frac{1}{(\sqrt[3]{1+\varepsilon}-1)^{2}}\right)$.

Commitments make the problem much more difficult. Indeed, Lucier et al. LMNY13 showed that even with slack, no performance guarantees are possible for general weights $w_{j}$. By proposing a model with limited commitment called $\beta$-responsive, Azar et al. AKLMNY15 gave an algorithm with competitive ratio $5+\Theta\left(\frac{1}{\sqrt[3]{1+\varepsilon}-1}\right)+\Theta\left(\frac{1}{(\sqrt[3]{1+\varepsilon}-1)^{2}}\right)$ for $\varepsilon>3$. Similar relaxed commitment models were recently considered by Chen et al. CEMSS18 for the problem of maximizing the number of accepted jobs $(w_{j}=1)$. For $w_{j}=p_{j}$ (the utilization maximization problem), a number of algorithms with commitment have been proposed. On a single machine without assuming slack or preemption, Lipton and Tomkins LiT94 gave a lower bound of $\Omega(\log\Delta)$ for the competitive factor of any randomized online algorithm. Additionally assuming $d_{j}=p_{j}+r_{j}$ for all jobs, they obtained an upper bound of $O(\log^{1+\delta}\Delta)$ for any $\delta>0$. For arbitrary deadlines, Goldman, Parwatikar, and Suri GPS00 presented a $6(\lceil\log\Delta\rceil+1)$ competitive algorithm.

Baruah and Haritsa BaH97 were among the first to present results for problems with slack when they addressed the single machine problem with preemption and commitment. For this problem, they gave an algorithm with a competitive ratio $1+\frac{1}{\varepsilon}$ and a lower bound of $1+\frac{1}{\lceil 1+\varepsilon\rceil}$. For the corresponding non-preemptive problem on a single machine, Goldwasser’s algorithm Gol99 ; Gol03 guarantees a tight deterministic competitive ratio of $2+\frac{1}{\varepsilon}$. A similar competitive ratio is also given by Garay et al. GNYZ02 .

For parallel identical machines, DasGupta and Palis DaP01 consider preemption without migration and suggest a simple greedy algorithm. They claim the same competitive factor as for the single machine problem with preemption. They also give a lower bound of $1+\frac{1}{m\varepsilon}$. For the non-preemptive case, Kim and Chwa KiC01 apply Goldwasser’s algorithm Gol99 ; Gol03 to parallel identical machines. Lee Lee03 considers a model without commitment and presents a non-preemptive algorithm that adds many newly submitted jobs to a queue and decides later whether to schedule or to reject them. He claims a competitive ratio of $m+1+m\varepsilon^{-1/m}$ for small slack values. This competitive ratio is slightly worse than our competitive ratio for the same problem with commitment.

2 Notations and Basic Properties

We schedule jobs of a job sequence $\mathcal{J}$ on $m$ parallel identical machines ($P_{m}$ model). Release date $r_{j}$, processing time $p_{j}$, and deadline $d_{j}$ of a job $J_{j}\in{\mathcal{J}}$ obey the slack condition $d_{j}-r_{j}\geq(1+\varepsilon)\cdot p_{j}$. $\varepsilon>0$ is the fixed slack factor of the system. We say that $J_{j}$ has a tight slack if $d_{j}-r_{j}=(1+\varepsilon)\cdot p_{j}$ holds. In the three field notation, the constraint $\varepsilon$ indicates a problem with slack factor $\varepsilon$. We are interested in problems with a small slack ($\varepsilon\leq 1$). The job sequence $\mathcal{J}$ defines an order of the jobs such that job $J_{i}$ precedes job $J_{j}$ for $r_{i}<r_{j}$.

We discuss an online scenario with commitment: the jobs arrive in sequence order and we must decide whether to accept the most recent job or not before seeing any job at a later position in the sequence. Complying with the common notation in scheduling theory, we use the binary variable $U_{j}$ to express this decision for job $J_{j}$: $U_{j}=0$ denotes acceptance of job $J_{j}$ while the rejection of $J_{j}$ produces $U_{j}=1$. We commit ourselves to complete every accepted job not later than its deadline and say that a schedule is valid if it satisfies this commitment. Therefore, we can only accept a new job if there is a valid extension of the current schedule that includes this job. We consider preemptive and non-preemptive variants of this problem. If the system allows preemption (pmtn) then we can interrupt the execution of any job and immediately or later resume it on a possibly different machine without any penalty. In the non-preemptive case, we combine the acceptance commitment with a machine and start time commitment (immediate decision, see Bunde and Goldwasser BuG10 ).

For a previously released job, we only consider its remaining processing time when generating or modifying a preemptive schedule. Therefore, progression of time may change the values of variables that depend on the processing time. For such a variable, we use the appendix $|_{t}$ to indicate its value at time $t$.

It is our goal to maximize the total processing time of all accepted jobs ($\sum p_{j}\cdot(1-U_{j})$). An online algorithm $ALG$ determines $U_{j}(ALG)$ for all jobs in $\mathcal{J}$ such that there is a valid schedule $S$ for all jobs $J_{j}$ with $U_{j}(ALG)=0$. $P[t,t^{\prime})(S,{\mathcal{J}})$ denotes the total processing time of schedule $S$ for job sequence ${\mathcal{J}}$ in interval $[t,t^{\prime})$ while $P^{*}[t,t^{\prime})({\mathcal{J}})$ is the maximum total processing time of any optimal schedule for the same job sequence in the same interval. We evaluate our algorithm by determining bounds for the competitive ratio, that is the largest ratio between the optimal objective value and the objective value produced by online algorithm $ALG$ for all possible job sequences $\mathcal{J}$: $ALG$ has a strict competitive ratio $c_{ALG}$ if $c_{ALG}\geq\frac{P^{*}[0,\max_{J_{j}\in\mathcal{J}}d_{j})({\mathcal{J}})}{P[0,\max_{J_{j}\in\mathcal{J}}d_{j})(S,{\mathcal{J}})}$ holds for any job sequence $\mathcal{J}$. Finally, $c$ is a lower bound of the competitive ratio if $c\leq c_{ALG}$ holds for any online algorithm $ALG$.

3 Online Scheduling with Preemption

We present an approach for solving our problem on parallel identical machines with preemption. Contrary to previous approaches, our algorithm is based on lazy acceptance, that is, we may not accept a job although its acceptance allows a valid schedule. We show that our lazy acceptance leads to better competitive ratios than the greedy acceptance approach.

In this section, we frequently use function $\left(\frac{1+\varepsilon}{\varepsilon}\right)^{x}$ with the identity

[TABLE]

and the threshold expression

[TABLE]

We start by recalling a known aggregation function for a sequence $\mathcal{J}$ of jobs that are submitted at time $t$ or earlier but not yet completed ($p_{j}|_{t}>0$): $V_{min}(\tau)|_{t}$ for $\tau\geq t$ is the minimum total processing time that we must execute in interval $[t,\tau)$ of any valid schedule.

[TABLE]

Based on function $V_{min}$, Horn Hor74 has given a necessary and sufficient condition for the existence of a valid preemptive schedule:

Theorem 3.1 (Horn)

There is a valid preemptive schedule in interval $[t,\max_{J_{j}\in\mathcal{J}}d_{j})$ for a sequence $\mathcal{J}$ of jobs with deadlines on $m$ parallel identical machines if and only if we have

[TABLE]

Proof

See Horn Hor74 , proof of Theorem 2.

Next we introduce two algorithms: the first algorithm decides whether to accept a newly submitted job while the second algorithm determines the schedule of the accepted jobs. Afterwards, we prove that the combination of both algorithms always produces a valid solution and give the competitive ratio of our approach.

Main component of Algorithm 1 Acceptance for Preemption is the non decreasing threshold deadline $d_{min}$. We simply accept a new job if and only if its deadline is at least as large as $d_{min}$, see Lines 5 to 6 and 8 to 9. Initially, we assume $r_{j}\geq 0$ for all jobs and set $d_{min}=0$ (Line 1). Whenever there is a submission of a new job then Line 3 prevents $d_{min}$ to be in the past. Line 4 introduces a compensation value $V_{\Delta}$ for job parts with a large deadline that are scheduled earlier due to the availability of machines, compare Algorithm 2, lines 14-18, and Lemma 1. Due to this early scheduling, progression of time may result in $V_{min}(d_{min})|_{r_{j}}<(d_{min}-r_{j})\cdot f(m,\varepsilon)$. $V_{\Delta}$ compensates for this reduction and prevents an increase of the threshold that is too small. To this end, Line 7 sets $d_{min}$ to the largest value $\tau$ that satisfies $V_{min}(\tau)|_{r_{j}}+V_{\Delta}=(\tau-r_{j})\cdot f(m,\varepsilon)$.

Algorithm 2 Schedule Generation uses the current time $t$ as input parameter and generates a schedule for interval $[t,T)$ including the specification of the end of the interval $T$ (Lines 6, 11, and 17). We must run the algorithm again if we have accepted a new job or as soon as time has progressed to $T$. We determine the largest deadline $d_{k}$ such that at most $m$ jobs contribute to $V_{min}(d_{k})|_{t}$ (Line 2). If there is no such deadline, we skip any preallocation and select the setting to produce an LRPT schedule for the contributions of the jobs to $V_{min}(d_{1})|_{t}$ (Lines 3 to 7). Otherwise, we execute a preallocation by starting each of the jobs contributing to $V_{min}(d_{k})|_{t}$ on a separate machine (Lines 9 and 10). $T$ exceeds $t$ by at most the smallest contribution among those jobs to $V_{min}(d_{k})|_{t}$ (Line 11). $m_{LRPT}$ is the number of idle machines after this preallocation (Line 12). If there are idle machines in interval $[t,T)$ and the total number of uncompleted jobs exceeds $m$ then we apply LRPT to determine a schedule starting at time $t$ on these $m_{LRPT}$ idle machines for the contribution of any not yet allocated job to $V_{min}(d_{k+1})|_{t}$ (Lines 15 and 16). If a machine becomes idle in this LRPT schedule before the previously determined value of $T$ then we reduce $T$ accordingly (Line 17).

Since Algorithm 2 prioritizes contributions to $V_{min}(\tau_{1})|_{t}$ over additional contributions to $V_{min}(\tau_{2})|_{t}$ for $\tau_{2}>\tau_{1}>t$, it generates a valid schedule if one exists, see Theorem 3.1.

Next we discuss the influence of progression of time due to Algorithm 2 on $V_{min}$ and on $d_{min}$ for a valid schedule.

Lemma 1

If Algorithm 2 has generated a valid schedule starting at time $t$ then progression from time $t$ to time $t^{\prime}$ without acceptance of a new job in interval $(t,t^{\prime})$ produces

[TABLE]

and for each $\tau>d_{min}|_{t^{\prime}}$,

[TABLE]

Proof

Eq. (4) holds for time $\tau>t^{\prime}$ if no machine is idle in interval $[t,t^{\prime})$ and every machine only executes job parts contributing to $V_{min}(\tau)|_{t}$ due to

[TABLE]

If at least one machine executes in interval $[t,t^{\prime})$ some job parts that do not contribute to $V_{min}(\tau)|_{t}$ for some time $\tau\geq t^{\prime}$ or has some idle time then Algorithm 2 guarantees that at time $t^{\prime}$, there are $k<m$ jobs with uncompleted job parts contributing to $V_{min}(\tau)|_{t}$ and the total amount of processing time in interval $[t,t^{\prime})$ that contributes to $V_{min}(\tau)|_{t}$ is at least $k\cdot(t^{\prime}-t)$. Then we have

[TABLE]

We assume that Eq. (5) holds for $t$ and apply an inductive approach. For $d_{min}|_{t}\geq t^{\prime}$, Algorithm 1 sets $d_{min}|_{t^{\prime}}=d_{min}|_{t}$. Due to Algorithm 2, we have for each $\tau>d_{min}|_{t^{\prime}}$,

[TABLE]

For $d_{min}|_{t}<t^{\prime}$, Algorithm 1 sets $d_{min}|_{t^{\prime}}=t^{\prime}$ and $V_{\Delta}|_{t^{\prime}}=0$. Then we have for each $\tau>d_{min}|_{t^{\prime}}$,

[TABLE]

∎

Next, we prove that Algorithms 1 and 2 guarantee the existence of a valid schedule. To this end, we introduce a new function $V(x)$ with $0\leq x$. In the middle part of this definition, we use $x=y\cdot\left(\frac{\varepsilon}{1+\varepsilon}\right)^{\frac{m-h}{m}}$ with $h\in\{0,1,\ldots,m-1\}$ and $1\leq y\leq\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{1}{m}}$.

[TABLE]

$V(x)$ is piecewise linear with non-negative slopes. Note that we have defined $V(x)$ twice at all corner points ($y=1$ and $x=1$). At each of these points, both definitions produce the same value. Therefore, $V(x)$ is continuous and we have

[TABLE]

Eq. (12) holds since the slopes are non-negative and decreasing in interval $(0,1)$. Based on function $V(x)$, we claim the following property of our combination of algorithms:

Lemma 2

Algorithms 1 and 2 guarantee

[TABLE]

and for $\tau\geq d_{min}$,

[TABLE]

$V_{min}(\tau)|_{t}\leq(\tau-t)\cdot f(m,\varepsilon)-V_{\Delta}$ is equivalent to Eq. (14) for $\tau>d_{min}>t$.

Proof

We use an inductive approach by assuming validity of Eq. (13) and (14) for time $t$ and separately consider the events progression of time and acceptance of a new job.

We start with progression from time $t$ to time $t^{\prime}$ without acceptance of a new job in interval $(t,t^{\prime})$. Eq. (13) and (14) clearly hold for time $\tau=t^{\prime}$. Eq. (5) guarantees validity of Eq. (14) for $\tau>d_{min}|_{t^{\prime}}=\max\{d_{min}|_{t},t^{\prime}\}$. For $t^{\prime}<\tau\leq d_{min}|_{t}=d_{min}|_{t^{\prime}}$, Eq. (13) also remains valid due to Lemma 1:

[TABLE]

The second event is the acceptance of a new job $J_{j}$ with $r_{j}=t$, $(1+\varepsilon)\cdot p_{j}\leq d_{j}-r_{j}$, and $d_{j}\geq d_{min}$, see Algorithm 1. To simplify the formal description of this event, we omit the appendix $|_{t}$ of the variables and apply a time shift by $-t$, that is, we assume $r_{j}=t=0$. This time shift does not affect the validity of our transformations since they always use $d_{min}-t$ or $\tau-t$.

Again we assume the validity of Eq. (13) and (14) before the submission of $J_{j}$. The acceptance of $J_{j}$ produces a new deadline threshold $d_{min}^{new}\geq d_{min}$. We partition time into several intervals: Eq. (14) is always valid for $\tau\geq d_{min}^{new}$ due to Line 7 of Algorithm 1 and it remains valid for $d_{min}^{new}\cdot\left(\frac{\varepsilon}{1+\varepsilon}\right)^{\frac{1}{m}}\leq\tau<d_{min}^{new}$ due to Eq. (11) and $V_{min}(\tau)\leq V_{min}(d_{min}^{new})$. For $\tau\leq d_{j}-p_{j}$, Eq. (13) and (14) remain valid due to Eq. (12) since there is no change in $V_{min}(\tau)$.

For the remaining intervals, we start with the case $d_{j}=d_{min}=\frac{V_{min}(d_{min})+V_{\Delta}}{f(m,\varepsilon)}$.

If job $J_{j}$ has tight slack ($p_{j}=\frac{d_{min}}{1+\varepsilon}$) then Line 7 of Algorithm 1 produces

[TABLE]

For $\tau=d_{min}\cdot y\cdot\left(\frac{\varepsilon}{1+\varepsilon}\right)^{\frac{m-h}{m}}$ with $h\in\{0,1,\ldots,m-1\}$ and $1\leq y\leq\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{1}{m}}$, there is

[TABLE]

For $h=0$, that is $d_{min}\cdot\frac{\varepsilon}{1+\varepsilon}\leq\tau\leq d_{\min}\cdot\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{1}{m}}\cdot\frac{\varepsilon}{1+\varepsilon}\leq d_{min}^{new}\cdot\frac{\varepsilon}{1+\varepsilon}$, we have

[TABLE]

For $h\in\left\{1,\ldots,m-1\right\}$, there is

[TABLE]

We compare this tight slack scenario to the acceptance of a job with $d_{j}=d_{min}$ but without tight slack ($p_{j}<\frac{d_{min}}{1+\varepsilon}$). We indicate the variables of the non-tight scenario with ′ and obtain for $d_{j}-p_{j}<\tau\leq d_{min}$

[TABLE]

This result leads to

[TABLE]

For the general case $p_{j}\leq\frac{d_{min}}{1+\varepsilon}$, we consider next an arbitrary $\tau$ with $d_{j}=d_{min}=\frac{V_{min}(d_{min})+V_{\Delta}}{f(m,\varepsilon)}<\tau<d_{min}^{new}\cdot\left(\frac{\varepsilon}{1+\varepsilon}\right)^{\frac{1}{m}}$. Due to Line 7 of Algorithm 1, we have

[TABLE]

Therefore, Eq. (13) remains valid after the acceptance of job $J_{j}$.

Finally, we allow $d_{j}>d_{min}$ and address $d_{j}-p_{j}<\tau<d_{min}^{new}$. Due to the range of $\tau$, we can assume $d_{j}\leq d_{min}^{new}$. For $V_{min}(d_{min}^{new})\geq V_{min}(d_{min})+(d_{j}-d_{min})\cdot f(m,\varepsilon)$, we transfer processing time in direction of earlier deadlines to obtain

[TABLE]

Again we use the notation $(\ldots)^{\prime}$ to indicate values after the transformation. Since we do not generate a schedule after the transformation, the missing continuity of $\left(V_{min}(\tau)\right)^{\prime}$ for $\tau=d_{j}$ does not matter. The transformation leads to $\left(d_{min}\right)^{\prime}=d_{j}$. Due to Eq. (12), Eq. (13) remains valid after the transformation and we have already shown the validity of Eq. (13) after the acceptance of $J_{j}$. This validity also holds for the original values of $V_{min}^{new}(\tau)\leq\left(V_{min}^{new}(\tau)\right)^{\prime}$.

For $V_{min}(d_{min}^{new})<V_{min}(d_{min})+(d_{j}-d_{min})\cdot f(m,\varepsilon)$, we determine the largest value $\delta\in(\max\{d_{min},d_{j}-p_{j}\},d_{j})$ with $V_{min}(d_{min}^{new})+(d_{j}-\delta)=V_{min}(d_{min})+(\delta-d_{min})\cdot f(m,\varepsilon)$. $\delta$ exists due to

[TABLE]

We split job $J_{j}$ into two jobs $J_{j_{1}}$ and $J_{j_{2}}$ with $d_{j_{1}}=d_{j}$, $p_{j_{1}}=d_{j}-\delta$, $d_{j_{2}}=\delta$, and $p_{j_{2}}=p_{j}-(d_{j}-\delta)$. Both jobs observe the slack condition. We first submit and accept $J_{j_{1}}$. The acceptance of $J_{j_{1}}$ does not increase $d_{min}$ since $V_{min}(\tau)$ does not increase for any $\tau\leq\delta$. For any $\tau\in(\delta,d_{min}^{new}]$, we have

[TABLE]

Therefore, the acceptance does not change the validity of Eq. (14). For $J_{j_{2}}$, the previously discussed case applies. ∎

Due to Lemma 2, Algorithms 1 and 2 guarantee $V_{min}(\tau)|_{t}\leq(\tau-t)\cdot m$. Therefore, there is a valid preemptive schedule for the accepted jobs due to Theorem 3.1, and Algorithm 2 generates a valid schedule.

We now determine the performance of Algorithms 1 and 2. We begin with introducing a property of the generated schedule if all jobs have the same submission time.

Lemma 3

Consider a job set ${\mathcal{J}}$ with the common submission time [math] for all jobs. If there is a valid schedule for all these jobs then the repeated execution of Algorithm 2 generates a schedule $S$ for interval $[0,t)$ with

[TABLE]

for any time $t>0$.

Proof

If no machine is idle in schedule $S$ then the claim clearly holds. Therefore, we assume time $\tau<t$ to be the first time in schedule $S$ with at least one machine being idle. Then all jobs completing after time $\tau$ in schedule $S$ neither can start nor are preempted after time $\tau$. Let $k<m$ be the number of the jobs completing after time $t$ in $S$. Algorithm 2 produces $P[0,t)(S,{\mathcal{J}})\geq m\cdot\tau+k\cdot(t-\tau)$.

Since a job can contribute at most processing time $t$ to interval $[0,t)$ in any schedule, we have

[TABLE]

resulting in

[TABLE]

Due to inequalities $0<k<m$ and $0\leq\tau\leq t$, $k=0.5\cdot m$ and $\tau=0.5\cdot t$ produce a maximum for $k\cdot\tau/(m\cdot\tau+k\cdot t)$. ∎

Only Line 3 or Line 7 of Algorithm 1 may lead to an increase of $d_{min}$. We say an increase of $d_{min}$ is a time progression increase if it occurs due to Line 3. Any other increase of $d_{min}|_{t}$ from time $\tau$ to time $\tau^{\prime}$ does not involve progression of time and requires $V_{min}^{new}(\tau^{\prime})|_{t}-V_{min}(\tau)|_{t}=(\tau^{\prime}-\tau)\cdot f(m,\varepsilon)$. We use this distinction of increases of $d_{min}$ to prove the competitive ratio for Algorithms 1 and 2.

Theorem 3.2

The $P_{m}|\varepsilon,\mbox{online},pmtn|\sum p_{j}\cdot(1-U_{j})$ problem admits a deterministic online algorithm with competitive ratio at most

[TABLE]

Proof

We partition schedule $S$ generated by Algorithms 1 and 2 into an alternating sequence of rejection and non-rejection intervals. A non-rejection interval starts with some $d_{min}$ value such that every increase of $d_{min}$ in this interval is a time progression increase. At its end, $d_{min}|_{t}=t$ holds. We combine any neighboring non-rejection intervals into a single non-rejection interval. Algorithm 1 does not reject any job with either its submission time or its deadline being within this interval. An interval separating two subsequent non-rejection intervals is a rejection interval and does not contain any time progression increase of $d_{min}$.

Schedule $S$ will either start with a rejection interval or with a non-rejection interval but it will always finish with a non-rejection interval. Due to Lemma 3, we have for any non-rejection interval $[t,t^{\prime})$:

[TABLE]

For any rejection interval $[t,t^{\prime})$, the increase of the $d_{min}$ guarantees:

[TABLE]

For $\varepsilon\leq 1$, we have $\frac{m}{f(m,\varepsilon)}\geq\lim_{m\rightarrow\infty}\frac{m}{f(m,1)}=2\cdot\ln(2)>\frac{4}{3}$. ∎

Note that for $m=1$, Algorithms 1 and 2 guarantee the same competitive ratio $\frac{1+\varepsilon}{\varepsilon}$ as the optimal greedy algorithm for a single machine.

Lower Bounds

In this subsection, we provide a lower bound of the competitive ratio for the $P_{m}|\varepsilon,\mbox{online},pmtn|\sum p_{j}\cdot(1-U_{j})$ problem. First we describe the general concept. Our adversary controls the job sequence $\mathcal{J}$ that only uses jobs with release date [math] and consists of up to $m+2$ blocks. In blocks 1 to $m+1$, the adversary submits identical jobs up to a maximum number and proceeds with the next block as soon as we have accepted a block specific target number of these jobs. If we do not accept this target number then the adversary stops after submitting the above mentioned maximum number of jobs of this block. In block $m+2$, the adversary unconditionally submits the corresponding maximum number of jobs and stops afterwards.

The job of the first block has deadline $d_{1}=1+\varepsilon$ and an arbitrarily small positive processing time $p_{1}=\delta\ll 1$ such that the target number $\frac{\varepsilon}{\delta}\cdot\sum_{i=0}^{m-1}\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{i}{m}}$ is an integer. The maximum number of jobs is $\lfloor\frac{m\cdot(1+\varepsilon)}{\delta}\rfloor$.

The next $m$ blocks are similar. The job of block $k$ with $2\leq k\leq m+1$ has a tight slack with processing time $p_{k}=\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{k-2}{m}}$. For these blocks, the target number is 1 while the maximum number is $\lfloor m\cdot(1+\varepsilon)\rfloor$.

The job of the final block $m+2$ has a tight slack with processing time $p_{m+2}=\frac{1+\varepsilon}{\varepsilon}\cdot(1-\delta)$. The maximum number is $\lfloor m\cdot(1+\varepsilon)\rfloor$ as well.

Assume that we have accepted a total processing time of at most $P_{acc}$ and that we can arrange the submitted jobs to obtain a schedule with a total processing time of at least $P_{ideal}-const\cdot\delta$ then a lower bound of the competitive ratio for this scenario is $P_{ideal}/P_{acc}$ since $\delta$ is arbitrarily small.

Theorem 3.3

The competitive ratio for any deterministic online algorithm for the $P_{m}|\varepsilon,\mbox{online},\mbox{pmtn}|\sum p_{j}\cdot(1-U_{j})$ problem is at least

[TABLE]

Proof

If the adversary stops before starting block 2 then the submitted total processing time is more than $m\cdot(1+\varepsilon)-\delta$ while the algorithm has accepted a total processing time of at most $\varepsilon\cdot\sum_{i=0}^{m-1}\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{i}{m}}-\delta$ resulting in a lower bound of

[TABLE]

If the adversary stops before starting block $k+1$ with $2\leq k\leq m+1$ then the algorithm has accepted a total processing time of $p_{k}\cdot\varepsilon\cdot\sum_{i=0}^{m-1}\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{i}{m}}$ due to $p_{2}=1$ and

[TABLE]

Due to Theorem 3.1, we can use at least all $\lfloor m\cdot(1+\varepsilon)\rfloor$ jobs with processing time $p_{k}$ in the optimal schedule. This usage results in a lower bound of

[TABLE]

If the adversary starts with block $m+2$ then the algorithm has accepted exactly one job with deadline $d_{k}$ for $3\leq k\leq m+1$ while all other jobs have deadline $d_{1}=d_{2}$. The total accepted processing time is

[TABLE]

resulting in no idle time on any machine in interval $[0,d_{1})$. Since any job of block $m+2$ cannot start later than time

[TABLE]

we cannot accept any job of block $m+2$.

Again, the total processing time of the optimal schedule is at least $\lfloor m\cdot(1+\varepsilon)\rfloor\cdot p_{m+2}$ resulting in a lower bound of

[TABLE]

∎

Theorems 3.3 and 3.2 show that Algorithms  1 and 2 guarantee a tight (for $m\cdot(1+\varepsilon)$ being an integer) or an almost tight competitive ratio for $\varepsilon\leq 1$.

We can increase the lower bound to

[TABLE]

by adding accepted jobs with deadline $d_{1}$ in the optimal schedule if there are idle machines. The new lower bound reduces the gap for non-integral values of $m\cdot(1+\varepsilon)$ but cannot guarantee a tight lower bound for all those values.

Algorithms 1 and 2 guarantee a better competitive ratio than the known greedy approach for all values of $\varepsilon$ and $m>1$. In comparison to the single machine problem, the competitive factor is significantly better for small values of $\varepsilon$. Although we focus on small values of $\varepsilon$, we like to remark that for the parallel problem, the competitive ratio cannot approach 1 for large values of $\varepsilon$ due to the scheduling of the jobs (see Algorithm 2) while the competitive ratio tends to 1 for $\varepsilon\rightarrow\infty$ in the single machine problem.

4 Online Scheduling without Preemption

In this section, we present an online algorithm for the non-preemptive version. Our non-preemptive Algorithm 3 Online Allocation also uses a deadline threshold and determines this threshold based on an exponential sequence of processing times on the machines. Remember that in our online model, the algorithm must decide immediately after submission of a job whether to accept or reject the job. If we accept the job then we also must immediately allocate the job to a specific machine with a specific starting time and cannot change this allocation later. Once we have allocated a job to a machine, we start this job as early as possible on this machine. Therefore, it is not necessary to consider the job schedule but only the not yet completed load $l(m_{i})$ on each machine $m_{i}$. We index the machines in decreasing order of their loads: $l(m_{1})\geq l(m_{2})\geq\ldots\geq l(m_{m-1})\geq l(m_{m})$. We use the notation $l(m_{i})|_{t}$ to describe the value $l(m_{i})$ at a specific time $t$ although we are aware that there may be different load values at time $t$ due to the acceptance of jobs. For disambiguation, we apply a similar notation $l(m_{i})|_{J_{j}}$ to indicate the value $l(m_{i})$ when making the decision to accept job $J_{j}$. $l(m_{i})|_{J_{j}}^{\prime}$ describes the update of the load $l(m_{i})$ after accepting job $J_{j}$. Note that the allocation of $J_{j}$ to a machine may result in a re-indexing of the machines. This re-indexing is already considered in $l(m_{i})|_{J_{j}}^{\prime}$.

The next two expressions specify our deadline threshold:

[TABLE]

If $d_{lim}|_{t}=d^{i}_{lim}|_{t}$ holds then we say that machine $m_{i}$ determines $d_{lim}$. We use the notation $d_{lim}|_{J_{j}}^{\prime}$ to denote the value of $d_{lim}|_{J_{j}}$ after the acceptance of job $J_{j}$.

In Algorithm 3, Line 1, we initially set $d_{lim}$ to 0. At the submission of a new job $J_{j}$, we first update $d_{lim}$ to consider any progression of time since the previous submission (Line 3). If the resulting $d_{lim}|_{J_{j}}>d_{j}$ holds then we reject $J_{j}$. Otherwise we accept $J_{j}$ and allocate it to the machine that produces the smallest value $d_{lim}|_{J_{j}}^{\prime}$ (Lines 7 to 9). Contrary to Algorithm 3, Algorithm 1 allows a decrease of $d_{lim}$ due to progression of time. Therefore, there is no need for any compensation value.

Lemma 4

There is a legal schedule for all jobs accepted by Algorithm 3.

Proof

Acceptance of job $J_{j}$ requires $d_{j}\geq d_{lim}|_{J_{j}}$. If $J_{j}$ is allocated to machine $m_{m}$ then it completes at

[TABLE]

∎

For the proof of the competitive factor, we first establish a property of the schedule.

Lemma 5

Algorithm 3 always guarantees

[TABLE]

Proof

The claim holds whenever there is no load on any machine or if machine $m_{1}$ determines $d_{lim}$ due to Eq. (22). Similar to Lemma 2, we distinguish the events progression of time and acceptance of a new job.

First we consider progression from time $t$ to time $t^{\prime}$ and assume that the claim holds at time $t$. For every machine $m_{i}$ with $l(m_{i})|_{t}\leq t^{\prime}$, it leads to $l(m_{i})|_{t^{\prime}}=0\overset{Eq.(\ref{eq:def_dilim})}{\Rightarrow}d^{i}_{lim}|_{t^{\prime}}=t^{\prime}$. For all other machines, we have

[TABLE]

The function $d^{i}_{lim}|_{t^{\prime}}-t^{\prime}-\left(d^{i}_{lim}|_{t}-t\right)=-(t^{\prime}-t)\cdot\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{i}{m}}$ is decreasing in $i$. Therefore, progression of time does not require a change in the machine order. In addition, machine $m_{1}$ determines $d_{lim}|_{t^{\prime}}$ if it has already determined $d_{lim}|_{t}$. If machine $m_{1}$ does not determine $d_{lim}|_{t^{\prime}}$ then we apply induction and assume for all $i>1$ with $l(m_{i})|_{t}>t^{\prime}-t$

[TABLE]

Then Eq.(22) yields

[TABLE]

resulting in

[TABLE]

Next, we assume that Algorithm 3 accepts job $J_{j}$ and that the claim holds before accepting $J_{j}$. Algorithm 3 allocates $J_{j}$ to machine $m_{k}$. Re-indexing puts this machine at position $i\leq k$. For $k=1$, we either have $d_{lim}|_{J_{j}}=d_{lim}|_{J_{j}}^{\prime}$ or $d^{1}_{lim}|_{J_{j}}^{\prime}=d_{lim}|_{J_{j}}^{\prime}$. We have already stated that the claim holds in the latter case while in the former case, the claim continues to hold since no machine load decreases. Therefore, we assume $k>1$ and $d^{1}_{lim}|_{J_{j}}^{\prime}<d_{lim}|_{J_{j}}^{\prime}$, that is, machine $m_{h}$ with $h>1$ determines $d_{lim}|_{J_{j}}^{\prime}$.

For $l(m_{1})|_{J_{j}}+p_{j}+r_{j}\leq d_{j}$, Line 8 of Algorithm 3 guarantees

[TABLE]

For $l(m_{1})|_{J_{j}}+p_{j}+r_{j}>d_{j}\geq d_{lim}|_{J_{j}}$, we have either $d_{lim}|_{J_{j}}=d_{lim}|_{J_{j}}^{\prime}$ and the claim continues to hold or $i\leq h\leq k$ with $l(m_{h})|_{J_{j}}^{\prime}\leq l(m_{h-1})|_{J_{j}}$ and

[TABLE]

∎

Next, we prove a competitive ratio of Algorithm 3. To this end, we define busy and usable intervals of schedule $S$ generated by Algorithm 3: interval $[t,t^{\prime})$ is busy if $t=r_{j}$ is the submission time of a job $J_{j}$ and we have no load on any machine after progressing to $t$ but before accepting job $J_{j}$. $t^{\prime}$ is the first time after $t$ with no load on any machine after progressing to $t^{\prime}$ or a later time. Note that the submission time of any rejected job must be within a busy interval. ${\mathcal{J}}_{r}$ is the set of all rejected jobs with submission times in interval $[t,t^{\prime})$. Interval $[t,t^{\prime\prime})$ is usable with $t^{\prime\prime}=\max\left\{t^{\prime},\max_{J_{k}\in{\mathcal{J}}_{r}}\{d_{k}\}\right\}$. If rejected job $J_{k}$ determines $t^{\prime\prime}$ then we have $r_{k}\geq t$ and

[TABLE]

Using the definition of $P[t,t^{\prime})(S,{\mathcal{J}})$ in Section 3, we obtain

[TABLE]

Note that any time instance of schedule $S$ with at least one busy machine belongs to a busy interval and it is not possible to execute a rejected job at a time instance that does not belong to any usable interval. Such a restriction does not exist for an accepted job.

Theorem 4.1

The $P_{m}|\varepsilon,\mbox{online}|\sum p_{j}\cdot(1-U_{j})$ problem admits a deterministic online algorithm with competitive ratio at most

[TABLE]

Proof

Since no two busy intervals overlap, we assume $S$ to be a single busy interval $[t=0,t^{\prime})$ with the corresponding usable interval $[t=0,t^{\prime\prime}\leq\max_{J_{j}\in\mathcal{J}}\{d_{j}\})$. Then we have

[TABLE]

∎

The expression $m\cdot\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{1}{m}}+1$ has its minimal value $e\cdot\ln{\frac{1+\varepsilon}{\varepsilon}}+1$ for $m=\ln{\frac{1+\varepsilon}{\varepsilon}}$. Since it decreases for $1\leq m\leq\ln{\frac{1+\varepsilon}{\varepsilon}}$ and increases for $m\geq\ln{\frac{1+\varepsilon}{\varepsilon}}$, we may obtain a better competitive ratio by partitioning the system in groups of approximately $\ln{\frac{1+\varepsilon}{\varepsilon}}$ machines. In particular, this approach yields the following result.

Corollary 1

For $\ln{\frac{1+\varepsilon}{\varepsilon}}$ being an integer and $m=i\cdot\ln{\frac{1+\varepsilon}{\varepsilon}}$, $i\in\mathbb{N}$, the $P_{m}|\varepsilon,\mbox{online}|\sum p_{j}\cdot(1-U_{j})$ problem admits a deterministic online algorithm with competitive ratio at most

[TABLE]

Proof

We partition the machines into sets of machines with size $\ln{\frac{1+\varepsilon}{\varepsilon}}$. For each set of machines, we run Algorithm 3 and obtain a competitive ratio of at most $e\cdot\ln{\frac{1+\varepsilon}{\varepsilon}}+1$ for the set of jobs allocated to these machines. We consider any job not allocated to these machines on the next set of machines and repeat the procedure. Hence the competitive ratio of Theorem 4.1 with $m=\ln\frac{1+\varepsilon}{\varepsilon}$ carries over.

For $m=1$, Theorem 4.1 produces the competitive ratio of the single machine case although Algorithm 3 does not greedily accept every job that we can schedule: in particular, it rejects jobs with a deadline below the threshold deadline even if their small processing time allows a valid schedule. This rejection has no influence on the competitive ratio.

For $m>1$ and $\frac{1+\varepsilon}{\varepsilon}\leq e\Leftrightarrow\varepsilon>0.58$, greedy acceptance has a better competitive ratio than Algorithm 3 while the competitive ratio of Algorithm 3 is clearly better for smaller values of $\varepsilon$ and $m>1$.

We also briefly point out how to use our deterministic algorithm for parallel machines to obtain a randomized algorithm for small values of $\varepsilon$.

Corollary 2

The $1|\varepsilon,\mbox{online}|\sum p_{j}\cdot(1-U_{j})$ problem admits a randomized online algorithm against an oblivious adversary with competitive ratio at most

[TABLE]

if $\varepsilon>0$ is sufficiently small.

Proof

We simulate our deterministic Algorithm 3 with $m\in\left\{\left\lfloor\ln\left(\frac{1+\varepsilon}{\varepsilon}\right)\right\rfloor,\left\lceil\ln\left(\frac{1+\varepsilon}{\varepsilon}\right)\right\rceil\right\}$ machines. Denote by $ALG_{m}$ and $OPT_{m}$ the obtained utilization and the optimal utilization on these machines, respectively. Then we have

[TABLE]

We now choose one of the simulated machines uniformly at random which, on expectation, has exactly an $1/m$ fraction of the utilization of the simulated schedule, that is $\mathbb{E}[ALG]=\frac{1}{m}ALG_{m}$ resulting in $m^{2}\cdot\left(\frac{1+\varepsilon}{\varepsilon}\right)^{\frac{1}{m}}+m\geq\frac{OPT}{\mathbb{E}[ALG]}$. ∎

For $\ln\left(\frac{1+\varepsilon}{\varepsilon}\right)$ being integral, we obtain the competitive ratio $\ln\left(\frac{1+\varepsilon}{\varepsilon}\right)\cdot\left(\ln\left(\frac{1+\varepsilon}{\varepsilon}\right)\cdot e+1\right)$.

We note that a similar technique cannot be applied in the preemptive case, as we cannot independently treat the machines.

Lower Bounds

For the $P_{m}|\varepsilon,\mbox{online}|\sum p_{j}\cdot(1-U_{j})$ problem, no lower bound of the competitive ratio is known. In comparison to the single machine problems, it is more difficult to determine a lower bound for the non-preemptive problem than for the preemptive problem since any non-preemptive scheduling algorithm faces restrictions in the machine space that are not present in the preemptive problem. Looking back at the lower bound instance in the preemptive case, we realize that the generated schedules are non-preemptive. Therefore, we can use this approach to determine a lower bound although the common submission time in this approach prevents us from achieving the increase of the lower bound in the proof of Goldwasser Gol03 over the lower bound for the single machine preemptive problem. Hence, we cannot expect to obtain a tight lower bound with this approach. Moreover, the optimal schedule in the proof of Theorem 3.3 uses $\lfloor m\cdot(1+\varepsilon)\rfloor$ jobs of a given length and tight slack to cover the interval $[0,p_{j}\cdot(1+\varepsilon))$ as well as possible. For $\varepsilon<1$, we can schedule only $m$ of these jobs without applying preemption.

Therefore, we use a slightly modified approach for small $\varepsilon$. The adversary first submits a single job $J_{1}$ with $r_{1}=0$, $p_{1}=1$, and a sufficiently large deadline. An online algorithm must accept this job to prevent an infinite competitive ratio. We assume starting time $t$ of $J_{1}$. Then the adversary submits $m-1$ different groups of up to $m$ identical jobs with submission time $t$ and a tight slack such that we must accept one job of each group to prevent the target competitive ratio or an even larger competitive ratio. The adversary selects the job parameters such that each job must execute on a separate machine. After we have accepted one job of a group, the adversary continues with the submission of a job of the next group. Finally the adversary submits $m$ jobs with submission time $t$ and processing time $\frac{1}{\varepsilon}-\delta$ for an arbitrary small $\delta>0$. As in the approach of Theorem 3.3, we are not able to schedule any job of the final group.

Theorem 4.2

For the $P_{m}|\varepsilon,\mbox{online}|\sum p_{j}\cdot(1-U_{j})$ problem with $\varepsilon<1$, any deterministic online algorithm is at least strictly $c$-competitive with

[TABLE]

Proof

For $\varepsilon<1$, we cannot allocate any two jobs $J_{j}$ and $J_{k}$ to the same machine if both jobs have a tight slack, $r_{j}=r_{k}=t$ and $1\leq p_{j},p_{k}<\frac{1}{\varepsilon}$. Since job $J_{1}$ starts at time $t$, we can include it into this group of jobs, that is, we cannot allocate any other job of this group to the same machine as job $J_{1}$.

Assume that we want to test whether a competitive ratio $c$ is a strict lower bound. Then we must show that there is a set of increasing processing times $p_{1}=1<p_{2}<\ldots<p_{m}<p_{m+1}<\frac{1}{\varepsilon}$ such that we have

[TABLE]

Eq. (27) assumes that we have accepted exactly one job from block 1 to block $j-1$ but no job from block $j$. As already mentioned, we can only schedule the accepted jobs using exactly $j-1$ machines. In the optimal schedule, we execute job $J_{1}$ such that it either completes before $t$ or starts at $t+\frac{1}{\varepsilon}$ while we allocate $m$ jobs with processing time $p_{j}$ to a separate machine each starting at time $t$. Since the right hand side of Eq. (27) is increasing with increasing $j$, there is no benefit in considering a processing time $p_{j}$ that is not larger than processing time $p_{j-1}$. Otherwise we can reduce the processing time $p_{j-1}$ and obtain an larger value $c$.

To minimize $c$, we assume a value $p_{2}$ with $1<p_{2}<\frac{1}{\varepsilon}$ and $p_{m+1}=\frac{1}{\varepsilon}$. We justify the second assumption by the fact that the difference between $p_{m+1}$ and $\frac{1}{\varepsilon}$ is arbitrarily small. We transform Eq. (27) into a set of equations and then subtract the equation for $p_{j-1}$ from the equation for $p_{j}$:

[TABLE]

Then we must solve the equation $\frac{c}{m}=\left(\frac{m}{(c-1)\cdot\varepsilon}\right)^{\frac{1}{m-1}}-1$. The condition $p_{2}=\frac{c-1}{m}$is necessary to obtain the largest value for $c$ and guarantee the validity of Eq. (27) for $j=2$. ∎

For large values of $m$, we obtain approximately $\frac{c}{m}=\left(\frac{1}{\varepsilon}\right)^{\frac{1}{m}}$.

For $m=1$, the lower bound of Theorem 4.2 becomes $1+\frac{1}{\varepsilon}$, that is the lower bound of the corresponding preemptive problem. Theorems 4.1 and 4.2 show that there is a gap between the lower bound of the competitive ratio and the competitive ratio of Algorithm 3. Therefore, the lower bound of Theorem 4.2 is not the best possible lower bound for this problem. Deriving a better lower bound that is applicable to all values of $m$ remains a challenging open problem.

Acknowledgements.

This work was partially funded by ERC Advanced Grant 788893 AMDROMA.