Adaptive scheduling with parallelism feedback

Abstract

Multiprocessor scheduling in a shared multiprogramming environment is often structured as two-level scheduling, where a kernellevel job scheduler allots processors to jobs and a user-level task scheduler schedules the work of a job on the allotted processors. In this context, the number of processors allotted to a particular job may vary during the job's execution, and the task scheduler must adapt to these changes in processor resources. For overall system efficiency, the task scheduler should also provide parallelism feedback to the job scheduler to avoid the situation where a job is allotted processors that it cannot use productively.We present an adaptive task scheduler for multitasked jobs with dependencies that provides continual parallelism feedback to the job scheduler in the form of requests for processors. Our scheduler guarantees that a job completes near optimally while utilizing at least a constant fraction of the allotted processor cycles. Our scheduler can be applied to schedule data-parallel programs, such as those written in High Performance Fortran (HPF), *Lisp, C*, NESL, and ZPL.Our analysis models the job scheduler as the task scheduler's adversary, challenging the task scheduler to be robust to the system environment and the job scheduler's administrative policies. For example, the job scheduler can make available a huge number of processors exactly when the job has little use for them. To analyze the performance of our adaptive task scheduler under this stringent adversarial assumption, we introduce a new technique called "trim analysis," which allows us to prove that our task scheduler performs poorly on at most a small number of time steps, exhibiting nearoptimal behavior on the vast majority.To be precise, suppose that a job has work T1 and critical-path length T∞ and is running on a machine with P processors. Using trim analysis, we prove that our scheduler completes the job in O(T1/ P + T∞ + L lg P ) time steps, where L is the length of a scheduling quantum and P denotes the O(T∞ + L lg P )-trimmed availability. This quantity is the average of the processor availabilThis research was supported in part by the Singapore-MIT Alliance and NSF Grant ACI-0324974. Yuxiong He is a Visiting Scholar at MIT CSAIL and a Ph.D. candidate at the National University of Singapore. Wen Jing Hsu is a Visiting Scientist at MIT CSAIL and Associate Professor at Nanyang Technological University.Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. ity over all time steps excluding the O(T∞ + L lg P ) time steps with the highest processor availability. When T1/T∞ P (the job's parallelism dominates the O(T∞ + L lg P )-trimmed availability), the job ach...

Improved results for scheduling batched parallel jobs by using a generalized analysis framework

“…Throughout this paper, in order to focus on the general framework and to simplify its analysis, we assume that the length of the scheduling quantum is chosen to be the execution time of a unitsize task, that is, the processors are reallocated after each time step. As has been shown in [1,21], we can also apply the same analysis to the more general case, where the length of the scheduling quantum can take an arbitrary number of time steps. Moreover, in order for the OS allocator to allocate processors more efficiently, the task scheduler at the user level can provide feedback to the OS allocator at the end of each time step indicating the job's processor desire for the next step.…”

“…In this section, we describe an adaptive scheduling architecture [1,21], where the scheduling of parallel jobs is divided into two distinct levels. At the system level, an OS allocator decides the processor allocations for all jobs in the system, and a task scheduler for each job at the user level schedules the tasks of the job with the allotted processors.…”

“…At any time t, a job J i scheduled by the XY algorithm can be characterized by a certain property, which usually indicates the relationship between the processor allotment and the parallelism of the job at time t, or the execution status of the job, etc. Our analysis relies on identifying two properties A and B for the active jobs at any time, 1 where a job is said to be active at time t if it is not yet completed by t. Let J(t) denote the set of all active jobs at time t. Then the set of active jobs that satisfy property A is denoted as J A (t) and the set of active jobs that satisfy property B is denoted as J B (t). The two sets J A (t) and J B (t) need not be disjoint, but they usually cover the whole set of jobs…”

“…Adaptive Greedy (AG) task scheduler [1] estimates a job's processor desire for a time step based on the execution characteristics of the job in the previous step, namely whether the processor desire has been satisfied and whether the allotted processors have been efficiently utilized. Specifically, let u(J i , t) denote the work completed by AG on time step t. Then AG calculates the processor desire d(J i , t) for any step t > 1 with a multiplicative-increase multiplicative-decrease (MIMD) strategy as follows: The processor desire for the very first step is set to the total number of processors P, i.e., d(J i , 1) = P. Unlike IG task scheduler, AG is not utilizing the instantaneous parallelism of the job and hence is non-clairvoyant, which is desirable if information about the job's instantaneous parallelism is difficult to obtain.…”

“…However, the same analysis can be applied to other job models as well, such as parallelism profiles and multiple phases of speedup functions, etc. We choose to present the algorithms using a common two-level adaptive scheduling architecture [1,19,21], where the scheduling of jobs is explicitly divided into two separate levels. At the system level, an OS allocator decides the processor allocations for the jobs, and at the user level a task scheduler schedules each job with the allotted processors.…”