Functional pearl: a SQL to C compiler in 500 lines of code

RompfTiark,; AminNada,

doi:10.1145/2858949.2784760

Cited by 13 publications

(5 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For example, NbE could be used in the security domain, to automatically remove superfluous security checks performed at runtime by programs written in a security eDSL (e.g., [39]). Similarly, in databases (e.g., [37]), NbE could be used normalize queries written in a higher-order eDSL to achieve elimination of higher-order functions and other intermediate data-structures [15,25].…”

Section: Final Remarksmentioning

confidence: 99%

Practical normalization by evaluation for EDSLs

Valliappan

Russo

Lindley

2021

Proceedings of the 14th ACM SIGPLAN International Symposium on Haskell

View full text Add to dashboard Cite

Embedded domain-specific languages (eDSLs) are typically implemented in a rich host language, such as Haskell, using a combination of deep and shallow embedding techniques. While such a combination enables programmers to exploit the execution mechanism of Haskell to build and specialize eDSL programs, it blurs the distinction between the host language and the eDSL. As a consequence, extension with features such as sums and effects requires a significant amount of ingenuity from the eDSL designer. In this paper, we demonstrate that Normalization by Evaluation (NbE) provides a principled framework for building, extending, and customizing eDSLs. We present a comprehensive treatment of NbE for deeply embedded eDSLs in Haskell that involves a rich set of features such as sums, arrays, exceptions and state, while addressing practical concerns about normalization such as code expansion and the addition of domain-specific features.CCS Concepts: • Software and its engineering → Functional languages.

show abstract

Section: Final Remarksmentioning

confidence: 99%

Practical normalization by evaluation for EDSLs

Valliappan

Russo

Lindley

2021

Proceedings of the 14th ACM SIGPLAN International Symposium on Haskell

View full text Add to dashboard Cite

show abstract

“…The Legobase [39] query compiler is implemented in Scala and uses the lightweight modular staging framework (LMS) [56] to generate optmized C. DBLAB [57] reimplements Legobase and uses multiple compiler passes to compile queries. The LB2 [64] query compiler expanded the work presented in ("SQL to C in 500 lines" [55]) and demonstrated that highly ecient query compilation can be performed eciently in a single compiler pass. LB2-Graph [66] supports compiling graph workloads in LB2.…”

Section: Related Workmentioning

confidence: 99%

Architecting a Query Compiler for Spatial Workloads

Tahboub

Rompf

2020

Proceedings of the 2020 ACM SIGMOD International Conference on Management of Data

Self Cite

View full text Add to dashboard Cite

Modern location-based applications rely extensively on the ecient processing of spatial data and queries. Spatial query engines are commonly engineered as an extension to a relational database or a cluster-computing framework. Large parts of the spatial processing runtime is spent on evaluating spatial predicates and traversing spatial indexing structures. Typical high-level implementations of these spatial structures incur signicant interpretive overhead, which increases latency and lowers throughput. A promising idea to improve the performance of spatial workloads is to leverage native code generation techniques that have become popular in relational query engines. However, architecting a spatial query compiler is challenging since spatial processing has fundamentally dierent execution characteristics from relational workloads in terms of data dimensionality, indexing structures, and predicate evaluation.In this paper, we discuss the underlying reasons why standard query compilation techniques are not fully eective when applied to spatial workloads, and we demonstrate how a particular style of query compilation based on techniques borrowed from partial evaluation and generative programming manages to avoid most of these diculties by extending the scope of custom code generation into the data structures layer. We extend the LB2 main-memory query compiler, a relational engine developed in this style, with spatial data types, predicates, indexing structures, and operators. We show that the spatial extension matches the performance of specialized library code and outperforms relational and map-reduce extensions.

show abstract

“…LMS draws inspiration from earlier work such as TaskGraph [Beckmann et al 2003], a C++ framework for program generation and optimization. LMS has been used in a variety of applications, ranging from web programming [Kossakowski et al 2012] over domain-specific languages for machine learning ] to database engines [Rompf and Amin 2015] and distributed systems [Ackermann et al 2012].…”

Section: Related Workmentioning

confidence: 99%

Collapsing towers of interpreters

Amin

Rompf

2017

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

Given a tower of interpreters, i.e., a sequence of multiple interpreters interpreting one another as input programs, we aim to collapse this tower into a compiler that removes all interpretive overhead and runs in a single pass. In the real world, a use case might be Python code executed by an x86 runtime, on a CPU emulated in a JavaScript VM, running on an ARM CPU. Collapsing such a tower can not only exponentially improve runtime performance, but also enable the use of base-language tools for interpreted programs, e.g., for analysis and verification. In this paper, we lay the foundations in an idealized but realistic setting. We present a multi-level lambda calculus that features staging constructs and stage polymorphism: based on runtime parameters, an evaluator either executes source code (thereby acting as an interpreter) or generates code (thereby acting as a compiler). We identify stage polymorphism, a programming model from the domain of high-performance program generators, as the key mechanism to make such interpreters compose in a collapsible way. We present Pink, a meta-circular Lisp-like evaluator on top of this calculus, and demonstrate that we can collapse arbitrarily many levels of self-interpretation, including levels with semantic modifications. We discuss several examples: compiling regular expressions through an interpreter to base code, building program transformers from modified interpreters, and others. We develop these ideas further to include reflection and reification, culminating in Purple, a reflective language inspired by Brown, Blond, and Black, which realizes a conceptually infinite tower, where every aspect of the semantics can change dynamically. Addressing an open challenge, we show how user programs can be compiled and recompiled under user-modified semantics.

show abstract

Functional pearl: a SQL to C compiler in 500 lines of code

Cited by 13 publications

References 22 publications

Practical normalization by evaluation for EDSLs

Practical normalization by evaluation for EDSLs

Architecting a Query Compiler for Spatial Workloads

Collapsing towers of interpreters

Contact Info

Product

Resources

About