CPU Counterpart Research Articles

Tabu Search with two approaches to parallel flowshop evaluation on CUDA platform

The introduction of NVidia’s powerful Tesla GPU hardware and Compute Unified Device Architecture (CUDA) platform enable many-core parallel programming. As a result, existing algorithms implemented on a GPU can run many times faster than on modern CPUs. Relatively little research has been done so far on GPU implementations of discrete optimisation algorithms. In this paper, two approaches to parallel GPU evaluation of the Permutation Flowshop Scheduling Problem, with makespan and total flowtime criteria, are proposed. These methods can be employed in most population-based algorithms, e.g. genetic algorithms, Ant Colony Optimisation, Particle Swarm Optimisation, and Tabu Search. Extensive computational experiments, on Tabu Search for Flowshop with both criteria, followed by statistical analysis, confirm great computational capabilities of GPU hardware. A GPU implementation of Tabu Search runs up to 89 times faster than its CPU counterpart.

GPU-Assisted Computation of Centroidal Voronoi Tessellation

Centroidal Voronoi tessellations (CVT) are widely used in computational science and engineering. The most commonly used method is Lloyd's method, and recently the L-BFGS method is shown to be faster than Lloyd's method for computing the CVT. However, these methods run on the CPU and are still too slow for many practical applications. We present techniques to implement these methods on the GPU for computing the CVT on 2D planes and on surfaces, and demonstrate significant speedup of these GPU-based methods over their CPU counterparts. For CVT computation on a surface, we use a geometry image stored in the GPU to represent the surface for computing the Voronoi diagram on it. In our implementation a new technique is proposed for parallel regional reduction on the GPU for evaluating integrals over Voronoi cells.

Performance Evaluation and Optimization on GPU

GPU provides higher peak performance with hundreds of cores than CPU counterpart. However, it is a big challenge to take full advantage of their computing power. In order to understand performance bottlenecks of applications on many-core GPU and then optimize parallel programs on GPU architectures, we propose a performance evaluating model based on memory wall and then classify applications into AbM (Application bound-in Memory) and AbC (Application bound-in Computing). Furthermore, we optimize kernels characterized with low memory bandwidth including matrix multiplication and FFT (Fast Fourier Transform) by employing texture cache on NVIDIA GTX280 using CUDA (Compute Unified Device Architecture). Experimental results show that texture cache is helpful for AbM with better data locality, so it is critical to utilize GPU memory hierarchy efficiently for performance improvement.

2P1-D20 GPU accelerating visual tracking

This paper describes our novel work of using graphic processing unit (GPU) on visual tracking. In this paper, we present our novel implementations of GPU based Efficient Second-order Minimization (GPU-ESM) algorithm. By utilizing the tremendous parallel processing capability of modern graphic hardware, we obtain significant processing acceleration from GPU over its CPU counterpart. Currently our GPU-ESM algorithm can process tracking area of 360×360 pixels at 145 fps on NVIDIA GTX295 board and Intel Core i7 920, which is approximately 30 times faster than CPU implementation. This speedup substantially improves the realtime performance of our system. In this paper, translation details of ESM algorithm from CPU to GPU implementation and novel optimizations are presented. The effectiveness of our GPU-ESM tracking algorithm is validated with experimental data.

Concurrent number cruncher: a GPU implementation of a general sparse linear solver

A wide class of numerical methods needs to solve a linear system, where the matrix pattern of non-zero coefficients can be arbitrary. These problems can greatly benefit from highly multithreaded computational power and large memory bandwidth available on graphics processor units (GPUs), especially since dedicated general purpose APIs such as close-to-metal (CTM) (AMD–ATI) and compute unified device architecture (CUDA) (NVIDIA) have appeared. CUDA even provides a BLAS implementation, but only for dense matrices (CuBLAS). Other existing linear solvers for the GPU are also limited by their internal matrix representation. This paper describes how to combine recent GPU programming techniques and new GPU dedicated APIs with high performance computing strategies (namely block compressed row storage (BCRS), register blocking and vectorization), to implement a sparse general-purpose linear solver. Our implementation of the Jacobi-preconditioned conjugate gradient algorithm outperforms by up to a factor of 6.0 × leading-edge CPU counterparts, making it attractive for applications which are content with single precision.

Stackless KD‐Tree Traversal for High Performance GPU Ray Tracing

Abstract Significant advances have been achieved for realtime ray tracing recently, but realtime performance for complex scenes still requires large computational resources not yet available from the CPUs in standard PCs. Incidentally, most of these PCs also contain modern GPUs that do offer much larger raw compute power. However, limitations in the programming and memory model have so far kept the performance of GPU ray tracers well below that of their CPU counterparts. In this paper we present a novel packet ray traversal implementation that completely eliminates the need for maintaining a stack during kd‐tree traversal and that reduces the number of traversal steps per ray. While CPUs benefit moderately from the stackless approach, it improves GPU performance significantly. We achieve a peak performance of over 16 million rays per second for reasonably complex scenes, including complex shading and secondary rays. Several examples show that with this new technique GPUs can actually outperform equivalent CPU based ray tracers.

Towards multi-GPU support for visualization

At the Institute for Ultrascale Visualization, we are tackling the broad problem of building visualization solutions for the petascale age and beyond. As computing transitions into a new age where scalar solutions no longer improve in performance, and parallel solutions are the vehicle for future performance gains, one key challenge in our effort is to harness the power of emerging commodity data-parallel processors.One of the most promising new parallel processors is the graphics processing unit (GPU), whose recent gains in programmability and enormous arithmetic and memory bandwidth substantially outpace its CPU counterpart. The GPU's performance and programmability, together with its graphics capabilities, make it particularly well suited for demanding next-generation visualization applications.We face a number of important challenges in making the GPU a first-class citizen for computation in these visualization applications. In this paper, we describe how we are addressing these challenges: mapping GPUs to general-purpose tasks, fundamental algorithms for GPUs, visualization applications that use the GPU for general-purpose computation, and extending our applications to support multiple GPUs. We also describe trends in upcoming GPU designs and how they will impact our research moving forward.

Brook for GPUs

In this paper, we present Brook for GPUs, a system for general-purpose computation on programmable graphics hardware. Brook extends C to include simple data-parallel constructs, enabling the use of the GPU as a streaming co-processor. We present a compiler and runtime system that abstracts and virtualizes many aspects of graphics hardware. In addition, we present an analysis of the effectiveness of the GPU as a compute engine compared to the CPU, to determine when the GPU can outperform the CPU for a particular algorithm. We evaluate our system with five applications, the SAXPY and SGEMV BLAS operators, image segmentation, FFT, and ray tracing. For these applications, we demonstrate that our Brook implementations perform comparably to hand-written GPU code and up to seven times faster than their CPU counterparts.