Composition and Reuse with Compiled Domain-Specific Languages

Sujeeth, Arvind K.; Rompf, Tiark; Brown, Kevin; Lee, HyoukJoong; Chafi, Hassan; Popic, Victoria; Wu, Michael C.; Prokopec, Aleksandar; Jovanović, Vojin; Odersky, Martin; Olukotun, Kunle

doi:10.1007/978-3-642-39038-8_3

Cited by 57 publications

(37 citation statements)

References 27 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…DSLs developed through Delite have been shown to perform competitively with hand-optimized C code. For graph processing, the Opti-Graph DSL 23 (embedded in Scala) performs on par with the standalone language Green Marl. Many Scala features are crucial for LMS and Delite to implement compiler optimizations in a modular and extensible way.…”

Section: Resultsmentioning

confidence: 99%

Unifying functional and object-oriented programming with Scala

Odersky

Rompf

2014

Commun. ACM

Self Cite

View full text Add to dashboard Cite

show abstract

Section: Resultsmentioning

confidence: 99%

Unifying functional and object-oriented programming with Scala

Odersky

Rompf

2014

Commun. ACM

Self Cite

View full text Add to dashboard Cite

show abstract

“…To mitigate this, we need principled ways of inter-operating between performanceoriented DSLs. We have recently shown that Delite DSLs can be composed at different granularities by exploiting the common back-end framework [Sujeeth et al 2013b]. However, this composition is limited (for DSLs with restricted semantics, we allow only pipeline composition), and does not address composing DSL front-ends (e.g., grammars or type systems).…”

Section: Discussionmentioning

confidence: 99%

“…Sujeeth et al first presented these DSLs [Sujeeth et al , 2013b; we expand on this discussion by highlighting Delite components that were reused in the implementation of the DSLs and identifying new features that had to be added to the framework to support a particular DSL. We also show how Delite supports implementing nontrivial domain-specific analyses and transformations for OptiMesh.…”

Section: Dslsmentioning

confidence: 99%

“…Delite substantially reduces the burden of developing high-performance DSLs by providing common reusable components that enable DSLs to quickly and efficiently target heterogeneous hardware [Sujeeth et al 2013b]. We present existing Delite DSLs for machine learning (OptiML), data querying (OptiQL), graph analysis (OptiGraph), and mesh computation (OptiMesh).…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Delite

Sujeeth

Brown

Lee

et al. 2014

ACM Trans. Embed. Comput. Syst.

Self Cite

138

View full text Add to dashboard Cite

Developing high-performance software is a difficult task that requires the use of low-level, architecturespecific programming models (e.g., OpenMP for CMPs, CUDA for GPUs, MPI for clusters). It is typically not possible to write a single application that can run efficiently in different environments, leading to multiple versions and increased complexity. Domain-Specific Languages (DSLs) are a promising avenue to enable programmers to use high-level abstractions and still achieve good performance on a variety of hardware. This is possible because DSLs have higher-level semantics and restrictions than general-purpose languages, so DSL compilers can perform higher-level optimization and translation. However, the cost of developing performance-oriented DSLs is a substantial roadblock to their development and adoption. In this article, we present an overview of the Delite compiler framework and the DSLs that have been developed with it. Delite simplifies the process of DSL development by providing common components, like parallel patterns, optimizations, and code generators, that can be reused in DSL implementations. Delite DSLs are embedded in Scala, a general-purpose programming language, but use metaprogramming to construct an Intermediate Representation (IR) of user programs and compile to multiple languages (including C++, CUDA, and OpenCL). DSL programs are automatically parallelized and different parts of the application can run simultaneously on CPUs and GPUs. We present Delite DSLs for machine learning, data querying, graph analysis, and scientific computing and show that they all achieve performance competitive to or exceeding C++ code.

show abstract

“…Other systems include PetaBricks [3], CVXgen [35] and Halide [65,64]. Delite is a compiler framework for embedded DSLs that provides parallelization and heterogeneous code generation on top of LMS [73,13,74,50,82]. Related work on lowlevel systems oriented programming in high-level languages in-cludes [32] and the Singularity operating system [49], the LegoBase database engine [47], and staged parsers for communication protocols [43].…”

Section: Related Workmentioning

confidence: 99%

LMS-Verify: abstraction without regret for verified systems programming

Amin

Rompf

2017

Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages

Self Cite

View full text Add to dashboard Cite

Performance critical software is almost always developed in C, as programmers do not trust high-level languages to deliver the same reliable performance. This is bad because low-level code in unsafe languages attracts security vulnerabilities and because development is far less productive, with PL advances mostly lost on programmers operating under tight performance constraints. Highlevel languages provide memory safety out of the box, but they are deemed too slow and unpredictable for serious system software.Recent years have seen a surge in staging and generative programming: the key idea is to use high-level languages and their abstraction power as glorified macro systems to compose code fragments in first-order, potentially domain-specific, intermediate languages, from which fast C can be emitted. But what about security? Since the end result is still C code, the safety guarantees of the high-level host language are lost.In this paper, we extend this generative approach to emit ACSL specifications along with C code. We demonstrate that staging achieves "abstraction without regret" for verification: we show how high-level programming models, in particular higher-order composable contracts from dynamic languages, can be used at generation time to compose and generate first-order specifications that can be statically checked by existing tools. We also show how type classes can automatically attach invariants to data types, reducing the need for repetitive manual annotations.We evaluate our system on several case studies that varyingly exercise verification of memory safety, overflow safety, and functional correctness. We feature an HTTP parser that is (1) fast (2) high-level: implemented using staged parser combinators (3) secure: with verified memory safety. This result is significant, as input parsing is a key attack vector, and vulnerabilities related to HTTP parsing have been documented in all widely-used web servers.

show abstract

Composition and Reuse with Compiled Domain-Specific Languages

Cited by 57 publications

References 27 publications

Unifying functional and object-oriented programming with Scala

Unifying functional and object-oriented programming with Scala

Delite

LMS-Verify: abstraction without regret for verified systems programming

Contact Info

Product

Resources

About