Quantitative dynamic‐memory analysis for Java

Abstract

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...

A separation logic for heap space under garbage collection

“…For each method, several quantities are characterized via recurrence equations: these include total memory allocation, active memory (memory that is allocated by a method and cannot yet be deallocated when the method exits), and peak heap space consumption. Also in the setting of Java, Braberman et al [2008Braberman et al [ , 2006 and Garbervetsky et al [2011] synthesize a formula that bounds the amount of memory allocated by a method, as a function of its parameters. The placement of deallocation operations is inferred, but is scope-based.…”

On Verifying Resource Contracts using Code Contracts

“…Recently, there were relevant advances in resource analysis for imperative and functional programs [12,8,10,17,5,20,19,21]. Most of them are aimed at inferring of resource consumption bounds rather than verifying them.…”

“…Another approach is trying directly to infer the consumption in those cases. In [10,17] we propose a technique to automatically infer memory consumption bounds on Java like programs. Essentially the technique works as follows: given a method featuring a loop (with possible several nested loops) including a new statement and a predicate describing its iteration space (i.e.…”

Summary-based inference of quantitative bounds of live heap objects

“…Only a few small real-life programs were reported as analyzed in the literature by approaches targeting Java-like languages. Those approaches were based on recurrence equation solving, implemented in Costa [3,6], or on symbolic calculation over iteration spaces, implemented in JConsume [11,21]. Costa translates programs into sets of recurrence equations.…”

“…They both suffer from scalability problems as they cannot even deal with medium-size applications. JConsume has been reported to be able to cope with a few small real-life programs in [21]. However, those examples possibly represent the largest programs which could be successfully handled by that approach with reasonable amount of human effort.…”