Jun‐Sik Kim, Myung Hwangbo, Takeo Kanade · 2009
A GPU becomes an affordable solution for accelerating a slow process on a commercial system. The most of achievements using it for non-rendering problems are the exact re-implementation of existing algorithms designed for a serial CPU. We study about conditions of a good parallel algorithm, and show that it is possible to design an algorithm targeted to a parallel hardware, though it may be useless on a CPU. The optical flow estimation problem is investigated to show the possibility. In some time-critical applications, it is more important to get results in a limited time than to improve the results. We focus on designing optical flow approximation algorithms tailored for a GPU to get a reasonable result as fast as possible by reformulating the problem as change detection with hypothesis generation using features tracked in advance. Two parallel algorithms are proposed: direct interpolation and testing multiple hypotheses. We discuss implementation issues in the CUDA framework. Both methods are running on a GPU in a near video rate providing reasonable results for the time-critical applications. These GPU-tailored algorithms become useful by running about 240 times faster than the equivalent serial implementations which are too slow to be useful in practice.
Cited by 7
M. Andrecut · Journal of Computational Biology · 2009
Principal component analysis (PCA) is a key statistical technique for multivariate data analysis. For large data sets, the common approach to PCA computation is based on the standard NIPALS-PCA algorithm, which unfortunately suffers from loss of orthogonality, and therefore its applicability is usually limited to the estimation of the first few components. Here we present an algorithm based on Gram-Schmidt orthogonalization (called GS-PCA), which eliminates this shortcoming of NIPALS-PCA. Also, we discuss the GPU (Graphics Processing Unit) parallel implementation of both NIPALS-PCA and GS-PCA algorithms. The numerical results show that the GPU parallel optimized versions, based on CUBLAS (NVIDIA), are substantially faster (up to 12 times) than the CPU optimized versions based on CBLAS (GNU Scientific Library).
Cited by 118
Vicente Galiano, Héctor Migallón, V. Migallón et al. · Civil-comp proceedings · 2011
Cited by 0
M. Andrecut · ArXiv.org · 2008
Principal component analysis (PCA) is a key statistical technique for multivariate data analysis. For large data sets the common approach to PCA computation is based on the standard NIPALS-PCA algorithm, which unfortunately suffers from loss of orthogonality, and therefore its applicability is usually limited to the estimation of the first few components. Here we present an algorithm based on Gram-Schmidt orthogonalization (called GS-PCA), which eliminates this shortcoming of NIPALS-PCA. Also, we discuss the GPU (Graphics Processing Unit) parallel implementation of both NIPALS-PCA and GS-PCA algorithms. The numerical results show that the GPU parallel optimized versions, based on CUBLAS (NVIDIA) are substantially faster (up to 12 times) than the CPU optimized versions based on CBLAS (GNU Scientific Library).
Cited by 4Open access
Miroslav N. Velev, Ping Gao · 2014
We present parallel algorithms for Binary Decision Diagram (BDD) manipulation optimized for efficient execution on Graphics Processing Units (GPUs). Compared to a sequential CPU-based BDD package with the same capabilities, our GPU implementation achieves at least 5 orders of magnitude speedup. To the best of our knowledge, this is the first work on using GPUs to accelerate a BDD package.
Cited by 7
Jérémie Allard, Olivier Comas, Stéphane Cotin et al. · 2008
Cited by 0
Wagner M. Nunan Zola · UFPR Digital Collection (Federal University of Paraná) · 2015
Orientador: Prof. Dr. Luis Carlos Erpen de Bona
Cited by 0Open access
Jing Jin, Xianggao Cai, Guoming Lai et al. · The Journal of Supercomputing · 2015
Cited by 5
Thé Van Luong, Ieee Student, Nouredine Melab et al. · 2010
Abstract — Over the last years, interest in hybrid metaheuristics has risen considerably in the field of optimization. Combinations of methods such as evolutionary algorithms and local searches have provided very powerful search algorithms. However, due to their complexity, the computational time of the solution search exploration remains exorbitant when large problem instances are to be solved. Therefore, the use of GPUbased parallel computing is required as a complementary way to speed up the search. This paper presents a new methodology to design and implement efficiently and effectively hybrid evolutionary algorithms on GPU accelerators. The methodology enables efficient mappings of the explored search space onto the GPU memory hierarchy. The experimental results show that the approach is very efficient especially for large problem instances. I.
Cited by 0
Jing Jin, Xiaola Lin · Lecture notes in computer science · 2014
Cited by 3Open access
Mohammed Alaa Ala’anzy, Nurdaulet Tolendi, Baizhan Baubek et al. · PLoS ONE · 2026
Sorting can be approached in two main ways: sequentially and in parallel. In sequential sorting, data is processed in a single-threaded manner, which can be slow for large datasets. However, parallel sorting divides the task across multiple processing units, enabling faster results by processing data simultaneously. Furthermore, Compute Unified Device Architecture (CUDA) technology enables developers to leverage GPU power for general-purpose parallel computing, significantly accelerating tasks like sorting. This paper investigates the GPU-based parallelization of merge sort (MS), quick sort (QS), bubble sort (BS), radix top-k selection sort (RS), and slow sort (SS) presenting optimized algorithms designed for efficient sorting of large datasets using modern GPUs. The primary objective is to evaluate the performance of these algorithms on GPUs utilizing CUDA, with a focus on analyzing both parallel time complexity and space complexity across various data types. Experiments are conducted on four dataset scenarios: randomly generated data, reverse-sorted data, already-sorted data, and nearly-sorted data. Also, the performance of GPU-accelerated implementations is compared with their sequential counterparts to assess improvements in computational efficiency and scalability. Earlier GPU-based generations of this type typically achieved acceleration rates between 2× and 9× over scalar CPU code. With newer GPU enhancements, including parallel-aware primitives and radix- or merge-optimized operations, acceleration rates have seen significant improvement. Our experiments indicate that Radix Sort based on GPUs achieves a significant speedup of approximately 50× (sequential: 240.8 ms, parallel: 4.83 ms) on 10 million random sort elements. Quick Sort and Merge Sort have 97× and 103× speedups, respectively (Quick: 1461.97 ms vs. 15.1 ms; Merge: 2212.33 ms vs. 21.4 ms). Bubble Sort, while significantly improving in parallel (123,321.9 ms to 7377.8 ms for an ≈17× improvement), is considerably worse overall. Slow Sort demonstrates a moderate but consistent acceleration, reducing execution time from 74.07 ms in the sequential version to 3.99 ms on the GPU, yielding an ≈18.6× speedup. These experimental findings confirm that the new single-GPU implementations can get speedups ranging from 17× to over 100×, surpassing the typical gains reported in previous generations and comparable to or over rates of acceleration reported for cutting-edge parallel sorting algorithms in recent studies.
Cited by 0Open access
Martin Dybdal, Martin Elsman, Bo Joel Svensson et al. · 2016
We present a Functional Compute Language (FCL) for low-level GPU programming. FCL is functional in style, which allows for easy composition of program fragments and thus easy prototyping and a high degree of code reuse. In contrast with projects such as Futhark, Accelerate, Harlan, Nessie and Delite, the intention is not to develop a language providing fully automatic optimizations, but instead to provide a platform that supports absolute control of the GPU computation and memory hierarchies. The developer is thus required to have an intimate knowledge of the target platform, as is also required when using CUDA/OpenCL directly.
Cited by 2
Ratul Kishore Saha, Ashutosh Pradhan, Tiash Ghosh et al. · Lecture notes in computer science · 2022
Cited by 0
Fuxiang Zhu · 2012
In order to deal with the relatively high time-complexity of practical issue,parallel modern optimization based on GPU was presented in this paper.Firstly,CUDA parallel programming architecture and programming model were summarized at a macroscopic level.Then the parallel processes of five typical modern optimization algorithms(Simulated Annealing,Tabu Search,Genetic Algorithms,Particle Swarm Optimization and Artificial Neural Network) using CUDA programming model were provided.Experimental statistics measured in different environment indicate that the parallel method can obtain better performance on average than CPU.Finally the parallel optimization strategy was discussed and the outlook of future direction of parallel optimization algorithm was also pointed out.
Cited by 2
В. М. Глушков · 2013
Parallel algorithms for modern high performance computing systems are required for fast modelling of high dimensional convection-diusi on processes in air. Such algorithms, designed for alternate-triangular nite dierence splitting schemes applied to convection-diusi on equation, have been considered. An algorithm for single GPU systems and an algorithm for clusters with graphical processors has been described, algorithms' performance theoretical estimations has been given and results of their testing on SKIT-4 cluster of Institute of Cybernetics has been presented. Obtained testing results about developed algorithms' performance with sucient accuracy agree with theoretical estimations.
Cited by 0
Neetu Faujdar, Shipra Saraswat · 2017
In today's world, sorting is a basic need and appropriate method starts with searching. Several sorting algorithms has been developed on CPU (Central Processing Unit). But according to current scenario, CPU is not so efficient in sorting. To get the more speedup of sorting algorithms parallelization should b e done. There are many ways of Parallelizing sorting methods which can be performed by using different tools. But for achieving high efficiency GPU (Graphics Processing Unit) comuting is the most preferable way. The authors of this paper surveyed various aspects in the direction of research of GPU based sorting algorithms. This paper also refined the different research gaps based on GPU sorting algorithms like parallel (Merge, Quick, Bitonic, Odd-Even, Count, and Radix etc.) by using GPU computing with CUDA (Compute Unified Device Architecture). Future re s e arch will motivate to do the work in GPU architecture.
Cited by 5
Vsevolod Bohaienko · 2013
Parallel algorithms for modern high performance computing systems are required for fast modelling of high dimensional convection-diffusion processes in air. Such algorithms, designed for alternate-triangular finite difference splitting schemes applied to convection-diffusion equation, have been considered. An algorithm for single GPU systems and an algorithm for clusters with graphical processors has been described, algorithms’ performance theoretical estimations has been given and results of their testing on SKIT-4 cluster of Institute of Cybernetics has been presented. Obtained testing results about developed algorithms’ performance with sufficient accuracy agree with theoretical estimations.
Cited by 0
Fiaz Gul Khan, Omar Khan, Bartolomeo Montrucchio et al. · 2011
Sorting algorithms have been studied extensively since past three decades. Their uses are found in many applications including real-time systems, operating systems, and discrete event simulations. In most cases, the efficiency of an application itself depends on usage of a sorting algorithm. Lately, the usage of graphic cards for general purpose computing has again revisited sorting algorithms. In this paper we extended our previous work regarding parallel sorting algorithms on GPU, and are presenting an analysis of parallel and sequential bitonic, odd-even and rank-sort algorithms on different GPU and CPU architectures. Their performance for various queue sizes is measured with respect to sorting time and rate and also the speed up of bitonic sort over odd-even sorting algorithms is shown on different GPUs and CPU. The algorithms have been written to exploit task parallelism model as available on multi-core GPUs using the OpenCL specification. Our findings report minimum of 19x speed-up of bitonic sort against odd-even sorting technique for small queue sizes on CPU and maximum of 2300x speed-up for very large queue sizes on Nvidia Quadro 6000 GPU architecture.
Cited by 14
Yuting Feng, Lei Zhao, Jiwen Yang · International Journal of Modern Education and Computer Science · 2010
Most recent schema matching systems combine multiple components, each of which employs a particular matching technique with several knobs. The multicomponent nature has brought a tuning problem, that is to determine which components to execute and how to adjust the knobs (e.g., thresholds, weights, etc.) of these components for domain users. In this paper, we present an approach to automatically tune schema matching systems using genetic algorithms. We match a given schema S against generated matching scenarios, for which the ground truth matches are known, and find a configuration that effectively improves the performance of matching S against real schemas. To search the huge space of configuration candidates efficiently, we adopt genetic algorithms (GAs) during the tuning process. To promote the performance of our approach, we implement parallel genetic algorithms on graphic processing units (GPUs) based on NVIDIA's Compute Unified Device Architecture (CUDA). Experiments over four real-world domains with two main matching systems demonstrate that our approach provides more qualified matches over different domains.
Cited by 0Open access
Kwan-Ho Lee, Chi-Yong Kim · Journal of IKEEE · 2017
본 논문에서는 적은 면적의 GP-GPU에서 성능을 향상시키기 위한 방법을 제안한다. 본 논문에서는 superscalar와 같이 과도하게 스케줄링 복잡성을 증가시키지 않는 대신 단순한 코어의 수를 늘려 성능을 극대화 시키는 방법을 제안한다. GP-GPU를 구성하는 Stream Processor의 구조를 단순화한다. 또한, Warp Schedule에서 thread 할당을 어플리케이션에 적합한 방법을 개발하여 성능을 개선한다. 성능을 검증하는 방안으로 neural network의 한 분야인 딥러닝에 대한 스레드 할당방식을 제안한다. Neural Network 알고리즘의 경우 Intel CPU 대비 90%에서 ARM Cortex-A15 4 core 대비 98% 성능 향상을 확인할 수 있었다. In this paper, we proposed a way to improve function of small scale GP-GPU. Instead of using superscalar which increase scheduling-complexity, we suggested the application of simple core to maximize GP-GPU performance. Our studies also demonstrated that simplified Stream Processor is one of the way to achieve functional improvement in GP-GPU. In addition, we found that developing of optimal thread-assigning method in Warp Scheduler for specific application improves functional performance of GP-GPU. For examination of GP-GPU functional performance, we suggested the thread-assigning way which coordinated with Deep-Learning system; a part of Neural Network. As a result, we found that functional index in algorithm of Neural Network was increased to 90%, 98% compared with Intel CPU and ARM cortex-A15 4 core respectively.
Cited by 0Open access