Loo.py: Transformation-based code generation for GPUs and CPUs

Andreas Klockner

doi:10.1145/2627373.2627387

Loo.py: Transformation-based code generation for GPUs and CPUs

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

Abstract

Today's highly heterogeneous computing landscape places a burden on programmers wanting to achieve high performance on a reasonably broad cross-section of machines. To do so, computations need to be expressed in many different but mathematically equivalent ways, with, in the worst case, one variant per target machine. Loo.py, a programming system embedded in Python, meets this challenge by defining a data model for array-style computations and a library of transformations that operate on this model. Offering transformations such as loop tiling, vectorization, storage management, unrolling, instruction-level parallelism, change of data layout, and many more, it provides a convenient way to capture, parametrize, and re-unify the growth among code variants. Optional, deep integration with numpy and PyOpenCL provides a convenient computing environment where the transition from prototype to high-performance implementation can occur in a gradual, machine-Assisted form..

Original language	English (US)
Title of host publication	ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014
Publisher	Association for Computing Machinery
Pages	82-87
Number of pages	6
ISBN (Electronic)	9781450329378
DOIs	https://doi.org/10.1145/2627373.2627387
State	Published - Jun 9 2014
Event	1st ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY 2014 - Part of PLDI 2014 - Edinburgh, United Kingdom Duration: Jun 12 2014 → Jun 13 2014

Publication series

Name	Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

Conference

Conference	1st ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY 2014 - Part of PLDI 2014
Country	United Kingdom
City	Edinburgh
Period	6/12/14 → 6/13/14

Keywords

Code generation
Data layout
Embedded language
GPU
High-level language
High-performance
Vectorization

ASJC Scopus subject areas

Software

Access to Document

10.1145/2627373.2627387

Fingerprint Dive into the research topics of 'Loo.py: Transformation-based code generation for GPUs and CPUs'. Together they form a unique fingerprint.

Cite this

Klockner, A. (2014). Loo.py: Transformation-based code generation for GPUs and CPUs. In ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014 (pp. 82-87). (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). Association for Computing Machinery. https://doi.org/10.1145/2627373.2627387

Loo.py : Transformation-based code generation for GPUs and CPUs. / Klockner, Andreas.

ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014. Association for Computing Machinery, 2014. p. 82-87 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

Klockner, A 2014, Loo.py: Transformation-based code generation for GPUs and CPUs. in ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Association for Computing Machinery, pp. 82-87, 1st ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY 2014 - Part of PLDI 2014, Edinburgh, United Kingdom, 6/12/14. https://doi.org/10.1145/2627373.2627387

Klockner A. Loo.py: Transformation-based code generation for GPUs and CPUs. In ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014. Association for Computing Machinery. 2014. p. 82-87. (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). https://doi.org/10.1145/2627373.2627387

Klockner, Andreas. / Loo.py : Transformation-based code generation for GPUs and CPUs. ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014. Association for Computing Machinery, 2014. pp. 82-87 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).

@inproceedings{b79caf68886a4cf0afab1b85dbd5f003,

title = "Loo.py: Transformation-based code generation for GPUs and CPUs",

abstract = "Today's highly heterogeneous computing landscape places a burden on programmers wanting to achieve high performance on a reasonably broad cross-section of machines. To do so, computations need to be expressed in many different but mathematically equivalent ways, with, in the worst case, one variant per target machine. Loo.py, a programming system embedded in Python, meets this challenge by defining a data model for array-style computations and a library of transformations that operate on this model. Offering transformations such as loop tiling, vectorization, storage management, unrolling, instruction-level parallelism, change of data layout, and many more, it provides a convenient way to capture, parametrize, and re-unify the growth among code variants. Optional, deep integration with numpy and PyOpenCL provides a convenient computing environment where the transition from prototype to high-performance implementation can occur in a gradual, machine-Assisted form..",

keywords = "Code generation, Data layout, Embedded language, GPU, High-level language, High-performance, Vectorization",

author = "Andreas Klockner",

note = "Publisher Copyright: Copyright {\textcopyright} 2014 ACM 978-1-4503-2937-8/14/06. 15.00. Copyright: Copyright 2015 Elsevier B.V., All rights reserved.; 1st ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY 2014 - Part of PLDI 2014 ; Conference date: 12-06-2014 Through 13-06-2014",

year = "2014",

month = jun,

day = "9",

doi = "10.1145/2627373.2627387",

language = "English (US)",

series = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",

publisher = "Association for Computing Machinery",

pages = "82--87",

booktitle = "ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014",

}

TY - GEN

T1 - Loo.py

T2 - 1st ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY 2014 - Part of PLDI 2014

AU - Klockner, Andreas

PY - 2014/6/9

Y1 - 2014/6/9

N2 - Today's highly heterogeneous computing landscape places a burden on programmers wanting to achieve high performance on a reasonably broad cross-section of machines. To do so, computations need to be expressed in many different but mathematically equivalent ways, with, in the worst case, one variant per target machine. Loo.py, a programming system embedded in Python, meets this challenge by defining a data model for array-style computations and a library of transformations that operate on this model. Offering transformations such as loop tiling, vectorization, storage management, unrolling, instruction-level parallelism, change of data layout, and many more, it provides a convenient way to capture, parametrize, and re-unify the growth among code variants. Optional, deep integration with numpy and PyOpenCL provides a convenient computing environment where the transition from prototype to high-performance implementation can occur in a gradual, machine-Assisted form..

AB - Today's highly heterogeneous computing landscape places a burden on programmers wanting to achieve high performance on a reasonably broad cross-section of machines. To do so, computations need to be expressed in many different but mathematically equivalent ways, with, in the worst case, one variant per target machine. Loo.py, a programming system embedded in Python, meets this challenge by defining a data model for array-style computations and a library of transformations that operate on this model. Offering transformations such as loop tiling, vectorization, storage management, unrolling, instruction-level parallelism, change of data layout, and many more, it provides a convenient way to capture, parametrize, and re-unify the growth among code variants. Optional, deep integration with numpy and PyOpenCL provides a convenient computing environment where the transition from prototype to high-performance implementation can occur in a gradual, machine-Assisted form..

KW - Code generation

KW - Data layout

KW - Embedded language

KW - GPU

KW - High-level language

KW - High-performance

KW - Vectorization

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

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

U2 - 10.1145/2627373.2627387

DO - 10.1145/2627373.2627387

M3 - Conference contribution

AN - SCOPUS:84908256404

T3 - Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

SP - 82

EP - 87

BT - ARRAY 2014 - Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, co-located with PLDI 2014

PB - Association for Computing Machinery

Y2 - 12 June 2014 through 13 June 2014

ER -