Architecture of Computing Systems (Lecture Notes in Computer ...

Optimizing Stencil Application on Multi-thread GPU Architecture 235
architectures provide easier programmability and increased generality, abstracting
away trivial graphics programming details, i.e., Brook+ [1] and CUDA [2].
Therefore, people begin to harness the tremendous processing power of GPUs
for non-graphics applications. Now GPU computation has been widely adopted
in the field of scientific computing, such as biomedicine, computational fluid
dynamics simulation, and molecular dynamics simulation [3].
GPUs were originally developed for graphics processing, i.e., media applications,
which have less data reuse and lay more emphasis on real time. However,
in scientific applications, there can be rich data reuse while the data access patterns
may not be as uniform as media applications. There is much space left for
programmers to optimize the GPU codes to exploit more data reuse and hide
long memory access latencies. Therefore, besides choosing a good CPU-to-GPU
application mapping, we should also try to optimize the GPU codes according to
the architecture of the GPU and the mechanisms provided by the programming
language.
In this paper, we have implemented and optimized Mgrid, a multi-grid application
commonly used to solve partial differential equations (PDEs) taken from
Spec2000, on an AMD GPU platform. At the heart of Mgrid are stencil (nearestneighbor)
computations in each 27-point 3D cube. Stencil computations feature
abundant parallelism and low computational intensity which offers great opportunity
for optimization in temporal and spatial locality, making them effective
architectural evaluation benchmarks [4]. To optimize the naive GPU code, we
have proposed four optimization strategies:
(a) Improve thread utilization. Using vector types and multiple output streams
provided by the Brook+ programming language, we exploit data reuse within
each thread and parallelism among threads to achieve better thread utilization.
(b) Stream reorganization. We reorganize the 3D data stream into the 2D
stream in the block manner to catch more data locality in the GPU cache. Stencil
computations of Mgrid refer data on three consecutive planes when calculating
a grid point. Through stream reorganization, we exploit the data reuse within
each plane.
(c) Branch elimination. We propose branch elimination to reduce the performance
loss caused by branch divergences in the Interp kernel. Though changing
the control dependence to data dependence, all of the eight branches in the
kernel are eliminated, thus improving the kernel performance significantly.
(d) CPU-GPU workload distribution. To make full use of the CPU-GPU heterogeneous
system, we should reasonably distribute the workload between the
two computing resource according to the work nature, problem size and communication
overhead.
Note that though our optimizations are developed for Mgrid, they can be applied
to any stencil-like computations, making our optimization approaches general
for developing GPU applications. In our work, all the experiments are done
under double-precision floating-point implementation. The experimental results
show that the optimized GPU implementation of Mgrid gains 2.38x speedup