Search

CMakeCatchTemplate (https://github.com/MattClarkson/CMakeCatchTemplate) is a project to provide a starting structure for C++ projects configured with CMake, that can be customised to work in a variety of scenarios, allowing developers to deploy new algorithms to users in a shorter timeframe. Main features include a SuperBuild to build optional dependencies; unit tests using Catch; support for CUDA, OpenMP and MPI; examples of command line and GUI applications; Doxygen integration; Continuous Integration templates and support for building/deploying Python modules. [ABSTRACT FROM AUTHOR]

Thinning is one of the most important techniques in the field of image processing. It is applied to erode the image of an object layer-by-layer until a skeleton is left. Several thinning algorithms allowing to get a skeleton of a binary image are already proposed in the literature. This paper investigates several well-known parallel thinning algorithms and proposes a modified version of the most widely used thinning algorithm, called the ZS algorithm. The proposed modified ZS (MZS) algorithm is implemented and compared against seven existing algorithms. Experimental results and performances evaluation, using different image databases, confirm the proposed MZS algorithm improvement over the seven examined algorithms both in terms of the obtained results quality and the computational speed. Moreover, for an efficient implementation (on Graphics Processing Units), a parallel model of the MZS algorithm is proposed (using the Compute Unified Device Architecture, CUDA, as a parallel programming model). Evaluation results have shown that the parallel version of the proposed algorithm is, on average, more than 21 times faster than the traditional CPU sequential version. [ABSTRACT FROM AUTHOR]

Abstract: This study focuses on the identification of the natural frequencies of structures through the analysis of the speckle pattern that a laser creates and a camera records. The laser pointer spreads its light over a target area on the structure and creates the speckle pattern. The ambient vibrations affect the pattern and a camera records the changes. The stream of images is fed into a graphics processing unit (GPU). The developed parallel code includes different algorithms: the speckle contrast image (SCI), the speckle flow imaging (SFI), and an innovative application of k‐means clustering that uses the geometrical centroid of each cluster as virtual sensors. The tracking of the centroid in time domain through the images creates a vibration signal. The signals from different clusters are processed together to extract the natural frequencies of the structure. This study applies the proposed method to different sample structures both in laboratory and in the field to demonstrate how the obtained signals are reliable and easy to handle. The GPU technology enhances the performance of the entire method and allows the achievement of real‐time processing. All these features create an inexpensive, portable, and efficient tool to inspect any structure or its components. [ABSTRACT FROM AUTHOR]

The world of DNA sequencing has not only been a difficult field since it was first worked upon, but it is also growing at an exponential rate. The amount of data involved in DNA searching is huge, thereby normal tools or algorithms are not suitable to handle this degree of data processing. BLAST is a tool given by National Center for Biotechnology Information (NCBI) to compare nucleotide or protein sequences to sequence databases and calculate the statistical significance of matches. Many variants of BLAST such as blastn, blastp, blastx, etc. are used to search for nucleotides, proteins, nucleotides-to-proteins sequences respectively. GPU-BLAST and HBLAST have already been proposed to handle the vast amount of data involved in searching DNA sequencing and they also speedup the searching process. In this article, we propose a new model for searching DNA sequences-HCudaBLAST. It involves CUDA processing and Hadoop combined for efficient searching. The results recorded after implementing HCudaBLAST are shown. This solution combines the multi-core parallelism of GPGPUs and the scalability feature provided by the Hadoop framework. [ABSTRACT FROM AUTHOR]

In some warning applications, such as aircraft taking-off and landing, ship sailing, and traffic guidance in foggy weather, the high definition (HD) and rapid dehazing of images and videos is increasingly necessary. Existing technologies for the dehazing of videos or images have not completely exploited the parallel computing capacity of modern multi-core CPU and GPU, and leads to the long dehazing time or the low frame rate of video dehazing which cannot meet the real-time requirement. In this paper, we propose a parallel implementation and optimization method for the real-time dehazing of the high definition videos based on a single image haze removal algorithm. Our optimization takes full advantage of the modern CPU+GPU architecture, which increases the parallelism of the algorithm, and greatly reduces the computational complexity and the execution time. The optimized OpenCL parallel implementation is integrate into FFmpeg as an independent module. The experimental results show that for a single image, the performance of the optimized OpenCL algorithm is improved approximately 500% compared with the existing algorithm, and approximately 153% over the basic OpenCL algorithm. The 1080p (1920 × 1080) high definition hazy video can also processed at a real-time rate (more than 41 frames per second). [ABSTRACT FROM AUTHOR]

Approximate string matching with k-differences has a number of practical applications, ranging from pattern recognition to computational biology. This paper proposes an efficient memory-access algorithm for parallel approximate string matching with k-differences on Graphics Processing Units (GPUs). In the proposed algorithm, all threads in the same GPUs warp share data using warp-shuffle operation instead of accessing the shared memory. Moreover, we implement the proposed algorithm by exploiting the memory structure of GPUs to optimize its performance. Experiment results for real DNA packages revealed that the performance of the proposed algorithm and its implementation archived up to 122.64 and 1.53 times compared to that of sequential algorithm on CPU and previous parallel approximate string matching algorithm on GPUs, respectively. [ABSTRACT FROM AUTHOR]

To solve the problem that the statistics of the common random number sequence is poor and the real-time of generating random number sequence is worse,combining advantages and disadvantages of each two types of traditional random number algorithm and newly random number algorithm,this paper proposed a new method that was based on the Sobol’s sequence random number algorithm. The new method could be used to increase the randomness and uniformity of random number sequence and could be obtained random number sequence samples having a good statistical. Next the new random number algorithm was implemented on the CUDA platform to improve its parallel acceleration rate. Finally by the statistical test and charts test this paper verified the feasibility of the above methods. Compared to the traditional CPU serial operation,the speedup ratio has reached more than 200 times,when generating 217 random numbers. [ABSTRACT FROM AUTHOR]

The availability of digital X-ray detectors, together with advances in reconstruction algorithms, creates an opportunity for bringing 3D capabilities to conventional radiology systems. The downside is that reconstruction algorithms for non-standard acquisition protocols are generally based on iterative approaches that involve a high computational burden. The development of new flexible X-ray systems could benefit from computer simulations, which may enable performance to be checked before expensive real systems are implemented. The development of simulation/reconstruction algorithms in this context poses three main difficulties. First, the algorithms deal with large data volumes and are computationally expensive, thus leading to the need for hardware and software optimizations. Second, these optimizations are limited by the high flexibility required to explore new scanning geometries, including fully configurable positioning of source and detector elements. And third, the evolution of the various hardware setups increases the effort required for maintaining and adapting the implementations to current and future programming models. Previous works lack support for completely flexible geometries and/or compatibility with multiple programming models and platforms. In this paper, we present FUX-Sim, a novel X-ray simulation/reconstruction framework that was designed to be flexible and fast. Optimized implementation for different families of GPUs (CUDA and OpenCL) and multi-core CPUs was achieved thanks to a modularized approach based on a layered architecture and parallel implementation of the algorithms for both architectures. A detailed performance evaluation demonstrates that for different system configurations and hardware platforms, FUX-Sim maximizes performance with the CUDA programming model (5 times faster than other state-of-the-art implementations). Furthermore, the CPU and OpenCL programming models allow FUX-Sim to be executed over a wide range of hardware platforms. [ABSTRACT FROM AUTHOR]

Video cards have now outgrown their purpose of being only a simple tool for graphic display. With their high speed video memories, lots of maths units and parallelism, they can be very powerful accessories for general purpose computing tasks. Our selected platform for testing is the CUDA (Compute Unified Device Architecture), which offers us direct access to the virtual instruction set of the video card, and we are able to run our computations on dedicated computing kernels. The CUDA development kit comes with a useful toolbox and a wide range of GPU-based function libraries. In this parallel environment, we implemented a reliable method based on the Branch-andBound algorithm. This algorithm will give us the opportunity to use node level (also called low-level or type 1) parallelization, since we do not modify the searching trajectories; nor do we modify the dimensions of the Branchand-Bound tree [5]. For testing, we chose the circle covering problem. We then scaled the problem up to three dimensions, and ran tests with sphere covering problems as well. [ABSTRACT FROM AUTHOR]

We made use of a special algorithm for Compute Unified Device Architecture (CUDA) for NVIDIA graphics cards, a nonlinear conjugate-gradient method to minimize energy functional, and a Monte-Carlo technique to directly observe the forming of the ground state configuration for the 2D hard-core bosons with lowering the temperature and its evolution with deviation away from half filling. The novel technique allowed us to examine earlier implications and uncover novel features of the charge order-to-superfluid phase transition, in particular, look upon the nucleation of the odd domain structure, emergence of filamentary superfluidity nucleated at the antiphase domain walls of the charge ordered phase, and nucleation and evolution of different topological structures. [ABSTRACT FROM AUTHOR]

Real-time image processing is used in a wide variety of applications like those in medical care and industrial processes. This technique in medical care has the ability to display important patient information graphi graphically, which can supplement and help the treatment process. Medical decisions made based on real-time images are more accurate and reliable. According to the recent researches, graphic processing unit (GPU) programming is a useful method for improving the speed and quality of medical image processing and is one of the ways of real-time image processing. Edge detection is an early stage in most of the image processing methods for the extraction of features and object segments from a raw image. The Canny method, Sobel and Prewitt filters, and the Roberts' Cross technique are some examples of edge detection algorithms that are widely used in image processing and machine vision. In this work, these algorithms are implemented using the Compute Unified Device Architecture (CUDA), Open Source Computer Vision (OpenCV), and Matrix Laboratory (MATLAB) platforms. An existing parallel method for Canny approach has been modified further to run in a fully parallel manner. This has been achieved by replacing the breadth-first search procedure with a parallel method. These algorithms have been compared by testing them on a database of optical coherence tomography images. The comparison of results shows that the proposed implementation of the Canny method on GPU using the CUDA platform improves the speed of execution by 2-100× compared to the central processing unitbased implementation using the OpenCV and MATLAB platforms. [ABSTRACT FROM AUTHOR]

We present the technique and algorithm of numerical modeling of high-resolution spectroscopic equipment. The software is implemented in C++ using nVidia CUDA technology. We report the results of currently developedmodeling of new-generation echelle spectrographs. To validate the algorithms used to construct the mathematical model, we present the results of modeling of NES spectrograph of the 6-m telescope of the Special Astrophysical Observatory of the Russian Academy of Sciences. A comparison of simulated and real images of the spectra acquired with NES spectrograph demonstrates good agreement between the model constructed and experimental data. [ABSTRACT FROM AUTHOR]

We present a GPU accelerated CUDA-C implementation of the Barnes Hut (BH) tree code for calculating the gravitational potential on octree adaptive meshes. The tree code algorithm is implemented within the FLASH4 adaptive mesh refinement (AMR) code framework and therefore fully MPI parallel. We describe the algorithm and present test results that demonstrate its accuracy and performance in comparison to the algorithms available in the current FLASH4 version. We use a MacLaurin spheroid to test the accuracy of our new implementation and use spherical, collapsing cloud cores with effective AMR to carry out performance tests also in comparison with previous gravity solvers. Depending on the setup and the GPU/CPU ratio, we find a speedup for the gravity unit of at least a factor of 3 and up to 60 in comparison to the gravity solvers implemented in the FLASH4 code. We find an overall speedup factor for full simulations of at least factor 1.6 up to a factor of 10. [ABSTRACT FROM AUTHOR]

Two fundamental challenges of simulating biologically relevant systems are the rapid calculation of the energy of solvation and the trajectory length of a given simulation. The Generalized Born model with a Simple sWitching function (GBSW) addresses these issues by using an efficient approximation of Poisson- Boltzmann (PB) theory to calculate each solute atom's free energy of solvation, the gradient of this potential, and the subsequent forces of solvation without the need for explicit solvent molecules. This study presents a parallel refactoring of the original GBSW algorithm and its implementation on newly available, low cost graphics chips with thousands of processing cores. Depending on the system size and nonbonded force cutoffs, the new GBSW algorithm offers speed increases of between one and two orders of magnitude over previous implementations while maintaining similar levels of accuracy. We find that much of the algorithm scales linearly with an increase of system size, which makes this water model cost effective for solvating large systems. Additionally, we utilize our GPU-accelerated GBSW model to fold the model system chignolin, and in doing so we demonstrate that these speed enhancements now make accessible folding studies of peptides and potentially small proteins. [ABSTRACT FROM AUTHOR]

Algebraic reconstruction is more suitable for image reconstruction than analytic reconstruction as its high contrast and precision for incomplete projecting data. The calculation of projection coefficients is the key step of algebraic reconstruction, which has crucial effect on the reconstructed quality and speed. In this paper, an efficient method to calculate projection coefficients is proposed for cone-beam computed tomography (CBCT), referring to the structure characteristics of graphics processing unit (GPU) and intersection law of ray and grids. Firstly, an array is used to store the projection coefficient value under different intersections of grids and ray. Then, another array is designed to correct it in another direction. Finally, the projection coefficients can be solved by combining the two arrays. The proposed method has the advantage of less calculation amount and less program branches, and is suitable for parallel acceleration based on compute unified device architecture (CUDA). The calculated speed can be accelerated significantly. Experimental results show that the proposed algorithm is 10 times faster than Siddon algorithm, and almost 30 times faster in GPU. [ABSTRACT FROM AUTHOR]

Nowadays, GPU computations are playing significant role in supercomputing technologies. This work is a part of a project dealing with solving problems of modeling hydro- and aerodynamics where linear algebra operations are frequently used and occupy most of execution time. In despite of the fact that GPUs are traditionally used for solving high sized problems, in our project we need to solve many tasks of low sizes. Because of this, modern library's solutions such as cuBLAS (1) and cuSPARSE (2) are not suitable enough for that, so we have a task of implementation more efficient functions for concrete linear algebra operations taking into account its specialties. [ABSTRACT FROM AUTHOR]

Amplitude-preserved Q compensation prestack time migration (Q migration) is a new method that evolved from prestack Kirchhoff time migration (PKTM). Five algorithms are developed for Q migration on graphics processing units (GPUs). First, the principle of Q migration is briefly introduced. Second, one parallel strategy, namely, imaging domain parallel strategy, is proposed to accelerate Q migration on a single GPU by developing GPU algorithm. Results show that the imaging domain parallel strategy with the corresponding algorithm is superior to the CPU algorithm in several aspects, i.e., faster computing speed, shorter computing time, and higher computational efficiency. Third, based on the imaging domain parallel strategy, two division methods, namely, seismic data division method and velocity data division method, are presented to optimize the performance of Q migration on multi-GPUs and four algorithms are implemented by using Message Passing Interface (MPI)+Compute Unified Device Architecture (CUDA) and multi-thread+CUDA. An optimal algorithm is determined by comparing the performance of four algorithms. Results demonstrate that the optimal algorithm has the shortest computing time, which is 3.85 times shorter than that of a single GPU when four GPUs are all involved in computation and 300 times shorter than that of a 4-core central processing unit (CPU). Finally, a parallel computing framework on GPU cluster is established, which consists of imaging domain parallel strategy, seismic data division method and MPI+CUDA. This framework is suitable for all prestack time migration (PSTM) methods and has a short computing time and high speedup ratio on GPU cluster. [ABSTRACT FROM AUTHOR]

Surface roughness is an important factor in bare soil microwave radiation for the observation of the Earth. Correlation length and standard deviation of surface height are the two statistical parameters that describe surface roughness. However, when the number of data points is large, the calculation of surface roughness parameters becomes time-consuming. Therefore, it is desired to have a high-performance computing facility to execute this task. A Graphics Processing Unit (GPU) provides hundreds of computing cores along with a high memory bandwidth. To carry out a parallel implementation of the algorithms, Compute Unified Device Architecture (CUDA) provides researchers with an easy way to execute multiple threads in parallel on GPUs. In this paper, we propose a GPU-based parallel computing method for 2D surface roughness estimation. We use an NVIDIA GeForce GTX 590 graphics card to run the CUDA implementation. The experimental input data is collected by our in-house surface roughness tester which is designed based on the laser triangulation principle, giving sample data points of up to 52,040. According to the experimental results, the serial CPU version of the implementation takes 5422 s whereas our GPU implementation takes only 47 s, resulting a significant 115× speedup. [ABSTRACT FROM AUTHOR]

Given a sequence of n numbers, with at least one positive value, the maximum subsequence sum problem consists in finding the contiguous subsequence with the largest sum or score, among all derived subsequences of the original sequence. Several scientific applications have used algorithms that solve the maximum subsequence sum. Particularly in Computational Biology, these algorithms can help in the tasks of identification of transmembrane domains and in the search for GC -content regions, a required activity in the operation of pathogenicity islands location. The sequential algorithm that solves this problem has Otn) time complexity. In this work we present BSP/CGM parallel algorithms to solve the maximum subsequence sum problem and three related problems: the maximum longest subsequence sum, the maximum shortest subsequence sum and the number of disjoints subsequences of maximum sum. To the best of our knowledge there are no parallel BSP/CGM algorithms for these related problems. Our algorithms use p processors and require Otn/p) parallel time with a constant number of communication rounds for the algorithm of the maximum subsequence sum and Otlog p) communication rounds, with Otn/p) local computation per round, for the algorithm of the related problems. We implemented the algorithms on a cluster of computers using MPI and on a machine with GPU using CUDA, both with good speed-ups. [ABSTRACT FROM AUTHOR]

This paper studies the CUDA programming challenges with using multiple GPUs inside a single machine to carry out plane-by-plane updates in parallel 3D sweeping algorithms. In particular, care must be taken to mask the overhead of various data movements between the GPUs. Multiple OpenMP threads on the CPU side should be combined multiple CUDA streams per GPU to hide the data transfer cost related to the halo computation on each 2D plane. Moreover, the technique of peer-to-peer data motion can be used to reduce the impact of 3D volumetric data shuffles that have to be done between mandatory changes of the grid partitioning. We have investigated the performance improvement of 2- and 4-GPU implementations that are applicable to 3D anisotropic front propagation computations related to geological folding. In comparison with a straightforward multi-GPU implementation, the overall performance improvement due to masking of data movements on four GPUs of the Fermi architecture was 23%. The corresponding improvement obtained on four Kepler GPUs was 47%. [ABSTRACT FROM AUTHOR]

Copyright of Computer Measurement & Control is the property of Magazine Agency of Computer Measurement & Control and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Many scientific and technical problems with massive computation requirements could benefit from the graphics processing units (GPUs) using compute unified device architecture (CUDA). Gravitational search algorithm (GSA) is a population-based metaheuristic which can be effectively implemented on GPU to reduce the execution time. Nonetheless, the performance improvement depends strongly on the process used to adapt the algorithm into CUDA environment. In this paper, we discuss possible approaches to parallelize GSA on graphics hardware using CUDA. An in-depth study of the computation efficiency of parallel algorithms and capability to effectively exploit the architecture of GPU is performed. Additionally, a comparative study of parallel and sequential GSA was carried out on a set of standard benchmark optimization functions. The results show a significant speedup while maintaining results quality which re-emphasizes the utility of CUDA-based implementation for complex and computationally intensive parallel applications. [ABSTRACT FROM AUTHOR]

Nowadays, it is common to find problems that require recognizing objects in an image, tracking them along time, or recognizing a complete real-world scene. One of the most known and used algorithms to solve these problems is the Speeded Up Robust Features (SURF) algorithm. SURF is a fast and robust local, scale and rotation invariant, features detector. This means that it can be used for detecting and describing a set of points of interest (keypoints) from an image. Because of the importance of this algorithm and the rise of the parallelism-based technologies, in the last years, diverse parallel implementations of SURF have been proposed. These parallel implementations are based on very different techniques: Compute Unified Device Architecture, OpenMp, OpenCL, and so on. In conclusion, we think valuable a comparative study of all of them highlighting the advantages and disadvantages of each parallel implementation. To our best knowledge, this article is the first attempt to do this comparative study. In order to make this study, we have used the standard metrics and image collection in this field, as well as other important metrics in parallelism as speedup and efficiency. [ABSTRACT FROM AUTHOR]

Graphics processing units (GPUs) offer parallel computing power that usually requires a cluster of networked computers or a supercomputer to accomplish. While writing kernel code is fairly straightforward, achieving efficiency and performance requires very careful optimisation decisions and changes to the original serial algorithm. We introduce a parallel canonical ensemble Monte Carlo (MC) simulation that runs entirely on the GPU. In this paper, we describe two MC simulation codes of Lennard-Jones particles in the canonical ensemble, a single CPU core and a parallel GPU implementations. Using Compute Unified Device Architecture, the parallel implementation enables the simulation of systems containing over 200,000 particles in a reasonable amount of time, which allows researchers to obtain more accurate simulation results. A remapping algorithm is introduced to balance the load of the device resources and demonstrate by experimental results that the efficiency of this algorithm is bounded by available GPU resource. Our parallel implementation achieves an improvement of up to 15 times on a commodity GPU over our efficient single core implementation for a system consisting of 256k particles, with the speedup increasing with the problem size. Furthermore, we describe our methods and strategies for optimising our implementation in detail. [ABSTRACT FROM AUTHOR]

Algorithmic skeletons simplify software development: they abstract typical patterns of parallelism and provide their efficient implementations, allowing the application developer to focus on the structure of algorithms, rather than on implementation details. This becomes especially important for modern parallel systems with multiple graphics processing units (GPUs) whose programming is complex and error-prone, because state-of-the-art programming approaches like CUDA and OpenCL lack high-level abstractions. We define a new algorithmic skeleton for allpairs computations which occur in real-world applications, ranging from bioinformatics to physics. We develop the skeleton's generic parallel implementation for multi-GPU Systems in OpenCL. To enable the automatic use of the fast GPU memory, we identify and implement an optimized version of the allpairs skeleton with a customizing function that follows a certain memory access pattern. We use matrix multiplication as an application study for the allpairs skeleton and its two implementations and demonstrate that the skeleton greatly simplifies programming, saving up to 90 % of lines of code as compared to OpenCL. The performance of our optimized implementation is up to 6.8 times higher as compared with the generic implementation and is competitive to the performance of a manually written optimized OpenCL code. [ABSTRACT FROM AUTHOR]

In this paper, we propose an efficient acceleration method for the nonrigid registration of multimodal images that uses a graphics processing unit. The key contribution of our method is efficient utilization of on-chip memory for both normalized mutual information (NMI) computation and hierarchical B-spline deformation, which compose a well-known registration algorithm. We implement this registration algorithm as a compute unified device architecture program with an efficient parallel scheme and several optimization techniques such as hierarchical data organization, data reuse, and multiresolution representation. We experimentally evaluate our method with four clinical datasets consisting of up to 512 \times 512 \times 296 voxels. We find that exploitation of on-chip memory achieves a 12-fold increase in speed over an off-chip memory version and, therefore, it increases the efficiency of parallel execution from 4% to 46%. We also find that our method running on a GeForce GTX 580 card is approximately 14 times faster than a fully optimized CPU-based implementation running on four cores. Some multimodal registration results are also provided to understand the limitation of our method. We believe that our highly efficient method, which completes an alignment task within a few tens of seconds, will be useful to realize rapid nonrigid registration. [ABSTRACT FROM PUBLISHER]

SUMMARY With the emergence of general-purpose computation on graphics processing units, high-level approaches that hide the conceptual complexity of the low-level Compute Unified Device Architecture and Open Computing Language platforms are the subject of active research. However, these approaches may require a trade-off in terms of achieved performance and utilisation on graphics processing units hardware and may impose algorithmic limitations. In this paper, we present and systematically evaluate the parallel performance of three implementations of the brute force, all-pairs N-body algorithm with skeletal deployments based on the FastFlow, SkePU and Thrust frameworks. Our results indicate that the skeletal framework implementation achieves up to two orders of magnitude speed-up over serial version with a Tesla M2050 with lower implementation complexity than low-level Compute Unified Device Architecture programming. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Searching for similar 3D protein structures is one of the primary processes employed in the field of structural bioinformatics. However, the computational complexity of this process means that it is constantly necessary to search for new methods that can perform such a process faster and more efficiently. Finding molecular substructures that complex protein structures have in common is still a challenging task, especially when entire databases containing tens or even hundreds of thousands of protein structures must be scanned. Graphics processing units (GPUs) and general purpose graphics processing units (GPGPUs) can perform many time-consuming and computationally demanding processes much more quickly than a classical CPU can. In this paper, we describe the GPU-based implementation of the CASSERT algorithm for 3D protein structure similarity searching. This algorithm is based on the two-phase alignment of protein structures when matching fragments of the compared proteins. The GPU (GeForce GTX 560Ti: 384 cores, 2GB RAM) implementation of CASSERT ('GPU-CASSERT') parallelizes both alignment phases and yields an average 180-fold increase in speed over its CPU-based, single-core implementation on an Intel Xeon E5620 (2.40GHz, 4 cores). In this paper, we show that massive parallelization of the 3D structure similarity search process on many-core GPU devices can reduce the execution time of the process, allowing it to be performed in real time. GPU-CASSERT is available at: . [ABSTRACT FROM AUTHOR]

A novel algorithm is presented to compute the convex hull of a point set in ℝ³ using the graphics processing unit (GPU). By exploiting the relationship between the Voronoi diagram and the convex hull, the algorithm derives the approximation of the convex hull from the former. The other extreme vertices of the convex hull are then found by using a two-round checking in the digital and the continuous space successively. The algorithm does not need explicit locking or any other concurrency control mechanism, thus it can maximize the parallelism available on the modern GPU. The implementation using the CUDA programming model on NVIDIA GPUs is exact and efficient. The experiments show that it is up to an order of magnitude faster than other sequential convex hull implementations running on the CPU for inputs of millions of points. The works demonstrate that the GPU can be used to solve nontrivial computational geometry problems with significant performance benefit. [ABSTRACT FROM AUTHOR]

This paper presents a novel method for parallelizing the seeded region growing (SRG) algorithm using Compute Unified Device Architecture (CUDA) technology, with intention to overcome the theoretical weakness of SRG algorithm of its computation time being directly proportional to the size of a segmented region. The segmentation performance of the proposed CUDA-based SRG is compared with SRG implementations on single-core CPUs, quad-core CPUs, and shader language programming, using synthetic datasets and 20 body CT scans. Based on the experimental results, the CUDA-based SRG outperforms the other three implementations, advocating that it can substantially assist the segmentation during massive CT screening tests. [ABSTRACT FROM AUTHOR]

A modified parallel variable distribution (PVD) algorithm for solving large-scale constrained optimization problems is developed, which modifies quadratic subproblem QP1 at each iteration instead of the QP01 of the SQP-type PVD algorithm proposed by C. A. Sagastiz'abal and M. V. Solodov in 2002.The algorithm can circumvent the difficulties associated with the possible inconsistency of QP01 subproblem of the original SQP method. Moreover, we introduce a nonmonotone technique instead of the penalty function to carry out the line search procedure with more flexibly. Under appropriate conditions, the global convergence of the method is established. In the final part, parallel numerical experiments are implemented on CUDA based on GPU (Graphics Processing unit). [ABSTRACT FROM AUTHOR]