Identifying Logically Related Regions of the Heap

Identifying Logically Related Regions of the Heap Mark Marron1, Deepak Kapur2, Manuel Hermenegildo1 1Imdea-Software (Spain) 2University of New Mexico

Overview • Want to identify regions (sets of objects) that are conceptually related • Conceptually related • Same recursive data structure • Stored in equivalent locations (e.g., same array) • Extract information via static analysis • Apply memory optimizations on regions instead of over entire heap • Region Allocation/Collection • Region/Parallel GC • Optimized Layout

Region Representation • Must be Dynamic • Variable based partitions too coarse, do not represent composition well. • Allocation site based too imprecise, can cause spurious grouping of objects. • Must be Repartitionable • Want to track program splitting and merging regions: list append, subset operations.

Explicit Representation Model • Base on storage shape graph • Nodes represent sets of objects (or recursive data structures), edges represent sets of pointers • Has natural representation heap regions and relations between them • Efficient • Annotate nodes and edges with additional instrumentation properties • For region identification only need type information

Region Concepts • Recursive Structures • Group objects representing same recursive structure, keep distinct from other recursive structures • References • Group objects stored in similar sets of locations together (objects in A, in B, both A and B) • Composite Structures • Group objects in each subcomponent, group similar components hierarchically

Recursive Structures • The general approach taken to Identifying Recursive Data Structures is well known • Look at type information to determine which objects may be part of a recursive structure • Based on connectivity group these recursive objects together • Two subtle distinctions made in this work • Only group objects in complete recursive structure • Ignore back pointers in computing complete recursive structures

Em3d: Back Edges class Enode { Enode[] fromN; … }

Composite Struct./Containers • The grouping of objects that are in the same container or related composite structures is more difficult • Given regions R, R’ when do they represent conceptually equivalent sets of objects • Stored in the same types of locations (variables, collections, referred to by same object fields) • Have same type of recursive signature (can split leaf contents of recursive structures from internal recursive component)

Storage Location Similarity

Case Study BH (Barnes-Hut) • N-Body Simulation in 3-dimensions • Uses Fast Multi-Pole method with space decomposition tree • For nearby bodies use naive n2 algorithm • For distant bodies compute center of mass of many bodies and treat as single point mass

Main Execution Loop for(…) { root = null; makeTree(); Iterator<Body> bm = this.bodyTabRev.iterator(); while(bm.hasNext()) bm.next().hackGravity(root); Iterator<Body> bp = this.bodyTabRev.iterator(); while(bm.hasNext()) bm.next().propUpdatedAccel(); }

Static Collection: root = null • Statically collect, space decomposition tree and all MathVector/double[] objects (11% of GC work).

Parallel Collection: hackGravity • GC objects reachable from the acc/vel fields in parallel with the hackGravity method (no overhead).

Object Inline • Inline Double[] into MathVectorobjects, 23% serial speedup 37% memory use reduction.

Benchmark Analysis Statistics

Debug Benchmark • Simple interpreter and debug environment for large subset of Java language • 14,000+ Loc (in normalized form), 90 Classes • Additional 1500 Loc for specialized standard library handling stubs. • Large recursive call structures, large inheritance trees with numerous virtual method implementations • Wide range of data structure types, extensive use of java.util collections, heap contains both shared and unshared structures.

Conclusion and Future Work • Region Information provides excellent basis for driving many memory optimizations and supporting other analysis work • A simple set of heuristics (when taking into account a few subtleties) is sufficient for grouping memory objects • Recent work shows excellent scalability on non-trivial programs • Further work on developing robust infrastructure for further evaluation and applications

Back Pointers + Partial Strucures • Many programs (particularly OO programs) use back pointers to parent objects • Makes type recursive even though structure is finite • Can lead to grouping many structures that are conceptually distinct in the program • Simply ignore them based on depth from roots • Similarly want to wait until structures are finished before merging them • Preserves analysis precision during construction of recursive structures • Prevents grouping of objects that have recursive types but are used in finite heap structures

General Approach • Using heuristics based on declared type information and connectivity group • Objects that make up recursive data structures • Objects that are stored in the same sets of containers (arrays, java.util collections) • Objects that are in the same kind of composite structure • Use incremental approach to identify these structures (for efficiency in dataflow analysis)

Example: Arithmatic Exp. exp Heap vars

Example: Arithmatic Exp. exp {+, -, *, /} {Var} {Const} {Var[]} vars

Example: Exp

Merge nodes 2 and 5

Finish Recursive Merge

Merge Edges 9 and 6

Merge Nodes 7 and 8

Wrap-Up and Future Work • We have the core of a practical heap analysis technique • Performance: • Analyze moderate size non-trivial Java programs • Runtime on the order of 10s of seconds • Recent work should improve scalability • Accuracy: • Precisely represent connectivity, sharing, shape properties + region and dependence information • Qualitatively Useful • Used results in multiple optimization domains • Want to apply tool to other problems, work on improvements in frontend, IR and exporting results

Demo of the shape analysis and benchmark code available at: www.cs.unm.edu/~marron/software.html

Example: Arithmatic Exp. exp {+, -, *, /} Heap vars

Example: Arithmatic Exp. exp {+, -, *, /} {Var} {Const} Heap vars

Identifying Logically Related Regions of the Heap