LaminarIR: Compile-time queues for structured streams

Yousun Ko, bernd Burgstaller, Bernhard Scholz

Research output: Chapter in Book/Report/Conference proceedingConference contribution

3 Citations (Scopus)

Abstract

Stream programming languages employ FIFO (first-in, first-out) semantics to model data channels between producers and consumers. A FIFO data channel stores tokens in a buffer that is accessed indirectly via read- and write-pointers. This indirect tokenaccess decouples a producer's write-operations from the readoperations of the consumer, thereby making dataflow implicit. For a compiler, indirect token-access obscures data-dependencies, which renders standard optimizations ineffective and impacts stream program performance negatively. In this paper we propose a transformation for structured stream programming languages such as StreamIt that shifts FIFO buffer management from run-time to compile-time and eliminates splitters and joiners, whose task is to distribute and merge streams. To show the effectiveness of our lowering transformation, we have implemented a StreamIt to C compilation framework. We have developed our own intermediate representation (IR) called LaminarIR, which facilitates the transformation. We report on the enabling effect of the LaminarIR on LLVM's optimizations, which required the conversion of several standard StreamIt benchmarks from static to randomized input, to prevent computation of partial results at compile-time. We conducted our experimental evaluation on the Intel i7-2600K, AMD Opteron 6378, Intel Xeon Phi 3120A and ARM Cortex-A15 platforms. Our LaminarIR reduces data-communication on average by 35.9% and achieves platform-specific speedups between 3.73x and 4.98x over StreamIt. We reduce memory accesses by more than 60% and achieve energy savings of up to 93.6% on the Intel i7-2600K.

Original languageEnglish
Title of host publicationPLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation
EditorsSteve Blackburn, David Grove
PublisherAssociation for Computing Machinery
Pages121-130
Number of pages10
ISBN (Electronic)9781450334686
DOIs
Publication statusPublished - 2015 Jun 3
Event36th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2015 - Portland, United States
Duration: 2015 Jun 132015 Jun 17

Publication series

NameProceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)
Volume2015-June

Other

Other36th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2015
CountryUnited States
CityPortland
Period15/6/1315/6/17

Fingerprint

Computer programming languages
Energy conservation
Semantics
Data storage equipment
Communication

All Science Journal Classification (ASJC) codes

  • Software

Cite this

Ko, Y., Burgstaller, B., & Scholz, B. (2015). LaminarIR: Compile-time queues for structured streams. In S. Blackburn, & D. Grove (Eds.), PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation (pp. 121-130). (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI); Vol. 2015-June). Association for Computing Machinery. https://doi.org/10.1145/2737924.2737994
Ko, Yousun ; Burgstaller, bernd ; Scholz, Bernhard. / LaminarIR : Compile-time queues for structured streams. PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. editor / Steve Blackburn ; David Grove. Association for Computing Machinery, 2015. pp. 121-130 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).
@inproceedings{60c5a94e94f2425999e46f4d8198fd6f,
title = "LaminarIR: Compile-time queues for structured streams",
abstract = "Stream programming languages employ FIFO (first-in, first-out) semantics to model data channels between producers and consumers. A FIFO data channel stores tokens in a buffer that is accessed indirectly via read- and write-pointers. This indirect tokenaccess decouples a producer's write-operations from the readoperations of the consumer, thereby making dataflow implicit. For a compiler, indirect token-access obscures data-dependencies, which renders standard optimizations ineffective and impacts stream program performance negatively. In this paper we propose a transformation for structured stream programming languages such as StreamIt that shifts FIFO buffer management from run-time to compile-time and eliminates splitters and joiners, whose task is to distribute and merge streams. To show the effectiveness of our lowering transformation, we have implemented a StreamIt to C compilation framework. We have developed our own intermediate representation (IR) called LaminarIR, which facilitates the transformation. We report on the enabling effect of the LaminarIR on LLVM's optimizations, which required the conversion of several standard StreamIt benchmarks from static to randomized input, to prevent computation of partial results at compile-time. We conducted our experimental evaluation on the Intel i7-2600K, AMD Opteron 6378, Intel Xeon Phi 3120A and ARM Cortex-A15 platforms. Our LaminarIR reduces data-communication on average by 35.9{\%} and achieves platform-specific speedups between 3.73x and 4.98x over StreamIt. We reduce memory accesses by more than 60{\%} and achieve energy savings of up to 93.6{\%} on the Intel i7-2600K.",
author = "Yousun Ko and bernd Burgstaller and Bernhard Scholz",
year = "2015",
month = "6",
day = "3",
doi = "10.1145/2737924.2737994",
language = "English",
series = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",
publisher = "Association for Computing Machinery",
pages = "121--130",
editor = "Steve Blackburn and David Grove",
booktitle = "PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation",

}

Ko, Y, Burgstaller, B & Scholz, B 2015, LaminarIR: Compile-time queues for structured streams. in S Blackburn & D Grove (eds), PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), vol. 2015-June, Association for Computing Machinery, pp. 121-130, 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2015, Portland, United States, 15/6/13. https://doi.org/10.1145/2737924.2737994

LaminarIR : Compile-time queues for structured streams. / Ko, Yousun; Burgstaller, bernd; Scholz, Bernhard.

PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. ed. / Steve Blackburn; David Grove. Association for Computing Machinery, 2015. p. 121-130 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI); Vol. 2015-June).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

TY - GEN

T1 - LaminarIR

T2 - Compile-time queues for structured streams

AU - Ko, Yousun

AU - Burgstaller, bernd

AU - Scholz, Bernhard

PY - 2015/6/3

Y1 - 2015/6/3

N2 - Stream programming languages employ FIFO (first-in, first-out) semantics to model data channels between producers and consumers. A FIFO data channel stores tokens in a buffer that is accessed indirectly via read- and write-pointers. This indirect tokenaccess decouples a producer's write-operations from the readoperations of the consumer, thereby making dataflow implicit. For a compiler, indirect token-access obscures data-dependencies, which renders standard optimizations ineffective and impacts stream program performance negatively. In this paper we propose a transformation for structured stream programming languages such as StreamIt that shifts FIFO buffer management from run-time to compile-time and eliminates splitters and joiners, whose task is to distribute and merge streams. To show the effectiveness of our lowering transformation, we have implemented a StreamIt to C compilation framework. We have developed our own intermediate representation (IR) called LaminarIR, which facilitates the transformation. We report on the enabling effect of the LaminarIR on LLVM's optimizations, which required the conversion of several standard StreamIt benchmarks from static to randomized input, to prevent computation of partial results at compile-time. We conducted our experimental evaluation on the Intel i7-2600K, AMD Opteron 6378, Intel Xeon Phi 3120A and ARM Cortex-A15 platforms. Our LaminarIR reduces data-communication on average by 35.9% and achieves platform-specific speedups between 3.73x and 4.98x over StreamIt. We reduce memory accesses by more than 60% and achieve energy savings of up to 93.6% on the Intel i7-2600K.

AB - Stream programming languages employ FIFO (first-in, first-out) semantics to model data channels between producers and consumers. A FIFO data channel stores tokens in a buffer that is accessed indirectly via read- and write-pointers. This indirect tokenaccess decouples a producer's write-operations from the readoperations of the consumer, thereby making dataflow implicit. For a compiler, indirect token-access obscures data-dependencies, which renders standard optimizations ineffective and impacts stream program performance negatively. In this paper we propose a transformation for structured stream programming languages such as StreamIt that shifts FIFO buffer management from run-time to compile-time and eliminates splitters and joiners, whose task is to distribute and merge streams. To show the effectiveness of our lowering transformation, we have implemented a StreamIt to C compilation framework. We have developed our own intermediate representation (IR) called LaminarIR, which facilitates the transformation. We report on the enabling effect of the LaminarIR on LLVM's optimizations, which required the conversion of several standard StreamIt benchmarks from static to randomized input, to prevent computation of partial results at compile-time. We conducted our experimental evaluation on the Intel i7-2600K, AMD Opteron 6378, Intel Xeon Phi 3120A and ARM Cortex-A15 platforms. Our LaminarIR reduces data-communication on average by 35.9% and achieves platform-specific speedups between 3.73x and 4.98x over StreamIt. We reduce memory accesses by more than 60% and achieve energy savings of up to 93.6% on the Intel i7-2600K.

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

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

U2 - 10.1145/2737924.2737994

DO - 10.1145/2737924.2737994

M3 - Conference contribution

AN - SCOPUS:84951743431

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

SP - 121

EP - 130

BT - PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation

A2 - Blackburn, Steve

A2 - Grove, David

PB - Association for Computing Machinery

ER -

Ko Y, Burgstaller B, Scholz B. LaminarIR: Compile-time queues for structured streams. In Blackburn S, Grove D, editors, PLDI 2015 - Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation. Association for Computing Machinery. 2015. p. 121-130. (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). https://doi.org/10.1145/2737924.2737994