Arity Raising in Manticore

Bergström, Lars; Reppy, John

doi:10.1007/978-3-642-16478-1_6

Cited by 4 publications

(7 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…We have some quantitative evidence in particular for the latter in that benchmarks on the left side of the graph tend to be particularly sensitive to thunk-representation choice (we have several such choices). We believe that a more sophisticated approach to elimi- nating currying [5] than we have so far attempted might help. There is also some room for improvement in our thunk representation.…”

Section: Performancementioning

confidence: 94%

“…This approach was easy to implement and gave good improvements in runtime. However, the overhead of curried functions continue to be an issue in some benchmarks, suggesting that more sophisticated controlflow analysis based techniques [5] might be beneficial (either at the ANormStrict level, or in MIL). We have also considered experimenting with dynamic techniques such as those described by Marlow and Peyton Jones [15], but would prefer to explore static options first, since dynamic options impose an overhead even when they are not used.…”

Section: Anormstrict Optimizationsmentioning

confidence: 97%

See 1 more Smart Citation

The Intel labs Haskell research compiler

Liu

Glew

Petersen

et al. 2013

Proceedings of the 2013 ACM SIGPLAN Symposium on Haskell

View full text Add to dashboard Cite

The Glasgow Haskell Compiler (GHC) is a well supported optimizing compiler for the Haskell programming language, along with its own extensions to the language and libraries. Haskell's lazy semantics imposes a runtime model which is in general difficult to implement efficiently. GHC achieves good performance across a wide variety of programs via aggressive optimization taking advantage of the lack of side effects, and by targeting a carefully tuned virtual machine. The Intel Labs Haskell Research Compiler uses GHC as a frontend, but provides a new whole-program optimizing backend by compiling the GHC intermediate representation to a relatively generic functional language compilation platform. We found that GHC's external Core language was relatively easy to use, but reusing GHC's libraries and achieving full compatibility were harder. For certain classes of programs, our platform provides substantial performance benefits over GHC alone, performing 2× faster than GHC with the LLVM backend on selected modern performance-oriented benchmarks; for other classes of programs, the benefits of GHC's tuned virtual machine continue to outweigh the benefits of more aggressive whole program optimization. Overall we achieve parity with GHC with the LLVM backend. In this paper, we describe our Haskell compiler stack, its implementation and optimization approach, and present benchmark results comparing it to GHC.

show abstract

Section: Performancementioning

confidence: 94%

Section: Anormstrict Optimizationsmentioning

confidence: 97%

The Intel labs Haskell research compiler

Liu

Glew

Petersen

et al. 2013

Proceedings of the 2013 ACM SIGPLAN Symposium on Haskell

View full text Add to dashboard Cite

show abstract

“…We support the parallelism and concurrency features of PML by transformations on the AST and BOM representations that introduce explicit continuation binders [15,16,4,25]. The translation from BOM to CPS uses the Danvy-Filinski CPS transformation [7] and we perform several kinds of optimizations on the CPS IR [5,3]. The conversion from CPS to CFG uses a flat, safe-for-space, closure representation [6].…”

Section: The Pml Compilermentioning

confidence: 99%

“…We also hand-crafted two sequences of LLVM optimization passes, using trial-and-error guided by intuition, 5 to simplify the LLVM program output by the PML compiler. Crafting a custom pass sequence is recommended for compiler frontends that target LLVM, as the default "-Ox" passes are tuned for a C/C++ frontend [9].…”

Section: Llvm Optimizationsmentioning

confidence: 99%

Compiling with Continuations and LLVM

Farvardin

Reppy

2018

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

LLVM is an infrastructure for code generation and low-level optimizations, which has been gaining popularity as a backend for both research and industrial compilers, including many compilers for functional languages. While LLVM provides a relatively easy path to high-quality native code, its design is based on a traditional runtime model which is not well suited to alternative compilation strategies used in high-level language compilers, such as the use of heap-allocated continuation closures.This paper describes a new LLVM-based backend that supports heap-allocated continuation closures, which enables constant-time callcc and very-lightweight multithreading. The backend has been implemented in the Parallel ML compiler, which is part of the Manticore system, but the results should be useful for other compilers, such as Standard ML of New Jersey, that use heap-allocated continuation closures.

show abstract

“…Variants of normalization (also known as scalar replacement of aggregates or flattening) have been employed in numerous functional language implementations, e.g. [3] and [36]. Reducing tuples to individual scalar values simplifies the program to a normal form where tuples no longer appear and exposes the individual values to classical compiler optimizations.…”

Section: Normalizationmentioning

confidence: 99%

Harmonizing classes, functions, tuples, and type parameters in virgil iii

Titzer

2013

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

View full text Add to dashboard Cite

Languages are becoming increasingly multi-paradigm. Subtype polymorphism in statically-typed object-oriented languages is being supplemented with parametric polymorphism in the form of generics. Features like first-class functions and lambdas are appearing everywhere. Yet existing languages like Java, C#, C++, D, and Scala seem to accrete ever more complexity when they reach beyond their original paradigm into another; inevitably older features have some rough edges that lead to nonuniformity and pitfalls. Given a fresh start, a new language designer is faced with a daunting array of potential features. Where to start? What is important to get right first, and what can be added later? What features must work together, and what features are orthogonal? We report on our experience with Virgil III, a practical language with a careful balance of classes, functions, tuples and type parameters. Virgil intentionally lacks many advanced features, yet we find its core feature set enables new species of design patterns that bridge multiple paradigms and emulate features not directly supported such as interfaces, abstract data types, ad hoc polymorphism, and variant types. Surprisingly, we find variance for function types and tuple types often replaces the need for other kinds of type variance when libraries are designed in a more functional style.

show abstract

Arity Raising in Manticore

Cited by 4 publications

References 18 publications

The Intel labs Haskell research compiler

The Intel labs Haskell research compiler

Compiling with Continuations and LLVM

Harmonizing classes, functions, tuples, and type parameters in virgil iii

Contact Info

Product

Resources

About