🤖 AI Summary
This paper studies the scheduling of multi-class parallelizable jobs under limited server resources to minimize average response time. Jobs are categorized by parallelizability and size distribution, and must be dynamically assigned to $k$ servers. The work first reveals that the load regime fundamentally determines the optimal policy: Least-Parallelizable-First is asymptotically optimal in the sub-Halfin–Whitt (light-load) regime, while SERPT is asymptotically optimal in the super-NDS (heavy-load) regime. Leveraging this insight, we design an adaptive policy that requires no prior knowledge of system load. Using tools from multi-class queueing theory, load-scaling analysis, and online algorithm design, we rigorously prove that each regime-specific policy achieves the fundamental lower bound on average response time. Simulation results demonstrate that the proposed adaptive strategy consistently attains near-theoretically-optimal performance across the entire load spectrum.
📝 Abstract
Many modern computing workloads are composed of parallelizable jobs. A single parallelizable job can be completed more quickly if it is run on additional servers, however each job is typically limited in the number of servers it can run on (its parallelizability level). A job's parallelizability level is determined by the type of computation the job performs and how it was implemented. As a result, a single workload of parallelizable jobs generally consists of multiple $ extit{job classes}$, where jobs from different classes may have different parallelizability levels. The inherent sizes of jobs from different classes may also be vastly different. This paper considers the important, practical problem of how to schedule an arbitrary number of classes of parallelizable jobs. Here, each class of jobs has an associated job size distribution and parallelizability level. Given a limited number of servers, $k$, we ask how to allocate the $k$ servers across a stream of arriving jobs in order to minimize the $ extit{mean response time}$ -- the average time from when a job arrives to the system until it is completed. The problem of optimal scheduling in multiserver systems is known to be difficult, even when jobs are not parallelizable. To solve the harder problem of scheduling multiple classes of parallelizable jobs, we turn to asymptotic scaling regimes. We find that in lighter-load regimes (i.e., Sub-Halfin-Whitt), the optimal allocation algorithm is Least-Parallelizable-First (LPF), a policy that prioritizes jobs from the least parallelizable job classes. By contrast, we also find that in the heavier-load regimes (i.e., Super-NDS), the optimal allocation algorithm prioritizes the jobs with the Shortest Expected Remaining Processing Time (SERPT). We also develop scheduling policies that perform optimally when the scaling regime is not known to the system a priori.