Content uploaded by Rodrigo A. Carrasco
Author content
All content in this area was uploaded by Rodrigo A. Carrasco on Mar 13, 2018
Content may be subject to copyright.
Resource Cost Aware Scheduling
Rodrigo A. Carrasco∗
Faculty of Engineering and Sciences, Universidad Adolfo Ib´a˜nez, Santiago, Chile
Garud Iyengar, Cliff Stein
Department of Industrial Engineering & Operations Research, Columbia University, New York, NY 10027
Abstract
We are interested in the scheduling problem where there are several different resources that deter-
mine the speed at which a job runs and we pay depending on the amount of each resource that
we use. This work is an extension of the resource dependent job processing time problem and the
energy aware scheduling problems. We develop a new constant factor approximation algorithm for
resource cost aware scheduling problems: the objective is to minimize the sum of the total cost
of resources and the total weighted completion time in the one machine non-preemptive setting,
allowing for arbitrary precedence constraints and release dates. Our algorithm handles general job-
dependent resource cost functions. We also analyze the practical performance of our algorithms,
showing that it is significantly superior to the theoretical bounds and in fact it is very close to
optimal. The analysis is done using simulations and real instances, which are left publicly avail-
able for future benchmarks. We also present additional heuristic improvements and we study their
performance in other settings.
Keywords: Scheduling; Approximation Algorithms; Resource Aware Scheduling; Speed-Scaling
1. Introduction
Managing non-renewable resource consumption is fast emerging as a problem of critical impor-
tance. There is always a trade-off between resource consumption and performance: more resource
consumption typically results in better performance, but at a higher cost. This trade-off also arises
in many scheduling problems, where resource management decisions must be combined with the
scheduling decisions to optimize a global objective.
Recently, scheduling problems in which one has to trade scheduling performance with metrics
such as completion time or flow time, with CPU processing speed, and therefore the energy con-
sumed, have been extensively studied. However, the problem of balancing resource consumption
with scheduling performance was proposed much earlier. Vickson [57] observed that in many prac-
tical settings, the processing time of a job depends on the amount of resources (e.g. catalizer,
workforce size, energy, etc.) utilized, and the relationship between resource utilization and pro-
∗Corresponding author
Email addresses: rax@uai.cl (Rodrigo A. Carrasco), garud@ieor.columbia.edu (Garud Iyengar),
cliff@ieor.columbia.edu (Cliff Stein)
Final version available at https://doi.org/10.1016/j.ejor.2018.02.059
c
2018. This manuscript version is made available under the CC-BY-NC-ND 4.0 license http://
creativecommons.org/licenses/by-nc-nd/4.0/
Preprint submitted to European Journal of Operational Research, v.6.7 (180313084144) Tuesday 13th March, 2018
cessing time depends on each job’s characteristics. Other examples of scheduling problems with
resource dependent job processing times include repair and maintenance processes [26]; ingot pre-
heating processes in steel mills, where the batches need to be scheduled and the amount of gas used
and the concentration level determine the time required to preheat the ingots [38,59]; many work-
force intensive operations; VLSI circuit design [44]; project scheduling with resource constraints in
mining operations [35,46], and more recently processing tasks in a CPU, where the job processing
times depends on CPU speed, the available RAM, bus speed, as well as other system resources [2].
Although the CPU setting has mostly been studied as an online problem, due to its importance in
cloud computing online services, it is also very relevant in the offline setting. Scientific computa-
tion and simulations like the ones required in astronomical studies [43,45,55] or recurrent batch
processes that are scheduled to run at specific intervals all run in an offline setting, where users
know or at least have a good estimation of their processing times.
1.1. Previous work
The literature on resource dependent job processing time problems has mainly focused on two
models. In the first model the processing time piof job iis piece-wise linear function of the resource
consumption level ui, of the form pi(ui) = min{pi, bi−aiui}, where ai, biare job parameters and
piis the smallest possible processing time [21,20,23,24,37,39,56,60]. In more recent work,
the processing time as a function of the resource consumption level is assumed to be a decreasing,
convex function of the form pi(ui) = (ρi/ui)kfor some ρ > 0 and k > 0 [41,51,53,58]. The
primary justification for this model is that it captures the decreasing marginal improvements that
are observed in practical applications [51].
The trade-off between resource consumption and performance is modeled in several different
ways. In [21,20,23,24,41,53,56] the authors consider a bicriteria approach where the objective is
to reduce resource consumption, and simultaneously optimize the scheduling metric. On the other
hand, [37,39,51,58,60] optimize the scheduling performance for a given bound on the available
resource or vice versa. A survey with different approaches to these problems can be found in [52].
Energy aware scheduling of computing tasks is an important example of resource aware schedul-
ing problems, and has received much attention recently [2,4,6,7,8,12,19,36,40,42,62]. Data
centers use a large amount of energy. For example, the main search engines in the U.S. consume
more than 6,000 times the energy consumed by an average U.S. households [22,25,30]. CPUs
account for 50-60% of a typical computer’s energy consumption [1]; consequently, CPU energy
management is especially important for laptops and other mobile devices. It is clear that when
scheduling computing tasks, it is important to take both the relevant scheduling quality of service
(QoS) metrics such as makespan, weighted completion time or weighted flow time, and the energy
consumption into account. Modern CPUs can run at multiple speeds; the lower the speed, the less
energy used, and the relationship is device-dependent but typically superlinear. Thus, the energy
consumed can be controlled by speed scaling.
In the literature the power Pconsumed is a polynomial function of speed sof the form P(s) = sβ
for some constant β∈[2,3]. Recent work uses a more general power function with minimum
regularity conditions, like non-negativity, but in all the cases the power function is not job-dependent
since the jobs are homogeneous [5,9]. Our approach allows job-dependent power functions, and
thus can be applied to a more general class of problems outside this specific setting. Furthermore,
most energy aware algorithms assume cost functions that are closely related to energy consumption;
however in practice, the actual energy cost is not simply a function of energy consumption, it is a
complicated function of discounts, pricing, time of consumption, etc. That observation motivated
our consideration of a more general class of cost functions that are only restricted to be non-negative.
We are not aware of any other work that allows such general costs.
2
There are three main settings for energy aware scheduling problems: optimizing a QoS metric
with an energy budget [49,50], minimizing energy subject to a QoS constraint [7,10,11,61], or
optimizing some combination of a scheduling objective and energy consumption [3,5,9,13]. Our
work is in the third setting. Implicit in the last criterion is the assumption that both energy (or
any resource for that matter) and time can be (implicitly) converted into a common unit, such as
dollars. The prior work on speed scaling algorithms assumes that the energy cost is only a function
of the speed. We allow for the cost to be dependent on all the resources being utilized. For example,
in the context of scheduling computational task, we can allow for the cost to be dependent on the
CPU speed, the RAM utilized, and bus bandwidth, and we need to know the relation between
these factors and the speed at which we can process jobs.
In this paper we consider the commonly studied scheduling metric, weighted completion time.
This metric has not received attention in the resource or energy cost aware scheduling literature,
even though it has applications in several different areas such as software compilers, instruction
scheduling in VLIW processors, MapReduce-like systems, manufacturing processes, and mainte-
nance procedures among others [16,17,18,48]. In all these applications there are related resources
that can be used to control the speed at which jobs are processed, which should be taken into ac-
count. For example, in maintenance and repair procedures, the processing time of a job can depend
on the workforce size, spare parts inventory levels, energy consumption, training, etc. Furthermore,
in many settings jobs have precedence constraints as well, something that has not been dealt with
in the current literature.
Given a schedule in which job iwith weight wiand release time riis completed at time Ci,
the total weighted completion time is given by PiwiCi. We consider the non-preemptive, offline
problem on one machine, and allow arbitrary precedence constraints and arbitrary release dates
as well. Our objective is to minimize the sum of our scheduling metric and the total resource
consumption cost. We are not aware of any previous work on resource cost aware scheduling or
energy aware scheduling algorithms for this metric, although there is a rich literature on minimizing
weighted completion time in the absence of energy concerns (e.g. [47,48,54]).
Minimizing weighted completion time is well studied in the combinatorial scheduling literature.
Phillips et al. [47] and Hall et al. [33,34] introduced the concept of α-points that has lead to
small constant factor approximation algorithms for many scheduling problems [54]. In the α-point
approach, the scheduling problem is formulated as an integer program in terms of decision variables
xit that is 1 if job icompletes at time t. The α-point of each job is defined as the earliest time at
which an αfraction of the job has completed in the linear relaxation. The jobs are ordered in the
order of their α-points and run in non-preemptive fashion. There are many variants and extensions
of this technique, including choosing αrandomly [18,28] or choosing a different αfor each job
[29]. We extend α-point technique by defining α-speeds that are achieved by time-sharing between
resource operating points.
1.2. Our results
We make several contributions to the problem of scheduling with non-renewable resources:
•We introduce a model that extends the previous cost models (linear, convex, and other
energy models) by allowing a more general relation between job processing time (or equivalent
processing speed) and resource consumption.
•We further generalize the problem by allowing arbitrary precedence constraints and release
dates.
•We give approximation algorithms for minimizing an objective that is a combination of a
scheduling metric (weighted completion time) and resource consumption cost.
3
•We introduce the concept of α-speeds, which extend the α-points technique to problems with
multiple speeds.
•We show that these algorithms have small constant approximation ratios and also demonstrate
the effectiveness of the algorithms via experiential results.
Cost Model. We consider a more general model of resource cost than has previously been used.
As noted previously the resource dependent job processing time literature either focuses on job’s
processing times that depend linearly on resource consumption or a convex relation of the form
(ρi/ui)k, generally considering only a single resource. Our setting captures both of these models by
considering an arbitrary non-negative speed function S(Ψ(i)), where Ψ(i)∈Ψ={Ψ(1),...,Ψ(q)}
denotes one of the qallowable operating points of the resources. We also generalize the resource cost,
which is generally linear in the literature, by considering an arbitrary non-negative job-dependent
resource cost function Ri(Ψ(i)).
Main Result. Our paper contains results for two related scheduling problems, we state here
the most general result:
Theorem 1.1. Given njobs with precedence constraints and release dates and a general non-
negative resource cost function, there is an O(1)-approximation algorithm for the problem of non-
preemptively minimizing a weighted sum of the completion time and resource cost.
The constants in the O(1) are modest. Given some > 0, the algorithm has a (4 + )-
approximation ratio when only precedence constraints exist, and (3 + 2√2 + )-approximation
ratio when release dates are added. Through simulations and real instances, we also show that the
bounds are much better in practice. It is important to note that we assume that job processing
times are known in advance (in the offline setting) or when the job arrives (in the online setting),
and that the relationship between the resource consumption and the processing speed is also known
beforehand.
1.3. Our methodology
In this paper, we extend an interval-indexed IP to handle resource costs and speed scaling, and
then design a new α-point based rounding algorithm to obtain the resulting schedules. In doing so
we introduce the new concept of α-speeds. We assume in Sections 2and 3that we have a discrete
set of qallowable resource operating points Ψ={Ψ(1),...,Ψ(q)}, and that the speed at which
the job is processed is a general non-negative function of the resource operating point. Although
the time-indexed IP is used in the experimental results, we will describe only the interval-indexed
linear programs in this paper. In our interval-indexed IP, a variable xijt is 1 if job iruns at resource
operating point Ψ(j)and completes in interval t. We can then extend the standard interval-indexed
integer programming formulation to take the extra dimensions of resource consumption and speed
into account (see Section 2for details). Once we have solved its linear program relaxation (LPi),
we need to determine both an α-point and α-speed. The key insight is that by “summarizing” each
dimension appropriately, we are able to make the correct choice for the other dimension. At a high
level, we first choose the α-point by “collapsing” all pieces of a job that completes in the LPi in
interval t(these pieces have different speeds), being especially careful with the last interval, where
we may have to choose only some of the speeds. We then use only the pieces of the job that complete
before the α-point to choose the speed, where the speed is chosen by collapsing the time dimension
and then interpreting the result as a probability mass function (pmf), where the probability that
the job is run at speed S(Ψ(j)) depends on the total amount of processing done at that operating
point. We then define the concept of α-speeds, which is related to the expected value under this
pmf, and run the job at this speed (see Section 3for more details). We combine this new rounding
4
method with extensions of the more traditional methods for dealing with precedence constraints
and release dates to obtain our algorithm.
After presenting our algorithm and approximation analysis, in Section 4we further study the
energy aware setting, where the only operating point decision is energy consumption and thus
speed (i.e. S(s) = s) and the relationship between speed and power consumption is of the form
Ei(si) = viρisβ−1
i, for some vi>0 and β > 2, with ρidenoting the machine cycles (i.e. CPU
operations) required by job i.
Finally, in Section 5we study our algorithm empirically through simulations and real-life in-
stances, showing that it performs very close to optimal. Furthermore, we also study a heuristic
improvement that results in even better performance. We also study the performance of our al-
gorithm in additional settings like on-line scheduling, where each job’s arrival time is not known
beforehand.
2. Problem formulation
In this section, we formally define our problem and also give an interval-indexed linear pro-
gramming relaxation.
2.1. Problem setting
We are given a single machine that requires pdifferent resources, indexed 1, . . . , p to run. As
mentioned in the previous section, examples of these resources include energy, fuel, maintenance
level, wear rate, reaction catalizer, and workforce size. The machine has qdifferent resource oper-
ating points Ψ(j)∈Ψ={Ψ(1),...,Ψ(q)}, where Ψ(j)=hΨ(j)
1. . . Ψ(j)
piis described by a vector
of pvalues, one for each resource. We are also given a function S:Rp→R+which maps each
operating point Ψ(j)to a speed σj=S(Ψ(j)), and a function Ri(Ψ(j)), with R:Rp→R+, which
denotes the cost of running job iat the resource operating point Ψ(j). Additionally, we are given
njobs, where job ihas a processing requirement of ρimachine cycles, a release time ri, and an
associated positive weight wi. We may also be given precedence constraints among the jobs but we
do not allow preemption.
Aschedule defines, for each job, a time interval during which it runs, and a resource operating
point from the allowable set to be used within the interval. As in previous work, we can make
some observations that simplify the structure of a schedule. By time sharing between different
operating points the machine can run at any point within the convex hull of Ψ. We thus extend
the domain of the speed function and the cost function to include points ψin the convex hull of Ψ
in the natural way: for ψ(i)such that ψ(i)=Pq
j=1 λjΨ(j), with Pjλj= 1 and λj∈[0,1], then if
ψ=PjδjΨ(j), then S(ψ) = PjδjS(Ψ(j)) and Ri(ψ(i)) = Pq
j=1 λjRi(Ψ(j)). Thus, by extending
our domain in this way, we can assume that each job runs at one resource operating point, and
one speed. We can further assume that a point with lower speed also has lower cost, for otherwise
we could achieve that point by running at a higher speed and then idling, thereby achieving an
even better cost. Throughout the paper, we will use capital Ψ to denote the input set of operating
points and lowercase ψto denote points in the convex hull.
With the above extension, we can define a schedule precisely as follows. Let ψ(i)denote the
operating point at which job iruns, thus si=S(ψ(i)) denotes the speed at which job iruns in the
machine, and pi=ρi
S(ψ(i)), its processing time. Let Cidenote the completion time of job i, and let
Π = {π(1), . . . , π(n)}denote the order in which the jobs are processed, i.e. π(k) = iimplies that
job iis the k-th job to be processed. Then Cπ(i)= max{rπ(i), Cπ(i−1)}+ρπ(i)
sπ(i)is the completion
time of the i-th job to be processed, with Cπ(0) = 0.
The objective is to compute a feasible schedule (Π,C), consisting of an order Π and completion
5
times C, possibly subject to precedence and/or release date constraints, and the vector of resource
requirements that ψ=ψ(1) . . . ψ(n)minimizes the total cost,
f(Π,C,ψ) =
n
X
i=1 hRi(ψ(i)) + wπ(i)Cπ(i)i.(1)
For convenience we will use an extended version of the notation of Graham et al. [31] to refer
to our different resource cost aware scheduling problems, i.e. 1|ri, prec|PRi(ψ(i)) + wiCi, will
refer to the problem setting with 1 machine, with rirelease dates, precedence constraints, and the
weighted completion time as the scheduling performance metric. The Ri(ψ(i)) term indicates that
the resource cost is also added as a performance metric.
We assume, w.l.o.g., that the resource operating points are ordered by speed (slowest first),
and use σi=S(Ψ(i)) to denote the ith slowest speed. Note that since any speed used is a convex
combination of these σi’s, we will never consider any speed slower than σ1or faster than σq(which
we denote by σmax). We also assume that the resources are given explicitly as part of the input.
2.2. Interval-indexed formulation
Unlike a time-indexed formulation, which divides the time horizon into regular time-steps, the
interval-indexed formulation divides the time horizon into geometrically increasing intervals. In
this formulation the completion time of each job is assigned to one of these intervals. Since the
completion times are not associated to a specific time, the completion times are not precisely known
but can be lower bounded by the begging of the interval. By controlling the growth of each interval
one can obtain a sufficiently tight bound.
The problem formulation is as follows. We divide the time horizon into the following geometri-
cally increasing intervals: [κ, κ], (κ, (1 + )κ], ((1 + )κ, (1 + )2κ], . . ., where > 0 is an arbitrary
small constant, and κ=ρmin
σmax denotes the smallest interval size that will hold at least one whole job.
We define interval It= (τt−1, τt], with τ0=κand τt=κ(1 + )t−1. The interval index ranges over
{1, . . . , T }, with T= min{dte:κ(1 + )t−1≥maxn
i=1 ri+Pn
i=1
ρi
σ1}; and thus, we have a polynomial
number of indices t. Note that since we can only compute a lower bound on the completion times
of jobs finished in an interval, we may induce an error when comparing the optimal value to the
real completion time, but this error can be at most by a factor of (1 + ).
Let
xijt =1,if job iruns at o.p. Ψ(j)and completes in time interval It
0,otherwise (2)
By using the lower bounds τt−1of each time interval It, a lower bound to (1) is written as,
min
x
n
X
i=1
q
X
j=1
T
X
t=1 Ri(Ψ(j)) + wiτt−1xijt .(3)
The following are the constraints required for the 1|ri, prec|PRi(ψ(i)) + wiCiproblem:
1. Each job must finish in a unique time interval and speed; therefore for i={1, . . . , n}:
q
X
j=1
T
X
t=1
xijt = 1 .(4)
2. Since only one job can be processed at any given time, the total processing time of jobs up
to time interval Itmust be at most τtunits. Thus, for t={1, . . . , T }:
n
X
i=1
q
X
j=1
t
X
u=1
ρi
σj
xiju ≤τt.(5)
6
3. Job irunning at speed σjrequires ρi
σjtime units to be processed, and considering that its
release time is ri, then for i={1, . . . , n},j={1, . . . , q}, and t={1, . . . , T }:
xijt = 0,if τt< ri+ρi
σj
.(6)
4. For i={1, . . . , n},j={1, . . . , q}and t={1, . . . , T }:
xijt ∈ {0,1}.(7)
5. The precedence constraint i1≺i2implies that job i2cannot finish in an interval earlier than
i1. Therefore for every i1≺i2constraint we have that for t={1, . . . , T }:
q
X
j=1
t
X
u=1
xi1ju ≥
q
X
j=1
t
X
u=1
xi2ju .(8)
It is important to note that this integer program only provides a lower bound for (1); in fact
its optimal solution may not be schedulable, since constraints (5) do not imply that only one job
can be processed at a single time, they only bound the total amount of work in ∪tIt.
3. Approximation algorithm for weighted completion time
We now describe the approximation algorithm for the weighted completion time, called Sched-
ule by α-intervals and α-speeds (SAIAS) which is displayed in Figure 1.
Let ¯xijt denote the optimal solution of the linear relaxation of the integer program (3)-(8), in
which we change constraints (7) for xijt ≥0. In step 2of the algorithm we compute the optimal
solution ¯x and in step 3, given 0 ≤α≤1, we compute the α-interval τα
iof job i, defined as
τα
i= min
τ:
q
X
j=1
τ
X
u=1
¯xiju ≥α
.(9)
Since several jobs may have the same α-interval, let Jtdenote the set of jobs that have Itas its
α-interval, Jt={i:τα
i=t}, and we use these sets to determine the order Παas described in step
4. The order within a set Jtcan be efficiently done using topological sorting of the corresponding
jobs.
Schedule by α-intervals and α-speeds (SAIAS)
Inputs: set of jobs, α∈(0,1), > 0, set of resource operating points Ψ,
speed function Sand resource function R
1 Compute the set of speeds S={σ1, . . . , σq}.
2 Compute an optimal solution ¯x to the linear relaxation (3)-(8).
3 Compute the α-intervals ταand the sets Jtvia (9)
4 Compute an order Παthat has sets Jtordered in non-decreasing values of tand
the jobs within each set in a manner consistent with the precedence constraints.
5 Compute the α-speeds sαvia (12).
6 Set the i-th job to start at time max{rπ(i), C α
π(i−1)}, where Cα
π(i−1) is the
completion time of the previous job using the rounded α-speeds, and Cα
π(0) = 0.
7return speeds sαand schedule (Πα,¯
Cα).
Figure 1: Schedule by α-intervals and α-speeds
7
Next, in step 5, we compute the α-speeds as follows. Since Pq
j=1 Pτα
i
u=1 ¯xiju ≥α, we define the
auxiliary variables {˜xijt}as:
˜xijt =
¯xijt , t < τα
i
max nmin n¯xijτ α
i, α −Pj−1
l=1 ¯xilτ α
i−βio,0o, t =τα
i
0, t > τα
i
,(10)
where βi=Pq
j=1 Pτα
i−1
u=1 ¯xiju < α. Note that for this auxiliary variable, we have that Pq
j=1 Pτα
i
u=1 ˜xiju =
α. This is a key step that allows us to truncate the fractional solution so that for every job i, the sum
of ˜xijt up to time interval τα
ifor each speed jcan be interpreted as a probability mass function. We
define this probability mass function (pmf) µi= (µi
1, . . . , µi
q) on the set of speeds S={σ1, . . . , σq}
as
µi
j=1
α
τα
i
X
u=1
˜xiju .(11)
Let ˆsidefine a random variable distributed according to the pmf µi, i.e. µi
j=P(ˆsi=σj). Then,
the α-speed of job i,sα
i, is defined as follows:
1
sα
i
=E1
ˆsi=
q
X
j=1
µi
j
σj⇒sα
i=1
Eh1
ˆsii.(12)
We define the α-speeds using the reciprocal of the speeds since the completion times are propor-
tional to the reciprocals, and we need to bound completion times in the analysis of the algorithm.
Note that (11) defines the fraction of the machine cycles requirement ρithat must be processed at
each operating point Ψ(j)to achieve the α-speed sα
i.
Finally, in steps 6and 7we compute the completion times given the calculated speeds and
return the set of speeds sαand the schedule (Πα,Cα).
We now analyze this algorithm’s performance both with and without release dates. In the
following subsections we will assume w.l.o.g. that τα
1≤τα
2≤. . . τ α
n.
3.1. Single machine problem with precedence constraints
In this section, we analyze our algorithm for the case of precedence constraints but no release
dates. We first prove that the output of the SAIAS algorithm is indeed feasible.
Lemma 3.1. Suppose i1≺i2. Then (8) implies that τα
i1≤τα
i2.
Proof. Evaluating the LP constraint (8) corresponding to i1≺i2, for t=τα
i2, we have that,
q
X
j=1
τα
i2
X
u=1
xi1ju ≥
q
X
j=1
τα
i2
X
u=1
xi2ju ≥α , (13)
where the last inequality follows from the definition of τα
i2. The chain of inequalities implies that
Pq
j=1 Pτα
i2
u=1 xi1ju ≥α, so τα
i1≤τα
i2.
Since the SAIAS algorithm schedules jobs by first ordering the sets Jtin increasing order of t,
and then orders the jobs within each set in a way that is consistent with the precedence constraints,
Lemma 3.1 implies that the SAIAS algorithm preserves the precedence constraints, and, therefore,
the output of the algorithm is feasible.
8
Theorem 3.1. The SAIAS algorithm with α=1
2is a (4 + )-approximation algorithm for the
1|prec|PRi(ψ(i)) + wiCiproblem, with a general non-negative Ri(ψ)resource cost function.
Proof. Let OP T denote the optimal value of the instance of the 1|prec|PRi(ψ(i))+ wiCiproblem.
Let ¯xijt denote the fractional solution of the linear relaxation of problem (3)-(8), and ˜xij u the
auxiliary variables calculated for the SAIAS algorithm.
Since in (3) the completion time assigned to jobs completed in interval Itis τt−1, it follows that,
n
X
i=1
q
X
j=1
T
X
t=1 Ri(Ψ(j)) + wiτt−1¯xijt ≤O P T . (14)
Let ψ(i)α=Pq
j=1 µi
jΨ(j)denote the effective operating point that achieves the required α-
speed, and ˆ
ψ(i)define a random variable distributed according to the pmf µi, just like with ˆsi. The
resource cost terms of the algorithm’s solution are bounded as follows,
Ri(ψ(i)α) = Ri(Ehˆ
ψ(i)i)≤EhRi(ˆ
ψ(i))i=
q
X
j=1
µi
jRi(Ψ(j)),(15)
where the inequality follows from Jensen’s Inequality applied to the convex function Ri(). Using
the definition of µi
jin (11) and given that 0 ≤α≤1, > 0, and ˜xijt ≤¯xij t, it follows that,
Ri(ψ(i)α)≤1
α
q
X
j=1
τα
i
X
u=1 Ri(Ψ(j))˜xij u ≤(1 + )
α(1 −α)
q
X
j=1
T
X
u=1 Ri(Ψ(j))¯xij u .(16)
Since there are no release date constraints there is no idle time between jobs and thus,
Cα
i=
i
X
j=1
ρj
sα
j
=
i
X
j=1
ρjE1
ˆsj=1
α
i
X
j=1
q
X
l=1
τα
j
X
u=1
ρj
σl
˜xjlu ≤1
α
n
X
j=1
q
X
l=1
τα
i
X
u=1
ρj
σl
¯xjlu ,(17)
and from constraint (5) for t=τα
iwe get, Cα
i≤1
αττα
i.
Let ¯
Ci=Pq
j=1 PT
t=1 τt−1¯xijt denote the optimal fractional completion time given by the optimal
solution of the relaxed linear program (3)-(6). Since it is possible that Pq
j=1 Pτα
i
t=1 ¯xijt > α; we
define X(1)
i=α−Pq
j=1 Pτα
i−1
t=1 ¯xijt and X(2)
i=Pq
j=1 Pτα
i
t=1 ¯xijt −α, thus X(1)
i+X(2)
i=Pq
j=1 ¯xijτ α
i,
and we can rewrite
¯
Ci=
q
X
j=1
τα
i−1
X
t=1
τt−1¯xijt +ττα
i−1X(1)
i+ττα
i−1X(2)
i+
q
X
j=1
T
X
t=τα
i+1
τt−1¯xijt ,(18)
and eliminating the lower terms of the previous sum we get that,
¯
Ci≥ττα
i−1X(2)
i+
q
X
j=1
T
X
t=τα
i+1
τt−1¯xijt
≥ττα
i−1X(2)
i+
q
X
j=1
T
X
t=τα
i+1
ττα
i−1¯xijt =ττα
i−1(1 −α).(19)
9
Because ττα
i= (1+)ττα
i−1, from (17) and (19) we get that Cα
i≤(1+)
α(1−α)¯
Ci, and thus Pn
i=1 wiCα
i≤
(1+)
α(1−α)Pn
i=1 wi¯
Ci. From this, (14), and (16) it follows that,
n
X
i=1 Ri(ψ(i)α) +
n
X
i=1
wiCα
i≤(1 + )
α(1 −α)OP T , (20)
and we set α= arg min0≤α≤1n1
α(1−α)o=1
2, to minimize the bound, and get the desired approxi-
mation ratio.
3.2. Single machine problem with precedence and release date constraints
We now analyze the case with precedence constraints and release dates. Release dates makes
the problem somewhat harder since they can introduce idle times between jobs.
Theorem 3.2. The SAIAS algorithm with α=√2−1is a (3+2√2+)-approximation algorithm for
the 1|ri, prec|PRi(ψ(i))+ wiCiproblem, with a general non-negative Ri(ψ)resource cost function.
Proof. The bounds for the resource cost terms computed in equation (15) are still valid when there
is idle time between jobs, and we have that,
Ri(ψ(i)α)≤(1 + )
α(1 −α)
q
X
j=1
T
X
u=1 Ri(Ψ(j))¯xij u ≤(1 + )(1 + α)
α(1 −α)
q
X
j=1
T
X
u=1 Ri(Ψ(j))¯xij u .(21)
When bounding the completion time Cα
i, given the sorting done in step 4of the SAIAS algo-
rithm, now one has to consider all the jobs up to the ones in set Jτα
i, and thus,
Cα
i≤max
j∈{J1,...,Jτα
i}rj+X
j∈{J1,...,Jτα
i}
ρj
sα
j
.(22)
Since all jobs that have been at least partially processed up to time interval Itneed to be
released before τt, it follows that maxj∈{J1,...,Jτα
i}rj≤ττα
i. On the other hand, we also have that,
X
j∈{J1,...,Jτα
i}
ρj
sα
j
=1
αX
j∈{J1,...,Jτα
i}
q
X
l=1
τα
j
X
u=1
ρj
σl
˜xjlu ≤1
α
n
X
j=1
q
X
l=1
τα
i
X
u=1
ρj
σl
¯xjlu ≤1
αττα
i,(23)
where the last inequality follows from constraint (5) with t=τα
i. Thus, Cα
i≤(1+α)
αττα
i. Since
¯
Ci=Pq
j=1 PT
t=1 τt−1¯xijt , (19) is still valid and because ττα
i= (1 + )ττα
i−1, we get,
Cα
i≤(1 + )(1 + α)
α(1 −α)¯
Ci⇒
n
X
i=1
wiCα
i≤(1 + )(1 + α)
α(1 −α)
n
X
i=1
wi¯
Ci.(24)
Finally, from (15), (21), and (24), it follows that,
n
X
i=1 Ri(ψ(i)α) +
n
X
i=1
wiCα
i≤(1 + )(1 + α)
α(1 −α)OP T , (25)
and by setting α= arg min0≤α≤1n(1+α)
α(1−α)o=√2−1, we get the required approximation ratio.
10
4. Special cases for polynomial energy cost functions
As indicated before, the special case where the only resource is energy consumption has received
special attention. In this setting the operating point is defined by the speed at which the machine
runs and in general the energy cost of job irunning at speed siis of the form Ri(ψ(i)) = Ei(si) =
viρisβ−1
i, where vi>0 and β > 2 are constants. Clearly, all the results in Section 3apply to this
setting as well.
4.1. Heuristic improvement when the schedule order is given
A natural improvement one could consider for the SAIAS algorithm is to recalculate the optimal
resource operating point once the order is defined by the SAIAS algorithm. Without loss of gener-
ality, we assume that the schedule order computed by the SAIAS algorithm is Πα={1,2, . . . , n}.
The following result establishes that we can compute the optimal resource operating point for each
job (i.e. its processing speed), for any given order, in closed form [15].
Lemma 4.1. Given the schedule order Πα, the optimal speed at which to run job iis given by
s∗
i=β
sPn
j=iPi
k=1 λ∗
jk
(β−1)vi
,∀i∈ {1, . . . , n},(26)
where λ∗
jk is the optimal solution of the following optimization problem:
max
λ
n
X
i=1
i
X
j=1
λij rj+
n
X
i=1 Bρiv
1
β
i
n
X
j=i
i
X
k=1
λjk
b
s.t.: Pi
j=1 λij =wi,∀i,
λij ≥0,∀j∈ {1, . . . , i},∀i,
,(27)
with b=β−1
β, and B ≡ β
(β−1)b.
Proof. Given the order Πα={1,2, . . . , n}the optimal speeds are given by the solution of the
following optimization problem:
min
s
n
X
i=1
viρisβ−1
i+wiCi
s.t.: Ci≥rj+Pi
k=j
ρk
sk,∀j∈ {1, . . . , i},∀i,
si≥0,∀i.
(28)
The Lagrangian for (28) is given by
L(s,λ) =
n
X
i=1
viρisβ−1
i+wiCi−
n
X
i=1
i
X
j=1
λij
Ci−rj−
i
X
k=j
ρk
sk
,(29)
where λij ,j={1, . . . , i}denotes the dual variables of the release date constraints in (28) for
the i-th job. From the necessary conditions for optimality it follows that Pi
j=1 λ∗
ij =wi, for all
i∈ {1, . . . , n}, and that the optimal speed for job iis given by (26), where s∗and λ∗are the
optimal speeds and optimal dual variables respectively.
Using (29) it is also easy to show that (27) is the dual problem of (28). Since λ∗is its optimal
solution, it follows that (26) will give the optimal speeds.
11
Note from (26) that the optimal speed of the i-th job only depends of the dual variables of the
completion time constraints of future jobs, and not past ones.
Corollary 4.1. If ri= 0,∀i, then the optimal speed of job iis given by
s∗
i=β
sPn
j=iwj
(β−1)vi
,∀i∈ {1, . . . , n}.(30)
Proof. By setting ri= 0, ∀iin (27) we note that the maximum value of this modified optimization
problem is achieved when λi1=wi, and thus λij = 0, for j={2, . . . , i}. The proof follows by using
these values of λin (26).
This result is an extension of the speed rule used in most of the energy aware scheduling
literature for the flow time metric [4,5]. The main result here is that using SRPT as ordering rule
and a speed of s=β
qnt
(β−1)v, where ntis the number of jobs available at time t, achieves good
competitive ratios. Since [4,5] consider the total flow time (i.e. wi= 1, ∀i) and the same energy
cost function for all jobs (i.e. vi=v,∀i) the optimal speed s=β
qnt
(β−1)vis identical to the one
given in (30).
Using Lemma 4.1 and Corollary 4.1 one can design an algorithm that computes the optimal
speeds for a given order Π in O(n) time, when there are no release dates, and in O(n2) time, when
there are release dates.
4.2. Cases solvable in polynomial time
When no precedence constraints and release dates exist, there are two versions of this problem
that can be optimally solved in polynomial time: when all weights wiare equal, and when all jobs
are of the same size (i.e. ρi=ρ,∀i) and have the same energy cost function. For these cases we
have the following result:
Theorem 4.1. If wi=w, ∀ior ρiv
1
β
i=ξ, ∀ithen the order Πis optimal if
wπ(i)
ρπ(i)v
1
β
π(i)
≥wπ(i+1)
ρπ(i+1)v
1
β
π(i+1)
,∀i∈ {1, . . . , n −1}.
Proof. Define ξi≡ρiv
1
β
i. Using the dual formulation (27) for the energy aware setting with no
precedence or release date constraints, it follows that the optimization problem of interest is given
by,
min
πG(π) = min
π
n
X
i=1 Bξπ(i)
n
X
j=i
wπ(j)
b
.(31)
First, when wi≡w, Theorem 4.1 implies that in the optimal order ξπ(i+1) ≥ξπ(i). By contra-
diction, let πbe an optimal order such that for some index k,ξπ(k+1) < ξπ(k). For this order the
12
total cost is
G(π) =
n
X
i=1 Bξπ(i)
n
X
j=i
w
b
=
n
X
i=1 Bξπ(i)((n−i+ 1)w)b,
=Bwb
ξπ(k)(n−k+ 1)b+ξπ(k+1)(n−k)b+
n
X
i=1
i6=k,k+1
ξπ(i)(n−i+ 1)b
.
Let πkdefine the order where we switch jobs kand k+ 1 from order π, i.e. πk(k) = π(k+ 1)
and πk(k+ 1) = π(k). Given this order we have that
G(π)−G(πk) = Bwbnξπ(k)(n−k+ 1)b+ξπ(k+1)(n−k)b−ξπ(k+1) (n−k+ 1)b
−ξπ(k)(n−k)bo,
=Bwbn(n−k+ 1)b(ξπ(k)−ξπ(k+1))−(n−k)b(ξπ(k)−ξπ(k+1))o,
=Bwbnξπ(k)−ξπ(k+1)(n−k+ 1)b−(n−k)bo .
By our initial assumption the first term is positive (since ξπ(k+1) < ξπ(k)) and the second one is
always positive, hence G(π)−G(πk)>0 which is a contradiction, since that implies that πkhas a
smaller cost.
When ξi≡ξ, then Theorem 4.1 implies that an order πis optimal then wπ(i)≥wπ(i+1). Let π
be an optimal order such that for some index k,wπ(k)< wπ(k+1). The total cost for this solution is
G(π) =
n
X
i=1 Bξ
n
X
j=i
wπ(i)
b
,
=Bξ
k
X
i=1
n
X
j=i
wπ(i)
b
+
n
X
j=k+1
wπ(i)
b
+
n
X
i=k+2
n
X
j=i
wπ(i)
b
,
=Bξ
k
X
i=1
n
X
j=i
wπ(i)
b
+
wπ(k+1) +
n
X
j=k+2
wπ(i)
b
+
n
X
i=k+2
n
X
j=i
wπ(i)
b
.
Let πkdefine the order where we switch jobs kand k+ 1 from order π. Given this new order
we have
G(π)−G(πk) = Bξ
wπ(k+1) +
n
X
j=k+2
wπ(i)
b
−
wπ(k)+
n
X
j=k+2
wπ(i)
b
>0,
since wπ(k+1) > wπ(k)by our initial assumption, which is a contradiction since this result implies
that order πkhas a lower cost.
13
5. Experimental results
In this section we present an experimental analysis of the performance of the algorithm pro-
posed in this paper. Our experimental setting considers both simulated instances, as well as real
instances from a server cluster. There are very few examples of performance analysis in the resource
aware scheduling literature. A notable exception is [4]. We also present experimental results for
other settings not covered in our theoretical results, such as online scheduling and the heuristic
improvement.
We restrict our problem to the speed-scaling energy-aware scheduling case. Thus, we have q
different operating points, where Ψ(j)=σjand S(σj) = σj. We restrict the speeds to the CPU
setting such that σj+1 = (1 + δ)σjfor some δ > 0. Furthermore, we use the standard polynomial
relationship between speed and energy that appears in most of the literature, as the resource cost
function, i.e. for job ithe resource cost function is Ri(si) = Ei(si) = viρisβ−1
i, where vi>0 is a
job parameter, ρi∈N+is the job size, and β= 3.
For each analysis we simulated a large number of randomly generated instances with the fol-
lowing distributions: vi∼unif{0,...,40},wi∼unif{0,...,20}, and ρi∼unif {1,...,10}. Al-
though the size of the jobs seems small, we also analyzed instances with much larger ones (such as
ρi∼unif{1,...,100}), as well as ρidrawn from bimodal distributions, which are generally hard
for scheduling algorithms, without observing any significant degradation in the performance of our
algorithms. This is because the performance of speed-scaling algorithms depends on the job density,
which in turn depends on the release dates.
Since it is computational inexpensive to test different values of α, once we solve the LP we test
several values of αand use the one with the best result.
We compared the output of our algorithm with the integer solution of the interval-and-speed-
indexed formulation (IPi), its linear relaxation (LPi), and the integer and relaxed solutions of a
time-and-speed-indexed formulation for this problem (IPt and LPt respectively). Although we
do not explicitly give these formulations, we use them in the experiments to help us understand
whether the error comes from the rounding in the algorithm or the interval relaxation in the LP. All
simulations were done in Python 3.5 [27], using Gurobi 7.0 [32] to solve the IP and LP relaxation
of each instance.
Our experimental results show that the SAIAS algorithm, although it has a theoretical approxi-
mation ratio of 3+2√2+≈5.8+for the case with arbitrary precedence constraints and arbitrary
release dates, in practice it performs very close to optimal, with average approximation ratios below
1.16. Furthermore we also show that these results remain stable even when the size of the instances
grow several orders of magnitude. It is important to note that when analyzing large instances,
since the IPt formulation is too large to be solved in a reasonable amount of time, we compared the
algorithm’s output with the LPi solution, and thus the real approximation ratio is likely to be even
Problem Instances Size (n) Average Ratio 99% Worst Ratio
1|ri|PEi(ψ(i)) + wiCi
10,000 7 1.011 1.053 1.149
10,000 100 1.07511.100 1.158
10,000 500 1.07511.082 1.108
Heuristic Improvement 10,000 7 1.001 1.005 1.012
10,000 100 1.001 1.004 1.018
Online 10,000 100 1.39711.496 1.627
Table 1: Experimental Results Summary for Total Weighted Completion Time.
1For large instances ratios were computed comparing with the LPi and not the LPt solution.
14
Figure 2: Approximation Ratio - SAIAS/IPt, n= 7, 10,000 instances
better. The results also show that a modification to the algorithm, where we compute the optimal
speeds given the order computed by the SAIAS algorithm, as discussed in Section 4, reduces the
approximation ratios. This improvement can also be used in the online setting. Table 1shows a
summary of all the results.
In the following subsections we present details of the simulation results. We characterize the dis-
tribution of the approximation or competitive ratios via histograms. We believe that displaying the
entire distribution is important since it gives a more complete understanding of how the algorithm
performs as compared to just reporting an average value or a worst case scenario. In the histograms
we highlight the average value for all simulations and the 95% percentile. For both these measures
we also display the 99% confidence intervals, shown as doted lines around the corresponding value.
Table 1shows a summary of the main experimental results for the 1|ri|PRi(ψ(i)) + wiCiproblem.
5.1. Total weighted completion time – simulated instances
The number of variables and constraints in the IPt formulation grows very fast with the num-
ber of jobs n, making it impractical for large instances. On the other hand, the size of the IPi
formulation can be easily controlled with and thus much larger instances can be simulated. For
small instances we compared the performance of the SAIAS algorithm to the optimal solution of
IPt, as well as the bounds given by the LPi formulation. For large instances we compared the
SAIAS algorithm’s solution to the LPi optimal value.
The simulation settings for the smaller instances were: 10,000 simulation with n= 7 jobs,
Figure 3: Relaxation Error - LPi/IPt, n= 7, 10,000 instances
15
α=√2−1, σ1= 1, δ= 1, q= 3, = 0.1, and ri∼unif [0,0.1Pi
ρi
σ1]. The upper bound of
the probability distribution of the release dates was determined experimentally to show the worst
performance, specially in the on-line settings we present later. The reason is that a smaller upper
bound will be equivalent to have an offline setting, whereas a larger upper bound makes most jobs
to be processed alone eliminating the scheduling problem. Figures 2and 3show the main results
of the simulations.
Figure 2displays a histogram with the empirical approximation ratio of the SAIAS algorithm
is close to optimal with an average of 1.011, and the 95% percentile given by 1.053. For the 10,000
instances, the worst approximation ratio was 1.149.
The histogram in Figure 3displays the difference between the LPi bound and the IPt optimal
solutions. This is important since later we will compare the output of our algorithm to the LPi
solution. The histogram shows that on average the LPi bound is 0.885 times the LPt solution, and
in 95% of the instances it was below 0.924. This means that when we compare the algorithm’s
output to the LPi we need to remember that we are comparing it with a solution that is between
5% to 10% lower than the optimal solution.
Since our experiments show a stable and relatively constant ratio between LPt and LPi, for
larger instances, we compare the performance of the SAIAS algorithm to the LPi bound. Given
that we don’t solve the IPt formulation the simulations can be done over much larger instances.
Figure 4shows the result of n= 500, with 10,000 random instances.
Although we are now comparing the algorithm’s output to the LPi solution, the approximation
ratio remains small. For n= 500 we have an average ratio of 1.075, a worst value of 1.108, and 95%
of the cases below 1.082. The fact that the approximation ratio is not much bigger is important
since for n= 7 the ratio between the LPi and the IPt solution was in average 0.885, hence much
of the error shown in figure 4could be attributed to the relaxation as opposed to the algorithm’s
performance.
5.2. Heuristic improvement and online setting
Given that we have an efficient way of computing the optimal speed values given the order
determined by the SAIAS algorithm, we can use it to improve the final solution. Using the same
parameters as in Section 5.1 we simulated 10,000 randomly generated instances and compared the
empirical approximation ratios for the SAIAS algorithm and the heuristic improvement, SAIAS-H.
Table 1shows the improvement results.
As expected, the heuristic improvement reduces the approximation ratio on average to 1.001,
and in 95% of the instances it improved the ratio below 1.005 with 1.012 being the least worst
Figure 4: Approximation Ratio - SAIAS/LPi, n= 500, 10,000 instances
16
Problem Instances Avr. Ratio 99% Worst Ratio Avr. Time [s]
1|ri, prec|PEi(ψ(i)) + wiCi
rx13 1.062 1.163 1.233 0.112
rx35 1.084 1.213 1.297 0.444
rx109 1.165 1.350 1.549 1.619
rx485 1.155 1.330 1.418 9.652
rx100k 1.354 1.682 1.885 32.069
1|prec|PEi(ψ(i)) + wiCi
rx13 1.037 1.064 1.084 0.134
rx35 1.043 1.068 1.170 0.523
rx109 1.118 1.217 1.249 2.079
rx485 1.095 1.187 1.238 26.294
rx100k 1.230 1.412 1.533 76.669
Table 2: Experimental Results Summary for Total Weighted Completion Time.
achieved. It is also important to note that the fraction of instances in which the heuristic algorithm
computed the optimal solution went up from 0.05% to 0.13%.
Using this heuristic improvement we now study the performance of the SAIAS-H algorithm
in the online setting. In this setting we do not know the information of all the jobs at time
t= 0, but only as they arrive, hence, can’t compute the whole schedule beforehand. The way
we adapt the SAIAS-H algorithm is as follows: we compute the approximate schedule using the
SAIAS-H algorithm every time we finish a job, considering only the jobs present at that time, and
every time a new job arrives, we recompute the speeds using the results of Section 4, but because
preemption is not allowed, we only change the speeds and not the schedule. Table 1shows the
empirical competitive ratios obtained over 10,000 randomly generated instances, with all other
settings as before.
In the online setting, the performance measure is called the competitive ratio, and is the ratio
between the algorithm’s output and the optimal offline solution. As expected, the competitive ratio
is slightly larger than the approximation ratio of the offline case, but still it is very good, with an
average of 1.397, 95% of the instances below 1.496, and a worst case of 1.627 for the large instances.
5.3. Total weighted completion time – real instances
Since the algorithms performed very well in simulated instances, we gathered real-life instances
for the energy aware scheduling problem. For this, we analyzed three years of data of the computing
servers at Universidad Adolfo Ib´a˜nez, building instances with the daily workload that each server
received. These instances consider both release dates and precedence constraints, and are publicly
available in [14] to be used as benchmarks for future algorithms. The different instances were
classified into 5 different groups, according to the number of jobs in each instance. The group rx13
has 125 instances having between 4 and 13 jobs; group rx35 has 109 instances having between 14
and 35 jobs; group rx109 has 112 instances having between 36 and 109 jobs; group rx485 has 123
instances having between 110 and 485 jobs; and group rx100k has 188 instances having between
486 and 84,654 jobs. In all groups there are instances with and without precedence constraints,
and all of them have release dates. Additionally, for each job, a weight was added depending on its
priority, and was scaled to make it comparable to the energy cost considering vi= 1,∀i. Just like
in the previous simulated case, the setting was a machine with q= 3 possible speeds, with δ= 1.
We applied the SAIAS algorithm to all the 657 instances, considering the case with and without
release dates. In the smaller instances (rx13 and rx35), the algorithm’s output was compared to the
IPi solution with = 0.1, for instances in rx109 and rx485 the algorithm’s output was compared
to the IPi solution with = 0.5, and for the largest instances (rx100k) it was compared to the LPi
17
Figure 5: Performance profile for all 657 instances
relaxation, since the integer formulation took too much time or ran out of memory. Table 2shows
a summary of the results for each group of instances, for the cases with and without considering
the release dates. For the instances in rx13 to rx485 an = 0.1 was used, whereas for rx100k was
= 0.5 for instances with less than 30,000 jobs and = 1 for the larger ones.
The resulting approximation ratios, reported in Table 2are quite small, and the increase ob-
served for larger instances it is mainly due to having a worst LPi lower bound because of the
increment in . Reducing for some of the instances did not improve the algorithm’s output
significantly, but increased the lower bound drastically. Hence, it is expected that the real approxi-
mation ratios are much smaller. Adding constraints from the project scheduling literature, such as
early-start and early-finish, further strengthened the LP and improved the lower bounds, without
affecting the algorithm’s output. Furthermore, these constraints reduced the computation times,
since they allow a reduction in the problem variables. The additional lower bounds found when
using these additional constraints were not used to compute the approximation ratios of Table 2.
Together with the benchmark instances available in [14], a detailed document with the best upper
and lower bounds found for each instance, plus the parameters used, is available as part of the data
set for future comparisons.
It is also important to note that all these instances were solved very fast. Figure 5shows the
performance profile of the algorithm, for the case with and without release dates, which ran in a
desktop computer with an Intel third generation i7 CPU and 8 GB in RAM. The profile is done
in a semilog plot in order to show important details: 40.49% of the instances with release dates,
and 37.60% of the ones without are solved in less than 1 second, 85.39% of the ones with release
dates and 78.69% of the ones without in less than 10 seconds, and 96.96% of the instances with
release dates and 92.24% without, in less than a minute. There were only 18 instances with release
dates that required more than a minute to compute a solution. These instances were very large,
with a combination of large and small jobs, and an important number of precedence constraints.
This meant that large LPs were required and thus it took more time to model and solve them.
Implementing decomposition techniques, such as the Bienstock-Zuckerberg algorithm, could reduce
this computation significantly as it is shown in [46].
6. Conclusion
In this work we have introduced a general approximation algorithm for minimizing the sum of
weighted completion times and the total resource cost. We have a model for scheduling jobs with
job-dependent non-renewable resources and we have computed small constant-factor approximation
ratios for the resulting algorithm. We have also tested the performance of the algorithm through
18
simulations and real instances, showing that the SAIAS algorithm’s output is very close to optimum
and computes good solutions very fast. Furthermore, we tested the algorithm in additional settings,
such as on-line and using the total weighted flow time as scheduling metric, showing that the
performance is very good in these settings as well.
We believe that our methodology, which extends the idea of α-points to the resource cost aware
setting by developing the α-speeds concept, should have many more applications. For example,
by adding minor regularity conditions to the resource cost R(Ψ(j)) and speed-scaling the resulting
output, we can use the SAIAS algorithm in the setting where there are no release dates and the
scheduling metric is a convex function of the completion time, like weighted tardiness or completion
time squared. Our methodology assumes that job processing times are known beforehand, since it
is a required parameter for running our algorithms.
We also suspect that, via techniques such as using randomly chosen values of αor using different
αvalues for different jobs, we could obtain tighter bounds, and that these techniques could be
extended to other settings, such as multiple parallel machines among others.
A very interesting open problem is what happens when job processing times are not known
even when a job arrives, but only when a job finishes. This is a common problem in online services,
where the arriving jobs need to be scheduled, but their processing times are unknown, and only
when the job is finished the system knowns the actual processing time. He have not tested our
algorithm in this setting but we believe it is a very relevant and important line of research.
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; Fulbright/Conicyt Chile, Fondecyt Project 1151098, and Conicyt PIA Anillo ACT
1407.
We would also like to thank Professor Eduardo Moreno for the raw server data used for the
experimental analysis.
References
[1] Albers, S. Algorithms for Energy Saving. In Efficient Algorithms, S. Albers, H. Alt, and
S. N¨aher, Eds., vol. 5760 of Lecture Notes in Computer Science. Springer Berlin Heidelberg,
Berlin, Heidelberg, 2009, pp. 173–186.
[2] Albers, S. Energy-efficient algorithms. Communications of the ACM 53, 5 (may 2010), 86.
[3] Albers, S., and Fujiwara, H. Energy-efficient algorithms for flow time minimization. ACM
Transactions on Algorithms 3, 4 (nov 2007), 49–es.
[4] Andrew, L. L., Lin, M., and Wierman, A. Optimality, fairness, and robustness in speed
scaling designs. ACM Sigmetrics (2010).
[5] Andrew, L. L., Wierman, A., and Tang, A. Optimal speed scaling under arbitrary power
functions. ACM SIGMETRICS Performance Evaluation Review 37, 2 (oct 2009), 39.
[6] Atkins, L., Aupy, G., Cole, D., and Pruhs, K. R. Speed Scaling to Manage Temperature.
Lecture Notes in Computer Science 6595 (2011), 9–20.
[7] Bansal, N., Bunde, D., Chan, H. L., and Pruhs, K. R. Average rate speed scaling.
In Proceedings of the 8th Latin American conference on Theoretical informatics (dec 2008),
Springer-Verlag, pp. 240–251.
19
[8] Bansal, N., Chan, H. L., Lam, T., and Lee, L. Scheduling for speed bounded processors.
Automata, Languages and Programming (2010), 409–420.
[9] Bansal, N., Chan, H. L., and Pruhs, K. R. Speed scaling with an arbitrary power func-
tion. In Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms
(2009), Society for Industrial and Applied Mathematics, pp. 693–701.
[10] Bansal, N., Kimbrel, T., and Pruhs, K. R. Dynamic speed scaling to manage energy
and temperature. Energy (2004).
[11] Bansal, N., Kimbrel, T., and Pruhs, K. R. Speed scaling to manage energy and tem-
perature. Journal of the ACM (JACM) 54, 1 (mar 2007), 3.
[12] Bansal, N., and Pruhs, K. R. Speed scaling to manage temperature. Lecture Notes in
Computer Science 3404 (2005), 460–471.
[13] Bansal, N., Pruhs, K. R., and Stein, C. Speed scaling for weighted flow time. In
Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms (2007),
vol. pages, Society for Industrial and Applied Mathematics, p. 813.
[14] Carrasco, R. Server scheduling benchmark instances v.1. Mendeley Data,http://dx.doi.
org/10.17632/ph95d337dj.1.
[15] Carrasco, R. A., Iyengar, G. N., and Stein, C. Energy Aware Scheduling for Weighted
Completion Time and Weighted Tardiness. Tech. rep., Columbia University, 2011.
[16] Chang, H., Kodialam, M., Kompella, R. R., Lakshman, T. V., Lee, M., and
Mukherjee, S. Scheduling in mapreduce-like systems for fast completion time. 2011 Pro-
ceedings IEEE INFOCOM (apr 2011), 3074–3082.
[17] Chekuri, C., and Khanna, S. 11. Approximation Algorithms for Minimizing Average
Weighted Completion Time. In Handbook of Scheduling: Algorithms, Models, and Performance
Analysis. 2004, pp. 1–30.
[18] Chekuri, C., Motwani, R., Natarajan, B., and Stein, C. Approximation Techniques
for Average Completion Time Scheduling. SIAM Journal on Computing 31, 1 (2001), 146.
[19] Chen, J., Kuo, T., and Lu, H. Power-saving scheduling for weakly dynamic voltage scaling
devices. Algorithms and Data Structures (2005), 338–349.
[20] Cheng, T., Janiak, A., and Kovalyov, M. Y. Single machine batch scheduling with
resource dependent setup and processing times. European Journal of Operational Research
135, 1 (nov 2001), 177–183.
[21] Cheng, T. C. E., Janiak, A., and Kovalyov, M. Y. Bicriterion single machine scheduling
with resource dependent processing times. SIAM Journal on Optimization 8, 2 (1998), 617–
630.
[22] Comscore. Comscore February 2016 Ranking. http://goo.gl/yC55zw, 2016.
[23] Daniels, R. L. A multi-objective approach to resource allocation in single machine scheduling.
European Journal of Operational Research 48, 2 (sep 1990), 226–241.
20
[24] Daniels, R. L., and Sarin, R. K. Single machine scheduling with controllable processing
times and number of jobs tardy. Operations Research 37, 6 (1989), 981–984.
[25] DOE. Department of Energy website. http://goo.gl/DWojgg, 2011.
[26] Duffuaa, S., Duffuaa, S. O., Raouf, A., and Campbell, J. D. Planning and control
of maintenance systems: modeling and analysis. John Wiley & Sons Inc, 1999.
[27] Foundation, P. S. Python language reference, version 3.5. http://www.python.org, 2016.
[28] Goemans, M. X. Improved approximation algorthims for scheduling with release dates.
ACM-SIAM symposium on Discrete algorithms (1997), 591–598.
[29] 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.
[30] Google. Google Datacentre Webpage. http://goo.gl/44nDs, 2009.
[31] 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.
[32] Gurobi Optimization, I. Gurobi optimizer reference manual. http://www.gurobi.com,
2016.
[33] Hall, L. A., Schulz, A. S., Shmoys, D. B., and Wein, J. Scheduling to Minimize
Average Completion Time: Off-Line and On-Line Approximation Algorithms. Mathematics of
Operations Research 22, 3 (aug 1997), 513–544.
[34] Hall, L. A., Shmoys, D. B., and Wein, J. Scheduling to minimize average completion time:
off-line and on-line algorithms. In Proceedings of the seventh annual ACM-SIAM symposium
on Discrete algorithms (Philadelphia, PA, USA, 1996), SODA ’96, Society for Industrial and
Applied Mathematics, pp. 142–151.
[35] Herroelen, W., and Leus, R. Project scheduling under uncertainty: Survey and research
potentials. In European Journal of Operational Research (2005), vol. 165, pp. 289–306.
[36] Irani, S., Shukla, S., and Gupta, R. Algorithms for power savings. ACM Transactions
on Algorithms 3, 4 (nov 2007), 41.
[37] Janiak, A. One-machine scheduling with allocation of continuously-divisible resource and
with no precedence constraints. Kybernetika 23, 4 (1987).
[38] Janiak, A. Single machine scheduling problem with a common deadline and resource depen-
dent release dates. European Journal of Operational Research 53 (1991), 317–325.
[39] Janiak, A., and Kovalyov, M. Y. Single machine scheduling subject to deadlines and
resource dependent processing times. European Journal of Operational Research 2217, 96
(1996).
[40] Jawor, W. Three dozen papers on online algorithms. ACM SIGACT News 36, 1 (2005),
71–85.
21
[41] Kaspi, M., and Shabtay, D. A bicriterion approach to time/cost trade-offs in schedul-
ing with convex resource-dependent job processing times and release dates. Computers &
Operations Research 33, 10 (oct 2006), 3015–3033.
[42] Kwon, W.-C., and Kim, T. Optimal voltage allocation techniques for dynamically variable
voltage processors. ACM Transactions on Embedded Computing 4, 1 (2005), 211–230.
[43] Lagos, C. d. P., Stevens, A. R. H., Bower, R. G., Davis, T. A., Contreras, S.,
Padilla, N. D., Obreschkow, D., Croton, D., Trayford, J. W., Welker, C., and
Theuns, T. Quantifying the impact of mergers on the angular momentum of simulated
galaxies. Monthly Notices of the Royal Astronomical Society 473, 4 (feb 2018), 4956–4974.
[44] Monma, C. L., Schrijver, A., Todd, M. J., and Wei, V. K. Convex resource alloca-
tion problems on directed acyclic graphs: duality, complexity, special cases, and extensions.
Mathematics of Operations 15, 4 (1990), 736–748.
[45] Mu˜
noz Arancibia, A. M., Navarrete, F. P., Padilla, N. D., Cora, S. A., Gawiser,
E., Kurczynski, P., and Ruiz, A. N. Properties of submillimetre galaxies in a semi-analytic
model using the Count Matching’ approach: application to the ECDF-S. Monthly Notices of
the Royal Astronomical Society 446, 3 (jan 2015), 2291–2311.
[46] Mu˜
noz, G., Espinoza, D., Goycoolea, M., Moreno, E., Queyranne, M., and Lete-
lier, O. R. A study of the BienstockZuckerberg algorithm: applications in mining and resource
constrained project scheduling. Springer US, 2017.
[47] Phillips, C. A., Stein, C., and Wein, J. Minimizing average completion time in the
presence of release dates. Mathematical Programming 82, 1-2 (jun 1998), 199–223.
[48] Pinedo, M. Scheduling: Theory, Algorithms, and Systems, 3rd ed. Springer New York, New
York, NY, 2008.
[49] Pruhs, K. R., Stee, R., and Uthaisombut, P. Speed Scaling of Tasks with Precedence
Constraints. Theory of Computing Systems 43, 1 (oct 2007), 67–80.
[50] Pruhs, K. R., Uthaisombut, P., and Woeginger, G. J. Getting the best response for
your erg. ACM Transactions on Algorithms 4, 3 (jun 2008), 1–17.
[51] Shabtay, D., and Kaspi, M. Minimizing the total weighted flow time in a single machine
with controllable processing times. Computers & Operations Research 31, 13 (nov 2004),
2279–2289.
[52] Shabtay, D., and Steiner, G. A survey of scheduling with controllable processing times.
Discrete Applied Mathematics 155, 13 (aug 2007), 1643–1666.
[53] Shabtay, D., and Steiner, G. A bicriteria approach to minimize the total weighted number
of tardy jobs with convex controllable processing times and assignable due dates. Journal of
Scheduling 14, 5 (nov 2011), 455–469.
[54] Skutella, M. List Scheduling in Order of α-Points on a Single Machine. In Efficient Ap-
proximation and Online Algorithms, E. Bampis, K. Jansen, and C. Kenyon, Eds., vol. 3484
of Lecture Notes in Computer Science. Springer Berlin Heidelberg, Berlin, Heidelberg, 2006,
pp. 250–291.
22
[55] Stevens, A. R. H., del P. Lagos, C., Contreras, S., Croton, D. J., Padilla, N. D.,
Schaller, M., Schaye, J., and Theuns, T. How to get cool in the heat: comparing
analytic models of hot, cold, and cooling gas in haloes and galaxies with EAGLE. Monthly
Notices of the Royal Astronomical Society 467, 2 (jan 2017), stx243.
[56] Van Wassenhove, L. N., and Baker, K. R. A bicriterion approach to time/cost trade-offs
in sequencing. European Journal of Operational Research (1982).
[57] Vickson, R. G. Choosing the job sequence and processing times to minimize total processing
plus flow cost on a single machine. Operations Research 28, 5 (1980).
[58] Wang, J.-B., and Wang, M.-Z. Single-machine scheduling to minimize total convex resource
consumption with a constraint on total weighted flow time. Computers & Operations Research
39, 3 (mar 2011), 492–497.
[59] Williams, T. J. Analysis and design of hierarchical control systems: with special reference
to steel plant operations, vol. 3. Elsevier, 1985.
[60] Xu, K., Feng, Z., and Ke, L. Single machine scheduling with total tardiness criterion
and convex controllable processing times. Annals of Operations Research 186, 1 (mar 2011),
383–391.
[61] Yao, F., Demers, A., and Shenker, S. A scheduling model for reduced CPU energy. In
Proceedings of IEEE 36th Annual Foundations of Computer Science (1995), IEEE Comput.
Soc. Press, pp. 374–382.
[62] Yun, H., and Kim, J. On energy-optimal voltage scheduling for fixed-priority hard real-time
systems. ACM Transactions on Embedded Computing Systems (TECS) 2, 3 (2003), 393–430.
23
