[Paper Review] A Complexity Preserving Transformation from Jinja Bytecode to Rewrite Systems

Georg Moser, Michael Schaper|arXiv (Cornell University)|Apr 6, 2012

Algorithms and Data Compression33 references3 citations

TL;DR

This paper presents a complexity-preserving transformation from Jinja Bytecode (JBC) programs to constrained term rewrite systems (cTRSs), using finite computation graphs to represent execution paths. The method ensures that runtime complexity is preserved, enabling automated complexity analysis of imperative JBC programs via established rewrite system techniques, with non-termination preservation as a key corollary.

ABSTRACT

We revisit known transformations from Jinja bytecode to rewrite systems from the viewpoint of runtime complexity. Suitably generalising the constructions proposed in the literature, we define an alternative representation of Jinja bytecode (JBC) executions as "computation graphs" from which we obtain a novel representation of JBC executions as "constrained rewrite systems". We prove non-termination and complexity preservation of the transformation. We restrict to well-formed JBC programs that only make use of non-recursive methods and expect tree-shaped objects as input. Our approach allows for simplified correctness proofs and provides a framework for the combination of the computation graph method with standard techniques from static program analysis like for example "reachability analysis".

Motivation & Objective

• To enable automated static analysis of resource usage in imperative JBC programs using term rewrite systems.
• To address the lack of direct applicability of existing complexity analysis tools to JBC by transforming it into a form amenable to such analysis.
• To ensure that the transformation preserves both runtime complexity and non-termination behavior of JBC programs.
• To provide a modular framework integrating term-based abstraction with standard static analysis techniques like shape analysis.
• To lay the foundation for future complexity analysis of constrained term rewrite systems (cTRSs).

Proposed method

• Constructs a finite computation graph representing all possible execution paths of a JBC program using symbolic execution and widening techniques.
• Introduces a novel abstraction of JVM states to ensure finiteness and correctness of the computation graph.
• Encodes the finite computation graph as a constrained term rewrite system (cTRS), where constraints express relations over program variables.
• Employs a two-stage transformation: first building the computation graph, then encoding it into a cTRS for complexity analysis.
• Relies on external shape analysis (e.g., acyclicity and reachability) to support the construction of the computation graph, making the method modular and extensible.
• Uses term-based abstraction to represent program states and transitions, enabling precise complexity reasoning via rewrite system techniques.

Experimental results

Research questions

• RQ1 Can a finite and complexity-preserving representation of JBC execution be constructed using computation graphs?
• RQ2 Does the transformation from JBC to cTRS preserve runtime complexity and non-termination?
• RQ3 Can the resulting cTRS be used for automated complexity analysis of imperative programs?
• RQ4 How can term-based abstraction be combined with standard static analysis techniques like shape analysis in this context?
• RQ5 What are the theoretical guarantees of the transformation, especially regarding finiteness and correctness?

Key findings

• The transformation from JBC programs to cTRSs is complexity-preserving: the runtime complexity of the original JBC program is bounded by that of the resulting cTRS.
• The computation graph representation is provably finite due to the use of widening in abstract state construction.
• The transformation is non-termination preserving, as proven by contradiction using normal form properties of cTRSs.
• The method allows for the integration of existing shape analysis techniques, improving modularity and reusability of static analysis components.
• The prototype implementation, JaT, successfully analyzes the flatten program and confirms linear runtime complexity using the TCT tool.
• The approach provides a theoretical foundation for extending complexity analysis techniques to cTRSs, though current tools like TCT offer only limited support for cTRSs.