Source-linked AI summary
FIESTA 4: optimized Feynman integral calculations with GPU support
Alexander V. Smirnov
TL;DR
FIESTA’s numerical integration becomes increasingly costly when higher precision requires many more sampling points. This release combines vectorization, cluster and GPU parallelization, and stability improvements; it reports 2–4× speed gains over the previous version and another 2–4× from GPUs under suitable sampling conditions.
Problem
Increasing sampling points to reduce uncertainty is computationally expensive: a 100-fold increase gives roughly a 10-fold error-estimate reduction while increasing time about 100-fold.
Method
FIESTA4 uses two parallelization layers—distributing integrands across processes and evaluating multiple points through vectorization or GPUs—alongside cluster and stability options.
Results
The new version is about 2–4 times faster than the old one, and GPU usage can add another 2–4 times improvement over pure CPU mode when enough sampling points are available.
Takeaways & Limitations
FIESTA4 supports large-scale numerical integration by combining parallelization approaches that can be used simultaneously for maximal performance.
Takeaways & Limitations
GPU acceleration requires an NVIDIA CUDA-capable setup, and laptop GPUs with only 2 streaming multiprocessors cannot provide performance benefits in FIESTA.
Abstract
from arXiv · showhide
This paper presents a new major release of the program FIESTA (Feynman Integral Evaluation by a Sector decomposiTion Approach). The new release is mainly aimed at optimal performance at large scales when one is increasing the number of sampling points in order to reduce the uncertainty estimates. The release now supports graphical processor units (GPU) for the numerical integration, methods to optimize cluster-usage, as well as other speed, memory, and stability improvements.
PROGRAM SUMMARY
FIESTA4 is a parallelized program designed for numerical Feynman-integral evaluation across systems ranging from desktop computers to supercomputers, with GPU-capable sampling-point evaluation.
- FIESTA4 is written in Wolfram Mathematica 7.0 or higher and C++, and is licensed under GPLv2.
- The program supports parallel execution from one processor up to loading a supercomputer.
- Sampling-point evaluation is vectorized and can use graphical processing units for parallelization.
- Problem complexity is mostly limited by the CPU time required for integration and obtaining proper precision.
1. Introduction
FIESTA evaluates Feynman integrals through sector decomposition and numerical integration, with the new release targeting the steep computational cost of higher precision through parallelization, GPUs, and stability improvements.
- Sector decomposition is an automatic approach to evaluating Feynman integrals, implemented in FIESTA and other public programs.
- Feynman integrals use dimensional regularization with d = 4 − 2ε, and their numerical evaluation proceeds in the epsilon expansion after fixing kinematic invariants and masses.
- The approach is based on the alpha-representation, whose constructively defined U and F Symanzik polynomials depend on the Feynman parameters.
- A 100-fold increase in sampling points yields roughly a 10-fold decrease in the error estimate, while increasing computation time about 100-fold.
- The new release addresses high-precision computation with internal vectorization, cluster usage, GPU usage, and stability features for large-scale jobs.
- The new version is about 2–4 times faster than the old one, while GPU use can provide 2–4 more times improvement over pure CPU mode when enough sampling points are used.
2. Parallelization in FIESTA
FIESTA uses two complementary parallelization layers: distributing integrands across processes or cluster nodes, and evaluating multiple sampling points simultaneously through vectorization or GPUs. The release also addresses GPU constraints, thread coordination, memory limits, and cluster-job stability.
- Vectorization: Vectorization evaluates multiple sampling points simultaneously, using the Cuba library after FIESTA parses integrands into operation sequences.The approach targets integrands that are almost rational functions and requires no user changes.
- GPU usage: GPU evaluation prepares a kernel, transfers input data to GPU memory, runs thread blocks on the data, and copies results back to RAM.FIESTA uses this kernel-and-thread-grid approach for numerical integration.
- GPU usage: GPU throughput depends on hardware and memory constraints: FIESTA uses 128-thread blocks, while complex evaluations consume registers and intermediate storage.The number of simultaneously evaluated points must fit available GPU memory, and some GPUs cannot be fully loaded because of register use.
- Parallel integration: FIESTA can assign selected integration threads to GPU accelerators, but Cuba’s shared-memory parallelization is disabled by default because transfers can cause slowdown.The option may help when more processor kernels are available than integration terms; tests indicate at least four threads should use a GPU.
- Cluster usage: Cluster calculations can continue from saved intermediate results after crashes or timeouts, while frozen slave jobs can be resubmitted to other nodes.The -continue option is most useful for lengthy calculations when integration time dominates synchronization overhead.
- Cluster usage: FIESTA distributes different integrands across multiple processes on one computer or across a cluster.Its CIntegratePoolMPI variant assigns work from a master task to slave nodes, which launch integration binaries.
3. Benchmarks
The benchmarks evaluate FIESTA4 on a four-loop non-planar on-shell propagator integral using different CPU, GPU, and parallelization configurations. They show substantial speedups from GPU use and parallel execution, while performance depends on hardware and sampling-point count.
- The benchmark uses a quark-mass-relation example with a roughly 200 MB database containing 649 integrands.
- Three computer configurations vary processor-core and GPU counts, from 4 cores with 1 GPU to 8 cores with 2 GPUs.
- The first test compares GPU calculation, CPU calculation, and the old CPU-only FIESTA version across different sampling-point counts.
- The optimization test finds the best arrangement uses 4 cores with the GPU and 4 cores with the CPU on the tested 8-core system.The tested processor and GPU combination is less optimal for FIESTA4's new features, so its speed gain is smaller.
- On an 8-core Lomonosov node, two GPUs provide a 4-times speedup over an 8-kernel node without GPUs.For small sampling-point counts, MPI communication overhead causes some slowdown.
- Parallel evaluation reduced a calculation that would require about 1000 years sequentially on one CPU to a computation completed using several months of CPU time.
4. Installation and usage
FIESTA4 combines Mathematica-based preparation with C++ integration binaries, supporting threaded, MPI, and GPU execution across desktop and cluster workflows. Installation requires platform-specific libraries and separate build targets for MPI and GPU components.
- Program usage: FIESTA4 can be used without its C++ component, but this removes access to most of the program’s features.The documentation therefore recommends using the C++ part for the described options.
- Installation: Source installation requires numerical libraries including MPFR and GMP, with qhull additionally needed for selected sector-decomposition strategies.An MPI environment is required when building the MPI integration pool.
- Installation: Building the GPU integrators requires CUDA libraries and drivers, and the GPU build is produced with the `make gpu` target.The regular build does not create the GPU integration workers or MPI pool automatically.
- Code structure: FIESTA4 prepares integration databases in Mathematica, while CIntegratePool evaluates them and returns results through temporary files and output databases.The final numerical result is generated from the saved output database.
- Program usage: The `OnlyPrepare` workflow separates database creation from integration, allowing shell execution on other computers and experimentation with integration options before generating the final answer.After integration, Mathematica uses `GenerateAnswer[]` to produce the result.
- Code structure: The standard pool distributes tasks with threads, while CIntegratePoolMPI provides an MPI-based option for cluster use.Integration workers are selected from binaries supporting CPU, complex-number, and GPU execution.
5. Conclusion
The new FIESTA release adds substantial performance improvements and GPU support for Feynman-integral calculations.
- The release improves integration speed by about 2–4 times compared with the previous version.
- GPU calculations can provide another 2–4 times speed improvement over pure CPU usage.
- The release also adds new options and improvements in calculation capabilities.