CuPP - A framework for easy CUDA integration

Breitbart, Jens

doi:10.1109/ipdps.2009.5160937

Cited by 21 publications

(14 citation statements)

References 0 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…GPU language translators have been made available for several languages including Java [213], C [28], C++ [42], OpenMP [141], Python [136], Ruby [155], .NET [137], MATLAB [43] and Fortran [186]. The porting process focuses on exploiting the massive computational capabilities of modern GPUs by porting structured data-parallel parts of the application such as for-loops in C++ with no loop-carried dependences etc.…”

Section: Code Generationmentioning

confidence: 99%

Performance-aware component composition for GPU-based systems

Dastgeer¹

2014

View full text Add to dashboard Cite

This thesis adresses issues associated with efficiently programming modern heterogeneous GPU-based systems, containing multicore CPUs and one or more programmable Graphics Processing Units (GPUs). We use ideas from component-based programming to address programming, performance and portability issues of these heterogeneous systems. Specifically, we present three approaches that all use the idea of having multiple implementations for each computation; performance is achieved/retained either a) by selecting a suitable implementation for each computation on a given platform or b) by dividing the computation work across different implementations running on CPU and GPU devices in parallel.In the first approach, we work on a skeleton programming library (SkePU) that provides high-level abstraction while making intelligent implementation selection decisions underneath either before or during the actual program execution. In the second approach, we develop a composition tool that parses extra information (metadata) from XML files, makes certain decisions offline, and, in the end, generates code for making the final decisions at runtime. The third approach is a framework that uses source-code annotations and program analysis to generate code for the runtime library to make the selection decision at runtime. With a generic performance modeling API alongside program analysis capabilities, it supports online tuning as well as complex program transformations.These approaches differ in terms of genericity, intrusiveness, capabilities and knowledge about the program source-code; however, they all demonstrate usefulness of component programming techniques for programming GPU-based systems. With experimental evaluation, we demonstrate how all three approaches, although different in their own way, provide good performance on different GPU-based systems for a variety of applications.This work has been supported by two EU FP7 projects (PEP-PHER, EXCESS) and by SeRC. Populärvetenskaplig sammanfattningAtt få varje generation av datorer att fungera snabbareär viktigt för samhä-llets utveckling och tillväxt. Traditionellt hade de flesta datorer bara en general-purpose processor (den så kallade CPU:n) som bara kunde exekvera en beräkningsuppgift i taget. Under det senasteårtiondet har dock flerkärniga och mångkärniga processorer blivit vanliga, och datorer har också blivit mer heterogena. Ett modernt datorsystem innehåller vanligtvis flerän en CPU, tillsammans med specialprocessorer såsom grafikprocessorer (GPU:er) som ar anpassade för att kunna exekvera vissa typer av beräkningar effektivarë an CPU:er. Vi kallar ett sådant system med en eller flera GPU:er för ett GPU-baserat system. GPU:er i sådana system har sitt eget separata minne, och för att kunna köra en beräkning på en GPU så behöver man vanligtvis flytta all indata till GPU:ns minne och sedan hämta tillbaka resultatet när beräkningenär klar.Programmeringen av GPU-baserade systemär icke-trivialt av flera anledningar: (1) CPU:er och GPU:er kräver olika programmeringsexper...

show abstract

Section: Code Generationmentioning

confidence: 99%

Performance-aware component composition for GPU-based systems

Dastgeer¹

2014

View full text Add to dashboard Cite

show abstract

“…However, it is arguable that each of these approaches exhibits some form of weakness. For example, Application Programming Interfaces [9,10,11] and Domain Specific Languages [12] simplify the task of expressing parallelism, but they are not suitable for legacy software. Libraries [13], while highly tuned and easy to use, are limited to specific application domains.…”

Section: Related Workmentioning

confidence: 99%

Paralysis: An Extensible Multi-tiered Guidance Environment for Program Parallelization and Analysis

McCool

Shao

Milligan

et al. 2013

2013 21st Euromicro International Conference on Parallel, Distributed, and Network-Based Processing

View full text Add to dashboard Cite

The heterogeneous computing revolution continues unabated. Yet despite the vast number of naïve users in possession of bespoke software hoping to embrace the opportunities that this revolution has wrought, few approaches proposed in current literature can guide such users in these efforts. The most appropriate choice would appear to be a (semi-)automating compiler. However, these typically target a single device-type and demand the unguided use of directives. Consequently, they are of little use when naïve users are seeking answers to more fundamental questions, such as: which fragments of a program can/should be parallelized, which device should each fragment target, and what speedup will be attained. To this end, this paper expands on previous work and proposes Paralysis -an extensible guidance environment, tiered for varying programmer competencies with support for static and dynamic analysis techniques. At the highest level, guided user experiences are paramount. At the lowest level, underlying functionality is exposed as a set of plug-ins, ensuring longevity. A partial prototype, built atop the Cetus infrastructure, is described. It is used to analyze two serial programs for CUDA execution -the DFT and the Box Blur Filter. Speedups of 15x and 22x are achieved on the basis of the analysis.

show abstract

“…Moreover, at the host side, function calls resemble the inofficial OpenCL C++ bindings available on the OpenCL homepage [11]. The bindings were chosen since our programs partially rely on the CuPP library [2], a framework of easier-to-use interfaces for reoccurring tasks.…”

Section: Opencl Implementation For the Cbeamentioning

confidence: 99%

Analyzing Use of OpenCL on the Cell Broadband Engine and a Proposal for OpenCL Extensions

Breitbart

Fohry

2011

IJNC

Self Cite

View full text Add to dashboard Cite

Current processor architectures are diverse and heterogeneous. Examples include multicore chips, GPUs and the Cell Broadband Engine (CBE). The recent Open Compute Language (OpenCL) standard aims at efficiency and portability. This paper explores its efficiency when implemented on the CBE, without using CBE-specific features such as explicit asynchronous memory transfers. We based our experiments on two applications: matrix multiplication, and the client side of the Einstein@Home distributed computing project. Both were programmed in OpenCL, and then translated to the CBE. For matrix multiplication, we deployed different levels of OpenCL performance optimization, and observed that they pay off on the CBE. For Einstein@Home, our translated OpenCL version achieves almost the same speed as a native CBE version. We experimented with two versions of the OpenCL to CBE mapping, in which the PPE component of the CBE does or does not take the role of a compute unit.Another major contribution of the paper is a proposal for two OpenCL extensions that we analyzed for both CBE and NVIDIA GPUs. First, we suggest an additional memory level in OpenCL, called static local memory. With little programming expense, it can lead to significant speedups such as for reduction a factor of seven on the CBE and about 20% on NVIDIA GPUs. Second, we introduce static work-groups to support user-defined mappings of tasks. Static work-groups may simplify programming and lead to speedups of 35% (CBE) and 100% (GPU) for all-parallel-prefix-sums.

show abstract

CuPP - A framework for easy CUDA integration

Cited by 21 publications

References 0 publications

Performance-aware component composition for GPU-based systems

Performance-aware component composition for GPU-based systems

Paralysis: An Extensible Multi-tiered Guidance Environment for Program Parallelization and Analysis

Analyzing Use of OpenCL on the Cell Broadband Engine and a Proposal for OpenCL Extensions

Contact Info

Product

Resources

About