Graphics Processing Units Code Research Articles

Numerical modelling of armour block sea breakwater with smoothed particle hydrodynamics

The application of smoothed particle hydrodynamics (SPH) to model the three-dimensional fluid–structure interaction for waves approaching a rubble mound breakwater is presented. The main aim is to model the armoured structure and to validate its response under the action of periodic waves. The complex geometry is represented by grooved cubic blocks such that the surrounding gaps within the breakwater seaward layer require a large number of particles to obtain a sufficiently detailed description of the flow. Using novel computer architecture solutions such as graphics processing units (GPUs), the fluid-structure interaction is modelled with SPH particles between armour blocks that are representative of the real structure. The open-source GPU code, DualSPHysics, enables the simulation of millions of particles required for the accurate simulation of the run-up on an armoured structure. SPH has been proven to be a suitable method for practical applications in coastal engineering. In the present work the run-up heights are computed and compared with empirical solutions and experimental data. Reasonable agreement is obtained for the run-up due to regular waves over a range of surf similarity numbers from 3.0 to 5.5.

GPU-accelerated Gibbs ensemble Monte Carlo simulations of Lennard-Jonesium

This work describes an implementation of canonical and Gibbs ensemble Monte Carlo simulations on graphics processing units (GPUs). The pair-wise energy calculations, which consume the majority of the computational effort, are parallelized using the energetic decomposition algorithm. While energetic decomposition is relatively inefficient for traditional CPU-bound codes, the algorithm is ideally suited to the architecture of the GPU. The performance of the CPU and GPU codes are assessed for a variety of CPU and GPU combinations for systems containing between 512 and 131,072 particles. For a system of 131,072 particles, the GPU-enabled canonical and Gibbs ensemble codes were 10.3 and 29.1 times faster (GTX 480 GPU vs. i5-2500K CPU), respectively, than an optimized serial CPU-bound code. Due to overhead from memory transfers from system RAM to the GPU, the CPU code was slightly faster than the GPU code for simulations containing less than 600 particles. The critical temperature Tc∗=1.312(2) and density ρc∗=0.316(3) were determined for the tail corrected Lennard-Jones potential from simulations of 10,000 particle systems, and found to be in exact agreement with prior mixed field finite-size scaling calculations [J.J. Potoff, A.Z. Panagiotopoulos, J. Chem. Phys. 109 (1998) 10914].

SU‐E‐T‐242: A Gateway for GPU Computations in Radiotherapy

Purpose: Graphics Processing Unit (GPU) has become increasingly important in radiotherapy. However, it is still difficult for general clinical researchers to access GPU codes developed by other researchers with GPU expertise, and also for developers to benchmark their codes. It is quite often to see repeated efforts spent on developing GPU codes with low quality. The goal of this project is to establish an infrastructure for sharing GPU codes in the community. Methods: We deployed a GPU code sharing infrastructure on a GPU cluster. A number of codes developed in our group can be accessed via a web interface. To use the services, researchers first upload their test data or use the data provided by our system. Then they have to select the GPU device they are going to run the codes. Our system offers all mainstream GPU hardware for code benchmarking purpose. After the code running is complete, the system will automatically summarize and display the computing results. We will also release a SDK to allow the developers to build their own algorithm implementation and submit their binary codes to the system. The submitted code will be systematically benchmarked using a variety of GPU hardware and representative clinical data provided by our system. Results: This project provides a platform to the public to access a variety of GPU codes for radiotherapy research via a web interface. With the help of this platform, researchers are able to focus their efforts on clinical research. Developers will also benefit from this platform by benchmarking their codes on various GPU platforms and clinical data sets and comparing with other people's codes for the same application. Conclusion: The gateway for GPU code developers and clinical research users can greatly facilitate the adoption of GPU codes in radiotherapy.

WE‐C‐108‐05: A Hardware Accelerator Based Fast Monte Carlo Code for Radiation Dosimetry: Software Design and Preliminary Results

Purpose: Monte Carlo (MC) simulation provides the most accurate results for CT dose calculations. Yet it is a time‐consuming task which often takes long time to run on CPUs. Using the recently developed hardware accelerators such as Graphics Processing Unit (GPU) and the Intel Xeon Phi coprocessor, one can run the MC simulations in massively parallel and reduce the simulation time significantly. In this work we present our effort of developing a new MC suite, Accelerated Radiation‐transport Computations in Heterogeneous EnviRonments (ARCHER), which utilizes NVIDIA GPUs and other accelerators. Methods: We first developed the radiation transport MC codes in C, and then adapted the code to ARCHERGPU and ARCHERMIC which are specific for NVIDIA GPU and Intel MIC architecture, respectively. Currently the code is capable of calculating the dose for CT X‐ray scan and electron radiotherapy. Our code also incorporated a whole CT scanner model and various computational human phantoms. Results: We tested our GPU‐based MC code on NVIDIA Tesla M2090 GPUs and compared its performance with other MC codes running on an Intel Xeon X5650 CPU. Two tests were carried out: 1) For a whole body helical CT scan with RPI‐Adult male obese phantom and 9e8 incoming photons, the ARCHER_GPU code and ARCHER_MIC code are 1200 and 561 times faster, respectively, than MCNPX running on the CPU. 2) For a simple water‐aluminum‐water phantom and 20MeV electron source, the ARCHER_GPU code takes 186 sec to simulate 6e6 electrons, and it is about 1000 times faster than MCNPX running on the CPU. Conclusion: Our preliminary results showed the efficiency of using different hardware accelerators to speed up MC radiation transport simulations for medical dosimetry. On‐going work includes further optimization of the code and implementation of more complex physics models.

TH-A-108-01: Radiation Dose Calculations On Graphics Processing Units (GPUs): Advances and Challenges

Dose calculation is a critical component for radiation therapy. To ensure its accuracy, especially in complicated cases with large tissue heterogeneity, modern dose-calculation algorithms contain a lot of details in their models, which demand a high computation power to achieve an acceptable level of efficiency. Especially for Monte Carlo simulation, the most accurate dose-calculation method, its high computational burden hinders the clinical applications in many contexts. Recently, a number of research have been devoted to accelerating dose calculations for both photon and proton radiotherapy on computer graphics processing units (GPU), specialized processors with a highly parallel structure originally designed for manipulating computer graphics. The achieved speed-up factors and accuracy, as well as the low cost in hardware setup and maintenance, indicate a great potential for the clinical applications of GPU-based dose calculations. Yet, there are still significant challenges. For instance, there exist conflicts between the GPU's data-parallel processing structure and the randomness of Monte Carlo simulations and hence, it is challenging to design GPU-friendly parallelization schemes for this method. It is also desirable to develop suitable physics models that are simple for GPU implementations but attain sufficient accuracy. The proposed symposium aims to bring together experts to exchange the most recent advances in this topic, including pencil-beam algorithms, superposition/convolution algorithms, and both photon and proton Monte Carlo simulations. Challenges in these methods and potential solutions will also be discussed. Learning Objectives: 1. Understand how GPU is used to accelerate dose calculations in radiotherapy, including pencil-beam algorithm, superposition/ convolution, and Monte Carlo methods. 2. Understand the current status of these algorithms. 3. Understand the challenges for GPU-based dose calculations and the potential solutions. Dr. Sami Hissoiny is employed by Elekta. The GPU code from Dr. Todd McNutt was licensed to Elekta and Gulmay.

3D Anisotropic Diffusion on GPUs by Closed-Form Local Tensor Computations

We present an efficient implementation of volumetric anisotropic image diffusion filters on modern programmable graphics processing units (GPUs), where the mathematics behind volumetric diffusion is effectively reduced to the diffusion in 2D images. We hereby avoid the computational bottleneck of a time consuming eigenvalue decomposition in ℝ 3 . Instead, we use a projection of the Hessian matrix along the surface normal onto the tangent plane of the local isodensity surface and solve for the remaining two tangent space eigenvectors. We derive closed formulas to achieve this and prevent the GPU code from branching. We show that our most complex volumetric anisotropic diffusion filters gain a speed up of more than 600 compared to a CPU solution.

SU‐C‐500‐03: GGEMS‐Brachy: Fully GPU Geant4‐Based Efficient Monte Carlo Simulation for Brachytherapy Applications

Purpose: In brachytherapy, dosimetric plans are routinely calculated with the TG43 formalism which considers the patient as a simple water box. However, an accurate modeling of the physical processes considering patient heterogeneity using Monte Carlo (MC) methods is currently too time‐consuming and computationally demanding to be routinely used. As solution we implemented an accurate and fast MC simulation on graphics processing unit (GPU) for brachytherapy (HDR and LDR) applications. Methods: Based on Geant4 a MC simulation framework was developed on GPU. This framework was extended to include a hybrid GPU navigator, allowing navigation within a voxelized phantom derived from CT imaging including an analytical based structure for accurately modeling the 125I seeds (Source Tech Medical STM1251). In addition, dose scoring based on TLE including uncertainty calculations was incorporated. The implemented full GPU based modeling was compared with a classical CPU MC simulation based on GATE/GEANT4, as well as previously proposed GPU approaches based on the use of phasespace files for the seeds and their positioning based on simple replacement of voxels within the CT volumes. Results: Energy distribution from the seed and dose mapping including uncertainty were compared showing a high agreement (differences <1%). Preliminary results have shown that the GPU implementation is faster by at least two orders of magnitude compared to the GATE mono‐CPU version. A comparison between dosimetric plans based on TG43 and a full MC simulation using the GPU code for LDR prostate brachytherapy led to 40%–100% differences depending on the level of tissue heterogeneity. Conclusion: We propose a full GPU MC simulation based on Geant4, with a hybrid navigator dedicated for brachytherapy applications. Our evaluation shows large dose differences compared to the simplistic TG43 formalism in LDR and very fast execution times compatible with clinical practice.

Precorrected-FFT Method on Graphics Processing Units

A detailed scheme of mapping Precorrected-FFT (P-FFT) method to graphics processing units (GPUs) is presented through the solution of electric field integral equation (EFIE) for modeling the scattering from 3-D perfectly electric conducting (PEC) object. The procedure of the P-FFT method is analyzed to identify its computationally intensive spots, which are to be implemented on GPU. Based on this, a mapping scheme is proposed. Moreover, the optimization of the GPU code is discussed to demonstrate its importance in achieving better performance. The optimization scheme is broken down into several stages to show the gradual performance improvement in each stage. Accurate numerical results obtained using the GPU code validate the proposed mapping and optimization scheme. The performance of GPU code is benchmarked and the acceleration ratio achieved is more than 50.

Matrix-free GPU implementation of a preconditioned conjugate gradient solver for anisotropic elliptic PDEs

Many problems in geophysical and atmospheric modelling require the fast solution of elliptic partial differential equations (PDEs) in “flat” three dimensional geometries. In particular, an anisotropic elliptic PDE for the pressure correction has to be solved at every time step in the dynamical core of many numerical weather prediction (NWP) models, and equations of a very similar structure arise in global ocean models, subsurface flow simulations and gas and oil reservoir modelling. The elliptic solve is often the bottleneck of the forecast, and to meet operational requirements an algorithmically optimal method has to be used and implemented efficiently. Graphics Processing Units (GPUs) have been shown to be highly efficient (both in terms of absolute performance and power consumption) for a wide range of applications in scientific computing, and recently iterative solvers have been parallelised on these architectures. In this article we describe the GPU implementation and optimisation of a Preconditioned Conjugate Gradient (PCG) algorithm for the solution of a three dimensional anisotropic elliptic PDE for the pressure correction in NWP. Our implementation exploits the strong vertical anisotropy of the elliptic operator in the construction of a suitable preconditioner. As the algorithm is memory bound, performance can be improved significantly by reducing the amount of global memory access. We achieve this by using a matrix-free implementation which does not require explicit storage of the matrix and instead recalculates the local stencil. Global memory access can also be reduced by rewriting the PCG algorithm using loop fusion and we show that this further reduces the runtime on the GPU. We demonstrate the performance of our matrix-free GPU code by comparing it both to a sequential CPU implementation and to a matrix-explicit GPU code which uses existing CUDA libraries. The absolute performance of the algorithm for different problem sizes is quantified in terms of floating point throughput and global memory bandwidth.

Performance comparison of three types of GPU‐accelerated indirect boundary element method for voxel model analysis

SUMMARYAn indirect boundary element method that is geared to electrostatic field analysis in voxel models is accelerated by graphics processing units (GPUs). The method considers square walls on cubic voxels as boundary surface elements and uses the fast multipole method (FMM) to analyze large‐scale models. On the basis of two conventional CPU codes, three GPU codes are programmed in search of higher computing performance. These GPU codes are designed as follows: In GPU code 1, direct and far fields in the FMM are simultaneously calculated on the GPU and the CPU, respectively; in GPU code 2, both fields are calculated on the GPU with a rotation‐coaxial translation–rotation decomposition algorithm; and in GPU code 3, both fields are calculated on the GPU with a diagonal translation scheme. The electric fields in human models are generated by applying a 50‐Hz magnetic field or by injecting direct‐current (DC) current through two electrodes and they were calculated successfully using a personal computer with three GPUs and six CPU cores. An analysis with 3.9 million surface elements took 89.4 s to solve its governing linear system with double‐precision floating‐point arithmetic. GPU codes 1, 2, and 3 demonstrated the least memory usage, the greatest speed‐up ratio, and the fastest calculation time, respectively. These results show an example of the trade‐off relationships of computation performances on a heterogeneous CPU–GPU system. Copyright © 2013 John Wiley & Sons, Ltd.

3D Anisotropic Diffusion on GPUs by Closed-Form Local Tensor Computations

We present an efficient implementation of volumetric anisotropic image diffusion filters on modern programmable graphics processing units (GPUs), where the mathematics behind volumetric diffusion is effectively reduced to the diffusion in 2D images. We hereby avoid the computational bottleneck of a time consuming eigenvalue decomposition in ℝ 3 . Instead, we use a projection of the Hessian matrix along the surface normal onto the tangent plane of the local isodensity surface and solve for the remaining two tangent space eigenvectors. We derive closed formulas to achieve this and prevent the GPU code from branching. We show that our most complex volumetric anisotropic diffusion filters gain a speed up of more than 600 compared to a CPU solution.

Efficient Volumetric Anisotropic Diffusion Computation on GPUs

AbstractWe present an efficient implementation of volumetric anisotropic image diffusion on modern programmable graphics processing units (GPUs). We avoid the computational bottleneck of a time consuming eigenvalue decomposition in ℝ3. Instead, we use a projection of the Hessian matrix along the surface normal onto the tangent plane of the local isodensity surface and solve for the remaining two tangent space eigenvectors. We derive closed formulas to achieve this resulting in efficient GPU code. Our most complex volumetric anisotropic diffusion gains a speed up of more than 600 compared to a CPU solution [1]. (© 2012 Wiley‐VCH Verlag GmbH & Co. KGaA, Weinheim)

Generating Efficient Quantum Chemistry Codes for Novel Architectures

We describe an extension of our graphics processing unit (GPU) electronic structure program TeraChem to include atom-centered Gaussian basis sets with d angular momentum functions. This was made possible by a "meta-programming" strategy that leverages computer algebra systems for the derivation of equations and their transformation to correct code. We generate a multitude of code fragments that are formally mathematically equivalent, but differ in their memory and floating-point operation footprints. We then select between different code fragments using empirical testing to find the highest performing code variant. This leads to an optimal balance of floating-point operations and memory bandwidth for a given target architecture without laborious manual tuning. We show that this approach is capable of similar performance compared to our hand-tuned GPU kernels for basis sets with s and p angular momenta. We also demonstrate that mixed precision schemes (using both single and double precision) remain stable and accurate for molecules with d functions. We provide benchmarks of the execution time of entire self-consistent field (SCF) calculations using our GPU code and compare to mature CPU based codes, showing the benefits of the GPU architecture for electronic structure theory with appropriately redesigned algorithms. We suggest that the meta-programming and empirical performance optimization approach may be important in future computational chemistry applications, especially in the face of quickly evolving computer architectures.

Accelerating the discontinuous Galerkin method for seismic wave propagation simulations using the graphic processing unit (GPU)—single-GPU implementation

We have successfully ported an arbitrary high-order discontinuous Galerkin (ADER-DG) method for solving the three-dimensional elastic seismic wave equation on unstructured tetrahedral meshes to an Nvidia Tesla C2075 GPU using the Nvidia CUDA programming model. On average our implementation obtained a speedup factor of about 24.3 for the single-precision version of our GPU code and a speedup factor of about 12.8 for the double-precision version of our GPU code when compared with the double precision serial CPU code running on one Intel Xeon W5880 core. When compared with the parallel CPU code running on two, four and eight cores, the speedup factor of our single-precision GPU code is around 12.9, 6.8 and 3.6, respectively. In this article, we give a brief summary of the ADER-DG method, a short introduction to the CUDA programming model and a description of our CUDA implementation and optimization of the ADER-DG method on the GPU. To our knowledge, this is the first study that explores the potential of accelerating the ADER-DG method for seismic wave-propagation simulations using a GPU.

Accelerating Cardiac Bidomain Simulations Using Graphics Processing Units

Anatomically realistic and biophysically detailed multiscale computer models of the heart are playing an increasingly important role in advancing our understanding of integrated cardiac function in health and disease. Such detailed simulations, however, are computationally vastly demanding, which is a limiting factor for a wider adoption of in-silico modeling. While current trends in high-performance computing (HPC) hardware promise to alleviate this problem, exploiting the potential of such architectures remains challenging since strongly scalable algorithms are necessitated to reduce execution times. Alternatively, acceleration technologies such as graphics processing units (GPUs) are being considered. While the potential of GPUs has been demonstrated in various applications, benefits in the context of bidomain simulations where large sparse linear systems have to be solved in parallel with advanced numerical techniques are less clear. In this study, the feasibility of multi-GPU bidomain simulations is demonstrated by running strong scalability benchmarks using a state-of-the-art model of rabbit ventricles. The model is spatially discretized using the finite element methods (FEM) on fully unstructured grids. The GPU code is directly derived from a large pre-existing code, the Cardiac Arrhythmia Research Package (CARP), with very minor perturbation of the code base. Overall, bidomain simulations were sped up by a factor of 11.8 to 16.3 in benchmarks running on 6-20 GPUs compared to the same number of CPU cores. To match the fastest GPU simulation which engaged 20 GPUs, 476 CPU cores were required on a national supercomputing facility.

MO‐F‐213CD‐01: GPU‐Based Monte Carlo Methods for Accelerating Radiographic and CT Imaging Dose Calculations: Feasibility and Scalability

Purpose: To develop a Graphics Processing Unit (GPU) based Monte Carlo (MC) code that uses a dual‐GPU system to accelerate radiographic simulation and CT imaging dose calculations. Methods: We considered two clinical cases, a chest x‐ray radiography and an abdominal CT scan. In the first case, a voxelized VIP‐Man phantom with detailed 3D anatomical information was used and an x‐ray beam of 120kVp was simulated. In the second case, a voxelized abdomen phantom derived from 120 CT slices was used, and a GE LightSpeed 16‐MDCT scanner was modeled. The CPU version of the MC code was written in C++ and run on Intel Xeon X5660 2.8GHz CPU, then translated into GPU code written in CUDA C and tested on a dual Tesla m2090 GPU system. The code was featured with automatic assignment of simulation task to multiple GPUs, as well as accurate calculation of energy‐ and material‐dependent cross‐sections. Results: Double‐precision floating point format was used for accuracy. In the first case, radiograph formation was simulated and doses to the organs listed in ICRP‐60 were calculated. When running on a single GPU, the MC GPU code was found to be x13 times faster than the CPU code and x29 times faster than MCNPX. In the second case, doses to the rectum, prostate, bladder and femoral heads were calculated. A speedup of x19 was observed compared to CPU code. These speedup factors were doubled on the dual‐GPU system. The imaging dose was benchmarked against MCNPX and a maximum difference of 1% was observed when the relative error is kept below 0.1%. Conclusions: A GPU‐based MC code was developed to simulate radiography and calculate imaging dose using detailed patient and CT scanner models. Efficiency and accuracy were both guaranteed in this code. Scalability of the code was confirmed on the dual‐GPU system.

Sponge

Graphics processing units (GPUs) provide a low cost platform for accelerating high performance computations. The introduction of new programming languages, such as CUDA and OpenCL, makes GPU programming attractive to a wide variety of programmers. However, programming GPUs is still a cumbersome task for two primary reasons: tedious performance optimizations and lack of portability. First, optimizing an algorithm for a specific GPU is a time-consuming task that requires a thorough understanding of both the algorithm and the underlying hardware. Unoptimized CUDA programs typically only achieve a small fraction of the peak GPU performance. Second, GPU code lacks efficient portability as code written for one GPU can be inefficient when executed on another. Moving code from one GPU to another while maintaining the desired performance is a non-trivial task often requiring significant modifications to account for the hardware differences. In this work, we propose Sponge, a compilation framework for GPUs using synchronous data flow streaming languages. Sponge is capable of performing a wide variety of optimizations to generate efficient code for graphics engines. Sponge alleviates the problems associated with current GPU programming methods by providing portability across different generations of GPUs and CPUs, and a better abstraction of the hardware details, such as the memory hierarchy and threading model. Using streaming, we provide a write-once software paradigm and rely on the compiler to automatically create optimized CUDA code for a wide variety of GPU targets. Sponge's compiler optimizations improve the performance of the baseline CUDA implementations by an average of 3.2x.

SU-E-T-493: Accelerated Monte Carlo Methods for Photon Dosimetry Using a Dual-GPU System and CUDA.

To develop a Graphics Processing Unit (GPU) based Monte Carlo (MC) code that accelerates dose calculations on a dual-GPU system. We simulated a clinical case of prostate cancer treatment. A voxelized abdomen phantom derived from 120 CT slices was used containing 218×126×60 voxels, and a GE LightSpeed 16-MDCT scanner was modeled. A CPU version of the MC code was first developed in C++ and tested on Intel Xeon X5660 2.8GHz CPU, then it was translated into GPU version using CUDA C 4.1 and run on a dual Tesla m2 090 GPU system. The code was featured with automatic assignment of simulation task to multiple GPUs, as well as accurate calculation of energy- and material- dependent cross-sections. Double-precision floating point format was used for accuracy. Doses to the rectum, prostate, bladder and femoral heads were calculated. When running on a single GPU, the MC GPU code was found to be ×19 times faster than the CPU code and ×42 times faster than MCNPX. These speedup factors were doubled on the dual-GPU system. The dose Result was benchmarked against MCNPX and a maximum difference of 1% was observed when the relative error is kept below 0.1%. A GPU-based MC code was developed for dose calculations using detailed patient and CT scanner models. Efficiency and accuracy were both guaranteed in this code. Scalability of the code was confirmed on the dual-GPU system.

GPU parallel computing: Programming language, debugging tools and data structures

With many cores driven by high memory bandwidth, today’s graphics processing unit (GPU) has involved into an absolute computing workhorse. More and more scientists, researchers and software developers are using GPUs to accelerate their algorithms and applications. Developing complex programs and software on the GPU, however, is still far from easy with existing tools provided by hardware vendors. This article introduces our recent research efforts to make GPU software development much easier. Specifically, we designed BSGP, a high-level programming language for generalpurpose computation on the GPU. A BSGP program looks much the same as a sequential C program, and is thus easy to read, write and maintain. Its performance on the GPU is guaranteed by a well-designed compiler that converts the program to native GPU code. We also developed an effective debugging system for BSGP programs based on the GPU interrupt, a unique feature of BSGP that allows calling CPU functions from inside GPU code. Moreover, using BSGP, we developed GPU algorithms for constructing several widely-used spatial hierarchies for high-performance graphics applications.

The challenges of writing portable, correct and high performance libraries for GPUs

Graphics Processing Units (GPUs) are widely used to accelerate scientific applications. Many successes have been reported with speedups of two or three orders of magnitude over serial implementations of the same algorithms. These speedups typically pertain to a specific implementation with fixed parameters mapped to a specific hardware implementation. The implementations are not designed to be easily ported to other GPUs, even from the same manufacturer. When target hardware changes, the application must be re-optimized. In this paper we address a different problem. We aim to deliver working, efficient GPU code in a library that is downloaded and run by many different users. The issue is to deliver efficiency independent of the individual user parameters and without a priori knowledge of the hardware the user will employ. This problem requires a different set of tradeoffs than finding the best runtime for a single solution. Solutions must be adaptable to a range of different parameters both to solve users' problems and to make the best use of the target hardware. Another issue is the integration of GPUs into a Problem Solving Environment (PSE) where the use of a GPU is almost invisible from the perspective of the user. Ease of use and smooth interactions with the existing user interface are important to our approach. We illustrate our solution with the incorporation of GPU processing into the Scientific Computing Institute (SCI)Run Biomedical PSE developed at the University of Utah. SCIRun allows scientists to interactively construct many different types of biomedical simulations. We use this environment to demonstrate the effectiveness of the GPU by accelerating time consuming algorithms in the scientist's simulations. Specifically we target the linear solver module, including Conjugate Gradient, Jacobi and MinRes solvers for sparse matrices.