We considered non-clairvoyant multiprocessor scheduling of jobs with arbitrary arrival times and changing execution characteristics. The problem has been studied extensively when either the jobs all arrive at time zero, or when all the jobs are fully parallelizable, or when the scheduler has considerable knowledge about the jobs. This paper considers for the first time this problem without any of these three restrictions and provides new upper and lower bound techniques applicable in this more difficult scenario. The results are of both theoretical and practical interest. In our model, a job can arrive at any arbitrary time and its execution characteristics can change through the life of the job from being anywhere from fully parallelizable to completely sequential. We assume that the scheduler has no knowledge about the jobs except for knowing when a job arrives and knowing when it completes. (This is why we say that the scheduler is completely in the dark.) Given all this, we prove t...

Scheduling has been studied extensively in many varieties and from many viewpoints. Inspired by applications in practical computer systems, it developed into a theoretical area with many interesting results, both positive and negative. The basic situation we study is the following. We have some sequence of jobs that have to be processed on the machines available to us. In the most basic problem, each job is characterized by its running time and has to be scheduled for that time on one of the machines. In other variants there may be additional restrictions or relaxations specifying which schedules are allowed. We want to schedule the jobs as efficiently as possible, which most often means that the total length of the schedule (the makespan) should be as small as possible, but other objective functions are also considered. The notion of an on-line algorithm is intended to formalize the realistic scenario, where the algorithm does not have the access to the whole inp...

Abstract. We study the problem of processor scheduling for n parallel jobs applying the method of competitive analysis. We prove that for jobs with a single phase of parallelism, a preemptive scheduling algorithm without information about job execution time can achieve a mean completion time within 2 − 2 2 times the optimum. In other words, we prove a competitive ratio of 2 − n+1 n+1. The result is extended to jobs with multiple phases of parallelism (which can be used to model jobs with sublinear speedup) and to interactive jobs (with phases during which the job has no CPU requirements) to derive solutions guaranteed to be within 4 − 4 times the optimum. In comparison n+1 with previous work, our assumption that job execution times are unknown prior to their completion is more realistic, our multiphased job model is more general, and our approximation ratio (for jobs with a single phase of parallelism) is tighter and cannot be improved. While this work presents theoretical results obtained using competitive analysis, we believe that the results provide insight into the performance of practical multiprocessor scheduling algorithms that operate in the absence of complete information.

Scheduling has been studied extensively in many varieties and from many viewpoints. Inspired by applications in practical computer systems, it developed into a theoretical area with many interesting results, both positive and negative. The basic situation we study is the following. We have some sequence of jobs

This paper revisits the problem of on-line scheduling of sequential jobs with hard deadlines in a preemptive, multiprocessor setting. An on-line scheduling algorithm is said to be optimal if it can schedule any set of jobs to meet their deadlines whenever it is feasible in the off-line sense. It is known that the earliest-deadline-first strategy (EDF) is optimal in a one-processor setting, and there is no optimal on-line algorithm in an m-processor setting where m 2. Recent work [Phillips et al. stoc 97] however reveals that if the on-line algorithm is given faster processors, EDF is actually optimal for all m (e.g., when m = 2, it suffices to use processors 1.5 times as fast). This paper initiates the study of the trade-off between increasing the speed and using more processors in deriving optimal on-line scheduling algorithms. Several upper bound and lower bound results are presented. For example, the speed requirement of EDF can be reduced to 2 \Gamma 1+p m+p when it is given p ...

We investigate the use of runtime measurements to improve job scheduling on a parallel machine. Emphasis is on gang scheduling based strategies. With the information gathered at runtime, we define a task classification scheme based on fuzzy logic and Bayesian estimators. The resulting local task classification is used to provide better service to I/O bound and interactive jobs under gang scheduling. This is achieved through the use of idle times and also by controlling the spinning time of a task in the spin block mechanism depending on the node's workload. Simulation results show considerable improvements, in particular for I/O bound workloads, in both throughput and machine utilization for a gang scheduler using runtime information compared with gang schedulers for which this type of information is not available.

Abstract We present an adaptive work-stealing thread scheduler, A-STEAL, for fork-join multithreaded jobs, like those written using the Cilk multithreaded language or the Hood work-stealinglibrary. The A-STEAL algorithm is appropriate for large parallel servers where many jobs share a common multiprocessorresource and in which the number of processors available to a particular job may vary during the job's execution. A-STEALprovides continual parallelism feedback to a job scheduler in the form of processor requests, and the job must adapt its ex-ecution to the processors allotted to it. Assuming that the job scheduler never allots any job more processors than requestedby the job's thread scheduler, A-STEAL guarantees that the job completes in near-optimal time while utilizing at least a con-stant fraction of the allotted processors. Our analysis models the job scheduler as the thread sched-uler's adversary, challenging the thread scheduler to be robust to the system environment and the job scheduler's administra-tive policies. We analyze the performance of A-STEAL using "trim analysis, " which allows us to prove that our thread sched-uler performs poorly on at most a small number of time steps, while exhibiting near-optimal behavior on the vast majority.To be precise, suppose that a job has work T1 and critical-path length T1. On a machine with P processors, A-STEALcompletes the job in expected O(T1/eP + T1 + L lg P) timesteps, where L is the length of a scheduling quantum and ePdenotes the O(T1 + L lg P)-trimmed availability. This quan-tity is the average of the processor availability over all but

Abstract—Multi-core processors offer a significant performance increase over single core processors. Therefore, they have the potential to enable computation-intensive real-time applications with stringent timing constraints that cannot be met on traditional single-core processors. However, most results in traditional multiprocessor real-time scheduling are limited to sequential programming models and ignore intra-task parallelism. In this paper, we address the problem of scheduling periodic parallel tasks with implicit deadlines on multi-core processors. We first consider a synchronous task model where each task consists of segments, each segment having an arbitrary number of parallel threads that synchronize at the end of the segment. We propose a new task decomposition method that decomposes each parallel task into a set of sequential tasks. We prove that our task decomposition achieves a resource augmentation bound of 4 and 5 when the decomposed tasks are scheduled using global EDF and partitioned deadline monotonic scheduling, respectively. Finally, we extend our analysis to directed acyclic graph (DAG) task model where each node in the DAG has unit execution requirement. We show how these tasks can be converted into synchronous tasks such that the same transformation can be applied and the same augmentation bounds hold. Keywords-parallel task; multi-core processor; real-time scheduling; resource augmentation bound. I.

Abstract. In real systems, such as operating systems, the scheduler is often unaware of the remaining work in each job or of the ability of the job to take advantage of more resources. In this paper, we adopt the setting for non-clairvoyance of [3,2]. Based on the particular case of malleable jobs, it is generally assumed in the literature that “Equi never starves a job since it allocates to every job the same amount of processing power”. We provide an analysis of the competitiveness of Equi for the makespan objective which shows that under this more general setting this statement is at the same time true and false: false, because, some ln n jobs may be stretched by a factor as large as, but no more than, lnln n with respect to the optimal, where n is the size of the largest set; true, because no algorithm can achieve a better competitive ratio up to a constant factor. In this paper, we extend the results in [2,11] to the batch scheduling of sets of jobs that go through arbitrary phases: user request all together at time 0, for the execution of a set of jobs and is served when the last job completes. We prove that the algorithm Equi◦Equi is (2 + √ ln n 3+o(1))-competitive, where n is the maximum size of a lnln n set, which is optimal up to a constant factor. We provide experimental evidences that this algorithm may have the same asymptotic competitive ln n ratio Θ ( ) (independent of the number of requests) for the flowtime lnln n objective when requests have release dates, if it is given sufficiently large extra processing power with respect to the optimum.

Abstract. Multiprocessor scheduling in a shared multiprogramming environment can be structured in two levels, where a kernel-level job scheduler allots processors to jobs and a user-level thread scheduler maps the ready threads of a job onto the allotted processors. This paper presents two-level scheduling schemes for scheduling “adaptive ” multithreaded jobs whose parallelism can change during execution. The AGDEQ algorithm uses dynamic-equipartioning (DEQ) as a job-scheduling policy and an adaptive greedy algorithm (A-Greedy) as the thread scheduler. The ASDEQ algorithm uses DEQ for job scheduling and an adaptive work-stealing algorithm (A-Steal) as the thread scheduler. AGDEQ is suitable for scheduling in centralized scheduling environments, and ASDEQ is suitable for more decentralized settings. Both two-level schedulers achieve O(1)-competitiveness with respect to makespan for any set of multithreaded jobs with arbitrary release time. They are also O(1)competitive for any batched jobs with respect to mean response time. Moreover, because the length of the scheduling quantum can be adjusted to amortize the cost of context-switching during processor reallocation, our schedulers provide control over the scheduling overhead and ensure effective utilization of processors. 1