GPU programming in a high level language

Cunningham, Dave; Bordawekar, Rajesh; Saraswat, Vijay

doi:10.1145/2212736.2212744

Cited by 58 publications

(29 citation statements)

References 3 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Directive based approaches such as OpenMP to CUDA [29], OpenACC to OpenCL [36], and hiCUDA [22] compile sequential C code for the GPU. X10, a language for high performance computing, can also be used to program GPUs [14]. However, this remains lowlevel since the programmer has to express the same low-level operations found in CUDA or OpenCL.…”

Section: Related Workmentioning

confidence: 99%

Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code

SteuwerMichel¹,

FenschChristian²,

LindleySam³

et al. 2015

SIGPLAN Not.

View full text Add to dashboard Cite

Computers have become increasingly complex with the emergence of heterogeneous hardware combining multicore CPUs and GPUs. These parallel systems exhibit tremendous computational power at the cost of increased programming effort resulting in a tension between performance and code portability. Typically, code is either tuned in a low-level imperative language using hardware-specific optimizations to achieve maximum performance or is written in a high-level, possibly functional, language to achieve portability at the expense of performance.We propose a novel approach aiming to combine high-level programming, code portability, and high-performance. Starting from a high-level functional expression we apply a simple set of rewrite rules to transform it into a low-level functional representation, close to the OpenCL programming model, from which OpenCL code is generated. Our rewrite rules define a space of possible implementations which we automatically explore to generate hardware-specific OpenCL implementations. We formalize our system with a core dependently-typed λ-calculus along with a denotational semantics which we use to prove the correctness of the rewrite rules.We test our design in practice by implementing a compiler which generates high performance imperative OpenCL code. Our experiments show that we can automatically derive hardwarespecific implementations from simple functional high-level algorithmic expressions offering performance on a par with highly tuned code for multicore CPUs and GPUs written by experts.

show abstract

Section: Related Workmentioning

confidence: 99%

Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code

SteuwerMichel¹,

FenschChristian²,

LindleySam³

et al. 2015

SIGPLAN Not.

View full text Add to dashboard Cite

show abstract

“…Obsidian uses an API as a intermediate layer for optimizations with CUDA. X10 [36] is a language for high performance computing that can also be used to program GPUs [11]. However, the programming style often remains low-level since the programmer has to express the same low-level operations found in CUDA or OpenCL.…”

Section: High-level Languages For Gpus Programmingmentioning

confidence: 99%

Runtime Code Generation and Data Management for Heterogeneous Computing in Java

Fumero

Remmelg

Steuwer

et al. 2015

Proceedings of the Principles and Practices of Programming on the Java Platform

View full text Add to dashboard Cite

GPUs (Graphics Processing Unit) and other accelerators are nowadays commonly found in desktop machines, mobile devices and even data centres. While these highly parallel processors offer high raw performance, they also dramatically increase program complexity, requiring extra effort from programmers. This results in difficult-to-maintain and non-portable code due to the low-level nature of the languages used to program these devices.This paper presents a high-level parallel programming approach for the popular Java programming language. Our goal is to revitalise the old Java slogan -Write once, run anywhere -in the context of modern heterogeneous systems. To enable the use of parallel accelerators from Java we introduce a new API for heterogeneous programming based on array and functional programming. Applications written with our API can then be transparently accelerated on a device such as a GPU using our runtime OpenCL code generator.In order to ensure the highest level of performance, we present data management optimizations. Usually, data has to be translated (marshalled) between the Java representation and the representation accelerators use. This paper shows how marshal affects runtime and present a novel technique in Java to avoid this cost by implementing our own customised array data structure. Our design hides low level data management from the user making our approach applicable even for inexperienced Java programmers.We evaluated our technique using a set of applications from different domains, including mathematical finance and machine learning. We achieve speedups of up to 500× over sequential and multi-threaded Java code when using an external GPU.

show abstract

“…X10 [14] and Habanero [40] both have shown support for GPUs, but they use different techniques to handle singlesource portability across other architectures. They do not provide any mechanism for reverting to a multicore platform from a tuned GPU implementation.…”

Section: Related Workmentioning

confidence: 99%

Performance Portability with the Chapel Language

Sidelnik

Maleki

Chamberlain³

et al. 2012

2012 IEEE 26th International Parallel and Distributed Processing Symposium

View full text Add to dashboard Cite

Abstract-It has been widely shown that high-throughput computing architectures such as GPUs offer large performance gains compared with their traditional low-latency counterparts for many applications. The downside to these architectures is that the current programming models present numerous challenges to the programmer: lower-level languages, loss of portability across different architectures, explicit data movement, and challenges in performance optimization.This paper presents novel methods and compiler transformations that increase programmer productivity by enabling users of the language Chapel to provide a single code implementation that the compiler can then use to target not only conventional multiprocessors, but also high-throughput and hybrid machines. Rather than resorting to different parallel libraries or annotations for a given parallel platform, this work leverages a language that has been designed from first principles to address the challenge of programming for parallelism and locality. This also has the advantage of providing portability across different parallel architectures. Finally, this work presents experimental results from the Parboil benchmark suite which demonstrate that codes written in Chapel achieve performance comparable to the original versions implemented in CUDA on both GPUs and multicore platforms.

show abstract

GPU programming in a high level language

Cited by 58 publications

References 3 publications

Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code

Generating performance portable code using rewrite rules: from high-level functional expressions to high-performance OpenCL code

Runtime Code Generation and Data Management for Heterogeneous Computing in Java

Performance Portability with the Chapel Language

Contact Info

Product

Resources

About