Speed

Gulwani, Sumit; Mehra, Krishna K.; Chilimbi, Trishul

doi:10.1145/1480881.1480898

Cited by 138 publications

(11 citation statements)

References 26 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…While previous works present methods for disjunctive polynomial bounds [36] (such as max(0, n) · (1 + max(n, m))), or multivariate polynomial analysis [39], these works do not provide efficient methods to synthesize bounds such as O(n log n) or O(n r ), where r is not an integer.…”

Section: Efficient Methods For Precise Boundsmentioning

confidence: 99%

“…All results were obtained on an Intel i3-4130 CPU 3.4 GHz 8 GB of RAM. [35,36,34]. There are two key differences of our methods as compared to previous works.…”

Section: Theorem 5 Our Algorithm Synalgo Is a Sound Approach For Tmentioning

confidence: 98%

“…Resource Analysis. The use of abstract interpretation and type systems to deal with loop, recursion, data-structures has also been considered [36,1,49], e.g., using linear invariant generation to obtain disjunctive and non-linear bounds [18], potentialbased methods for handling recursion and inductive data structures [39,40]. 3.…”

Section: Introductionmentioning

confidence: 99%

“…However, the problem of deriving precise worst-case bounds is of huge interest in program analysis: (a) first, in applications such as hard real-time systems, guarantees of worst-case behavior are required; and (b) the bounds are useful in early detection of egregious performance problems in large code bases. Works such as [35,36,39,40] provide an excellent motivation for the study of automatic methods to obtain worst-case bounds for programs.…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Non-polynomial Worst-Case Analysis of Recursive Programs

Chatterjee

Goharshady

2017

Computer Aided Verification

View full text Add to dashboard Cite

Abstract. We study the problem of developing efficient approaches for proving worst-case bounds of non-deterministic recursive programs. Ranking functions are sound and complete for proving termination and worst-case bounds of nonrecursive programs. First, we apply ranking functions to recursion, resulting in measure functions. We show that measure functions provide a sound and complete approach to prove worst-case bounds of non-deterministic recursive programs. Our second contribution is the synthesis of measure functions in nonpolynomial forms. We show that non-polynomial measure functions with logarithm and exponentiation can be synthesized through abstraction of logarithmic or exponentiation terms, Farkas' Lemma, and Handelman's Theorem using linear programming. While previous methods obtain worst-case polynomial bounds, our approach can synthesize bounds of the form O(n log n) as well as O(n r ) where r is not an integer. We present experimental results to demonstrate that our approach can obtain efficiently worst-case bounds of classical recursive algorithms such as (i) Merge-Sort, the divide-and-conquer algorithm for the ClosestPair problem, where we obtain O(n log n) worst-case bound, and (ii) Karatsuba's algorithm for polynomial multiplication and Strassen's algorithm for matrix multiplication, where we obtain O(n r ) bound such that r is not an integer and close to the best-known bounds for the respective algorithms.

show abstract

Section: Efficient Methods For Precise Boundsmentioning

confidence: 99%

“…All results were obtained on an Intel i3-4130 CPU 3.4 GHz 8 GB of RAM. [35,36,34]. There are two key differences of our methods as compared to previous works.…”

Section: Theorem 5 Our Algorithm Synalgo Is a Sound Approach For Tmentioning

confidence: 98%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Non-polynomial Worst-Case Analysis of Recursive Programs

Chatterjee

Goharshady

2017

Computer Aided Verification

View full text Add to dashboard Cite

show abstract

“…Abstraction (e.g., making branches non-deterministic by simply hiding the conditionals) is clearly doable, while sophisticated static analysis technology may allow the construction of more precise front ends. Importantly, current static analysis techniques allow for computing loop bounds [1,2,17] and thus transforming an arbitrary loop into our bounded-loop form. These intentions motivate the choice of including nondeterminism in our core language.…”

Section: Introductionmentioning

confidence: 99%

Flowchart Programs, Regular Expressions, and Decidability of Polynomial Growth-Rate

Ben-Amram¹,

Pineles²

2016

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

We present a new method for inferring complexity properties for a class of programs in the form of flowcharts annotated with loop information. Specifically, our method can (soundly and completely) decide if computed values are polynomially bounded as a function of the input; and similarly for the running time. Such complexity properties are undecidable for a Turing-complete programming language, and a common work-around in program analysis is to settle for sound but incomplete solutions. In contrast, we consider a class of programs that is Turing-incomplete, but strong enough to include several challenges for this kind of analysis. For a related language that has well-structured syntax, similar to Meyer and Ritchie's LOOP programs, the problem has been previously proved to be decidable. The analysis relied on the compositionality of programs, hence the challenge in obtaining similar results for flowchart programs with arbitrary control-flow graphs. Our answer to the challenge is twofold: first, we propose a class of loop-annotated flowcharts, which is more general than the class of flowcharts that directly represent structured programs; secondly, we present a technique to reuse the ideas from the work on structured programs and apply them to such flowcharts. The technique is inspired by the classic translation of non-deterministic automata to regular expressions, but we obviate the exponential cost of constructing such an expression, obtaining a polynomial-time analysis. These ideas may well be applicable to other analysis problems.

show abstract

Quantitative dynamic‐memory analysis for Java

Garbervetsky

Yovine

Braberman

et al. 2010

Concurrency and Computation

View full text Add to dashboard Cite

Space-and time-predictability are hard to achieve for object-oriented languages with automated dynamicmemory management. Although there has been significant work to design APIs, such as the Real-Time Specification for Java (RTSJ), and to implement garbage collectors to enable real-time performance, quantitative space analysis is still in its infancy. This work presents the integration of a series of compiletime analysis techniques to help predicting quantitative memory usage. In particular, we focus on providing tool assistance for identifying RTSJ scoped-memory regions, their sizes, and overall memory usage. First, the tool-suite synthesizes a memory organization where regions are associated with methods. Second, it infers their sizes in parametric closed form in terms of relevant program variables. Third, it exhibits a parametric upper bound on the amount of available free memory required to execute a method. The experiments carried out with a RTSJ benchmark, a real-time aircraft collision detector, show that semiautomatic, tool-assisted generation of scoped-based code is both helpful and doable.An interesting approach to gain control on time and space is to change the memory organization model allocating objects in regions [4,5]. The Real-time Specification for Java (RTSJ) [6] supports application-level region-based memory management through ScopedMemory areas. Under suitable conditions, this environment guarantees both predictable-time operations and predictable-space occupancy at the expense of making programming more difficult. Indeed, complying with RTSJ rules complicates reusing legacy code without careful modification [7]. More importantly in practice, it forces the programmer to adopt new coding habits and to reason in a new paradigm quite different from Java. Moreover, ensuring predictability requires providing upper-bounds of region sizes.This paper presents an integration of a series of techniques and tools into a tool-suite to help developers tackling the aforementioned problems. It also explains how to use it to produce sound and predictable scope-memory managed code from conventional Java code. The tool-suite is meant to be used following the scenario depicted in Figure 1. The basic idea is to follow a two-step approach to assist programmers in generating regions. First, infer memory scopes with the aid of escape analysis [8,9]. Second, fine tune the memory layout by resorting to a region edition tool [10] and explicit program annotations.Furthermore, the tool-chain provides two unique key features, which are independent of the way objects are organized into regions. The first is the ability to produce upper bounds of region sizes as functions of program variables [11]. Such functions are used at runtime to determine the actual sizes of RTSJ memory-scopes. The second is the symbolic over-approximation of the dynamic memory footprint of a method (including its callees) [12]. This enables checking whether the method can be safely executed without running out of memory. That is, the resulting express...

show abstract

Speed

Cited by 138 publications

References 26 publications

Non-polynomial Worst-Case Analysis of Recursive Programs

Non-polynomial Worst-Case Analysis of Recursive Programs

Flowchart Programs, Regular Expressions, and Decidability of Polynomial Growth-Rate

Quantitative dynamic‐memory analysis for Java

Contact Info

Product

Resources

About