Optimizing data structures in high-level programs

Rompf, Tiark; Sujeeth, Arvind K.; Amin, Nada; Brown, Kevin; Jovanović, Vojin; Lee, HyoukJoong; Jonnalagedda, Manohar; Olukotun, Kunle; Odersky, Martin

doi:10.1145/2429069.2429128

Cited by 78 publications

(20 citation statements)

References 49 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We have extended LMS with a local control operator, as well as support for 2nd-class continuations that map to labels and goto statements in C. To use these new facilities, we have also modified a pre-existing regexp compiler [Rompf 2016;Rompf et al 2013]. The original version would emit top-level C functions for each DFA state along with a driver loop (Figure 10, left).…”

Section: Discussionmentioning

confidence: 99%

Compiling with continuations, or without? whatever.

Cong

Osvald

Essertel

et al. 2019

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

What makes a good compiler IR? In the context of functional languages, there has been an extensive debate on the advantages and disadvantages of continuation-passing-style (CPS). The consensus seems to be that some form of explicit continuations is necessary to model jumps in a functional style, but that they should have a 2nd-class status, separate from regular functions, to ensure efficient code generation. Building on this observation, a recent study from PLDI 2017 proposed a direct-style IR with explicit join points, which essentially represent local continuations, i.e., functions that do not return or escape. While this IR can work well in practice, as evidenced by the implementation of join points in the Glasgow Haskell Compiler (GHC), there still seems to be room for improvement, especially with regard to the way continuations are handled in the course of optimization. In this paper, we contribute to the CPS debate by developing a novel IR with the following features. First, we integrate a control operator that resembles Felleisen’s C , eliminating certain redundant rewrites observed in the previous study. Second, we treat the non-returning and non-escaping aspects of continuations separately, allowing efficient compilation of well-behaved functions defined by the user. Third, we define a selective CPS translation of our IR, which erases control operators while preserving the meaning and typing of programs. These features enable optimizations in both direct style and full CPS, as well as in any intermediate style with selectively exposed continuations. Thus, we change the spectrum of available options from “CPS yes or no” to “as much or as little CPS as you want, when you want it”.

show abstract

Section: Discussionmentioning

confidence: 99%

Compiling with continuations, or without? whatever.

Cong

Osvald

Essertel

et al. 2019

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

show abstract

“…This process repeats until the centroid values stop changing. Previous work [40,10,13] has shown how to automatically convert applications like k-means into a parallel pattern IR similar to ours as well as perform multiple high-level optimizations automatically on the IR. One of the most important optimizations is fusing patterns together, both vertically (to decrease the reuse distance between producer-consumer relationships) and horizontally (to eliminate redundant traversals over the same domain).…”

Section: Parallel Patternsmentioning

confidence: 92%

Generating Configurable Hardware from Parallel Patterns

Prabhakar

Koeplinger

Brown

et al. 2016

SIGOPS Oper. Syst. Rev.

Self Cite

View full text Add to dashboard Cite

In recent years the computing landscape has seen an increasing shift towards specialized accelerators. Field programmable gate arrays (FPGAs) are particularly promising as they offer significant performance and energy improvements compared to CPUs for a wide class of applications and are far more flexible than fixed-function ASICs. However, FPGAs are difficult to program. Traditional programming models for reconfigurable logic use low-level hardware description languages like Verilog and VHDL, which have none of the productivity features of modern software development languages but produce very efficient designs, and low-level software languages like C and OpenCL coupled with high-level synthesis (HLS) tools that typically produce designs that are far less efficient.Functional languages with parallel patterns are a better fit for hardware generation because they both provide high-level abstractions to programmers with little experience in hardware design and avoid many of the problems faced when generating hardware from imperative languages. In this paper, we identify two optimizations that are important when using parallel patterns to generate hardware: tiling and metapipelining. We present a general representation of tiled parallel patterns, and provide rules for automatically tiling patterns and generating metapipelines. We demonstrate experimentally that these optimizations result in speedups up to 40× on a set of benchmarks from the data analytics domain.

show abstract

“…Rompf et al [27] demonstrate a loop fusion and deforestation algorithm for data parallel loops and traversals. They use staging as a compiler transformation pass and apply to query processing for in-memory objects.…”

Section: Related Workmentioning

confidence: 99%

Stream fusion, to completeness

KiselyovOleg¹,

BiboudisAggelos²,

PalladinosNick³

et al. 2017

SIGPLAN Not.

View full text Add to dashboard Cite

Stream processing is mainstream (again): Widely-used stream libraries are now available for virtually all modern OO and functional languages, from Java to C# to Scala to OCaml to Haskell. Yet expressivity and performance are still lacking. For instance, the popular, well-optimized Java 8 streams do not support the zip operator and are still an order of magnitude slower than hand-written loops. We present the first approach that represents the full generality of stream processing and eliminates overheads, via the use of staging. It is based on an unusually rich semantic model of stream interaction. We support any combination of zipping, nesting (or flat-mapping), sub-ranging, filtering, mapping—of finite or infinite streams. Our model captures idiosyncrasies that a programmer uses in optimizing stream pipelines, such as rate differences and the choice of a “for” vs. “while” loops. Our approach delivers hand-written–like code, but automatically. It explicitly avoids the reliance on black-box optimizers and sufficiently-smart compilers, offering highest, guaranteed and portable performance. Our approach relies on high-level concepts that are then readily mapped into an implementation. Accordingly, we have two distinct implementations: an OCaml stream library, staged via MetaOCaml, and a Scala library for the JVM, staged via LMS. In both cases, we derive libraries richer and simultaneously many tens of times faster than past work. We greatly exceed in performance the standard stream libraries available in Java, Scala and OCaml, including the well-optimized Java 8 streams.

show abstract

Optimizing data structures in high-level programs

Cited by 78 publications

References 49 publications

Compiling with continuations, or without? whatever.

Compiling with continuations, or without? whatever.

Generating Configurable Hardware from Parallel Patterns

Stream fusion, to completeness

Contact Info

Product

Resources

About