Equal-length Jobs Research Articles

Scheduling unrelated machines with two types of jobs

In this paper, we consider the problem of scheduling a set of jobs having only two possible processing times on a set of unrelated parallel machines. This problem is a generalisation of the much more common problem of scheduling equal-length jobs on identical machines. Such a situation may occur in the production of two different types of products. First, we show that an earlier open problem of scheduling jobs with two possible processing times and on unrelated machines with the objective to minimise the makespan can be polynomially solved by an algorithm consisting of two phases. A slight modification of this algorithm yields an absolute worst-case error of for the case of two arbitrary processing times and , . Thus, for practical problems of a large size with two types of products and two possible processing times, the approximation algorithm generates schedules very close to an optimal one.

Improved Randomized Online Scheduling of Intervals and Jobs

We study the online preemptive scheduling of intervals and jobs (with restarts). Each interval or job has an arrival time, a deadline, a length and a weight. The objective is to maximize the total weight of completed intervals or jobs. While the deterministic case for intervals was settled a long time ago, the randomized case remains open. In this paper we first give a 2-competitive randomized algorithm for the case of equal length intervals. The algorithm is barely random in the sense that it randomly chooses between two deterministic algorithms at the beginning and then sticks with it thereafter. Then we extend the algorithm to cover several other cases of interval scheduling including monotone instances, C-benevolent instances and D-benevolent instances, giving the same competitive ratio. These algorithms are surprisingly simple but have the best competitive ratio against all previous (fully or barely) randomized algorithms. Next we extend the idea to give a 3-competitive algorithm for equal length jobs. Finally, we prove a lower bound of 2 on the competitive ratio of all barely random algorithms that choose between two deterministic algorithms for scheduling equal length intervals (and hence jobs). A preliminary version of this paper appeared in Fung et al. (The 6th International Workshop on Approximation and Online Algorithmspp, vol. 5426, pp. 53–66, 2008).

Improved online algorithms for the batch scheduling of equal-length jobs with incompatible families to maximize the weighted number of early jobs

We consider the online scheduling of equal-length jobs with incompatible families on \(m\) identical batch machines. Each job has a release time, a deadline and a weight. Each batch machine can process up to \(b\) jobs (which come from the same family) simultaneously as a batch, where \(b\) is called the capacity of the machines. Our goal is to determine a preemption-restart schedule which maximizes the weighted number of early jobs. For this problem, Li et al. (Inf Process Lett 112:503–508, 2012) provided an online algorithm of competitive ratio \(3+2\sqrt{2}\) for both \(b=\infty \) and \(b<\infty \). In this paper, we study two special cases of this problem. For the case that \(m=2\), we first present a lower bound 2, and then provide an online algorithm with a competitive ratio of 3 for both \(b=\infty \) and \(b<\infty \). For the case in which \(m=3\), \(b=\infty \) and all jobs come from a common family, we present an online algorithm with a competitive ratio of \((8+2\sqrt{15})/3\approx 5.249\).

Online batch scheduling of equal-length jobs on two identical batch machines to maximise the number of early jobs

We study the online batch scheduling of equal-length jobs on two identical batch machines. Each batch machine can process up to b jobs simultaneously as a batch (where b is called the capacity of the machines). The goal is to determine a schedule that maximises the (weighted) number of early jobs. For the non-preemptive model, we first present an upper bound that depends on the machine capacity b, and then we provide a greedy online algorithm with a competitive ratio of 1/(b + 1). For the preemption-restart model with b = ∞, we first show that no online algorithm has a competitive ratio greater than 0.595, and then we design an online algorithm with a competitive ratio of .

Branch less, cut more and minimize the number of late equal-length jobs on identical machines

A simple greedy-type solution for a discrete optimization problem does not guarantee the optimality if the problem is sufficiently complicated. Dynamic programming is then a commonly used method, and a direct combinatorial algorithm is its reasonable alternative. Here we propose such an algorithm with some specific features, called branch less and cut more, abbreviated blesscmore. A blesscmore algorithm, like a branch-and-bound algorithm uses a solution tree whereas the branching and cutting criteria are based on the analysis of the so-called behavior alternatives. Our O(n3logn) blesscmore algorithm solves an earlier open problem of scheduling n equal-length jobs with release times and due-dates on a group of identical machines to minimize the number of late jobs.

A best possible online algorithm for scheduling equal-length jobs on two machines with chain precedence constraints

We consider the online scheduling on two identical parallel machines with chain precedence constraints to minimize makespan, where jobs arrive over time and have identical processing times. For this online scheduling problem, Huo and Leung [Y. Huo and J.Y.-T. Leung, Online scheduling of precedence constrained tasks, SIAM Journal on Computing, 34 (2005), 743–762] proved that it is impossible to have an online algorithm of a competitive ratio 1. We provide a best possible online algorithm of competitive ratio 13−12.

Online scheduling of equal-length jobs with incompatible families on multiple batch machines to maximize the weighted number of early jobs

This paper studies the online scheduling of equal-length jobs with incompatible families on multiple batch machines which can process the jobs from a common family in batches, where each batch has a capacity b with b=∞ in the unbounded batching and b<∞ in the bounded batching. Each job J has an equal-length integral processing time p>0, an integral release time r(J)⩾0, an integral deadline d(J)⩾0 and a real weight w(J)⩾0. The goal is to determine a preemptive schedule with restart which maximizes the weighted number of early jobs. When p=1, we show that a simple greedy online algorithm has a competitive ratio 2, and establish the lower bound 2−1/b. This means that the greedy algorithm is of the best possible for b=∞. When p is any positive integer, we provide an online algorithm of competitive ratio 3+22 for both b=∞ and b<∞. This is the first online algorithm for the problem with a constant competitive ratio.

Temperature aware online algorithms for scheduling equal length jobs

We study the online scheduling problem of maximising job completion subject to temperature constraints. In our setting, jobs are of equal length and have deadlines and heat contributions. The algorithm tries to complete as many jobs as possible before their deadlines while keeping the temperature of the system within an acceptable limit. We give an optimal algorithm for the case where preemption is not allowed. Then we consider the case of preemption and prove a number of lower bounds, showing that for many combination of system parameters, preemption (with restart) is not helpful in improving the competitiveness.

Online scheduling on batching machines to minimise the total weighted completion time of jobs with precedence constraints and identical processing times

This article studies online scheduling of equal length jobs with precedence constraints on m parallel batching machines. The jobs arrive over time. The objective is to minimise the total weighted completion time of jobs. Denote the size of each batch by b with b = ∞ in the unbounded batching and b < ∞ in the bounded batching. For the unbounded batching version, we provide an online algorithm with a best possible competitive ratio of ρ m , where ρ m is the positive solution of ρ m+1 − ρ = 1. The algorithm is also best possible when the jobs have identical weights. For the bounded batching version with identical weights of jobs, we provide an online algorithm with a competitive ratio of 2.

Online scheduling of weighted equal-length jobs with hard deadlines on parallel machines

We consider the problem of scheduling a maximum profit selection of equal length jobs on m identical machines. Jobs arrive online over time and the goal is to determine a non-preemptive schedule which maximizes the total profit of the scheduled jobs. Let the common processing requirement of the jobs be p>0. For each job ji, i=1,…,n we are given a release time ri (at which the job becomes known) and a deadline ri+p+δi. If the job is scheduled and completed before the deadline, a profit of wi is earned.Upon arrival of a new job, an online algorithm must decide whether to accept the job or not. In case of acceptance, the online algorithms must provide a feasible starting date for the job.Competitive analysis has become a standard way of measuring the quality of online algorithms. For a maximization problem, an online algorithm is called c-competitive, if on every input instance it achieves at least a 1/c-fraction of the optimal (“offline”) profit.We give lower bounds for the competitivity of online algorithms and propose algorithms which match this lower bound up to a constant factor.

Parallel batch scheduling of equal-length jobs with release and due dates

In this paper we study parallel batch scheduling problems with bounded batch capacity and equal-length jobs in a single and parallel machine environment. It is shown that the feasibility problem 1|p-batch,b<n,r j ,p j =p,C j ?d j |? can be solved in O(n 2) time and that the problem of minimizing the maximum lateness can be solved in O(n 2log?n) time. For the parallel machine problem P|p-batch,b<n,r j ,p j =p,C j ?d j |? an O(n 3log?n)-time algorithm is provided, which can also be used to solve the problem of minimizing the maximum lateness in O(n 3log?2 n) time.

Minimizing total weighted tardiness on a single machine with release dates and equal-length jobs

In this paper we study the problem of scheduling n jobs with release dates, due dates, weights, and equal processing times on a single machine. The objective is to minimize total weighted tardiness. We formulate the problem as a time-indexed ILP after which we solve the LP-relaxation. We show that for certain special cases (namely when either all due dates, all weights, or all release dates are equal, or when all due dates and release dates are equally ordered), the solution for the LP-relaxation is either integral or can be adjusted in polynomial time into an integral one. For the general case we present a branching rule that performs well. Furthermore we show that the same approach holds for the m identical, parallel machines variant of the problem. Finally we show that with a minor modification the same approach also holds for the single-machine problems of minimizing the sum of weighted late jobs (1|r j ,p j =p|∑w j U j ) and the sum of weighted late work (1|r j ,p j =p|∑w j V j ) as well as their respective variants with m identical, parallel machines. We further show how we can solve these problems by applying column generation when there is not sufficient memory available to apply the direct ILP-approach.

Preemptive Scheduling of Equal-Length Jobs in Polynomial Time

We study the preemptive scheduling problem of a set of n jobs with release times and equal processing times on a single machine. The objective is to minimize the sum of the weighted completion times \({\sum_{i=1}^{n}w_{i}C_{i}}\) of the jobs. We propose for this problem the first parameterized algorithm on the number k of different weights. The runtime of the proposed algorithm is \({O\left(\left(\frac{n}{k}+1\right)^{k}n^{8}\right)}\) and hence, the problem is polynomially solvable for any fixed number k of different weights.

Preemptive scheduling of equal length jobs with release dates on two uniform parallel machines

We consider a problem of scheduling n jobs on two uniform parallel machines. For each job we are given its release date when the job becomes available for processing. All jobs have equal processing requirements. Preemptions are allowed. The objective is to find a schedule minimizing total completion time. We suggest an O ( n 3 ) algorithm to solve this problem.

Online nonpreemptive scheduling of equal-length jobs on two identical machines

We consider the nonpreemptive scheduling of two identical machines for jobs with equal processing times yet arbitrary release dates and deadlines. Our objective is to maximize the number of jobs completed by their deadlines. Using standard nomenclature, this problem is denoted as P 2 | p j = p , r j | Σ Ū j . The problem is known to be polynomially solvable in an offline setting. In an online variant of the problem, a job's existence and parameters are revealed to the scheduler only upon that job's release date. We present an online deterministic algorithm for the problem and prove that it is 3/2-competitive. A simple lower bound shows that this is the optimal deterministic competitiveness.

On single-machine scheduling without intermediate delays

This paper introduces the non-idling machine constraint where no intermediate idle time between the operations processed by a machine is allowed. In its first part, the paper considers the non-idling single-machine scheduling problem. Complexity aspects are first discussed. The “Earliest Non-Idling” property is then introduced as a sufficient condition so that an algorithm solving the original problem also solves its non-idling variant. Moreover it is shown that preemptive problems do have that property. The critical times of an instance are then introduced and it is shown that when their number is polynomial, as for equal-length jobs, a polynomial algorithm solving the original problem has a polynomial variant solving its non-idling version.

A simpler competitive analysis for scheduling equal-length jobs on one machine with restarts

We consider the online problem of scheduling jobs with equal processing times on a single machine. Each job has a release time and a deadline, and the goal is to maximize the number of jobs completed by their deadlines. Chrobak et al. (2007, SICOMP 36:6) introduce a preempt-restart model in which progress toward completing a preempted job is lost, yet that job can be restarted from scratch. They provide a 3 2 -competitive deterministic algorithm and show that this is the optimal competitiveness. Their analysis is based on a complex charging scheme among individual jobs and the use of several partial functions and mappings for assigning the charges. In this paper, we provide an alternative proof of the result using a more global potential argument to compare the relative progress of the algorithm versus the optimal schedule over time. This new proof is significantly simpler and more intuitive that the original, and our technique is applicable to related problems.

On-line scheduling of two parallel machines with a single server

In this paper, we consider the on-line scheduling of two parallel identical machines sharing a single server with the objective of minimizing the latest completion time of all jobs. Each job has to be setup by the server before being processed on one of the machines. Three special cases: equal length jobs, equal processing times and regular equal setup times are considered and the asymptotic competitive ratios of list scheduling are determined. Also, a lower bound for the equal length job case is given, and two heuristics with tight asymptotic competitive ratios for the other two cases are proposed.

A Note on Scheduling Equal-Length Jobs to Maximize Throughput

The main aim of this note is to show that a polynomial-time algorithm for the scheduling problem 1|r j ; p j = p| ∑ Uj given by Carlier in (1981) is incorrect. In this problem we are given n jobs with release times and deadlines. All jobs have the same processing time p. The objective is to find a non-preemptive schedule that maximizes the number of jobs completed by their deadlines. The feasibility version of this problem, where we ask whether all jobs can meet their deadlines, has been studied thoroughly. Polynomial-time algorithms for this version were first found, independently, by Simons (1978) and Carlier (1981). A faster algorithm, with running time O(n log n), was subsequently given by Garey et al. (1981). The elegant feasibility algorithm of Carlier (1981) is based on dynamic programming and it processes jobs from left to right on the time-axis. For each time t, it constructs a partial schedule with jobs that complete at or before time t. Carlier also attempted to apply the same technique to design a polynomial-time algorithm for the maximization version, 1|r j ; p j = p| ∑ Uj , and claimed an O(n3 log n)-time algorithm. His result is now widely cited in the literature. We show, however, that this algorithm is not correct, by giving an instance on which it produces a sub-optimal schedule. Our counter-example can be, in fact, extended to support a broader claim, namely that even the general approach from Carlier (1981) cannot yield a polynomial-time algorithm. By this general approach we mean a class of algorithms that processes the input from left to right and make decisions based on the deadline ordering, and not their exact values. The question remains as to how efficiently can we solve the scheduling problem 1|r j ; p j = p| ∑ Uj . Baptiste (1999) gave an O(n7)-time algorithm for the more general version of this problem where jobs have weights. We show how to modify his algorithm to obtain a faster, O(n5)-time algorithm for the non-weighted case. These last two results are discussed only briefly in this note. The complete proofs can be found in the full version of this paper, see Chrobak et al. (2004).

Preemptive scheduling of equal-length jobs to maximize weighted throughput

We study the problem of computing a preemptive schedule of equal-length jobs with given release times, deadlines and weights. Our goal is to maximize the weighted throughput. In Graham's notation this problem is described as (1|r j;p j=p; pmtn|∑ w jU j) . We provide an O( n 4)-time algorithm, improving the previous bound of O( n 10).