Detection of Silent Data Corruptions in Smoothed Particle Hydrodynamics Simulations

TL;DR

This paper introduces Selective Particle Replication (SPR), a novel method for detecting silent data corruptions in Smoothed Particle Hydrodynamics simulations, achieving high detection rates with minimal overhead.

Contribution

SPR is the first particle-based replication method specifically designed to detect silent data corruptions in SPH simulations, improving reliability in large-scale scientific computing.

Findings

SPR detects 91-99.9% of SDCs with no false positives.

SPR incurs 1-10% overhead in HPC environments.

Effective in error propagation scenarios in SPH simulations.

Abstract

Silent data corruptions (SDCs) hinder the correctness of long-running scientific applications on large scale computing systems. Selective particle replication (SPR) is proposed herein as the first particle-based replication method for detecting SDCs in Smoothed particle hydrodynamics (SPH) simulations. SPH is a mesh-free Lagrangian method commonly used to perform hydrodynamical simulations in astrophysics and computational fluid dynamics. SPH performs interpolation of physical properties over neighboring discretization points (called SPH particles) that dynamically adapt their distribution to the mass density field of the fluid. When a fault (e.g., a bit-flip) strikes the computation or the data associated with a particle, the resulting error is silently propagated to all nearest neighbors through such interpolation steps. SPR replicates the computation and data of a few carefully selected SPH particles. SDCs are detected when the data of a particle differs, due to corruption, from its replicated counterpart. SPR is able to detect many DRAM SDCs as they propagate by ensuring that all particles have at least one neighbor that is replicated. The detection capabilities of SPR were assessed through a set of error-injection and detection experiments and the overhead of SPR was evaluated via a set of strong-scaling experiments conducted on an HPC system. The results show that SPR achieves detection rates of 91-99.9%, no false-positives, at an overhead of 1-10%.

Figures

Tables

Table 1. Table 1 : Design of target experiments

Experiment target	Error-injection	Strong-scaling
Test simulation	ECsg	EC	WB
#Processes	16	4-256	4-256
#Threads/process	20	12	12
#Particles	$65,536$	$1,000,000$	$3,157,385$
Self-gravity	Yes	Yes	No
HPC system	miniHPC	Piz Daint
#Neighbors	100

Full text

1 Introduction

The frequency of faults, errors and failures in large-scale systems increases proportionally to the number of components. As such, reliability has been identified as a major challenge for Exascale computing [43, 14, 15]. Trustworthy computing aims at guaranteeing the correctness of the results of long-running computations on large-scale supercomputers. In particular, silent errors, or silent data corruptions (SDCs), represent a major threat to the correctness of the results of such calculations. SDCs typically manifest when one or more bits are flipped in the memory of the system. There are several causes for these errors, such as packaging pollution or cosmic rays, among others [4, 39, 51].

The standard solution for protecting the memory subsystem against data corruption is the use of error correcting codes (ECC). However, these mechanisms are not able to detect and correct all errors. Indeed, recent studies suggest that such mechanisms may not prevent data corruptions from occurring at extreme scales [4, 37, 33], and in particular in DRAM devices [45]. This work expands on detecting DRAM errors.

Triple modular redundancy111In this work, redundancy and replication are used interchangeably. (TMR) [35] is the most general and non-intrusive approach to detect and correct SDCs in scientific applications. SDCs detectors are characterized by their precision and their recall. The precision is the ratio of true errors detected (in contrast to false-positives) over all errors detected, and the recall is simply the ratio of true errors detected over all true errors that occurred during the execution. A high precision and a high recall indicate both few false-positives and a good detection rate, respectively. In general, detectors that either employ full replication of entire applications [27] or selective replication of parts of an application [10] offer the highest precision and recall. However, they are often prohibitively expensive in terms of additional required computing resources and time. Therefore, many application-specific detectors have been proposed as alternatives to redundancy to lower the cost of error detection. Specifically, *data analytics-*based techniques detect outliers by relying on application-specific properties, such as spatial and/or temporal data smoothness. *Interpolation-*based detectors employ techniques such as time series prediction and spatial multivariate interpolation [2, 5, 6] to interpolate the next value of a data-point, and offer broad error detection coverage at low cost, but typically have a lower precision compared to full-replication approaches. A further review of relevant error detection methods is presented in Section 4.

Smoothed particle hydrodynamics (SPH) is a meshless Lagrangian method commonly used for performing hydrodynamical simulations. Initially devised in the late ’70s [34, 31], this technique underwent sustained development  [13, 44, 28, 41] and is, nowadays, commonly used in many fields including computational fluid dynamics, plasma physics, solid mechanics, and astrophysics. Its inherent good conservation properties and its adaptability to distorted geometries make SPH a common choice to simulate highly-dynamic three-dimensional scenarios. The SPH technique discretizes a fluid in a series of interpolation points (called SPH particles) whose distribution follows the mass density of the fluid, and their evolution relies then on a weighted interpolation over close neighboring particles. The cost of such a highly-adaptive unstructured fluid discretization is the non-uniformity of data, in terms of the number and distribution of neighbors that a particle might have at a specific location and time. This renders most data analytics-based error detectors less accurate than redundancy-based detectors. Moreover, SPH simulations are inherently robust: it is likely that SDCs will not crash the execution of an SPH application, thereby not alerting the user.

Selective particle replication (SPR) is proposed in this work. SPR replicates the computation and data of a few carefully selected SPH particles, and SDCs are detected when the data of a particle differs from the data of its replica or viceversa.

It is necessary to understand how SDCs propagate in SPH simulations before we clarify how to select which particles need to be replicated. We assume that an SDC initially strikes the data of a single particle (e.g., a bit-flip in the position, density, mass, temperature, or in any other data field associated with that particle). The subsequent SPH interpolation steps will proceed with erroneous data and propagate the error to all neighbors of that particle, i.e., typically affecting $\sim 100$ other particles. However, having just one redundant neighbor would be enough to detect the difference (no matter how small) in the computed result due to the original SDC. Therefore, by ensuring that all particles have at least one redundant neighbor, SPR can detect most SDCs (as they propagate). We detail the entire process and its limitations in Section 2.

We conduct a series of experiments by incorporating SPR in a production SPH code and running two test simulations commonly used in astrophysics. First, we perform a set of error-injection and detection experiments to assess the detection capabilities of SPR. Next, we conduct a set of performance-evaluation experiments, without injecting errors, to assess the overhead of SPR for the two test simulations on the Piz Daint supercomputer222https://www.cscs.ch/computers/piz-daint/. The outcome shows that SPR is particularly suited for detecting SDCs in SPH simulations, detecting $91-99.9\%$ of the injected errors, for a typical execution overhead between $1-10\%$. In addition, SPR raises no false-positives, which is a significant advantage over unprecise detectors.

This work makes the following contributions: (1) Presents a simple, yet effective method (SPR) for selecting particles to be replicated and detects errors with bit-level precision; (2) Experimentally quantifies the recall and precision of SPR through an error-injection and detection campaign in a production scientific application; and (3) Assesses the scalability and overhead of the proposed SPR approach through real experiments on an HPC system.

The remainder of this work is structured as follows. We describe in detail and illustrate the proposed approach for silent error detection via selective particle replication in Section 2. We include the experimental setup and results in Section 3 along with their evaluation and a discussion of the findings. Section 4 surveys the relevant literature related to silent errors detection. Finally, Section 5 outlines the conclusion of this work together with insights into future work extensions.

2 Selective Particle Replication

Selective particle replication (SPR) consists of three steps, namely selection, replication, and detection. Section 2.1 describes an algorithm to select the particles that will be replicated, Section 2.2 covers the different aspects and challenges of particle replication in SPH, and Section 2.3 presents the error-detection algorithm as well as its limitations.

2.1 Selection

In parallel SPH implementations [38], the particle domain is distributed among the processes. Each process is given a list of particles and their associated data. The first step in SPR is to select which particles to replicate to ensure that all particles in a process have at least one neighbor that is replicated in another process, as illustrated in Figure 1.

Given that the number of computations grows linearly with the number of particles selected on each process, we want to replicate as few particles as possible overall. The domain composed of the particles and their neighbors can be compared to a graph where vertices and edges represent the particles connected to their neighbors.

Particles must be selected such that any given particle in a process either belongs to the set of particles selected for replication, or has a selected particle as neighbor, which translates to finding a Minimum Dominating Set (MDS). However, this is a classical NP-Hard problem [29] and there is no known optimal polynomial time algorithm for finding such a minimum set. One can alternatively solve the simpler Maximal Independent Set (MIS) problem, where a MIS is also a Dominating Set (albeit not minimum). As opposed to a dominating set, a MIS ensures that no selected vertices (respectively particles) in the graph are adjacent, which leads to fewer vertices being selected, and it is possible to find many MISs in a graph.

The present work proposes the use of a greedy algorithm to find a MIS, listed in Algorithm 1. Given the set $P_{q}$ of particles assigned to process $q$ for computation, Algorithm 1 returns the set $S_{q}$ of particles selected for replication in another process. A possible solution to the problem is presented in Figure 1 for a small example with $32$ particles distributed on three processes, highlighting the selected particles in each process.

Complexity. Algorithm 1 requires, in the worst case, to iterate through the $n_{q}$ particles of process $q$ and for each particle to visit at most $ng_{max}$ neighbors, where $ng_{max}$ denotes the maximum number of neighbors for any given particle in the simulation. Therefore, the running time of this algorithm is $\mathcal{O}(n_{q}ng_{max})$.

Overall asymptotic cost. The running time of SPH applications is dominated by large interpolation kernels scaling as $O(n_{q}ng_{max})$. Comparatively, our approach only requires $\mathcal{O}(n_{r}ng_{max})$ additional computations, where $n_{r}$ is the maximum number of replicated particles per node. A lower bound on $n_{r}$ is $\frac{1}{ng_{max}}$, when only $1$ particle is selected to dominate all of its neighbors. Experiments show $n_{r}$ to be in the range of $1-10\%$ based on our MIS approach. Consequently, the increment in memory cost and communication time is also very small $1-10\%$ (see Section 3).

Note that the maximum number of neighbors, $ng_{max}$, is often a user-defined parameter in the order of $10^{2}$ particles for 3D simulations.333Given a target number of neighbors, the simulation will try to reach this number of neighbors for each particle and this influences the resulting smoothing length. As the simulated scenarios grow in complexity and require increased resolution, the overall number of particles in SPH simulations increases, as well as the number of neighbors. Nowadays, 3D SPH simulations require between $10^{5}-10^{12}$ particles, with $10^{2}-5\cdot 10^{2}$ neighbors per particle.

2.2 Replication

The second SPR step is to copy the data and to replicate the execution of the previously selected particles onto a target process. Each process must send a copy of all its selected particles and their neighbors to its assigned target process. As the selected particles are in fact a MIS, each process copies of the data of all its particles on to its assigned target process, as shown in Figure 2. However, only the selected particles are computed on the target process.

Figure 2 shows the distribution of $32$ particles onto three processes $\{q-1,q,q+1\}$. In this configuration, each process initially sends a copy of the data associated with all its particles to the next process id. Note that both computation and data are replicated onto a target process for the selected particles, while only data is replicated for all the neighbors of a selected particle. This data is needed to update the selected particles during SPH neighbor interpolation steps.

To avoid the risk of using corrupted data, detection must be performed before any inter-process communications occur. As long as no data is communicated to another process, the error is guaranteed to be contained within the faulty process. Since in SPH, processes must exchange data after every interpolation step to exchange neighbors that are at the edge of their respective computational domain, SPR detection must also be done right after each interpolation step. In addition, each process must update the copy of the data of all its particles on the target process, so that the selected replicated particles use the latest version of their neighbors data.

The general workflow is described in Algorithm 2 and additional SPR steps are shown in blue. Depending on the scenario they simulate or the research field in which they are used, SPH codes can greatly vary in terms of implementation and physical processes they include. Nevertheless, many SPH codes apply the same general underlying workflow. This allows us to generalize the use of the SPR method proposed here, not only to a single specific SPH code but to the vast majority of SPH codes.

2.3 Detection

Error-detection is done by comparing the data of the selected particles against their the data of their replica. Detection must be performed after every computational workflow step, before any data are communicated to other processes, as illustrated in Algorithm 2 (in blue).

Given that an original particle and its replica represent the same particle, their data are expected to remain identical at any point during the simulation. Moreover, the data of the original particle can be compared against the data of its replica with bit-level resolution. If an error propagates to either the original particle or its replica, even by causing a change in single bit, it will be detected via a simple comparison.

Figure 3 shows how one of the selected particle on process $q$ becomes corrupted after using data from a corrupted neighbor during an interpolation step. Since the newly computed data on process $q$ differs from the data of its replica on process $q+1$, the error is detected via a simple comparison.

The following algorithm is proposed to detect errors using replicated particles selected a priori in Step 1. We assume that replicated particles are always computed upon the next process in a round robin fashion, i.e., the list of replicated particles selected on process $q$ with Algorithm 1 is sent to process $q+1$, so that process $q+1$ computes the selected replicated particles from process $q$, and so on. Therefore, for detection purposes, process $q$ sends the data corresponding to replicated particles from process $q-1$ back to process $q-1$, and in return, it receives the data corresponding to its own replicated particles from process $q+1$. Let $S_{q-1}$ denote the set of particles selected for replication on process $q-1$ and let $data_{q}(S_{q-1})$ denote the data associated with replicated particles selected on process $q-1$ and used for computation on process $q$. Similarly, let $data_{q+1}(S_{q})$ denote the data associated with replicated particles selected on process $q$ and used for computation on process $q+1$. The detection algorithm is listed in Algorithm 3.

For a given process $q$, Algorithm 3 iterates through the list of replicated particles that have been selected on process $q$ and computed on process $q+1$. For each selected particle, it compares the data obtained on process $q+1$, corresponding to the replica, with the data obtained on process $q$, corresponding to the original particle. If the data differ, an error has been detected.

2.4 Limitations

The SPR detection capabilities are limited to errors that propagate. SPH codes typically simulate several complex physical phenomena in the same application. Some particle datasets, such as the positions of the particles, are used very often during interpolation throughout the simulation. The data is read and used multiple times in different interpolation steps. An error in such datasets is more likely to propagate, and therefore to be detected, while errors in datasets than are used less often, such as particle particle densities, are less likely to propagate and may not always be detected.

Note that this approach is limited to deterministic calculations and that round-off errors are expected and need to be accounted for. This is typically achieved by allowing $k$ lower order bits to differ. The SPH method is entirely deterministic, and in the experiments performed in this work, no round-off errors or truncated values were encountered.

2.5 Error Correction

Even though the main focus of this work is on the detection of SDCs, it is possible to combine the proposed detector with other error-detection and correction methods. Checkpointing with rollback recovery [17, 23] is the de-facto general-purpose recovery technique in high-performance computing. Finding the optimal checkpointing interval [49, 19, 21, 7] or the optimal recovery method for SPH codes is beyond the scope of this paper.

Because the SPR error detector is used in every simulation time-step, it is possible to safely checkpoint the state of the simulation if no error was detected. Then, whenever a new error is detected, the simulation can simply rollback to the last correct checkpoint and re-execute from there. For completeness, this work implements checkpointing using the Fault-Tolerance Interface (FTI) [3].

3 Experimental Evaluation

In this section, we describe the experiments conducted with two test simulations commonly used in astrophysics. The goal of these experiments is two-fold: (1) experimentally assess the detection capabilities of SPR through an error injection campaign; and (2) assess the performance of the proposed approach at scale.

3.1 Experimental Setup

SPR implementation into a production SPH code

SPR has been incorporated in SPHYNX444Freely available at https://astro.physik.unibas.ch/sphynx [12], an SPH code with focus on astrophysical simulations. The incorporation of SPR into SPHYNX comprises the implementation of Algorithms 1,  2, and 3 presented in Section 2. SPHYNX includes state-of-the-art SPH methods that allow it to address subsonic hydrodynamical instabilities and strong shocks, which are ubiquitous in astrophysical scenarios. SPHYNX is implemented in Fortran and uses the message-passing interface (MPI) for inter-process communication and the open multi-processing interface (OpenMP) for intra-process/inter-threads data sharing. Note that compared to the original SPHYNX code, which counts $\sim 30,000$ lines of code, less than $300$ additional lines of code were added by SPR as a module for SPHYNX. In the following, the term SPHYNX denotes the original code, and SPHYNX+SPR denotes the version of the code extended with SPR. SPHYNX was used to run two different test simulations: (1) the Evrard collapse (EC) [25], which studies the gravitational collapse of a gaseous cloud and is a common test to evaluate the correctness of the coupling of hydrodynamics and self-gravity; and (2) the wind-bubble interaction test (WB) [1], which studies the interaction of a supersonic wind with a high-density colder bubble in pressure equilibrium.

Choice of number of neighbors

The number of neighbors per particle must cover the area of influence of the interpolation kernel in a reasonably homogeneous way, and is, therefore, linked to the type of SPH kernel used in the simulation. In general, $10^{2}$ neighbors is a very common value found in the bibliography, for frequently used SPH kernels in 3D simulations. Unlike the kernel used in SPHYNX (Sinc kernel [13]), other SPH kernels, e.g., Wendland kernel [20], have a much longer radius and, as a consequence, must use larger amounts of neighbors (e.g., $5\times 10^{2}$). These choices are made after an empirical iterative process in the SPH history and are proven to be adequate to balance accuracy and computational cost, while suppressing numerical instabilities, like particle pairing.

Experiments

For each test simulation, different parameters were passed to SPHYNX: a file containing the initial conditions, the corresponding number of particles, and other parameters specific to each test. During the time this work was performed, the initial conditions for only three tests cases were available: an EC test simulation with $65,536$ particles that was used to experiment with error-injection and detection, and two larger EC and WB test simulations with $1,000,000$ and $3,157,385$ particles, respectively, that were used to assess the scalability of SPR. Generating initial conditions for different numbers of particles is a non-trivial process. Therefore, this work employs a set of strong-scaling experiments to assess the performance at scale for the proposed SPR method. Table 1 summarizes the different experiments and the corresponding parameters used. Error-injection and error-detection experiments were conducted on a small scale system with $20$ nodes named miniHPC, while strong-scaling experiments were done the Piz Daint supercomputer with up to $256$ nodes.

3.2 Error-Injection and Error-Detection Experiments

In this section, an error-injection and detection campaign was performed using the ECsg test simulation described in Table 1. The goal was to experimentally assess the detection capabilities of SPR. Specifically, the focus was on measuring the recall and the precision of the detector, where the precision is defined as $100\times\left(1-\frac{\text{\#false-positives}}{\text{\#errors detected}}\right)$, and the recall is defined as $100\times\frac{\text{\#errors detected}}{\text{\#errors detected}+\text{\#errors undetected}}$.

A golden set of results was first created by running two time-steps of the application in an error-free environment. To inject errors, an additional thread was created in each process to inject single bit-flips into the data of the application during its execution. The timing of the error to be injected is critical: if it is injected too early in a time-step, the error may be overwritten and masked, while if it is injected too late (after propagation occurred), it may not be detected by SPR.

The simulation repeatedly executed the same two time-steps as in the golden set: a single bit-flip was injected at a random time and a random data location within the first time-step, and results were collected at the end of the second time-step. The injected error was masked if all datasets were identical to the ones in the golden set, detected if SPR raised a flag, and undetected otherwise. False-positive errors are also counted, which would have been observed if SPR had raised a flag while there was no error. However, no false-positives were observed in the experiments, which means that SPR has an experimentally measured precision of $100\%$.

To quantify the recall, experiments were performed of the most five critical particle datasets, namely position, mass, internal energy, velocity and density. Each one of these datasets holds as many $64$-bits double-precision numbers as there are particles in the simulation, and up to three times more for multi-dimensional datasets, such as positions and velocities. Following the IEEE 754 number representation, bit $64$ encodes the sign, bits $63$ to $53$ (included) encode the exponent, and bits $53$ to $1$ encode the fraction or mantissa, which corresponds to approximately $16$ decimal digits of precision. For each of these datasets, $5,000$ bit-flips were injected in random processes, particles, and bit positions, for a total of $25,000$ errors injected over the execution of $50,000$ simulation time-steps.

The results of the error-injection and detection campaign are presented in Figure 4. Note that certain SDCs fall into the significant errors category. These errors correspond to an absolute difference greater than $10^{-6}$ between the corrupted and the golden data. Most detection techniques focus only on significant errors and will fail to detect less significant errors (of which many of them may be impactful). In fact, only a comparison with the actual correct data can reveal them, which SPR is able to perform.

The differences in the number of detected, masked, and undetected errors for different datasets are due to several factors. Certain particle datasets, such as positions, are critical to the SPH method. They are used in almost every computational step of the workflow, which greatly increases the probability that an error is propagated, and therefore detected by SPR. Other particle datasets, such as density, can be recomputed from other datasets, and are less frequently used in the computational workflow. Therefore, the probability that an error is masked is higher, and there are fewer opportunities for SPR to detect it.

3.3 Strong Scaling Experiments

Overall, the measured recall was always greater than $0.91$, and as high as $0.999$ for significant errors. The recall is only slightly lower when accounting for all errors below the current precision limit.

To assess the performance of SPR at scale, strong-scaling experiments were conducted on the EC and WB test cases, as described in Table 1.

Each experiment was performed by running two versions of SPHYNX, the original version (SPHYNX) and the resilient version (SPHYNX+SPR). As the focus of this experiment is on assessing the performance of error-detection at scale, given the long execution time requirements for such simulations, the number of time-steps of the simulation was set to $20$, while a full SPH simulation would typically require several thousands time-steps. For each execution, we have excluded the first $10$ time-steps that correspond to the SPH initialization phase and are not representative of the general performance behavior of the SPH code. Overall, the reported execution time of each test case is an average of a total of $100$ time-steps for $10$ executions.

Figures 5(a) and 5(b) present the average execution time needed to complete a single time-step for both SPHYNX and SPHYNX+SPR, for the EC and WB test cases, respectively, when executed on $4$ to $256$ computing nodes, each with $12$ computing cores. In both cases, it can be observed that SPHYNX+SPR yields a low overhead, never exceeding $5\%$ and $10\%$ for the EC and WB test cases, respectively. This corresponds to the case with the largest number of particles per node.

Figures 6(a) and 6(b) illustrate a break down of the execution time of SPHYNX+SPR by the main computational workflow steps, including the time to select particles and the total communication time. It can be seen that the algorithm to select particles represents at most $2.6\%$ of the time needed to complete a single time-step. The total cost of detection never exceeds $0.1\%$ of the total execution time and is not shown in these figures.

Overall, both SPHYNX and SPHYNX+SPR scale very well with increasing node count, the main performance limitations being: (1) the sequential implementation of the Build tree step SPHYNX; and (2) the increasing communication cost, which is negligible when executing on $4$ computing nodes, but a dominant factor when executing on more than $128$ nodes.

Figures 7(a) and Figure 7(b) show the average communication to computation ratio (CCR) for the EC and WB test simulations, respectively. For both versions of the code, the CCR ratio steadily increases with the number of nodes. Yet, despite requiring multiple additional inter-process communications, the difference with between SPHYNX and SPHYNX+SPR remains very small. The significant increase in overhead on $256$ nodes (also shown in Figure 6(a) and Figure 6(b)) is mainly due to having too few particles per node.

3.4 Summary and Discussion

The experimental results show that SPR can practically be incorporated into commonly used astrophysical SPH test simulations with minimal changes to the original code, and with low additional overhead, ranging from $1\%$ to $10\%$ for the EC and WB test cases.

SPH simulations are expected to use more particles in production runs (i.e. up to $10^{12}$), which results in greater particle counts per process and greater neighbor count per process (i.e. several hundreds) in some scenarios. Consequently, SPR is expected to deliver improved performance on large-scale SPH simulations: an increase in both the number of particles and number of neighbors per particles will lead to fewer selected particles, and, thus, less overhead overall.

4 Related Work

Complete redundancy

The use of redundant MPI processes for error detection has been widely analyzed in the last decade [16, 24, 26, 27, 50, 18, 40]. Unlike these full-process or full-task replication efforts, the present work employs selective sub-process or sub-task duplication (illustrated in Figure 2) of a selected part of the work assigned to a process or a task that corresponds to the particle selected for replication. While dual modular redundancy or triple modular redundancy incurs $100\%$ and $200\%$ additional computational overhead, respectively, SPR only replicates $1-10\%$ of the application with a $1-10\%$ added overhead.

Partial redundancy

Partial redundancy has been studied to decrease the overhead of complete redundancy [22, 46, 47, 48]. Adaptive partial redundancy has also been proposed wherein a subset of processes is dynamically selected for replication [30]. Partial replication (using additional hardware) of selected MPI processes has been combined with prediction-based detection to achieve SDC protection levels comparable with those of full duplication [9, 10, 36]. The proposed SPR approach differs from the existing partial redundancy approaches in that it protects the data of the entire application (as opposed to a subset) by selectively duplicating only a subset of the computations within processes. To the best of our knowledge, this is the first time such methods are applied to SPH.

Detection via Interpolation

Silent error detectors based on data analytics use several interpolation techniques, such as time series prediction [8] and multivariate interpolation [2, 5, 6], to interpolate the next value of a computational point based on spatial and temporal data smoothness. Multivariate interpolation has been used to detect and correct SDCs in computational fluid dynamics [5], where the approach achieves $99.8\%$ precision and low recall. Additional tests on synthetic benchmarks achieved a maximum of $90\%$ recall at $1\%$ overhead [6]. To ensure that the false-positive rate remains well below the SDC rate, a high detection precision supersedes a high recall. As shown in Section 3, SPR yields $100\%$ precision (i.e. no false-positives) and a high recall for selected data-fields.

Algorithm-based fault tolerance (ABFT) is another error detection technique which uses checksums to detect up to a certain number of errors and is currently only suitable for linear algebra kernels [32, 11, 42].

5 Conclusion and Future Work

In this work, we proposed a novel silent data corruption (SDC) detection method, namely selective particle replication (SPR), and we implemented it in SPHYNX, a production smoothed particle hydrodynamics (SPH) simulation code.

SPR comprises of three simple, yet efficient, algorithms to select the particles for which to replicate the computations and data of selected particles onto different processes, and to compare the values of the original particles against the data of their replica, to detect SDCs during execution.

The error-detection capabilities of SPR were experimentally evaluated through an error-injection and detection campaign. Not only is SPR able to detect $91-99.9\%$ of the injected errors (i.e., DRAM bit-flips), it also does not raise any false-positives. In addition, experiments conducted on an HPC system demonstrate the scalability of SPR in production SPH codes, at an overhead of $1-10\%$.

Because SPR is scalable, non-intrusive and precise, it can easily be combined with other error-detection methods, to detect errors that could escape SPR’s detection coverage. Furthermore, SPR can also be applied to other classes of applications, e.g., N-body simulations, stencils, and computational fluid dynamics. Whether SPR can accurately detect errors in such applications is a topic that deserves further investigation.

Acknowledgement

This work has been supported by the Swiss Platform for Advanced Scientific Computing (PASC) project SPH-EXA and by a grant from the Swiss National Supercomputing Centre (CSCS) under project ID c16.