Ju Qian

Static Slicing for Python First-Class Objects

Program slicing is an important program analysis technique and now has been used in many fields of software engineering. However, most existing program slicing methods focus on static programming languages such as C/C++ and Java, and methods on dynamic languages like Python are rarely seen. Python, a typical dynamic object-oriented language, has been more and more widely used now. In Python, everything is a first-class object, including functions, classes, methods, and modules. Existing slicing methods cannot handle the issue of these first-class objects. Therefore, this paper proposes a static slicing method for Python first-class objects. By adding all the definitions of first-class objects into the dependence model and uniformly constructing the program dependence graphs for all the functions, classes, methods, and modules, this method can effectively solve the slicing problems caused by arbitrary definitions and uses of first-class objects in Python.

Inferring weak references for fixing Java memory leaks

Lots of efforts have yet been devoted to the detection of memory leaks. However, very few work concerns on the problem of memory leak fixing. In this paper, we propose a dynamic approach for the weak reference based memory leak fixing. The approach can automatically infer the weakenable references in a program, rank them and report them to the user. The user can then weaken references according to the reports to fix the memory leaks.

Finding shrink critical section refactoring opportunities for the evolution of concurrent code in trustworthy software

With the keyword synchronized, Java provides a simple but often over-used synchronization mechanism. Many programmers tend to use a big synchronized section to protect a large block of statements even if many of them are unnecessarily synchronized. Such coarse-gained synchronizations may increase lock contention and thereby decrease the performance of a program, especially in a multi-core environment. The decrease in performance may affect the quality of service provided by the software and hence make the software less trustworthy. To ensure trustworthiness, this paper proposes a source-code level refactoring approach to optimize coarse-gained synchronizations. It exploits dependence and escape information to search for shrinkable critical sections and can transform them into smaller ones automatically. The approach can be used to gradually evolve concurrent code for better quality. In the approach, to achieve more optimizations, we develop a new escape analysis, named escape state analysis, which can not only tell us whether an object finally escapes but also determine the escape states of objects at each program site. With such an analysis, more refactoring opportunities can be found. We build a tool and test our refactoring approach on several benchmark programs. The results show that the proposed approach does make effective refactoring suggestions for the users.

Identifying extract class refactoring opportunities for internetware

The quality of internetware software is significantly associated with class structure. As software evolves, changes often introduce many unrelated responsibilities to the same classes or distribute tightly-related methods in different classes. These changes make the classes difficult to understand and maintain. Extract class refactoring is an effective technique to improve the quality of software structure by decomposing unrelated methods in one class to create new classes or extracting tightly-related methods from different classes. In this paper, we propose a novel approach for class extraction from internetware source codes. This approach leverages a community structure detection technique to partition software into clusters and extracts classes from the resulting clusters. Our experimental results, which investigate the public well-known internetware PKUAS, indicate that: (1) the proposed approach is much faster than existing search-based clustering approaches (Hillclimbing and Genetic algorithm) and is thus applicable for large-scale internetware; (2) the proposed approach can identify meaningful class extractions for internetware; and (3) Extract Class refactoring candidates identified by the proposed approach significantly improve class cohesion of internetware.

Resource-Aware Test Suite Optimization

Regression testing is an expensive and frequently executed activity, which is often performed in a resource constrained execution environment. As resource-aware test suite optimization problem can be reduced to the 0-1 knapsack problem, which can be efficiently approximated with multiple algorithms. This paper proposes a new resource-aware test suite optimization technique and corresponding metric. The effectiveness of the technique and metric are illustrated by a case study.

Dependence Analysis for C Programs with Combinability of Dataflow Facts under Consideration

To avoid the precision loss caused by combining dataflow facts impossible to occur in the same execution path in dependence analysis for C programs, this paper first proposes a flow-sensitive and context-insensitive points-to analysis algorithm and then presents a new dependence analysis approach based on it. The approach makes more sufficient consideration on the executable path problem and can avoid invalid combination between points-to relations and between points-to relations and reaching definitions. The results of which are therefore more precise than those of the ordinary dependence analysis approaches.

A Specification-Based Approach to the Testing of Java Memory Bloat

Inefficient use of memory may cause memory bloat, and the bloat may lead to performance slowdowns or even crashes. To address the problem, lots of efforts have been devoted to the diagnosing of bloat, especially the bloat caused by memory leaks. However, testing and identifying the executions potentially containing bloat, which act as key steps before diagnosing, are still challenging. In this paper, we introduce a memory specification tool named MemSpec to help programmers test memory inefficiencies in Java programs. The specification works as a test oracle to automatically determine whether a program suffers from memory bloat. Users can write their own memory specifications using our specification language. MemSpec weaves the specification checking mechanisms into the tested programs. During test runs, memory bloat will be reported if the some specifications are not satisfied. With this specification-based approach, a tester does not need to manually watch the program executions to identify bloat. The automatically reporting of memory bloat can reduce the manual efforts in memory inefficiency testing. We test the proposed approach on ArgoUML. The initial results show that it is effective.

Side-effect analysis with fast escape filter

Side-effect analysis is a fundamental static analysis used to determine the memory locations modified or used by each program entity. For the programs with pointers, the analysis can be very imprecise. To improve the precision of side-effect analysis, many approaches design more elaborate background pointer analyses in order to obtain smaller side-effect sets, but very few approaches consider to achieve better precisions by refining the side-effect analysis algorithms themselves. To address the problem, this paper presents a new side-effect analysis approach that uses Gay and Steensgaards fast escape analysis to filter superfluous side-effects. The approach does not need to modify the background pointer analysis and can filter side-effects in the intraprocedural level and the interprocedural level. The experimental results show that it can effectively improve the analysis precision within a short extra time.

Contribution-based call stack abstraction for call string based pointer analysis

Context: Different method calls may have different contributions to the precision of the final application when abstracted into the call strings. The existing call string based pointer analysis algorithms do not consider such contribution difference and hence may not achieve best cost-effectiveness. Objective: To be more cost-effective, we try to leverage the contribution information of each method call in call string based pointer analysis. Method: The paper firstly proposes a contribution-based call stack abstraction method which abstracts the call stacks into call strings with the contribution information under consideration. Then, we apply the new call stack abstraction method to the pointer analysis of AspectJ programs and propose a concern-sensitive points-to analysis method. Besides, the new abstraction method is also applied to multi-threaded Java programs and results in a thread-sensitive pointer analysis method. Results: The experimental results show that the two pointer analysis methods with contribution-based call stack abstraction can be more cost-effective than the ordinary call string based approaches for an application that detects harmful advices and an application that detects inter-thread data flow. Conclusion: These pointer analysis methods more concretely and more clearly show that the contribution-based call stack abstraction can lead to better cost-effectiveness for the given applications.

Contribution-Based Call Stack Abstraction and Its Application in Pointer Analysis of AspectJ Programs

Different method calls may have different contributions to the precision of the final application when abstracted into the call strings. The existing call string based pointer analysis algorithms do not consider such contribution difference and hence often can not achieve best cost-effectiveness. To solve the problem, this paper firstly proposes a contribution-based call stack abstraction method which abstracts the call stacks to the call strings with the contribution information under consideration. Then, we apply the new call stack abstraction method to the pointer analysis of AspectJ programs and propose a concern-sensitive points-to analysis method. The concern-sensitive points-to analysis is more cost-effective than the ordinary call string based approaches for an application that detects harmful advices. It more concretely and more clearly shows that the contribution-based call stack abstraction can lead to better cost-effectiveness for the given applications.