Efficient communication and collection with compact normal forms

Yang, Emily; Campagna, G.; Ağacan, Ömer S.; El-Hassany, Ahmed; Kulkarni, Abhishek; Newton, Ryan

doi:10.1145/2784731.2784735

Cited by 7 publications

(6 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…• We present a strategy for synthesizing LoCal programs from a first-order, purely-functional input language, HiCal (the front-end for our Gibbon compiler), and redesign our compiler around LoCal ( §5). • We evaluate our compiler pipeline against approaches for working with serialized binary data, including Compact Normal Form [32], Cap'N Proto, and prior Gibbon [29] ( §7). Our pipeline achieves 3.2×, 9.4×, and 202× geomean speedups respectively (Table 2), including asymptotic advantages, and substantial speedups in IO-intensive experiments.…”

Section: Introductionmentioning

confidence: 99%

LoCal: a language for programs operating on serialized data

Vollmer

Koparkar

Rainey

et al. 2019

Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation

Self Cite

View full text Add to dashboard Cite

In a typical data-processing program, the representation of data in memory is distinct from its representation in a serialized form on disk. The former has pointers and arbitrary, sparse layout, facilitating easy manipulation by a program, while the latter is packed contiguously, facilitating easy I/O. We propose a language, LoCal, to unify in-memory and serialized formats. LoCal extends a region calculus into a location calculus, employing a type system that tracks the byte-addressed layout of all heap values. We formalize LoCal and prove type safety, and show how LoCal programs can be inferred from unannotated source terms.We transform the existing Gibbon compiler to use LoCal as an intermediate language, with the goal of achieving a balance between code speed and data compactness by introducing just enough indirection into heap layouts, preserving the asymptotic complexity of traditional representations, but working with mostly or completely serialized data. We show that our approach yields significant performance improvement over prior approaches to operating on packed data, without abandoning idiomatic programming with recursive functions.CCS Concepts • Software and its engineering → Formal language definitions; Compilers.

show abstract

Section: Introductionmentioning

confidence: 99%

LoCal: a language for programs operating on serialized data

Vollmer

Koparkar

Rainey

et al. 2019

Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation

Self Cite

View full text Add to dashboard Cite

show abstract

“…All memory objects in PM are stored in their native closure layout and can be directly accessed, so that data does not have to be serialized before it is copied to PM. This native closure layout contains pointers to code in the statically-linked binary, which currently restricts PM structures to be used by a single application [Berthold 2010;Yang et al 2015]. To support multiple binaries the code needs to be shared between them, e.g.…”

Section: Persistent Heap and Automatic Memory Managementmentioning

confidence: 99%

Persistent software transactional memory in Haskell

Krauter

Raaf

Braam

et al. 2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Emerging persistent memory in commodity hardware allows byte-granular accesses to persistent state at memory speeds. However, to prevent inconsistent state in persistent memory due to unexpected system failures, different write-semantics are required compared to volatile memory. Transaction-based library solutions for persistent memory facilitate the atomic modification of persistent data in languages where memory is explicitly managed by the programmer, such as C/C++. For languages that provide extended capabilities like automatic memory management, a more native integration into the language is needed to maintain the high level of memory abstraction. It is shown in this paper how persistent software transactional memory (PSTM) can be tightly integrated into the runtime system of Haskell to atomically manage values of persistent transactional data types. PSTM has a clear interface and semantics extending that of software transactional memory (STM). Its integration with the language’s memory management retains features like garbage collection and allocation strategies, and is fully compatible with Haskell's lazy execution model. Our PSTM implementation demonstrates competitive performance with low level libraries and trivial portability of existing STM libraries to PSTM. The implementation allows further interesting use cases, such as persistent memoization and persistent Haskell expressions.

show abstract

“…Work on more general approaches for packing recursive structures into buffers includes Cap'N Proto [Varda 2015], which attempts to unify on-disk and in-memory representations of data structures, and Compact Normal Form (CNF) [Yang et al 2015]. Neither of these approaches have the same design goals as LoCal and LoCal par : both Cap'N Proto and CNF preserve internal pointers in their representations, eliding the problem of parallel access by invariably paying the cost (in memory consumption and lost spatial locality) of maintaining those pointers.…”

Section: Related Workmentioning

confidence: 99%

“…Representing tree-like data as pointer-free, serialized byte arrays can be extremely efficient for tree traversals, as it minimizes pointer-chasing and maximizes locality [Goldfarb et al 2013;Makino 1990;Meyerovich et al 2011]. Moreover, by using an in-memory representation also suitable for external transfer and storage [Varda 2015;Yang et al 2015], programs can rapidly process data without the overhead of deserialization. Traditionally, any such tree-layout optimizations would be implemented manually by the programmer-for example, in a scientific application with balanced trees.…”

Section: Introductionmentioning

confidence: 99%

Efficient Tree-Traversals: Reconciling Parallelism and Dense Data Representations

Koparkar¹,

Rainey²,

Vollmer³

et al. 2021

Preprint

Self Cite

View full text Add to dashboard Cite

Recent work showed that compiling functional programs to use dense, serialized memory representations for recursive algebraic datatypes can yield significant constant-factor speedups for sequential programs. But serializing data in a maximally dense format consequently serializes the processing of that data, yielding a tension between density and parallelism. This paper shows that a disciplined, practical compromise is possible. We present Parallel Gibbon, a compiler that obtains the benefits of dense data formats and parallelism. We formalize the semantics of the parallel location calculus underpinning this novel implementation strategy, and show that it is type-safe. Parallel Gibbon exceeds the parallel performance of existing compilers for purely functional programs that use recursive algebraic datatypes, including, notably, abstract-syntax-tree traversals as in compilers. * Extended version of "Efficient Tree-Traversals: Reconciling Parallelism and Dense Data Representations, " [Koparkar et al.

show abstract

Efficient communication and collection with compact normal forms

Cited by 7 publications

References 30 publications

LoCal: a language for programs operating on serialized data

LoCal: a language for programs operating on serialized data

Persistent software transactional memory in Haskell

Efficient Tree-Traversals: Reconciling Parallelism and Dense Data Representations

Contact Info

Product

Resources

About