The paper describes features of the multithreaded algorithms implementation on contemporary CPU and GPU. The features of access of a graphics processing unit (GPU) memory are reviewed. The bottlenecks have been identified, in which there is a loss of speed in image processing. Recommendations are made for optimization of algorithms for processing image of various size. Examples of implementation of the algorithms are given in the software and hardware architecture CUDA, which is well suited for a wide range of applications with high parallelism.
Differences between the CPU and GPU Any program running on CPU uses the operating memory, processor cache, and processor itself. Being run on GPU, the working process of a program is more complex: the algorithm and data should be previously uploaded to GPU before use. The majority of graphics adapters are implemented with the PCI-Express bus, which has limited bandwidth. This is one of the reasons why the central processing unit can perform calculations faster. Obviously, the value of the data and memory uploading time is the crucial parameter for calculation speed.
The CUDA memory model includes the host DRAM memory (regular operating memory), device DRAM (graphics memory), and registered and shared memory that are located on every multiprocessor of the graphics chip. The CUDA threads have access to all kinds of the GPU memory, which differ by scope, speed, and size (Table 1). The registered memory is used for local variables. Other variables that exceed the registered memory are placed in the local memory, which is suited outside of the chip and has low access speed. The shared memory is used for interaction between the threads. All threads have read/write access to the global memory. The scope for global memory is the whole application, and contents of the global memory doesn’t change while starting different cores. Moreover, the central processor has also access to the global memory; this is why the global memory is used for data exchange between the CPU and GPU.
Types of memory available for the CUDA applications
16384 registers High per SM Low
exceeding registered memory Threads inter operation Data storage with CPU
Thus, the most data operations and exchange with the CPU are implemented by the global memory, which has low speed, as seen from Table 1. The memory delay problem in the CPU is solved by caching and code predicting. But the GPU goes in the other way: in the case of waiting the data access in some thread, the video chip attaches to another thread that has already got all necessary data. Moreover, the video memory mostly has wider bandwidth than the common memory. Instead of active cache memory used by the CPU, the graphics cards have only 128-256 Kb of the cache memory, which is applied to bandwidth extension and of reduction delays.
Multithreading is supported in the GPU on the hardware level. Vendors achieve instant switching between threads (by 1 clock cycle) and support up to 1024 threads on every core.
Large number of threads in the CPU is not advisable due to significant time loss while switching, which may consume up to several hundreds of clock-cycles. In addition, one CPU core is able to process only 1 or 2 threads simultaneously. 3 3.1
Performance tests were done on image processing algorithms software
implementation. Four different resolutions of image (50x50, 150x150, 300x300, and
512x512) were used with the quality of JPEG Quality 25 and JPEG Quality
100. As a reference image, the well-known file Lena.jpg [
The images were processed by application of Sarcis [
Theoretical description of filtering algorithms
Weighted linear filtering. The linear smoothing filters are good ones for
removing the Gaussian noise and, also, the other types of noise. A linear filter is
implemented using the weighted sum of the pixels in the successive windows.
Typically, the same pattern of weights is used in each window; this means that
the linear filter is spatially invariant and can be implemented using a convolution
mask. If different filter weights are used for different parts of the image (but the
filter is still implemented as a weighted sum), then the linear filter is spatially
varied [
One of the simplest linear filters is implemented by a local averaging operation where the value of each pixel is replaced by the average of all the values in the local neighborhood. The weighted linear filtering mask is given by the mask 1 2 1 M = 116 2 4 2 . The main strategy is to set the largest weight at the central 1 2 1 pixel and inversely proportional to distance values to other pixels:
Reverse gradient filter. The idea of the reverse gradient filter is in choosing the mask weights. The greater bright difference between the central and the next point, the less weight is prescribed to the next point.
The mean gradient module value calculated for each aperture brightness level is:
HG(l) =
1 h(l) h(l) X Glm(i, j) m=1 Where HG(l) is the mean brightness gradient function value for l; h(l) is the number of points with brightness l; Gl(i, j) is the gradient value in the mth point −1 −1 −1 with brightness l at position (i, j). The Laplace operator 52 = −1 +8 −1 is −1 −1 −1 used to calculate the gradient value
Canny filter. The Canny filter is considered to be the optimal choice for
any task, which requires edge extraction or edge enhancement of elements with
different shapes and characteristics. This is due to its easy implementation and
ability to be adapted to different circumstances [
There are the following three criteria for the algorithm: • smart detection (increasing the signal/noise ratio); • good localization (correct definition of boundary position); • only one response to the border. The Canny filter differs from other classic edge detecting filters because it considers directionality of the element and permits personalization of the filter behavior by choosing the value of parameters of the algorithm. This provides changes in direction of the filter polarization and sensibility of the edge extraction.
The algorithm runs in 5 separate steps [
Morphological Image Processing. The morphological image processing is a collection of non-linear operations related to the shape or morphology the image features. Erosion of images is generally used for getting rid of the image of random insertions. The idea is that the inclusions are eliminated by blurring, while large and, thus, more visually important regions remain.
a) b) c)
Erosion (morphological narrowing) is a convolution of the image or its area selected with some kernel. The kernel may be of arbitrary shape and size. Here, in calculating the convolution, only one leading position is selected in core, which is aligned with the current pixel. In many cases, the core is selected as a square or circle with a leading position at the center (Fig. 2b). The core can be regarded as a pattern or a mask.
Applications of dilation is reduced to the passage pattern throughout the image and use some operator to search for a local minimum intensities of the pixels in the image, which covers the template. The gray color filled pixels appear black due to erosion (Fig. 2c). 3.3
Weighted linear filtering. As seen from graphs in Fig. 3, the images with size 50 × 50 are processed for the same time by both the CPU and GPU, excluding NVIDIA GTX260, which works a little better. The larger images are processed faster by the GPU.
Reverse gradient filter.As seen from graphs in Fig. 4, application of the reverse gradient filter gives comparable results w.r.t. the weighted linear filter.
Canny filter. It is obvious from Fig. 5 that the CPU runs faster on images up to 150 × 150 quality 25, but the GPU NVIDIA GT630M takes advantage in times on larger images. The GPU NVIDIA GTX260 works better when the CPU starts from images 300 × 300 regardless of image quality.
Morphological Image Processing. Analysis of graphs in Fig. 6 shows that in using the morphological processing similar to Canny’s filter, the GPU NVIDIA GT630M starts process faster than CPU from images size 50 × 50; and the GPU NVIDIA GTX260 is faster from size 300 × 300. Results of this research show a rise in the efficiency of the GPU computing while image size grows. Nowadays, the images with resolution less than 1024 × 768 can be found rarely. From resolutions 300 × 300, the GPU starts to process images faster than the CPU; so, it is advisable to use image processing algorithms applying the GPU computing. The CPU computing is suitable in small image processing or hardware systems without the GPU.