ArticlePDF Available

# Single machine scheduling with job-dependent convex cost and arbitrary precedence constraints

Authors:

## Abstract and Figures

In this work we combine resource augmentation and alpha-point scheduling techniques, which have resulted in very good performance scheduling algorithms, to compute approximate solutions for a general family of scheduling problems: each job has a convex non-decreasing cost function and the goal is to compute a schedule that minimizes the total cost subject to precedence constraints.We show that our algorithm is a O(1)O(1)-speed 11-approximation algorithm and our numerical experiments show that the speed-scaling ratio required is close to 11.
Content may be subject to copyright.
Single Machine Scheduling with Job-Dependent Convex Cost and Arbitrary
Precedence Constraints
Rodrigo A. Carrasco, Garud Iyengar, Cliﬀ Stein
Department of Industrial Engineering & Operations Research, Columbia University, New York, NY
Abstract
In this work we combine resource augmentation and alpha-point scheduling techniques, which have
resulted in very good performance scheduling algorithms, to compute approximate solutions for a
general family of scheduling problems: each job has a convex non-decreasing cost function and the
goal is to compute a schedule that minimizes the total cost subject to precedence constraints.
We show that our algorithm is a
O
(1)-speed 1-approximation algorithm and our numerical
experiments show that the speed-scaling ratio required is close to 1.
Keywords: scheduling, approximation algorithms, speed scaling, alpha-points, job-dependent
convex cost, weighted tardiness
1. Introduction
We consider the following oﬄine scheduling problem: we are given a collection of
n
jobs, where
job
i
has a requirement of
ρi
machine cycles, and the cost of completing job
i
at time
Ci
is given by
a non-decreasing convex function
fi
:
R+R+
. Additionally, we are given arbitrary precedence
constraints and the objective is to compute a schedule that minimizes the total cost
Pifi(Ci)
.
Because jobs have no release dates we can assume, without loss of generality, that the schedule is
non-preemptive. For simplicity we will use the three-ﬁeld notation [
11
], and denote this problem as
1|prec|Pfi(Ci).
Special cases of this problem have been studied since the early 1960s. Schild and Fredman
considered
PiC2
i
as the scheduling metric [
27
], whereas later Townsend studied a more general
cost functions of the form
f(Ci)
=
wiC2
i
+
viCi
, where
wi
and
vi
are arbitrary weights [
30
]. More
recently H¨ohn and Jacobs [
16
] presented a 1
.
75-approximation algorithm for the
PiwiC2
i
problem.
Some additional examples can be found in [
1
,
2
,
3
,
8
,
12
,
20
,
21
]. The ﬁrst major breakthrough
with general, possible non-convex, cost functions was due to Bansal and Pruhs [
5
], who developed a
O
(
log log nP
)-approximation algorithm for the 1
|ri, pmtn|Pfi(Ci)
problem. For the special case
with no release dates (i.e.
ri
0) this algorithm is a 16-approximation algorithm. Later, Cheung
and Shmoys [
7
] presented a pseudo-polynomial (2 +
)-approximation algorithm for the case without
preemption. Note that, to the best of our knowledge, there has been no results for problems with
arbitrary precedence constraints.
Corresponding author
Email addresses: rax@ieor.columbia.edu (Rodrigo A. Carrasco), garud@ieor.columbia.edu (Garud Iyengar),
cliff@ieor.columbia.edu (Cliﬀ Stein)
Final version available at https://doi.org/10.1016/j.orl.2013.05.008
2013. This manuscript version is made available under the CC-BY-NC-ND 4.0 license
http://creativecommons.
Preprint submitted to Operations Research Letters, v.2.5(180313092331) Tuesday 13th March, 2018
Due date related metrics are another set of interesting and widely used scheduling metrics that
satisfy the convexity requirement [
24
]. In these problems each job
i
di
and the objective function of the problem is a function of the completion times
Ci
di
. Some typical examples of convex due date related scheduling metrics are lateness (deﬁned as
Li
=
Cidi
) and tardiness (deﬁned as
Ti
=
max{
0
, Cidi}
). The total tardiness problem is
NP-Hard even in the case without release dates or precedence constraints [
18
,
19
], and thus the total
weighted tardiness is also NP-Hard. Since it is commonly used as industrial performance metric,
the total weighted tardiness has received much attention in the scheduling literature [
24
], but not
in the resource augmentation or
α
-points approximation algorithms literature. To the best of our
knowledge, only the paper by Bansal, et al. [
4
] has addressed the total weighted tardiness from
a resource augmentation point of view. In their work they present, among others, an algorithm
that is 2-machine, 24-speed, 4-approximation ratio for the 1
|ri|PwiTi
problem. Another important
metric that has received a lot of attention lately is the tardiness square
T2
, because it penalizes
more jobs with larger tardiness and thus it is a natural metric for just-in-time type processes. In
this setting only branch-and-bound algorithms have been proposed to solve it [26].
In this paper we propose an algorithm for the setting with job-dependent convex cost func-
tions with arbitrary precedence constraints that uses techniques from the
α
-point and resource
augmentation literatures.
The
α
-point algorithms were introduced by Phillips, Stein, and Wein [
23
], and Hall, Schulz,
Shmoys, and Wein [
14
,
15
], and have resulted in small constant factor approximation algorithms
for many scheduling problems [
28
]. In this approach, the scheduling problem is formulated as a
0
1 integer program (IP) in terms of decision variables
xit
that are 1 if job
i
completes at time
t
. The
α
-point of each job is deﬁned as the earliest time at which an
α
fraction of the job has
been completed in linear relaxation of the IP. The jobs are then ordered in some fashion according
to these
α
-points. Currently there are many variants and extensions of these technique including
choosing
α
randomly [
6
,
9
] or choosing a diﬀerent
α
for each job [
10
]. A detailed survey of many of
the current
α
-point algorithms and the approximation ratios achieved by them can be found in [
28
].
Resource augmentation was developed to circumvent the shortcomings of the worst-case approxi-
mation ratio criterion, and has helped explain why some algorithms perform much better in practice
than their worst-case theoretical guarantees. The main idea of this analysis is that one compares the
optimal solution of the original problem with the solution computed by an algorithm that has access
to an augmented set of resources: more machines, more space, faster speed, etc. Although the ﬁrst
examples of resource augmentation analysis are almost three decades old [
29
], this technique has
become popular only recently. Kalyanasundaram and Pruhs [
17
] introduced the idea, by showing that
running the algorithm at a faster speed was equivalent to having clairvoyance in the total ﬂow time
scheduling problem. Although it is known that there are no constant factor non-clairvoyant on-line
algorithm for this scheduling problem, they showed that one can achieve a constant competitive
ratio by speed scaling. The term resource augmentation analysis was introduced by Philips, Stein,
Trong, and Wein [
22
]. They deﬁned an
s
-speed
ρ
-approximation algorithm, as an algorithm that
achieves a
ρ
worst-case approximation ratio when jobs run at
s
times the nominal speed of the
machine. In [
22
] they also deﬁned an
m
-machine
s
-speed
ρ
-approximation algorithm, in which the
algorithm achieves the worst-case approximation ratio
ρ
when jobs are run at
s
times the nominal
speed and the algorithm has
m
times more machines at its disposal. A survey with some of the
on-line resource augmentation results can be found in [25].
1.1. Our Results
We make several contributions to the problem of scheduling jobs with convex cost functions:
(a)
We introduce a model that extends the previous models by allowing a more general nonlinear
2
job-dependent cost function as the scheduling metric.
(b)
We propose a new approximation algorithm for minimizing the total nonlinear schedule cost
that uses both the α-point and resource augmentation techniques.
(c)
We show that this algorithm has a small constant approximation ratio and a small speed-scaling
ratio for two important scheduling metrics, the total weighted tardiness and the total completion
time squared. Our numerical results show that the practical performance is signiﬁcantly superior
to the theoretical bounds.
Main Result. Our main result is the following
Theorem 1.1. Given njobs with arbitrary precedence constraints and convex non-decreasing cost
functions
fi(Ci)
, there is a
O
(1)-speed 1-approximation algorithm for the problem of non-preemptively
minimizing the total nonlinear cost Pfi(Ci).
The speed scaling constant is relatively small. Given
 >
0 our algorithm is a (4 +
)-speed
1-approximation algorithm. Moreover, we are not aware of any other algorithm that achieves this
nor that combines both resource augmentation and α-point techniques.
1.2. Our Methodology
Time-indexed IP formulations for scheduling problems are not typically of polynomial size,
therefore, we extend the polynomial size interval-indexed IP formulation introduced in [
14
], to
handle the nonlinear cost functions. The basic idea is to divide time into geometrically increasing
intervals and assign the completion time of each job to one of these intervals instead of a speciﬁc
time. In this formulation, variables
xit
are 1 if job
i
is completed in interval
t
and 0 otherwise. This
allows a polynomially sized problem, but since completion times only belong to an interval and not
exactly known, the approximation ratio suﬀers a small degradation. In Section 2we describe this
interval-indexed formulation in further detail.
After presenting our algorithm in Section 3, we analyse its approximation ratio. In doing so we
combine techniques from the
α
-points literature as well as the resource augmentation literature.
The key insight is that through resource augmentation, speciﬁcally speed scaling, we ensure that
the completion times given by the algorithm and the optimal completion times are comparable.
Finally, in section 4we report the results of our numerical experiments. These results clearly
show that our algorithm performs very well and that the actual speed-scaling required is less than
2% in the worst case scenarios.
2. Problem Formulation
2.1. Problem Setting
The problem setting is as follows. We are given
n
jobs, where job
i
has a processing requirement
of
ρiN+
machine cycles, and thus requires
pi
=
ρi
σ
time units on a machine that runs at speed
of
σ
cycles per time unit. Without loss of generality, we assume that
ρi>
0, for all
i
=
{
1
, . . . , n}
and
σ
= 1. Let
Ci
denote the completion time of job
i
and
fi(Ci)
, with
fi
:
R+R+
, denote a
job-dependent non-decreasing convex cost function. Let Π =
{π
(1)
, . . . , π
(
n
)
}
denote the order in
which the jobs are processed, i.e.
π
(
i
) =
k
implies that the
i
-th job to be processed is job
k
. Then
Cπ(i)
=
Cπ(i1)
+
pπ(i)
is the completion time of the
i
-th job, where
π
(0) = 0 and
Cπ(0)
= 0, and is
completely determined by the order Π when all jobs are processed at the same speed.
The objective is to compute a feasible schedule, consisting of an order Π that respects
precedence constraints and minimizes the total cost of all jobs, i.e. minimizes the function,
F(Π) = Pn
i=1 fπ(i)Cπ(i).
3
2.2. Interval-Indexed Formulation
We now modify and extend the interval-indexed formulation proposed by Hall et al. [
14
] for
the total nonlinear cost setting. The interval-indexed formulation divides the time horizon into
geometrically increasing intervals, and the completion time of each job is assigned to one of these
intervals. The problem formulation is as follows. We divide the time horizon into the following
geometrically increasing intervals: [
κ, κ
], (
κ,
(1 +
)
κ
], ((1 +
)
κ,
(1 +
)
2κ
],
. . .
, where
 >
0 is an
arbitrary small constant, and
κ
=
minj{pj}
denotes the smallest interval size that will hold at least
one whole job. We deﬁne interval
It
= (
τt1, τt
], with
τ0
=
κ
and
τt
=
κ
(1+
)
t1
. The interval index
ranges over
{
1
, . . . , T }
, with
T
=
min dte:κ(1 + )t1Pn
i=1 pi
; and thus, we have a polynomial
number of indices t.
Let
xit
be 1 if job
i
completes in the time interval
It
= (
τt1, τt
] and 0 otherwise. We consider
the following IP, which is a lower bound on
F
(Π) since we consider the initial time of each time
interval It:
min
xPn
i=1 PT
t=1 fi(τt1)xit (1)
s.t.: PT
t=1 xit = 1, i ={1, . . . , n},(2)
Pn
i=1 Pt
u=1 pixiu τt, t ={1, . . . , T },(3)
xit = 0,if τt< pi, i ={1, . . . , n}, t ={1, . . . , T },(4)
Pt
u=1 xi1uPt
u=1 xi2u,if i1i2, t ={1, . . . , T },(5)
xit ∈ {0,1}, i ={1, . . . , n}, t ={1, . . . , T }.(6)
We have constraint (2) because each job
i
must ﬁnish in a unique time interval; constraint (3)
because since only one job can be processed at any given time, the total processing time of jobs up
to time interval
It
must be at most
τt
units; constraint (4) because each job
i
requires
pi
time units
to be processed; and constraint (5) because the precedence constraint
i1i2
implies that job
i2
cannot ﬁnish in an interval earlier than
i1
. Note that, although the function
fi(Ci)
is non-linear,
the objective in the interval approximation (1) is linear and also note that the error associated with
the interval relaxation is controlled through .
It is important to note that this integer program only provides a lower bound for
F
(Π) but
it might not be feasible. This is because the precedence constraints (5) do not ensure that two
sequential jobs that ﬁnish in the same interval have the right order.
3. Approximation Algorithm for Total Job-dependent Nonlinear Cost
We now describe the speed scaling and
α
-point based algorithm for the total job-dependent
nonlinear cost metric, called Schedule by
α
-intervals and Resource Augmentation (SAIRA)
which is shown in Figure 1.
Let
¯xit
denote the optimal solution of the linear relaxation of the integer program (1) when
replacing the constraints (6) by
xit
0. In steps 1and 2of the algorithm we model and compute
the optimal solution
¯x
and in step 3, given 0
α
1, we compute the
α
-interval of job
i
, which
is deﬁned as,
Iα
i
=
min t:Pt
u=1 ¯xiu α
. Since several jobs may ﬁnish in the same interval, let
Jt
=
{i
:
Iα
i
=
t}
denote the set of jobs that ﬁnish in interval
It
. In step 4we describe the order Π
α
that we use to schedule jobs.
Next, in step 5, we speed up each job by
γ
and ﬁnally in steps 6and 7we compute the completion
times given the calculated speeds and return the schedule Π
α
and completion times
Cα
. Note that
since γis constant for all jobs, the SAIRA algorithm is a γ-speed approximation algorithm.
We now analyse this algorithm’s performance. We will assume w.l.o.g. that Iα
1Iα
2. . . Iα
n.
4
Schedule by α-intervals and Resource Augmentation (SAIRA)
Inputs: set of jobs, functions fi(Ci), α(0,1),  > 0, γ > 1.
1 Divide time into increasing time intervals It= (τt1, τt], with τt=κ(1 + )t1.
2 Compute an optimal solution ¯x to the linear relaxation of problem (1).
3 Compute the α-intervals ταand the sets Jt.
4 Compute an order Παthat has the sets Jtordered in non-decreasing values of tand the
jobs within each set in a manner consistent with the precedence constraints.
5 Run each job iat speed γ.
6 Set the i-th job to start at time Cα
π(i1), which is the completion time of the previous
job using speeds γ, and Cα
π(0) = 0.
7return schedule Παand completion times Cα.
Figure 1: Schedule by α-intervals and Resource Augmentation Algorithm
First, the following lemma shows that the output of the SAIRA algorithm is indeed feasible.
Lemma 3.1. If i1i2, then constraint (5) implies that Iα
i1Iα
i2.
Proof.
Evaluating constraint (5) corresponding to
i1i2
, for
t
=
Iα
i2
, we have that,
PIα
i2
u=1 xi1u
PIα
i2
u=1 xi2uα
, where the last inequality follows from the deﬁnition of
Iα
i2
. The chain of inequalities
implies that PIα
i2
u=1 xi1uα, so Iα
i1Iα
i2.
Since the SAIRA algorithm schedules jobs by ﬁrst ordering the sets
Jt
in increasing order of
t
,
and then orders the jobs within each set in a way that is consistent with the precedence constraints,
by Lemma 3.1 it follows that the SAIRA algorithm preserves the precedence constraints, and,
therefore, the output of the algorithm is feasible.
Theorem 3.1.
The SAIRA algorithm with
α
=
1
2
and
γ
= (4+
)is a (4+
)-speed, 1-approximation
algorithm for the total weighted non-linear cost problem with convex non-decreasing cost and arbitrary
precedence constraints, 1|prec|Pfi(Ci).
Proof.
Let
C
i
be the completion time of job
i
in the optimal solution,
fi(C
i)
denote its cost,
ˆxit
denote an optimal solution of the integer problem (1), and
¯xit
the fractional optimal solution of its
linear relaxation. Because we consider
τt1
as the completion time for all jobs that ﬁnish in time
interval
t
, and since
¯xit
is the optimal solution of the linear relaxation and
fi(C)
is non-decreasing
we have that
n
X
i=1
T
X
t=1
fi(τt1) ¯xit
n
X
i=1
T
X
t=1
fi(τt1) ˆxit
n
X
i=1
fi(C
i).(7)
Let
¯
Ci
=
PT
t=1 τt1¯xit
denote the optimal fractional completion time of job
i
, given by the
optimal solution of the relaxed linear program. Because
fi(C)
is convex and
Pt¯xit
= 1 from
constraint (2) then
fi¯
Ci=fi T
X
t=1
τt1¯xit!
T
X
t=1
fi(τt1) ¯xit.(8)
5
and thus, from (7) and (8),
n
X
i=1
fi¯
Ci
n
X
i=1
fi(C
i).(9)
Because there are no release date constraints there is no idle time between jobs and we can
bound the completion time determined by the algorithm, Cα
i, by
Cα
i=1
γ
i
X
j=1
pj1
γα
i
X
j=1
Iα
j
X
u=1
pj¯xju 1
γα
n
X
j=1
Iα
i
X
u=1
pj¯xju,(10)
and from constraint (3) for t=Iα
iwe get that,
Cα
i1
γα τIα
i.(11)
Since it is possible that
PIα
i
t=1 ¯xit > α
; we deﬁne
X(1)
i
=
αPIα
i1
t=1 ¯xit
and
X(2)
i
=
PIα
i
t=1 ¯xit α
,
thus X(1)
i+X(2)
i= ¯xiIα
i, and we can rewrite
¯
Ci=
Iα
i1
X
t=1
τt1¯xit +τIα
i1X(1)
i+τIα
i1X(2)
i+
T
X
t=Iα
i+1
τt1¯xit,(12)
and eliminating the lower terms of the previous sum we get that,
¯
CiτIα
i1X(2)
i+
T
X
t=Iα
i+1
τt1¯xit τIα
i1X(2)
i+
T
X
t=Iα
i+1
τIα
i1¯xit =τIα
i1(1 α).(13)
Because
τIα
i
= (1 +
)
τIα
i1
, from (11) and (13) we get that
Cα
i(1+)
γα(1α)¯
Ci
. The key step is
that by setting
γ
=
(1+)
α(1α)
, which implies that we have a
(1+)
α(1α)
-speed approximation algorithm, we
make the algorithm’s completion time and the fractional completion time comparable, and thus,
n
X
i=1
fi(Cα
i)
n
X
i=1
fi(1 + )
γα(1 α)¯
Ci=
n
X
i=1
fi¯
Ci.(14)
Finally, from (9) and (14) it follows that
n
X
i=1
fi(Cα
i)
n
X
i=1
fi(C
i),(15)
and by setting
α
=
arg min0α1n1
α(1α)o
=
1
2
, which minimizes the resource augmentation
requirement, we get the desired speed and approximation ratios.
Regretfully, we are not able to extend this algorithm to the setting where release dates are
present, since we use speed scaling as a method to make sure that jobs are ﬁnished in a certain
interval.
Since the tardiness metric
Td
i
, with
d
1, is convex and non-decreasing, we have the following
6
Problem Instances Size (n) Average Ratio 99.5% Worst Ratio
1|prec|PwiTi
20,720 10 0.139 0.189 0.205
20,000 10, bimodal 0.150 0.220 0.222
20,010 50 0.1510.179 0.192
20,010 100 0.1480.168 0.176
20,002 500 0.1450.155 0.159
1|prec|PwiC2
i
20,010 10 0.052 0.053 0.055
20,010 100 0.0590.059 0.059
1|prec|PwiT2
i
20,000 10 0.023 0.036 0.041
20,000 500 0.0280.031 0.032
Figure 2: Experimental Approximation Ratios Summary
corollary.
Corollary 3.1.
For any
d
1, the SAIRA algorithm with
α
=
1
2
and
γ
= (4 +
)is a (4 +
)-speed,
1-approximation algorithm for the total weighted tardiness with arbitrary precedence constraints,
1|prec|PwiTd
i.
For the speciﬁc setting where
fi(Ci)
=
Cd
i
, with
d
1, if no resource augmentation is allowed,
we have the following corollary.
Corollary 3.2.
For any
d
1, the SAIRA algorithm with
α
=
1
2
and
γ
= 1 is a (4 +
)
d
-
approximation algorithm for the 1|prec|PwiCd
iproblem.
4. Experimental Results
In this section we present a simulation based performance analysis of the SAIRA algorithm. In
our simulations we considered two common scheduling metrics: total weighted tardiness, where
fi(Ci)
=
wi
(
Cidi
)
+
, with
di
denoting job
i
’s due date; and total weighted completion time
squared, where fi(Ci) = wiC2
i.
For each setting we simulated a large number of randomly generated instances with
= 0
.
1
and the following distributions:
wiunif{
0
,...,
20
}
,
ρiunif{
1
,...,
10
}
, and for the tardiness
setting
diunif{
0
,...,
0
.
1
Pρi}
. We also analysed instances with much larger ones (such as
ρiunif{
1
,...,
100
}
), as well as
ρi
drawn from bimodal distributions, which are generally hard for
scheduling algorithms, without observing any signiﬁcant degradation in the performance.
We compared the output of our algorithm with the integer solution of the interval-and-speed-
indexed formulation (IPi), its linear relaxation (LPi), and when possible to the integer and relaxed
solutions of a time-indexed formulation for this problem (IPt and LPt respectively). Although we
do not explicitly give these two last formulations, we use them to help us understand whether the
optimality gap is a consequence of the rounding in the algorithm or due to the gap in the interval
relaxation of the LP. Because the IPt formulation is non-polynomial in size, it becomes impractical
to solve it for large instances, and thus, we have to use the LPi solution as a proxy to estimate
our empirical approximation ratio, and thus the real approximation ratio is likely to be better. All
simulations were done in Matlab, using Gurobi [
13
] and Gurobi MEX [
31
] to solve the IP and LP
relaxations of each instance. Figure 2shows a summary of simulation results for all the diﬀerent
cases and instance sizes. For large instances (
n
50) the ratios were computed comparing the
algorithm’s output with the LPi and not the IPt solution.
Figure 3a shows further details for the total weighted tardiness case with instances of
n
= 500
jobs. In this ﬁgure we display the full histogram of the approximation ratios. We believe that the
full histogram gives a better understanding of how the algorithm performs as compared to just
7
(a) SAIRA/LPi Ratio for n= 500, 20,002 instances. (b) LPi/IPt Ratio for n= 10, 20,720 instances.
Figure 3: SAIRA Experimental Approximation Ratio for 1|prec|PwiTi.
reporting an average value or a worst case value. In the histogram we highlight the average value for
all simulations and the 99
.
5% quantile and for both measures we also display the 99
.
99% conﬁdence
intervals, shown as doted lines around the corresponding value.
Although the performance shown in ﬁgure 3a is very good, the real approximation ratio is likely
to be even better since, as shown in ﬁgure 3b, the average gap between the IPt and LPI solutions
is 0
.
8. Additionally, we computed the minimum speed-up required in each instance so that the
schedule determined by the SAIRA algorithm would have the same cost as the optimal schedule.
Figure 4shows that only a small speed-up is required, being 1
.
053 the maximum speed-up required
among all the instances.
We repeated the same analysis for the 1
|prec|PwiC2
i
problem. Figures 5a and 5b show details
of some of the simulated settings. Since the cost function is quadratic in
Ci
the performance is even
better than the total weighted tardiness case and the required speed-up is smaller, with a maximum
speed-up of 1
.
035. As expected, when the
T2
i
metric was used the performance was also better than
when using the Timetric.
5. Conclusions
We suspect that this methodology could be further extended to other
α
-point based algorithms
to obtain smaller speed scaling ratios for the scheduling problems presented here, or even construct
new algorithms for other settings such as multiple machines or other scheduling metrics.
Acknowledgements
This research was partially supported by NSF grants CCF-0728733 and CCF-0915681; NSF
grant DMS-1016571, ONR grant N000140310514, and DOE grants DEFG02-08ER25856 and DE-
AR0000235; and Fulbright/Conicyt Chile.
Figure 4: Minimum Speed-Up Required for 1|prec|PwiTi, for n= 10.
8
(a) SAIRA/LPi Ratio for n= 100, 20,010 instances. (b) Minimum Speed-Up Required for n= 10.
Figure 5: SAIRA Experimental Approximation Ratio for 1|prec|PwiC2
i
References
[1]
Alidaee, B. Single machine scheduling with nonlinear cost functions. Computers & operations
research 18, 3 (1991), 317–322.
[2]
Alidaee, B. Numerical Methods for Single Machine Scheduling with Non-Linear Cost Functions
to Minimize Total Cost. The Journal of the Operational Research Society 44, 2 (Feb. 1993),
125.
[3]
Bagga, P., and Kalra, K. NoteA Node Elimination Procedure for Townsend’s Algorithm
for Solving the Single Machine Quadratic Penalty Function Scheduling Problem. Management
Science 26, 6 (1980), 633–637.
[4]
Bansal, N., Chan, H.-L., Khandekar, R., Pruhs, K., Stein, C., and Schieber, B.
Non-Preemptive Min-Sum Scheduling with Resource Augmentation. In 48th Annual IEEE
Symposium on Foundations of Computer Science (FOCS’07) (Oct. 2007), IEEE, pp. 614–624.
[5]
Bansal, N., and Pruhs, K. The Geometry of Scheduling. In 2010 IEEE 51st Annual
Symposium on Foundations of Computer Science (Oct. 2010), IEEE, pp. 407–414.
[6]
Chekuri, C., Motwani, R., Natarajan, B., and Stein, C. Approximation Techniques
for Average Completion Time Scheduling. SIAM Journal on Computing 31, 1 (2001), 146.
[7]
Cheung, M., and Shmoys, D. A Primal-Dual Approximation Algorithm for Min-Sum
Single-Machine Scheduling Problems. Approximation, Randomization, and Combinatorial
Optimization. Algorithms and Techniques (2011), 135–146.
[8]
Croce, F. D., Szwarc, W., Tadei, R., Baracco, P., and di Tullio, R. Minimizing the
weighted sum of quadratic completion times on a single machine. Naval Research Logistics 42,
8 (Dec. 1995), 1263–1270.
[9]
Goemans, M. X. Improved approximation algorthims for scheduling with release dates.
ACM-SIAM symposium on Discrete algorithms (1997), 591–598.
[10]
Goemans, M. X., Queyranne, M., Schulz, A. S., Skutella, M., and Wang, Y. Single
Machine Scheduling with Release Dates. SIAM Journal on Discrete Mathematics 15, 2 (2002),
165.
9
[11]
Graham, R., Lawler, E. L., Lenstra, J. K., and Rinnooy Kan, A. H. G. Optimization
and approximation in deterministic sequencing and scheduling: a survey. Discrete optimization
5(1979), 287–326.
[12]
Gupta, S. K., and Sen, T. On the Single Machine Scheduling Problem with Quadratic
Penalty Function of Completion Times: An Improved Branching Procedure. Management
Science 30, 5 (1984), 644–647.
[13] Gurobi Optimization, I. Gurobi Optimizer Reference Manual, 2012.
[14]
Hall, L. A., Schulz, A. S., Shmoys, D. B., and Wein, J. Scheduling to Minimize
Average Completion Time: Oﬀ-Line and On-Line Approximation Algorithms. Mathematics of
Operations Research 22, 3 (Aug. 1997), 513–544.
[15]
Hall, L. A., Shmoys, D. B., and Wein, J. Scheduling to minimize average completion time:
oﬀ-line and on-line algorithms. In Proceedings of the seventh annual ACM-SIAM symposium
on Discrete algorithms (Philadelphia, PA, USA, Aug. 1996), SODA ’96, Society for Industrial
and Applied Mathematics, pp. 142–151.
[16]
H
¨
ohn, W., and Jacobs, T. An experimental and analytical study of order constraints
for single machine scheduling with quadratic cost. Proc. of the 14th Workshop on Algorithm
Engineering and Experiments (ALENEX) (2012), 103–117.
[17]
Kalyanasundaram, B., and Pruhs, K. R. Speed is as powerful as clairvoyance. Journal of
the ACM 47, 4 (July 2000), 617–643.
[18]
Lawler, E. L. A “pseudopolynomial” algorithm for sequencing jobs to minimize total
tardiness. In Studies in integer programming (Proc. Workshop, Bonn, 1975) (Bonn, 1977),
vol. 1, pp. 331–342.
[19]
Lawler, E. L., and Moore, J. M. A Functional Equation and its Application to Resource
Allocation and Sequencing Problems. Management Science 16, 1 (Sept. 1969), 77–84.
[20]
Mondal, S. A., and Sen, A. K. An improved precedence rule for single machine sequencing
problems with quadratic penalty. European Journal of Operational Research 125, 2 (Sept.
2000), 425–428.
[21]
Moore, J. M. An n job, one machine sequencing algorithm for minimizing the number of late
jobs. Management Science 15, 1 (1968), 102–109.
[22]
Phillips, C. A., Stein, C., Torng, E., and Wein, J. Optimal time-critical scheduling via
resource augmentation. Algorithmica 32, 2 (2002), 163–200.
[23]
Phillips, C. A., Stein, C., and Wein, J. Minimizing average completion time in the
presence of release dates. Mathematical Programming 82, 1-2 (June 1998), 199–223.
[24]
Pinedo, M. Scheduling: Theory, Algorithms, and Systems, 3rd ed. Springer New York, New
York, NY, 2008.
[25]
Pruhs, K. R., Sgall, J., and Torng, E. 15. Online Scheduling. In Handbook of Scheduling:
Algorithms, Models, and Performance Analysis. 2004.
[26]
Schaller, J., and Valente, J. M. Minimizing the weighted sum of squared tardiness on a
single machine. Computers & Operations Research 39, 5 (May 2012), 919–928.
10
[27]
Schild, A., and Fredman, I. J. Scheduling tasks with deadlines and non-linear loss functions.
Management Science 9, 1 (1962), 73–81.
[28]
Skutella, M. List Scheduling in Order of
α
-Points on a Single Machine. vol. 3484 of Lecture
Notes in Computer Science. Springer, 2006, pp. 250–291.
[29]
Sleator, D. D., and Tarjan, R. E. Amortized eﬃciency of list update and paging rules.
Communications of the ACM 28, 2 (Feb. 1985), 202–208.
[30]
Townsend, W. The single machine problem with quadratic penalty function of completion
times: a branch-and-bound solution. Management Science 24, 5 (1978), 530–534.
[31]
Yin, W. Gurobi Mex: A MATLAB interface for Gurobi. Online at
http://convexoptimization.com/wikimization/index.php/gurobi mex.
11
... Job scheduling has been studied for decades. In fact, the Min-WCS problem is a special case of singlemachine scheduling with a non-linear objective function under precedence constraints, which has been studied by Schulz and Verschae [15] and Carrasco et al. [16]. Specifically, for any > 0, the algorithm proposed by Schulz and Verschae approximates the optimum within a factor of (2+ ) when the objective function is concave [15]. ...
... Specifically, for any > 0, the algorithm proposed by Schulz and Verschae approximates the optimum within a factor of (2+ ) when the objective function is concave [15]. When the objective function is convex, Carrasco et al. proposed a (4 + )-speed 1-approximation algorithm for any > 0 [16]. 3 The solutions proposed by Schulz and Verschae [15] and Carrasco et al. [16] are based on linear programming rounding. ...
... When the objective function is convex, Carrasco et al. proposed a (4 + )-speed 1-approximation algorithm for any > 0 [16]. 3 The solutions proposed by Schulz and Verschae [15] and Carrasco et al. [16] are based on linear programming rounding. The objective function of the Min-WCS problem is convex, and we give a randomized 2.733-approximation algorithm for the Min-WCS problem without linear programming. ...
Preprint
We consider a transmission scheduling problem in which multiple systems receive update information through a shared Time Division Multiple Access (TDMA) channel. To provide timely delivery of update information, the problem asks for a schedule that minimizes the overall age of information. We call this problem the Min-Age problem. This problem is first studied by He \textit{et al.} [IEEE Trans. Inform. Theory, 2018], who identified several special cases where the problem can be solved optimally in polynomial time. Our contribution is threefold. First, we introduce a new job scheduling problem called the Min-WCS problem, and we prove that, for any constant $r \geq 1$, every $r$-approximation algorithm for the Min-WCS problem can be transformed into an $r$-approximation algorithm for the Min-Age problem. Second, we give a randomized 2.733-approximation algorithm and a dynamic-programming-based exact algorithm for the Min-WCS problem. Finally, we prove that the Min-Age problem is NP-hard.
... Formulation (F k ) is not a relaxation of (F ); as a consequence, for k > 1, the optimal objective function value of (F k ) does not necessarily provide an upper bound on the optimal value of (F ). We can modify (F k ) (see, e.g., Carrasco et al. 2013, Carrasco et al. 2018, Fuentes et al. 2021) to obtain a relaxation as follows. Define (F sk ) by substituting the constraints in (2c) with ...
Article
Effective computational methods are important for practitioners and researchers working in strategic underground mine planning. We consider a class of problems that can be modeled as a resource-constrained project scheduling problem with optional activities; the objective maximizes net present value. We provide a computational review of math programming and constraint programming techniques for this problem, describe and implement novel problem-size reductions, and introduce an aggregated linear program that guides a list scheduling algorithm running over unaggregated instances. Practical, large-scale planning problems cannot be processed using standard optimization approaches. However, our strategies allow us to solve them to within about 5% of optimality in several hours, even for the most difficult instances. History: Accepted by Andrea Lodi, Area Editor for Design and Analysis of Algorithms—Discrete. Funding: This work was supported by Alford Mining Systems, the Centro de Modelamiento Matemático [Grants ACE210010 and FB21005], ANID-Chile [BASAL funds for center of excellence and FONDEF Grant ID19-10164], and the supercomputing infrastructure of the NLHPC [Grant ECM-02].
... Angel, Bampis, and Kacem [4] derive constant approximations for nonpreemptive models with unrelated machines and release dates. Carrasco, Iyengar, and Stein [8] obtain similar results even under precedence constraints. ...
... This technique of increasing a resource (in this case speed) to achieve an approximate optimal solution is known as resource augmentation, and it has been recently used in many scheduling applications as a method to circumvent the limitations of the worst-case scenario analysis that is done in approximation algorithms. A summary of the results presented in this chapter can be found in [ Carrasco et al., 2013 ] . ...
Article
We consider a transmission scheduling problem in which multiple agents receive update information through a shared Time Division Multiple Access (TDMA) channel. To provide timely delivery of update information, the problem asks for a schedule that minimizes the overall Age of Information (AoI). We call this problem the Min-AoI problem. Several special cases of the problem are known to be solvable in polynomial time. Our contribution is threefold. First, we introduce a new job scheduling problem called the Min-WCS problem, and we prove that, for any constant ${r} \geq 1$ , every r -approximation algorithm for the Min-WCS problem can be transformed into an r -approximation algorithm for the Min-AoI problem. Second, we give a randomized 2.619-approximation algorithm, a randomized 3-approximation algorithm, which outperforms the previous one in certain scenarios, and a dynamic-programming-based exact algorithm for the Min-WCS problem. Finally, we prove that the Min-AoI problem is NP-hard.
Article
This paper addresses minimizing Tardy/Lost penalties with common due dates on a single machine. According to this penalty criterion, if tardiness of a job exceeds a predefined value, the job will be lost and penalized by a fixed value. The problem is formulated as an integer programming model, and a heuristic algorithm is constructed. Then, using the proposed dominance rules and lower bounds, we develop two dynamic programming algorithms as well as a branch and bound. Experimental results show that the heuristic algorithm has an average optimality gap less than 2 % in all problem sizes. Instances up to 250 jobs with low variety of process times are optimally solved and for high process time varieties, the algorithms solved all instances up to 75 jobs.
Article
Full-text available
This paper presents a new heuristic method for solving multi-mode resource constrained project scheduling problems with renewable resources. Assumptions such as resource vacation and activity splitting are also considered. The proposed heuristic determines one mode for the execution of each activity first, so that the multi-mode problem is reduced to a single-mode one. Our method is compared to two of the existing methods in terms of computational time and solution quality. The results show that while it can outperform one of them (especially as the size of the problem grows), it is outperformed by the other for tested instances with low complexity, but can yield good results for tested instances with higher values of this parameters. This quality may be useful in real-world scheduling problems. We also validate the first phase of our method, i.e., mode selection, with numerical experiments. Our results indicate that better mode vectors selected in the first phase lead to better makespans for the MRCPSP. Moreover, we correct some erroneous constraints in the mathematical model of the problem. We implement the mathematical programming model of the problem in GAMS, and show that solving it to optimality requires much more computational effort compared to our method.
Article
Full-text available
We consider the following single-machine scheduling problem, which is often denoted $1||\sum f_{j}$: we are given $n$ jobs to be scheduled on a single machine, where each job $j$ has an integral processing time $p_j$, and there is a nondecreasing, nonnegative cost function $f_j(C_{j})$ that specifies the cost of finishing $j$ at time $C_{j}$; the objective is to minimize $\sum_{j=1}^n f_j(C_j)$. Bansal \& Pruhs recently gave the first constant approximation algorithm with a performance guarantee of 16. We improve on this result by giving a primal-dual pseudo-polynomial-time algorithm based on the recently introduced knapsack-cover inequalities. The algorithm finds a schedule of cost at most four times the constructed dual solution. Although we show that this bound is tight for our algorithm, we leave open the question of whether the integrality gap of the LP is less than 4. Finally, we show how the technique can be adapted to yield, for any $\epsilon >0$, a $(4+\epsilon )$-approximation algorithm for this problem.
Article
Full-text available
In this article we study the amortized efficiency of the “move-to-front” and similar rules for dynamically maintaining a linear list. Under the assumption that accessing the ith element from the front of the list takes &thgr;(i) time, we show that move-to-front is within a constant factor of optimum among a wide class of list maintenance rules. Other natural heuristics, such as the transpose and frequency count rules, do not share this property. We generalize our results to show that move-to-front is within a constant factor of optimum as long as the access cost is a convex function. We also study paging, a setting in which the access cost is not convex. The paging rule corresponding to move-to-front is the “least recently used” (LRU) replacement rule. We analyze the amortized complexity of LRU, showing that its efficiency differs from that of the off-line paging rule (Belady's MIN algorithm) by a factor that depends on the size of fast memory. No on-line paging algorithm has better amortized performance.
Chapter
Full-text available
In this chapter, we summarize research efforts on several different problems that fall under the rubric of online scheduling. In online scheduling, the scheduler receives jobs that arrive over time, and generally must schedule the jobs without any knowledge of the future. The lack of knowledge of the future generally precludes the scheduler from guaranteeing optimal schedules. Thus much research has been focused on finding scheduling algorithms that guarantee schedules that are in some way not too far from optimal. We focus on problems that arise within the ubiquitous client-server setting. In a client-server system, there are many clients and one server (or a perhaps a few servers). Clients submit requests for service to the server(s) over time. In the language of scheduling, a server is a processor, and a request is a job. Applications that motivate the research we survey include multiuser operating systems such as Unix and Windows, web servers, database servers, name servers, and load...
Article
This article discusses the scheduling problem of minimizing the weighted sum of quadratic completion times on a single machine. It establishes links between orderings of adjacent and nonadjacent jobs that lead to a powerful branch and bound method. Computational results show that this method clearly outperforms the state of the art algorithm. © 1995 John Wiley & Sons. Inc.
Article