Type-Based Cost Analysis for Lazy Functional Languages

Jost, Steffen; Vasconcelos, Pedro; Florido, Mário; Hammond, Kevin

doi:10.1007/s10817-016-9398-9

Cited by 21 publications

(51 citation statements)

References 29 publications

(61 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In this paper, we have presented an automated amortized analysis on the resource usage of Haskell programs. Our work is based on a previous paper by Jost et al [9], which proposed a type-based analysis on an artificial language called JVFH. We use the plugin API of the GHC compiler to translate any given Haskell code into a heavily simplified representation called GHC Core.…”

Section: Resultsmentioning

confidence: 99%

Type-Based Resource Analysis on Haskell

Siglmüller

2019

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

We propose an amortized analysis that approximates the resource usage of a Haskell expression. Using the plugin API of GHC, we convert the Haskell code into a simplified representation called GHC Core. We then apply a type-based system which derives linear upper bounds on the resource usage. This setup allows us to analyze actual Haskell code, whereas previous implementations of similar analyses do not support any commonly used lazy functional programming languages.

show abstract

Section: Resultsmentioning

confidence: 99%

Type-Based Resource Analysis on Haskell

Siglmüller

2019

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…This is achieved using a type system that generates resource-specific inequalities to be solved by a linear programming solver. The initial system [2003] supports linear bounds on monomorphic, first-order programs but this has since been generalised to incorporate polynomial bounds [Hoffmann et al 2011[Hoffmann et al , 2012, higher-order functions [Jost et al 2010], parallelism [Hoffmann and Shao 2015], and most recently, a Haskell-like lazy semantics [Jost et al 2017]. As AARA focuses on automatically inferring bounds, its analysis is often less precise than ours.…”

Section: Related Workmentioning

confidence: 99%

“…Unfortunately, however, performance bugs are as difficult to detect as they are common [Jin et al 2012]. As a result, the problem of statically analysing the resource usage, or execution cost, of programs has been subject to much research in which a broad range of techniques have been studied, including resource-aware type systems [Çiçek et al 2017;Hoffmann et al 2012;Hofmann and Jost 2003;Jost et al 2017;Wang et al 2017], program and separation logics [Aspinall et al 2007;Atkey 2010], and sized types [Vasconcelos 2008].…”

Section: Introductionmentioning

confidence: 99%

Liquidate your assets: reasoning about resource usage in liquid Haskell

Handley

Vazou

Hutton

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Liquid Haskell is an extension to the type system of Haskell that supports formal reasoning about program correctness by encoding logical properties as refinement types. In this article, we show how Liquid Haskell can also be used to reason about program efficiency in the same setting. We use the system's existing verification machinery to ensure that the results of our cost analysis are valid, together with custom invariants for particular program contexts to ensure that the results of our analysis are precise. To illustrate our approach, we analyse the efficiency of a wide range of popular data structures and algorithms, and in doing so, explore various notions of resource usage. Our experience is that reasoning about efficiency in Liquid Haskell is often just as simple as reasoning about correctness, and that the two can naturally be combined.In this article, we take inspiration from [Radiček et al. 2018] and implement a monadic datatype to measure the abstract resource usage of pure Haskell programs. We then use Liquid Haskell's [Vazou 2016] refinement type system to statically prove bounds on resource usage. Our framework supports the standard approach to cost analysis, which is known as unary cost analysis and aims to establish upper and lower bounds on the execution cost of a single program, together with the more recent relational approach [Çiçek 2018], which aims to calculate the difference between the execution costs of two related programs or between one program on two different inputs.Reasoning about execution cost using the Liquid Haskell system has two main advantages over most other formal cost analysis frameworks [Radiček et al. 2018]. First of all, the system allows correctness properties to be naturally integrated into cost analysis, which helps to ensure that cost analyses are valid. And secondly, the wide range of sophisticated invariants that can be expressed and automatically verified by the system can be exploited to analyse resource usage in particular program contexts, which often leads to more precise and/or simpler analyses.By way of example, Liquid Haskell can automatically verify that Haskell's standard sort function returns an ordered list (of type OList a) with the same length as its input, even when the result is embedded in the Tick datatype that we use to measure resource usage: sort :: Ord a => xs:[a] → Tick { zs:OList a | length zs == length xs } Applying our cost analysis to this function then allows us to prove that the maximum number of comparisons required to sort any list xs is O(n log n), where n = lenдth xs: sortCost :: Ord a => xs:[a] → { tcost (sort xs) <= 4 * length xs * log 2 (length xs) + length xs } Moreover, we can also combine correctness and resource properties to show that the maximum number of comparisons becomes linear when the input list is already sorted: sortCostSorted :: Ord a => xs:OList a → { tcost (sort xs) <= length xs }The aim of this article is to develop, prove correct, and evaluate a system that supports the above form of reasoning. To this end, t...

show abstract

“…Our embedding of RAML in R C shows that R C is more expressive, but R C is a proof framework, not an automated system. Jost et al [2017] extend amortized analysis to lazy semantics (Haskell). They specifically focus on co-inductive definitions.…”

Section: Related Workmentioning

confidence: 99%

Monadic refinements for relational cost analysis

Radiček

Barthe

Gaboardi

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Formal frameworks for cost analysis of programs have been widely studied in the unary setting and, to a limited extent, in the relational setting. However, many of these frameworks focus only on the cost aspect, largely side-lining functional properties that are often a prerequisite for cost analysis, thus leaving many interesting programs out of their purview. In this paper, we show that elegant, simple, expressive proof systems combining cost analysis and functional properties can be built by combining already known ingredients: higher-order refinements and cost monads. Specifically, we derive two syntax-directed proof systems, U C and R C , for unary and relational cost analysis, by adding a cost monad to a (syntax-directed) logic of higher-order programs. We study the metatheory of the systems, show that several nontrivial examples can be verified in them, and prove that existing frameworks for cost analysis (RelCost and RAML) can be embedded in them.

show abstract

Type-Based Cost Analysis for Lazy Functional Languages

Cited by 21 publications

References 29 publications

Type-Based Resource Analysis on Haskell

Type-Based Resource Analysis on Haskell

Liquidate your assets: reasoning about resource usage in liquid Haskell

Monadic refinements for relational cost analysis

Contact Info

Product

Resources

About