## Parallelised Veto Algorithm for GPU-Accelerated Parton Showers This document details a parallelised Sudakov veto algorithm for simulating parton showers on GPUs, significantly accelerating high-energy physics event generation. ### 1. The Sudakov Veto Algorithm The standard Sudakov veto algorithm is a crucial component of most parton shower simulations. It works iteratively: 1. **Generate Emission:** Propose a parton emission at an evolution scale *t*. 2. **Acceptance/Veto:** Accept the emission with a probability given by the ratio of the emission probability to its overestimate. If rejected (vetoed), return to step 1. 3. **Select Winner:** If multiple emissions are possible, select the one with the highest *t*. 4. **Make Parton:** Add the accepted parton to the event. 5. **Repeat:** Continue until the evolution scale reaches a cutoff *t_C*. The Sudakov veto ensures that the probability of emitting a parton at a given scale is correctly accounted for. Imagine rolling a die. If you roll a 1 or 2, you "veto" the roll and try again. If you roll a 3, 4, 5, or 6, you "accept" the roll. This is analogous to the acceptance/veto step, where the probability of acceptance is less than 1. ### 2. Parallelization for GPUs The key innovation is to perform each step of the Sudakov veto algorithm *simultaneously* for all events. This leverages the Single Instruction Multiple Thread (SIMT) architecture of GPUs, where many threads execute the same instruction on different data. The independence of each event makes this parallelization highly efficient. **Challenges and Solutions:** * **Idle Threads:** Some events may fail the veto check, leading to idle threads. Modern GPUs mitigate this through independent thread scheduling. Threads that finish processing one event can immediately start on another. * **Cutoff Synchronization:** All events must reach the cutoff scale *t_C* before the shower ends. Again, efficient thread scheduling minimizes the waiting time. The GPU's warp scheduler and convergence optimizer handle synchronization automatically, simplifying development. Assuming all threads will always be busy during the entire simulation can lead to inaccurate performance predictions. ### 3. Implementation and Results (LEP at 91.2 GeV) The parallelised algorithm was implemented in CUDA C++ for *e⁺e^- → q q̄* events at LEP energy (91.2 GeV). A CPU-only version was also created for comparison. #### 3.1 Validation Both CPU and GPU implementations reproduced results from a reference implementation, validating the correctness of the parallelised code. This was confirmed by comparing jet rates (Durham algorithm) and event shapes (thrust and heavy jet mass). The agreement between the CPU and GPU results for jet rates and event shapes demonstrates the accuracy of the parallelised algorithm. #### 3.2 Execution Time Comparison The GPU implementation showed significant speedups compared to the CPU, especially for a large number of events ( > 1000). The speedup increased with the number of events, reaching factors of 86x (matrix element), 266x (parton shower), and 179x (observables) for 10⁶ events. The speedup is not perfectly linear due to the limitations of GPU resources and memory management overhead. #### 3.3 Energy Consumption While the GPU (250W) consumes more power than a single CPU core (85W/16 cores ≈ 5W), the overall energy consumption is significantly lower due to the massive speedup. To match the GPU's performance, one would need many more CPUs, resulting in a much higher total power consumption. ### 4. Concluding Remarks This work demonstrates the successful parallelization of the Sudakov veto algorithm for GPU-accelerated parton shower simulations. The significant speedup achieved opens up possibilities for more computationally intensive simulations in high-energy physics. The code (GAPS) is available as an open-source project. This approach can be extended to other parton shower models and provides a foundation for future optimizations.