U.S. patent application number 13/116378 was filed with the patent office on 2012-11-29 for scheduling mapreduce jobs in the presence of priority classes.
This patent application is currently assigned to INTERNATIONAL BUSINESS MACHINES CORPORATION. Invention is credited to Andrey Balmin, Kirsten W. Hildrum, Rohit M. Khandekar, Deepak Rajan, Joel L. Wolf.
Application Number | 20120304186 13/116378 |
Document ID | / |
Family ID | 47220174 |
Filed Date | 2012-11-29 |
United States Patent
Application |
20120304186 |
Kind Code |
A1 |
Balmin; Andrey ; et
al. |
November 29, 2012 |
Scheduling Mapreduce Jobs in the Presence of Priority Classes
Abstract
Techniques for scheduling one or more MapReduce jobs in a
presence of one or more priority classes are provided. The
techniques include obtaining a preferred ordering for one or more
MapReduce jobs, wherein the preferred ordering comprises one or
more priority classes, prioritizing the one or more priority
classes subject to one or more dynamic minimum slot guarantees for
each priority class, and iteratively employing a MapReduce
scheduler, once per priority class, in priority class order, to
optimize performance of the one or more MapReduce jobs.
Inventors: |
Balmin; Andrey; (San Jose,
CA) ; Hildrum; Kirsten W.; (Hawthorne, NY) ;
Khandekar; Rohit M.; (Elmsford, NY) ; Rajan;
Deepak; (Fishkill, NY) ; Wolf; Joel L.;
(Goldens Bridge, NY) |
Assignee: |
INTERNATIONAL BUSINESS MACHINES
CORPORATION
Armonk
NY
|
Family ID: |
47220174 |
Appl. No.: |
13/116378 |
Filed: |
May 26, 2011 |
Current U.S.
Class: |
718/103 |
Current CPC
Class: |
G06F 9/50 20130101; G06F
9/4881 20130101; G06F 9/46 20130101 |
Class at
Publication: |
718/103 |
International
Class: |
G06F 9/46 20060101
G06F009/46; G06F 9/50 20060101 G06F009/50 |
Claims
1. A method for scheduling one or more MapReduce jobs in a presence
of one or more priority classes, wherein the method comprises:
obtaining a preferred ordering for one or more MapReduce jobs,
wherein the preferred ordering comprises one or more priority
classes; prioritizing the one or more priority classes subject to
one or more dynamic minimum slot guarantees for each priority
class; and iteratively employing a MapReduce scheduler, once per
priority class, in priority class order, to optimize performance of
the one or more MapReduce jobs.
2. The method of claim 1, further comprising repeating the
iterative process until there are no idle processors in the
MapReduce schedule or no further need for additional
allocations.
3. The method of claim 1, wherein each job belongs to a priority
class.
4. The method of claim 1, wherein prioritizing the one or more
priority classes subject to one or more dynamic minimum slot
guarantees for each priority class comprises preventing starvation
of one or more jobs in lower priority classes.
5. The method of claim 1, wherein within the one or more priority
classes, class minima are appropriately allocated amongst the one
or more jobs.
6. The method of claim 1, wherein iteratively employing a MapReduce
scheduler, once per priority class, in priority class order
comprises allocating any additional slack slots in a cluster in an
intelligent manner to the one or more jobs.
7. The method of claim 1, further comprising performing bookkeeping
after each iteration to provide input data to a subsequent
scheduling scheme.
8. The method of claim 1, further comprising optimizing a
scheduling metric within one or more given constraints.
9. The method of claim 1, further comprising providing, via a
scheduling manager component, a revised minimum number of slots per
job, wherein the minimum is greater than or equal to an original
minimum.
10. The method of claim 1, further comprising implementing a
Malleable Packing Scheme and implementing only a first layer of
malleable packing with an expectation that a revised schedule will
arrive in sufficient time.
11. The method of claim 1, further comprising re-optimizing
performance of the one or more MapReduce jobs when input data
changes.
12. The method of claim 1, further comprising providing a system,
wherein the system comprises one or more distinct software modules,
each of the one or more distinct software modules being embodied on
a tangible computer-readable recordable storage medium, and wherein
the one or more distinct software modules comprise a priority
control module, a preemptive priority class allocation module, a
non-preemptive priority subclass allocation module, and an enhanced
FLEX scheduling module executing on a hardware processor.
13. A computer program product comprising a tangible computer
readable recordable storage medium including computer useable
program code for scheduling one or more MapReduce jobs in a
presence of one or more priority classes, the computer program
product including: computer useable program code for obtaining a
preferred ordering for one or more MapReduce jobs, wherein the
preferred ordering comprises one or more priority classes; computer
useable program code for prioritizing the one or more priority
classes subject to one or more dynamic minimum slot guarantees for
each priority class; and computer useable program code for
iteratively employing a MapReduce scheduler, once per priority
class, in priority class order, to optimize performance of the one
or more MapReduce jobs.
14. The computer program product of claim 13, wherein the computer
useable program code for iteratively employing a MapReduce
scheduler, once per priority class, in priority class order
comprises computer useable program code for allocating any
additional slack slots in a cluster in an intelligent manner to the
one or more jobs.
15. The computer program product of claim 13, further comprising
computer useable program code for performing bookkeeping after each
iteration to provide input data to a subsequent scheduling
scheme.
16. The computer program product of claim 13, further comprising
computer useable program code for repeating the iterative process
until there are no idle processors in the MapReduce schedule or no
further need for additional allocations.
17. The computer program product of claim 13, further comprising
computer useable program code for providing, via a scheduling
manager component, a revised minimum number of slots per job,
wherein the minimum is greater than or equal to an original
minimum.
18. The computer program product of claim 13, further comprising
computer useable program code for re-optimizing performance of the
one or more MapReduce jobs when input data changes.
19. A system for scheduling one or more MapReduce jobs in a
presence of one or more priority classes, comprising: a memory; and
at least one processor coupled to the memory and operative to:
obtain a preferred ordering for one or more MapReduce jobs, wherein
the preferred ordering comprises one or more priority classes;
prioritize the one or more priority classes subject to one or more
dynamic minimum slot guarantees for each priority class; and
iteratively employ a MapReduce scheduler, once per priority class,
in priority class order, to optimize performance of the one or more
MapReduce jobs.
20. The system of claim 19, wherein the at least one processor
coupled to the memory operative to iteratively employ a MapReduce
scheduler, once per priority class, in priority class order is
further operative to allocate any additional slack slots in a
cluster in an intelligent manner to the one or more jobs.
21. The system of claim 19, wherein the at least one processor
coupled to the memory is further operative to perform bookkeeping
after each iteration to provide input data to a subsequent
scheduling scheme.
22. The system of claim 19, wherein the at least one processor
coupled to the memory is further operative to optimize a scheduling
metric within one or more given constraints.
23. The system of claim 19, wherein the at least one processor
coupled to the memory is further operative to provide, via a
scheduling manager component, a revised minimum number of slots per
job, wherein the minimum is greater than or equal to an original
minimum.
24. The system of claim 19, wherein the at least one processor
coupled to the memory is further operative to re-optimize
performance of the one or more MapReduce jobs when input data
changes.
25. The system of claim 19, wherein the at least one processor
coupled to the memory is further operative to repeat the iterative
process until there are no idle processors in the MapReduce
schedule or no further need for additional allocations.
Description
FIELD OF THE INVENTION
[0001] Embodiments of the invention generally relate to information
technology, and, more particularly, to MapReduce scheduling in the
presence of priority classes.
BACKGROUND OF THE INVENTION
[0002] Challenges exist in scheduling multiple concurrent MapReduce
jobs while to respecting constraints due to priority classes.
Existing approaches to scheduling MapReduce work have not
considered the notion of priority classes. Yet, the notion of
priority classes is an entirely natural one. As an example, it
might be that work in an "operations" class would be more important
than work in an "analysts" class, which would be, in turn, more
important than work in a "capability development" class. Further,
these priority classes may be preemptive or non-preemptive in
nature, or even a hybrid combination of both. There does exist at
least one MapReduce scheduler which can optimize towards one of a
multiplicity of several standard metrics. However, existing
MapReduce scheduler approaches cannot optimize towards one of the
standard metrics while simultaneously respecting the relative
importance of priority classes.
SUMMARY OF THE INVENTION
[0003] Principles and embodiments of the invention provide
techniques for scheduling MapReduce jobs in the presence of
priority classes. An exemplary method (which may be
computer-implemented) for scheduling one or more MapReduce jobs in
a presence of one or more priority classes, according to one aspect
of the invention, can include steps of obtaining a preferred
ordering for one or more MapReduce jobs, wherein the preferred
ordering comprises one or more priority classes, prioritizing the
one or more priority classes subject to one or more dynamic minimum
slot guarantees for each priority class, and iteratively employing
a MapReduce scheduler, once per priority class, in priority class
order, to optimize performance of the one or more MapReduce
jobs.
[0004] One or more embodiments of the invention or elements thereof
can be implemented in the form of a computer product including a
tangible computer readable storage medium with computer useable
program code for performing the method steps indicated.
Furthermore, one or more embodiments of the invention or elements
thereof can be implemented in the form of an apparatus including a
memory and at least one processor that is coupled to the memory and
operative to perform exemplary method steps. Yet further, in
another aspect, one or more embodiments of the invention or
elements thereof can be implemented in the form of means for
carrying out one or more of the method steps described herein; the
means can include (i) hardware module(s), (ii) software module(s),
or (iii) a combination of hardware and software modules; any of
(i)-(iii) implement the specific techniques set forth herein, and
the software modules are stored in a tangible computer-readable
storage medium (or multiple such media).
[0005] These and other objects, features and advantages of the
present invention will become apparent from the following detailed
description of illustrative embodiments thereof, which is to be
read in connection with the accompanying drawings.
BRIEF DESCRIPTION OF THE DRAWINGS
[0006] FIG. 1 is a diagram illustrating MapReduce scheduling
examples, according to an embodiment of the present invention;
[0007] FIG. 2 is a diagram illustrating an apparatus for defining
minimum slot guarantees by preemptive priority class, according to
an embodiment of the present invention;
[0008] FIG. 3 is a diagram illustrating an alternative view of an
apparatus for defining minimum slot guarantees by preemptive
priority class, according to an embodiment of the present
invention;
[0009] FIG. 4 is a diagram illustrating an apparatus for defining
both preemptive priority classes and non-preemptive priority
sub-classes, according to an embodiment of the present
invention;
[0010] FIG. 5 is a diagram illustrating standard scheduling
metrics, according to an embodiment of the present invention;
[0011] FIG. 6 is a block diagram illustrating an example
embodiment, according to an aspect of the invention;
[0012] FIG. 7 is a flow diagram illustrating techniques for
scheduling one or more MapReduce jobs in a presence of one or more
priority classes, according to an embodiment of the invention;
[0013] FIG. 8 is a diagram illustrating an example of the
allocation of slots to a non-preemptive subclass within a
preemptive priority class, according to an embodiment of the
present invention;
[0014] FIG. 9 illustrates the enhanced Malleable Packing Scheme
employed by one or more embodiments of the present invention;
[0015] FIG. 10 is a flow diagram illustrating techniques for
scheduling one or more MapReduce jobs in a presence of one or more
priority classes, according to an embodiment of the present
invention; and
[0016] FIG. 11 is a system diagram of an exemplary computer system
on which at least one embodiment of the invention can be
implemented.
DETAILED DESCRIPTION OF EMBODIMENTS
[0017] Principles of the invention include scheduling MapReduce
jobs in the presence of priority classes. The techniques detailed
herein can include enforcing, for example, two sub-goals. The first
sub-goal can be stated as: priority "rules," but subject to dynamic
minimum slot guarantees for the individual priority classes. This
prevents starvation of jobs in the lower classes, provided
sufficient work in those classes exists, and is analogous to what a
high quality MapReduce scheduler would do at the job level. The
second sub-goal involves iteratively employing an intelligent
MapReduce scheduler, class by class, to optimize performance, and
repeating this iterative process until completion. In one or more
embodiments of the invention, the class minima are appropriately
allocated within classes amongst the jobs of that class.
Thereafter, any additional "slack" slots in the cluster are
allocated in an intelligent manner to the jobs.
[0018] One or more embodiments of the invention includes employing
a scheduling scheme such as, for example, an appropriately enhanced
version of FLEX iteratively, once per priority class, in priority
class order. After each iteration, bookkeeping can be carried out
to provide input data to the subsequent enhanced FLEX scheduling
scheme. This bookkeeping includes, for example, creating a
time-based histogram of the resources used thus far by the
scheduler, in order to feed that data as resource to the next
enhanced version of the enhanced FLEX scheduler. Also, an enhanced
version of FLEX can be embedded, in one or more embodiments of the
invention, in a MapReduce system (such as, for example, provided in
Hadoop). The FLEX scheduler, which serves as a building block of
one or more embodiments of the invention, is described in detail in
U.S. patent application Ser. No. 12/853,925, filed Aug. 10, 2010,
the disclosure of which is incorporated by reference herein.
[0019] FIG. 1 is a diagram illustrating MapReduce scheduling
examples, according to an embodiment of the present invention. By
way of illustration, FIG. 1 depicts an allocation layer model 102
and an assignment layer reality 104. By way of example, FLEX, FAIR
and First In, First Out (FIFO) are slot-based Allocation Layer
schedulers. Slots are the basic unit of resource in MapReduce, and
MapReduce jobs can include many small, independent tasks that get
assigned to these slots. In an allocation layer, FLEX, FAIR and
FIFO allocate numbers of slots to different jobs, and such
allocations can vary over time. In an assignment layer, this lower
layer can attempt to implement the decisions of the allocation
layer.
[0020] As described herein, one or more embodiments of the
invention include scheduling with priority classes. By way of
illustration, each job belongs to a "priority class." An example
can include three priority classes of "operations," "analysts" and
"capability development." In such an example, priority class 1
("operations") is more important than class 2 ("analysts"), which
is more important than class 3 ("capability development").
[0021] A goal of such an example may include scheduling the jobs in
these classes in an intelligent manner. A first sub-goal, as noted
herein, can include assuming that priority "rules," but subject to
"dynamic" minimum slot guarantees for the individual classes, which
prevents starvation of jobs in the lower classes, and includes a
priority class minima analogous to what FAIR and FLEX do at the job
level. A second sub-goal can include using an intelligent FLEX-like
scheduler to optimize performance, both within classes to allocate
the class minima amongst the jobs, and to allocate any additional
"slack" slots in the cluster to the jobs.
[0022] FIG. 2 is a diagram illustrating an apparatus for defining
minimum slot guarantees by preemptive priority class, according to
an embodiment of the present invention. Sliders 202, 204 and 206
can be adjusted to set dynamic minimum guarantees of priority class
slots 208, 210 and 212. The sum of dynamic minima must be at most
100%, but possibly leaving spare, unallocated slots referred to as
the "slack." In the instance of FIG. 2, slack is
100%-(30%+10%+20%)=40%. Slack will be given to jobs in preemptive
priority order, and any unallocated slots within a priority class
will be given by FLEX to jobs in a different class, also in
preemptive priority order.
[0023] FIG. 3 is a diagram illustrating an alternative view of an
apparatus for defining minimum slot guarantees by preemptive
priority class, according to an embodiment of the present
invention. Sliders 302, 304 and 306 set dynamic minimum guarantees
of preemptive priority class slots. As above, the sum of dynamic
minima must be at most 100%, possibly leaving spare, unallocated
slots (slack), and in the FIG. 3 instance, slack is
100%-(30%+10%+20%)=40%. As also noted above, slack will be given to
jobs in preemptive priority order, and any unallocated slots within
a preemptive priority class will be given by FLEX to jobs in a
different class, also in priority order.
[0024] According to a more general embodiment of the invention, it
is possible, as noted, to refer to the three classes of FIG. 2 or
FIG. 3 as preemptive priority classes. They may themselves be
hierarchically organized, with multiple non-preemptive sub-classes
contained within each.
[0025] FIG. 4 is a diagram illustrating an apparatus for defining
both preemptive priority classes and non-preemptive priority
sub-classes, according to an embodiment of the present invention.
By way of illustration, FIG. 4 depicts a dashboard for a three
class and seven sub-class case, including new slider 402, as well
as sliders 404, 406, 408, 410 and 412. The three classes are
delineated via sliders 404 and 410, which are entirely
left-justified. They determine that subclasses 1 and 2 are in the
highest preemptive priority class, that subclasses 3, 4 and 5 are
in the medium preemptive priority class, and that subclasses 6 and
7 are in the lowest preemptive priority class. Within each class
there are also sliders, not left-justified, which decide how to
divide up resource allocation amongst the different sub-classes in
the class. Slider 402 divides the first class. Sliders 406 and 408
divide the second class. Slider 412 divides the third class.
Sliders towards the left favor the previous sub-class over the
subsequent class. Sliders towards the right favor more equality.
Sliders which are completely right justified favor complete
equality amongst the previous and subsequent sub-class.
[0026] Additionally subtleties, in accordance with one or more
embodiments of the invention, can include the following. A job may
have a minimum imposed by FAIR and FLEX, and a natural useful job
maximum may exist as well (for example, if there are only a few
tasks remaining). Also, there may be few or no active jobs in a
priority class. A guiding scheduling principal includes not wasting
slots, and so priority class minima is made dynamic and slack is
allocated.
[0027] As noted above, FLEX, FIFO and FAIR are MapReduce
schedulers. FLEX is a MapReduce scheduler that can optimize a
variety (for example, 15) of user-chosen metrics while meeting some
simple and reasonable constraints. FIFO is a MapReduce scheduler,
but does not optimize anything and does not include metrics or
constraints (and, as such, it can starve a small job if a big job
arrives earlier). FAIR is a MapReduce scheduler, but does not
formally optimize any of the standard scheduling metrics. It does
meet one simple constraint in an effort to avoid starvation.
[0028] Scheduling optimization problems can have multiple key
components. For instance, there can be a desire to (maximize or)
minimize some expression which describes the quality of a
particular schedule (that is, maximize the good or minimize the
bad). Examples of minimizing bad include average response time,
stretch, number of tardy jobs, stretch, service level agreements
(SLAs), makespan, etc. Examples of maximizing good would be
throughput or SLA profits. Additionally, all schedules considered
in this process must satisfy some conditions, typically to make the
schedule "practical." In other words, some constraints are to be
enforced in order to have an acceptable schedule. Examples include
minimum numbers of slots per job, minimum numbers of slots per
priority class, etc. Further, in all cases, the more restrictive
the constraints, the worse the quality of the schedule.
[0029] All metrics considered in connection with one or more
embodiments of the invention are based on functions of the
completion times of the jobs. Examples can be based on the sum (or
average) over all jobs, as well as the maximum (worst case) over
all jobs. Also, for example, an average response time metric favors
small jobs because they count the same as big jobs, and therefore
makes more job users "happy." A stretch metric favors fairness
because jobs get allocations roughly proportionally to the amount
of work they require (equivalently, proportional to amount of time
they would take if given all system resources). A number of tardy
jobs metric can be common if jobs have deadlines (such as the end
of a batch window), and should complete as many jobs as possible
given the deadlines. An SLA metric can be used if jobs "pay" costs
which depend on when they complete relative to multiple soft
deadlines, possibly appropriate, for example, for a cloud
environment. Additionally, a makespan metric indicates the maximum
completion time over all the jobs. Such a metric is basically
inversely related to throughput, so minimizing makespan would
effectively maximize throughput.
[0030] FIG. 5 is a diagram illustrating standard scheduling
metrics, according to an embodiment of the present invention. By
way of illustration, FIG. 5 depicts a weighted response time metric
502, a weighted number of tardy jobs metric 504, a weighted
tardiness metric 506, a weighted lateness metric 508 and a SLA cost
metric 510. In one or more embodiments of the invention, there are
16 metrics in all, given combinatorial choices involving whether
the metric is maximum or average case performance, and whether or
not there are weights in the objective function.
[0031] For many metrics, FLEX with zero or modest job minima will
provide schedules while avoiding job starvation. For some metrics,
job minima may be necessary. The use of a particular metric can
depend on the application environment. The metric might also depend
on the type of the job itself (for example, response time for ad
hoc jobs, and number of tardy jobs for batch jobs). FLEX is
flexible enough to largely handle these metrics, as one can install
and experiment with FLEX as is (without priority classes)
immediately, but FLEX will need to be significantly enhanced to
handle priority class minima.
[0032] In particular, FLEX includes a scheme that has two major
components. The first component produces a "preferred" ordering of
jobs for a particular metric. This preferred ordering is then input
to the second component, known as the Malleable Packing Scheme
(MPS). For purposes of one or more embodiments of the invention,
the preferred ordering scheme of the original FLEX scheduler can be
used as is. However, the Malleable Packing Scheme must be
significantly enhanced in order to handle time-based histograms of
available allocation slots. Therefore, the FLEX scheduler, taken as
a whole, may also be said to be significantly enhanced. Also, in
one or more embodiments of the invention, iterative calls to an
enhanced FLEX scheduler are made by preemptive priority classes and
non-preemptive priority subclasses, together with bookkeeping on
slot availability, job minima and maxima, priority class minima and
slack. Each priority class can be optimized to a different,
appropriate metric. Then, the entire iterative process can be
repeated until either there are no idle processors or there is no
further work required.
[0033] As detailed herein, one or more embodiments of the invention
include providing a scheduler (for example, a modified version of
FLEX) for MapReduce workloads that allocates all available slots in
the distributed cluster to the jobs. A scheduling manager provides
a "revised" minimum number of slots per job, and the minimum will
be greater than or equal to the original minimum. Additionally, in
one or more embodiments of the invention, there is no slack unless
there is insufficient work to be performed. The sum of "revised"
minimum slots will be the total number of slots or the total amount
of work to be performed, so no FAIR proportional sharing slack
rules are relevant. One or more embodiments of the invention also
include allowing for constraints on the maximum number of slots per
job (a generalization of FAIR), but FLEX will also attempt to
optimize any of 16 different standard scheduling metrics within the
given constraints.
[0034] As described herein, one or more embodiments of the
invention include a scheduling manager component. Refer now to FIG.
6, a block diagram illustrating an example embodiment, according to
an aspect of the invention. Use of a scheduling manager can depend
on multiple ideas. One or more embodiments of the invention will
include a priority control component 600, that component containing
three modules. There is a preemptive priority class allocation
module 602, which apportions the total slots in the cluster to the
individual priority classes. There is a non-preemptive priority
sub-class module 604, which apportions the appropriately revised
time-based histogram of slots allocated to the priority class to
the individual priority subclasses. There is also an enhanced FLEX
scheduling module 606. For example, depending on the metric, a
preferred ordering of the jobs in the subclass is computed.
Accordingly, given a preferred ordering of jobs, a high quality
enhanced malleable packing scheme can be used to compute a
schedule.
[0035] Refer now to FIG. 7, a flow diagram illustrating techniques
for scheduling one or more MapReduce jobs in a presence of one or
more priority classes, according to an embodiment of the invention.
Accordingly, the priority control component proceeds iteratively
through the priority classes, in order of highest preemptive
priority class to lowest preemptive priority class. The preemptive
priority classes are indexed by p, from 1 to P. For each preemptive
priority class p, the non-preemptive priority subclasses are
indexed by n, from 1 to N.sub.p. For each non-preemptive priority
subclass (p,n), there will exist a minimum allocation m.sub.p,n of
slots. This can be summed over n to compute a minimum number of
slots M.sub.p of minimum slot allocations per preemptive priority
class p.
[0036] As depicted in FIG. 7, step 700 includes setting the initial
priority p to be 1. Initially, there is a total remaining slack S
equal to the difference between the total number of slots M in the
cluster and the sum over all preemptive priority classes of M. The
number of slots given by the preemptive priority class allocation
module to class 1 is a trivial time-based histogram of M.sub.1+S.
That is, it is time-invariant, always equal to this value. The
additional slack slots will be shared in a fair manner by the
sub-classes within the class.
[0037] Step 702 includes setting the initial non-preemptive
priority to be 1. The number of slots given by the non-preemptive
priority sub-class allocation module in step 704 to subclass (1,1)
is M.sub.1,1+SM.sub.1,1/M.sub.1. Additionally, step 706 includes
scheduling the jobs in subclass (1,1) by finding a preferred
ordering of the jobs in the sub-class and employing an enhanced
Malleable Packing Scheme, as described herein. This schedule will
use a number of allocation slots which is not time-invariant.
Specifically, there will be a finite number of times T.sub.k at
which the number of slots will change.
[0038] Step 708 includes incrementing n, and step 710 includes
testing to see if n is less than or equal to N.sub.p. If n is less
than or equal to N.sub.p, control is passed back to step 704, which
schedules the jobs in the next sub-class. Note that past sub-class
(1,1), all time-based histograms may be non-trivial, and this
histogram is used by the enhanced Malleable Packing Scheme. If n is
not less than or equal to N.sub.p, control is passed to step 712,
which increments p. Further, step 714 includes testing to see if p
is less than or equal to P. If p is less than or equal to P,
control is passed back to step 702. If p is not less than or equal
to P, the process terminates at step 716 with a complete
schedule.
[0039] FIG. 8 is a diagram illustrating an example of the
allocation of slots to a non-preemptive subclass within a
preemptive priority class, according to an embodiment of the
present invention, and it also illustrates the time-based histogram
that guides the number of slots available. Specifically, FIG. 8
depicts a portion 802 of already scheduled higher classes, a
portion 804 of allocation for highest sub-class in a class, and a
portion 806 for a sum of minima for lower classes. The allocation
for the highest priority sub-class in the class is shown as a
concrete example, but the diagram would be analogous for subsequent
sub-classes.
[0040] FIG. 9 illustrates the enhanced Malleable Packing Scheme
employed by one or more embodiments of the present invention. This
scheme starts with a preferred ordering of the jobs in a sub-class.
In the original Malleable Packing Scheme component of the FLEX
scheduler, the number of slots available was time-invariant. In one
or more embodiments of the invention this is generalized to allow
for time-based histograms of available slots. Note the times
T.sub.k in the steps in FIG. 9, where T.sub.0 is the start time of
the scheduler and T.sub.1, T.sub.2 and so on, represent the times
at which the histogram changes. Step 900 represents the status as
the packing begins. Step 902 represents the status at the end of
the first stage of packing, and step 904 represents the status at
the end of the second stage.
[0041] There are six jobs in this illustrative example, represented
by indices 1 through 6. In step 902, the packing proceeds by
allocating the minimum number of slots to each job, in preferred
order. The remaining slack is then scheduled in preferred order,
with job 1 getting additional allocation up to its maximum, job 2
getting additional allocation up to its maximum, and job 3 getting
a portion of that additional allocation until there are no further
slots. Given this allocation, each job will finish at some time,
which in this example is beyond the time T.sub.1 of the first
histogram change. The enhanced Malleable Packing Scheme cuts off
the schedule at that point, leaving some additional work remaining
for each of the jobs.
[0042] After performing bookkeeping (as described herein), the
scheme continues with step 904. In this step, there are fewer slots
available, and after each job gets its minimum, only job 1 gets an
allocation up to its maximum. Job 2 gets a partial allocation. Each
job will again finish at some time, as shown in step 904, and in
this example job 2 completes before the time T.sub.2 of the next
histogram change. The enhanced Malleable Packing Scheme cuts off
the schedule at this point, leaving some additional work for jobs 1
and 3 through 6. This process repeats until all jobs have been
scheduled, thus creating a revised histogram of useful work.
[0043] More formally, in an enhanced malleable packing scheme,
input can include, for example, a preferred ordering of jobs. It
can also include a time-based histogram of available slots. The
changes occur at times T.sub.k and there are S.sub.k available
slots between times T.sub.k-1 and T.sub.k. This can include a total
number of slots R based on phase, where each job has a positive
minimum arising from the FAIR scheduler. Each job can also have a
maximum, if appropriate. Setting the maximum max.sub.j to P is
equivalent to "removing" this constraint for job j. Additionally,
the output for a malleable packing scheme can include malleable
allocation of slots to jobs that meets constraints.
[0044] An algorithm, in accordance with one or more embodiments of
the invention, can include the following:
TABLE-US-00001 Initialization: Create list K of all jobs, in
preference order Set time T to be T.sub.0 While list is not empty
do { Allocate minimum number of slots m.sub.k to each job k in K
Set L = K, with implied ordering Compute slack S = S-.SIGMA.m.sub.k
While (S .gtoreq. 0 | L .noteq. O) do { Allocate most preferred job
k in L min (S, M.sub.k - m.sub.k) slots Remove job j from L
Recompute S = S-min (S, M.sub.j - m.sub.j) } If (Exists job j
completing before next histogram change time T.sub.k+1) Remove j
from K Reset T to be this completion time } else { Reset T to be
T.sub.k+1 Bookkeeping to compute remaining work through this
completion time }
[0045] Additionally, in one or more embodiments of the invention, a
FLEX scheduler can be integrated in a MapReduce system (such as,
for example, Hadoop). The FLEX scheduler overrides the one method
in FAIR, and a current implementation minimizes average response
time. Minimal changes are made to FAIR scheduler code. For example,
the scheduler can be activated as an "advanced" scheduler
(configuration parameter), while nothing else in the critical path
is modified. One or more embodiments of the invention can also
include a developed infrastructure for logging task processing
times. Such an aspect can be needed for optimizing metrics,
builds/maintains models of job processing time estimates, and sets
minimum slots of new jobs to 1.
[0046] FIG. 10 is a flow diagram illustrating techniques for
scheduling one or more MapReduce jobs in a presence of one or more
priority classes, according to an embodiment of the present
invention.
[0047] Step 1002 includes obtaining a preferred ordering for one or
more MapReduce jobs, wherein the preferred ordering comprises one
or more priority classes (wherein each job belongs to a priority
class). This step can be carried out, for example, using an
enhanced FLEX scheduling module.
[0048] Step 1004 includes prioritizing the one or more priority
classes subject to one or more dynamic minimum slot guarantees for
each priority class. This step can be carried out, for example,
using a preemptive priority class allocation module. Prioritizing
the priority classes subject to one or more dynamic minimum slot
guarantees for each priority class also prevents starvation of jobs
in lower priority classes. Additionally, within the priority
classes, class minima are appropriately allocated amongst the one
or more jobs.
[0049] Step 1006 includes iteratively employing a MapReduce
scheduler, once per priority class, in priority class order, to
optimize performance of the one or more MapReduce jobs. This step
can be carried out, for example, using a non-preemptive priority
sub-class module. Iteratively employing a MapReduce scheduler, once
per priority class, in priority class order can include allocating
any additional slack slots in a cluster in an intelligent manner to
the one or more jobs.
[0050] The techniques depicted in FIG. 10 can also include
repeating the iterative process until there are no idle processors
in the MapReduce schedule or no further need for additional
allocations. Also, in one or more embodiments of the invention,
bookkeeping is performed after each iteration to provide input data
to a subsequent scheduling scheme. One or more embodiments of the
invention additionally include optimizing a scheduling metric
within one or more given constraints. Also, the techniques depicted
in FIG. 10 can include providing, via a scheduling manager
component, a revised minimum number of slots per job, wherein the
minimum is greater than or equal to an original minimum.
[0051] One or more embodiments of the invention can also include
implementing a Malleable Packing Scheme and implementing only a
first layer of malleable packing with an expectation that a revised
schedule will arrive in sufficient time. Additionally, the
techniques detailed herein also include re-optimizing performance
of the one or more MapReduce jobs when input data changes (such as,
for example, task completion, new job arrival, etc.).
[0052] The techniques depicted in FIG. 10 can also, as described
herein, include providing a system, wherein the system includes
distinct software modules, each of the distinct software modules
being embodied on a tangible computer-readable recordable storage
medium. All the modules (or any subset thereof) can be on the same
medium, or each can be on a different medium, for example. The
modules can include any or all of the components shown in the
figures. In one or more embodiments, the modules include a priority
control module, a preemptive priority class allocation module, a
non-preemptive priority subclass allocation module, and an enhanced
FLEX scheduling module that can run, for example on one or more
hardware processors. The method steps can then be carried out using
the distinct software modules of the system, as described above,
executing on the one or more hardware processors. Further, a
computer program product can include a tangible computer-readable
recordable storage medium with code adapted to be executed to carry
out one or more method steps described herein, including the
provision of the system with the distinct software modules.
[0053] Additionally, the techniques depicted in FIG. 10 can be
implemented via a computer program product that can include
computer useable program code that is stored in a computer readable
storage medium in a data processing system, and wherein the
computer useable program code was downloaded over a network from a
remote data processing system. Also, in one or more embodiments of
the invention, the computer program product can include computer
useable program code that is stored in a computer readable storage
medium in a server data processing system, and wherein the computer
useable program code are downloaded over a network to a remote data
processing system for use in a computer readable storage medium
with the remote system.
[0054] As will be appreciated by one skilled in the art, aspects of
the present invention may be embodied as a system, method or
computer program product. Accordingly, aspects of the present
invention may take the form of an entirely hardware embodiment, an
entirely software embodiment (including firmware, resident
software, micro-code, etc.) or an embodiment combining software and
hardware aspects that may all generally be referred to herein as a
"circuit," "module" or "system." Furthermore, aspects of the
present invention may take the form of a computer program product
embodied in one or more computer readable medium(s) having computer
readable program code embodied thereon.
[0055] One or more embodiments of the invention, or elements
thereof, can be implemented in the form of an apparatus including a
memory and at least one processor that is coupled to the memory and
operative to perform exemplary method steps.
[0056] One or more embodiments can make use of software running on
a general purpose computer or workstation. With reference to FIG.
11, such an implementation might employ, for example, a processor
1102, a memory 1104, and an input/output interface formed, for
example, by a display 1106 and a keyboard 1108. The term
"processor" as used herein is intended to include any processing
device, such as, for example, one that includes a CPU (central
processing unit) and/or other forms of processing circuitry.
Further, the term "processor" may refer to more than one individual
processor. The term "memory" is intended to include memory
associated with a processor or CPU, such as, for example, RAM
(random access memory), ROM (read only memory), a fixed memory
device (for example, hard drive), a removable memory device (for
example, diskette), a flash memory and the like. In addition, the
phrase "input/output interface" as used herein, is intended to
include, for example, one or more mechanisms for inputting data to
the processing unit (for example, mouse), and one or more
mechanisms for providing results associated with the processing
unit (for example, printer). The processor 1102, memory 1104, and
input/output interface such as display 1106 and keyboard 1108 can
be interconnected, for example, via bus 1110 as part of a data
processing unit 1112. Suitable interconnections, for example via
bus 1110, can also be provided to a network interface 1114, such as
a network card, which can be provided to interface with a computer
network, and to a media interface 1116, such as a diskette or
CD-ROM drive, which can be provided to interface with media
1118.
[0057] Accordingly, computer software including instructions or
code for performing the methodologies of the invention, as
described herein, may be stored in one or more of the associated
memory devices (for example, ROM, fixed or removable memory) and,
when ready to be utilized, loaded in part or in whole (for example,
into RAM) and implemented by a CPU. Such software could include,
but is not limited to, firmware, resident software, microcode, and
the like.
[0058] A data processing system suitable for storing and/or
executing program code will include at least one processor 1102
coupled directly or indirectly to memory elements 1104 through a
system bus 1110. The memory elements can include local memory
employed during actual implementation of the program code, bulk
storage, and cache memories which provide temporary storage of at
least some program code in order to reduce the number of times code
must be retrieved from bulk storage during implementation.
[0059] Input/output or I/O devices (including but not limited to
keyboards 1108, displays 1106, pointing devices, and the like) can
be coupled to the system either directly (such as via bus 1110) or
through intervening I/O controllers (omitted for clarity).
[0060] Network adapters such as network interface 1114 may also be
coupled to the system to enable the data processing system to
become coupled to other data processing systems or remote printers
or storage devices through intervening private or public networks.
Modems, cable modem and Ethernet cards are just a few of the
currently available types of network adapters.
[0061] As used herein, including the claims, a "server" includes a
physical data processing system (for example, system 1112 as shown
in FIG. 11) running a server program. It will be understood that
such a physical server may or may not include a display and
keyboard.
[0062] As noted, aspects of the present invention may take the form
of a computer program product embodied in one or more computer
readable medium(s) having computer readable program code embodied
thereon. Any combination of one or more computer readable medium(s)
may be utilized. The computer readable medium may be a computer
readable signal medium or a computer readable storage medium. A
computer readable storage medium may be, for example, but not
limited to, an electronic, magnetic, optical, electromagnetic,
infrared, or semiconductor system, apparatus, or device, or any
suitable combination of the foregoing. Media block 1118 is a
non-limiting example. More specific examples (a non-exhaustive
list) of the computer readable storage medium would include the
following: an electrical connection having one or more wires, a
portable computer diskette, a hard disk, a random access memory
(RAM), a read-only memory (ROM), an erasable programmable read-only
memory (EPROM or Flash memory), an optical fiber, a portable
compact disc read-only memory (CD-ROM), an optical storage device,
a magnetic storage device, or any suitable combination of the
foregoing. In the context of this document, a computer readable
storage medium may be any tangible medium that can contain, or
store a program for use by or in connection with an instruction
execution system, apparatus, or device.
[0063] A computer readable signal medium may include a propagated
data signal with computer readable program code embodied therein,
for example, in baseband or as part of a carrier wave. Such a
propagated signal may take any of a variety of forms, including,
but not limited to, electro-magnetic, optical, or any suitable
combination thereof. A computer readable signal medium may be any
computer readable medium that is not a computer readable storage
medium and that can communicate, propagate, or transport a program
for use by or in connection with an instruction execution system,
apparatus, or device.
[0064] Program code embodied on a computer readable medium may be
transmitted using any appropriate medium, including but not limited
to wireless, wireline, optical fiber cable, radio frequency (RF),
etc., or any suitable combination of the foregoing.
[0065] Computer program code for carrying out operations for
aspects of the present invention may be written in any combination
of one or more programming languages, including an object oriented
programming language such as Java, Smalltalk, C++ or the like and
conventional procedural programming languages, such as the "C"
programming language or similar programming languages. The program
code may execute entirely on the user's computer, partly on the
user's computer, as a stand-alone software package, partly on the
user's computer and partly on a remote computer or entirely on the
remote computer or server. In the latter scenario, the remote
computer may be connected to the user's computer through any type
of network, including a local area network (LAN) or a wide area
network (WAN), or the connection may be made to an external
computer (for example, through the Internet using an Internet
Service Provider).
[0066] Aspects of the present invention are described herein with
reference to flowchart illustrations and/or block diagrams of
methods, apparatus (systems) and computer program products
according to embodiments of the invention. It will be understood
that each block of the flowchart illustrations and/or block
diagrams, and combinations of blocks in the flowchart illustrations
and/or block diagrams, can be implemented by to computer program
instructions. These computer program instructions may be provided
to a processor of a general purpose computer, special purpose
computer, or other programmable data processing apparatus to
produce a machine, such that the instructions, which execute via
the processor of the computer or other programmable data processing
apparatus, create means for implementing the functions/acts
specified in the flowchart and/or block diagram block or
blocks.
[0067] These computer program instructions may also be stored in a
computer readable medium that can direct a computer, other
programmable data processing apparatus, or other devices to
function in a particular manner, such that the instructions stored
in the computer readable medium produce an article of manufacture
including instructions which implement the function/act specified
in the flowchart and/or block diagram block or blocks.
[0068] The computer program instructions may also be loaded onto a
computer, other programmable data processing apparatus, or other
devices to cause a series of operational steps to be performed on
the computer, other programmable apparatus or other devices to
produce a computer implemented process such that the instructions
which execute on the computer or other programmable apparatus
provide processes for implementing the functions/acts specified in
the flowchart and/or block diagram block or blocks.
[0069] The flowchart and block diagrams in the figures illustrate
the architecture, functionality, and operation of possible
implementations of systems, methods and computer program products
according to various embodiments of the present invention. In this
regard, each block in the flowchart or block diagrams may represent
a module, component, segment, or portion of code, which comprises
one or more executable instructions for implementing the specified
logical function(s). It should also be noted that, in some
alternative implementations, the functions noted in the block may
occur out of the order noted in the figures. For example, two
blocks shown in succession may, in fact, be executed substantially
concurrently, or the blocks may sometimes be executed in the
reverse order, depending upon the functionality involved. It will
also be noted that each block of the block diagrams and/or
flowchart illustration, and combinations of blocks in the block
diagrams and/or flowchart illustration, can be implemented by
special purpose hardware-based systems that perform the specified
functions or acts, or combinations of special purpose hardware and
computer instructions.
[0070] It should be noted that any of the methods described herein
can include an additional step of providing a system comprising
distinct software modules embodied on a computer readable storage
medium; the modules can include, for example, any or all of the
components shown in FIG. 6. The method steps can then be carried
out using the distinct software modules and/or sub-modules of the
system, as described above, executing on one or more hardware
processors 1102. Further, a computer program product can include a
computer-readable storage medium with code adapted to be
implemented to carry out one or more method steps described herein,
including the provision of the system with the distinct software
modules.
[0071] In any case, it should be understood that the components
illustrated herein may be implemented in various forms of hardware,
software, or combinations thereof; for example, application
specific integrated circuit(s) (ASICS), functional circuitry, one
or more appropriately programmed general purpose digital computers
with associated memory, and the like. Given the teachings of the
invention provided herein, one of ordinary skill in the related art
will be able to contemplate other implementations of the components
of the invention.
[0072] The terminology used herein is for the purpose of describing
particular embodiments only and is not intended to be limiting of
the invention. As used herein, the singular forms "a," "an" and
"the" are intended to include the plural forms as well, unless the
context clearly indicates otherwise. It will be further understood
that the terms "comprises" and/or "comprising," when used in this
specification, specify the presence of stated features, integers,
steps, operations, elements, and/or components, but do not preclude
the presence or addition of one or more other features, integers,
steps, operations, elements, components, and/or groups thereof.
[0073] The corresponding structures, materials, acts, and
equivalents of all means or step plus function elements in the
claims below are intended to include any structure, material, or
act for performing the function in combination with other claimed
elements as specifically claimed. The description of the present
invention has been presented for purposes of illustration and
description, but is not intended to be exhaustive or limited to the
invention in the form disclosed. Many modifications and variations
will be apparent to those of ordinary skill in the art without
departing from the scope and spirit of the invention. The
embodiment was chosen and described in order to best explain the
principles of the invention and the practical application, and to
enable others of ordinary skill in the art to understand the
invention for various embodiments with various modifications as are
suited to the particular use contemplated.
[0074] At least one embodiment of the invention may provide one or
more beneficial effects, such as, for example, scheduling MapReduce
jobs in the presence of priority classes.
[0075] It will be appreciated and should be understood that the
exemplary embodiments of the invention described above can be
implemented in a number of different fashions. Given the teachings
of the invention provided herein, one of ordinary skill in the
related art will be able to contemplate other implementations of
the invention. Indeed, although illustrative embodiments of the
present invention have been described herein with reference to the
accompanying drawings, it is to be understood that the invention is
not limited to those precise embodiments, and that various other
changes and modifications may be made by one skilled in the
art.
* * * * *