Ignacio Laguna
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Ignacio Laguna has a total of 89 co-authors. Here are the top co-authors by number of shared publications:
- Cindy Rubio-González
University of California at Davis, Davis, USA
6 shared publications - Giorgis Georgakoudis
Lawrence Livermore National Laboratory
5 shared publications - Konstantinos Parasyris
Lawrence Livermore National Laboratory
5 shared publications - Dolores Miao
University of California, Davis, Davis, USA
4 shared publications Martin Schulz
Technische Universität München Munich Germany
4 shared publications- Ang Li
Pacific Northwest National Laboratory
3 shared publications
Latest Publications
- 24 December 2025
- Published by Elsevier in Journal of Systems and Software
- Vol. 234
Leveraging explainable AI to characterize floating-point exceptions in linear solvers
- 24 December 2025
- Published by Elsevier in Journal of Systems and Software
- Vol. 234
Leveraging explainable AI to characterize floating-point exceptions in linear solvers
- Open Access
- 15 November 2025
- Published by Association for Computing Machinery (ACM)
- p. 1057-1065
Scabbard: LLVM Instrumentation-aided Race Checking in CPU/GPU Unified Memory for AMD GPUs
- 15 November 2025
- Published by Association for Computing Machinery (ACM)
- p. 1057-1065
Open AccessScabbard: LLVM Instrumentation-aided Race Checking in CPU/GPU Unified Memory for AMD GPUs
- Open Access
- 9 October 2025
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Programming Languages
- Vol. 9 (OOPSLA2) , 1063-1091
Synthesizing Sound and Precise Abstract Transformers for Nonlinear Hyperbolic PDE Solvers
Partial Differential Equations (PDEs) play a ubiquitous role in scientific computing and engineering. While numerical methods make solving PDEs tractable, these numerical solvers encounter several issues, particularly for hyperbolic PDEs. These issues arise from multiple sources including the PDE’s physical model, which can lead to effects like shock wave formation, and the PDE solver’s inherent approximations, which can introduce spurious numerical artifacts. These issues can cause the solver’s program execution to crash (due to overflow) or return results with unacceptable levels of inaccuracy (due to spurious oscillations or dissipation). Moreover, these challenges are compounded by the nonlinear nature of many of these PDEs. In addition, PDE solvers must obey numerical invariants like the CFL condition. Hence there exists a critical need to apply program analysis to PDE solvers to certify such problems do not arise and that invariants are always satisfied. As a solution, we develop Phocus, which is the first abstract interpretation of hyperbolic PDE solvers. Phocus can certify precise bounds on nonlinear PDE solutions and certify key invariants such as the CFL condition and a solution’s total variation bound. Hence Phocus can verify the absence of shock formation, the stability of the solver, and bounds on the amount of spurious numerical effects. To enable effective abstract interpretation of hyperbolic PDE solvers, Phocus uses a novel optimization-based procedure to synthesize precise abstract transformers for multiple finite difference schemes. To evaluate Phocus, we develop a new set of PDE benchmark programs and use them to perform an extensive experimental evaluation which demonstrates Phocus’s significant precision benefits and scalability to several thousand mesh points.
- 9 October 2025
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Programming Languages
- Vol. 9 (OOPSLA2) , 1063-1091
Open AccessSynthesizing Sound and Precise Abstract Transformers for Nonlinear Hyperbolic PDE Solvers
Partial Differential Equations (PDEs) play a ubiquitous role in scientific computing and engineering. While numerical methods make solving PDEs tractable, these numerical solvers encounter several issues, particularly for hyperbolic PDEs. These issues arise from multiple sources including the PDE’s physical model, which can lead to effects like shock wave formation, and the PDE solver’s inherent approximations, which can introduce spurious numerical artifacts. These issues can cause the solver’s program execution to crash (due to overflow) or return results with unacceptable levels of inaccuracy (due to spurious oscillations or dissipation). Moreover, these challenges are compounded by the nonlinear nature of many of these PDEs. In addition, PDE solvers must obey numerical invariants like the CFL condition. Hence there exists a critical need to apply program analysis to PDE solvers to certify such problems do not arise and that invariants are always satisfied. As a solution, we develop Phocus, which is the first abstract interpretation of hyperbolic PDE solvers. Phocus can certify precise bounds on nonlinear PDE solutions and certify key invariants such as the CFL condition and a solution’s total variation bound. Hence Phocus can verify the absence of shock formation, the stability of the solver, and bounds on the amount of spurious numerical effects. To enable effective abstract interpretation of hyperbolic PDE solvers, Phocus uses a novel optimization-based procedure to synthesize precise abstract transformers for multiple finite difference schemes. To evaluate Phocus, we develop a new set of PDE benchmark programs and use them to perform an extensive experimental evaluation which demonstrates Phocus’s significant precision benefits and scalability to several thousand mesh points.
- Open Access
- 20 July 2025
- Published by Association for Computing Machinery (ACM)
- p. 1-12
FloatGuard: Efficient Whole-Program Detection of Floating-Point Exceptions in AMD GPUs
- 20 July 2025
- Published by Association for Computing Machinery (ACM)
- p. 1-12
Open AccessFloatGuard: Efficient Whole-Program Detection of Floating-Point Exceptions in AMD GPUs
- Open Access
- 22 June 2025
- Published by Association for Computing Machinery (ACM)
- p. 1-12
Accurate Differential Analysis using Record and Selective Replay
- 22 June 2025
- Published by Association for Computing Machinery (ACM)
- p. 1-12
Open AccessAccurate Differential Analysis using Record and Selective Replay
- Open Access
Testing the Unknown: A Framework for OpenMP Testing via Random Program Generation
We present a randomized differential testing approach to test OpenMP implementations. In contrast to previous work that manually creates dozens of verification and validation tests, our approach is able to randomly generate thousands of tests, exposing OpenMP implementations to a wide range of program behaviors. We represent the space of possible random OpenMP tests using a grammar and implement our method as an extension of the Varity program generator. By generating 1,800 OpenMP tests, we find various performance anomalies and correctness issues when we apply it to three OpenMP implementations: GCC, Clang, and Intel. We also present several case studies that analyze the anomalies and give more details about the classes of tests that our approach creates.
Open AccessTesting the Unknown: A Framework for OpenMP Testing via Random Program Generation
We present a randomized differential testing approach to test OpenMP implementations. In contrast to previous work that manually creates dozens of verification and validation tests, our approach is able to randomly generate thousands of tests, exposing OpenMP implementations to a wide range of program behaviors. We represent the space of possible random OpenMP tests using a grammar and implement our method as an extension of the Varity program generator. By generating 1,800 OpenMP tests, we find various performance anomalies and correctness issues when we apply it to three OpenMP implementations: GCC, Clang, and Intel. We also present several case studies that analyze the anomalies and give more details about the classes of tests that our approach creates.
- Open Access
Testing GPU Numerics: Finding Numerical Differences Between NVIDIA and AMD GPUs
As scientific codes are ported between GPU platforms, continuous testing is required to ensure numerical robustness and identify numerical differences. Compiler-induced numerical differences occur when a program is compiled and run on different GPUs, and the numerical outcomes are different for the same input. We present a study of compiler-induced numerical differences between NVIDIA and AMD GPUs. Our approach uses Varity to generate thousands of short numerical tests in CUDA and HIP, and their inputs; then, we use differential testing to check if the program produced a numerical inconsistency when run on these GPUs. We also use the HIPIFY tool to convert CUDA tests into HIP and check if there are numerical inconsistencies induced by HIPIFY. We generated more than 600,000 tests and found subtle numerical differences that come from (1) math library calls, (2) differences in floating-point precision (FP64 versus FP32), and (3) converting code with HIPIFY.
Open AccessTesting GPU Numerics: Finding Numerical Differences Between NVIDIA and AMD GPUs
As scientific codes are ported between GPU platforms, continuous testing is required to ensure numerical robustness and identify numerical differences. Compiler-induced numerical differences occur when a program is compiled and run on different GPUs, and the numerical outcomes are different for the same input. We present a study of compiler-induced numerical differences between NVIDIA and AMD GPUs. Our approach uses Varity to generate thousands of short numerical tests in CUDA and HIP, and their inputs; then, we use differential testing to check if the program produced a numerical inconsistency when run on these GPUs. We also use the HIPIFY tool to convert CUDA tests into HIP and check if there are numerical inconsistencies induced by HIPIFY. We generated more than 600,000 tests and found subtle numerical differences that come from (1) math library calls, (2) differences in floating-point precision (FP64 versus FP32), and (3) converting code with HIPIFY.
- Open Access
- 3 June 2024
- Published by Association for Computing Machinery (ACM)
- p. 83-93
FPBOXer: Efficient Input-Generation for Targeting Floating-Point Exceptions in GPU Programs
Numerical programs that generate floating-point exceptions, such as NaNs, are inherently unreliable, as these programs can produce meaningless outputs or affect control flow. When these programs run on GPUs, one cannot rely on hardware traps to handle the exceptions, as most GPUs do not support them. Unfortunately, we must also employ black-box testing for many such GPU programs, as they are supplied as binary code only. While previous work has shown that black-box testing for triggering floating-point exceptions can be approached using Bayesian Optimization, their approach cannot handle programs with more than three inputs. We contribute a new tool, FPBOXer, which pushes up the capabilities of BO to handle over 20 inputs---this makes our contribution capable of handling realistic HPC program functions. In addition to delivering an overall 90x speedup over the previous methods, FPBOXer does not suffer from "self-inflicted" exceptions that are caused by the BO algorithm itself---something that previous tools did. This is achieved through parallel deployments of asynchronous BO searches, which has the beneficial side-effect of improving the GPU-utilization. By using FPBOXer, developers can, for the first time, find exception-causing inputs in realistic HPC programs, as we demonstrate when we apply FPBOXer to NAS, Lampps, CFD, ExaMiniMD, HPCCG, MiniFE, and BDCSVD.
- 3 June 2024
- Published by Association for Computing Machinery (ACM)
- p. 83-93
Open AccessFPBOXer: Efficient Input-Generation for Targeting Floating-Point Exceptions in GPU Programs
Numerical programs that generate floating-point exceptions, such as NaNs, are inherently unreliable, as these programs can produce meaningless outputs or affect control flow. When these programs run on GPUs, one cannot rely on hardware traps to handle the exceptions, as most GPUs do not support them. Unfortunately, we must also employ black-box testing for many such GPU programs, as they are supplied as binary code only. While previous work has shown that black-box testing for triggering floating-point exceptions can be approached using Bayesian Optimization, their approach cannot handle programs with more than three inputs. We contribute a new tool, FPBOXer, which pushes up the capabilities of BO to handle over 20 inputs---this makes our contribution capable of handling realistic HPC program functions. In addition to delivering an overall 90x speedup over the previous methods, FPBOXer does not suffer from "self-inflicted" exceptions that are caused by the BO algorithm itself---something that previous tools did. This is achieved through parallel deployments of asynchronous BO searches, which has the beneficial side-effect of improving the GPU-utilization. By using FPBOXer, developers can, for the first time, find exception-causing inputs in realistic HPC programs, as we demonstrate when we apply FPBOXer to NAS, Lampps, CFD, ExaMiniMD, HPCCG, MiniFE, and BDCSVD.
- Open Access
- 30 May 2024
- Published by Association for Computing Machinery (ACM)
- p. 201-212
Input Range Generation for Compiler-Induced Numerical Inconsistencies
Compiler-induced numerical inconsistencies present a significant challenge when testing and verifying numerical software—they can arise in a variety of situations, such as when porting code to a new platform or when using a different compiler or optimization flag. While existing tools can identify the source code location that induce an inconsistency for a specific input, no techniques are available to find input ranges where inputs that trigger these inconsistencies exist. In this paper, we propose a multi-phase approach to detect unknown input ranges that induce such inconsistencies; we call them inconsistency-inducing inputs. Our approach combines input-partitioned and coverage-based input sampling, input clustering, and optimization algorithms. We implement our approach in the tool CIGEN, which finds inputs that trigger high compiler-induced inconsistencies in numerical programs and outputs a list of input ranges containing such inconsistency-inducing inputs. Our experimental evaluation show 53.4% improvement over the state of the art in finding inputs that trigger compiler-induced inconsistencies in 175 GNU Scientific Library (GSL) functions. We further examine a subset of the inconsistencies and discuss their characteristics and possible root causes.
- 30 May 2024
- Published by Association for Computing Machinery (ACM)
- p. 201-212
Open AccessInput Range Generation for Compiler-Induced Numerical Inconsistencies
Compiler-induced numerical inconsistencies present a significant challenge when testing and verifying numerical software—they can arise in a variety of situations, such as when porting code to a new platform or when using a different compiler or optimization flag. While existing tools can identify the source code location that induce an inconsistency for a specific input, no techniques are available to find input ranges where inputs that trigger these inconsistencies exist. In this paper, we propose a multi-phase approach to detect unknown input ranges that induce such inconsistencies; we call them inconsistency-inducing inputs. Our approach combines input-partitioned and coverage-based input sampling, input clustering, and optimization algorithms. We implement our approach in the tool CIGEN, which finds inputs that trigger high compiler-induced inconsistencies in numerical programs and outputs a list of input ranges containing such inconsistency-inducing inputs. Our experimental evaluation show 53.4% improvement over the state of the art in finding inputs that trigger compiler-induced inconsistencies in 175 GNU Scientific Library (GSL) functions. We further examine a subset of the inconsistencies and discuss their characteristics and possible root causes.
- Open Access
- 3 March 2024
- Published by Association for Computing Machinery (ACM)
- p. 22-31
MUPPET
Performance optimization continues to be a challenge in modern HPC software. Existing performance optimization techniques, including profiling-based and auto-tuning techniques, fail to indicate program modifications at the source level thus preventing their portability across compilers. This paper describes Muppet, a new approach that identifies program modifications called mutations aimed at improving program performance. Muppet's mutations help developers reason about performance defects and missed opportunities to improve performance at the source code level. In contrast to compiler techniques that optimize code at intermediate representations (IR), Muppet uses the idea of source-level mutation testing to relax correctness constraints and automatically discover optimization opportunities that otherwise are not feasible using the IR. We demonstrate the Muppet's concept in the OpenMP programming model. Muppet generates a list of OpenMP mutations that alter the program parallelism in various ways, and is capable of running a variety of optimization algorithms such as Bayesian Optimization and delta debugging to find a subset of mutations which, when applied to the original program, cause the most speedup while maintaining program correctness. When Muppet is evaluated against a diverse set of benchmark programs and proxy applications, it is capable of finding sets of mutations in 70% of the evaluated programs that induce speedup.
- 3 March 2024
- Published by Association for Computing Machinery (ACM)
- p. 22-31
Open AccessMUPPET
Performance optimization continues to be a challenge in modern HPC software. Existing performance optimization techniques, including profiling-based and auto-tuning techniques, fail to indicate program modifications at the source level thus preventing their portability across compilers. This paper describes Muppet, a new approach that identifies program modifications called mutations aimed at improving program performance. Muppet's mutations help developers reason about performance defects and missed opportunities to improve performance at the source code level. In contrast to compiler techniques that optimize code at intermediate representations (IR), Muppet uses the idea of source-level mutation testing to relax correctness constraints and automatically discover optimization opportunities that otherwise are not feasible using the IR. We demonstrate the Muppet's concept in the OpenMP programming model. Muppet generates a list of OpenMP mutations that alter the program parallelism in various ways, and is capable of running a variety of optimization algorithms such as Bayesian Optimization and delta debugging to find a subset of mutations which, when applied to the original program, cause the most speedup while maintaining program correctness. When Muppet is evaluated against a diverse set of benchmark programs and proxy applications, it is capable of finding sets of mutations in 70% of the evaluated programs that induce speedup.