Heavy-ion physics central a pivotal role in advancing our understanding of the fundamental properties of matter under extreme conditions. By studying collisions of heavy ions at high energies, researchers probe the behavior of quark-gluon plasma, a state of matter believed to have existed just moments after the Big Bang. These experiments help uncover the forces and interactions between the most basic constituents of matter, providing insight into the early evolution of the universe and guiding our understanding of phase transitions in nuclear matter at unprecedented energy densities.

Experimental facilities, such as particle accelerators and complex detector systems, provide unique opportunities to study the properties of elementary particles and their interactions at extreme energies, conditions that cannot be replicated in low-energy laboratory environments.

Research on particle collisions began with relatively simple tasks that could be handled manually, such as reconstructing particle trajectories in bubble chambers. However, as knowledge and understanding of the complex aspects of matter and interactions grew, the need for more in-depth analysis and investigation of increasingly intricate systems arose. As the volume of experimental data expanded and the complexity of the questions to be addressed increased, the demands on data processing and analysis methods grew significantly.

Modern research in heavy-ion physics is associated with the need to process vast volumes of data generated from high-energy nuclear collisions. This requires not only high-performance computing systems but also advanced analysis methods and algorithms capable of efficiently processing data and extracting meaningful information. As the complexity of the tasks and the volume of data increase, the demands for speed and quality of computational processing become critically important for the successful execution of research and the achievement of new scientific discoveries.

The results of modern experiments in heavy-ion physics can no longer be efficiently processed on individual computers and require the resources of large computational centers. Data analysis necessitates dozens or even hundreds of high-performance processors (CPUs) and graphics accelerators (GPUs), integrated into computing clusters and equipped with powerful cooling systems. These computational systems are major consumers of electrical energy.

On the other hand, the issue of global warming presents the scientific community and industry with the significant challenge of conserving energy and reducing greenhouse gas emissions. The growing energy demands associated with large-scale computing systems are in conflict with the need to reduce the carbon footprint. In the context of global efforts to minimize climate impact, it is essential to explore and implement innovative approaches to improving the energy efficiency of computational infrastructures. In addition, attention must be paid to the efficient use of computational resources, both in terms of task distribution and optimization of the programs and algorithms themselves.

One of the key experiments in heavy-ion physics is the CBM (Compressed Baryonic Matter) [1] experiment, planned to take place at the FAIR accelerator (Facility for Antiproton and Ion Research). Its primary objective is to study the properties of strongly interacting matter at high net-baryon densities, aiming to explore the QCD phase diagram and the possible existence of a first-order phase transition and a critical point.

New experiments at FAIR are being developed with the latest trends in energy efficiency in mind. As part of this initiative, the Green IT Cube [2], an innovative computing infrastructure, was built specifically to minimize energy consumption and reduce the carbon footprint. Furthermore, the Goethe HLR (now upgraded to Goethe NHR) [3], a high-performance computing cluster, is available to support research projects. In the latest Green500 ranking from June 2024 [4], Goethe NHR holds the 17th position globally in terms of energy efficiency.

This work is dedicated to the study of the energy efficiency of an algorithm that plays a crucial role in particle collision reconstruction, the Kalman filter-based trajectory fitting algorithm [5]. It is interesting to note that this optimized algorithm has reduced the runtime of the original scalar algorithm by a significant factor of 120.000. Currently, this algorithm is actively used in large-scale heavy-ion physics experiments, such as ALICE at CERN and STAR at BNL, as well as in the track searching and analysis procedures of the future CBM experiment. The high efficiency of the algorithm for track fitting has previously been studied in Kisel and for CBM Collaboration [6], also investigating the scaling of the number of tracks fitted per time for different computing architectures.

The Kalman Filter Track Fitter benchmark provides numerous options for launching parallel computations, allowing researchers to explore the algorithm’s performance on various hardware configurations. Vectorized computations are available using all major instruction sets of modern Intel processors: scalar (32-bit, 1 floating point variable), SSE (128-bit, 4 floating point variables), AVX2 (256-bit, 8 floating point variables), and AVX512 (512-bit, 16 floating point variables). Each instruction set has its own characteristics in terms of its impact on CPU energy consumption. However, in our study the testing was primarily conducted using the AVX2 instruction set, as it is the most advanced in terms of vectorization efficiency available on the AMD EPYC CPUs.

Parallel computations are implemented using the OpenMP standard. The program is executed sequentially with varying numbers of threads, ranging from 1 up to 2 CPUs × 64 cores × 2 threads = 256 threads. Computational threads are pinned to cores according to the CPU topology, ensuring that the primary and hyper-threading threads of each core are utilized sequentially. Task distribution is done statically with a step size of 1,000 tracks, while the total number of tracks is a multiple of 1,000. This eliminates overhead associated with task distribution in the given context. As a result, we obtain the algorithm’s performance, expressed as the number of tracks fitted per unit of time.

The computations on the GPU are implemented using the OpenCL framework, with optimization for local memory utilization for the most frequently accessed variables. The program is executed with various local item size values, ranging from 1 to 256. Using more threads per block is considered impractical, as the optimal block size for AMD GPUs is 64 elements, and the chosen configurations will allow a full assessment of the relevant patterns. Additionally, an excessive number of threads would lead to local memory overflow and a corresponding decrease in computational speed.

The scalability of the fitting algorithm’s computation speed is shown in Figure 3. The graph of computation speed growth depending on the number of threads used on the CPU (Figure 3a) exhibits a nearly linear shape with some deviations and changes in slope. The independence of threads and the equivalence of computations in each thread result in a proportional increase in overall performance. The slightly convex shape of the histogram segments reflects the characteristics of the processor’s power supply depending on the load.

At low loads, with up to 64 threads in use, we can clearly see the effect of hyperthreading in Figure 3a. This is reflected in the ladder-like structure of the graph, in which the performance gain for every second thread that uses a virtual core is no more than 20%–30%. At higher loads, some artifacts caused by CPU power optimization are noticeable, which also affects the efficiency of hyperthreading, making the results difficult to interpret.

The utilization of AVX2 instructions for data-level parallelization ensures high performance of the algorithm by fully populating SIMD vectors with 8 single-precision floating-point elements. The resulting track fitting speed in the context of this study varies from 10.5 tracks / μ s when using a single core, to 1071.3 tracks / μ s at maximum CPU load.

The AMD MI210 graphics card features 104 compute units (CUs), each supporting 64 threads. This GPU structure defines the scalability characteristics of parallel computations (Figure 3b). The histogram clearly shows a stepwise pattern with increments of 64 elements. Using an incomplete set of threads within a CU results in idle computations and a proportional decrease in the overall performance of the algorithm.

The minimum computation speed is 48.4 tracks / μ s with an energy consumption of approximately 135 Wh, which significantly surpasses the CPU’s performance under similar load conditions due to the structural differences between the devices. As the number of active threads increases, performance grows at a rate of about 48 tracks / μ s per thread. Peak performance reaches 2553.5 tracks / μ s when utilizing all 64 threads. With further increases in the local item size, the algorithm’s performance decreases in proportion to the ratio of active to idle threads. Subsequent performance peaks show similar, though slightly lower, results. As the number of tasks per CU increases, the amount of both global and local memory used grows, leading to minor additional overhead costs.

The final energy consumption values (Figure 4) were calculated for each pair of total energy consumption per unit of time (Figure 2) and computation speed (Figure 3) using Equation 1, with an estimation for fitting k = 1 0 10 tracks. In addition to the energy spent directly on the calculations, the equation takes into account the memory energy consumption at the rate of P m = 0.3725 W/GB.

The Kalman Filter track fitter does not require significant amounts of additional memory for calculations and storing intermediate results. The main memory consumption is for storing information about the detector geometry, as well as directly processed data: tracks and hits they consist of.

In the benchmark under consideration, information about each of the 7 detector stations takes up 156 bytes. In real-world applications, this value can increase to several tens of KB, mainly due to a more detailed map of the station material. This amount of memory use has almost no effect on overall energy consumption.

The main memory consumption is for tracks that are being fitted, primarily due to their number. In the benchmark, this value is 240 bytes per track. Since the fitting process occurs in batches, the amount of memory used n m was determined based on the simultaneous storage of up to 1 0 6 tracks. If this parameter is significantly increased, energy costs for temporary data storage start to outweigh the computation costs, which does not align with the algorithm’s usage model. Thus, the results provide insight into the approximate energy cost of track fitting that can be expected in the CBM experiment over the course of 1 s, under conditions of maximum particle interaction rates with high collision centrality, when the largest number of fragments is produced.

It should be noted that many of the conditions considered for the upcoming CBM experiment are estimates based on theoretical models and tend to result in inflated numbers. For this reason, the results of the study cannot be regarded as precise values but rather as approximate estimates of the algorithm’s energy consumption. These estimates, however, provide valuable insights into the main trends and allow for a rough assessment of the algorithm’s energy efficiency.

According to theoretical estimates (Figure 2a, blue markers), fitting 1 0 10 particle trajectories using the Kalman filter on modern CPUs required between 0.83 and 1.25 Wh of electricity (Figure 4a, blue markers). The wavelike structure of the histogram is caused by the uneven growth in computation speed with linear increases in energy consumption.

Actual power consumption measurements (Figure 4a, red markers) show clear differences from the estimates in areas of high or low CPU utilization, whereas they are rather close to the estimates for medium CPU utilization. Computations on a small number of threads lead to relatively low power efficiency, which is an obvious effect of the jump and a sharp further growth of power consumption with a more uniform increase in the speed of calculations. At the same time, the power efficiency at maximum CPU load looks better than theoretical. Fitting 1 0 10 tracks in this case requires about 1.00 Wh of electricity.

Now, knowing the energy cost for fitting 1 0 10 tracks—representing the hypothetical peak track output per second—we can calculate the carbon footprint for 1 day of algorithm operation using Equation 2, as outlined in the Green Algorithms methodology. The choice of a 24-h time interval is made for clarity and ease of further extrapolation, as the experiment and data processing will be conducted continuously around the clock. C = E × C I = 24 h × 60 min × 60 sec × 0.0010 kWh × 380 ⁢ gCO 2 / kWh = 32,832 ⁢ gCO 2

Thus, particle trajectory fitting in the CBM experiment using CPUs at maximum load could result in up to 32.8 kg of CO 2 emissions per day. To make this more relatable, these emissions can be expressed in terms of driving distance and carbon sequestration (Table 1).

According to open data from the European Environment Agency [14], the average CO 2 emissions for new cars in Europe are 102.2   gCO 2 / km . Therefore, the CO 2 emissions in the scenario considered would correspond to: 32,832 gCO 2 102.2 gCO 2 / km ≈ 321 km

Consistent with studies [15], a tree absorbs 10—12 kgCO 2 per year, depending on growth conditions, or approximately 1   kg/month . Thus, the daily CO 2 emissions from the fitting of the experimental data would be equivalent to about 3 tree-year. These comparisons give a clearer sense of the environmental impact of the computational tasks involved in the CBM experiment.

By comparison, processing 1 0 10 tracks at minimum CPU load requires approximately 17 times more electricity, resulting in a corresponding increase in carbon dioxide production.

As a means of self-validation, we also compared the calculated results with the output data from the online calculator Green Algorithms (Figure 5), whose operation served as the foundation for developing the research methodology. The calculations performed by the online calculator were based on the use of 1,195 CPU cores over 24 h. This setup is expected to enable the fitting of 1 0 10 tracks per second, according to previously obtained estimates of the algorithm’s performance (Figure 3a). It should also be noted that the measured peak energy consumption of the system under consideration was 20% lower than the maximum values used by the authors of Green Algorithms by default.

Daily electricity consumption, according to our calculations, amounted to 86.4 kWh, which is approximately 20% lower than the result provided by the online calculator and therefore fully aligns with the expected values. The difference in the mass of the emitted C O 2 is only about 10%. This discrepancy arises from the use of different values for the carbon intensity factor in the calculations. Specifically, Green Algorithms uses data from 2020 (338.66 g C O 2 / k W h ), while our research is based on more recent figures from 2023 (380 g C O 2 / k W h ). Accounting for this difference reconciles the results. An even more pronounced discrepancy in the driving distance metric reflects not only the influence of prior carbon emission calculations, but also a significant difference in the average C O 2 emissions per 100 km for vehicles: 175 g C O 2 / k m (2019) in Green Algorithms compared to 102.2 g C O 2 / k m (2024) in our study.

Thus, it can be concluded that the results of our study align with the stated methodology and correlate well with the estimates provided by the Green Algorithms online calculator. However, it is equally important to note that indirect estimations are highly dependent on the coefficients used, which may vary over time or differ depending on the source. Such estimates can be utilized to enhance the interpretability of the results, but they are not sufficiently precise on their own.

The dependence of GPU energy consumption on the device load is much more pronounced (Figure 4b). We will examine two extreme cases in terms of carbon footprint and compare the obtained results with the data from the CPU.

The worst energy efficiency occurs when only one thread per compute unit is used. Low computational performance combined with high energy consumption results in a requirement of approximately 8.34 Wh to process 1 0 10 tracks. These computations result in up to 273.8 kgCO 2 per day. This is equivalent to driving a car for a distance of 2,679 km. Compensation for such emissions would require around 274 tree-months of CO 2 sequestration.

Optimal GPU energy efficiency is largely determined by the proper utilization of computational resources to achieve maximum fitting speed. This corresponds to configurations where all threads are utilized, that is, when the local item size is a multiple of 64. The peak efficiency is similar across settings, but the best value is achieved with a local item size of 64, resulting in an energy consumption of 0.35 Wh per 1 0 10 tracks.

Converting this result similarly to the previously obtained data, we arrive at the following values. Daily CO 2 emissions amount to approximately 11.5 kg, which is 3 times less than in the case of CPU usage. This is equivalent to a trip by car of 112.4 km. Such environmental impact would be compensated for by approximately 12.6 tree-months of CO 2 sequestration.

In this work, an analysis of the efficiency of the Kalman Filter-based fitting algorithm, which plays a key role in particle trajectory reconstruction in heavy-ion physics experiments such as the CBM experiment at FAIR, was conducted. The study included an assessment of computational resources, energy consumption, and carbon footprint when executing the algorithm on modern processors and graphics accelerators. The results show that the algorithm, optimized for SIMD instructions and multithreading, provides high performance and efficiency in the reconstruction and analysis of particle trajectories.

Further analysis reveals that CPU energy efficiency improves with increasing thread count, but power management mechanisms lead to nonuniform efficiency gains. At low CPU loads, baseline power consumption reduces efficiency, whereas at peak loads, real energy usage remains below theoretical estimates. GPU efficiency depends on optimal resource utilization—under low occupancy, energy costs rise sharply, while full utilization achieves up to three times lower energy consumption per fitted track compared to the CPU.

This reduction in energy consumption leads to a threefold decrease in CO 2 emissions and, consequently, in the amount of carbon sequestration needed. Therefore, optimizing the algorithm for GPU execution not only enhances computational efficiency but also significantly reduces the carbon footprint of experimental data processing in heavy-ion physics.

The data obtained highlight the importance of further optimizing algorithms and computational systems to achieve a balance between performance and energy efficiency, especially in the context of increasing data volumes and heightened demands for computational power. In the face of global efforts to reduce carbon footprints, the development of “green” computing algorithms and infrastructures is becoming an integral part of the modern scientific process, particularly in the field of heavy-ion physics.