Online Parallel Machine Scheduling to Maximize the Number of Early Jobs

Abstract

We study a maximization problem: online scheduling on m identical machines to maximize the number of early jobs. The problem is online in the sense that all jobs arrive over time. Each job's characteristics, such as processing time and due date, become known at its arrival time. We consider the preemption-restart model, in which preemption is allowed, while once a job is restarted, it loses all the progress that has been made on this job so far. If in some schedule a job is completed before or at its due date, then it is called early (or on time). The objective is to maximize the number of early jobs. For m identical machines, we prove an upper bound 1−(1/2𝑚) of competitive ratio and show that ECT (earliest completion time) algorithm is 1/2-competitive.

1. Introduction

In classical scheduling, it is generally assumed that the information for all jobs in an instance is known in advance. However, this assumption is not true in many situations. This promotes the emergence of online scheduling. There are three online models commonly considered [1]. The first model assumes that jobs arrive in a list without release dates. Any online algorithm has to schedule each job before seeing the next job in the list. The second model assumes that the running time of a job is unknown until the job is finished. The online algorithm only knows whether a job is still running at any time. The third model assumes that jobs arrive over time. At each time when a machine becomes idle, the algorithm schedules one of the available jobs, if any, on the machine.

In this paper, we consider the third model where jobs arrive over time. There are also three submodels for online scheduling where jobs arrive over time. The first one is nonpreemptive model, in which it is assumed that once a job is started on a machine, it must run to completion. The second one is preemption-resume model, in which it is assumed that a job on processing may be preempted at any time and be resumed from where it was preempted at a later moment. The third one is preemption-restart model. In this model, if a job is preempted during processing, it has to be restarted from the beginning for completion later on. Notice that, in the preemption-restart model, the finally completed jobs construct a nonpreemptive schedule. In this paper, we focus on the preemption-restart model in the online setting where jobs arrive over time.

We use the competitive analysis [2] to measure the performance of an online algorithm. For any job input sequence 𝐼, let 𝐶_ON(𝐼) denote the number of early jobs in the schedule produced by an online algorithm 𝒜_ON, and let 𝐶_OPT(𝐼) denote the number of early jobs in an optimal schedule. We say 𝒜_ON is 𝜌-competitive where𝐶𝜌=inf^ON(𝐼)𝐶_OPT(𝐼)∣𝐶_OPT(𝐼)>0. (1.1)𝜌 is also called the competitive ratio of 𝒜_ON. Clearly, 0≤𝜌≤1 holds. The closer the ratio 𝜌 approaches 1, the better the performance of algorithm 𝒜_ON.

Sgall [3] gave a survey on online scheduling, including results on both nonpreemptive and preemption-resume models. Shmoys et al. [4] studied a preemption-restart model to minimize the makespan and presented several results for scheduling jobs on 𝑚 parallel machines. Hoogeveen et al. [5] investigated the preemption-restart model in online single-machine scheduling to maximize the number of early jobs. They proved that the shortest remaining processing time (SRPT) rule yields an optimal online algorithm with competitive ratio 1/2. Note that SRPT rule implies earliest completion time (ECT) rule. In this paper, our main result is a kind of generalization of that in Hoogeveen et al. [5].

The rest of this paper is organized as follows. Section 2 introduces some definitions and notations. In Section 3, we show that 1−(1/2𝑚) is an upper bound of competitive ratio for all online algorithms. In Section 4, we present an online algorithm ECT based on the earliest completion time (ECT) rule and prove that the algorithm is 1/2-competitive.

2. Problem Definition and Notations

We are given 𝑚 identical machines. Without loss of generality, we denote them by machine-1,…, machine-𝑚, respectively. Each machine processes at most one job at any time. A sequence of jobs ℐ={𝐽₁,…,𝐽_𝑛} with due dates arrive over time where the value of 𝑛 is unknown to online algorithms in advance. The information of each job is released on its release time to online algorithms. If a job is completed on or before its due date, we say it is an early job; otherwise it is a tardy job. The objective is to maximize the number of early jobs. We consider the preemption-restart model such that if a job on processing is preempted, then all the progress that has been made on the job so far is lost. A preempted job has to be restarted from the beginning to be completed later on.

Below we introduce some notations. 𝑝_𝑗: the processing time of job 𝐽_𝑗.𝑟_𝑗: the release time of job 𝐽_𝑗.𝑑_𝑗: the due date of job 𝐽_𝑗.Feasible schedule: a schedule consists of early jobs.Current workload (of a machine): the total processing time of all jobs currently assigned to one machine at a time.

By the objective of maximizing the number of early jobs, we may schedule the processing of all tardy jobs after the last early job, and the processing of tardy jobs has no relation to the objective value. That is, it suffices to consider only feasible schedule and omit all the tardy jobs. In the remainder, when discussing a schedule produced by an online algorithm, we refer to a feasible schedule instead of the original schedule including preempted jobs.

At any time 𝑡, let 𝑝_𝑗(𝑡) denote the remaining processing time of job 𝐽_𝑗 with 𝑟_𝑗≤𝑡. From this definition, 𝑝_𝑗(𝑡)=𝑝_𝑗 if 𝐽_𝑗 is neither on processing at time 𝑡 nor completed by the time. On the other hand, if 𝐽_𝑗 was started at time 𝑠 and is being processed throughout time interval [𝑠,𝑡], then 𝑝_𝑗(𝑡)=𝑝_𝑗−(𝑡−𝑠). When the notation is completely understood, we sometimes use 𝑝_𝑗 instead of 𝑝_𝑗(𝑡) for notational convenience.

3. Upper Bound of Competitive Ratio

In order to show the upper bound of competitive ratio for all online algorithms, we use the following lemma.

Lemma 3.1. In 𝑚 identical machine scheduling problem, for any integer 𝑘≥0 and for all real numbers 𝑟 and 𝑑 with 𝑟<𝑑, there exists an adversary strategy 𝒮_𝑚=𝒮_𝑚(𝑘,𝑟,𝑑) with the following properties.(1)𝒮_𝑚 creates (2𝑘+1)𝑚 jobs. The earliest release time of these jobs is 𝑟, and the latest due date of these jobs is 𝑑.(2)There exists a feasible schedule in which all the (2𝑘+1)𝑚 jobs are early. In such a schedule, the machines are continuously busy throughout interval [𝑟,𝑑].(3)If 𝑢∈{0,1,…,𝑚} machines are unavailable throughout interval [𝑟,𝑑), the adversary strategy 𝒮_𝑚 can prevent any online algorithm from scheduling more than (2𝑘+1)(𝑚−𝑢) jobs to be early.(4)The adversary strategy 𝒮_𝑚 can prevent any online algorithm from scheduling more than (2𝑚−1)𝑘+𝑚 jobs to be early. That is, any online algorithm has at least 𝑘 tardy jobs.

Proof. The proof is by induction on 𝑘. For 𝑘=0, the adversary 𝒮_𝑚 releases 𝑚 jobs with processing time 𝑑−𝑟 at time 𝑟. For 𝑘≥1, the adversary 𝒮_𝑚 proceeds as follows. Let 𝐿=(𝑑−𝑟)/8, that is, 𝑑=𝑟+8𝐿. The adversary releases 2𝑚 jobs 𝐽₁,𝐽₂,…,𝐽_2𝑚 with processing times 𝑝_𝑖=3𝐿 and 𝑝_𝑚+𝑖=4𝐿 for 𝑖=1,2,…,𝑚 at time 𝑟. All these 2𝑚 jobs have due date 𝑑. Then the adversary waits until time 𝑟+2𝐿.
Case 1. If at time 𝑟+2𝐿 the online algorithm is processing at least one job 𝐽_𝑖 with 𝑖∈{1,2,…,𝑚} and thus 𝑝_𝑖=3𝐿, then 𝒮_𝑚 calls subadversary 𝒮_𝑚(𝑘−1,𝑟+4𝐿,𝑟+5𝐿).
Case 2. Otherwise, 𝒮_𝑚 calls subadversary 𝒮_𝑚(𝑘−1,𝑟+3𝐿,𝑟+4𝐿).
(1) The Proof of Property (1)
When 𝑘=0, Property (1) holds. Consider the case 𝑘≥1. Assume that Property (1) follows for 𝑘−1. Since 𝒮_𝑚 creates 2𝑚 new jobs 𝐽₁,𝐽₂,…,𝐽_2𝑚 together with the (2𝑘−1)𝑚 jobs generated by the subadversary, Property (1) holds for 𝑘.
(2) The Proof of Property (2)
To prove Property (2), we consider the following schedules with all jobs early. In Case 1, machine-𝑖(1≤𝑖≤𝑚) processes jobs 𝐽_𝑖 and 𝐽_𝑚+𝑖 within intervals [𝑟+5𝐿,𝑑] and [𝑟,𝑟+4𝐿], respectively, then the 𝑚 machines process all jobs of the subadversary by induction. In Case 2, machine-𝑖(1≤𝑖≤𝑚) processes jobs 𝐽_𝑖 and 𝐽_𝑚+𝑖 within intervals [𝑟,𝑟+3𝐿] and [𝑟+4𝐿,𝑑], respectively, then the 𝑚 machines process all jobs of the subadversary by induction.
(3) The Proof of Property (3)
Given the assumption that 𝑢∈{0,1,…,𝑚} machines are unavailable throughout interval [𝑟,𝑑], we prove Property (3) by induction on 𝑘. For 𝑘=0, Property (3) holds, that is, 𝒮_𝑚 can prevent any online algorithm from scheduling more than (𝑚−𝑢) jobs to be early with the assumption of 𝑢 unavailable machines. Assume that for 𝑘−1 (in 𝑘≥1 case), Property (3) holds, that is, 𝒮_𝑚(𝑘−1,𝑟,𝑑) can prevent any online algorithm from scheduling more than (2𝑘−1)(𝑚−𝑢) jobs to be early with 𝑚−𝑢 available machines. To prove that Property (3) holds for 𝑘, we observe that within interval [𝑟,𝑑], 𝑚−𝑢 available machines can schedule at most 2(𝑚−𝑢) jobs to be early among the 2𝑚 jobs that were released by 𝒮_𝑚. More precisely, the 𝑚−𝑢 machines can process at most 𝑚−𝑢 jobs during each of intervals [𝑟+3𝐿,𝑟+4𝐿] and [𝑟+4𝐿,𝑟+5𝐿]. This observation is true for both Cases 1 and 2. Together with the (2𝑘−1)(𝑚−𝑢) jobs generated by the subadversary, there are at most (2𝑘+1)(𝑚−𝑢) early jobs, and thus Property (3) follows.
(4) The Proof of Property (4)
Now, we show that Property (4) holds by induction on 𝑘. First, it is a trivial case when 𝑘=0. Assume that for 𝑘−1 (in 𝑘≥1 case), Property (4) holds, that is, 𝒮_𝑚(𝑘−1,𝑟,𝑑) can prevent any online algorithm from scheduling more than (2𝑚−1)(𝑘−1)+𝑚 jobs to be early. The remainder is to prove that Property (4) holds for 𝑘. Consider the following two cases.
Case A. The online algorithm schedules all the 2𝑚 jobs 𝐽₁,𝐽₂,…,𝐽_2𝑚 to be early. If Case 1 happens, that is, at least one of the 𝑚 jobs with length 3𝐿 is being processed at time 𝑟+2𝐿. Notice that this job is to be completed no earlier than time 𝑟+3𝐿. It implies that at least one of the 𝑚 jobs, denoted by 𝑅, with length 4𝐿 must be started within interval [𝑟+3𝐿,𝑟+4𝐿] to be completed on time due to its job length 4𝐿 and due date 𝑑=𝑟+8𝐿. The processing of 𝑅 will then cover interval [𝑟+4𝐿,𝑟+5𝐿] on one of the machines, that is, the machine for processing job 𝑅 is unavailable to other jobs throughout the interval, then we call subadversary 𝒮_𝑚=𝒮_𝑚(𝑘−1,𝑟+4𝐿,𝑟+5𝐿). By Property (3), throughout interval [𝑟+4𝐿,𝑟+5𝐿], the online algorithm can schedule at most (2𝑘−1)(𝑚−1) jobs to be early. Therefore, the total number of early jobs by the online algorithm is 2𝑚+(2𝑘−1)(𝑚−1)=(2𝑚−1)𝑘+𝑚+(1−𝑘)≤(2𝑚−1)𝑘+𝑚. (3.1) Otherwise, if Case 2 happens, then all the 𝑚 jobs, 𝐽_𝑚+1,…,𝐽_2𝑚, with length 4𝐿 must be completed by the 𝑚 machines on or before time 𝑑−3𝐿=𝑟+5𝐿. This implies that the 𝑚 machines are unavailable for all jobs except jobs 𝐽_𝑘(𝑚+1≤𝑘≤2𝑚) within interval [𝑟+3𝐿,𝑟+4𝐿]. By calling subadversary 𝒮_𝑚=𝒮_𝑚(𝑘−1,𝑟+3𝐿,𝑟+4𝐿), the online algorithm schedules only 2𝑚≤(2𝑚−1)𝑘+𝑚 jobs to be early. Hence, Property (4) holds in this case.
Case B. Among the 2𝑚 jobs 𝐽₁,…,𝐽_2𝑚, the online algorithm schedules at most 2𝑚−1 of them to be early. By induction, for 𝑘−1, the online algorithm can schedule at most (2𝑚−1)(𝑘−1)+𝑚 jobs to be early in both Case 1 and Case 2. Together with the other ≤2𝑚−1 early jobs scheduled by the online algorithm for 𝑘, we have that the number of early jobs is at most (2𝑚−1)(𝑘−1)+𝑚+(2𝑚−1)=(2𝑚−1)𝑘+𝑚. (3.2) Property (4) follows.

Remark 3.2. Lemma  2 in [5] is a special case of the above lemma with 𝑚=1.

Theorem 3.3. For the online scheduling problem on 𝑚 identical machines to maximize the number of early jobs, any online algorithm 𝒜 has competitive ratio 𝜌_𝒜≤1−(1/2𝑚).

Proof. Let 𝐶_OPT and 𝐶_ON denote the number of early jobs of an offline optimal algorithm (offline algorithm for short) and that of an online algorithm, respectively. By Lemma 3.1, we have 𝐶_OPT=(2𝑘+1)𝑚 and 𝐶_ON≤(2𝑚−1)𝑘+𝑚. Therefore, 𝐶_ON𝐶_OPT≤(2𝑚−1)𝑘+𝑚()𝑚12𝑘+1⟶1−2𝑚,𝑘⟶∞. (3.3) The theorem follows.

Remark 3.4. Theorem  3 in [5] is a special case of Theorem 3.3 with 𝑚=1.

4. ECT Algorithm

In this section, we describe and analyze online algorithm ECT, which is based on the shortest remaining processing time (SRPT) or ECT rule. Algorithm ECT constructs a feasible schedule of early jobs only, since all tardy jobs can be appended to the end of this schedule in an arbitrary order.

Given a job instance ℐ, algorithm ECT runs as follows.

Step 1. Wait until a decision time point 𝑡, at which either a new job is released or at least one of the 𝑚 machines, becomes idle.

Step 2. At time 𝑡, let 𝐽_𝑖 be the job such that 𝑝_𝑖=min{𝑝_𝑘∣𝑟_𝑘≤𝑡,𝑝_𝑘>0and𝑡+𝑝_𝑘≤𝑑_𝑘}, that is, 𝐽_𝑖 is with the shortest remaining processing time among all the uncompleted arrival jobs. If there is no idle machine at the time, schedule 𝐽_𝑖 on the machine with the least current workload and start the job immediately; otherwise, start to process 𝐽_𝑖 at the time on any idle machine.

Step 3. If at some decision point 𝑡, no more jobs are released and 𝑡+𝑝_𝑘>𝑑_𝑘 holds for any arrival job 𝐽_𝑘 with 𝑝_𝑘>0, stop; otherwise, go to Step 1.

Note that algorithm ECT applies the earliest completion time (ECT) policy to the case with 𝑚 identical machines. By Step 2 of the algorithm, a job is preempted only if a newly released job is supposed to be completed earlier than the current one.

Without loss of generality, we assume that the 𝑚 machines are reindexed in nondecreasing order of job length considering the 𝑚 jobs which are scheduled at the first position on the 𝑚 machines. Let 𝑁(𝑆) be the number of early jobs in a schedule 𝑆. Let 𝑆⃗ be the feasible schedule produced by ECT, and let 𝑆^∗ be an optimal schedule, respectively. Let 𝐽_𝑘(𝑆) be the job with the 𝑘th smallest completion time in schedule 𝑆. If two jobs are completed at the same time, the job completed on the machine with smaller index is regarded to be completed earlier.

Note that 𝑆⃗ only contains early jobs and algorithm ECT terminates at some time 𝑡, at which none of the rest uncompleted jobs in ℐ can meet its due date even if started at once.

Theorem 4.1. Algorithm ECT is 1/2-competitive.

Proof. If 𝑆^∗=𝑆⃗, the theorem follows. In the following proof, we assume that 𝑆^∗≠𝑆⃗. To prove the theorem, it is sufficient to prove that 𝑁(𝑆)⃗≥𝑁(𝑆^∗)/2. We construct a series of feasible schedules 𝑆⁰,𝑆¹,…,𝑆^ℎ such that 𝑆⁰=𝑆^∗,𝑆^ℎ=𝑆⃗, and 𝑆^𝑞(𝑞=1,…,ℎ−1) is different from 𝑆⃗. 𝑆^𝑞 is obtained from 𝑆^𝑞−1 for 𝑞=1,…,ℎ in the following way.
Let 𝑘^′(𝑞) be the smallest 𝑘 such that 𝐽_𝑘(𝑆^𝑞−1)≠𝐽_𝑘(𝑆)⃗ for 1≤𝑘≤𝑁(𝑆)⃗. Such a 𝑘 does exist since 𝑆^𝑞−1 is different from 𝑆⃗. From the notation, we have either 𝑘^′(𝑞)=1 or 𝐽_𝑘𝑆^𝑞−1=𝐽_𝑘𝑆⃗,𝑘∈1,…,𝑘^′𝑞−1. (4.1)𝑆^𝑞 is obtained by(i)deleting job 𝐽_{𝑘′(𝑞)}(𝑆^𝑞−1) from 𝑆^𝑞−1; (ii)either moving or adding job 𝐽_{𝑘′(𝑞)}(𝑆)⃗ to the place of 𝐽_{𝑘′(𝑞)}(𝑆^𝑞−1), depending on whether the job was already in 𝑆^𝑞−1.

By construction, 𝑆^𝑞 is necessarily feasible since 𝐽_{𝑘′(𝑞)}(𝑆)⃗ is the job to be completed the earliest among all uncompleted jobs at that time (ECT policy). Furthermore, for 𝑞=1,…,ℎ, we have either 𝑆^𝑞=𝑆⃗ or𝑘^′𝑞>𝑘^′,𝑁𝑆𝑞−1_𝑞≥𝑁𝑆^𝑞−1−1. (4.2)(4.3)

From inequality (4.2), we obtainℎ≤𝑁𝑆⃗. (4.4) From inequalities (4.3) and (4.4), we obtain𝑁𝑆⃗=𝑁𝑆^ℎ≥𝑁𝑆^ℎ−1−1≥𝑁𝑆^ℎ−2−2≥⋯≥𝑁𝑆⁰−ℎ=𝑁𝑆^∗−ℎ≥𝑁𝑆^∗−𝑁𝑆⃗. (4.5) As a consequence, 𝑁(𝑆)⃗≥𝑁(𝑆^∗)/2, and the theorem follows.

Acknowledgment

This work is partially supported by NSF of China under Grants nos. 71172189, 71101106, 70832005, 71071123, and 71090404/71090400.