A multi-event interface for next-to-leading order calculations in MadGraph5_aMC@NLO

We detail the implementation of a multi-event interface for next-to-leading order (NLO) calculations in MadGraph5_aMC@NLO, allowing tree-level scattering amplitudes for multiple phase space points to be evaluated in each call to the integrated NLO differential cross section during event generation. Additionally, a multithreaded implementation based on this multi-event interface where tree-level amplitudes are evaluated in parallel across multiple CPU threads is presented for the Monte Carlo generation of quantum chromodynamical (QCD) events. Although this work primarily concerns the implemented code, some algorithmic changes involving the order of the application of phase-space cuts and calls to different scattering amplitudes are included. The codebase currently supports multi-threaded execution, but these changes pave the way for continued data parallelism in the form of on-CPU SIMD instructions or SIMT GPU offloading. A study in the runtime fraction spent in different diagrammatic contributions across various processes suggests that NLO QCD event generation are computationally dominated by tree-level scattering amplitude evaluations, which we show are perfectly suited for data parallelisation.

💡 Research Summary

**
The paper presents a comprehensive redesign of the next‑to‑leading order (NLO) event‑generation workflow in MadGraph5_aMC@NLO (MG5aMC) to enable data‑parallel evaluation of scattering amplitudes. The authors introduce a “multi‑event interface” that allows a single call to the integrated differential cross‑section routine to process n phase‑space points simultaneously, rather than the traditional one‑point‑at‑a‑time approach.

In the original MG5aMC code, the core routine sigintF receives a random number array, maps it to a phase‑space point, and then sequentially evaluates Born, virtual (loop), real‑emission, and the associated subtraction (counter‑term) contributions. This algorithm is highly branching, relies on global data structures, and therefore is ill‑suited for SIMD or GPU execution.

The new interface restructures the workflow as follows: (1) a single random seed array generates n momentum configurations for both the n‑body (Born) and (n + 1)‑body (real) kinematics; (2) all required running couplings are computed for each configuration; (3) tree‑level amplitudes are evaluated in a vectorised fashion, returning an array of complex numbers; (4) the accumulated contributions (Born, real, subtraction, etc.) are built by feeding these pre‑computed amplitudes into the existing evaluation routines. By passing the amplitudes as arguments rather than recomputing them inside each sub‑routine, the implementation automatically re‑uses amplitudes that appear in multiple contributions (e.g., the same Born amplitude entering several counter‑terms).

To demonstrate feasibility, the authors implement a proof‑of‑concept multithreaded version using OpenMP. Each thread processes a subset of the n phase‑space points, while global data access is eliminated and helicity‑symmetric configurations are identified beforehand to avoid redundant calculations. Benchmarks on an 8‑core CPU show a speed‑up of roughly 1.8× compared with the original sequential code. Although this gain is modest—comparable to running several independent event‑generation jobs in parallel—it validates the correctness of the interface (bit‑wise agreement for n = 1, with only a single negligible discrepancy) and establishes a baseline for future SIMD or GPU acceleration.

A detailed runtime profiling across several representative processes (e.g., pp → tt̄, pp → Z + jet) reveals that tree‑level amplitude evaluation accounts for more than 70 % of the total NLO event‑generation time. Consequently, the authors argue that data‑parallelisation of this component offers the largest potential performance improvement.

The paper also discusses current limitations. Because phase‑space cuts are applied after the amplitude‑evaluation loop, some amplitudes are computed only to be discarded later, introducing unnecessary work. Future versions could move cut checks earlier or employ dynamic scheduling to mitigate this overhead. Moreover, the multi‑event interface is deliberately designed to be compatible with the existing CUDACPP plugin, which already accelerates LO tree‑level amplitudes on SIMD‑enabled CPUs and SIMT GPUs. Extending the same plugin to NLO amplitudes should be straightforward, promising order‑of‑magnitude speed‑ups on modern hardware.

In conclusion, the authors provide a solid software engineering foundation for parallel NLO event generation. By exposing a vectorised amplitude API and demonstrating a working multithreaded implementation, they show that the dominant computational bottleneck—tree‑level amplitude evaluation—can be efficiently parallelised. This work paves the way for SIMD‑level CPU vectorisation and GPU off‑loading, which will be essential for meeting the demanding precision requirements of the High‑Luminosity LHC and future collider experiments.