Search

The amount of data coming from modern acquisition systems, especially working in extreme experimental conditions, is significantly rising over the years. Combined with complex algorithms, the computation time and power consumption are considerably increasing. The issue usually occurs in many world laboratories, such as CERN, Brookhaven National Laboratory, GSI Helmholtzzentrum für Schwerionenforschung, and tokamak devices (JET, WEST, MAST, and more). Often well verified, but legacy codes are used as a main computational engine, resulting in weak performance unsuitable for current needs. The paper presents a methodology to appropriately adapt the legacy C/C++ high-energy physics (HEP) algorithms for computation acceleration using FPGAs, which may improve the designing of real-time systems based on verified codes. The main idea is to separate the HLS-FPGA code work areas between groups of experts: physicists and electronics. The methodology consists of several parts: interfacing, storage, verification methods, defining the algorithm and data structures, program refactoring in the scope of CPU and FPGA, performance and results analysis, FPGA verification methods, FPGA performance estimation, and automatization of the process. The methodology has been successfully tested by implementing a legacy, complex HEP algorithm for femtoscopy correlations in the HLS framework for FPGA. It works with extensive input data from international experiments, like STAR at RHIC. The implementation and verification were done successfully on the FPGA hardware platform. Following the methodology results in a clearer to analyze and debug HEP code than a machine-generated version by tools. We also confirmed that it is possible to make a working, HLS-compliant program designed by non-FPGA experts. Using the modern implementation tools, FPGA resource usage is low despite unoptimized syntax. It gives a large field for further significant optimizations and good performance. The proposed approach should be interesting to introduce in devices like tokamaks, synchrotrons, and similar, where the real-time monitoring of the experimental processes is essential. • Methodology of complex algorithms conversion from legacy code to FPGA accelerated using High-Level Synthesis languages. • Preliminary hardware FPGA laboratory tests of the Monte-Carlo HEP algorithm for heavy-ion collisions using presented approach. • Guidelines to achieve the performance improvement of legacy high-energy physics algorithms. • Elaboration on High-Level Synthesis (HLS) languages usage for complex algorithms acceleration used in physics experiments. [ABSTRACT FROM AUTHOR]

This paper describes our approach to developing a simulation software application for the fully kinetic 6D-Vlasov equation, which will be used to explore physics beyond the reduced gyrokinetic model. Simulating the fully kinetic Vlasov equation requires efficient utilization of compute and storage capabilities due to the high dimensionality of the problem. In addition, the implementation needs to be extensible regarding the physical model and flexible regarding the hardware for production runs. We start on the algorithmic background to simulate the 6-D Vlasov equation using a semi-Lagrangian algorithm. The performance portable software stack, which enables production runs on pure CPU as well as AMD or Nvidia GPU accelerated nodes, is presented. The extensibility of our implementation is guaranteed through the described software architecture of the main kernel, which achieves a memory bandwidth of almost 500 GB/s on a V100 Nvidia GPU and around 100 GB/s on an Intel Xeon Gold CPU using a single code base. We provide performance data on multiple node-level architectures discussing utilized and further available hardware capabilities. Finally, the network communication bottleneck of 6-D grid-based algorithms is quantified. A verification of physics beyond gyrokinetic theory, for the example of ion Bernstein waves, concludes the work. • Performance portable implementation of a semi-Lagrangian algorithm for full kinetics. • Software architecture for Lagrange interpolation stencils using design patterns. • Node level performance analysis for OpenMP, HIP and CUDA using a single code base. • Quantification of the network communication bottleneck for 6D distributed grids. [ABSTRACT FROM AUTHOR]

Nowadays, the interoperability and interfacing of codes and libraries have become crucial aspects of software development and engineering, and the basis for enabling and simplifying the sharing of methods and tools, both within and among communities. One of the most important bottlenecks that arises when developing and maintaining an interface of a library with an already existing software, is to keep it aligned with the development route of the latter. This might include significant changes, such as changes in the data structures used by the library, which are communicated through the interface. In this paper, an approach for inserting a new algorithm into existing software is presented, through a minimally invasive interface, that takes over an already present algorithm, and thus changes its original purpose. The approach is applied to the well-established Activation-Relaxation Technique nouveau (ARTn) algorithm, that is revisited and re-engineered to bias and take over the FIRE minimization algorithm, as presently implemented in two community codes for atomistic simulations, namely Quantum ESPRESSO (PWscf) and LAMMPS. ARTn is a well established single-ended saddle-point search algorithm that allows for the exploration of potential energy surfaces. The resulting algorithm acts as a plugin, and is distributed in the form of an external library (pARTn). Program Title: plugin Activation Relaxation Technique nouveau (pARTn) CPC Library link to program files: https://doi.org/10.17632/xpwr56d2yk.1 Developer's repository link: https://gitlab.com/mammasmias/artn-plugin Licensing provisions: Apache-2.0/GPLv3 Programming language: Modern Fortran and C++ Nature of problem: Original ARTn implementation was difficult to interface, port and maintain. Solution method: Full refactoring and re-engineering into a library, which utilizes and biases a minimization algorithm already implemented in the engine, to make it behave as ARTn. The biasing is done by reverse-engineering specific external conditions that drive the displacement of atoms. [ABSTRACT FROM AUTHOR]