rDLB: A Novel Approach for Robust Dynamic Load Balancing of Scientific Applications with Parallel Independent Tasks

TL;DR

This paper introduces rDLB, a proactive, fault-tolerant dynamic load balancing method for scientific applications with independent tasks, significantly improving robustness and reducing execution time on HPC systems.

Contribution

The paper presents a novel proactive load balancing approach, rDLB, that does not rely on failure detection and enhances fault tolerance and performance in HPC environments.

Findings

rDLB tolerates up to (P-1) processor failures.

rDLB increases robustness by up to 30 times under perturbations.

rDLB reduces application execution time by up to 7 times.

Abstract

Scientific applications often contain large and computationally intensive parallel loops. Dynamic loop self scheduling (DLS) is used to achieve a balanced load execution of such applications on high performance computing (HPC) systems. Large HPC systems are vulnerable to processors or node failures and perturbations in the availability of resources. Most self-scheduling approaches do not consider fault-tolerant scheduling or depend on failure or perturbation detection and react by rescheduling failed tasks. In this work, a robust dynamic load balancing (rDLB) approach is proposed for the robust self scheduling of independent tasks. The proposed approach is proactive and does not depend on failure or perturbation detection. The theoretical analysis of the proposed approach shows that it is linearly scalable and its cost decrease quadratically by increasing the system size. rDLB is integrated into an MPI DLS library to evaluate its performance experimentally with two computationally intensive scientific applications. Results show that rDLB enables the tolerance of up to (P minus one) processor failures, where P is the number of processors executing an application. In the presence of perturbations, rDLB boosted the robustness of DLS techniques up to 30 times and decreased application execution time up to 7 times compared to their counterparts without rDLB.

Equations

$$T$$

$${\mathbb{E}}_T$$

$$=T+p_F^T\left(\frac{t}{n}\sum _{i=0}^n\frac{n-i}{q-1}\right)$$

$$=T+p_F^T\frac{t}{2}\frac{n+1}{q-1}$$

$${\mathbb{E}}_T$$

$${\mathbb{H}}_T$$

$${\mathbb{H}}_T^C$$

$$C\ge =\frac{\lambda t^2}{8}\frac{(n+1{)}^2}{(q-1{)}^2}.$$

Full text

1. 1 Introduction

2. 2 Background and Related Work

3. 2.1 Background

4. 2.2 Related Work

5. 3 Proposed Approach: rDLB

6. 3.1 Theoretical analysis

7. 3.2 Implementation

8. 4 Experimental Evaluation

9. 4.1 Design of Experiments

10. 4.2 Evaluation and Discussion

11. 5 Conclusion and Future Work

keywords. Dynamic loop self-scheduling, independent task scheduling, Robustness, Fault tolerance, High performance computing, Fail-stop errors, Perturbations

1 Introduction

Scientific applications are often large and computationally-intensive. Parallel loop iterations are a vast resource of parallelism in these applications, in the form of independent tasks, where a loop iteration is a task. Large scientific applications are executed on high performance computing (HPC) systems to fulfill their computational need. Due to the irregularity of parallel tasks or HPC system characteristics, the performance of scientific applications may degrade as a result of load imbalance. Dynamic loop self-scheduling (DLS) is used to balance the execution of parallel loops within computationally-intensive applications. As HPC systems become larger to accommodate the computational needs of scientific applications, they become more vulnerable to faults and perturbations. In fact, observed failures grow proportional to the number of processor sockets in a system [1]. In addition, as smaller transistors are used for high integration in modern and future systems, they more prone to faults and failures due to their low operating voltage and wear-out. Besides failures, perturbations in the availability of the processing elements (PEs), network bandwidth, or network latency could also degrade applications performance. These perturbations may occur due to other applications that share the same (network) resources, operating system interference, or transient malfunction [2].

Current DLS approaches, such as DLB_tool [3] and its extension DLS4LB [4] do not address failures. An approach for fault tolerant DLS where failed tasks are rescheduled on other PEs was evaluated in simulation [5]. However, this approach depends on detecting PE failures and reacting afterward by rescheduling failed tasks. For scheduling under perturbations, reinforced learning or simulation was used to learn [6] or predict [2] the DLS technique that would improve the performance given certain measured or predicted perturbations during execution.

In this work, robust dynamic load balancing (rDLB) is introduced for the robust self-scheduling of independent tasks. The proposed rDLB approach is proactive rather than reactive and does not depend or need any failure or perturbation detection or measurement mechanism. rDLB is used to extend the MPI DLS4LB DLS library to enable robust scheduling in the presence of failures and perturbations. The FePIA procedure [7] is used to evaluate the robustness of the proposed approach during the execution of two computationally-intensive scientific applications in different failure and perturbation scenarios.

This work makes the following contributions: (1) The introduction of a robust dynamic load balancing (rDLB) approach that applies the self-scheduling concept; (2) A lower bound of the expected performance with rDLB and the cost in the case of a single PE failure through the theoretical analysis of the proposed approach; (3) The extension of the DLS4LB with the rDLB approach to employ robust dynamic loop self-scheduling; (4) The evaluation of the proposed approach through native experiments and injecting failures and perturbation. In addition, the FePIA procedure is applied to calculate the robustness of the proposed approach in the execution of two scientific applications under failures and perturbations.

The rest of this work is structured as follows. Section 2 offers the required background for this work. In addition, a review of the most related works is presented. The description, theoretical analysis and the extension of DLS4LB with rDLB is described in Section 3. The design of experiments, results, and the evaluation of the proposed approach is discussed in Section 4. Section 5 concludes this work and outlines future work.

2 Background and Related Work

An overview of the most successful dynamic loop scheduling (DLS) techniques that improve the performance of computationally-intensive scientific applications via load balancing is given. Also, relevant definitions of faults, errors, failures, fault tolerance, and robustness are provided. The most related work on fault-tolerant and robust scheduling is discussed thereafter.

2.1 Background

Loop scheduling. Loop iterations are assigned via loop scheduling to PEs to achieve a balanced load execution with minimum overhead. Loop scheduling techniques are divided into static and dynamic. Static loop scheduling techniques divide and assign loop iterations to PEs before the execution starts. The division of loop iterations nor their assignment do not change during execution. Examples of static loop scheduling techniques are block, cyclic, and block-cyclic [8]. In this work, block scheduling is considered, denoted as STATIC, where each PE is assigned a block (chunk) of loop iterations equal to the total number of loop iterations, $N$, divided by the number of PEs, $P$. DLS techniques assign a chunk of loop iterations to free and requesting PEs during execution via self-scheduling. DLS techniques can be further divided into nonadaptive and adaptive techniques. Nonadaptive DLS techniques address the load imbalance caused by problem or application characteristics, such as the variation of loop iterations execution times. Nonadaptive DLS techniques include self-scheduling [9] (SS), fixed-sized chunk [10] (FSC), modified fixed-sized chunk [11] (mFSC), guided self-scheduling [12] (GSS), trapezoid self-scheduling [13] (TSS), factoring [14] (FAC), weighted factoring [15] (WF), and random [16] (RAND). SS assigns a single loop iteration at a time per PE request. Thus, it results in the maximum load balance and the maximum scheduling overhead. SS represents one extreme, where the load balancing effect and the scheduling overhead are at maximum, whereas STATIC represents the other extreme, where load balancing effect and the scheduling overhead are at minimum. FSC assigns loop iterations in chunks of fixed size, hence reducing the scheduling overhead compared to SS. The chunk size depends on the scheduling overhead, $h$, and the standard deviation of the iterations execution time, $\sigma$. mFSC alleviates the burden of determining $h$ and $\sigma$ and assigns a chunk size that results in a number of chunks that is similar to that of FAC (explained below). GSS addresses the uneven starting times of PEs and assigns chunks in decreasing sizes. The chunk sizes in GSS are calculated as the number of the remaining loop iterations, $R$, divided by $P$. TSS assigns chunks of decreasing sizes, similar to GSS. However, chunk sizes decrease linearly in TSS, which simplifies the chunk calculation and reduces scheduling overhead. FAC assigns chunks in batches to reduce the scheduling overhead. FAC employs probabilistic analysis of application characteristics to calculate batch sizes that maximize the probability of achieving a balanced load execution. The batch size calculation depends on the mean of iterations execution times, $\mu$, and their standard deviation, $\sigma$. The chunk sizes are equal in a batch, namely the batch size divided by $P$. When $\mu$ and $\sigma$ are not available, FAC is practically implemented by assigning half of the remaining loop iterations as a batch, which is equally distributed to PEs on request. WF is similar to FAC, except that it addresses heterogeneous PEs. In WF, each PE is assigned a relative weight that is fixed during execution. Each PE is assigned a chunk from the current batch relative to its weight. In this work, the practical implementations of FAC and WF are used. RAND employs the uniform distribution to arrive at a randomly calculated chunk size between an upper and a lower bound. The randomly calculated chunk size is bounded by $N/(100\times P)\leq chunk\_size\leq N/(2\times P)$ [16].

Adaptive DLS techniques measure the performance during execution and adapt their chunk calculation accordingly to address the load imbalance due to systemic characteristics, such as non-uniform memory access (NUMA) delays and perturbations during execution. Adaptive DLS techniques include adaptive weighted factoring [17] (AWF), and its variants [18] AWF-B, AWF-C, AWF-D, and AWF-E and adaptive factoring [19] (AF), among others. AWF adapts the relative PE weights during execution according to their performance. It is designed for time-stepping applications. It measures the performance of PEs during previous time-steps and updates the PEs relative weights after each time-step to balance the load according to the computing system’s present state. AWF-B relieves the time-stepping requirement to learn the PE weights. It learns the PE weights from their performance in previous batches instead of time-steps. AWF-C is similar to AWF-B, however, the PE weights are updated after the execution of each chunk, instead of batch. AWF-D is similar to AWF-B, where the scheduling overhead (time taken to assign a chunk of loop iterations) is taken into account in the weight calculation. AWF-E is similar to AWF-C, and takes into account also the scheduling overhead, similar to AWF-D. AF is also based on FAC. However, it measures the performance of PEs to learn the $\mu$ and $\sigma$ per PE during execution.

DLS in Scientific Applications. Several scientific applications use dynamic loop scheduling to improve their performance on HPC systems. DLS can be used at the process-level or the thread-level. For example at the process-level, SS, FAC, AWF, and AF were used in heat diffusion application on an unstructured grid [20]. Also, FSC, WF, and AF were used to balance the load of the shadow process in decision support systems for solar energy potential [21]. DLS techniques have also been used to balance the load of automatic quadrature routines [18], N-Body simulations [22], and parallel spin image algorithm (PSIA) [23]. At the thread-level, SS, TSS, GSS, FAC, and WF were used to balance the load in kernels of several benchmarks such as RODINIA suite, NAS OpenMP suite, and SPEC OpenMP [16].

Robustness. A fault is a sudden malfunction that occurs in the computing system, such as a bit flip or incorrect control signal. A fault can lead to an error when a faulty unit is used in calculations. Errors could be fatal, which result in a fail-stop failure, meaning that the system will cease its normal service, or they could be silent or dormant errors, such as silent data corruptions (SDC) [24]. In this work, fail-stop failures of computing cores, nodes, or network links that render certain nodes are unreachable are considered and denoted as failures in the rest of this text. Besides failures, the available computing speed of a PE or the network latency or bandwidth could change during applications execution due to resource sharing or temporary (instantaneous) malfunctions. These variations in the computing speed or network latency or bandwidth are referred to as perturbations and can degrade the application performance running on large scale HPC system. Maintaining “correct” operation in the presence of failures is denoted as fault tolerance, whereas robustness denotes the maintenance of certain desired system characteristics despite fluctuations in the behavior of its components or its environment [7]. Robustness of DLS techniques to variations in the computing unit availability is denoted as flexibility [25] whereas the robustness against fail-stop PE failures is denoted as resilience.

Failures in HPC systems. HPC systems are large and complex that are built with quality components. However, due to the large number of components in these systems, failures are inevitable. For example, ASC Q system at Los Alamos National Laboratory had on average $26.1$ processors failures per week [26]. Also, the mean time between failures (MTTF) for BlueGene and Titan were found to be $7.9$ days [27] and $22.78$ hours [28], respectively. In fact, failure rates of a system grow proportional to the number of processors sockets in a system [1]. The study of failures in large scale systems revealed that there is a correlation between the failure rate of a system and the type and intensity of the workload execution on it [29]. In addition, failures exhibit temporal correlation and are spatially correlated as well, especially for network root-caused failures. Extrapolating the current failure rates to Exascale systems would result in MTTF of $24$ minutes, and if the resiliency of the components is assumed to be improved by a factor of $10$, this would result in a failure every $4$ hours [27].

2.2 Related Work

The flexibility of nonadaptive DLS techniques on distributed heterogeneous HPC systems was studied [30]. Also, the flexibility of adaptive and nonadaptive DLS techniques has been studied [31] and machine learning was used to create a portfolio of DLS techniques flexibility. However, none of the work above considered sources of perturbations other than the variability of PEs availabilities, such as unpredictable network latency or bandwidth. RUMR [32] was introduced as a robust scheduling method to unpredictable task execution time and unpredictable communication time. Multi-objective evolutionary algorithm and a robust version of HEFT [33] were introduced for the robust scheduling of tasks with uncertain computation and communication time [34]. Static scheduling methods such as robust HEFT or evolutionary algorithm optimization can not adapt to unpredictable perturbations and failures that might occur during execution. Dynamic selection of the most robust DLS technique using reinforced learning was used introduced [6] and simulation was used to predict and select the best scheduling techniques under unpredictable perturbations during execution to achieve the best application performance [2]. DLS selection methods above are reactive rather than proactive and depend on detecting perturbations during execution either by measuring or predicting. Also, non-preemptive scheduling could result in poor performance in certain cases due to frequent change of the selected DLS.

A fault-tolerant approach for DLS was introduced and studied using simulation [5], where failed tasks were rescheduled dynamically to working PEs. Different numbers of failed PEs were simulated that represent $12.5\%$, $25\%$, and $50\%$ of the total PEs in the system and the resilience of different DLS techniques were measured based on the number of tasks that needed to be rescheduled in each case. The above work introduced fault tolerance to the DLS techniques. However, it is a reactive approach and depends on detecting a PE failure and then reacting by rescheduling the failed tasks on working PEs. Moreover, the failure detection method was not explicitly clear in this work, as it was only studied in a simulation.

Fault tolerant self-scheduling [35] (FTSS) was introduced for shared memory systems. FTSS incorporate work-stealing with self-scheduling for fault tolerance. An idle thread will steal work from other loaded/failed thread after all loop iterations are already scheduled. This is different from the proposed rDLB, where PEs are assigned work from a central work queue that contain all unfinished tasks and not steal from a certain victim PE. Also, work stealing and victim selection depend on failure detection in FTSS, which was not discussed in this related work.

Fault tolerant work-stealing [36] (FTWS) was presented for distributed memory systems. Tasks are duplicated and executed on two different PEs to detect transient and permanent PE failures. Failed tasks are pushed to the faulty task queue, where PEs executes its tasks as soon as they finish their original work queue. An approach was proposed for enhancing the flexibility of scheduling of a bag of tasks on compute grids [37]. Only perturbations in the computing resources and variations in task sizes were considered and the proposed method was evaluated in simulation. In contrast, the present work considers both failures and perturbations in the computing resources and the network and evaluates the rDLB via native experiments using MPI-based library. Similar robust scheduling approach to restart failed tasks can be configured for Apache Spark and Hadoop YARN [38].

This work proposes a robust approach to DLS, namely: rDLB, that tolerates up to $P-1$ failures, where $P$ is the number of PEs used by the application. In addition, the proposed approach achieves improved performance in cases of severe PE availability or network perturbations. The proposed approach is proactive and does not depend or need any failures or perturbations detection mechanism. The proposed approach is integrated into a state-of-the-art DLS MPI library, namely: DLS4LB [4], and its performance is evaluated by theoretical modeling and in native experiments.

3 Proposed Approach: rDLB

A Robust DLS approach is proposed herein, where processes (PEs and nodes) failures are tolerated. In the proposed approach, each loop iteration is flagged as Unscheduled, or Scheduled, or Finished. At the beginning of the execution, all loop iterations are Unscheduled. Loop iterations are scheduled via DLS techniques to free and requesting PEs, and changes their flag from Unscheduled to Scheduled. In normal non-robust DLS execution, the scheduling operations end when all loop iterations are scheduled to PEs. In the proposed approach, scheduling continues after all loop iterations are scheduled, and reschedule scheduled and unfinished loop iterations, that has their flag set to Scheduled. The key idea of the proposed approach is to leverage the idle time processes wait at the end of the execution for robustness. The execution completes when all loop iterations are executed and have their flag set to Finished.

Figure 1 illustrates the execution with and without the proposed robust DLS approach in the presence of fail-stop failure or perturbations. In case of PE failure, T4 will never be executed because from scheduling it was already scheduled on $P3$ which failed later, and the execution would wait indefinitely for $P3$ to finish T4 and complete the execution. With rDLB, after all tasks are scheduled, and $P2$ becomes available, and requests work, the first scheduled and unfinished task, T4 is assigned to it, and the execution completes as soon as all tasks are Finished.

Similarly in the case of a severe perturbation, represented by Figure 2, tasks assigned to $P2$, the perturbed PE, takes much longer to complete execution. With the proposed robust approach, T7 is rescheduled on $P3$ and execution completes earlier than that without rDLB. The advantage of the proposed approach is that it acts proactively and does not depend on any failure or perturbation mechanism. Rescheduling of unfinished loop iterations or tasks does not entirely add to the execution time, as it overlaps with the idle time when all loop iterations are scheduled and PEs are waiting for the completion of all loop iterations. The execution terminates as soon as either the original or the rescheduled tasks complete.

3.1 Theoretical analysis

Without taking into account the overhead of the scheduling algorithm and the communication overhead between PEs:

• •

Without failure, general case:

[TABLE]

with $T_{P_{i}}=\sum_{i=0}^{n_{i}}t_{i}$.

• •

Without failure, all tasks equal and equally distributed:

[TABLE]

• •

With one failure only, all tasks equal and equally distributed:

[TABLE]

With exponential failures:

[TABLE]

First-order approx:

[TABLE]

Overhead:

[TABLE]

Overhead checkpointing:

[TABLE]

FT-DLS is better than checkpointing when (first-order approx, i.e. $C<<\frac{1}{\lambda}$):

[TABLE]

3.2 Implementation

The proposed rDLB approach is used to extend the DLS4LB MPI scheduling library with robustness. The DLS4LB implements 13 DLS techniques (nonadaptive and adaptive) and uses a master-worker execution model. Algorithm 1 shows how DLS4LB is used for robust scheduling. The MPI error handler has to be changed to MPI_ERRORS_RETURN which reports MPI errors, rather than considering them fatal and ends the program immediately on MPI errors (default behavior). Workers ask the master for work whenever they become free. Upon completing a chunk of loop iterations, the worker sends the results to the master and asks for more work. Upon receiving the results of a chunk from a worker, the master marks the loop iterations previously assigned to the requesting worker as Finished and assigns the worker new chunk. The DLS4LB is adjusted such that scheduling operations are continued until all loop iterations are completed. When the master marks all iterations as Finished, it exits the while loop immediately, save all the results, and calls MPI_Abort to kill all other process and end the execution. MPI_Abort is called to ensure that the execution will terminate immediately as soon as all iterations are finished, and not hang indefinitely in a collective operation such as MPI_Finalize due to failed processes. Alternatively, implementations of fault-tolerant MPI such as User-Level Failure Mitigation [39] (ULFM), could be used to detect and exclude failed processes from the communicator. However, as such fault-tolerant implementations are not yet part of the MPI standard, the MPI_Abort approach is chosen instead, as it complies with the MPI standard and suffices the requirement of terminating the execution, even in case of failed processes. The current implementation of the proposed robust DLS works proactively and does not depend on or require fault detection. It does not add overhead to the application execution time, as the loop iterations are only rescheduled on free PEs when they are waiting for the completion of the execution after all loop iterations are scheduled. The execution is terminated as soon as all loop iterations are completed and reported to the master successfully. A limitation of the current implementation is the master, being a single point of failure. However, work is planned to transform the DLS4LB to a decentralized execution model using decentralized DLS implementation approaches previously explored at the thread-level [40] and the process-level [41].

4 Experimental Evaluation

4.1 Design of Experiments

A summary of the experiments performed to evaluate rDLB is presented in Table 1. In practice, PE or node failures are often noticed in long executions over a large number of PEs. For practical reasons, in this work, short applications execution times and small system size are used to show the benefit of the proposed approach.

Applications. Two computationally-intensive applications are considered in this work, the parallel spin image algorithm (PSIA) [42] and the calculation of the Mandelbrot set [43]. PSIA is a computer vision application that converts 3D objects into sets of 2D descriptors. Mandelbrot is a well-known mathematical kernel, and it is often used to evaluate the performance of scheduling techniques due to the high variation between its loop iterations execution times.

Loop Scheduling. The DLS4LB is employed for scheduling the loop iterations in both applications. The DLS4LB is extended in this work with the rDLB approach to enable robust scheduling as shown in Section 3.

Injecting failures and perturbations. To simulate failures, ranks make exit calls during the computation of the loop at arbitrary times during execution. To show the benefit of rDLB in tolerating a high number of failures, experiments are performed with $1$, $P/2$, and $P-1$ failures, where $P$ is the number of PEs. Perturbations in PE availability is performed by running a CPU burner simultaneously on the same PEs as the running applications. For perturbations in network latency, MPI communication calls are intercepted through MPI profiling interface, and $10$ seconds delays are added for any communication to or from a specified node. As computationally-intensive applications are the focus of this work, perturbations in network bandwidth have almost no effect on application performance [2]. Therefore, perturbations in network bandwidth are not considered in this work.

Computing system. The evaluation experiments are conducted on miniHPC, a research and teaching cluster at the Department of Mathematics and Computer Science at the University of Basel, Switzerland. Sixteen nodes are used in the experiments, with 16 ranks per node, 8 ranks per socket, with a total of 256 ranks on 256 PEs.

Evaluation of robustness. The FePIA [7] procedure in applied to the performance results to evaluate the robustness of rDLB. The resilience, understood as robustness against failures is calculated as $\rho_{res}(\phi,\pi)$ where $\phi$ is the performance feature, i.e., parallel loop execution time $T_{par}$ and $\pi$ is the perturbation parameter, i.e., PE failures [25]. $\rho_{res}(\phi,\pi)=r_{DLS}/r_{minDLS}$, where the robustness radius $r_{DLS}=T_{par}^{\pi}-T_{par}^{orig}$ and $r_{minDLS}$ is the minimum robustness radius for certain perturbation parameter $\pi$. $T_{par}^{\pi}$ is the parallel execution time under perturbation $\pi$ and $T_{par}^{orig}$ is the parallel execution time in the baseline. $\rho_{res}(\phi,\pi)$ is calculated for $\pi_{1}$, $\pi_{2}$, and $\pi_{3}$, which corresponds to one PE failure, $P/2$ PE failures, and $P-1$ PE failures, respectively. Similarly, flexibility defined as robustness against perturbations, is calculated as $\rho_{flex}(\phi,\pi)$, where $\phi$ is the parallel loop execution time $T_{par}$ and $\pi$ is the perturbation parameter, i.e., PE perturbations, latency perturbations, and combined perturbations for the three perturbations cases considered in this work. A $\rho_{res}$ or $\rho_{flex}$ of $1$ denotes the most robust technique (the metric), and the robustness of other techniques are calculated with respect to the most robust one (how many times they are less robust than the most robust technique).

4.2 Evaluation and Discussion

The performance results of PSIA and Mandelbrot under failures and perturbations is depicted in Figure 3 and the robustness metrics are presented in Figure 4 and Figure 5. STATIC technique is not included in the results with rDLB as rDLB is applied for dynamic self-scheduling techniques only. The results show the average parallel loop execution time over $20$ executions for each experiment. As execution with DLS4LB without rDLB will hang forever in the presence of failures, Figure 3a, Figure 3b, only show the results with rDLB. Inspecting Figure 3a, Figure 3b, and Figure 4 reveals that one PE failure is tolerated with rDLB with almost no effect on the execution time, i.e., execution time with one failure is very close to the baseline. Specifically for the adaptive DLS techniques, the execution times in the case of single failure and baseline are almost equal. The cost of tolerating $P/2$ failures depends largely on the DLS technique. DLS techniques that assign small chunk sizes, such as SS (the most robust in this scenario), are more robust that techniques that assign large chunks. Small chunk sizes in such case minimizes the amount of lost work in the case of PE failures. In the case of $P-1$ failures, The work is almost serialized on only the master, and in this case the execution time depends on overhead of the DLS technique (number of scheduling rounds). For the execution with perturbations, two experiments are performed per scheduling technique per perturbation scenario: without rDLB and with rDLB to show the benefit of rDLB in enhancing application performance and robustness under perturbations. The results show that perturbations in PE availability do not affect the performance significantly. Comparing the performance results in latency and combined perturbations, one can see that rDLB enhanced the performance of PSIA in Figure 3c and Mandelbrot in Figure 3d. Results of the flexibility metric in Figure 5 confirm that using rDLB approach boosted the robustness of DLS techniques in case of severe latency perturbations and combined PE and latency availabilities perturbations. In fact, for the adaptive techniques AWF-B,-C, -D, -E their flexibility is enhanced more than $30$ folds by applying rDLB approach in the case of combined PE and latency perturbations in PSIA execution.

5 Conclusion and Future Work

A robust dynamic load balancing rDLB is introduced in this work. The theoretical analysis of the proposed approach shows its linear scalability with the system size and the quadratic decrease of its cost with increasing the number of PEs. The proposed rDLB is integrated into the DLS4LB and used to schedule the loops of two computationally-intensive scientific applications under PE failures and perturbations. Results show that rDLB, applications tolerated up to ($P-1$ )PE failures with reasonable cost. rDLB boosted the robustness of DLS techniques in the case of execution under perturbations nearly $30$ times with adaptive DLS techniques. DLS techniques with rDLB achieved improved performance in terms of parallel execution time up to $7$ times faster compared to their counterparts without rDLB in the presence of latency perturbations.

Extending DLS4LB to employ a decentralized control approach instead of a master-worker model and integrating rDLB into the extended DLS4LB is planned in the future to avoid the master being a single point of failure. The application of rDLB to other independent task self-scheduling techniques is also envisioned in the future. In addition, addressing silent data corruptions in large scale scientific applications is planned to ensure the integrity of applications results.

Acknowledgment

This work has been partially supported by the Swiss Platform for Advanced Scientific Computing (PASC) project SPH-EXA: Optimizing Smooth Particle Hydrodynamics for Exascale Computing and by the Swiss National Science Foundation in the context of the “Multi-level Scheduling in Large Scale High Performance Computers” (MLS) grant, number 169123.