# Power Consumption Comparison of GPU Linear Solvers for Cellular Potts Model Simulations
## 4 Results  
This section details the primary experiments conducted to validate the performance gain and power consumption savings of the developed parallel software. With the substantial increase in trials required for real-world healthcare applications, the computational demand of the Metropolis algorithm also rises significantly. The primary aim is to demonstrate the efficiency, particularly in terms of execution time reduction. Experimental tests, focusing on the most computationally intensive kernels, are presented to highlight the substantial improvements in time performance achieved through the GPU-parallelized algorithm. The following tests were conducted on the MARCONI-100 high-performance computing system provided by CINECA [17], featuring:  
* Dual 16-core IBM POWER9 AC922 CPUs at 3.1 GHz;
* Four NVIDIA Volta V100 GPUs with NVLink 2.0 connectivity and 16 GB memory each;
* 256 GB of system RAM. The input parameters for the CPM simulations were derived from an extensive literature review, ensuring the tests reflect real-world scenarios and facilitate direct comparisons with established findings. The test setup varies two critical parameters: the number of trials \(M\), equal to the number of cells; and the number of Metropolis algorithm time steps \(N_{\tau}\). These parameters significantly impact the computational performance of the parallel algorithm. Moreover, the computational complexity of the CPM model increases not only due to these input parameters but also due to the solver used. The most computationally demanding part involves solving the linear system, with the complexity heavily influenced by the solver choice. Therefore, some tests adopting different solvers within the CUDA environment were carried out. The performance metrics are based on the mean results of 30 executions to ensure efficiency in both execution time and power consumption reduction. **Test 1: Execution Time Comparison of Linear System Solvers. **  
In this experiment, the computational kernel responsible for solving the linear system \(Ku=f\), isolating this from the overall software execution times, is considered. This focused approach enables a detailed evaluation of the efficiency and effectiveness of each solver in isolation. Table 1 compares the execution times for all the chosen GPU-based methods:  
* The Jacobi method, implemented via the gesvdj routine from the cuSOLVER library;
* The LU decomposition, implemented through the getrf routine from cuSOLVER;
* The Gauss-Seidel method, implemented using the AmxG library;
* The conjugate gradient-based custom implementation. By varying the parameters \(N_{\tau}\) and \(M\), where \(N_{\tau}\) refers to the time iterations, and \(M\) is the Metropolis algorithm trials, a comparison between the different methods is presented. More precisely, the following test provides insights into the performance characteristics and computational efficiency of each solver, revealing significant improvements in execution time with the custom CG method. Table 1 shows the custom CG solver achieves significant execution time reductions compared to the other GPU solvers. This trend is observed across varying values of \(N_{\tau}\) and \(M\), confirming that the best solver performance in each experimental setup in the table is that of custom CG. **Test 2: Power Consumption Comparison of Linear System Solvers. **  
Starting from the good results in execution time achieved in the previous test, the following tests compare all the methods in terms of power consumption. In detail, the power consumption data in Table 2 highlight the energy efficiency of the various GPU solvers, including Jacobi, LU, Gauss-Seidel, and the custom conjugate gradient (CG) solver, across \(N_{\tau}\) different computational load levels. The custom CG solver exhibits the lowest power usage across all matrix sizes (\(M\)), indicating superior energy efficiency. For instance, at \(M=900\), the custom CG solver consumes 14.70 watts for \(N_{\tau}=9000\), while the Jacobi solver requires 25.81 watts under the same conditions.