Probabilistic Points-to Analysis for Java

Abstract

Probabilistic points-to analysis is an analysis technique for defining the probabilities on the points-to relations in programs. It provides the compiler with some optimization chances such as speculative dead store elimination, speculative redundancy elimination, and speculative code scheduling. Although several static probabilistic points-to analysis techniques have been developed for C language, they cannot be applied directly to Java because they do not handle the classes, objects, inheritances and invocations of virtual methods. In this paper, we propose a context-insensitive and flow-sensitive probabilistic points-to analysis for Java (JPPA) for statically predicting the probability of points-to relations at all program points (i.e., points before or after statements) of a Java program. JPPA first constructs an interprocedural control flow graph (ICFG) for a Java program, whose edges are labeled with the probabilities calculated by an algorithm based on a static branch prediction approach, and then calculates the probabilistic points-to relations of the program based upon the ICFG. We have also developed a tool called Lukewarm to support JPPA and conducted an experiment to compare JPPA with a traditional context-insensitive and flow-sensitive points-to analysis approach. The experimental results show that JPPA is a precise and effective probabilistic points-to analysis technique for Java.

Platform independent analysis of probabilities on execution paths of multithreaded programs

“…Specially, the PDP on a node node s2 to the only one precedence node s1 is 1 (see Figure 4(a)); the PDP on the node node s3 to the node of either branch (s 1 or s 2 ) of the if-else statement is 0.5 (see Figure 4(b)); the PDP on a condition C to the body of a while statement is 0.5 (see Figure 4(c)); and the PDP on a condition C to the body of a for statement is n n+1 , considering that C needs to be checked for n + 1 times (see Figure 4(d)). Sun et al also discuss in [14] about an interprocedural analysis of the PDPs. For example, in Figure 2, P DP (start → (main, block 1 )) = 1.0 denotes that start is the only predecessor of block 1 ; P DP ((t 2 , s 21 ) → (t 2 , s 22 )) = 1.0 denotes that in the region with respect to t 2 , s 21 is the only predecessor of s 22 .…”

“…A PDP can then be calculated by using the method proposed in [14], where the dependability of a node having n precedences to one of the precedences is 1 n . Specially, the PDP on a node node s2 to the only one precedence node s1 is 1 (see Figure 4(a)); the PDP on the node node s3 to the node of either branch (s 1 or s 2 ) of the if-else statement is 0.5 (see Figure 4(b)); the PDP on a condition C to the body of a while statement is 0.5 (see Figure 4(c)); and the PDP on a condition C to the body of a for statement is n n+1 , considering that C needs to be checked for n + 1 times (see Figure 4(d)).…”

“…For example, some hottest (i.e., most frequently executed) program paths should deserve more attention during program optimization phase because an optimization of them can help improve performance of the program, but the coldest (i.e., least frequently executed) ones may be focused on during testing because errors are prone to hide in them. In addition, the domain of program analysis can benefit from the probabilities on paths, e.g., the accuracy of a points-to analysis can get improved in that the register/memory allocations on some coldest program paths can be speculatively omitted [10] [14].…”

Untitled

“…The trade-off between accuracy and time costs hinders a universal pointer analysis and motivates application-directed techniques for pointer analysis 26 . A probabilistic pointer analysis that is flow-sensitive and context-insensitive has been presented for Java programs 27 . While our work is based on type systems, previous work is based on interprocedural control flow graphs whose edges are enriched with probabilities.…”

“…While our work treats multithreaded programs, the work in Ref. 27 treats only sequential programs. Context-sensitive and control-flow-sensitive pointer analyses 4,10,28,29 are known to be accurate but not scalable.…”