Papers for

hpc application developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Energy use and performance vary with GPU number precision levels

Energy-Aware Performance Characterization of Kokkos Kernels Across Precision Levels

Abstract: Kokkos is a performance-portable programming model used in GPU-accelerated HPC applications comprising kernels with diverse computational and memory behaviors. We characterize kernels from two applications to evaluate how FP32, FP64, and mixed FP32/FP64 affect arithmetic intensity, performance throughput, and GPU energy consumption. We introduce an Energy-Aware Roofline Model that incorporates energy into performance analysis and a Thermal-Aware Inter-Kernel Energy Model that visualizes energy consumption alongside duration, GPU temperature, and execution order. We study both applications with: (1) fine-grained, application-level instrumentation through the Kokkos Performance Tools PAPI Connector and (2) coarse-grained PAPI instrumentation applied to a dedicated-kernel benchmark using vendor-specific power management components. Our analysis shows that precision effects vary by application, kernel, and workload. Mixed FP32/FP64 kernels generally achieve arithmetic intensity comparable to FP32, with modestly lower throughput and, in most cases, a modest increase in energy consumption. FP64 kernels generally exhibit the highest energy consumption among the evaluated precision configurations.

Thu 22 OctPerformance
The gist
Computers doing heavy calculations on GPUs can use different number types that affect how fast and energy-efficient they run. The authors looked at three ways of using these number types and measured how much work the GPUs did, their speed, and how much energy they used. They made new models to show the relationship between energy, performance, and temperature. Their findings show that using 64-bit numbers generally uses more energy, while mixing 32-bit and 64-bit numbers balances speed and energy better depending on the task.
Open → 2610.31917v1

Gpu aware mpi communication simulation for supercomputer design

Orrery: Modeling and Simulation of GPU-direct MPI Communication with SimGrid

Abstract: Simulation of HPC applications is an essential tool for analyzing system design trade-offs and enabling effective hardware--software co-design. As modern supercomputers increasingly rely on GPU acceleration, MPI implementations have evolved to support GPU-aware communication, enabling direct GPU data transfers. Modeling these mechanisms is therefore critical for simulating HPC applications on current systems. In this paper, we introduce Orrery, an interposition layer built on SimGrid's SMPI to model GPU-aware MPI communication using existing collective implementations and flow-based simulation. Orrery intercepts GPU memory allocations, kernel launches, data transfers, and MPI operations, and models their execution in SimGrid according to target system specifications, enabling simulation without requiring physical GPUs. We validate Orrery using CUDA-aware MPI microbenchmarks and a Jacobi solver on up to 32 nodes of the MUSICA supercomputer and demonstrate that it reproduces key GPU-aware MPI mechanisms.

Tue 13 OctDistributed, Parallel, and Cluster ComputingPerformance
The gist
Simulating programs that run on supercomputers helps researchers design better machines and software. As these supercomputers often use GPUs to speed up calculations, it’s important to model how GPUs communicate directly using MPI (a messaging system). The authors created Orrery, a tool that mimics how GPUs share data in an MPI environment without needing real GPUs. This tool was tested on a real supercomputer and matched key behaviors, making it useful for testing and improving high-performance computing setups.
Open → 2610.18565v1

LLM agents improve resilience in high performance computing applications

LLM Agents as Resilience Engineers for Scientific Applications

Abstract: Efficient checkpoint/restart support is essential for resilient HPC scientific applications, but implementing it requires substantial expertise: developers must identify recoverable state, choose globally consistent checkpoint points, and preserve application invariants during restart. We study whether frontier LLM coding agents can automate this process. We build a benchmark suite of 16 MPI applications spanning diverse domains, code sizes, and critical-state structures, and evaluate them with a no-human-in-the-loop generate--validate--revise pipeline for checkpoint/restart synthesis. Across the benchmark, the pipeline produces 41 working resilient implementations. Our results show that agent-driven resilience engineering is practical when critical state is visible or accessible through coherent abstractions: successful runs finish in under one hour on average, consume about 15M tokens, and produce implementations with negligible failure-free overhead and recovery efficiency comparable to human-written code. However, modularized and fragmented state remains a major limitation, with some failed attempts consuming over 100M tokens and 300 minutes without producing a working implementation.

Thu 8 OctDistributed, Parallel, and Cluster Computing
The gist
High-performance computing (HPC) applications need a way to save their work regularly so they can recover quickly from failures. This saving and recovery process is hard to implement because programmers must carefully identify and manage the important parts of the program's state. The authors tested whether advanced language models (LLMs) could automate this task. They found that LLMs can successfully generate checkpoint and restart code in many cases within about an hour, especially when the program’s important data is in clear and accessible structures. However, they struggle when the important data is scattered or complex.
Open → 2610.11260v1