[Paper Review] A Simple and Scalable Static Analysis for Bound Analysis and Amortized Complexity Analysis

Moritz Sinn, Florian Zuleger+1 more|arXiv (Cornell University)|Jan 23, 2014

Software Engineering Research3 citations

TL;DR

This paper presents a scalable, static bound analysis for imperative programs that achieves amortized complexity analysis by directly deriving bounds from abstract program models using lossy vector addition systems (VASS). It introduces a novel use of lexicographic ranking functions to capture arithmetic dependencies between components, enabling precise amortized bounds without expensive reasoning tools, and evaluates the approach on a large C benchmark with superior performance and scalability compared to prior tools.

ABSTRACT

We present the first scalable bound analysis that achieves amortized complexity analysis. In contrast to earlier work, our bound analysis is not based on general purpose reasoners such as abstract interpreters, software model checkers or computer algebra tools. Rather, we derive bounds directly from abstract program models, which we obtain from programs by comparatively simple invariant generation and symbolic execution techniques. As a result, we obtain an analysis that is more predictable and more scalable than earlier approaches. Our experiments demonstrate that our analysis is fast and at the same time able to compute bounds for challenging loops in a large real-world benchmark. Technically, our approach is based on lossy vector addition systems (VASS). Our bound analysis first computes a lexicographic ranking function that proves the termination of a VASS, and then derives a bound from this ranking function. Our methodology achieves amortized analysis based on a new insight how lexicographic ranking functions can be used for bound analysis.

Motivation & Objective

• To develop a scalable and predictable static analysis for resource bound and amortized complexity analysis in imperative programs.
• To overcome the limitations of prior approaches relying on general-purpose reasoners like abstract interpreters or computer algebra systems.
• To enable amortized complexity analysis by capturing arithmetic dependencies between components of lexicographic ranking functions.
• To achieve high performance and scalability on real-world C programs through a modular, four-phase analysis pipeline.
• To evaluate the method on a large public benchmark of C programs, demonstrating superior results and speed compared to existing tools.

Proposed method

• The analysis constructs an abstract program model using simple invariant generation and symbolic execution, representing the program as a lossy vector addition system with states (VASS).
• It computes a lexicographic ranking function to prove termination of the VASS, using a novel technique that tracks how changes in one component affect others.
• The bound is derived from the lexicographic ranking function by analyzing the arithmetic dependencies between components, enabling amortized complexity bounds.
• The method is structured into four well-defined phases: program abstraction, control-flow abstraction, lexicographic ranking function generation, and bound computation.
• Path-sensitivity is managed via lightweight path reduction techniques to avoid exponential blowup, unlike prior approaches that compute transitive hulls of inner loops.
• The approach avoids expensive reasoning tools by relying on direct symbolic analysis of the VASS model, enhancing predictability and scalability.

Experimental results

Research questions

• RQ1 Can a static bound analysis achieve amortized complexity analysis without relying on general-purpose reasoners like abstract interpreters or computer algebra systems?
• RQ2 How can lexicographic ranking functions be used to capture arithmetic dependencies between components for precise bound computation?
• RQ3 Can a simple, modular analysis pipeline outperform existing tools in both speed and precision on real-world C programs?
• RQ4 To what extent does the method scale to complex, nested loops with dependent counters and non-trivial control flow?
• RQ5 How effective is the approach on challenging loop categories such as outer-dependent, inner-dependent, and multi-path loops?

Key findings

• The tool analyzed 4,210 loops across 2833 SCCs in under 20 minutes, with only 27 SCCs exceeding 10 seconds of analysis time.
• The approach achieved a 98% success rate in bound computation for loops where termination was proven, demonstrating high reliability.
• For 107 out of 305 loops in the 'Inner Dependent' category, the computed bounds were amortized, showing the method's ability to capture non-trivial complexity behavior.
• The method outperformed the prior tool [27] by an order of magnitude in speed, completing the benchmark in under 20 minutes versus nearly 13 hours.
• The tool achieved 100% success in the 'Outer Dependent' and 'Paths > 1' categories, with success ratios of around 50% in the most challenging categories.
• The analysis successfully computed precise bounds for 12 loops where no other tool could do so, due to their amortized behavior involving counter increments across loop levels.