Improved Approximations for Multiprocessor Scheduling Under Uncertainty

arXiv:0802.2418v2 [cs.DC] 19 Feb 2008 Improved Approximations for Multiprocessor Scheduling Under Uncertainty Christopher Crutchfield Zoran Dzunic Jeremy T. Fineman∗ David R. Karger Jacob H. Scott† Computer Science and Artificial Intelligence Laboratory Massachusetts Institute of Technology Cambridge, MA 02139, USA {cyc,zoki,jfineman,karger,jhscott}@csail.mit.edu November 17, 2021 This paper presents improved approximation algorithms for the problem of multiprocessor scheduling under uncertainty (SUU), in which the execution of each job may fail probabilisti- cally. This problem is motivated by the increasing use of distributed computing to handle large, computationally intensive tasks. In the SUU problem we are given n unit-length jobs and m ma- chines, a directed acyclic graph G of precedence constraints among jobs, and unrelated failure probabilities qij for each job j when executed on machine i for a single timestep. Our goal is to find a schedule that minimizes the expected makespan, which is the expected time at which all jobs complete. Lin and Rajaraman gave the first approximations for this NP-hard problem for the special cases of independent jobs, precedence constraints forming disjoint chains, and precedence constraints forming trees. In this paper, we present asymptotically better approximation algorithms. In particular, we give an O(log log(min{m, n}))-approximation for independent jobs (improving on the previously best O(log n)-approximation). We also give an O(log(n + m) log log(min{m, n}))- approximation algorithm for precedence constraints that form disjoint chains (improving on the previously best O  log(n) log(m) log(n+m) log log(n+m)  -approximation by a (log n/ log log n)2 factor when n = mΘ(1). Our algorithm for precedence constraints forming chains can also be used as a component for precedence constraints forming trees, yielding a similar improvement over the previously best algorithms for trees. ∗Supported in part by Google, NSF Grant CSR-AES 0615215. †Supported by an NDSEG Fellowship. 1 INTRODUCTION Our work concerns approximation algorithms for multiprocessor scheduling under uncertainty, first introduced in [12]. This model extends the classical construction of machine scheduling to handle cases where machines run jobs for discrete timesteps and succeed in processing them only proba- bilistically. Our motivation stems from the increasing use of distributed computing to handle large, computationally intensive tasks. Projects like Seti@Home [1] divide computations into smaller jobs of relatively uniform length, which are then executed on unreliable machines (e.g., of volunteers). Scheduling multiple machines to process the same job at once can help overcome the problem of unreliable machines, but many machines processing a single job can also slow down overall throughput. The situation is exacerbated when precedence constraints among jobs are present, which is often the case for sophisticated computations; here a single job failing may delay the start of many others. Note that the special case of having no precedence constraints retains practical significance. Google’s MapReduce architecture [3], for example, generates jobs whose dependencies form a complete bipartite graph, which is equivalent to two phases of independent jobs. Motivated by these examples, we study the multiprocessor scheduling under uncertainty (SUU) problem. An SUU instance is comprised of a set of n unit-time jobs and a set of m machines. For each machine i and job j, we are given a failure probability qij, which is the chance that job j does not complete when run on machine i for a single timestep. Any precedence constraints are modeled as a directed acyclic graph (dag). Our objective is to construct a schedule assigning machines to eligible jobs at each timestep, minimizing the expected time until all jobs have suc- cessfully completed. In contrast to many other scheduling problems, SUU allows multiple machines to execute the same job in a single timestep. Related work Malewicz’s initial presentation of SUU [12] includes a polynomial-time dynamic-programming so- lution for instances where both the number of machines and the width of the precedence dag are constant. If either of these constraints is relaxed, he proves that the problem becomes NP-Hard. Furthermore, when both constraints are removed, there is no polynomial-time approximation al- gorithm for the problem achieving an approximation ratio lower than 5/4, unless P = NP. This work does not include approximation algorithms for the general (NP-Hard) problem. Lin and Rajaraman present the first (and, to date, only) approximation algorithms for SUU [11]. Using a greedy approximation algorithm to maximize the chance of success across all jobs, they give an O(log n)-approximation when all jobs are independent. More sophisticated techniques, including LP-rounding and random delay [9,15], yield a variety of O(poly log(n + m)) approximations when precedence graphs

…(Full text truncated)…

This content is AI-processed based on ArXiv data.