1. Mark Marron 1, Deepak Kapur 2, Manuel Hermenegildo 1 1 Imdea-Software (Spain) 2 University of New Mexico 1

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

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

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

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

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

7. 7 class Enode { Enode[] fromN; … }

8.  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) 8

9. 9

10.  N-Body Simulation in 3-dimensions  Uses Fast Multi-Pole method with space decomposition tree For nearby bodies use naive n 2 algorithm For distant bodies compute center of mass of many bodies and treat as single point mass 10

11. 11

12. 12 for(…) { root = null; makeTree(); Iterator bm = this.bodyTabRev.iterator(); while(bm.hasNext()) bm.next().hackGravity(root); Iterator bp = this.bodyTabRev.iterator(); while(bm.hasNext()) bm.next().propUpdatedAccel(); }

13.  Statically collect, space decomposition tree and all MathVector/double[] objects (11% of GC work). 13

14.  GC objects reachable from the acc/vel fields in parallel with the hackGravity method (no overhead). 14

15.  Inline Double[] into MathVector objects, 23% serial speedup 37% memory use reduction. 15

16. BenchmarkLOCAnalysis Time Analysis Memory Region Ok tsp9100.03s<30 MBY em3d11030.09s<30 MBY voronoi13240.50s<30 MBY bh23040.72s<30 MBY db19850.68s<30 MBY raytrace580915.5s38 MBY exp3567152.3s48 MBY debug15293114.8s122 MBY 16

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

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

19. 19

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

21.  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) 21

22. 22 exp vars Heap

23. 23 exp vars {+, -, *, /} {Const} {Var} {Var[]}

24. 24

25. 25

26. 26

27. 27

28. 28

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

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

31. 31 exp vars Heap {+, -, *, /}

32. 32 exp vars Heap {+, -, *, /} {Const} {Var}