On the Inference of Resource Usage Upper and Lower Bounds

Albert, Elvira; Genaim, Samir; Masud, Abu Naser

doi:10.1145/2499937.2499943

Cited by 36 publications

(47 citation statements)

References 33 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This substitution instantiates every variable i ∈ V by the arithmetic expression t i . Furthermore, it maps each 3 x ∈ V \ to x, i.e., the domain of σ is dom(σ ) = { i | 1 ≤ i ≤ k, i t i } and its range is {xσ | x ∈ dom(σ )}. Substitutions are homomorphically extended to terms (i.e., σ (t) instantiates all variables x in the term t by σ (x)) and we usually write tσ instead of σ (t).…”

Section: Program Modelmentioning

confidence: 99%

See 1 more Smart Citation

Lower Runtime Bounds for Integer Programs

Frohn

Naaf

Hensel

et al. 2016

Automated Reasoning

View full text Add to dashboard Cite

We present a technique to infer lower bounds on the worst-case runtime complexity of integer programs, where in contrast to earlier work, our approach is not restricted to tail-recursion. Our technique constructs symbolic representations of program executions using a framework for iterative, under-approximating program simplification. The core of this simplification is a method for (under-approximating) program acceleration based on recurrence solving and a variation of ranking functions. Afterwards, we deduce asymptotic lower bounds from the resulting simplified programs using a special-purpose calculus and an SMT encoding. We implemented our technique in our tool LoAT and show that it infers non-trivial lower bounds for a large class of examples.

show abstract

Section: Program Modelmentioning

confidence: 99%

“…In [24], the automation of this check has not been discussed. (3) We lift our approach to non-tail-recursive programs in the new Section 4. In contrast, [24] was restricted to tail-recursive integer programs.…”

Section: Introductionmentioning

confidence: 99%

Lower Runtime Bounds for Integer Programs

Frohn

Naaf

Hensel

et al. 2016

Automated Reasoning

View full text Add to dashboard Cite

show abstract

“…For example, for SPEED [23], one would need to verify the correctness of the generated invariants, while using other techniques to verify the implementation of the other parts, e.g., the implementation of the counter-optimal proof-structure procedure. As another example, we consider the extension of costa, described in [11], to handle cases where the cost can be precisely described using a sum such as n i=0 i. In this case, the algorithm for computing the UB is based on using the ranking functions and invariants to first generate recurrence relations and then solve them using computer algebra systems.…”

Section: Discussionmentioning

confidence: 99%

A formal verification framework for static analysis

et al. 2015

Self Cite

View full text Add to dashboard Cite

Static analysis tools, such as resource analyzers, give useful information on software systems, especially in real-time and safety-critical applications. Therefore, the question of the reliability of the obtained results is highly important. State-of-the-art static analyzers typically combine a range of complex techniques, make use of external tools, and evolve quickly. To formally verify such systems is not a realistic option. In this work, we propose a different approach whereby, instead of the tools, we formally verify the results of the tools. The central idea of such a formal verification framework for static analysis is the method-wise translation of the information about a program gathered durCommunicated by Prof. Einar Broch Johnsen and Luigia Petre. This work is a revised and extended version of two conference papers published in the proceedings of PEPM'11 [8] and FASE'12 [9].B ing its static analysis into specification contracts that contain enough information for them to be verified automatically. We instantiate this framework with costa, a state-of-theart static analysis system for sequential Java programs, for producing resource guarantees and KeY, a state-of-the-art verification tool, for formally verifying the correctness of such resource guarantees. Resource guarantees allow to be certain that programs will run within the indicated amount of resources, which may refer to memory consumption, number of instructions executed, etc. Our results show that the proposed tool cooperation can be used for automatically producing verified resource guarantees.

show abstract

“…There is a long history of techniques for extracting cost information from programs, probably starting with Wegbreit [1975], who computes closed bounds for Lisp programs. Much of the work has been done for imperative languages, as exemplified by the COSTA project for Java bytecode analysis [Albert et al 2012[Albert et al , 2013 and SACO for parallel cost [Albert et al 2018]. We cannot hope to review the entire field here, so concentrate on recent work on cost analysis for functional programs.…”

Section: Related Workmentioning

confidence: 99%

Recurrence extraction for functional programs through call-by-push-value

Kavvos

Morehouse

Licata

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

The main way of analyzing the complexity of a program is that of extracting and solving a recurrence that expresses its running time in terms of the size of its input. We develop a method that automatically extracts such recurrences from the syntax of higher-order recursive functional programs. The resulting recurrences, which are programs in a call-by-name language with recursion, explicitly compute the running time in terms of the size of the input. In order to achieve this in a uniform way that covers both call-by-name and call-by-value evaluation strategies, we use Call-by-Push-Value (CBPV) as an intermediate language. Finally, we use domain theory to develop a denotational cost semantics for the resulting recurrences. Recurrence Extraction for Functional Programs through Call-by-Push-Value (Extended Version) 15:3 A for the (open and closed) terms of PCF of type A, and V PCF A for the CBV canonical forms of type A.Our natural numbers are introduced by constants 0, 1, . . . and correspond to eager, rather than lazy, natural numbers. Instead of the usual predecessor and successor functions, we introduce five arithmetic operations on natural numbers, as well as the zero test if N then P else Q, which behaves like P if N is 0, and like Q otherwise. This choice of primitives gives them the flavor of machine words. We sometimes refer to these as "flat" natural numbers, as they admit a domain interpretation with a flat information order (bottom below all numerals, and no other relations).The terms of the CBN and the CBV variants differ only on fixed points. In the case of CBN we may take fixed points at every type: if we have M : A in terms of x : A, we may construct fix x . M : A. However, in CBV we are only allowed to take fixed points at function types, i.e. to

show abstract

On the Inference of Resource Usage Upper and Lower Bounds

Cited by 36 publications

References 33 publications

Lower Runtime Bounds for Integer Programs

Lower Runtime Bounds for Integer Programs

A formal verification framework for static analysis

Recurrence extraction for functional programs through call-by-push-value

Contact Info

Product

Resources

About