Resilient Scheduling of Moldable Parallel Jobs to Cope With Silent Errors

Abstract

We study the resilient scheduling of moldable parallel jobs on highperformance computing (HPC) platforms. Moldable jobs allow for choosing a processor allocation before execution, and their execution time obeys various speedup models. The objective is to minimize the overall completion time of the jobs, or the makespan, when jobs can fail due to silent errors and hence may need to be re-executed after each failure until successful completion. Our work generalizes the classical scheduling framework for failure-free jobs. To cope with silent errors, we introduce two resilient scheduling algorithms, Lpa-List and Batch-List, both of which use the List strategy to schedule the jobs. Without knowing a priori how many times each job will fail, Lpa-List relies on a local strategy to allocate processors to the jobs, while Batch-List schedules the jobs in batches and allows only a restricted number of failures per job in each batch. We prove new approximation ratios for the two algorithms under several prominent speedup models (e.g., roofline, communication, Amdahl, power, monotonic, and a mixed model). An extensive set of simulations is conducted to evaluate different variants of the two algorithms, and the results show that they consistently outperform some baseline heuristics. Overall, our best algorithm is within a factor of 1.6 of a lower bound on average over the entire set of experiments, and within a factor of 4.2 in the worst case.

Online Scheduling of Moldable Task Graphs under Common Speedup Models

“…We have recently investigated the problem of scheduling independent moldable tasks subject to failures [3], where tasks need to be re-executed after a failure until a successful completion. This corresponds to a semi-online setting, since all tasks are known at the beginning, but failed tasks are only discovered on-the-fly.…”

“…It consists of two steps. The first step performs an initial allocation for the task, which is inspired by the Local Processor Allocation (LPA) strategy proposed in [2], [3]. Specifically, for each possible allocation p ∈ [1, p max j ], we define the ratio between the area of the task and the minimum area to be α p = a j (p)/a min j , and the ratio between the execution time of the task and the minimum execution time to be β p = t j (p)/t min j .…”

“…It consists of two steps. The first step performs an initial allocation for the task, which is inspired by the local processor allocation strategy proposed in [5,6]. Specifically, for each possible allocation p ∈ [1, p max j ], we define the following:…”

“…We first outline an analysis framework, under which the competitive ratio of the proposed online algorithm will be derived for different speedup models. The framework is inspired by the analysis shown in [24,20,19] for list scheduling as well as the analysis used in [5,6] for local processor allocation. Together, the result nicely connects the makespan of the online algorithm to the lower bound (Lemma 2), thus proving the competitive ratio.…”

“…When w ′ ≤ 1, setting p = 1 also gives the minimum execution time, i.e., t(p) t min = 1. Otherwise, we have t(p) t min = f (w ′ , 1) ≤ f (6, 1) = 6 min( 62 +1, 6 3 +2) = 3 2 , since p max = 2 or p max = 3 when w ′ = 6. Case 2: 6 < w ′ ≤ 25.…”