Estimating the Impact of Heap Liveness Information on Space Consumption in Java

Transcription

1 Estimating the Impact of Heap Liveness Information on Space Consumption in Java by R. Shaham, E. Kolodner and M. Sagiv first presented at ISSM'02 presentation: Adrian Moos

2 Contents what is this about? contemporary garbage collection liveness information motivation experiment: idealized interface experiment: realistic interface results conclusion and future work

3 GC by Reachability programmers can only access objects reachable from variables. unreachable objects can not be accessed, and therefore be reclaimed. a c variables (=root set) b d e

4 Example int foo(collection c, int[] a) { int res=0; Iterator iter = c.iterator(); while (iter.hasnext()) { res+=((integer)iter.next()).intvalue(); } } for (int i=0; i<a.length; i++) { res-=a[i]; } return res; iter is still in scope, but no longer used.

5 Variable Liveness Information static property from compiler design variable live at some program point pt iff exists execution path from pt reading its value variable dead = variable not live dead variables can be ignored by GC

6 Expression Liveness Information expression live at pt iff exists execution path from pt reading its value references denoted by dead reference expressions can be ignored by GC (?) substantially more complicated than variable liveness - why?

7 Aliasing Strikes Back void foo() { Obj a = new Obj(); a.f.m(); Obj b = a; b.f.m(); } a.f and b.f are different expressions, but denote the same reference liveness is defined on expressions, yet GC works on references...

8 Motivation GC by reachability is not optimal liveness information could help unknown/difficult how to use expression liveness liveness information worth the trouble?

9 Contents what is this about? experiment: idealized interface idea execution experiment: realistic interface results conclusion and future work

10 Liveness with Idealized Interface Assumption: idealized liveness information dynamic (=for a specific execution) informs GC of last use of reference more accurate than any liveness information execute program, log memory usage compare to reachability based GC gives upper bound on memory savings by any liveness information

11 Classes of References local (on java-stack) global (static) heap (field or array) other (everything else)

12 Method attach to every object heapl,stackl, globall last read of a (heap stack global) reference to the object modify JVM to update these on reference read

13 Method (2) On GC, update for every object: stackl*, globall* = last time reachable from a live (stack static) root stackr, globalr, otherr last GC time directly reachable from (stack global other) stackr*, globalr*, otherr* = last GC time object is reachable on a path from a (stack static other) root

14 Computation of Transitive Properties traverse reference graph, for every object: stackl* = max(stackl, stackl*); stackl*(obj) = max(stackl*(parent), stackl*(obj)); stackr* = current time; analogously for global and other done in linear time

15 Computing Collection Time at collection time, for every object with respect to presence/absence of liveness for any type of reference from properties

16 Computing Collection Time (2) stack obj global other objects!=obj that can reach obj none heap stack heap + stack + global max(stackr*, globalr*, otherr*) max(heapl, stackr, globalr, otherr) max(stackl*, globalr*, otherr*) max(heapl, stackl, globall, otherr)

17 Method (3) Upon termination, the average and maximum heap size is computed from the logged object lifetimes.

18 Contents what is this about? experiment: idealized interface experiment: realistic interface what interface? idea execution results conclusion and future work

19 What Interface? Allow the application to disable references, that is, to state that they will not be used later on, and modify the compiler to automatically disable them whenever possible. As null is a disabled reference, references could be disabled by setting them to null.

20 Method Assumption: more realistic liveness dynamic (=for a specific execution) code-centric all communication of liveness to GC through execution of program code that assigns null to reference expressions after their use optimal optimal dynamic analysis at least as powerful as any static one

21 Method (2) execute program, log all program points where reference expressions can be assigned null execute again and simulate space savings

22 Method (3) let SNULL be the set of program points where a reference expression can safely be nullified. consider all pt that access the heap as candidates then execute, and remove all unsuitable candidates: Event pt: read x.f pt: write x.f Action SNULL = SNULL \ {P(x.f)} P(x.f) = pt P(x.f) = pt

23 Method (4) What exactly are these program points? A program point is the sequence of the last k return addresses in the call stack plus the address of the current instruction. Experiments were run for k=0,1,2,3.

24 Contents what is this about? experiment: idealized interface experiment: realistic interface results test cases summary for idealized interface summary for realistic interface conclusion and future work

25 Test Cases jess raytrace db javac jack mc euler juru analyser tvla expert system shell raytracer database simulator java compiler parser generator financial simulation euler equations solver web indexing mutability analyser static analysis framework

26 Results For Idealized Interface reduction of average memory consumption (averaged over all test cases) stack 2 % stack + global 9 % heap 39 % drag 42 % (results for peak memory consumption are similar)

27 Results For Realistic Interface data for heap liveness only, other kinds useless (< 1% savings) intraprocedural: 6% context length 2: 15% tighter bound, yet just a bound: uses dynamic information provisioning, static provisioning weaker...

28 Conclusion and Future Work stack liveness yields very little benefit global liveness yields small potential benefits; is therefore hardly worth the hassle heap liveness must be interprocedural to be effective. Upper bound: 15% savings. substantially improving GC is difficult authors are working on static analysis identifying null-assignable program points

29 ?