Utilization Of Graphics Processing Units Research Articles

A Data-Loader Tunable Knob to Shorten GPU Idleness for Distributed Deep Learning

Deep Neural Networks (DNNs) have been applied as an effective machine learning algorithm to tackle problems in different domains. However, the endeavor to train sophisticated DNN models can stretch from days into weeks, presenting substantial obstacles in the realm of research focused on large-scale DNN architectures. Distributed Deep Learning (DDL) contributes to accelerating DNN training by distributing training workloads across multiple computation accelerators, for example, graphics processing units (GPUs). Despite the considerable amount of research directed toward enhancing DDL training, the influence of data loading on GPU utilization and overall training efficacy remains relatively overlooked. It is non-trivial to optimize data-loading in DDL applications that need intensive central processing unit (CPU) and input/output (I/O) resources to process enormous training data. When multiple DDL applications are deployed on a system (e.g., Cloud and High-Performance Computing (HPC) system), the lack of a practical and efficient technique for data-loader allocation incurs GPU idleness and degrades the training throughput. Therefore, our work first focuses on investigating the impact of data-loading on the global training throughput. We then propose a throughput prediction model to predict the maximum throughput for an individual DDL training application. By leveraging the predicted results, A-Dloader is designed to dynamically allocate CPU and I/O resources to concurrently running DDL applications and use the data-loader allocation as a knob to reduce GPU idle intervals and thus improve the overall training throughput. We implement and evaluate A-Dloader in a DDL framework for a series of DDL applications arriving and completing across the runtime. Our experimental results show that A-Dloader can achieve a 28.9% throughput improvement and a 10% makespan improvement compared with allocating resources evenly across applications.

Characterizing Hardware Utilization on Edge Devices when Inferring Compressed Deep Learning Models

Implementing edge AI involves running AI algorithms near the sensors. Deep Learning (DL) Model has successfully tackled image classification tasks with remarkable performance. However, their requirements for huge computing resources hinder the implementation of edge devices. Compressing the model is an essential task to allow the implementation of the DL model on edge devices. Post-training quantization (PTQ) is a compression technique that reduces the bit representation of the model weight parameters. This study looks at the impact of memory allocation on the latency of compressed DL models on Raspberry Pi 4 Model B (RPi4B) and NVIDIA Jetson Nano (J. Nano). This research aims to understand hardware utilization in central processing units (CPU), graphics processing units (GPU),and memory. This study focused on the quantitative method, which controls memory allocation and measures warm-up time, latency, CPU, and GPU utilization. Speed comparison among inference of DL models on RPi4B and J. Nano. This paper observes the correlation between hardware utilization versus the various DL inference latencies. According to our experiment, we concluded that smaller memory allocation led to high latency on both RPi4B and J. Nano. CPU utilization on RPi4B. CPU utilization in RPi4B increases along with the memory allocation; however, the opposite is shown on J. Nano since the GPU carries out the main computation on the device. Regarding computation, thesmaller DL Size and smaller bit representation lead to faster inference (low latency), while bigger bit representation on the same DL model leads to higher latency.

Transition from machine intelligence to knowledge intelligence: A multi-agent simulation approach to technology transfer

Abstract The traditional machine intelligence system lacks deep understanding and reasoning ability. This study took the automatic driving system in multi-agent as an example to bring higher-level intelligence and decision-making ability to automatic driving through knowledge intelligence. It obtained real-world geographic information data from OpenStreetMap, preprocessed the data, and built a virtual environment. The inception model was used to identify information in environmental images, and the knowledge information of traffic regulations, road signs, and traffic accidents was expressed to build a knowledge map. The knowledge related to automatic driving was integrated, and automatic driving training was carried out through the reward mechanism and the deep Q-network (DQN) model. About 13 kinds of traffic situations were set up in the virtual environment, and the traditional machine intelligence autonomous driving and knowledge fusion autonomous driving multi-agent were compared. The results show that the average number of accidents in 100,000 km of traditional machine intelligence autonomous driving and knowledge fusion autonomous driving multi-agents was 3 and 1.4, and the average number of violations in 100,000 km was 4.3 and 1.8, respectively. The average graphics processing unit (GPU) utilization rate of knowledge fusion autonomous driving in 13 virtual environments was 75.9%, and the average peak GPU utilization rate was 96.1%. Knowledge fusion of autonomous driving multi-agents can effectively improve the safety of autonomous driving and enable autonomous driving multi-agents to have a higher level of decision-making ability.

Towards a platform-portable linear algebra backend for OpenFOAM

AbstractGraphics processing unit accelerators have become a widespread technology on modern high performance computing clusters for increasing the performance of scientific computing algorithms. Despite early efforts to adopt linear solvers that utilize graphics processing units for OpenFOAM, to this date no widely accepted approach has gotten traction. In recent years, the number of different vendors providing graphics processing units accelerators has grown, and as of the writing of this paper, no commonly accepted, unified approach to leverage accelerators exists. This makes platform-portable solutions to increase the efficiency of graphics processing units offloading techniques desirable, and an important research topic. In this work, we investigate a platform-portable solution using the Ginkgo sparse linear algebra library.

#2924 Comparison of large language models and traditional natural language processing techniques in predicting arteriovenous fistula failure

Abstract Background and Aims Large language models (LLMs) have gained significant attention in the field of natural language processing (NLP), marking a shift from traditional techniques like Term Frequency-Inverse Document Frequency (TF-IDF). We developed a traditional NLP model to predict arteriovenous fistula (AVF) failure within next 30 days using clinical notes. The goal of this analysis was to investigate whether LLMs would outperform traditional NLP techniques, specifically in the context of predicting AVF failure within the next 30 days using clinical notes. Method We defined AVF failure as the change in status from active to permanently unusable status or temporarily unusable status. We used data from a large kidney care network from January 2021 to December 2021. Two models were created using LLMs and traditional TF-IDF technique. We used “distilbert-base-uncased”, a distilled version of BERT base model [1], and compared its performance with traditional TF-IDF-based NLP techniques. The dataset was randomly divided into 60% training, 20% validation and 20% test dataset. The test data, comprising of unseen patients’ data was used to evaluate the performance of the model. Both models were evaluated using metrics such as area under the receiver operating curve (AUROC), accuracy, sensitivity, and specificity. Results The incidence of 30 days AVF failure rate was 2.3% in the population. Both LLMs and traditional showed similar overall performance as summarized in Table 1. Notably, LLMs showed marginally better performance in certain evaluation metrics. Both models had same AUROC of 0.64 on test data. The accuracy and balanced accuracy for LLMs were 72.9% and 59.7%, respectively, compared to 70.9% and 59.6% for the traditional TF-IDF approach. In terms of specificity, LLMs scored 73.2%, slightly higher than the 71.2% observed for traditional NLP methods. However, LLMs had a lower sensitivity of 46.1% compared to 48% for traditional NLP. However, it is worth noting that training on LLMs took considerably longer than TF-IDF. Moreover, it also used higher computational resources such as utilization of graphics processing units (GPU) instances in cloud-based services, leading to higher cost. Conclusion In our study, we discovered that advanced LLMs perform comparably to traditional TF-IDF modeling techniques in predicting the failure of AVF. Both models demonstrated identical AUROC. While specificity was higher in LLMs compared to traditional NLP, sensitivity was higher in traditional NLP compared to LLMs. LLM was fine-tuned with a limited dataset, which could have influenced its performance to be similar to that of traditional NLP methods. This finding suggests that while LLMs may excel in certain scenarios, such as performing in-depth sentiment analysis of patient data for complex tasks, their effectiveness is highly dependent on the specific use case. It is crucial to weigh the benefits against the resources required for LLMs, as they can be significantly more resource-intensive and costly compared to traditional TF-IDF methods. This highlights the importance of a use-case-driven approach in selecting the appropriate NLP technique for healthcare applications.

ACCELERATING ORE SINTERING MATHEMATICAL MODEL USING GPU

The study aims to enhance the efficiency and computational speed of the ore sintering model through the utilization of graphics processing units (GPUs). The purpose of this research is to address the growing demand for faster and more scalable simulations in the field of ore sintering, a crucial process in the production of iron and steel. Methodology involves the integration of parallel computing capabilities offered by GPUs into the existing ore sintering model. By leveraging the parallel processing power of GPUs, the computational workload is distributed across multiple cores, significantly reducing the simulation time. Results demonstrate a substantial acceleration in the ore sintering simulation process. Comparative analyses between CPU and GPU implementations reveal a remarkable reduction in computation time, thereby enabling real-time or near-real-time simulations. The achieved speedup not only enhances the efficiency of ore sintering modeling but also opens avenues for exploring larger and more complex scenarios. This is the successful integration of GPU parallel computing into the ore sintering model, showcasing the adaptability of advanced computational technologies to traditional industrial processes. The study contributes to the field by bridging the gap between computational power and metallurgical simulations, demonstrating the potential for GPU acceleration in other areas of metallurgical processes. Practical significance of this research is underscored by its potential to revolutionize the ore sintering industry. Faster simulations facilitate quicker decision-making in process optimization, leading to improved energy efficiency and reduced environmental impact. This research sets the stage for the broader adoption of GPU acceleration in metallurgical modeling, signaling a paradigm shift towards more efficient and sustainable industrial practices

A GPU-accelerated computational fluid dynamics solver for assessing shear-driven indoor airflow and virus transmission by scale-resolved simulations

We explore the applicability of MATLAB for 3D computational fluid dynamics (CFD) of shear-driven indoor airflows. A new scale-resolving, large-eddy simulation (LES) solver titled DNSLABIB is proposed for MATLAB utilizing graphics processing units (GPUs). In DNSLABIB, the finite difference method is applied for the convection and diffusion terms while a Poisson equation solver based on the fast Fourier transform (FFT) is employed for the pressure. The immersed boundary method (IBM) for Cartesian grids is proposed to model solid walls and objects, doorways, and air ducts by binary masking of the solid/fluid domains. The solver is validated in two canonical reference cases and against experimental data. Then, we demonstrate the validity of DNSLABIB in a room geometry by comparing the results against another CFD software (OpenFOAM). Next, we demonstrate the solver performance in several isothermal indoor ventilation configurations and the implications of the results are discussed in the context of airborne transmission of COVID-19. The novel numerical findings using the new CFD solver are as follows. First, a linear scaling of DNSLABIB is demonstrated and a speed-up by a factor of 3-4 is also noted in comparison to similar OpenFOAM simulations. Second, ventilation in three different indoor geometries are studied at both low (0.1 m/s) and high (1 m/s) airflow rates corresponding to Re=5000 and Re=50000. An analysis of the indoor CO2 concentration is carried out as the room is emptied from stale, high CO2 content air. We estimate the air changes per hour (ACH) values for three different room geometries and show that the numerical estimates from 3D CFD simulations differ by 80%–150% (Re=50000) and 75%–140% (Re=5000) from the theoretical ACH value based on the perfect mixing assumption. Third, the analysis of the CO2 probability distributions (PDFs) indicates a relatively non-uniform distribution of fresh air indoors. Fourth, utilizing a time-dependent Wells-Riley analysis, an example is provided on the growth of the cumulative infection risk which is shown to reduce rapidly after the ventilation is started. The average infection risk is shown to reduce by a factor of 2 for lower ventilation rates (ACH=3.4-6.3) and 10 for the higher ventilation rates (ACH=37-64). Finally, we utilize the new solver to comment on respiratory particle transport indoors. A key contribution of the paper is to provide an efficient, GPU compatible CFD solver environment enabling scale-resolved simulations (LES/DNS) of airflow in large indoor geometries on a single GPU designed for high-performance computing. The demonstrated efficacy of MATLAB for GPU computing indicates a high potential of DNSLABIB for various future developments on airflow prediction.

Agnostic Energy Consumption Models for Heterogeneous GPUs in Cloud Computing

The adoption of cloud computing has grown significantly among individuals and in organizations. According to this growth, Cloud Service Providers have continuously expanded and updated cloud-computing infrastructures, which have become more heterogeneous. Managing these heterogeneous resources in cloud infrastructures while ensuring Quality of Service (QoS) and minimizing energy consumption is a prominent challenge. Therefore, unifying energy consumption models to deal with heterogeneous cloud environments is essential in order to efficiently manage these resources. This paper deeply analyzes factors affecting power consumption and employs these factors to develop power models. Because of the strong correlation between power consumption and energy consumption, the influencing factors on power consumption, with the addition of other factors, are considered when developing energy consumption models to enhance the treatment in heterogeneous infrastructures in cloud computing. These models have been developed for two Virtual Machines (VMs) containing heterogeneous Graphics Processing Units (GPUs) architectures with different features and capabilities. Experiments evaluate the models through a cloud testbed between the actual and predicted values produced by the models. Deep Neural Network (DNN) power models are validated with shallow neural networks using performance counters as inputs. Then, the results are significantly enhanced by 8% when using hybrid inputs (performance counters, GPU and memory utilization). Moreover, a DNN energy-agnostic model to abstract the complexity of heterogeneous GPU architectures is presented for the two VMs. A comparison between the standard and agnostic energy models containing common inputs is conducted in each VM. Agnostic energy models with common inputs for both VMs show a slight enhancement in accuracy with input reduction.

Accelerating split-exponential track length estimator on GPU in TRIPOLI-4®

In the context of computing 3D volumetric scores for nuclear applications, combiningMonte Carlo methods andHigh Performance Computing is key to achieve precise, computationally tractable simulations andmeet the industrial deadlines. The next-event “split exponential track-length estimator” (seTLE) is typically adapted to the estimation of a tally in a mesh. We take advantage of the computing capabilities of Graphics Processing Unit (GPU) to mitigate the CPU-intensive tasks involved in the application of the seTLE: the estimation of cross section, the sampling of many out-going pseudo-particles at collision, the ray tracing across the geometry and the accumulation of scores in volumes. We discuss the performance improvements brought by porting each of these steps to GPU. We discuss the influence of the many parameters involved, and select a working point providing the best trade-off between the acceleration factor and the GPU utilization. We show on two examples thatwe obtain an acceleration factor of 8.56 on average over the entire map for the shielding application (up to 50 behind the concrete shield), and of 6.30 on average for the criticality application (up to 16 in the burnable poison tubes), compared to standard TLE on CPU.

GPARS: Graph predictive algorithm for efficient resource scheduling in heterogeneous GPU clusters

Efficient resource scheduling in heterogeneous graphics processing unit (GPU) clusters are critical for maximizing system performance and optimizing resource utilization. However, prior research in resource scheduling algorithms typically employed machine learning (ML) algorithms to estimate job durations or GPU utilization in the cluster based on training progress and task speed. Regrettably, these studies often overlooked the performance variations among different GPU types within these clusters, as well as the presence of spatiotemporal correlations among jobs. To address these limitations, this paper introduces the graph predictive algorithm for efficient resource scheduling (GPARS) designed specifically for heterogeneous clusters. GPARS leverages spatiotemporal correlations among jobs and utilizes graph attention networks (GANs) for precise job duration prediction. Building upon the prediction results, we develop a dynamic objective function to allocate suitable GPU types for newly submitted jobs. By conducting a comprehensive analysis of Alibaba’s heterogeneous GPU cluster, we delve into the impact of GPU capacity and type on job completion time (JCT) and resource utilization. Our evaluation, using real traces from Alibaba and Philly, substantiates the effectiveness of GPARS. It achieves a remarkable 10.29% reduction in waiting time and an average improvement of 7.47% in resource utilization compared to the original scheduling method. These findings underscore GPARS’s superior performance in enhancing resource scheduling within heterogeneous GPU clusters.

An automated and portable method for selecting an optimal GPU frequency

Power consumption poses a significant challenge in current and emerging graphics processing unit (GPU) enabled high-performance computing systems. In modern GPUs, dynamic voltage frequency scaling (DVFS) appears to be a reliable control to regulate power consumption and performance. However, the DVFS design space is large - hence, brute-force approaches are infeasible to select the optimal frequency. Furthermore, no single frequency can be universally optimal for applications with varying computational intensities. Thus, the application’s complexity and the availability of a wide range of frequency settings are a challenge in selecting the optimal frequency configuration for a given GPU workload. To that end, this paper proposes a systematic approach that consists of three steps. The feature characterization study identifies the fine-grain GPU utilization metrics that influence the power consumption and execution time of a given workload. To understand the performance, power, and energy consumption behaviors of a workload across GPU’s DVFS design space, we derived analytical power and performance models using the identified fine-grain features. It is shown that the same set of GPU utilization metrics can estimate both the power consumption and execution time while being agnostic of changes to frequency and input sizes. Applying a power control with the single objective of reducing power may cause performance degradation, leading to more energy consumption. A multi-objective approach is proposed to select the optimal GPU DVFS configuration for a workload that reduces power consumption with negligible degradation in performance. The evaluation was conducted using SPEC ACCEL benchmarks and three real applications - NAMD LAMMPS, and LSTM on NVIDIA GV100, GA100, and AMD MI210 GPUs. On average, real applications showed 29.6% energy savings with a performance loss of 5.2% on GA100 and 22.6% energy savings with a performance loss of 4.7% on GV100. Moreover, the proposed models are portable to real applications, GPU architectures, and vendors, and require metric collection at only the default frequency rather than all supported DVFS configurations. Additionally, we conducted a comparison between our models and the GPU assembly instructions (PTX)-based static models. The results revealed a significant reduction in the average error rates, with a decrease from 19.7% to 3.1% for power models and from 29.4% to 5.2% for performance models.

Efficient Knowledge Graph Embedding Training Framework with Multiple GPUs

When training a large-scale knowledge graph embedding (KGE) model with multiple graphics processing units (GPUs), the partition-based method is necessary for parallel training. However, existing partition-based training methods suffer from low GPU utilization and high input/output (10) overhead between the memory and disk. For a high 10 overhead between the disk and memory problem, we optimized the twice partitioning with fine-grained GPU scheduling to reduce the 10 overhead between the CPU memory and disk. For low GPU utilization caused by the GPU load imbalance problem, we proposed balanced partitioning and dynamic scheduling methods to accelerate the training speed in different cases. With the above methods, we proposed fine-grained partitioning KGE, an efficient KGE training framework with multiple GPUs. We conducted experiments on some benchmarks of the knowledge graph, and the results show that our method achieves speedup compared to existing framework on the training of KGE.

Regularized Convolutional Neural Network for Highly Effective Parallel Processing

Convolutional neural network (CNN) has been adopted in various areas. Using graphics processing unit (GPU), speed improvement can be achieved on CNN, and many studies have proposed such acceleration methods. However, parallelizing the CNN on GPU is not straightforward because there are irregular characteristics in generating output feature maps in typical CNN models. In this paper, we propose a method that maximizes the utilization of GPU by modifying convolution combinations of a well-known CNN network, LeNet-5. Our regularized implementation on a heterogeneous system has achieved an improvement of up to 37.26 times in convolution and sub-sampling layers. Further, an energy consumption reduction of up to 26.40 times is achieved.

A Deep Learning Framework Performance Evaluation to Use YOLO in Nvidia Jetson Platform

Deep learning-based object detection technology can efficiently infer results by utilizing graphics processing units (GPU). However, when using general deep learning frameworks in embedded systems and mobile devices, processing functionality is limited. This allows deep learning frameworks such as TensorFlow-Lite (TF-Lite) and TensorRT (TRT) to be optimized for different hardware. Therefore, this paper introduces a performance inference method that fuses the Jetson monitoring tool with TensorFlow and TRT source code on the Nvidia Jetson AGX Xavier platform. In addition, central processing unit (CPU) utilization, GPU utilization, object accuracy, latency, and power consumption of the deep learning framework were compared and analyzed. The model is You Look Only Once Version4 (YOLOv4), and the dataset uses Common Objects in Context (COCO) and PASCAL Visual Object Classes (VOC). We confirmed that using TensorFlow results in high latency. We also confirmed that TensorFlow-TensorRT (TF-TRT) and TRT using Tensor Cores provide the most efficiency. However, it was confirmed that TF-Lite showed the lowest performance because it utilizes a GPU limited to mobile devices. Through this paper, we think that when developing deep learning-related object detection technology on the Nvidia Jetson platform or desktop environment, services and research can be efficiently conducted through measurement results.

Fast infrared radiative transfer calculations using graphics processing units: JURASSIC-GPU v2.0

Abstract. Remote sensing observations in the mid-infrared spectral region (4–15 µm) play a key role in monitoring the composition of the Earth's atmosphere. Mid-infrared spectral measurements from satellite, aircraft, balloons, and ground-based instruments provide information on pressure, temperature, trace gases, aerosols, and clouds. As state-of-the-art instruments deliver a vast amount of data on a global scale, their analysis may require advanced methods and high-performance computing capacities for data processing. A large amount of computing time is usually spent on evaluating the radiative transfer equation. Line-by-line calculations of infrared radiative transfer are considered to be the most accurate, but they are also the most time-consuming. Here, we discuss the emissivity growth approximation (EGA), which can accelerate infrared radiative transfer calculations by several orders of magnitude compared with line-by-line calculations. As future satellite missions will likely depend on exascale computing systems to process their observational data in due time, we think that the utilization of graphical processing units (GPUs) for the radiative transfer calculations and satellite retrievals is a logical next step in further accelerating and improving the efficiency of data processing. Focusing on the EGA method, we first discuss the implementation of infrared radiative transfer calculations on GPU-based computing systems in detail. Second, we discuss distinct features of our implementation of the EGA method, in particular regarding the memory needs, performance, and scalability, on state-of-the-art GPU systems. As we found our implementation to perform about an order of magnitude more energy-efficient on GPU-accelerated architectures compared to CPU, we conclude that our approach provides various future opportunities for this high-throughput problem.

ClusterSheep: A Graphics Processing Unit-Accelerated Software Tool for Large-Scale Clustering of Tandem Mass Spectra from Shotgun Proteomics.

Modern shotgun proteomics experiments generate gigabytes of spectra every hour, only a fraction of which were utilized to form biological conclusions. Instead of being stored as flat files in public data repositories, this large amount of data can be better organized to facilitate data reuse. Clustering these spectra by similarity can be helpful in building high-quality spectral libraries, correcting identification errors, and highlighting frequently observed but unidentified spectra. However, large-scale clustering is time-consuming. Here, we present ClusterSheep, a method utilizing Graphics Processing Units (GPUs) to accelerate the process. Unlike previously proposed algorithms for this purpose, our method performs true pairwise comparison of all spectra within a precursor mass-to-charge ratio tolerance, thereby preserving the full cluster structures. ClusterSheep was benchmarked against previously reported clustering tools, MS-Cluster, MaRaCluster, and msCRUSH. The software tool also functions as an interactive visualization tool with a persistent state, enabling the user to explore the resulting clusters visually and retrieve the clustering results as desired.

Accelerating Spark-Based Applications with MPI and OpenACC

The amount of data produced in scientific and commercial fields is growing dramatically. Correspondingly, big data technologies, such as Hadoop and Spark, have emerged to tackle the challenges of collecting, processing, and storing such large-scale data. Unfortunately, big data applications usually have performance issues and do not fully exploit a hardware infrastructure. One reason is that applications are developed using high-level programming languages that do not provide low-level system control in terms of performance of highly parallel programming models like message passing interface (MPI). Moreover, big data is considered a barrier of parallel programming models or accelerators (e.g., CUDA and OpenCL). Therefore, the aim of this study is to investigate how the performance of big data applications can be enhanced without sacrificing the power consumption of a hardware infrastructure. A Hybrid Spark MPI OpenACC (HSMO) system is proposed for integrating Spark as a big data programming model, with MPI and OpenACC as parallel programming models. Such integration brings together the advantages of each programming model and provides greater effectiveness. To enhance performance without sacrificing power consumption, the integration approach needs to exploit the hardware infrastructure in an intelligent manner. For achieving this performance enhancement, a mapping technique is proposed that is built based on the application’s virtual topology as well as the physical topology of the undelaying resources. To the best of our knowledge, there is no existing method in big data applications related to utilizing graphics processing units (GPUs), which are now an essential part of high-performance computing (HPC) as a powerful resource for fast computation.

Exploiting Reuse for GPU Subgraph Enumeration

Subgraph enumeration is important for many applications such as network motif discovery, community detection, and frequent subgraph mining. To accelerate the execution, recent works utilize graphics processing units (GPUs) to parallelize subgraph enumeration. The performances of these parallel schemes are dominated by the set intersection operations which account for up to 95 percent of the total processing time. (Un)surprisingly, a significant portion (as high as 99 percent) of these operations is actually redundant, i.e., the same set of vertices is repeatedly encountered and evaluated. Therefore, in this article, we seek to salvage and recycle the results of such operations to avoid repeated computation. Our solution consists of two phases. In the first phase, we generate a reusable plan that determines the opportunity for reuse. The plan is based on a novel reuse discovery mechanism that can identify available results to prevent redundant computation. In the second phase, the plan is executed to produce the subgraph enumeration results. This processing is based on a newly designed reusable parallel search strategy that can efficiently maintain and retrieve the results of set intersection operations. Our implementation on GPUs shows that our approach can achieve up to 5 times speedups compared with the state-of-the-art GPU solutions.

Relative Speed Tabulation Method for Efficient Treatment of Resonance Scattering in GPU-Based Monte Carlo Neutron Transport Calculation

A target velocity sampling method named the Relative Speed Tabulation (RST) is proposed for the efficient treatment of resonance elastic scattering in the Monte Carlo simulation utilizing graphics processing units (GPU). The RST method samples the relative speed between a neutron and a target nucleus by employing pretabulated probabilities of relative speeds. The target velocity is then determined from the sampled relative velocity and the neutron speed. The motivation was to avoid the rejection process of the Doppler Broadening Rejection Correction (DBRC) method, which can incur a significant reduction in the parallel performance of vector processors, such as GPUs, due to its largely varying rejection rates. The RST can also overcome the weakness of large variance of the Weight Correction Method (WCM), which would involve drastic changes in neutron weights. The verification results obtained for the Mosteller benchmark problems demonstrate that the RST is equivalent to the DBRC in accuracy, while the calculation speed remains at the same level of the WCM.

Cardinal: A Lower-Length-Scale Multiphysics Simulator for Pebble-Bed Reactors

This paper demonstrates a multiphysics solver for pebble-bed reactors, in particular, for Berkeley’s pebble-bed -fluoride-salt-cooled high-temperature reactor (PB-FHR) (Mark I design). The FHR is a class of advanced nuclear reactors that combines the robust coated particle fuel form from high-temperature gas-cooled reactors, the direct reactor auxiliary cooling system passive decay removal of liquid-metal fast reactors, and the transparent, high-volumetric heat capacitance liquid-fluoride salt working fluids (e.g., FLiBe) from molten salt reactors. This fuel and coolant combination enables FHRs to operate in a high-temperature, low-pressure design space that has beneficial safety and economic implications. The PB-FHR relies on a pebble-bed approach, and pebble-bed reactors are, in a sense, the poster child for multiscale analysis. Relying heavily on the MultiApp capability of the Multiphysics Object-Oriented Simulation Environment (MOOSE), we have developed Cardinal, a new platform for lower-length-scale simulation of pebble-bed cores. The lower-length-scale simulator comprises three physics: neutronics (OpenMC), thermal fluids (Nek5000/NekRS), and fuel performance (BISON). Cardinal tightly couples all three physics and leverages advances in MOOSE, such as the MultiApp system and the concept of MOOSE-wrapped applications. Moreover, Cardinal can utilize graphics processing units for accelerating solutions. In this paper, we discuss the development of Cardinal and the verification and validation and demonstration simulations.