OpenCL Research Articles

Adaptation and optimization of basic operations for an unstructured mesh CFD algorithm for computation on massively parallel accelerators

The design of efficient algorithms for large-scale gas dynamics computations with hybrid (heterogeneous) computing systems whose high performance relies on massively parallel accelerators is addressed. A high-order accurate finite volume algorithm with polynomial reconstruction on unstructured hybrid meshes is used to compute compressible gas flows in domains of complex geometry. The basic operations of the algorithm are implemented in detail for massively parallel accelerators, including AMD and NVIDIA graphics processing units (GPUs). Major optimization approaches and a computation transfer technique are covered. The underlying programming tool is the Open Computing Language (OpenCL) standard, which performs on accelerators of various architectures, both existing and emerging.

N‐body computations using skeletal frameworks on multicore CPU/graphics processing unit architectures: an empirical performance evaluation

SUMMARYWith 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.

Accelerated implementation of level set based segmentation

An Open Computing Language implementation of a level set solver for 2D and 3D image segmentation tasks is presented. An adaptive time stepping algorithm is implemented using an optimised parallel reduction kernel to compensate for a loss of algorithmic parallelisation. For a 2D data set (256x256) the execution is accelerated by a factor of 20 in the adaptive case and 100 in the non-adaptive case compared to a CPU implementation, facilitating real time interactive parameter tuning. For a 3D data set (384x397x41) the acceleration factors are 200 and 270 for the adaptive and non-adaptive cases, respectively. Though a single iteration of the adaptive method is slower compared to the non-adaptive scheme, it automatically enforces the Courant--Friedrichs--Lewy condition and reduces the number of user-tuned parameters while safely allowing larger time steps. Open Computing Language optimisations and techniques are discussed. References D. Adalsteinsson and J. A. Sethian. The fast construction of extension velocities in level set methods J. Comp. Phys. 148(1):2--22, 1999. doi:10.1006/jcph.1998.6090 J. F. Aujol and G. Aubert. Signed distance functions and viscosity solutions of discontinuous Hamilton--Jacobi equations Research Report, Inria, France 4507, 2002. K. N. Chaudhury and K. R.Ramakrishnan. Stability and convergence of the level set method in computer vision Patt. Rec. Lett. 28:884--893, 2007. doi:10.1016/j.patrec.2006.12.003 S. De Weerdt. Animal models: Towards a myeloma mouse Nature 480(7377):S38--S39, 2011. doi:10.1038/480S38a P. F. Felzenszwalb and D. P. Huttenlocher. Distance transforms of sampled functions Cornell Comp. Inf. Sci. TR2004-1963, 2004. J. Gomes and O. Faugeras. Reconciling distance functions and level sets J. Vis. Comm. Image Rep. 11:209--223, 2000. doi:10.1006/jvci.1999.0439 Khronos Group. The open standard for parallel programming of heterogeneous systems. http://www.khronos.org/opencl/, 17/10/2012. M. Harris et al. Optimizing parallel reduction in CUDA Proc. of ACM SIGMOD 21(13):104--110, 2007. D. Lee, I. Dinov, B. Dong, B. Gutman, I. Yanovsky and A. W. Toga. CUDA optimization strategies for compute---and memory---bound neuroimaging algorithms Comp. Meth. Prog. Biomed. 106:175--187, 2012. doi:10.1016/j.cmpb.2010.10.013 C. Li, C. Xu, C. Gui and M. D. Fox. Level set evolution without re-initialization: a new variational formulation IEEE Conf. Comp Vision and Pattern Recognition 1:430--436, 2005. doi:10.1109/CVPR.2005.213 A. E. Lefohn, J. M. Kniss, C. D. Hansen and R. T. Whitaker. A streaming narrow-band algorithm: interactive computation and visualization of level sets IEEE Trans. Vis Comp Graphics 10(4):422--433, 2004. doi:10.1109/TVCG.2004.2 R. Malladi, J. A. Sethian and B. C. Vermuri. Shape modeling with front propagation: a level set approach IEEE Trans. Patt. Analy. Mach. Int. 17(2):158--175, 1995. doi:10.1109/34.368173 S. Osher and N. Paragios. Geometric level set methods in imaging, vision, and graphics. Springer 2003. S. Osher and J. A. Sethian. Fronts propagating with curvature-dependent speed: Algorithms based on Hamilton--Jacobi formulations J. Comp. Phys. 79:12--49, 1988. doi:10.1016/0021-9991(88)90002-2 J. D. Owens, D. Luebke, N. Govindaraju, M. Harris, J. Kruger, A. E. Lefohn and T. J. Purcell. A survey of general-purpose computation on graphics hardware Computer Graphics Forum 26(1):80--113, 2007. doi:10.1111/j.1467-8659.2007.01012.x J. A. Sethian. Level Set Methods and Fast Marching Methods Evolving Interfaces in Computational Geometry, Fluid Mechanics, Computer Vision, and Materials Science. Cambridge Monographs on Applied and Computational Mathematics (3), $2$nd Ed, 1999. J. Strain. Semi-Lagrangian methods for level set equations J. Comp. Phys 151(2):498--533, 1999. doi:10.1006/jcph.1999.6194 K. R. Varshney and A. S. Willsky. Classification using geometric level sets J. Machine Learning Research 11:491--516, 2010. http://dl.acm.org/citation.cfm?id=1756006.1756020

Gnss Signal Processing in Gpu

ABSTRACT Signal processing of the global navigation satellite systems (GNSS) is a computationally demanding task due to the wide bandwidth of the signals and their complicated modulation schemes. The classical GNSS receivers therefore utilize tailored digital signal processors (DSP) not being flexible in nature. Fortunately, the up-to-date parallel processors or graphical processing units (GPUs) dispose sufficient computational power for processing of not only relatively narrow band GPS L1 C/A signal but also the modernized GPS, GLONASS, Galileo and COMPASS signals. The performance improvement of the modern processors is based on the constantly increasing number of cores. This trend is evident not only from the development of the central processing units (CPUs), but also from the development of GPUs that are nowadays equipped with up to several hundreds of cores optimized for video signals. GPUs include special vector instructions that support implementation of massive parallelism. The new GPUs, named as general-purpose computation on graphics processing units (GPGPU), are able to process both graphic and general data, thus making the GNSS signal processing possible. Application programming interfaces (APIs) supporting GPU parallel processing have been developed and standardized. The most general one, Open Computing Language (Open CL), is now supported by most of the GPU vendors. Next, Compute Unified Device Architecture (CUDA) language was developed for NVidia graphic cards. The CUDA language features optimized signal processing libraries including efficient implementation of the fast Fourier transform (FFT). In this paper, we study the applicability of the GPU approach in GNSS signal acquisition. Two common parallel DSP methods, parallel code space search (PCSS) and double-block zero padding (DBZP), have been investigated. Implementations in the C language for CPU and the CUDA language for GPU are discussed and compared with respect to the acquisition time. It is shown that for signals with long ranging codes (with 10230 number of chips - Galileo E5, GPS L5 etc.). Paper presented at the "European Navigation Conference 2012", held in Gdansk, Poland

SU‐E‐J‐02: GPU‐Accelerated Polyenergetic DRR Generation Based On Data Parallelism and Task Parallelism with a Dispatcher Using OpenCL: Effect of the Numbers of Tasks and Energies

Purpose: To improve the performance of parallel processing of multi‐energetic digitally reconstructed radiograph (DRR) generation using a task‐overlap strategy on heterogeneous platforms. Methods: A segmented 512 ×512 ×223 head‐neck phantom was used to generate 512 ×512 polyenergetic DRR based on Mohan4 and Mohan6 spectrums containing 16 and 24 energy bins, respectively. The DRR formation for each energy bin comprises three steps: (1) phantom conversion, (2) line integral and (3) exponential and weighting of projection. The parallel computing ecosystem consisted of one 8‐core CPU and one general purpose graphics processing unit (GPGPU). We used Open Computing Language (OpenCL) to decompose the low‐degree parallel and serial workloads into multiple tasks on CPU using task parallelism, and partition the high‐degree parallel workloads on GPGPU using data parallelism. Two sequential task partitions for the first DRR formation were tested: (A) Step1 as Task1 on CPU, Step2 as Task2 on GPU and Step3 as Task3 on CPU; and (B) Step1 as Task1 on CPU and Step2 and Step3 as Task2 on GPU. The subsequent DRR generation does not need Step 1 so Step1 as Task1 was excluded in each partition. A task‐overlap method driven by a dispatcher was also implemented using regular single‐threaded host program to further improve the performance. Results: For the first DRR formation and Partition A, the task‐overlap strategy was 5.8 and 6.5 times faster than sequential method for 16‐energy‐bin Mohan4 and 24‐energy‐bin Mohan6 spectrums, respectively. For Partition B, the speedup of the task‐overlap strategy was 5.2 and 5.5 times for Mohan4 and Mohan6 spectrums, respectively. For the following DRR formation, the speedups were 1.16 and 1.165 times in two‐task scenario for Mohan4 and Mohan6 spectrums. Conclusion: The task‐overlap strategy significantly improves the performance for parallel processing of multi‐energetic DRR generation. The parallelism is increased when more energies and tasks are driven by the dispatcher.

Simulation of sonic waves along a borehole in a heterogeneous formation: Accelerating 2.5-D finite differences using [Py]OpenCL

This paper presents an implementation of a 2.5-D finite-difference (FD) code to model acoustic full waveform monopole logging in cylindrical coordinates accelerated by using the new parallel computing devices (PCDs). For that purpose we use the industry open standard Open Computing Language (OpenCL) and an open-source toolkit called PyOpenCL. The advantage of OpenCL over similar languages is that it allows one to program a CPU (central processing unit) a GPU (graphics processing unit), or multiple GPUs and their interaction among them and with the CPU, or host device. We describe the code and give a performance test in terms of speed using six different computing devices under different operating systems. A maximum speedup factor over 34.2, using the GPU is attained when compared with the execution of the same program in parallel using a CPU quad-core. Furthermore, the results obtained with the finite differences are validated using the discrete wavenumber method (DWN) achieving a good agreement. To provide the Geoscience and the Petroleum Science communities with an open tool for numerical simulation of full waveform sonic logs that runs on the PCDs, the full implementation of the 2.5-D finite difference with PyOpenCL is included.

Olanzapine treatment of adolescent rats causes enduring specific memory impairments and alters cortical development and function.

Antipsychotic drugs are increasingly used in children and adolescents to treat a variety of psychiatric disorders. However, little is known about the long-term effects of early life antipsychotic drug treatment. Most antipsychotic drugs are potent antagonists or partial agonists of dopamine D2 receptors; atypical antipsychotic drugs also antagonize type 2A serotonin receptors. Dopamine and serotonin regulate many neurodevelopmental processes. Thus, early life antipsychotic drug treatment can, potentially, perturb these processes, causing long-term behavioral- and neurobiological impairments. Here, we treated adolescent, male rats with olanzapine on post-natal days 28–49. As adults, they exhibited impaired working memory, but normal spatial memory, as compared to vehicle-treated control rats. They also showed a deficit in extinction of fear conditioning. Measures of motor activity and skill, habituation to an open field, and affect were normal. In the orbital- and medial prefrontal cortices, parietal cortex, nucleus accumbens core and dentate gyrus, adolescent olanzapine treatment altered the developmental dynamics and mature values of dendritic spine density in a region-specific manner. Measures of motor activity and skill, habituation to an open field, and affect were normal. In the orbital- and medial prefrontal cortices, D1 binding was reduced and binding of GABAA receptors with open Cl− channels was increased. In medial prefrontal cortex, D2 binding was also increased. The persistence of these changes underscores the importance of improved understanding of the enduring sequelae of pediatric APD treatment as a basis for weighing the benefits and risks of adolescent antipsychotic drug therapy, especially prophylactic treatment in high risk, asymptomatic patients. The long-term changes in neurotransmitter receptor binding and neural circuitry induced by adolescent APD treatment may also cause enduring changes in behavioral- and neurobiological responses to other therapeutic- or illicit psychotropic drugs.

Parallel unsupervised Synthetic Aperture Radar image change detection on a graphics processing unit

Change detection is now routinely applied in many application domains, such as damage assessment, environmental monitoring and agricultural surveys. As the number of remote sensing images and the complexity of algorithms rise, the demand for processing power is increasing. In this paper, we propose PLog-FLICM , a parallel algorithm for change detection, which includes two steps: (1) generate the difference image based on the log-ratio operator; (2) detect changes in the difference image by using a modified fuzzy c-means clustering algorithm. PLog-FLICM is implemented on AMD Accelerated Parallel Processing SDK based on Open Computing Language. The parallel characteristics and implementation details of the proposed PLog-FLICM algorithm are presented. Experiments on several Synthetic Aperture Radar images demonstrate that the proposed algorithm outperforms other algorithms, and the designed parallel algorithm can greatly reduce the computational time of the change detection algorithm. Furthermore, we investigate the performance portability of PLog-FLICM in the different central processing unit and graphics processing unit platforms. Experimental results show that they have also achieved good parallel performance.

Computing OpenSURF on OpenCL and General Purpose GPU

Speeded-Up Robust Feature (SURF) algorithm is widely used for image feature detecting and matching in computer vision area. Open Computing Language (OpenCL) is a framework for writing programs that execute across heterogeneous platforms consisting of CPUs, GPUs, and other processors. This paper introduces how to implement an open-sourced SURF program, namely OpenSURF, on general purpose GPU by OpenCL, and discusses the optimizations in terms of the thread architectures and memory models in detail. Our final OpenCL implementation of OpenSURF is on average 37% and 64% faster than the OpenCV SURF v2.4.5 CUDA implementation on NVidia's GTX660 and GTX460SE GPUs, repectively. Our OpenCL program achieved real-time performance (>25 Frames Per Second) for almost all the input images with different sizes from 320*240 to 1024*768 on NVidia's GTX660 GPU, NVidia's GTX460SE GPU and AMD's Radeon HD 6850 GPU. Our OpenCL approach on NVidia's GTX660 GPU is more than 22.8 times faster than its original CPU version on Intel's Dual-Core E5400 2.7G on average.

An OpenCL Framework for Fuzzy Associative Classification and its Application to Disease Prediction

Recently, the broad availability of online and soft real-time data has been attracting corporations and researchers towards data analytics. Though newer and faster algorithms are developed, as the available dataset sizes increase exponentially, computational processing has been falling behind. The trend on computational resources is mostly towards multiple cores and parallel processing, while the CPU clock speed improvements are slowing down. An important computational resource is the Graphics Processing Unit with multiple-cores, surpassing 2,000 processing elements in one processing unit and operating at almost 5 teraflops capability, such as the recently introduced GeForce GTX Titan.In this study, an Open Computing Language parallel processing framework for fuzzy associative classification is described. The hybrid CPU-GPU implementation is developed and employed for prediction of infectious disease outbreaks, specifically Influenza, using environmental and disease data readily available online. A comparison of the implemented performance with respect to another in-house developed Fuzzy Association Rule Mining operator, FARM, and the performances on four distinct parallel processing environments, specifically a four processor, 64 threads capable, Opteron server; a two processor, 24 threads capable, Xeon server; a GeForce GTX 680 GPU card; and a Radeon HD 7950 GPU card, is presented. The advantages and disadvantages of the OpenCL implementation on parallel processors are discussed.

Enabling OpenCL support for GPGPU in Kernel‐based Virtual Machine

SUMMARYThe importance of heterogeneous multicore programming is increasing, and Open Computing Language (OpenCL) is an open industrial standard for parallel programming that provides a uniform programming model for programmers to write efficient, portable code for heterogeneous computing devices. However, OpenCL is not supported in the system virtualization environments that are often used to improve resource utilization. In this paper, we propose an OpenCL virtualization framework based on Kernel‐based Virtual Machine with API remoting to enable multiplexing of multiple guest virtual machines (guest VMs) over the underlying OpenCL resources. The framework comprises three major components: (i) an OpenCL library implementation in guest VMs for packing/unpacking OpenCL requests/responses; (ii) a virtual device, called virtio‐CL, that is responsible for the communication between guest VMs and the hypervisor (also called the VM monitor); and (iii) a thread, called CL thread, that is used for the OpenCL API invocation. Although the overhead of the proposed virtualization framework is directly affected by the amount of data to be transferred between the OpenCL host and devices because of the primitive nature of API remoting, experiments demonstrated that our virtualization framework has a small virtualization overhead (mean of 6.8%) for six common device‐intensive OpenCL programs and performs well when the number of guest VMs involved in the system increases. These results indirectly infer that the framework allows for effective resource utilization of OpenCL devices.Copyright © 2012 John Wiley & Sons, Ltd.

OpenCL‐based acceleration of the FDTD method in computational electromagnetics

SUMMARYThe evolution of processors into multi‐core architectures has led to the acceleration of scientific codes using numerous highly specialized processors, that is, multi‐core central processing units (CPUs), graphics processing units (GPUs) and also devices that merge both technologies in a single‐die chip. Development of parallel codes that are both scalable and portable between the processor architectures is challenging. To overcome this limitation, we investigated the acceleration of the finite‐difference time‐domain (FDTD) method in computational electromagnetics on modern computing architectures, that is, multi‐core CPUs and GPUs, through the use of Open Computing Language (OpenCL). Further extension of the OpenCL parallel programing model with the Message Passing Interface allows for the targeting of standard distributed memory computer clusters as well as clusters accelerated by GPUs. Portability between hardware manufactured by different vendors and highly specialized and parallel computing architectures is the main advantage of the developed FDTD solvers. The codes were coupled with a commercial simulation platform to evaluate the performance of the solvers in real‐world industrial scenarios. Although the portability resulted in a slightly reduced performance (10–35%) of the OpenCL‐accelerated FDTD simulations compared with the native Compute Unified Device Architecture or Open Multiprocessing implementations, the obtained benchmarking results of the OpenCL FDTD solvers on distributed memory systems show that the communication overhead can be hidden by computations for sufficiently large simulation domains with a scaling efficiency higher than 90%. Copyright © 2012 John Wiley & Sons, Ltd.

Software Performance Analysis with Parallel Programming Approaches

The term software performance engineering (SPE) is a systematic and quantitative approach for constructing software systems to meet the performance objectives such as response time, throughput, scalability and resource utilization. Optimization is major concern in achieving performance parameters. Optimization is performed during run-time, or in the design phase. This paper proposes the coding practices in Open Multi Processing (OpenMP) and Open Computing Language (OpenCL) that outperforms the conventional algorithms for searching, matrix multiplication and routing tasks in terms of response time.

Portable LDPC Decoding on Multicores Using OpenCL [Applications Corner

This article proposes to address, in a tutorial style, the benefits of using Open Computing Language [1] (OpenCL) as a quick way to allow programmers to express and exploit parallelism in signal processing algorithms, such as those used in error-correcting code systems. In particular, we will show how multiplatform kernels can be developed straightforwardly using OpenCL to perform computationally intensive low-density parity-check (LDPC) decoding, targeting them to run on a large set of worldwide disseminated multicore architectures, such as x86 general purpose multicore central processing units (CPUs) and graphics processing units (GPUs). Moreover, devices with different architectures can be orchestrated to cooperatively execute these signal processing applications programmed in OpenCL. Experimental evaluation of the parallel kernels programmed with the OpenCL framework shows that high-performance can be achieved for distinct parallel computing architectures with low programming effort.

An OpenCL implementation for the solution of the time-dependent Schrödinger equation on GPUs and CPUs

Open Computing Language (OpenCL) is a parallel processing language that is ideally suited for running parallel algorithms on Graphical Processing Units (GPUs). In the present work we report on the development of a generic parallel single-GPU code for the numerical solution of a system of first-order ordinary differential equations (ODEs) based on the OpenCL model. We have applied the code in the case of the Time-Dependent Schrödinger Equation of atomic hydrogen in a strong laser field and studied its performance on NVIDIA and AMD GPUs against the serial performance on a CPU. We found excellent scalability and a significant speedup of the GPU over the CPU device. The speedup in the benchmark tended towards a value of about 40 with significant speedups expected against multi-core CPUs. Furthermore, though we do not present the detailed benchmarks here, we also have achieved speedup values of around 75 by performing a slight optimization of the described algorithm.

General‐purpose computation on GPUs for high performance cloud computing

SUMMARYCloud computing is offering new approaches for High Performance Computing (HPC) as it provides dynamically scalable resources as a service over the Internet. In addition, General‐Purpose computation on Graphical Processing Units (GPGPU) has gained much attention from scientific computing in multiple domains, thus becoming an important programming model in HPC. Compute Unified Device Architecture (CUDA) has been established as a popular programming model for GPGPUs, removing the need for using the graphics APIs for computing applications. Open Computing Language (OpenCL) is an emerging alternative not only for GPGPU but also for any parallel architecture. GPU clusters, usually programmed with a hybrid parallel paradigm mixing Message Passing Interface (MPI) with CUDA/OpenCL, are currently gaining high popularity. Therefore, cloud providers are deploying clusters with multiple GPUs per node and high‐speed network interconnects in order to make them a feasible option for HPC as a Service (HPCaaS). This paper evaluates GPGPU for high performance cloud computing on a public cloud computing infrastructure, Amazon EC2 Cluster GPU Instances (CGI), equipped with NVIDIA Tesla GPUs and a 10 Gigabit Ethernet network. The analysis of the results, obtained using up to 64 GPUs and 256‐processor cores, has shown that GPGPU is a viable option for high performance cloud computing despite the significant impact that virtualized environments still have on network overhead, which still hampers the adoption of GPGPU communication‐intensive applications. Copyright © 2012 John Wiley & Sons, Ltd.

A high performance parallel DCT with OpenCL on heterogeneous computing environment

A noteworthy thing in desktop PCs is that they can provide a great opportunity to increase the performance of processing multimedia data by exploiting task- and data-parallelism with multi-core CPU and many-core GPU. This paper presents a high performance parallel implementation of 2D DCT on this heterogeneous computing environment. For this purpose, Intel TBB (threading building blocks) and OpenCL (Open Compute Language) are utilized for task- and data-parallelism, respectively. The simulation result shows that the parallel DCT implementations far the serial ones in processing speed. Especially, OpenCL implementation shows a linear speedup, a typical SIMD characteristic as the increase of 2D data sets.

Implementation of dyadic correlation and autocorrelation on graphics processors

The convolution and related operators of correlation and autocorrelation are essential and powerful mathematical tools in machine learning, signal processing, systems theory, and related areas. In particular, representation and handling of systems with binary encoded input and output signals requires intensive computation of the correlation and autocorrelation functions which are defined on the finite dyadic groups as the underlying algebraic structure. This paper presents methods for computing the dyadic correlation and autocorrelation functions on graphics processing units (GPUs). The proposed algorithms are based on the convolution and the Wiener–Khinchin theorems and implemented using the Open Computing Language (OpenCL). We address several key issues in developing an efficient mapping of the computations to the GPU architecture. The experimental results confirm that the application of the proposed method leads to significant computational speedups over traditional C/C++ implementations processed on central processing units (CPUs).

Productivity of GPUs under different programming paradigms

SUMMARYGraphical processing units have been gaining rising attention because of their high performance processing capabilities for many scientific and engineering applications. However, programming such highly parallel devices requires adequate programming tools. Many such programming tools have emerged and hold the promise for high levels of performance. Some of such tools may require specialized parallel programming skills, while others attempt to target the domain scientist. The costs versus the benefits out of such tools are often unclear. In this work we examine the use of several of these programming tools such as Compute Unified Device Architecture, Open Compute Language, Portland Group Inc., and MATLAB in developing kernels from the (NAS) NASA Advanced Supercomputing parallel benchmarking suite. The resulting performance as well as the needed programmers' efforts were quantified and used to characterize the productivity of graphical processing units using these different programming paradigms. Copyright © 2011 John Wiley & Sons, Ltd.

Three‐dimensional thinning algorithms on graphics processing units and multicore CPUs

SUMMARYThree‐dimensional curve skeletons are a very compact representation of three‐dimensional objects with many uses and applications in fields such as computer graphics, computer vision, and medical imaging. An important problem is that the calculation of the skeleton is a very time‐consuming process. Thinning is a widely used technique for calculating the curve skeleton because of the properties it ensures and the ease of implementation. In this paper, we present parallel versions of a thinning algorithm for efficient implementation in both graphics processing units and multicore CPUs. The parallel programming models used in our implementations are Compute Unified Device Architecture (CUDA) and Open Computing Language (OpenCL). The speedup achieved with the optimized parallel algorithms for the graphics processing unit achieves 106.24x against the CPU single‐process version and more than 19x over the CPU multithreaded version. Copyright © 2011 John Wiley & Sons, Ltd.