Compositional Pointer and Escape Analysis for Java Programs

Transcription

1 Compositional Pointer and Escape Analysis for Java Programs based on the paper by John Whaley and Martin Rinard presented by Natalia Prytkova Universität des Saarlandes

2 Motivation The aim: Optimization Two critical moments: 1 Memory allocation 2 Syncronization The main question: How to eliminate the overhead related with synchronization and allocation of objects in the heap?

3 The First Problem Memory

4 Storage in Java Register The stack The heap Constant storage Solution Objects that would otherwise be allocated in the heap and then reclaimed using garbage collection are allocated in an activation record on the stack and automatically (and cheaply) reclaimed when the activation record is popped off the stack. (Young Gil Park and Benjamin Goldberg Escape Analysis on Lists)

5 Storage in Java Register The stack The heap Constant storage Solution Objects that would otherwise be allocated in the heap and then reclaimed using garbage collection are allocated in an activation record on the stack and automatically (and cheaply) reclaimed when the activation record is popped off the stack. (Young Gil Park and Benjamin Goldberg Escape Analysis on Lists)

6 Storage in Java Register The stack The heap Constant storage Solution Objects that would otherwise be allocated in the heap and then reclaimed using garbage collection are allocated in an activation record on the stack and automatically (and cheaply) reclaimed when the activation record is popped off the stack. (Young Gil Park and Benjamin Goldberg Escape Analysis on Lists)

7 Storage in Java Register The stack The heap Constant storage Solution Objects that would otherwise be allocated in the heap and then reclaimed using garbage collection are allocated in an activation record on the stack and automatically (and cheaply) reclaimed when the activation record is popped off the stack. (Young Gil Park and Benjamin Goldberg Escape Analysis on Lists)

8 Storage in Java Register The stack The heap Constant storage Solution Objects that would otherwise be allocated in the heap and then reclaimed using garbage collection are allocated in an activation record on the stack and automatically (and cheaply) reclaimed when the activation record is popped off the stack. (Young Gil Park and Benjamin Goldberg Escape Analysis on Lists)

9 Example: Return Values

10 Example: Return Values

11 Example: Return Values

12 Example: Analysis Result for multiplyadd

13 Example: Analysis Result for multiplyadd The node that product points to is accessible only via the local variable product. Lifetime of the object is equal to the lifetime of the method invocation product can be allocated in the activation record of the multiplyadd method.

14 Example: Analysis Result for multiplyadd The node that product points to is accessible only via the local variable product. Lifetime of the object is equal to the lifetime of the method invocation product can be allocated in the activation record of the multiplyadd method.

15 Escaped objects When we can not allocate an object in the stack? A reference to the object was passed as a parameter into the current method A reference to the object was written into a static class variable A reference to the object was passed as a parameter to an invoked method, and there is no information about what the invoked method did with the object. The object is a thread object In these situations we say, that an object escapes the current method.

16 Escaped objects When we can not allocate an object in the stack? A reference to the object was passed as a parameter into the current method A reference to the object was written into a static class variable A reference to the object was passed as a parameter to an invoked method, and there is no information about what the invoked method did with the object. The object is a thread object In these situations we say, that an object escapes the current method.

17 Escaped objects When we can not allocate an object in the stack? A reference to the object was passed as a parameter into the current method A reference to the object was written into a static class variable A reference to the object was passed as a parameter to an invoked method, and there is no information about what the invoked method did with the object. The object is a thread object In these situations we say, that an object escapes the current method.

18 Escaped objects When we can not allocate an object in the stack? A reference to the object was passed as a parameter into the current method A reference to the object was written into a static class variable A reference to the object was passed as a parameter to an invoked method, and there is no information about what the invoked method did with the object. The object is a thread object In these situations we say, that an object escapes the current method.

19 The Second Problem Synchronization

20 Synchronization Why and when do we need synchronization? To prevent the problem of thread collision. If you are writing a variable that might next be read by another thread or reading the variable that might have last been written by another thread, you must use synchronization. (Bruce Eckel, Thinking in Java)

21 Synchronization Why and when do we need synchronization? To prevent the problem of thread collision. If you are writing a variable that might next be read by another thread or reading the variable that might have last been written by another thread, you must use synchronization. (Bruce Eckel, Thinking in Java) Overhead of Synchronization (Aldrich et al. Static Analyses for Eliminating Unnecessary Synchronization from Java Programs)

22 Synchronization Why and when do we need synchronization? To prevent the problem of thread collision. If you are writing a variable that might next be read by another thread or reading the variable that might have last been written by another thread, you must use synchronization. (Bruce Eckel, Thinking in Java) Solution If an object does not escape a thread, it is legal to remove the lock acquire and release operations from synchronized methods that execute on that object.

23 Example: Synchronization

24 Example: Synchronization

25 Analysis Algorithm What is to analyse? The algorithm analyses the program at the granularity of methods. How to analyse? Represent a program (interprocedural level) Represent an object (intraprocedural level)

26 Analysis Algorithm What is to analyse? The algorithm analyses the program at the granularity of methods. How to analyse? Represent a program (interprocedural level) Represent an object (intraprocedural level)

27 Program representation

28 Program representation

29 Program representation

30 Program representation

31 Program representation Analysis objects Set of classes cl Cl Set of object fields f F Set of local variables l L Set of formal parameters p P

32 Program representation Statements that affect points-to and escape information A copy statement l = v A load statement l 1 = l 2.f A store statement l 1.f = l 2 A global load statement l = cl.f A global store statement cl.f = l A return statement return l An object creation l = new cl A method invocation l = l 0.op(l 1,... l k )

33 Object representation

34 Object representation Types of nodes Set of inside nodes N I Set of thread nodes N T, N T N I Set of outside nodes N O Set of parameter nodes N P, N P N O Set of global nodes N G, N G N O Set of load nodes N L, N L N O Set of return nodes N R, N R N O

35 Points-to Escape Graph Is a quadruple O, I, e, r O is a set of outside edges O (N F ) (N L N G ) I is a set of inside edges I (V (N F )) N e : N 2 M is an escape function r N is a return set

36 Points-to Escape Graph O = I = { this, N this, a, N a, b, N b, product, N product, sum, N sum } e = {(b a.multiply(b)), (product this.add(product))} r = {N sum }

37 Intraprocedural Analysis: Example Line #20 O = I = { this, N this, a, N a, b, N b } n e 0 (n) = r =

38 Intraprocedural Analysis: Example Line #22 Kill I = edges(i, product) Gen I = {product} I(a.multiply(b)) I = (I Kill I ) Gen I = I + { product, a.multiply(b) }

39 Intraprocedural Analysis: Example Line #23 Kill I = edges(i, sum) Gen I = {sum} I(this.add(product)) I = (I Kill I ) Gen I = I + { sum, this.add(product) }

40 Intraprocedural Analysis: Example Line #24 r = I(sum) = {N sum }

41 Intraprocedural Analysis: Copy Statement l = v Kill I = edges(i, l) Gen I = {l} I(v) I = (I Kill I ) Gen I

42 Intraprocedural Analysis: Load Statement l 1 = l 2.f, 1st Case Kill I = edges(i, l 1 ) Gen I = {l 1 } {I(l 2 ) {f}} I = (I Kill I ) Gen I

43 Intraprocedural Analysis: Load Statement l 1 = l 2.f, 2nd Case Kill I = edges(i, l 1 ) Gen I = {l 1 } {I(l 2 ) {f}} I = (I Kill I ) Gen I Gen O = {I(l 2 ) {f}} n O = O Gen O

44 Intraprocedural Analysis: Store Statement l 1.f = l 2 Gen I = {I(l 1 ) {f}} I(l 2 ) I = I Gen I

45 Intraprocedural Analysis: Global Load Statement l = cl.f Kill I = edges(i, l) Gen I = {l} (O I)(cl, f) I = (I Kill I ) Gen I

46 Intraprocedural Analysis: Global Store Statement cl.f = l Gen I = { cl, f } I(l) I = I Gen I

47 Intraprocedural Analysis: Object Creation Sites l = new cl Kill I = edges(i, l) Gen I = { l, n } I = (I Kill I ) Gen I

48 Intraprocedural Analysis: Return Statement return l r = I(l)

49 Intraprocedural Analysis We analyse a method line by line, statement by statement Analysis Result Before Statement α( st) = {α(st ) : st pred(st)} Analysis Result After Statement α(st ) = [st](α( st)) Analysis Result Before Method Invocation α( enter op ) = O 0, I 0, e 0, r 0 Analysis Result After Method Invocation α(exit op ) = O, I, e, r = remove(s, O, I, e, r ) where S = {n N : not reachable (O I, CL P r, n)}

50 Intraprocedural Analysis We analyse a method line by line, statement by statement Analysis Result Before Statement α( st) = {α(st ) : st pred(st)} Analysis Result After Statement α(st ) = [st](α( st)) Analysis Result Before Method Invocation α( enter op ) = O 0, I 0, e 0, r 0 Analysis Result After Method Invocation α(exit op ) = O, I, e, r = remove(s, O, I, e, r ) where S = {n N : not reachable (O I, CL P r, n)}

51 Intraprocedural Analysis We analyse a method line by line, statement by statement Analysis Result Before Statement α( st) = {α(st ) : st pred(st)} Analysis Result After Statement α(st ) = [st](α( st)) Analysis Result Before Method Invocation α( enter op ) = O 0, I 0, e 0, r 0 Analysis Result After Method Invocation α(exit op ) = O, I, e, r = remove(s, O, I, e, r ) where S = {n N : not reachable (O I, CL P r, n)}

52 Intraprocedural Analysis We analyse a method line by line, statement by statement Analysis Result Before Statement α( st) = {α(st ) : st pred(st)} Analysis Result After Statement α(st ) = [st](α( st)) Analysis Result Before Method Invocation α( enter op ) = O 0, I 0, e 0, r 0 Analysis Result After Method Invocation α(exit op ) = O, I, e, r = remove(s, O, I, e, r ) where S = {n N : not reachable (O I, CL P r, n)}

53 Interprocedural Analysis At each method invocation site, the analysis has the option of either skipping the site or analysing the site. Skipped Method Invocation Sites l = l 0.op(l 1... l k ), return node n R O, I, e, r = [m]( O, I, e, r ) I = (I edges(i, l)) { l, n R } { e {e(n) m if 0 i k : n I(l i ) (n) = e(n) otherwise Analysed Method Invocation Sites l = l 0.op(l 1... l k ) O, I, e, r = [m]( O, I, e, r ) O, I, e, r = {map(m, O, I, e, r, op) : op callees(m)}

54 Mapping Algorithm We have 3 different points-to escape graphs: The old graph (before method invocation)

55 Mapping Algorithm We have 3 different points-to escape graphs: The incoming graph (the analysis result for the invoked method)

56 Mapping Algorithm We have 3 different points-to escape graphs: The incoming graph (the analysis result for the invoked method)

57 Mapping Algorithm We have 3 different points-to escape graphs: The new graph (after method invocation)

58 Mapping Algorithm: Rule 1 The new graph (after the method invocation) extends the old: where

59 Mapping Algorithm: Rule 2 Map each parameter node to the node in the old graph: where

60 Mapping Algorithm: Rule 2 Map each parameter node to the node in the old graph: where

61 Mapping Algorithm: Rule 2 Map each parameter node to the node in the old graph: where

62 Mapping Algorithm: Rule 3 Map the return nodes from incoming to the new graph: where

63 Mapping Algorithm: Rule 3 Map the return nodes from incoming to the new graph: where

64 Mapping Algorithm: Rule 4 Map each outside edge in the incoming graph to the corresponding inside edge in the old graph:

65 Mapping Algorithm: Rule 4 Map each outside edge in the incoming graph to the corresponding inside edge in the old graph:

66 Mapping Algorithm: Rule 4 Map each outside edge in the incoming graph to the corresponding inside edge in the old graph:

67 Mapping Algorithm: Rule 4 Map each outside edge in the incoming graph to the corresponding inside edge in the old graph:

68 Mapping Algorithm: Rule 5 Map all inside nodes that are reachable from some node in the new graph:

69 Mapping Algorithm: Rule 5 Map all inside nodes that are reachable from some node in the new graph:

70 Mapping Algorithm: Rule 5 Map all inside nodes that are reachable from some node in the new graph:

71 Mapping Algorithm: Rule 6 All nodes passed into unanalysed methods are marked in the escape function:

72 Mapping Algorithm: Rule 6 All nodes passed into unanalysed methods are marked in the escape function: e = {(n1 function5(n1))}

73 Results: Synchronization Elimination

74 Results: Stack Allocation

75 Analysis Properties Interprocedural Compositional Partial

76 Related Works Pointer analysis Escape Analysis Synchronization Optimization

77 Summary Now we are able: To analyse an object-oriented program with help of points-to escape graphs To analyse program parts independently To allocate up to 95% of objects in the stack To eliminate unnecessary synchronization up to 67%