Understanding Portability of a High-Level Programming Model on Contemporary Heterogeneous Architectures

Sabne, Amit J.; Sakdhnagool, Putt; Lee, Seyong; Vetter, Jeffrey S.

doi:10.1109/MM.2015.73

Title: Understanding Portability of a High-Level Programming Model on Contemporary Heterogeneous Architectures

Abstract

Accelerator-based heterogeneous computing is gaining momentum in the high-performance computing arena. However, the increased complexity of heterogeneous architectures demands more generic, high-level programming models. OpenACC is one such attempt to tackle this problem. Although the abstraction provided by OpenACC offers productivity, it raises questions concerning both functional and performance portability. In this article, the authors propose HeteroIR, a high-level, architecture-independent intermediate representation, to map high-level programming models, such as OpenACC, to heterogeneous architectures. They present a compiler approach that translates OpenACC programs into HeteroIR and accelerator kernels to obtain OpenACC functional portability. They then evaluate the performance portability obtained by OpenACC with their approach on 12 OpenACC programs on Nvidia CUDA, AMD GCN, and Intel Xeon Phi architectures. They study the effects of various compiler optimizations and OpenACC program settings on these architectures to provide insights into the achieved performance portability.

Authors:

Sabne, Amit J. ^[1]; Sakdhnagool, Putt ^[1]; Lee, Seyong ^[2]; Vetter, Jeffrey S. ^[2]

Purdue Univ., West Lafayette, IN (United States)
Oak Ridge National Lab. (ORNL), Oak Ridge, TN (United States)

Publication Date:: Mon Jul 13 00:00:00 EDT 2015

Research Org.:: Oak Ridge National Lab. (ORNL), Oak Ridge, TN (United States)

Sponsoring Org.:: USDOE Office of Science (SC)

OSTI Identifier:: 1265740

Grant/Contract Number:: AC05-00OR22725

Resource Type:: Accepted Manuscript

Journal Name:: IEEE Micro

Additional Journal Information:: Journal Volume: 35; Journal Issue: 4; Journal ID: ISSN 0272-1732

Publisher:: IEEE

Country of Publication:: United States

Language:: English

Subject:: 97 MATHEMATICS AND COMPUTING

Citation Formats


                    Sabne, Amit J., Sakdhnagool, Putt, Lee, Seyong, and Vetter, Jeffrey S. Understanding Portability of a High-Level Programming Model on Contemporary Heterogeneous Architectures.  United States: N. p., 2015. 
Web.  doi:10.1109/MM.2015.73.

Copy to clipboard


                    Sabne, Amit J., Sakdhnagool, Putt, Lee, Seyong, & Vetter, Jeffrey S. Understanding Portability of a High-Level Programming Model on Contemporary Heterogeneous Architectures.  United States.  https://doi.org/10.1109/MM.2015.73

Copy to clipboard


                    Sabne, Amit J., Sakdhnagool, Putt, Lee, Seyong, and Vetter, Jeffrey S. Mon .  
"Understanding Portability of a High-Level Programming Model on Contemporary Heterogeneous Architectures".  United States.  https://doi.org/10.1109/MM.2015.73.  https://www.osti.gov/servlets/purl/1265740.

Copy to clipboard


                    
@article{osti_1265740,

  title        = {Understanding Portability of a High-Level Programming Model on Contemporary Heterogeneous Architectures},

  author       = {Sabne, Amit J. and Sakdhnagool, Putt and Lee, Seyong and Vetter, Jeffrey S.},

  abstractNote = {Accelerator-based heterogeneous computing is gaining momentum in the high-performance computing arena. However, the increased complexity of heterogeneous architectures demands more generic, high-level programming models. OpenACC is one such attempt to tackle this problem. Although the abstraction provided by OpenACC offers productivity, it raises questions concerning both functional and performance portability. In this article, the authors propose HeteroIR, a high-level, architecture-independent intermediate representation, to map high-level programming models, such as OpenACC, to heterogeneous architectures. They present a compiler approach that translates OpenACC programs into HeteroIR and accelerator kernels to obtain OpenACC functional portability. They then evaluate the performance portability obtained by OpenACC with their approach on 12 OpenACC programs on Nvidia CUDA, AMD GCN, and Intel Xeon Phi architectures. They study the effects of various compiler optimizations and OpenACC program settings on these architectures to provide insights into the achieved performance portability.},

  doi          = {10.1109/MM.2015.73},

  journal      = {IEEE Micro},

  number       = 4,

  volume       = 35,

  place        = {United States},

  year         = {Mon Jul 13 00:00:00 EDT 2015},

  month        = {Mon Jul 13 00:00:00 EDT 2015}

}

Copy to clipboard

Journal Article:

Free Publicly Available Full Text

Accepted Manuscript (DOE)

Publisher's Version of Record

https://doi.org/10.1109/MM.2015.73

Other availability

Search WorldCat to find libraries that may hold this journal

Citation Metrics:

Cited by: 8 works

Citation information provided by
Web of Science

Figures / Tables:

TABLE 1: Comparison of Heterogeneous Architectures

All figures and tables (7 total)

Save / Share:

Export Metadata

Save to My Library

Figures / Tables found in this record:

Figures/Tables have been extracted from DOE-funded journal article accepted manuscripts.

Similar Records in DOE PAGES and OSTI.GOV collections:

Evaluating Performance Portability of OpenACC

Conference Sabne, Amit J ; Sakdhnagool, Putt ; Lee, Seyong ; ...

Accelerator-based heterogeneous computing is gaining momentum in High Performance Computing arena. However, the increased complexity of the accelerator architectures demands more generic, high-level programming models. OpenACC is one such attempt to tackle the problem. While the abstraction endowed by OpenACC offers productivity, it raises questions on its portability. This paper evaluates the performance portability obtained by OpenACC on twelve OpenACC programs on NVIDIA CUDA, AMD GCN, and Intel MIC architectures. We study the effects of various compiler optimizations and OpenACC program settings on these architectures to provide insights into the achieved performance portability.
Full Text Available
OpenACC to FPGA: A Framework for Directive-based High-Performance Reconfigurable Computing

Conference Lee, Seyong ; Kim, Jungwon ; Vetter, Jeffrey S.

This paper presents a directive-based, high-level programming framework for high-performance reconfigurable computing. It takes a standard, portable OpenACC C program as input and generates a hardware configuration file for execution on FPGAs. We implemented this prototype system using our open-source OpenARC compiler; it performs source-to-source translation and optimization of the input OpenACC program into an OpenCL code, which is further compiled into a FPGA program by the backend Altera Offline OpenCL compiler. Internally, the design of OpenARC uses a high- level intermediate representation that separates concerns of program representation from underlying architectures, which facilitates portability of OpenARC. In fact, thismore »« less
https://doi.org/10.1109/IPDPS.2016.28
Evaluating Performance Portability of Accelerator Programming Models using SPEC ACCEL 1.2 Benchmarks

Conference Boehm, Swen ; Pophale, Swaroop S. ; Melesse Vergara, Veronica G. ; ...

As heterogeneous architectures are becoming mainstream for HPC systems, application programmers are looking for programming model implementations that offer both performance and portability across platforms. Two directive-based programming models for accelerator programming that aim at doing this are OpenMP 4/4.5 and OpenACC. Many users want to know the difference between these two programming models, the state of their implementations, how to use them, and evaluate how suitable they are for their applications.The Standard Performance Evaluation Corporation (SPEC) ACCEL benchmarks, developed by the SPEC High Performance Group (HPG), recently released SPEC ACCEL 1.2 benchmark suite to help the evaluation of OpenCL,more »« less
Full Text Available
Investigation of Portable Event-Based Monte Carlo Transport Using the NVIDIA Thrust Library

Journal Article Bleile, Ryan C. ; Department of Computer and Information Science, University of Oregon, Eugene, OR 97403 ; Brantley, Patrick S. ; ... - Transactions of the American Nuclear Society

Power consumption considerations are driving future high performance computing platforms toward many-core computing architectures. Los Alamos National Laboratory's Trinity machine, available in 2016, will use both Intel Xeon Haswell processors and Intel Xeon Phi Knights Landing many integrated core (MIC) architecture coprocessors. Lawrence Livermore National Laboratory's Sierra machine, available in 2018, will use an IBM PowerPC architecture along with Nvidia graphics processing unit (GPU) architecture accelerators. These different advanced architectures make the computing landscape in upcoming years complex. Traditional approaches to Monte Carlo transport do not work efficiently on these new computing platforms. MIC architectures require vectorization to operate efficiently,more »« less
Portability for GPU-accelerated molecular docking applications for cloud and HPC: can portable compiler directives provide performance across all platforms?

Conference Thavappiragasam, Mathialakan ; Elwasif, Wael ; Sedova, Ada

High-throughput structure-based screening of drug-like molecules has become a common tool in biomedical research. Recently, acceleration with graphics processing units (GPUs) has provided a large performance boost for molecular docking programs. Both cloud and high-performance computing (HPC) resources have been used for large screens with molecular docking programs; while NVIDIA GPUs have dominated cloud and HPC resources, new vendors such as AMD and Intel are now entering the field, creating the problem of software portability across different GPUs. Ideally, software productivity could be maximized with portable programming models that are able to maintain high performance across architectures. While in manymore »« less
https://doi.org/10.1109/CCGrid54584.2022.00119

Full Text Available

Similar Records