Scalably Scheduling Processes with Arbitrary Speedup Curves
Jeff Edmonds
∗
Kirk Pruhs
†
Abstract
We give a scalable ((1+ǫ)-speed O(1)- competitive) nonclairvoyant algorithm for scheduling
jobs with sublinear nondecreasing speed-up curves on multiple processors with the objective of
average response time.
1 Introduction
Computer chip designers are agreed upon the fact that chips with hundreds to thousands o f proces-
sors chips will dominate the mar ket in the next decade. The founder of chip maker Tilera asserts
that a corollary to Moore’s law will be that the number of cores/processor s will double every 18
months [15]. Intel’s director of microprocessor technology assert s that while processors will get
increasingly simple, software will need to evolve more quickly than in the past to ca tch up [15 ]. In
fact, it is generally a greed that developing so ftware to harness the power of multiple processors i s
going to b e a much more difficult t echnical challenge than the development of the hardware. In
this paper, we consider one such software technical challenge: developing operating system algo-
rithms/policies for scheduling processes with varying degrees of par allelism on a multiprocessor.
We will consider t he setting where n processes/jobs arrive to the system o f m processors over
time. Job J
i
arrives a t time r
i
, and has a work requirement w
i
. At each point of tim e, a scheduling
algorithm specifies which job is run on each processo r at that time. An operating s ystem schedul-
ing algorithm generally needs to be nonclairvoyant, that is, the algorithm does not require internal
knowledge about jobs, say for example the jo bs’ work requirement, since such information is gen-
erally not available to the operating systems. Job J
i
completes after its w
i
units of work has been
processed. If a job J
i
completes at time C
i
, then its response time is C
i
− r
i
. In this paper we
will consider the schedule qual ity of service metr ic total response time, which for a schedule S is
defined to be F (S) =
P
n
i=1
(C
i
− r
i
). For a fixed number of j obs, total response time is essentially
equivalent to average response time. Average response time is by far the mostly commonly used
schedule quality of servi ce metric. Before starting our discussion of multiprocessor scheduling, let
us first review reso urce augmentation a nalysis and single processor scheduling.
For our purposes here, reso urce augmentation analysis compares an online scheduling algorithm
against an offline optimal scheduler with slower processors. Online scheduling algorithm A is s-
speed c-competitive if
max
I
F (A
s
(I))
F (Opt
1
(I))
≤ c
where A
s
(I) is the schedule produced by algorithm A with speed s processors on input I, and
Opt
1
(I) is the optimal schedule f or unit speed processors on input I, and F (S) is the total response
∗
York University, Canada. jeff@cs.yorku.ca. Supported in part by NSERC Canada.
†
Computer Science Department. University of Pittsburgh. kirk@cs.pitt.edu. Supported in part by an IBM faculty
award, and by NSF grants CNS-0325353, CCF-0514058, IIS-0534531, and CCF-0830558.
1
Dagstuhl Seminar Proceedings 10071
Scheduling
http://drops.dagstuhl.de/opus/volltexte/2010/2546
time for schedule S [13, 17]. An algorithm A is said to be scalable if for every ǫ > 0, there is a
constant c
ǫ
such A is (1+ǫ)-speed c
ǫ
-competitive [1 8, 19]. A scalable algorithm is O(1)-compet itive
on inputs I where Opt
1
(I) is approximately Opt
1+ǫ
(I), which intuitively are inputs that do not
fully load the server. So as the load increases, the performance o f a scalable algorithm should be
reasonably close to the performance of the optimal alg orit hm up until the server is almost fully
loaded. For a more detailed explanati on see [18, 19].
The nonclairvoyant algorithm Shortest Elapsed Time First (SETF) is scalable [13] for scheduling
jobs on a si ngle processor fo r the objective of total response tim e. SETF shares the processor equally
among all processes that have been processed the least to date. Intuitively, SETF g ives priority to
more recently arri ving jobs, until they have been processed as much as older jobs, at which point all
jobs are given equal priority. The process scheduling algori thm used by most standard operating
systems, e.g. Unix, essentially schedules jobs in way that is consistent wi th this intuition. No
nonclairvoyant scheduling algorithm can be O(1)-competitive for total r esponse time if compared
against the optimal schedule with the same speed [16]. The intuition is that one can construct
adversarial instances where the load is essentially the capaci ty of the system, and there is no time
for the nonclairvoyant algorithm to recover from any scheduling mistakes.
One important issue that arises when scheduling jobs on a multiprocessor is that jobs can have
widely varying degrees of parallelism. That is, som e jobs may be be considerably sped up when
simultaneously run on to multiple processors, while some jobs may not be s ped up at all (this could
be because the underlying algorithm is inherently sequential in nature, or because the process
was not coded in a way to make it easily parallelizable). To investigate this issue, we adopt the
following general model used in [8]. Each job consists of a sequence of phases. Each phase consists
of a po siti ve real number that denotes the amount o f work in that phase, and a speedup function
that specifies the rate at which work is processed in this phase as a function of the number of
processors executing the job. The speedup functions may be arbitrary, other than we assume that
they are nondecreasing (a job doesn’t r un slower if it is given more pro cessors), and sublinear (a job
sati sfies Brent’s theorem, that is increasing the number of processo rs doesn’t increase the efficiency
of computa tion).
The most obvious scheduling algorithm in the multiprocessor setting is Equi-partition (Equi),
which splits the processors evenly among all processes. Equi is analogous to the Round Robin or
Processor Sharing algorithm in the single processor setting. In what is generally regarded as a
quite complicated analysis, it is shown in [8] that Equi is a (2+ǫ)-speed (
2s
ǫ
)-competitive for total
response time. It is also known that, even in the case of a single processor, speed at least 2+ǫ is
required in order for Equi to be O(1)-competitive for total response time [13].
1.1 Our Results
In this paper we introduce a nonclair voyant algo rithm, which we call LAPS
hβ,si
, and show that it
is scalable for scheduling jobs with subli near nondecreasing speedup curves with the objective of
total response time.
LAPS
hβ,si
(Latest A rrival Processor Sharing) Definition: This algorithm is parameterized by
a real β ∈ (0, 1]. Let n
t
be the number of jobs alive at time t. The processors a re equally partitioned
among the ⌈βn
t
⌉ jobs with the latest arrival times (breaking ties ar bitrarily but consistently). Here
s is the speed of the processor, which w ill be useful in our analysis.
Note that LAPS
hβ,si
is a generalization of Equi since LAPS
h1,si
identical to Equi
s
. But as β
decreases, LAPS
hβ,si
, in a manner reminiscent of SETF, favors mor e recently released jobs. The
main result of this paper, which we prove in sectio n 3, is then:
2
Theorem 1. LAPS
hβ,si
, with speed s = ( 1 +β +ǫ) process ors, is
4s
βǫ
-
competitive algorithm for
scheduling processes with sublinear nondecreasing speedup curves for the objectiv e of average re-
spon se time. The same result holds if LAPS
hβ,si
is given s times as many speed one processors as
the adversary.
Essentially this shows t hat, perhaps s omewhat surprisingly, that a nonclairvoyant scheduling
algorithm can perform roughly as well in the setting of scheduling jobs with arbitrary speedup curves
on a multiprocessor, as it can when scheduling jobs on a single processor. Our proof of Theorem
1 uses a simple amortized local competitiveness argument with a simple potential function. When
β = 1, that is when LAPS
hβ,si
= Equi
s
, we get a s a coro llary of Theorem 1 t hat Equi is (2+ǫ)-speed
(
2s
ǫ
)-competitive, matching the bound given in [8], but with a much easier proof.
There is a unique feature of LAPS
hβ,si
that is worth mentioning. LAPS
hβ,si
is only O(1)-
competiti ve when s is sufficiently larger (depending on β) than 1. Previously analyses showing
(1+ǫ)-speed O(1)-competitive were for algorithms that were not para meterized by ǫ. For example,
in was shown in [13] that on one processor SETF is simultaneously (1+ǫ)-speed (1+
1
ǫ
)-competitive
for all ǫ > 0 simultaneously. Thus we need to introduce a new notion of scalability. We say that an
algorithm A
s
, that is parameterized by a speed s, is scalable if f or every ǫ > 0, there is a constant
c
ǫ
such the algorithm A
1+ǫ
is (1+ǫ)-speed c
ǫ
-competitive. So note that here the algorithm depends
on the choice of ǫ.
Theorem 1 also improves the best known competitiveness result for broadcast/multicast pull
scheduling. It is easiest to explain broadcast scheduling in co ntext of a web server servi ng static
content. In this setting, it is assumed that the web server is serving content on a broadcast channel.
So if the web server has multiple unsatisfied requests for the sam e file, it need only broadcast
that file once, simultaneously satisfying all the users who issued these requests. [11] s howed how
to convert any s-speed c-competitive nonclairvoyant algorithm for scheduling jobs with arbitrary
speedup curves into a 2s-speed c-competitive alg orithm for broadcast scheduling. Using this result,
and the analysis of Equi fro m [8], [11] showed that a version of Equi (4+ǫ)-sp eed O(1)-competitive
for broadcast scheduling with the objective of avera ge response time. Using Theorem 1 we can
then deduce that a bro adcast version of LAPS
hβ,si
is (2+ǫ)-speed O( 1)-competit ive for broadcast
scheduling with the objective of average respo nse time.
1.2 Related Results
For the objective of total response time on a single processor, the competitive r atio of every de-
terministic nonclairvoya nt algorithm is Ω(n
1/3
), and the competitive ratio of every randomized
nonclairvoyant algorithm against an oblivious adversary is Ω(l og n) [16]. There is a randomized al-
gorithm, Randomized Multi-Level Feedback Queues, that is O(log n)-competitive against an obliv-
ious adversary [2, 14]. T he online cl airvoyant algorithm Shortest Remaining Processing time is
optimal for total response tim e. The competitive a nalysis of SETF
s
for single processor s cheduling
was improved for cases when s ≫ 1 in [3].
Variat ions of Equi partition are buil t into many technolo gies. For example, the congestion control
protocol in the TCP Internet protocol essentially uses Equipartition to balance bandwidth to TCP
connections through a bottleneck r outer. Extensions of the analysis of Equi in [8] to analyzing
TCP can be found in [9, 10]. Other extensions to the analysis of Equi i n [8] for related scheduling
problems can found in [20–22]. In our results here, we essentially ignore the extra advantage that
the o nline algorithm g ains from having f aster processors instead o f more processors. [8] gives a
better competitive ratio fo r Equi in the model with faster processors.
3
There are many r elated scheduling problems with other objectives, and/or other assumptions
about the machine and job instance. Surveys can b e found in [18, 19].
2 Preliminaries
In this section, we review the formal definitions introduced in [8]. An instance consists of a
collection J = {J
1
, . . . , J
n
} where job J
i
has a release/arrival time r
i
and a sequence of phases
J
1
i
, J
2
i
, . . . , J
q
i
i
. Each phase is an ordered pair hw
q
i
, Γ
q
i
i, where w
q
i
is a positive real number that
denotes the am ount of work in the phase and Γ
q
i
is a function, called the speedup function, that
maps a nonnegative real number to a nonnegative rea l number. Γ
q
i
(p) represents t he rate at which
work is processed for phase q of job J
i
when run on p processors running at speed 1. If these
processors are running at speed s, then work is processed at a rate of sΓ
q
i
(p).
A schedule specifies for each time, and for each job, (1) a nonnegative real number specifying
the number of processors assigned to that job, and (2) a nonnegative real speed. The number of
processors assigned at any time can be at most m, the number of processors. Note that, formall y,
a schedule does not specify an assignment of copies of jobs to processors.
A nonclairvoya nt algorithm only knows when processes have been released and finished in the
past, and which processes have been run on each processor each time in the past. In particular, a
nonclairvoyant algorithm does not know w
q
i
, nor the current phase q, nor the speedup function Γ
q
i
.
The completion time of a job J
i
, denoted C
i
, is the first point of time when all the work of
the job J
i
has been processed. Note that in t he languag e of scheduling, we are assuming that
preemption is allowed, that is, a job maybe be suspended and later restarted from the point of
suspension. A job is said to be alive at time t, if it has been released, but has not completed, i .e.,
r
i
≤ t ≤ C
i
. The response/flow time of job J
i
is C
i
− r
i
, which is the length of the time interval
during which t he job is active. Let n
t
be the number of active jobs at t ime t. Another fo rmulation
of total flow time is
R
∞
0
n
t
dt.
A phase of a job is parallelizabl e if its speedup function is Γ(p) = p. Increasing the number of
processors allocated to a parallelizable phase by a factor of s increases the rate of processing by
a factor of s. A phase is sequential if its speedup function is Γ(p) = 1, for all p ≥ 0. The rate
that work is processed in a sequential phase is independent of the number of processo rs, even if it
is zero. A speedup function Γ is nondecreasing if and only if Γ(p
1
) ≤ Γ(p
2
) whenever p
1
≤ p
2
. A
speedup function Γ is sublinear if and only if Γ(p
1
)/p
1
≥ Γ(p
2
)/p
2
whenever p
1
≤ p
2
. We assume
all speedup functions Γ in the input inst ance are nondecreasing and sublinear.
Let A be an algorithm and J an instance. We denote the schedule output by A with speed s
processors on J as A
s
(J). Let Opt(J) be the optimal schedule with unit speed processo rs on input
J. We let F (S) denote the total response time incurred i n schedule S,
3 Analysis of LAPS
hβ ,si
This section will be devoted or proving Theorem 1, that LAPS
hβ,si
is scalable. We will assume that
the online algorithm has sm unit speed processors while the adversary has m unit speed processors.
Since in the context of preemptive scheduling, a speed s processo r is always at least as useful as s
unit speed processors, the analysis for speed augmentation will follow as a direct consequence of
our analysis for machine augmentation.
Foll owing the lead of [ 8] and [22], the first step in our proof is t o prove that there is a worst
case instance that contains only sequential and parallelizable phases.
4
Lemma 2. Let A be a nonclairvoyant scheduler. Let J be an instance of jobs with sublinear-
nondecreasing speedup functions. Then there is a job set J
′
that with only s equential and paralleliz-
able phases such that F (A(J
′
)) = F (A(J)) and F (Opt(J
′
)) ≤ F (Opt(J) ).
Proof. We explain how to modify J to obtain J
′
. We perform the following modification for
each time t and each job J
i
that A runs during the infinitesimal t ime [t, t + dt]. Let w be t he
infinitesimal amount of work processed by A during this time, and Γ the speedup function for the
phase containing w. Let p
a
denote the number of processors allocated by A to w at time t. So the
amount of work in w is Γ(p
a
)dt. Let p
o
denote the number of processors allocated by Opt to w.
It is impor tant to note that Opt may not process w at time t. If p
0
≤ p
a
, we then modify J by
replacing t his w amount of work with a sequential phase with work w
′
= dt. If p
o
> p
a
, we then
modify J by replacing this w amount of work with parallelizable phase with work w
′
= p
a
dt. Note
that by construction, A will not be able to distinguish between the instances J and J
′
during the
time period [t, t + dt]. Hence, since A is nonclairvoyant A(J
′
) = A(J). We are now left to argue
that F (Opt(J
′
)) ≤ F(Opt(J)). We will accomplish this by giving a schedule X for J
′
that has
total response time at m ost F(Opt(J)).
First consider the case that p
o
≤ p
a
. Because the speedup function Γ of the phase containing
the work w i s non-decreasing, it took Opt(J) more than time dt to finish the work w. The schedule
X will s tart working on the work w
′
with p
o
processors when Opt(J) start ed working on the work
w, and then after X completes w
′
, X can let these p
0
processors idle until Opt(J) completes w.
Now consider that case that p
o
≥ p
a
. Aga in the schedule X will st art working on w
′
when
Opt(J) started working on w. We now want to argue that X can complete w
′
with p
o
processors
in less time than it took Opt(J) to complete w with p
o
processors. It took time
p
a
dt
p
o
time for X to
complete w
′
since the p
a
dt work in w
′
is parallelizable. It took Opt(J) time
Γ(p
a
)dt
Γ(p
o
)
to complete the
Γ(p
a
)dt work in w. The fact X completes w
′
before Opt( J) completes w follows since
p
a
p
o
≤
Γ(p
a
)
Γ(p
o
)
since p
o
≥ p
a
and Γ is sublinear.
By Lemma 2, it is sufficient to consider instances that contain only sequential and parall elizable
phases. So for the rest of the proof we fix such an instance. Our goal is to bound the number N
t
of jobs alive under Opt at time t in terms of what is happening under LAPS
hβ,si
at this same time.
This requires the introductio n of a fair amount of notation. Let n
t
denote number of jobs alive
under LAPS
hβ,si
at tim e t. Let m
t
denote the number of these that are wit hin a parallelizable phase
at t his time and let ℓ
t
denote the same except for sequential phases. Let N
t
, M
t
, and L
t
denote
the same numbers except under Opt. Let
b
N
t
denote the number jobs at time t that LAPS
hβ,si
has not completed, but for which LAPS
hβ,si
is ahead of Opt. Let
b
ℓ
t
denote the number jo bs that
LAPS
hβ,si
has not completed at time t, and either LAPS
hβ,si
is ahead of Opt on this job at this
time, or LAPS
hβ,si
is executing a sequentia l phase on this job at this time.
We note some relationships between these job counts C learly
b
N
t
≤ N
t
since Opt has not
completed these
b
N
t
jobs.
R
∞
0
L
t
dt =
R
∞
0
ℓ
t
dt since each integral is simply the sum of the work of
all sequential phases of all jobs. Finally not e that
b
ℓ
t
≤
b
N
t
+ ℓ
t
since each of the
b
ℓ
t
jobs is either
in a sequent ial phase, or is included in the count
b
N
t
. T hus we can conclude that the total cos t to
Opt is bounded as follows:
F (Opt(J)) =
Z
∞
0
N
t
dt =
1
2
Z
∞
0
(N
t
+ (M
t
+ L
t
)) dt ≥
1
2
Z
∞
0
b
N
t
+ 0 + ℓ
t
dt ≥
Z
∞
0
b
ℓ
t
2
dt
To prove c-competitiveness using an amo rtized local competitiveness argument [8, 18, 19], we
need to define a po tential function Φ
t
such that the following conditions hold:
5