Search

In the last decades, the problem of target detection has received considerable attention in remote sensing applications. When this problem is tackled using hyperspectral images with hundreds of bands, the use of high-performance computing (HPC) is essential. One of the most popular algorithms in the hyperspectral image analysis community for this purpose is the automatic target detection and classification algorithm (ATDCA). Previous research has already investigated the mapping of ATDCA on HPC platforms such as multicore processors, graphics processing units (GPUs), and field-programmable gate arrays (FPGAs), showing impressive speedup factors (after careful fine-tuning) that allow for its exploitation in time-critical scenarios. However, the lack of standardization resulted in most implementations being too specific to a given architecture, eliminating (or at least making extremely difficult) code reusability across different platforms. In order to address this issue, we present a portability study of an implementation of ATDCA developed using the open computing language (OpenCL). We focus on cross-platform parameters such as performance, energy consumption, and code design complexity, as compared to previously developed (hand-tuned) implementations. Our portability study analyzes different strategies to expose data parallelism as well as enable the efficient exploitation of complex memory hierarchies in heterogeneous devices. We also conduct an assessment of energy consumption and discuss metrics to analyze the quality of our code. The conducted experiments—using synthetic and real hyperspectral data sets collected by the Hyperspectral Digital Imagery Collection Experiment (HYDICE) and NASA’s Airborne Visible Infra-Red Imaging Spectrometer (AVIRIS)—demonstrate, for the first time in the literature, that portability across different HPC platforms can be achieved for real-time target detection in hyperspectral missions. [ABSTRACT FROM AUTHOR]

The Steered Response Power with Phase Transform (SRP-PHAT) algorithm is a well-known method for sound source localization due to its robust performance in noisy and reverberant environments. This algorithm is used in a large number of acoustic applications such as automatic camera steering systems, human–machine interaction, video gaming and audio surveillance. SPR-PHAT implementations require to handle a high number of signals coming from a microphone array and a huge search grid that influences the localization accuracy of the system. In this context, high performance in the localization process can only be achieved by using massively parallel computational resources. Different types of multi-core machines based either on multiple CPUs or on GPUs are commonly employed in diverse fields of science for accelerating a number of applications, mainly using OpenMP and CUDA as programming frameworks, respectively. This implies the development of multiple source codes which limits the portability and application possibilities. On the contrary, OpenCL has emerged as an open standard for parallel programming that is nowadays supported by a wide range of architectures. In this work, we evaluate an OpenCL-based implementations of the SRP-PHAT algorithm in two state-of-the-art CPU and GPU platforms. Results demonstrate that OpenCL achieves close-to-CUDA performance in GPU (considered as upper bound) and outperforms in most of the CPU configurations based on OpenMP. [ABSTRACT FROM AUTHOR]

The growing interest to incorporate new features into mobile devices has increased the number of signal processing applications running over processors designed for mobile computing. A challenging signal processing field is acoustic source localization, which is attractive for applications such as automatic camera steering systems, human-machine interfaces, video gaming or audio surveillance. In this context, the emergence of systems-on-chip (SoC) that contain a small graphics accelerator (or GPU), contributes a notable increment of the computational capacity while partially retaining the appealing low-power consumption of embedded systems. This is the case, for example, of the Samsung Exynos 5422 SoC that includes a Mali-T628 MP6 GPU. This work evaluates an OpenCL-based implementation of a method for sound source localization, namely, the Steered-Response Power with Phase Transform (SRP-PHAT) algorithm, on GPUs of this type. The results show that the proposed implementation, given the audio samples, is able to perform audio localization in real time with high-resolution spatial grids using up to 12 microphones. [ABSTRACT FROM AUTHOR]

We provide efficient implementations of common Fast Multipole Method (FMM) tasks for modern multi-core (Intel Xeon Haswell), many-core (Intel Xeon Phi Knights Landing) and Nvidia Pascal GPUs, offering optimization guidelines for each kernel and architecture, and exposing task granularity issues with evaluations on performance and scalability. These results motivate the use of hybrid execution models for FMM in heterogeneous architectures, in which per-kernel execution configurations are set by the kernel adaptability to the processor. [ABSTRACT FROM AUTHOR]

Abstract: Parallel accelerators are playing an increasingly important role in scientific computing. However, it is perceived that their weakness nowadays is their reduced “programmability” in comparison with traditional general-purpose CPUs. For the domain of dense linear algebra, we demonstrate that this is not necessarily the case. We show how the libflame library carefully layers routines and abstracts details related to storage and computation, so that extending it to take advantage of multiple accelerators is achievable without introducing platform specific complexity into the library code base. We focus on the experience of the library developer as he develops a library routine for a new operation, reduction of a generalized Hermitian positive definite eigenvalue problem to a standard Hermitian form, and configures the library to target a multi-GPU platform. It becomes obvious that the library developer does not need to know about the parallelization or the details of the multi-accelerator platform. Excellent performance on a system with four NVIDIA Tesla C2050 GPUs is reported. This makes libflame the first library to be released that incorporates multi-GPU functionality for dense matrix computations, setting a new standard for performance. [Copyright &y& Elsevier]

While image texture is effective for use in pattern recognition and image analysis algorithms, textural features are time-consuming to calculate on standard CPUs. Therefore, we present novel implementations of textural feature algorithms on graphics processors (GPUs), enabling fast color and texture analysis. Since different textural feature calculations can exhibit diverse characteristics, we focus on using general and algorithm-specific techniques to exploit the inherent parallelism and computational power of a GPU. Common operations required during the textural feature pipeline range from streaming computations to recursive procedures, from arithmetically intensive transcendental functions to matrix operations. Some of these kernels are well-suited to GPUs, while others require considerable programming effort to fully exploit the memory hierarchy due to their memory usage patterns. In this paper, different strategies for computing textural features on GPUs are compared with counterpart implementations on multicore CPUs, and experimental results show GPU results reaching 500× speedup for certain operations. [ABSTRACT FROM AUTHOR]

While image texture is effective for use in pattern-recognition and image-analysis algorithms, textural features are time-consuming to calculate on standard CPUs. Therefore, we present novel implementations of textural-feature algorithms on graphics processors (GPUs), enabling fast color and texture analysis. Since different textural-feature calculations exhibit diverse characteristics, we focus on using general and algorithm-specific techniques to exploit the inherent parallelism and computational power of a GPU. Common operations required during the textural-feature pipeline range from streaming computations to recursive procedures, from arithmetically intensive transcendental functions to matrix operations. Some of these kernels are well-suited to GPUs, while others require considerable programming effort to fully exploit the memory hierarchy due to their memory-usage patterns. In this paper, different strategies for computing textural features on GPUs are compared with counterpart implementations on multicore CPUs, and experimental results show GPU results reaching a speedup of 500 times for certain operations. [ABSTRACT FROM PUBLISHER]

We investigate the performance of the routines in LAPACK and the Successive Band Reduction (SBR) toolbox for the reduction of a dense matrix to tridiagonal form, a crucial preprocessing stage in the solution of the symmetric eigenvalue problem, on general-purpose multi-core processors. In response to the advances of hardware accelerators, we also modify the code in the SBR toolbox to accelerate the computation by off-loading a significant part of the operations to a graphics processor (GPU). The performance results illustrate the parallelism and scalability of these algorithms on current high-performance multi-core and many-core architectures. Copyright © 2010 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

This paper advances the state-of-the-art in programming models for exploiting task-level parallelism on heterogeneous many-core systems, presenting a number of extensions to the OpenMP language inspired in the StarSs programming model. The proposed extensions allow the programmer to write portable code easily for a number of different platforms, relieving him/her from developing the specific code to off-load tasks to the accelerators and the synchronization of tasks. Our results obtained from the StarSs instantiations for SMPs, the Cell, and GPUs report reasonable parallel performance. However, the real impact of our approach in is the productivity gains it yields for the programmer. [ABSTRACT FROM AUTHOR]

We present several algorithms to compute the solution of a linear system of equations on a graphics processor (GPU), as well as general techniques to improve their performance, such as padding and hybrid GPU-CPU computation. We compare single and double precision performance of a modern GPU with unified architecture, and show how iterative refinement with mixed precision can be used to regain full accuracy in the solution of linear systems, exploiting the potential of the processor for single precision arithmetic. Experimental results on a GTX280 using CUBLAS 2.0, the implementation of BLAS for NVIDIA® GPUs with unified architecture, illustrate the performance of the different algorithms and techniques proposed. Copyright © 2009 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Abstract: We compare two approaches to compute a fraction of the spectrum of dense symmetric definite generalized eigenproblems: one is based on the reduction to tridiagonal form, and the other on the Krylov-subspace iteration. Two large-scale applications, arising in molecular dynamics and material science, are employed to investigate the contributions of the application, architecture, and parallelism of the method to the performance of the solvers. The experimental results on a state-of-the-art 8-core platform, equipped with a graphics processing unit (GPU), reveal that in realistic applications, iterative Krylov-subspace methods can be a competitive approach also for the solution of dense problems. [Copyright &y& Elsevier]