1 / 27

Finding Your Cronies: Static Analysis for Dynamic Object Colocation

T H E U N I V E R S I T Y O F T E X A S. A T A U S T I N. Finding Your Cronies: Static Analysis for Dynamic Object Colocation. Samuel Z. Guyer Kathryn S. McKinley. Motivation. Modern garbage collectors use multiple spaces Generational collectors:

hayden
Download Presentation

Finding Your Cronies: Static Analysis for Dynamic Object Colocation

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. T H E U N I V E R S I T Y O F T E X A S A T A U S T I N 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 Guyer, McKinley 2

  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 Guyer, McKinley 3

  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 Guyer, McKinley 4

  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 Guyer, McKinley 5

  6. Outline • Motivation • Dynamic object colocation • Colocators • Static analysis for finding colocators • Run-time system • Results • Related work • Conclusions Guyer, McKinley 6

  7. A newB void Simple(A p){ B newB = coalloc B(p); p.f = newB; } newB newB nursery mature space 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 Guyer, McKinley 7

  8. void BottomUp(A p){ B newB = coalloc B(p); C newC = coalloc C(p); newC.f = newB; p.f = newC; } 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 Guyer, McKinley 8

  9. Finding colocators • Use formal parameters • Likely to refer to older objects • Order of creation/connection doesn’t 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 Guyer, McKinley 9

  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 p q A B newC newD newE newE newG newF Guyer, McKinley 10

  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); Guyer, McKinley 11

  12. Analysis features Observation: Allocation doesn’t 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 Guyer, McKinley 12

  13. Volatility heuristics • Some connections should not cause colocation • Mistakes can fill the mature space with garbage Prune them out of the graph... void foo(Container c, Value v) { String value_name = new String(v); if ( ! c.contains(value_name)) c.add(value_name); } New string is conditionally stored Heuristic: store must post-dominate allocation void bar(Container c) { for (...) { c.add(new String(...)); } c.clear(); } Container object is immediately cleared Heuristic: skip connections that have null assignments Guyer, McKinley 13

  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. Guyer, McKinley 14

  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 Guyer, McKinley 15

  16. MB mature space alloc 86.7 150% 2.7 7.8 3.4 48.7 6.5 7.8 100% 50% Nursery survival MB promoted pseudojbb javac db mtrt jack raytrace jess 2.1 47.7 7.7 6.4 6.7 3.2 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 Guyer, McKinley 16

  17. GC Time: javac 62% 57% Guyer, McKinley 17

  18. GC Time: jbb -24% 40% 35% 55% Guyer, McKinley 18

  19. GC Time: average % speedup Guyer, McKinley 19

  20. Runtime: javac 4% 8% Guyer, McKinley 20

  21. Runtime: average % speedup Guyer, McKinley 21

  22. Runtime: db % speedup Guyer, McKinley 22

  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 Guyer, McKinley 23

  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 Guyer, McKinley 24

  25. Thank You http://www.cs.utexas.edu/users/sammy Guyer, McKinley 25

  26. GC Time: jbb % speedup Guyer, McKinley 26

  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 Guyer, McKinley 27

More Related