Silent error resilience in numerical time-stepping schemes
Download as PPTX, PDF0 likes395 views
This document summarizes research into detecting silent errors in numerical time-stepping schemes. The researcher presented a general algorithm that uses a base method like Runge-Kutta 5 alongside an auxiliary method like Runge-Kutta 4 to detect errors. If the difference between the results exceeds a threshold, it could indicate an error. The researcher showed this approach can effectively detect artificially inserted errors in solutions to heat equations, detecting large errors more easily with few false positives. The work provides a framework for error detection in numerical integration applications.
![Base method:
high-order numerical integration scheme:
Runge-Kutta 5
Auxiliary method:
lower-order scheme: Runge-Kutta 4
Difference:
Di = |Bi – Ai|
Re-purposing an old idea for step-size control
[Fehlberg, 1969], [Dormand and Prince, 1980]
8](https://image.slidesharecdn.com/silenterrorsicmecolloq-150131154056-conversion-gate02/85/Silent-error-resilience-in-numerical-time-stepping-schemes-8-320.jpg)
Silent error resilience in numerical time-stepping schemes
- 1. Silent error resilience in numerical time-stepping schemes Austin Benson arbenson@stanford.edu Stanford University ICME Colloquium, Jan. 26 2015 Joint work with Sven Schmit, Stanford Rob Schreiber, HP Labs code + data: http://stanford.edu/~arbenson/silent.html paper: Intl. J. of High Performance Computing Applications, 2014 1
- 2. Computer systems are getting bigger and more complicated. Software systems are getting bigger and more complicated. Pushing energy limits. Things break. 2
- 3. What breaks? Hardware wears out Bit flips from cosmic rays Data races and other software bugs Firmware bugs Silent errors are errors in application state that have escaped low-level error detection. 3
- 4. What can we do? Checkpoint/restart: Occasionally save state of system. If error is detected, restart. Does not scale. How to detect errors? Other ABFT: Clever algorithms that address these issues for particular algorithms. This work: Error detection for iterative computation in general, numerical time-stepping schemes in particular. 4
- 6. At time step 120, multiplied single entry in right-hand-side of Crank-Nicolson and Backward Euler linear solves by 0.995. 6
- 7. General algorithm: “Base method” generates sequence B1, B2, … “Auxiliary method” generates sequence A1, A2, … If Di = ||Bi – Ai|| is abnormal, possible error 7
- 8. Base method: high-order numerical integration scheme: Runge-Kutta 5 Auxiliary method: lower-order scheme: Runge-Kutta 4 Difference: Di = |Bi – Ai| Re-purposing an old idea for step-size control [Fehlberg, 1969], [Dormand and Prince, 1980] 8
- 9. Key idea: re-use data RK 1/2 scheme for u’ = f(t, u) Second-order scheme has error O(h^3) No extra function evaluations. Provides O(h^2) check. 9
- 10. Key idea: re-use data Implicit solve that is stable Explicit solve checks. It is OK that the explicit solve may be unstable. (Why?) 10 e.g., Backward Euler e.g., Forward Euler
- 11. Backward/Forward Euler Richardson/Crank-Nicolson Runge-Kutta 1/2, 2/3, 4/5 Adams-Bashforth linear multistep method 2/3, 4/5 Explicit check on implicit scheme Extrapolation Lots of these checks for numerical time-stepping algorithms… 11
- 12. Exercise in step detection (change point detection) Algorithmic details in the paper. Main parameters: Relative jump Variance change 12
- 13. Experimental setup: Solve heat equation for T time steps and artificially inject error at one time step. Do this many times with different types of errors. True positive rate: #(real errors detected) / #(trials) False positive rate: #(non-errors “detected”) / #(time steps) 13
- 14. Are large errors easier to detect? Local truncation error (LTE)-normalized error Output when no fault is injected. Output when fault is injected. 14
- 15. Error injection: Multiply single entry of RHS in linear solves by z ~ N(1, 5e-5) at a single time step 15
- 16. Error injection: Multiply q(x, t) at one discrete x by z ~ N(1, 0.1) at a single time step 16
- 17. Takeaways 17 We have a general framework for detecting silent errors. Numerical integration is our central application. We detect large errors more easily. Not too many false positives.
- 18. How many silent errors are there? How worried should we be? Do we need systems solutions or algorithmic solutions? Both? “Defense in depth” is good. But how easy are ABFT methods to incorporate into existing solvers? Resilience: what do we need to discuss? 18
- 19. Silent error resilience in numerical time-stepping schemes Austin Benson arbenson@stanford.edu Stanford University ICME Colloquium, Jan. 26 2015 Joint work with Sven Schmit, Stanford Rob Schreiber, HP Labs code + data: http://stanford.edu/~arbenson/silent.html paper: Intl. J. of High Performance Computing Applications, 2014 19
Editor's Notes
- #6: & u_t = \frac{1}{100}u_{xx} + 0.1\left(\sin(2\pi t) + \cos(2\pi x)\right) \nonumber \\ & t \in [0, 2], x \in [0, 1] \nonumber \\ & u(x, 0) = x(x-1) \nonumber \\ & \Delta x = 1 / 160, \Delta t = 1 / 100 \nonumber
- #7: & u_t = \frac{1}{100}u_{xx} + 0.1\left(\sin(2\pi t) + \cos(2\pi x)\right) \nonumber \\ & t \in [0, 2], x \in [0, 1] \nonumber \\ & u(x, 0) = x(x-1) \nonumber \\ & \Delta x = 1 / 160, \Delta t = 1 / 100 \nonumber
- #10: & \textcolor{blue}{k_1^{B}} = f(t_n, u_n^{B}) \nonumber \\ & u^{B}_{n+1} = u_n^{B} + hf\left(t_n + h/2, u_n^{B} + h\textcolor{blue}{k_1^{B}}/2\right) \nonumber \\ & \\ & u_{n+1}^{A} = u_n^{B} + h\textcolor{blue}{k_1^{B}} \nonumber \\ & \\ & D_{n+1} = \| u_{n+1}^{A} - u_{n+1}^{B} \|
- #11: & AU^{B}_{n+1} = \textcolor{blue}{U^{B}_{n}} \nonumber \\ & \\ & U^{A}_{n+1} = B\textcolor{blue}{U^{B}_{n}} \nonumber \\ & \\ & D_{n+1} = \| U^{B}_{n+1} - U^{A}_{n+1} \| \nonumber
- #13: & D_{n+1} = \| B_{n+1} - A_{n+1} \|_{\infty} \\ & J_{n+1} = \frac{D_{n+1} - D_n}{D_n} \\ & V_{n+1} = \frac{\text{Var}(D_{n-p+1}, \ldots, D_{n+1})}{\text{Var}(D_{n-p}, \ldots, D_{n})}
- #15: L_i = \frac{\| B_i - \hat{B}_i \|}{\| \hat{B}_i - \hat{A}_i \|} \approx \frac{\text{Difference caused by error}}{\text{local truncation error}}
- #16: $u_t = 0.001u_{xx} + (1 - \sqrt{1 - 4(t - t^2)}) / (2 - 2t)$ $u(x, 0) = 6|x - 1/2| - 3$
- #17: $u_t = 0.01u_{xx} + q(x, t)$, \quad $q(x, t) = xe^{-t/2}$ $u(x, 0) = 4x(x-1)(x-2)$