Efficient strictness analysis of Haskell

Jensen, Kristian; Hjæresen, Peter; Rosendahl, Mads

doi:10.1007/3-540-58485-4_51

Cited by 5 publications

(2 citation statements)

References 10 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The analysis takes an abstract interpretation approach over an abstract representation derived from ANormLazy called AbsCore. Our initial implementation uses a relatively simple algorithm described by Peyton Jones and Partain [22], but we hope at some point to replace it with a more complex algorithm such as that used by Jensen et al [12] to better handle higher-order functions. This optimization has proved less effective than we had hoped, but we continue to feel that there are opportunities to be had in this domain, in part because of our experiences with simple ad hoc strictness analyses performed in later phases of the compiler.…”

Section: Strictness Analysismentioning

confidence: 99%

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: Strictness Analysismentioning

confidence: 99%

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

“…For a number of years the implementation of higher-order strictness analysis on non-flat domains [5,16,25] has been a benchmark for how well different techniques perform. In a previous work [18] we constructed a strictness analysis for Haskell. It had some very attractive properties both regarding speed and precision.…”

Section: Introductionmentioning

confidence: 99%

Abstract Interpretation as a Programming Language

Rosendahl

2013

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

In David Schmidt's PhD work he explored the use of denotational semantics as a programming language. It was part of an effort to not only treat formal semantics as specifications but also as interpreters and input to compiler generators. The semantics itself can be seen as a program and one may examine different programming styles and ways to represent states. Abstract interpretation is primarily a technique for derivation and specification of program analysis. As with denotational semantics we may also view abstract interpretations as programs and examine the implementation. The main focus in this paper is to show that results from higher-order strictness analysis may be used more generally as fixpoint operators for higher-order functions over lattices and thus provide a technique for immediate implementation of a large class of abstract interpretations. Furthermore, it may be seen as a programming paradigm and be used to write programs in a circular style

show abstract