Conference PaperPDF Available

Overbooking in Planning Based Scheduling Systems.

Overbooking in Planning Based Scheduling Systems
Georg Birkenheuer #1 , Matthias Hovestadt 2, Odej Kao 3, Kerstin Voss #4
#Paderborn Center for Parallel Computing,
at Paderborn
urstenallee 11, 33102 Paderborn, Germany
Technische Universit¨
at Berlin
Einsteinufer 17, 10587 Berlin, Germany
Nowadays cluster Grids encompass many cluster sys-
tems with possible thousands of nodes and processors, of-
fering compute power that was inconceivable only a few
years ago. For attracting commercial users to use these en-
vironments, the resource management systems (RMS) have
to be able to negotiate on Service Level Agreements (SLAs),
which are defining all service quality requirements of such
a job, e.g. deadlines for job completion. Planning-based
scheduling seems to be well suited to guarantee the SLA
adherence of these jobs, since it builds up a schedule for the
entire future resource usage. However, it demands the user
to give runtime estimates for his job. Since many users are
not able to give exact runtime estimates, it is common prac-
tice to overestimate, thus reducing the number of jobs that
the system is able to accept. In this paper we describe the
potential of overbooking mechanisms for coping with this
Keywords: Grid-Scheduling, Overbooking, Resource
Management, SLA
1 Introduction
Grid Computing is providing computing power for sci-
entific and commercial users. Following the common evo-
lution in computer technology, the system and network per-
formance have constantly increased. The latest step in this
The authors would like to thank the EU for partially supporting this
work within the 6th Framework Programme under contract IST-031772
Advanced Risk Assessment and Management for Trustable Grids (As-
process was the introduction of multiple cores per proces-
sor, making Grid nodes even more powerful. This evolu-
tionary process particularly affects the scheduling compo-
nents of resource management systems that are used for
managing cluster systems. On the one hand, the increas-
ing number of nodes, processors, and cores results in an
increased degree of freedom for the scheduler, since the
scheduler has more options of placing jobs on the nodes
(and cores) of the system. On the other hand, also the re-
quirements of users have changed. Commercial users ask
for contractually fixed service quality levels, e.g. the ad-
herence of deadlines. Hence, the scheduler has to respect
additional constraints at scheduling time.
Queuing is a technique used in many currently avail-
able resource management systems, e.g. PBS [1], Load-
Leveler [2], Grid Engine [3], LSF [4], or Condor [5]. Since
queueing-based RMS only plan for the present, it is hard to
provide guarantees on future QoS aspects.
Planning-based RMS make functionalities like advance
reservations trivial to implement. If a new job enters the
system, the scheduling component of the RMS tries to place
the new job into the current system schedule, taking aspects
like project-specific resource usage limits, priorities, or ad-
ministrative reservations into account. In planning-based
systems it is mandatory for the user to specify the runtime
of his job. If thinking of the negotiation of Service Level
Agreements, this capability is essential for the provider’s
decision making process. As an example, using fixed reser-
vations, specific resources can be reserved in a fixed time
interval. In addition to plain queuing, the Maui [6] sched-
uler also provides planning capabilities. Few other RMS
like OpenCCS [7] have been developed as planning-based
systems from scratch.
However, (fixed) reservations in planning-based systems
potentially result in a high level of fragmentation of the
system schedule, preventing the achievement of optimal re-
source utilization and workload. Moreover, users tend to
overestimate the runtime of their jobs, since a planning-
based RMS would terminate jobs once their user-specified
runtime has expired. This termination is mandatory, if suc-
ceeding reservations are scheduled for being executed on
these resources. Overestimation of job runtime inherits an
earlier availability of assigned resources as expected by the
scheduler, i.e. at time trinstead of tp. Currently, mecha-
nisms like backfilling with new jobs or rescheduling (start,
if possible, an already planned job earlier) are initiated to
fill the gap between trand the planned start time tstpof
the succeeding reservation. Due to conflicts with the earli-
est possible execution time, moving of arbitrary succeeding
jobs to an earlier starting time might not be possible. In par-
ticular the probability to execute a job earlier might be low
if users have strict time intervals for the job execution since
a planning-based scheduler rejects job requests which can-
not be planned according to time and resource constraints
in the schedule. An analysis of cluster logfiles revealed
that users overestimated the runtime of their jobs by a fac-
tor of two to three [8]. For the provider this might result
in a bad workload and throughput, since computing power
is wasted if backfilling or rescheduling cannot start other
jobs earlier as initially planned. To prevent poor utilization
and throughput, overbooking has proven its potential in var-
ious fields of application for increase the system utilization
and provider’s profit. As a matter of fact, overbooking re-
sults in resource usage conflicts if the user-specified runtime
turns out to be realistic, or if the scheduler is working with
an overestimation presumption that is too high. To com-
pensate such situations, the suspension and later restart of
jobs are important instruments of the RMS. To suspend a
running job and without losing already performed compu-
tation steps, the RMS makes a snapshot of the job, i.e. stor-
ing the job process environment (including memory, mes-
sages, registers, and program counter), to be able to mi-
grate them to another machine or to restart them at a later
point of time. In the EC-funded project HPC4U [9] the nec-
essary mechanisms have been integrated in the planning-
based RMS OpenCCS to generate checkpoints and migrate
jobs. These fault-tolerance mechanisms are the basis for
a profitable overbooking approach as presented in this pa-
per since stopping a job does not imply losing computation
steps performed. Hence, gaps between advance reserva-
tions can be used from jobs, which will be finished before
the next reservation has to be started. In the next section
we discuss the related work followed by our ideas for over-
booking, which are described in Section 3. In Section 4 we
conclude the paper with a summary of our ideas and pre-
senting plans for future work.
2 Related Work
The idea of overbooking resources is a standard ap-
proach in many fields of application like in flight, hospi-
tal, or hotel reservations. Overbooking beds, flights, etc.
is a consequence of that a specific percentage of reserva-
tions are not occupied, i.e. usually more people reserve ho-
tel rooms [10] or buy flight tickets [11, 12] than actually
appearing to use their reservation. The examples of hotels
and aeronautical companies show the idea we are following
also in the provisioning of compute resources. Overbooking
in the context of computing Grids slightly differs from those
fields of applications since therein the assumption is made
that less customers utilize their reservations than booked.
In Grid computing all jobs that have been negotiated will be
executed, however, in planning-based systems users signif-
icantly overestimate the job duration. Comparing the usage
of a compute resource and a seat in an aircraft is not mean-
ingful since generally in computing Grids no fixed intervals
for the resource utilization exist whereas a seat in an air-
craft will not be occupied after the aircraft had taken off.
As a consequence, results and observations from overbook-
ing in the classical fields of applications cannot be reused in
Grid scheduling. As a non-classical field of application [13]
presents an overbooking approach for web platforms, how-
ever, the challenges also differ from the Grid environment.
In the Grid context, consider overbooking approaches is
most sensible for planning based scheduling since in queu-
ing based systems even the runtime have to be estimated
and thereby an additional uncertainty has to be taken into
account. Other work concerning overbooking in Grid or
HPC environments is rare. In the context of Grid or HPC
scheduling the benefits of using overbooking are pointed
out, but no solutions are provided [14, 15]. Overbooking
is also foreseen in a three layered protocol for negotiation
in Grids [16]. Here, the restriction is made that overbooking
is only used for multiple reservations for workflow sub-jobs
which were made by the negotiation protocol for optimal
workflow planning.
2.1 Planning Approaches
Some work had been done in the scope of planning al-
gorithms. Before showing in Section 3 how overbooking
can be integrated, different approaches already developed
are described in the following.
2.1.1 Geometry based approaches
Theoretical approaches for planning-based systems identify
that the scheduling is a special case of bin packing: the
width of a bin is defined as the number of nodes generally
available and its height equals the time the resource can be
used. As the total usage time for an arbitrary number of jobs
does not end, the height of the bin is infinite. Consequently
it is not a bin, rather defined as a strip. Jobs are considered
as rectangles having a width equal to the number of required
nodes and a height equal to the execution time determined
by the user. The rectangles have to be positioned in the
strip in such a way that the distances between rectangles in
the strip are minimal and the jobs must not overlap them-
selves. Since strip packing is an NP-hard problem, several
algorithms have been developed which work with heuris-
tics and are applicable in practice. Reference [17] gives a
good overview of strip packing algorithms. Two kinds, on-
line and offline, of strip packing algorithms are differed. An
offline algorithm has information about all jobs to be sched-
uled a priori whereas an online algorithms cannot estimate
which jobs arrive in future. It is obvious that offline algo-
rithms can achieve better utilization results since all jobs
are known and can be scheduled by comparing among each
other. The approaches could be divided into several main
areas: Bottom-left algorithms which try to put a new job as
far to the bottom of the strip and as left as possible, level-
oriented algorithms [18], split algorithms [18], shelf algo-
rithms [19], and hybrid algorithms which are combinations
of the above mentioned ones.
2.1.2 Planning for Clusters
In practice, most planning based systems use first-come
first-serve (FCFS) approaches. Grid scheduling has to
use an online algorithm and consequently planning optimal
schedules is not possible. The job is scheduled as soon as
possible according to the current schedule (containing all
jobs previously scheduled) as well as its resource and time
constraints. The FCFS approach might lead to gaps which
could be prevented if jobs would have scheduled in a dif-
ferent order. To increase the system utilization, backfilling
[20] had been introduced to avoid such problems. Conser-
vative Backfilling follows the objective to fill free gaps in
the scheduled produced by FCFS planning without delay-
ing any previously planned job. Simulations show that the
overall utilization of systems is increased using backfilling
strategies. If effects/delays of not started jobs are accept-
able, the more aggressive EASY backfilling [21] can further
improve the system utilization. However, [22] shows that
for systems with high load the EASY approach is not bet-
ter than the conservative backfilling. Furthermore, EASY
backfilling has to be used with caution in systems guaran-
teeing QoS aspects since delays of SLA bound jobs might
lead to SLA violations implying penalties.
Concluding, there is much work done in the scope of
planning based scheduling. Good resource utilization in
Grid systems can be achieved by using backfilling. How-
ever, applying conservative backfilling does not result in
a 100% workload since only gaps can be assigned to jobs
whose duration is less than the gap length. The more ag-
gressive EASY backfilling strategy does not necessarily
provide a better utilization of the system and implies haz-
ards for SLA provisioning. Combining conservative back-
filling with overbooking should further increase the system
utilization and does not affect the planned schedule. Con-
sequently, using these strategies combined has no disadvan-
tages for not overbooked jobs and offers the possibility to
schedule more jobs than with a simple FCFS approach.
3 Planning-Based Scheduling and Overbook-
This chapter explains the basic ideas to use overbook-
ing in planning-based HPC systems. A user sends an
SLA bound job request to the system. The SLA defines
job type (batch or interactive), number rof resources re-
quired, estimated runtime d, as well as an execution win-
dow [tstart, tend ], i.e. earliest start-time and latest comple-
tion time. The planning-based system can determine before
agreeing the SLA whether it is possible to execute the job
according to time and resource constraints.
Fixed Reservations Planning-based scheduling is espe-
cially beneficial if users are allowed to define time-slots
(r, h)in the SLA for interactive sessions, i.e. reserving
compute nodes and manually start (multiple) jobs during
the valid reservation time. The difference from an inter-
active session and a usual advance reservation is that the
reservation duration equals tend tstart. For example
r= 32 nodes should be reserved from h= [11.12.08 :
900,11.12.08 : 1400 ]for a duration of h= 5 hours. Such
so called interactive or fixed reservations increase the dif-
ficulty of the planning mechanism as these are fixed rect-
angles in the plan and cannot be moved. This will have
worse effects on the system utilization than planning only
advance reservations less strict timed. Consequently, sup-
porting fixed reservations step up the demand for additional
approaches like overbooking to ensure a good system uti-
lization. However, such fixed reservations appreciate the
value of using Grid computing for end-users if these have
either interactive applications or need to run simulations ex-
actly on-time, like for example for presentations.
For example, a resource management system (RMS) op-
erates a cluster with 32 nodes and the typical jobs scheduled
need 32 nodes and run 5 hours. During the day researchers
make two fixed reservations from 9am to 2pm and from
2pm to 7pm. All other jobs are scheduled as batch jobs.
In this scenario during the night, in the 14 hours between
the fixed reservations, only two 5 hours batch jobs could be
scheduled since these could be totally completed. Conse-
quently, the cluster would be idle for 4 hours. To achieve
a better system utilization, either the user has to shift the
fixed reservations one hour every day. Since this not feasi-
ble because of working-hours, assuming that the batch jobs
finishes after 4 hours and 30 minutes enables to overbook
resources and execute the three batch jobs.
3.1 Overbooking
Overbooking benefits from the fact that users overesti-
mate their jobs’ runtime. Consequently their jobs finish be-
fore the jobs’ planned completion time. Taking advantage
of this observation will increase the system utilization and
thereby the provider’s profit.
This section shows the process of integrating overbook-
ing in planning-based systems following conservative back-
filling as basic scheduling strategy. At first, aspects are
highlighted which have to be considered when declaring
jobs as usable for overbooking. Afterwards the overbooking
algorithm is described which is followed by remarks con-
cerning fault-tolerance mechanisms, which should prevent
job losses in case of wrong estimations of actual runtime
made. An example forms the end of this section.
3.1.1 Runtime-Estimations for Overbooking
The prevention of job losses caused by overbooking is one
important task of the scheduler. Further, good predictions
of the overestimated runtime forms the key factors for prof-
itable overbooking.
On the first glance, users overestimate the job duration
in average by two to three times of the actual runtime [8].
Unfortunately, job traces show that the distribution of the
overestimation seems to be uniform [22] and depending on
the trace, 15% to nearly 30% of jobs are underestimated
and have to be killed in planning-based systems after the
planned completion time. Obviously, more not completed
jobs could be killed when using overbooking. For instance,
using the average value of overestimation from the statisti-
cal measure (which is 150% up to 500%) in scope of over-
booking would lead to conflicts since half of the jobs would
be killed. Instead of exhausting overestimation to their full
extend, it will be more profitable to balance between the risk
of a too high overestimation and the opportunity to schedule
an additional job. Hence, it might be often beneficial to not
subtract the average overestimated runtime from the esti-
mated one in order to use this additional time for overbook-
ing. In many cases only using 10% of the overestimation
can be sufficient. Given a uniform distribution, this would
force 10% of the overbooked jobs to be lost, but 90% would
be finished and increase the utilization. These in addition
to the default strategy executed jobs increase the providers
profit. To use good predictions of the overestimated run-
time, historical observations on the cluster and of the users
are necessary. A detailed analysis has to be performed about
the functional behavior of the runtime since an average or
median value is not as meaningful as needed for reducing
the risk for the provider to cause job losses. If enough mon-
itoring data is available, the following question arises: How
can statistical information about actual job runtime be used
to effectively overbook machines? The answer is to ana-
lyze several different aspects. First of all, a user-oriented
analysis has to be performed since users often utilize com-
puting Grids for tasks in their main business/ working area
which results in submitting same applications with similar
input again and again [23, 24]. Consequently, analyzing es-
timated and actual runtime should whether and how much
overestimations are made. If the results show that a user
usually overestimates the runtime by factor x, the scheduler
can use xo< x of the overestimated time as a time-frame
for overbooking. If the statistical analysis shows, that the
user made accurate estimations, the scheduler should not
use her jobs for overbooking. If the user underestimates
the runtime the scheduler might even plan more time to
avoid job-kills at the end of the planned execution time. An
application-oriented statistical analysis of monitoring data
should be also performed in order to identify correlations of
overestimations and a specific application. Performed stud-
ies show, that automatically determined runtime estimations
based on historical information (job traces) can be better
than the user’s estimation [25, 26, 27]. The condition for
its applicability is that enough data is available. In addition
to these separated foci, a third analysis should combine the
user-oriented and application-oriented approach in order to
identify whether specific users over- or underestimate the
runtime when using a specific application. This analysis
should result in valuable predictions.
3.1.2 Algorithmic Approach
This paragraph provides the algorithmic definition of the
scheduling strategy for conservative backfilling with over-
booking. When a new job jwith estimated duration d, num-
ber of nodes n, and execution window [tstart, tend]arrives
in the system, the following algorithm is used inserting the
request into the schedule which has anchor point tswhere
resources become available and points where such slots end
1. Select, if available, statistical information about the
runtime of the application and the runtime estimation
of the user. Compare them with the given runtime for
the new job j. If
the estimated runtime dis significant longer than
the standard runtime of the application
or the user is tending to overestimate the runtime
of jobs
then mark the application as promising for
overbooking. Assuming a uniform distribu-
tion, the duration of the job dcan be adjusted
to d0=d
1+maxPoF where maxP oF is the
maximum acceptable probability of failure.
The time interval oj=dd0can be used
for overbooking.
else the job should not be used for overbooking
d0=d, oj= 0.
2. Find starting point tsfor job j, set tsas anchor point:
Scan the current schedule and find the first point
tststart where enough processors are avail-
able to run this job.
Starting from this point, check whether ts+d
tend and if this is valid, continue scanning the
schedule to ascertain that these processors re-
main available until the job’s expected termina-
tion ts+dtendslot.
If not,
check validity of ts+d0tend and
whether the processors remain available un-
til the job’s expected termination reduced
by the time usable for overbooking ts+
d0tendslot. If successful, mark the job
as overbooked and set the job duration d0=
tendslot ts.
It not, check, if there are direct predecessors
in the plan, which are ending at tsand are
usable for overbooking. Then reduce tsby
the time a= mink{ok}of those jobs kand
try again. tsa+d0tendslot. (In this case,
other jobs are also overbooked; nevertheless
their runtime is not reduced. If they do not
finish earlier than excepted, they can still fin-
ish and the overbooked job will be started
after their initially planned completion.) If
successful, mark the job as overbooked and
set the job duration d0=tendslot (tsa).
If overbooking was not possible, return and con-
tinue the scan to find the next possible anchor
3. Update the schedule to reflect the allocation of rpro-
cessors by this job jwith the duration d0for the reser-
vation h= [ts, min(tendslot, ts+d)], starting from its
anchor point ts, or earlier tsa.
4. If the job’s anchor is the current time, start it immedi-
The algorithm defines that a job kwhich was overbooked
by a job jshould be resumed until its completion or its
planned completion time if it had not finished at time tsa.
Considering SLA bound jobs, this might be doubtful if ful-
filling the SLA of job jwould be more profitable than of
job k. However, the reservation duration of job kis only
reduced after curtaining the duration of job j. Hence, the
provider has no guarantee that the SLA of job jwould be
not violated if stopping the job execution of job k. Conse-
quently, the scheduler should act conservatively and provide
for job kthe resources as required and prevent an SLA vio-
lation of job k.
3.1.3 Checkpointing and Migration
By using overbooking the likelihood of conflicts increases
and consequently the need of preventing job losses becomes
more important. Which contractor (end-user or provider)
has to pay the penalty in case of a not completed job de-
pend on the responsibilities. In conservative planning-based
systems, the user is responsible for an underestimated run-
time of a job. Hence, if the job is killed after providing re-
sources for the defined runtime, the provider does not care
about saving the results. The provider is responsible if it
the requested resources have not been available for the re-
quested time. Hence, violating an SLA caused by overbook-
ing results in that the provider has to pay the penalty fee.
If the scheduler overbooked a schedule with a job which is
planned for less than the user’s estimated runtime and has to
be killed/ dispatched for another job, the provider is respon-
sible since resources had not been available as agreed. The
RMS can prevent such conflicts by using the fault-tolerance
mechanisms checkpointing and migration [9]. If the exe-
cution time had been shortened by the RMS, at the end of
the reservation a checkpoint can be generated of the job, i.e.
making a snapshot of its memory, messages, the registers,
and program counter. The checkpoint can be stored in a file
system available in the network. This allows to restart the
not completed job in the next free gap before the job lat-
est completion time. To be efficient, the free gap should be
at least as long as the remaining estimated runtime. Note
that filling gaps by partly executing jobs should not be a
general strategy since checkpointing and migration requires
resources and result in additional costs for the job execu-
tion. As result, planning with checkpointing and migration
allow pre-emptive scheduling of HPC systems.
3.1.4 Example
To exemplify the approach, in the following a possible over-
booking procedure is explained. Assume a Grid cluster
with Xnodes, each job on the cluster will be assigned
to the same fixed reservations with a duration of 5 hours
[700 1200,1200 1700 ]. Assume further that the fixed
and some usual advance reservations are already scheduled,
directly beneath each other. Thus, the resources are oc-
cupied for 20 hours of the schedule: [700 1200,1200
1700,1700 2100 ,2100 300]. This schedule is the same
every day in the week considered. Then another job jwith
h= 5 hour reservation for Xnodes should be inserted in
the schedule in the next two days. However, the resources
are only free for 4 hours [300 700]! Consequently, the
scheduler has to reject the job request, in case it cannot
overbook the schedule 300 + 5 hours = 800 ¬ ≤ 700 .
We assume that the scheduler has statistics about the esti-
mated and actual runtimes of applications. and users that
propound an overestimation by 40%. Assume the sched-
uler can takeo=dd0of the statistic over-estimated run-
time of a job for overbooking, let the maximum PoF be
maxP oF = 13%. For a five-hour job these are 34 minutes.
(As h= 5 hours = 300 minutes and maxPoF = 0,13
1+maxPoF =300
1,13 265,5minutes o=dd0=
300 minutes 266 minutes = 34 minutes .) If we over-
book the advance reservation hfor 34 minutes, the sched-
ule is still not feasible (300 +4:26 hours = 726 ¬ ≤ 700 )
since the gap is only 4 hours and jwould be given a run-
time of 4 hours and 26 minutes. If the predecessor is also
overbooked by 34 minutes, each job is reduced by half an
hour and reservation hcan be accepted (300 0:34 hours)+
4:26 hours = 652 700 . Thus the job jwith an user esti-
mated runtime d= 5 hours has a duration d0=4:26 hours
and an estimated earliest start-time from ts= 226 in the
overbooked time-slot [300 700]The complete schedule is
[700 1200,1200 1700 ,1700 2100,2100 300 ,300 700].
Note that, overbooking is possible only, if neither jitself
nor the predecessor (in case of its overbooking) is a fixed
reservation. Hence, in our example avoiding an idle time
of 4 hours can be achieved by using overbooking only, if
the job jand the reservations before [2100 300]are not
fixed. For all reservations which are not fixed, a greater
flexibility exists if the start time tsof all those jobs could
be moved forward to their earliest start time tstart, if the
jobs before are ending earlier than planned. In this case, if
the other execution times are dynamically shifted, any over-
booked reservation from the schedule could be straighten
out before execution. This approach has the big advantage
that an 1 hour overbooked reservation hcould be finished
even it would use the estimated time, if in total the prede-
cessor reservations in the schedule require all in all 1 hour
less time than estimated.
4 Conclusion and Future Work
The paper first motivated the need for Grid systems and
in common with the management of supercomputers the
advantages of planning-based scheduling for SLA provi-
sioning and fixed reservations. However, advance reserva-
tions have the disadvantage to decrease the utilization of
the computer system. Using overbooking might be a pow-
erful instrument to re-increase the system utilization and the
provider’s profit. The paper presented the concept and algo-
rithm to use overbooking. Since overbooking might lead
to conflicts because of providing resources for a shorter
time than required, fault-tolerance mechanisms are crucial.
Checkpointing and migration can be used for preventing job
losses and SLA violations and support the applicability of
overbooking in Grid systems.
Future work focus on statistical analysis of runtime and
implementing the overbooking algorithm in the backfilling
scheduling algorithms. At last we will develop a simulation
process for testing and evaluating how much overbooking
increases the system utilization and provider’s profit.
[1] C. Ressources, “Torque resource man-
ager, 2008. [Online]. Available:
[2] IBM, “Loadleveler,” 2008. [On-
line]. Available: http://www-
[3] Gridengine, “Sun,” 2008. [Online]. Available:
[4] Platform, “Lfs load sharing facility,” 2008. [On-
line]. Available:
[5] “Condor, 2008. [Online]. Available:
[6] D. Jackson, Q. Snell, and M. Clement, “Core Algo-
rithms of the Maui Scheduler,Job Scheduling Strate-
gies for Parallel Processing: 7th International Work-
shop, JSSPP 2001, Cambridge, MA, USA, June 16,
2001: Revised Papers, 2001.
[7] “Openccs: Computing center software, 2008.
[Online]. Available:
[8] A. Streit, “Self-tuning job scheduling strate-
gies for the resource management of hpc sys-
tems and computational grids,” Ph.D. disserta-
tion, Paderborn Center for Parrallel Comput-
ing, 2003. [Online]. Available: http://wwwcs.uni-
[9] “Hpc4u: Introducing quality of service for grids,”, 2008.
[10] V. Liberman and U. Yechiali, “On the hotel overbook-
ing problem-an inventory system with stochastic can-
cellations,” Management Science, vol. 24, no. 11, pp.
1117–1126, 1978.
[11] J. Subramanian, S. Stidham Jr, and C. Lautenbacher,
Airline yield management with overbooking, can-
cellations, and no-shows,” Transportation Science,
vol. 33, no. 2, pp. 147–167, 1999.
[12] M. Rothstein, “Or and the airline overbooking prob-
lem,” Operations Research, vol. 33, no. 2, pp. 237–
248, 1985.
[13] B. Urgaonkar, P. Shenoy, and T. Roscoe, “Resource
overbooking and application profiling in shared host-
ing platforms,” ACM SIGOPS Operating Systems Re-
view, vol. 36, no. si, p. 239, 2002.
[14] M. Hovestadt, O. Kao, A. Keller, and A. Streit,
“Scheduling in hpc resource management systems:
Queuing vs. planning,” Job Scheduling Strategies
for Parallel Processing: 9th International Workshop,
Jsspp 2003, Seattle, Wa, Usa, June 24, 2003: Revised
Papers, 2003.
[15] A. Andrieux, D. Berry, J. Garibaldi, S. Jarvis, J. Ma-
cLaren, D. Ouelhadj, and D. Snelling, “Open Issues in
Grid Scheduling,” UK e-Science Report UKeS-2004-
03, April 2004.
[16] M. Siddiqui, A. Villaz´
on, and T. Fahringer, “Grid al-
location and reservation—Grid capacity planning with
negotiation-based advance reservation for optimized
QoS,” Proceedings of the 2006 ACM/IEEE conference
on Supercomputing, 2006.
[17] N. Ntene, “An algorithmic approach to the 2d oriented
strip packing problem,” Ph.D. dissertation.
[18] E. Coffman Jr, M. Garey, D. Johnson, and R. Tar-
jan, “Performance bounds for level-oriented two-
dimensional packing algorithms,” SIAM Journal on
Computing, vol. 9, p. 808, 1980.
[19] B. Baker and J. Schwarz, “Shelf algorithms for two-
dimensional packing problems,” SIAM Journal on
Computing, vol. 12, p. 508, 1983.
[20] D. Feitelson and M. Jette, “Improved Utilization and
Responsiveness with Gang Scheduling,Job Schedul-
ing Strategies for Parallel Processing: IPPS’97 Work-
shop, Geneva, Switzerland, April 5, 1997: Proceed-
ings, 1997.
[21] D. Lifka, “The ANL/IBM SP Scheduling System,”
Job Scheduling Strategies for Parallel Processing:
IPPS’95 Workshop, Santa Barbara, CA, USA, April
25, 1995: Proceedings, 1995.
[22] A. Mu’alem and D. Feitelson, “Utilization, pre-
dictability, workloads, and user runtime estimates in
scheduling the IBM SP 2 with backfilling,” IEEE
Transactions on Parallel and Distributed Systems,
vol. 12, no. 6, pp. 529–543, 2001.
[23] A. Downey and D. Feitelson, “The elusive goal of
workload characterization,ACM SIGMETRICS Per-
formance Evaluation Review, vol. 26, no. 4, pp. 14–
29, 1999.
[24] D. Feitelson and B. Nitzberg, “Job Characteristics of a
Production Parallel Scientific Workload on the NASA
Ames iPSC/860,” Job Scheduling Strategies for Par-
allel Processing: IPPS’95 Workshop, Santa Barbara,
CA, USA, April 25, 1995: Proceedings, 1995.
[25] R. Gibbons, “A Historical Application Profiler for Use
by Parallel Schedulers, Job Scheduling Strategies
for Parallel Processing: IPPS’97 Workshop, Geneva,
Switzerland, April 5, 1997: Proceedings, 1997.
[26] A. Downey, “Using Queue Time Predictions for
Processor Allocation,” Job Scheduling Strategies for
Parallel Processing: IPPS’97 Workshop, Geneva,
Switzerland, April 5, 1997: Proceedings, 1997.
[27] W. Smith, I. Foster, and V. Taylor, “Predicting Ap-
plication Run Times Using Historical Information,
Job Scheduling Strategies for Parallel Processing:
IPPS/SPDP’98 Workshop, Orlando, Florida, USA,
March 30, 1998: Proceedings, 1998.
... The difference is that Nissimovs acceptance test is applied to an already scheduled job and aims to reduce its slowdown, while our approach is used during the acceptance test at arrival time [24]. We have proposed our ideas for overbooking with focus on a single resource [25, 26] and are extending the algorithms and investigations for parallel resources in this work. ...
Conference Paper
The commercial exploitation of the emerging Grid and Cloud markets needs SLAs to sell computing run times. Job traces show that users have a limited ability to estimate the resource needs of their applications. This offers the possibility to apply overbooking to negotiation, but overbooking increases the risk of SLA violations. This work presents an overbooking approach with an integrated risk assessment model. Simulations for this model, which are based on real-world job traces, show that overbooking offers significant opportunities for Grid and Cloud providers.
Full-text available
M hotel rooms are available at a date n periods from now. Reservations are made by customers for that date, which is at the peak of the high season. Typically, for such a time period, a policy of overbooking is exercised by the hotel management. Customers, however, may cancel their previously confirmed reservations at any time prior to their arrival, with no penalty. On the other hand, new requests for rooms for that particular date are generated anew. At the end of each period the hotel management reviews both the "inventory" level of remaining uncanceled (previously confirmed) reservations and the total number of not-yet-confirmed new requests. At that time a decision is made regarding the inventory level of confirmed reservations with which to start the next period. A decision is one of three actions: (i) to keep the inventory at its present level (i.e., declining all new requests); (ii) to increase the level of overbooking by confirming some of the new requests and, if necessary, by trying to obtain some additional reservations (at some extra cost); (iii) to decrease the level of inventory by canceling some of the previously confirmed reservations (incurring a penalty for each such cancellation). Each occupied room at the target day carries a given profit, while each unhonored reservation at that time incurs a penalty. The problem is to find the optimal over-booking strategy that will maximize net profit. For both criteria, maximization of the expected total net profit, and maximization of the expected discounted net profit, it is shown that the optimal strategy is a 3-region policy as follows: For each period there exist upper and lower bounds and an intermediate point such that, (a) if the overbooking level at the end of a period is greater than the upper bound, it should be decreased to that bound; (b) if the inventory level is below the lower bound, two cases may occur: (i) if the discrepancy is greater than the number of new requests, all new requests should be confirmed and additional reservations should be acquired such that the inventory level will be equal to the lower bound; and (ii) if the discrepancy is smaller than the number of new requests, some of the new requests are confirmed but the inventory level may not exceed the intermediate point; (c) if the inventory level is between the two bounds there are two possibilities: (i) if it is above the intermediate point none of the new requests are confirmed, but (ii) if it is below that point, some of the new requests should be confirmed provided that the new inventory level will not exceed the intermediate point.
Conference Paper
Most commercial multicomputers use space-slicing schemes in which each scheduling decision has an unknown impact on the future: should a job be scheduled, risking that it will block other larger jobs later, or should the processors be left idle for now in anticipation of future arrivals? This dilemma is solved by using gang scheduling, because then the impact of each decision is limited to its time slice, and future arrivals can be accommodated in other time slices. This added flexibility is shown to improve overall system utilization and responsiveness. Empirical evidence from using gang scheduling on a Cray T3D installed at Lawrence Livermore National Lab corroborates these results, and shows conclusively that gang scheduling can be very effective with current technology.
We analyze several “level-oriented” algorithms for packing rectangles into a unit-width, infinite-height bin so as to minimize the total height of the packing. For the three algorithms we discuss, we show that the ratio of the height obtained by the algorithm to the optimal height is asymptotically bounded, respectively, by 2, 1.7, and 1.5. The latter two improve substantially over the performance bounds for previously proposed algorithms. In addition, we give more refined bounds for special cases in which the widths of the given rectangles are restricted and in which only squares are to be packed.
Conference Paper
The authors present a technique for deriving predictions for the run times of parallel applications from the run times of similar applications that have executed in the past. The novel aspect of the work is the use of search techniques to determine those application characteristics that yield the best definition of similarity for the purpose of making predictions. They use four workloads recorded from parallel computers at Argonne National Laboratory, the Cornell Theory Center, and the San Diego Supercomputer Center to evaluate the effectiveness of the approach.They show that on these workloads the techniques achieve predictions that are between 14 and 60% better than those achieved by other researchers; the approach achieves mean prediction errors that are between 41 and 65% of mean application run times.
Advance reservation of Grid resources can play a key role in enabling Grid middleware to deliver on-demand resource provision with significantly improved Quality-of-Service (QoS). However, in the Grid, advance reservation has been largely ignored due to the dynamic Grid behavior, under-utilization concerns, multi-constrained applications, and lack of support for agreement enforcement. These issues force the Grid middleware to make resource allocations at runtime with reduced QoS. To remedy these, we introduce a new, 3-layered negotiation protocol for advance reservation of the Grid resources. We model resource allocation as an on-line strip packing problem and introduce a new mechanism that optimizes resource utilization and QoS constraints while generating the contention-free solutions. The mechanism supports open reservations to deal with the dynamic Grid and provides a practical solution for agreement enforcement. We have implemented a prototype and performed experiments to demonstrate the effectiveness of our approach.
Conference Paper
Statistics of a parallel workload on a 128-node iPSC/860 located at NASA Ames are presented. It is shown that while the number of sequential jobs dominates the number of parallel jobs, most of the resources (measured in node-seconds) were consumed by parallel jobs. Moreover, most of the sequential jobs were for system administration. The average runtime of jobs grew with the number of nodes used, so the total resource requirements of large parallel jobs were larger by more than the number of nodes they used. The job submission rate during peak day activity was somewhat lower than one every two minutes, and the average job size was small. At night, submission rate was low but job sizes and system utilization were high, mainly due to NQS. Submission rate and utilization over the weekend were lower than on weekdays. The overall utilization was 50%, after accounting for downtime. About 2/3 of the applications were executed repeatedly, some for a significant number of times.
Conference Paper
Scheduling algorithms that use application and system knowl edge have been shown to be more effective at scheduling parallel jobs; on a multiprocessor than algorithms that do not. This paper focuses on obtaining such information for use by a scheduler in a network of workstations environment. The log files from three parallel systems are examined to determine: both how to categorize parallel jobs for storage in a job database and what job information would be useful to a scheduler. A Historical Profiler is proposed that stores information about programs and users, and manipulates this information to provide schedulers with execution time predictions. Several preemptive and non-preemptive versions of the FCFS, EASY and Least Work First scheduling algorithms are compared to evaluate the utility of the profiler. It is found that both preemption and the use of application execution time predictions obtained fi om the Historical Profiler lead to improved performance.