Graphics Processing Units Threads Research Articles

Development of a GPU-based multisphere DE–FE coupling method for interaction simulations between an off-road tire and a gravel terrain

For decades, growing interest has been devoted to simulating the tire–soil interaction phenomena using discrete element/finite element (DE–FE) coupling methods. In contrast to the widely used approach that idealizes soils as spherical DEs, a newly developed multisphere DE–FE method has been demonstrated to be more accurate in reproducing such phenomena; however, it requires considerable computational cost for large-scale tire–soil interaction simulations. Therefore, this study aims to develop an efficient graphics processing unit (GPU)-based multisphere DE–FE method based on a CUDA FORTRAN programming environment. To this end, two-level grids are introduced for the parallelization of contact detection for targeted multisphere DEs and subspheres, which helps to find contact pairs for the targeted subspheres of a multisphere DE in an efficient manner. In contrast to existing GPU-based parallelization techniques, which typically use atomic operations to avoid memory access conflicts, this study presents a parallelization strategy to process a contact pair between bounding spheres using one GPU thread to efficiently handle with owner-member relationships between multisphere DEs and their subspheres. In the parallelization for force calculation, our method introduces an efficient technique that utilizes one GPU thread to process a contact pair between subspheres, or between subspheres and FE segments, to reduce the number of repeated calculations. Finally, the developed GPU-based method is applied to analyze the travelling behaviors of a complex-patterned off-road tire on a gravel terrain, and the effectiveness and computational efficiency of this method are validated via indoor soil-bin experimental outcomes as well as serial and parallel simulation results. It is found that a speedup of approximately 38 has been achieved with the aid of the developed method.

An edge-aided parallel evolutionary privacy-preserving algorithm for Internet of Things

Data sanitization in the context of Internet of Things (IoT) privacy refers to the process of permanently and irreversibly hiding all sensitive information from vast amounts of streaming data. Taking into account the dynamic and real-time characteristics of streaming IoT data, we propose a parallel evolutionary Privacy-Preserving Data Mining (PPDM), called High-performance Evolutionary Data Sanitization for IoT (HEDS4IoT), and implement two mechanisms on a Graphics Processing Units (GPU)-aided parallelized platform to achieve real-time streaming protected data transmission. The first mechanism, the Parallel Indexing Engine (PIE), generates retrieval index lists from the dataset using GPU blocks. These lists are used in place of the dataset during the PPDM process. The second mechanism, called Parallel Fitness Function Engine (PF2E), parallelizes the index lists on the GPU threads to speed up the computation of the quality of solutions generated by the evolutionary algorithm, in which deferential evolution is adopted as the evolutionary algorithm. In addition to the ability for Big data, the HEDS4IoT can be adaptively adjusted for dynamic nature of IoT where new streaming data is considered for data sanitization. Our experimental results with extensive benchmarks show that, at the kernel level, the PIE and PF2E mechanisms are averagely 33.5x and 53.7x faster than their CPU-implemented version, respectively. At the application level, our findings demonstrate that the HEDS4IoT can perform the PPDM process 47.7x faster than some of the state-of-art methods.

Real-Time Polarization Demultiplexing by Multi-Thread Constant Modulus Algorithm for Fully Softwarized Access Networks

Optical access networks are replacing dedicated hardware-based architectures with architectures centered on general-purpose servers based on network function virtualization (NFV) and the software-defined network (SDN) in order to efficiently support various new services. To maximize the advantage of this new approach, studies are now targeting the fully softwarized access network which requires softwarization of digital signal processing (DSP). However, polarization demultiplexing includes sequential processing, and it is difficult to softwarize high-speed filter updates in a constant modulus algorithm (CMA) that supports real-world state of polarization (SOP) change. This paper proposes a novel multi-thread CMA that can track fast SOP changes by using multiple threads to implement filter convolution. It tracks faster SOP changes with the same filter update cycle as the conventional method by calculating multiple filters on multiple threads and averaging them. Its graphics processing unit (GPU) implementation adopts parallel reduction for averaging the filters and parallelizes the update of filters for tributaries X and Y in order to take advantage of many GPU threads. We evaluate the real-time bit error rate (BER) performance achieved by implementing the DSP functions with the proposal in a 5-Gb/s dual-polarization-quadrature phase-shift keying (DP-QPSK) system. The demonstration results show that the proposed algorithm supports 2,000 rd/s real-time performance for optical systems and offers high feasibility for application to the fully softwarized access network.

Comparison of Two Parallel Offsetting Algorithms Free from Conflicts Between Threads

Offset computation for expanding a polyhedral object by an offset radius is a fundamental geometric process frequently used in manufacturing applications. This process combined with the triple-dexel representation solid model has become popular because of its robustness and compatibility with parallel processing using a graphics processing unit (GPU). In parallel geometric processing, conflicts between threads must be avoided. Thus, we propose a novel parallel offsetting algorithm free from conflicts between threads. The triple-dexel model is a combination of x-, y-, and z-axis-aligned dexel models. Each dexel model is defined based on an orthogonal grid given on a coordinate plane. We subdivide the grid into several sub-grids of a fixed size in advance. For each sub-grid, a block of GPU threads is assigned. As each GPU thread always processes different dexel elements from the other threads in this method, no conflict occurs. Our research group has previously presented a parallel offset computation algorithm for a polyhedral solid model that also uses a triple-dexel representation model and a GPU. In the previous algorithm, the surface polygons of the model are classified into several groups in advance. The parallel offset computation of multiple polygon groups is realized by selecting groups of polygon in which the offset processing of the polygons does not affect one another. This selection process is time-consuming. Computational experiments were performed to analyze the performance difference between the current algorithm and our previous algorithm. In our experiments, the current algorithm achieved speedups of 1.4 times to 3.2 times compared to our previous offsetting algorithm.

GPU acceleration of finite state machine input execution: Improving scale and performance

SummaryModel‐based development is a popular development approach in which software is implemented and verified based on a model of the required system. Finite state machines (FSMs) are widely used as models for systems in several domains. Validating that a model accurately represents the required behaviour involves the generation and execution of a large number of input sequences, which is often an expensive and time‐consuming process. In this paper, we speed up the execution of input sequences for FSM validation, by leveraging the high degree of parallelism of modern graphics processing units (GPUs) for the automatic execution of FSM input sequences in parallel on the GPU threads. We expand our existing work by providing techniques that improve the performance and scalability of this approach. We conduct extensive empirical evaluation using 15 large FSMs from the networking domain and measure GPU speed‐up over a 16‐core CPU, taking into account total GPU time, which includes both data transfer and kernel execution time. We found that GPUs execute FSM input sequences up to 9.28× faster than a 16‐core CPU, with an average speed‐up of 4.53× across all subjects. Our optimizations achieve an average improvement over existing work of 58.95%for speed‐up and scalability to large FSMs with over 2K states and 500K transitions. We also found that techniques aimed at reducing the number of required input sequences for large FSMs with high density were ineffective when applied to all‐transition pair coverage, thus emphasizing the need for approaches like ours that speed up input execution.

Component-based 2-/3-dimensional nearest neighbor search based on Elias method to GPU parallel 2D/3D Euclidean Minimum Spanning Tree Problem

We present improved data parallel approaches working on graphics processing unit (GPU) compute unified device architecture (CUDA) platform to build hierarchical Euclidean minimum spanning forest or tree (EMSF/EMST) for applications whose input only contains N points with arbitrary data distribution in 2D/3D Euclidean space. Characteristic of the proposed parallel algorithms follows “data parallelism, decentralized control and O(1) local memory occupied by each GPU thread”. This research has to solve GPU parallelism of component-based nearest neighbor search (component-based NNS), tree traversal, and other graph operations like union-find. For exact NNS, instead of using classical K-d tree search or brute-force computing method, we propose a K-d search method working based on dividing the Euclidean K-dimensional space into congruent and non-overlapping square/cubic cells where size of points in each cell is bounded. For component-based NNS, with the uniqueness property based on 2D/3D square/cubic space partition, we propose dynamic and static pruning techniques to prune unnecessary neighbor cells’ search. For tree traversal, instead of using breadth-first-search, this paper proposes CUDA kernels working with a distributed dynamic link list for selecting a local spanning tree’s shortest outgoing edge since size of local EMSTs in EMSF cannot be predicted. Source code is provided online and experimental comparisons are conducted on both 2D and 3D benchmarks with up to 107 points to build final EMST. Results show that applying K-d search with static pruning technique and the proposed operators totally working in parallel on GPU, our current implementation runs faster than our previous work and current optimal sequential dual-tree mlpack EMST library.

GPU acceleration of MPAS microphysics WSM6 using OpenACC directives: Performance and verification

In this study, we accelerated a microphysics scheme embedded within the Model for Prediction Across Scales (MPAS), using OpenACC directives. As one of the most time-consuming physics parameterization schemes, we focused on parallelizing the Weather Research and Forecasting (WRF) single-moment 6-class microphysics scheme (WSM6) onto a graphics processing unit (GPU). We applied several essential methodologies to optimize the performance of WSM6 computation on the GPU, to minimize data transfer between the central processing unit (CPU) and GPU and to reduce the waste of GPU threads during computation. As a result, we achieved GPU runs using 1 T V100 that were 2.38 times faster than 48 message passing interface processes runs, on average. When porting the whole model onto the GPU, we achieved a ×5.71 speed-up in WSM6 computation, except in I/O communication. In addition, the precise verification method distinguished nonlinear chaotic error growth from differences introduced by GPU computation, considering the characteristics of the major output variables from WSM6. We then compared the difference between the CPU and the GPU runs to the difference between CPU runs with different compilers. Moreover, we examined bias in these differences, which can distort the climatology of model simulation. Our approach successfully passed the verification process, and this represents the successful application of GPU acceleration to realistic full-model integration of MPAS.

Multiple k −opt evaluation multiple k −opt moves with GPU high performance local search to large-scale traveling salesman problems

The 2-opt, 3-opt or k–opt heuristics are classical local search algorithms for traveling salesman problems (TSP) in combinatorial optimization area, while sequential k–opt complete neighborhood examination takes polynomial time complexity which is timeconsuming to approach large scale TSP instances. This paper introduces a reasonable methodology called “multiple k–opt evaluation, multiple k–opt moves” that allows to simultaneously execute, without interference, massive k −opt moves that are globally found on the same TSP tour, as well as keep high performance GPU (Graphics Processing Unit) parallel 2-/3-opt evaluation with characteristic of “data parallelism, decentralized control and O(1) local memory for each GPU thread”. The methodology is reasonable since intervention of a sequential O(N) time complexity tour reversal operation is unavoidable for each k −opt move when using array of ordered coordinates as TSP tour data structure for high performance GPU k −opt local search that considers coalesced memory access and usage of limited on-chip shared memory. Innovation work includes two parts, a sequential non-interacted k-opt moves’ set partition algorithm that takes linear time complexity; a new TSP tour representation, array of ordered coordinates-index, that unveils how to combine the advantages of using doubly linked list and array of ordered coordinates data structures for iterative parallel k −opt local search based on GPU CUDA. We test this methodology on 22 national TSP instances with up to 71009 cities and with brute initial tour solution. Average maximum 997 non-interacted 2-opt moves are found and executed on the same tour of ch71009.tsp instance after one iteration of complete $\frac {N*(N-1)}{2}$ 2-opt checks working in parallel on GPU. And the proposed iterative GPU parallel 2-opt methodology executes average 306631 2-opt moves while only iterates 786 tour reversal operations, in comparison with methods that have to execute tour reversal operation after each 2-opt move. Experimental comparisons show that our proposed methodology gets huge acceleration over both classical sequential and a current state-of-the-art GPU parallel 2-opt implementation.

Accelerating Revised Simplex Method Using GPU-Based Basis Update

Optimization problems lie at the core of scientific and engineering endeavors. Solutions to these problems are often compute-intensive. To fulfill their compute-resource requirements, graphics processing unit (GPU) technology is considered a great opportunity. To this end, we focus on linear programming (LP) problem solving on GPUs using revised simplex method (RSM). This method has potentially GPU-friendly tasks, when applied to large dense problems. Basis update (BU) is one such task, which is performed in every iteration to update a matrix called basis-inverse matrix. The contribution of this paper is two-fold. Firstly, we experimentally analyzed the performance of existing GPU-based BU techniques. We discovered that the performance of a relatively old technique, in which each GPU thread computed one element of the basis-inverse matrix, could be significantly improved by introducing a vector-copy operation to its implementation with a sophisticated programming framework. Second, we extended the adapted element-wise technique to develop a new BU technique by using three inexpensive vector operations. This allowed us to reduce the number of floating-point operations and conditional processing performed by GPU threads. A comparison of BU techniques implemented in double precision showed that our proposed technique achieved 17.4% and 13.3% average speed-up over its closest competitor for randomly generated and well-known sets of problems, respectively. Furthermore, the new technique successfully updated basis-inverse matrix in relatively large problems, which the competitor was unable to update. These results strongly indicate that our proposed BU technique is not only efficient for dense RSM implementations but is also scalable.

A Parallel-Computing Approach for Vector Road-Network Matching Using GPU Architecture

The road-network matching method is an effective tool for map integration, fusion, and update. Due to the complexity of road networks in the real world, matching methods often contain a series of complicated processes to identify homonymous roads and deal with their intricate relationship. However, traditional road-network matching algorithms, which are mainly central processing unit (CPU)-based approaches, may have performance bottleneck problems when facing big data. We developed a particle-swarm optimization (PSO)-based parallel road-network matching method on graphics-processing unit (GPU). Based on the characteristics of the two main stages (similarity computation and matching-relationship identification), data-partition and task-partition strategies were utilized, respectively, to fully use GPU threads. Experiments were conducted on datasets with 14 different scales. Results indicate that the parallel PSO-based matching algorithm (PSOM) could correctly identify most matching relationships with an average accuracy of 84.44%, which was at the same level as the accuracy of a benchmark—the probability-relaxation-matching (PRM) method. The PSOM approach significantly reduced the road-network matching time in dealing with large amounts of data in comparison with the PRM method. This paper provides a common parallel algorithm framework for road-network matching algorithms and contributes to integration and update of large-scale road-networks.

TripleID-Q: RDF Query Processing Framework Using GPU

Resource Description Framework (RDF) data represents information linkage around the Internet. It uses Inter- nationalized Resources Identifier (IRI) which can be referred to external information. Typically, an RDF data is serialized as a large text file which contains millions of relationships. In this work, we propose a framework based on TripleID-Q, for query processing of large RDF data in a GPU. The key elements of the framework are 1) a compact representation suitable for a Graphics Processing Unit (GPU) and 2) its simple representation conversion method which optimizes the preprocessing overhead. Together with the framework, we propose parallel algorithms which utilize thousands of GPU threads to look for specific data for a given query as well as to perform basic query operations such as union, join, and filter. The TripleID representation is smaller than the original representation 3-4 times. Querying from TripleID using a GPU is up to 108 times faster than using the traditional RDF tool. The speedup can be more than 1,000 times over the traditional RDF store when processing a complex query with union and join of many subqueries.

Exploiting GPU and cluster parallelism in single scan frequent itemset mining

This paper considers discovering frequent itemsets in transactional databases and addresses the time complexity problem by using high performance computing (HPC). Three HPC versions of the Single Scan (SS) algorithm are proposed. The first one (GSS) implements SS on a GPU (Graphics Processing Unit) architecture using an efficient mapping between thread blocks and the input data. The second approach (CSS) implements SS on a cluster architecture by scheduling independent jobs to workers in a cluster. The third, (CGSS) accelerates the frequent itemset mining process by using multiple cluster nodes equipped with GPUs. Moreover, three partitioning strategies are proposed to reduce GPU thread divergence and cluster load imbalance. Results show that CGSS outperforms SS, GSS, and CSS in terms of speedup. Specifically, CGSS provides up to a 350 times speedup for low minimum support values on large datasets. GCSS demonstrably outperforms the state-of-the-art HPC-based algorithms on big databases.

Accelerating data gravitation-based classification using GPU

Data gravitation-based classification model, a new physic law inspired classification model, has been demonstrated to be an effective classification model for both standard and imbalanced tasks. However, due to its large scale of gravitational computation during the feature weighting process, DGC suffers from high computational complexity, especially for large data sets. In this paper, we address the problem of speeding up gravitational computation using graphics processing unit (GPU). We design a GPU parallel algorithm namely GPU–DGC to accelerate the feature weighting process of the DGC model. Our GPU–DGC model distributes the gravitational computing process to parallel GPU threads, in order to compute gravitation simultaneously. We use 25 open classification data sets to evaluate the parallel performance of our algorithm. The relationship between the speedup ratio and the number of GPU threads is discovered and discussed based on the empirical studies. The experimental results show the effectiveness of GPU–DGC, with the maximum speedup ratio of 87 to the serial DGC. Its sensitivity to the number of GPU threads is also discovered in the empirical studies.

Efficient optimization approach for fast GPU computation of Zernike moments

Our study focuses on accelerating the computation of Zernike moments on graphics processing units (GPUs). There are two ideas to achieve the goal. First is to implement a novel re-layout that involves reordering the image pixels and addressing the diagonal pixels in advance, so that computations of all pixels are allocated to an octant effectively. Second is to the leverage the constant memory to store precomputed values used across GPU threads. An in-depth study has been carried out to evaluate the performance in each case and to compare against GPU implementation of other algorithms and to discuss the bottleneck. The result shows that our approach is effective and achieves significant performance improvement compared to other GPU state-of-the-art implementations. Furthermore, our approach is suited for allocating the data flow into multiple GPUs.

Scalable and fast SVM regression using modern hardware

Support Vector Machine (SVM) regression is an important technique in data mining. The SVM training is expensive and its cost is dominated by: (i) the kernel value computation, and (ii) a search operation which finds extreme training data points for adjusting the regression function in every training iteration. Existing training algorithms for SVM regression are not scalable to large datasets because: (i) each training iteration repeatedly performs expensive kernel value computations, which is inefficient and requires holding the whole training dataset in memory; (ii) the search operation used in each training iteration considers the whole search space which is very expensive. In this article, we significantly improve the scalability and efficiency of SVM regression by exploiting the high performance of Graphics Processing Units (GPUs) and solid state drives (SSDs). Our key ideas are as follows. (i) To reduce the cost of repeated kernel value computations and avoid holding the whole training dataset in the GPU memory, we precompute all the kernel values and store them in the CPU memory extended by the SSD; together with an efficient strategy to read the precomputed kernel values, reusing precomputed kernel values with an efficient retrieval is much faster than computing them on-the-fly. This also alleviates the restriction that the training dataset has to fit into the GPU memory, and hence makes our algorithm scalable to large datasets, especially for large datasets with very high dimensionality. (ii) To enhance the performance of the frequently used search operation, we design an algorithm that minimizes the search space and the number of accesses to the GPU global memory; this optimized search algorithm also avoids branch divergence (one of the causes for poor performance) among GPU threads to achieve high utilization of the GPU resources. Our proposed techniques together form a scalable solution to the SVM regression which we call SIGMA. Our extensive experimental results show that SIGMA is highly efficient and can handle very large datasets which the state-of-the-art GPU-based algorithm cannot handle. On the datasets of size that the state-of-the-art GPU-based algorithm can handle, SIGMA consistently outperforms the state-of-the-art GPU-based algorithm by an order of magnitude and achieves up to 86 times speedup.

High performance GPU‐based parity computing scheduler in storage applications

SummaryThis paper proposes a high‐performance graphics processing unit (GPU)‐based parity computing scheduler, which we call GPU‐redundant array of inexpensive disks (RAID), to reduce the encoding and decoding time for storage applications. The proposed GPU‐RAID differs from existing RAID in that it performs additional pairwise‐parallel XOR operations between data code words in each data stripe by applying divide‐and‐conquer approach using extra reserved space and it also increases parallelism by processing multiple strips in parallel using multiple GPU threads. And so the proposed GPU‐RAID pipelines data blocks into solid‐state disks and parity blocks into hard disk drives at the target server. The proposed algorithm decreases the span complexity of the parity computation schedule to O(log2nw) where n is the number of disks and w is the number of code words in a block, and it can be applied to various types of erasure codes. Experimental results show that the proposed storage application (SA1) improves average encoding performance by 63%, and 41%, and average decoding performance by 58%, and 38%, compared with traditional storage applications GPUStore (SA3) and Gibraltar RAID(SA2), respectively. Copyright © 2016 John Wiley & Sons, Ltd.

Monte Carlo dose calculations for high-dose–rate brachytherapy using GPU-accelerated processing

PurposeCurrent clinical brachytherapy dose calculations are typically based on the Association of American Physicists in Medicine Task Group report 43 (TG-43) guidelines, which approximate patient geometry as an infinitely large water phantom. This ignores patient and applicator geometries and heterogeneities, causing dosimetric errors. Although Monte Carlo (MC) dose calculation is commonly recognized as the most accurate method, its associated long computational time is a major bottleneck for routine clinical applications. This article presents our recent developments of a fast MC dose calculation package for high-dose–rate (HDR) brachytherapy, gBMC, built on a graphics processing unit (GPU) platform. Methods and MaterialsgBMC-simulated photon transport in voxelized geometry with physics in 192Ir HDR brachytherapy energy range considered. A phase-space file was used as a source model. GPU-based parallel computation was used to simultaneously transport multiple photons, one on a GPU thread. We validated gBMC by comparing the dose calculation results in water with that computed TG-43. We also studied heterogeneous phantom cases and a patient case and compared gBMC results with Acuros BV results. ResultsRadial dose function in water calculated by gBMC showed <0.6% relative difference from that of the TG-43 data. Difference in anisotropy function was <1%. In two heterogeneous slab phantoms and one shielded cylinder applicator case, average dose discrepancy between gBMC and Acuros BV was <0.87%. For a tandem and ovoid patient case, good agreement between gBMC and Acruos BV results was observed in both isodose lines and dose-volume histograms. In terms of the efficiency, it took ∼47.5 seconds for gBMC to reach 0.15% statistical uncertainty within the 5% isodose line for the patient case. ConclusionsThe accuracy and efficiency of a new GPU-based MC dose calculation package, gBMC, for HDR brachytherapy make it attractive for clinical applications.

Reducing memory usage by the lifting-based discrete wavelet transform with a unified buffer on a GPU

In this study, to improve the speed of the lifting-based discrete wavelet transform (DWT) for large-scale data, we propose a parallel method that achieves low memory usage and highly efficient memory access on a graphics processing unit (GPU). The proposed method reduces the memory usage by unifying the input buffer and output buffer but at the cost of a working memory region that is smaller than the data size n. The method partitions the input data into small chunks, which are then rearranged into groups so different groups of chunks can be processed in parallel. This data rearrangement scheme classifies chunks in terms of data dependency but it also facilitates transformation via simultaneous access to contiguous memory regions, which can be handled efficiently by the GPU. In addition, this data rearrangement is interpreted as a product of circular permutations such that a sequence of seeds, which is an order of magnitude shorter than input data, allows the GPU threads to compute the complicated memory indexes needed for parallel rearrangement. Because the DWT is usually part of a processing pipeline in an application, we believe that the proposed method is useful for retaining the amount of memory for use by other pipeline stages.

New GPU computing algorithm for wind load uncertainty analysis on high-rise systems

In recent years, the Graphics Processing Unit (GPU) has become a competitive computing technology in comparison with the standard Central Processing Unit (CPU) technology due to reduced unit cost, energy and computing time. This paper describes the derivation and implementation of GPU-based algorithms for the analysis of wind loading uncertainty on high-rise systems, in line with the research field of probability-based wind engineering. The study begins by presenting an application of the GPU technology to basic linear algebra problems to demonstrate advantages and limitations. Subsequently, Monte-Carlo integration and synthetic generation of wind turbulence are examined. Finally, the GPU architecture is used for the dynamic analysis of three high-rise structural systems under uncertain wind loads. In the first example the fragility analysis of a single degree-of-freedom structure is illustrated. Since fragility analysis employs sampling-based Monte Carlo simulation, it is feasible to distribute the evaluation of different random parameters among different GPU threads and to compute the results in parallel. In the second case the fragility analysis is carried out on a continuum structure, i.e., a tall building, in which double integration is required to evaluate the generalized turbulent wind load and the dynamic response in the frequency domain. The third example examines the computation of the generalized coupled wind load and response on a tall building in both along-wind and cross-wind directions. It is concluded that the GPU can perform computational tasks on average 10 times faster than the CPU.

An analytic linear accelerator source model for GPU-based Monte Carlo dose calculations

Recently, there has been a lot of research interest in developing fast Monte Carlo (MC) dose calculation methods on graphics processing unit (GPU) platforms. A good linear accelerator (linac) source model is critical for both accuracy and efficiency considerations. In principle, an analytical source model should be more preferred for GPU-based MC dose engines than a phase-space file-based model, in that data loading and CPU-GPU data transfer can be avoided. In this paper, we presented an analytical field-independent source model specifically developed for GPU-based MC dose calculations, associated with a GPU-friendly sampling scheme. A key concept called phase-space-ring (PSR) was proposed. Each PSR contained a group of particles that were of the same type, close in energy and reside in a narrow ring on the phase-space plane located just above the upper jaws. The model parameterized the probability densities of particle location, direction and energy for each primary photon PSR, scattered photon PSR and electron PSR. Models of one 2D Gaussian distribution or multiple Gaussian components were employed to represent the particle direction distributions of these PSRs. A method was developed to analyze a reference phase-space file and derive corresponding model parameters. To efficiently use our model in MC dose calculations on GPU, we proposed a GPU-friendly sampling strategy, which ensured that the particles sampled and transported simultaneously are of the same type and close in energy to alleviate GPU thread divergences. To test the accuracy of our model, dose distributions of a set of open fields in a water phantom were calculated using our source model and compared to those calculated using the reference phase-space files. For the high dose gradient regions, the average distance-to-agreement (DTA) was within 1 mm and the maximum DTA within 2 mm. For relatively low dose gradient regions, the root-mean-square (RMS) dose difference was within 1.1% and the maximum dose difference within 1.7%. The maximum relative difference of output factors was within 0.5%. Over 98.5% passing rate was achieved in 3D gamma-index tests with 2%/2 mm criteria in both an IMRT prostate patient case and a head-and-neck case. These results demonstrated the efficacy of our model in terms of accurately representing a reference phase-space file. We have also tested the efficiency gain of our source model over our previously developed phase-space-let file source model. The overall efficiency of dose calculation was found to be improved by ~1.3–2.2 times in water and patient cases using our analytical model.