An Algorithm to Parallelise Parton Showers on a GPU

1- demonstration of the feasability of a parton shower algorithms running on GPU
2- Clear explanations for a wide audience

The article describes a new implementation of a particle collision generator algorithm which runs on Graphical Processing Unit (GPU) computer system. Crucially, the algorithm includes the simulation of the parton shower (the QCD phenomena resulting from the emission of a quark of a gluon in the collision), by implementing a GPU version of the "Sudakov veto algorithm".
As clearly exposed and demonstrated in the article, the main advantage of this algorithm is its massively parallel execution on GPU, resulting in much faster or much more power efficient calculations than the same algorithm run on regular CPU.
The paper is well written and provide clear explanations, in particular through the annexes in which additional useful details for non experts are given.
The methodology is simple and robust and in my opinion supports the conclusions of the authors.
The article tackles an important problem for the future of particle physics research : obtaining a sustainable way of computing the necessary simulations to exploit the HL-LHC or potential future collider experiments.
As the authors provide a public repository for the source code of their algorithms, the reported work represents a concrete proof-of-concept for a solution of this problem in the event generation domain.
In my opinion a missing point is a discussion on how this work relates practically with existing generator software (Pythia, Herwig, others...), in particular if this implementation is compatible with others and/or can be easily ported (there's a sentence suggesting it is the case, but the point is to develop on this) and if it can be extended to more complex evaluations including higher-order calculations. Such a discussion would be more of an opinion rather than a scientific demonstration, but honest insights on how the algorithms can be generalized or adopted by the community would extremely instructive for all readers.

As a summary, I think this work is absolutely worth publishing, but I would insist the above discussion points are added, probably in the conclusion of the article.
Beside, I have other non-blocking minor questions and suggestion to clarify the document below.

- Figure 2 & annexe : For non experts, it is not immediately obvious what exactly is calculated as part of one parallel flow ( i.e. horizontal arrow connected boxes) : is it the successive emissions from 1 parton or all the emissions in one collision event. Simply stating it explicitely, ex as part of the caption of fig 2, would ease the reading.
- Figure 4 : the variables are not described. It would be good to give a description, even if very brief and an explanation of why they are relevant w.r.t. simpler variable such as pT or rapidity.
- figure 7 : Is the following interpretation correct : at cycle=80 we have 95% of events done but we need to wait 40 more cycle (That is 50% time more) for the parton shower step to end and move to observable calculation ? If so, is this (=waiting 50% longer for 5% of events) an intrinsic limitation of using GPUs ? if so this is an interesting point I would suggest is made in the article.
- Annexes : the pseudo-code are generally useful as they convey well the general ideas of the algs. There are a few confusing points which could be clarified :
* the is the parton_list in the 1st example a dynamic list owned by each thread ? Is it populated by the line "new parton(...)" in the 2nd example ?
* what is the "DeviceToHost" at the end of annex B ?
* there is multiple reference to "events [ idx ]. endShower" but it is nt very clear at which point in the examples this could be set to True ?

1- Discussion on how this work relates practically with existing generator software (Pythia, Herwig, others...), in particular if this implementation is compatible with others and/or can be easily ported (there's a sentence suggesting it is the case, but the point is to develop on this) and if it can be extended to more complex evaluations

Ask for minor revision

This paper proposes an algorithm for computing parton showers on a GPU.
It is therefore at the interface of physics and computer science.

The challenge is well motivated: simulation of parton showers is very resource intensive and presents a major bottleneck for experimental collaborations and theorists alike, while GPU hardware is becoming increasingly widespread and powerful, with the possibility of executing vast number of instructions simultaneously.

The paper is very clearly written, with a discussion of GPU architecture and the differences between programming for CPUs and GPUs; the algorithm is clearly described in terms of a flowchart and pseudocode in the appendix; there is an implementation with a physical application, and clear comparison of GPU and CPU performance; the implementation code is made public; the result is that their algorithm is much faster than the CPU equivalent and uses less energy. The paper is easy to read and interesting.

On the other hand, the idea behind their algorithm appears essentially just run each event on one GPU core, and run events in parallel. There is therefore little that is particular to a GPU compared to CPU computing, only that GPUs typically have of order 100 times as many cores as a CPU, and the authors admit that modern GPUs are designed with enough freedom that "allows developers to write sophisticated algorithms with little concern for optimisation or thread usage". Originally GPUs were designed to run many copies of simple commands, and therefore could not handle multiple branchings. This meant that parton showers were by default not suited to GPUs; the authors have not solved this problem, but instead rely on newer GPU technology being better able to handle warp divergence. One concern that I have is that, since their algorithm is essentially a toy model, an extrapolation to a full parton shower code would see the benefits reduced or disappear. I would appreciate if the authors could add some comments on this and the future prospects (of which currently there are none beyond some hopeful words), but otherwise in light of my above positive remarks I recommend the paper for publication.

1. Comment on the possibility of extrapolating to a more advanced parton shower algorithm and whether the GPU benefits will remain.

Ask for minor revision