Futhark: purely functional GPU-programming with nested parallelism and in-place array updates

Research output: Chapter in Book/Report/Conference proceedingArticle in proceedingsResearchpeer-review

Standard

Futhark : purely functional GPU-programming with nested parallelism and in-place array updates. / Henriksen, Troels; Serup, Niels G. W.; Elsman, Martin; Henglein, Fritz; Oancea, Cosmin Eugen.

Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. Association for Computing Machinery, 2017. p. 556-571.

Research output: Chapter in Book/Report/Conference proceedingArticle in proceedingsResearchpeer-review

Harvard

Henriksen, T, Serup, NGW, Elsman, M, Henglein, F & Oancea, CE 2017, Futhark: purely functional GPU-programming with nested parallelism and in-place array updates. in Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. Association for Computing Machinery, pp. 556-571, 38th ACM SIGPLAN Conference on Programming Language Design and Implementation, Barcelona, Spain, 18/06/2017. https://doi.org/10.1145/3062341.3062354

APA

Henriksen, T., Serup, N. G. W., Elsman, M., Henglein, F., & Oancea, C. E. (2017). Futhark: purely functional GPU-programming with nested parallelism and in-place array updates. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (pp. 556-571). Association for Computing Machinery. https://doi.org/10.1145/3062341.3062354

Vancouver

Henriksen T, Serup NGW, Elsman M, Henglein F, Oancea CE. Futhark: purely functional GPU-programming with nested parallelism and in-place array updates. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. Association for Computing Machinery. 2017. p. 556-571 https://doi.org/10.1145/3062341.3062354

Author

Henriksen, Troels ; Serup, Niels G. W. ; Elsman, Martin ; Henglein, Fritz ; Oancea, Cosmin Eugen. / Futhark : purely functional GPU-programming with nested parallelism and in-place array updates. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. Association for Computing Machinery, 2017. pp. 556-571

Bibtex

@inproceedings{67ec01f54a6d41ce96433043378ca8c9,
title = "Futhark: purely functional GPU-programming with nested parallelism and in-place array updates",
abstract = "Futhark is a purely functional data-parallel array language that offers a machine-neutral programming model and an optimising compiler that generates OpenCL code for GPUs. This paper presents the design and implementation of three key features of Futhark that seek a suitable middle ground with imperative approaches. First, in order to express efficient code inside the parallel constructs, we introduce a simple type system for in-place updates that ensures referential transparency and supports equational reasoning. Second, we furnish Futhark with parallel operators capable of expressing efficient strength-reduced code, along with their fusion rules. Third, we present a flattening transformation aimed at enhancing the degree of parallelism that (i) builds on loop interchange and distribution but uses higher-order reasoning rather than array-dependence analysis, and (ii) still allows further locality-of-reference optimisations. Finally, an evaluation on 16 benchmarks demonstrates the impact of the language and compiler features and shows application-level performance competitive with hand-written GPU code. Copyright is held by the owner/author(s).",
keywords = "Compilers, Functional language, GPGPU, Parallel",
author = "Troels Henriksen and Serup, {Niels G. W.} and Martin Elsman and Fritz Henglein and Oancea, {Cosmin Eugen}",
year = "2017",
doi = "10.1145/3062341.3062354",
language = "English",
pages = "556--571",
booktitle = "Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation",
publisher = "Association for Computing Machinery",
note = "null ; Conference date: 18-06-2017 Through 23-06-2017",

}

RIS

TY - GEN

T1 - Futhark

AU - Henriksen, Troels

AU - Serup, Niels G. W.

AU - Elsman, Martin

AU - Henglein, Fritz

AU - Oancea, Cosmin Eugen

N1 - Conference code: 38

PY - 2017

Y1 - 2017

N2 - Futhark is a purely functional data-parallel array language that offers a machine-neutral programming model and an optimising compiler that generates OpenCL code for GPUs. This paper presents the design and implementation of three key features of Futhark that seek a suitable middle ground with imperative approaches. First, in order to express efficient code inside the parallel constructs, we introduce a simple type system for in-place updates that ensures referential transparency and supports equational reasoning. Second, we furnish Futhark with parallel operators capable of expressing efficient strength-reduced code, along with their fusion rules. Third, we present a flattening transformation aimed at enhancing the degree of parallelism that (i) builds on loop interchange and distribution but uses higher-order reasoning rather than array-dependence analysis, and (ii) still allows further locality-of-reference optimisations. Finally, an evaluation on 16 benchmarks demonstrates the impact of the language and compiler features and shows application-level performance competitive with hand-written GPU code. Copyright is held by the owner/author(s).

AB - Futhark is a purely functional data-parallel array language that offers a machine-neutral programming model and an optimising compiler that generates OpenCL code for GPUs. This paper presents the design and implementation of three key features of Futhark that seek a suitable middle ground with imperative approaches. First, in order to express efficient code inside the parallel constructs, we introduce a simple type system for in-place updates that ensures referential transparency and supports equational reasoning. Second, we furnish Futhark with parallel operators capable of expressing efficient strength-reduced code, along with their fusion rules. Third, we present a flattening transformation aimed at enhancing the degree of parallelism that (i) builds on loop interchange and distribution but uses higher-order reasoning rather than array-dependence analysis, and (ii) still allows further locality-of-reference optimisations. Finally, an evaluation on 16 benchmarks demonstrates the impact of the language and compiler features and shows application-level performance competitive with hand-written GPU code. Copyright is held by the owner/author(s).

KW - Compilers

KW - Functional language

KW - GPGPU

KW - Parallel

UR - http://www.scopus.com/inward/record.url?scp=85025117216&partnerID=8YFLogxK

U2 - 10.1145/3062341.3062354

DO - 10.1145/3062341.3062354

M3 - Article in proceedings

AN - SCOPUS:85025117216

SP - 556

EP - 571

BT - Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation

PB - Association for Computing Machinery

Y2 - 18 June 2017 through 23 June 2017

ER -

ID: 184140914