Return of CFA: call-site sensitivity can be superior to object sensitivity even for object-oriented programs

In this paper, we challenge the commonly-accepted wisdom in static analysis that object sensitivity is superior to call-site sensitivity for object-oriented programs. In static analysis of object-oriented programs, object sensitivity has been established as the dominant flavor of context sensitivity thanks to its outstanding precision. On the other hand, call-site sensitivity has been regarded as unsuitable and its use in practice has been constantly discouraged for object-oriented programs. In this paper, however, we claim that call-site sensitivity is generally a superior context abstraction because it is practically possible to transform object sensitivity into more precise call-site sensitivity. Our key insight is that the previously known superiority of object sensitivity holds only in the traditional k -limited setting, where the analysis is enforced to keep the most recent k context elements. However, it no longer holds in a recently-proposed, more general setting with context tunneling. With context tunneling, where the analysis is free to choose an arbitrary k -length subsequence of context strings, we show that call-site sensitivity can simulate object sensitivity almost completely, but not vice versa. To support the claim, we present a technique, called Obj2CFA, for transforming arbitrary context-tunneled object sensitivity into more precise, context-tunneled call-site-sensitivity. We implemented Obj2CFA in Doop and used it to derive a new call-site-sensitive analysis from a state-of-the-art object-sensitive pointer analysis. Experimental results confirm that the resulting call-site sensitivity outperforms object sensitivity in precision and scalability for real-world Java programs. Remarkably, our results show that even 1-call-site sensitivity can be more precise than the conventional 3-object-sensitive analysis.

Applying Software Engineering Design Principles to Agile Architecture

Most enterprise IT systems are very complex with a combination of COBOL and Java programs running on multiple platforms. What is needed is a solid IT architecture that supports the operation and growth of a cross-platform IT system. It must enable the iterative and incremental development of applications that are foreseen in an agile development process. The design concept of such an architecture with its infrastructure and development tool is presented in this chapter. This design concept is based on the design principles and architectural patterns of software engineering. The architecture is a combination of layered, component-based, and service-oriented architectural patterns. The agile development process is based on a model-driven approach. The architecture and development approaches were first introduced in 2004. Since then, many applications have been developed on time and within budget.

Making pointer analysis more precise by unleashing the power of selective context sensitivity

Traditional context-sensitive pointer analysis is hard to scale for large and complex Java programs. To address this issue, a series of selective context-sensitivity approaches have been proposed and exhibit promising results. In this work, we move one step further towards producing highly-precise pointer analyses for hard-to-analyze Java programs by presenting the Unity-Relay framework, which takes selective context sensitivity to the next level. Briefly, Unity-Relay is a one-two punch: given a set of different selective context-sensitivity approaches, say S = S1, . . . , Sn, Unity-Relay first provides a mechanism (called Unity)to combine and maximize the precision of all components of S. When Unity fails to scale, Unity-Relay offers a scheme (called Relay) to pass and accumulate the precision from one approach Si in S to the next, Si+1, leading to an analysis that is more precise than all approaches in S. As a proof-of-concept, we instantiate Unity-Relay into a tool called Baton and extensively evaluate it on a set of hard-to-analyze Java programs, using general precision metrics and popular clients. Compared with the state of the art, Baton achieves the best precision for all metrics and clients for all evaluated programs. The difference in precision is often dramatic — up to 71% of alias pairs reported by previously-best algorithms are found to be spurious and eliminated.

Whole program analysis of Java programs for virtual calls and exception handling.

Java Programs suffer performance degradation due to the presence of virtual calls and the lack of an efficient exception handling mechanism. In this dissertation, we show how virtual calls can be statically resolved to one or two target methods. The resolved calls can then be potentially inlined and hence improve the performance of the program. Analyzing the whole program (including the Java runtime library) instead of only user code has a positive effect on the performance of the program. We present two exception handling mechanisms, Direct Path Analysis and Display Catch Exception Handling, that improve the performance of programs as compared to the existing popular techniques, Stack Unwinding and Stack Cutting. The first analysis shows that the number of the stack frames needed to be unwound is lower in our analysis than Stack Unwinding. In the second analysis, we propose the Display Catch Exception Handling mechanism which is better than Stack Cutting in terms of operations required to catch exceptions.

Code coagulation is an effective compilation technique for the JVM

Compilers are the interface between programmers and computers. The output of a compiler determines the speed of the resulting program as well as its energy footprint -- of increasing importance in this world of climate change and battery-dependent computing. Code coagulation has the potential to improve that performance, particularly relative to (JIT) interpreters. Java and related languages are in wide use, so addressing their performance has large potential impact. Optijava is an experimental compiler that applies code coagulation to Java programs.