Heap space analysis for java bytecode

Abstract

This article presents a heap space analysis for (sequential) Java bytecode. The analysis generates heap space cost relations which define at compile-time the heap consumption of a program as a function of its data size. These relations can be used to obtain upper bounds on the heap space allocated during the execution of the different methods. In addition, we describe how to refine the cost relations, by relying on escape analysis, in order to take into account the heap space that can be safely deallocated by the garbage collector upon exit from a corresponding method. These refined cost relations are then used to infer upper bounds on the active heap space upon methods return. Example applications for the analysis consider inference of constant heap usage and heap usage proportional to the data size (including polynomial and exponential heap consumption). Our prototype implementation is reported and demonstrated by means of a series of examples which illustrate how the analysis naturally encompasses standard data-structures like lists, trees and arrays with several dimensions written in object-oriented programming style.

Resource-Driven CLP-Based Test Case Generation

“…Memory consumption can be estimated by counting the actual size of all objects and arrays created along an execution [3].…”

Live heap space analysis for languages with garbage collection

“…Therefore, it is customary to formalize analyses on intermediate representations of the bytecode (e.g., [3,19,13]). We consider a rule-based procedural language (in the style of any of the above) in which a rule-based program consists of a set of procedures and a set of classes.…”

“…The superscript i on a class c is a unique identifier which associates objects with the program points where they have been created. The key features of this language are: (1) recursion is the only iterative mechanism, (2) guards are the only form of conditional, (3) there is no operand stack, (4) objects can be regarded as records, and the behavior induced by dynamic dispatch in the original bytecode program is compiled into dispatch blocks …”

Finding heap-bounds for hardware synthesis

“…This symbolic bound is expressed as a function on the generic parameters to the circuit description. 1 With our method for computing symbolic bounds we can then automatically translate C programs with dynamic memory usage into equivalent programs that operate over statically allocated arrays. That is, when circuit descriptions are instantiated in their surrounding designs, the symbolic bounds can be used to compute concrete bounds for use during synthesis.…”

“…For imperative programs, [20] develops a type system which tracks memory consumption. The Java memory-bounds tool described in [1] uses a heap abstraction and applies heuristics based on arithmetic simplification to find a memory bound. In contrast, our method uses a more precise numerical abstraction for dealing with heap, as we keep track of the size of intermediate list segments identified by the shape analysis when dissecting the heap, which was crucial for dealing with our examples.…”