Finding Your Cronies: Static Analysis for Dynamic Object Colocation

1
Finding Your Cronies Static Analysis for
Dynamic Object Colocation

• Samuel Z. Guyer
• Kathryn S. McKinley

2
Motivation

• Modern garbage collectors use multiple spaces
• Generational collectors
• Allocate new objects in nursery space
• Many objects die young collection is cheap
• Copy survivors into mature space promotion
• Problem longer-lived objects always copied
• javac 25 (47 MB out of 185 MB)

nursery
mature space
3
Avoiding promotion

• Solution skip nursery
• Allocate objects that will survive in mature
  space
• How do we predict nursery survivors?
• Look at why objects survive...
• Most objects survive because they are
  connected to older objects
• javac 10 stack, 90 mature space

p
nursery
mature space
4
Exploiting connectivity

• Pointers predict survival
• Create new object point to it from mature space
• New object will be promoted
• Instead colocate new object...
• Anticipate the pointer
• Allocate pointer target in same space as source

nursery
mature space
5
Dynamic Object Colocation

• Key a cooperative approach...
• Run-time new allocation routine
• coalloc() takes a Object argument the colocator
• Allocates new object in same space as colocator
• Compile-time static analysis
• Determine if a new object will be a pointer
  target
• At allocation site pass pointer source as
  colocator
• Connected objects end up in the same space

6
Outline

• Motivation
• Dynamic object colocation
• Colocators
• Static analysis for finding colocators
• Run-time system
• Results
• Related work
• Conclusions

7
Simple Example

• The new B object will live as long as A
• Colocate new B with A
• Run-time value of p determines behavior

void Simple(A p) B newB new B() p.f
newB
Unless p.f is overwritten
A
A
8
Complex Example

• Problem new C cannot be colocator for new B
• Solution use p as colocator for both
• Connectivity is transitive so is survival
• Simplifies task of finding colocators

void BottomUp(A p) B newB new B() C newC
new C() newC.f newB p.f newC
A
newC
newB
9
Finding colocators

• Use formal parameters
• Likely to refer to older objects
• Order of creation/connection doesnt matter
• Goal for each allocation site
• Will the new object end up connected to a
  parameter?
• (Directly or indirectly)
• Find colocators using custom pointer analysis
• Determine connectivity using points-to graph

10
Analysis algorithm
One method at a time

• Points-to graph
• Node for each parameter, alloc site
• Edges represent may point-to
• Visit each instruction in IR
• Keep track of variable bindings
• Add edges at putfield and astore
• Find colocators using graph
• Test reachability of allocation nodes from
  parameters

void foo(A p, B q) ...
p
q
p
A
B
newC
newD
newE
newE
newG
newF
11
Interprocedural analysis

• Common case local analysis good enough
• Problem allocation, connection in different
  methods
• For example, container classes
• Connector methods
• Record how method connects arguments
• Apply summary at call sites
• Factory methods
• Treat calls to factory as allocations at call
  sites
• Helpful, but not required...

p new Element() list.add(p)
12
Analysis features

• Observation Allocation doesnt affect
  correctness
• Colocation analysis can be unsound
• Simplify algorithm
• One pass no fixed-point computation
• No conservative assumptions (parameter aliasing)
• No closed-world assumption
• Works with class loading, reflection, native
  methods
• Ignore some connections
• Heuristics to identify volatile pointers

Unless p.f is overwritten

13
Volatility heuristics

• Some connections should not cause colocation
• Mistakes can fill the mature space with garbage
• Prune them out of the graph...

New string is conditionally stored Heuristic
store must post-dominate allocation
void foo(Container c, Value v) String
value_name new String(v) if ( !
c.contains(value_name)) c.add(value_name)
void bar(Container c) for (...)
c.add(new String(...)) c.clear()
Container object is immediately
cleared Heuristic skip connections that have
null assignments
14
Run-time

• Coalloc routine generational collector
• Factory methods
• At call site save the colocator
• At start of method retrieve the colocator
• Colocation depends on calling context

VM_Address coalloc(int bytes,
VM_Address colocator) if (!
colocator.isZero() colocator.LT(NURSERY_
START)) return matureAlloc(bytes) else
return nursery.alloc(bytes)
If the colocator is non-null and resides in the
mature space
allocate the new object directly in the mature
space.
otherwise, allocate the object in the nursery.
15
Methodology

• JikesRVM using MMTk
• 3.2 GHz Pentium 4, 1 GB memory, Linux 2.6.0
• Generational collectors 4 MB bounded nursery
• GenCopy copying older space
• GenMS mark/sweep older space
• Benchmarks SPECJVM98 pseudojbb
• Compile all methods ahead of time ( 5-10)
• Goals
• Reduce nursery promotion GC time
• Avoid filling up the mature space with garbage

16
Nursery survival
MB promoted
jess
raytrace
db
javac
mtrt
jack
pseudojbb
2.1
3.2
7.7
47.7
6.4
6.7
59.8
Bytes in mature space (normalized)
2.0
4.1
3.3
3.6
23.1
0.9
13.8
Base
Base
Base
Base
Base
Base
Base
Coloc
Coloc
Coloc
Coloc
Coloc
Coloc
Coloc
17
GC Time javac
62
57
18
GC Time jbb
-24
40
35
55
19
GC Time average speedup
20
Runtime javac
4
8
21
Runtime average speedup
22
Runtime db speedup
23
Related Work

• Co-allocation for locality Chilimbi 99
• Manually add coalloc() calls
• Pretenuring Blackburn 01
• Static decision needs alloc-site
  homogeneity
• Connectivity-based GC Hirzel 03
• Statically partitions objects
• Requires sound pointer analysis
• Our approach combines static and dynamic

24
Conclusions

• Dynamic object colocation overcomes limitations
  of static approaches
• Static analysis for garbage collection
• Complex property (object lifetime) predicted by
  simple information (local connectivity)
• Use aggressive, unconventional points-to analysis
• Cooperative approach
• Exploit different strengths of compiler and
  run-time

25
http//www.cs.utexas.edu/users/sammy
26
GC Time jbb speedup
27
Conclusions

• Compiler can assist garbage collector
• Compiler can discover useful information
• Complex property (lifetime) predicted by simple
  information (connectivity)
• Cooperative approach
• Static analysis to identify opportunities
• Run-time system handles dynamic behavior
• Low cost and effective
• Generalizes to other multi-space collectors