Ian William Tunbridge · Open University of Cape Town (University of Cape Town) · 2011
Graphics processing unit (GPU) architectures are increasingly used for general purpose computing, providing the means to migrate algorithms from the SISD paradigm, synonymous with CPU architectures, to the SIMD paradigm. Generally programmable commodity multi-core hardware can result in significant speed-ups for migrated codes. Because of their computational complexity, molecular simulations in particular stand to benefit from GPU acceleration.
Coarse-grained molecular models provide reduced complexity when compared to the traditional, computationally expensive, all-atom models. However, while coarse-grained models are much less computationally expensive than the all-atom approach, the pairwise energy calculations required at each iteration of the algorithm continue to cause a computational bottleneck for a serial implementation.
In this work, we describe a GPU implementation of the Kim-Hummer coarse-grained model for protein docking simulations, using a Replica Exchange Monte-Carlo (REMC) method. Our highly parallel implementation vastly increases the size- and time scales accessible to molecular simulation. We describe in detail the complex process of migrating the algorithm to a GPU as well as the effect of various GPU approaches and optimisations on algorithm speed-up.
Our benchmarking and profiling shows that the GPU implementation scales very favourably compared to a CPU implementation. Small reference simulations benefit from a modest speedup of between 4 to 10 times. However, large simulations, containing many thousands of residues, benefit from asynchronous GPU acceleration to a far greater degree and exhibit speed-ups of up to 1400 times.
We demonstrate the utility of our system on some model problems. We investigate the effects of macromolecular crowding, using a repulsive crowder model, finding our results to agree with those predicted by scaled particle theory. We also perform initial studies into the simulation of viral capsids assembly, demonstrating the crude assembly of capsid pieces into a small fragment.
This is the first implementation of REMC docking on a GPU, and the effectuate speed-ups alter the tractability of large scale simulations: simulations that otherwise require months or years can be performed in days or weeks using a GPU.
Cited by 0Open access
Takashi Nishitsuji · 2023
Cited by 0
Seon-Ho Shin, Eun-Jin Im, MyungKeun Yoon · Journal of Parallel and Distributed Computing · 2013
Cited by 16
Türeiti Keith, Stephen J. Weddell · Lecture notes in computer science · 2013
Cited by 2
Tyler Sorensen · J. Willard Marriott Library · 2015
Graphics Processing Units (GPUs) are highly parallel shared memory microprocessors, and as such, they are prone to the same concurrency considerations as their traditional multicore CPU counterparts. In this thesis, we consider shared memory consistency, i.e. what values can be read when issued concurrently with writes on current GPU hardware. While memory consistency has been relatively well studied for CPUs, GPUs present substantially different concurrency systems with an explicit thread and memory hierarchy. Because documentation on GPU memory models is limited, it remains unclear what behaviors are allowed by current GPU implementations. To this end, this work focuses on testing shared memory consistency behavior on NVIDIA GPUs. We present a format for describing GPU memory consistency tests (dubbed GPU litmus tests) which includes the placement of testing threads into the GPU thread hierarchy (e.g. cooperative thread arrays, warps) and memory locations into GPU memory regions (e.g. shared, global). We then present a framework for running GPU litmus tests under system stress designed to trigger weak memory model behaviors, that is, executions that do not correspond to an interleaving of the instructions of the concurrent program. We discuss GPU specific incantations (i.e. heuristics) which we found to be crucial for observing weak memory model executions; these include bank conflicts and custom GPU memory stressing functions. We then report the results of running GPU litmus tests in this framework and show that we observe a controversial relaxed coherence behavior on older NVIDIA chips. We present several examples of published GPU applications which may exhibit unintended behavior due to the lack of fence synchronization; one such example is a spin-lock published in the popular CUDA by Example book. We then test several families of tests and compare our results to a proposed operational GPU memory model and show that the model is unsound (i.e. disallows behaviors that we observe on hardware). Our techniques are implemented in a modified version of a memory model testing tool named litmus.
Cited by 0Open access
Vincent Roberge, Mohammed Tarbouchi · Canadian Journal of Electrical and Computer Engineering · 2021
Using multiple unmanned aerial vehicles (UAVs) improves the efficiency of reconnaissance, surveillance, and search and rescue missions. This article presents a path-planning software for a team of UAVs utilizing graphics processing units (GPUs). The UAVs are tasked to visit multiple points of interest (POIs) in a 3-D environment, and the software finds an optimized solution that assigns the POIs to the UAVs, selects the order in which the POIs are visited, and calculates the paths between the POIs. The software uses a multistep approach using a single-source-shortest-path algorithm to find the optimal paths between all combinations of POIs followed by a genetic algorithm to solve the multitraveling salesperson problem. The algorithm can minimize distance, time, or energy consumption depending on the setting selected by the user. The proposed GPU implementation is tested on eight different maps from around the world and executes in just 0.6 s, a 48.3× speedup compared to a sequential execution on CPU. This performance improvement is a real asset in a mission-changing environment.
Cited by 4
Ji Xu, Ying Ren, Wei Ge et al. · Molecular Simulation · 2010
Molecular dynamics (MD) simulation is a powerful computational tool to study the behaviour of macromolecular systems. However, many simulations in this field are limited in spatial or temporal scale by the available computational resource. In recent years, graphics processing units (GPUs) have provided unprecedented computational power for scientific applications. Many MD algorithms suit the multithread nature of GPU. In this paper, MD algorithms for macromolecular systems that run entirely on GPU are presented. For validation, we have performed MD simulations of polymer crystallisation with our GPU package, GPU_MD-1.0.5, and the results agree perfectly with computations on CPUs, meanwhile GPU_MD-1.0.5 achieves about 39 times speedup compared with GROMACS-4.0.5 on a single CPU core. Therefore, our single GPU code has already provided an inexpensive alternative for macromolecular simulations of traditional CPU clusters and will serve as a basis for developing parallel GPU programs to further speed up the computations.
Cited by 20Open access
Senaka Buthpitiya, Ian Lane, Jike Chong · 2011
Cited by 0
Yishin Lin · Zenodo (CERN European Organization for Nuclear Research) · 2017
<em>gpda</em> is an R package, conducting probability density approximation (PDA; Turner & Sederberg, 2012; Holmes, 2015). This package provides R functions and CUDA C API to harness the parallel computing power of graphics processing unit (GPU), making PDA computation efficient. PDA calculates likelihood even when their analytic functions are unavailable. It allows researchers to model computationally complex biological processes, which in the past could only be approached by overly simplified models. PDA is however computationally demanding. It requires a large number of Monte Carlo simulations to attain satisfactory approximation precision. Monte Carlo simulations add a heavy computational burden on every step of PDA algorithm.
Cited by 0Open access
A. M. Fails · 2012
In this project, I conduct a research that strives to make a huge impact on the area of computer forensics. When performing various investigations the process of finding evidence can be a lengthy one in terms of time and resources. We felt it would be cool if we could somehow use a GPU to aid in computer forensic investigations, particularly searching for files. The objective of this research is to test the time efficiency of a standard search method, and compare the results with GPU multi-threading search method. My hypothesis is that the GPU multiprocessors will significantly reduce the time and resources it takes to go through with an investigation of searching for files. My hypothesis is that the GPU multiprocessors will significantly reduce the time and resources it takes to go through with an investigation of searching for files, rendering the time it takes obsolete so that the original, reliable evidence may be used for prosecutions, validation of misconduct, etc. The structure of the graphics processing unit is designed specifically for heavily, complex computations, compared to central processing units that are designed for memory and storage purposes.
Cited by 0
Šopa, Dovydas, · KTUePubl (Repository of Kaunas University of Technology) · 2016
Bin packing problem is classic optimization problem. This problem is interesting not only theoretically, but also has many practical applications. F. e. placing articles in newspaper so that the amount of papers would be minimal. Or putting boxes in trucks so that the amount of trucks would be minimal. “Nvidia” perfected their CUDA technology which allows to perform a large amount of computation using graphics processing unit. Graphics processing unit is adapted to perform the same actions with different data many times, and that is exactly what bin packing problem is all about. This work is focused on solving two-dimensional bin packing problem where objects cannot be rotated, objects are rectangular shape, objects are given offline and all bins are same dimensions. CUDA will also be used to address this challenge in parallel. An evolutionary heuristic algorithm which applies modifications is presented as well. Finally, experiment for measuring the speed and accuracy of the proposed algorithm are presented, as well as the results obtained.
Cited by 0Open access
Abeer A. Mohamad Alshiha, Mohammed Wajid Al-Neama, Abdalrahman R. Qubaa · Bulletin of Miscellaneous Information (Royal Gardens Kew) · 2023
The expansion of biometric applications and databases is worrying. Processing extensive or sophisticated biometric data results in longer wait times, which might restrict application usefulness. This work focuses on accelerating the processing of biometric data and proposes a parallel method of data processing that exceeds the capabilities of a central processing unit (CPU). The combination of the graphics processing unit (GPU) and compute unified device architecture (CUDA) results in at least three times the processing speed of a published accurate and secure multimodal biometric system. The GPU-assisted approach beats the CPU-only implementation when saturating the CPU-only performance with more people than the available thread count. The GPU-assisted solution is also proven to have the same accuracy as the original system, indicating accuracy and processing performance improvements in the demanding big data environment.
Cited by 0Open access
Yusuke Shimotoku, Toshiaki Tanaka, Ryuichi Itoi · 2012
Cited by 0
Joseph M. Cavanagh, Thomas E. Potok, Xiaohui Cui · 2009
Latent Semantic Analysis (LSA) can be used to reduce the dimensions of large Term-Document datasets using Singular Value Decomposition. However, with the ever expanding size of data sets, current implementations are not fast enough to quickly and easily compute the results on a standard PC. The Graphics Processing Unit (GPU) can solve some highly parallel problems much faster than the traditional sequential processor (CPU). Thus, a deployable system using a GPU to speedup large-scale LSA processes would be a much more effective choice (in terms of cost/performance ratio) than using a computer cluster. In this paper, we presented a parallel LSA implementation on the GPU, using NVIDIA R Compute Unified Device Architecture (CUDA) and Compute Unified Basic Linear Algebra Subprograms (CUBLAS). The performance of this implementation is compared to traditional LSA implementation on CPU using an optimized Basic Linear Algebra Subprograms library. For large matrices that have dimensions divisible by 16, the GPU algorithm ran five to six times faster than the CPU version.
Cited by 21
Tien-Tsin Wong, Man Leung Wong · Studies in computational intelligence · 2006
Cited by 23
Shin Morishima · Computers & Electrical Engineering · 2021
In blockchain, approved transactions, including illegal ones, cannot be modified unlike existing bank transactions. To prevent the damage caused by illegal transactions, rapid anomaly detection of transactions is required because transactions can be modified before approval. However, existing anomaly detection methods must process all transactions in blockchain, and the processing time is longer than the interval of each approval. In this paper, we propose a subgraph-based anomaly detection method to perform the detection using a part of the blockchain data. The proposed structure of the subgraph is suitable for graphics processing units (GPUs) to accelerate detection by using parallel processing. In an evaluation using real Bitcoin transaction data, when the number of targeted transactions was one hundred, the proposed method was 11.1x faster than an existing GPU-based method without lowering the detection accuracy.
Cited by 28Open access
Heidi Anderson Kuzma, Dave Bremer, James W. Rector · 2007
Graphics Processing Units (GPUs) are inexpensive, commercial vector processors developed as engines for high‐speed computer games. By substituting geophysical data for color values in arrays that are designed to compute images, GPUs can be used as parallel scientific processors. Support Vector Machines (SVMs) are computer learning algorithms that can be used to emulate non‐linear geophysical inversion. SVMs depend on making multiple comparisons between examples of input data. These comparisons can be made in parallel on the GPU, significantly speeding up the algorithm. GPUs only support single precision, however, and are limited by their memory size. This poster presents results of a preliminary study showing that speedups of as great as 250× can be achieved using a GPU to make the comparisons necessary to train an SVM with a nearly 3000 example training set of input vectors with 3000 elements each. Because only the comparison part of the SVM algorithm was implemented on the GPU, this work can likely be generalized to other processes useful for Geophysics that depend on making comparisons, such as correlation and convolution.
Cited by 3
Mary McCabe, George Salazar, Glen Steele · NASA STI Repository (National Aeronautics and Space Administration) · 2015
A graphics processing capability will be required for deep space missions and must include a range of applications, from safety-critical vehicle health status to telemedicine for crew health. However, preliminary radiation testing of commercial graphics processing cards suggest they cannot operate in the deep space radiation environment. Investigation into an Software Graphics Processing Unit (sGPU)comprised of commercial-equivalent radiation hardened/tolerant single board computers, field programmable gate arrays, and safety-critical display software shows promising results. Preliminary performance of approximately 30 frames per second (FPS) has been achieved. Use of multi-core processors may provide a significant increase in performance.
Cited by 0Open access
Siwoo Eum, Hyunjun Kim, Min-Ho Song et al. · Applied Sciences · 2023
In modern information technology systems, secure storage and transmission of personal and sensitive data are recognized as important tasks. These requirements are achieved through secure and robust encryption methods. Argon2 is an advanced cryptographic algorithm that emerged as the winner in the Password Hashing Competition (PHC), offering a concrete and secure measure. Argon2 also provides a secure mechanism against side-channel attacks and cracking attacks using parallel processing (e.g., GPU). In this paper, we analyze the existing GPU-based implementation of the Argon2 algorithm and further optimize the implementation by improving the performance of the hashing function during the computation process. The proposed method focuses on enhancing performance by distributing tasks between CPU and GPU units, reducing the data transfer cost for efficient GPU-based parallel processing. By shifting several stages from the CPU to the GPU, the data transfer cost is significantly reduced, resulting in faster processing times, particularly when handling a larger number of passwords and higher levels of parallelism. Additionally, we optimize the utilization of the GPU’s shared memory, which enhances memory access speed, especially in the computation of the hash value generation process. Furthermore, we leverage the parallel processing capabilities of the GPU to perform efficient brute-force attacks. By computing the H function on the GPU, the proposed implementation can generate initial blocks for multiple inputs in a single operation, making brute-force attacks in an efficient way. The proposed implementation outperforms existing methods, especially when processing a larger number of passwords and operating at higher levels of parallelism.
Cited by 7Open access
Giuseppe M. J. Barca, Jorge L. Galvez-Vallejo, David Poole et al. · Journal of Chemical Theory and Computation · 2020
We present a high-performance, GPU (graphics processing unit)-accelerated algorithm for building the Fock matrix. The algorithm is designed for efficient calculations on large molecular systems and uses a novel dynamic load balancing scheme that maximizes the GPU throughput and avoids thread divergence that could occur due to integral screening. Additionally, the code adopts a novel ERI digestion algorithm that exploits all forms of permutational symmetry, combines efficiently the evaluation of both Coulomb and exchange terms together, and eliminates explicit thread synchronization requirements. Performance results obtained using a number of large molecules reveal remarkable speedups up to 24.4× with respect to the QUICK GPU code and up to 237× with respect to the GAMESS CPU parallel code.
Cited by 55