Awkward Array speeds up physics data with python cuda computing
GPU Acceleration of Awkward Arrays: Using Python cuda.compute
Distributed, Parallel, and Cluster ComputingPerformanceSoftware Engineering
Summary
Large physics experiments generate very complex and nested data that needs special tools to analyze efficiently. The authors improved a Python library called Awkward Array to better use graphics cards (GPUs) for faster processing. They created a new way to run Awkward Array operations on GPUs with fewer slow steps and allowed more flexible, user-defined operations. This helps scientists handle complicated data faster, especially for future large physics experiments.
What this means in practice
- •For high-energy physics data analysts: Speed up analysis of complex nested data sets using GPUs with fewer overheads and more flexible operations in Python.
- •For data engineers handling irregular data: Integrate custom Python code into GPU workflows to accelerate processing of variable-length, nested data structures.
Authors
Maksym Naumchyk, Ianna Osborne
Abstract
Awkward Array is a widely used library in high-energy physics (HEP) for representing and manipulating nested, variable-length data in Python. Previous CHEP contributions have explored GPU acceleration for Awkward Array, demonstrating the feasibility and performance benefits of CUDA-based backend while also identifying limitations related to irregular data access, fine-grained kernel launches, and composability of operations. In this contribution, we present recent developments that build directly on these earlier efforts by introducing a CUDA execution model for Awkward Array based on the Python CUDA Core Compute Libraries (CCCL). Using CCCL, we eliminate the need for custom CUDA kernels and can instead use a high-level Python interface. The CCCL-based approach also enables fusion of multiple Awkward operations into a reduced number of CUDA kernels, addressing kernel launch overhead observed in earlier GPU implementations. Lazy execution allows expression graphs to be constructed and optimized prior to kernel generation, improving performance for analysis workflows involving jagged arrays, combinatorial operations, and reductions. In contrast to earlier approaches, this design also emphasizes extensibility, allowing user-defined Python code to be incorporated into GPU execution paths with minimal boilerplate and without breaking existing analysis semantics. We present performance studies that demonstrate improvements over previously reported eager GPU execution strategies for representative HEP analysis patterns. These developments extend the GPU capabilities of Awkward Array toward a more composable and sustainable backend, aligned with the needs of Python-based analysis at the HL-LHC and beyond.