Research On Memory Usage Analysis Technology For Java Program

With the development of computer technology, the function, structure and behavior of software become more and more complex. The increasing complexity of problems solved by software have led to the proliferation of large-scale framework-intensive applications. These applications are typically built by combining standard packages, third-party layers for domain-specific functionality. While employing libraries and frameworks eases the development effort, it can be expensive to invoke the general APIs provided by these libraries, especially when they are used for simple tasks. Programmers in the software development process often pay more attention to the implementation of system function, lack optimization for program design and leave performance optimization of the task to run time system, resulting in performance problems caused by unreasonable memory usage widely exist in the program. The increase of software complexity brings new challenge to memory behavior understanding and memory problem detection in the process of software analysis and testing. For modern software system, how to quickly understand the memory behavior, accurately detect memory problem in the program has an important practical significance to guarantee the quality of software.In recent years, the analysis of software memory usage has been widely studied by a large number of scholars. Current research mainly includes two aspects. On the one hand, with the aid of program analysis technology to accurately extract the dependency between program entities, identify unreasonable program design; On the other hand, with dynamic information recorded and collected of a set of program runs,the suspiciousness of program entities can be calculated by applying statistical analysis method and characteristic analysis method to identify memory usage problems. However, the existing methods still face a series of problems. That is:(1)High resource overhead. The execution of Java program involves a large number of objects creation and usage, contains complex object reference relationship, which makes some methods consume a large amount of resources when perform memory usage analysis;(2) Diagnosis information is too abstract. While some methods can identify the performance problems in the program, but it is often just provide the class level information related to the issue of data structure. The ability of helpingprogrammers to find the root cause of the problem is limited;(3) The accuracy of the test results need to be improved. The existing research methods use the characteristics of memory usage problem to identify the problem, the accuracy of the detection results is low. In view of the above problems, this paper has carried on the following two aspects:(1) We proposed an approach to analyze the memory behavior of Java programs based on object reference relations. Unlike traditional methods that just consider the factor of memory consumption to find out program’s important data structures and analyze their memory behavior, our approach considers both memory consumption and memory domination to decide whether a data structure is important, and get the important memory behaviors via analyzes the memory dominance relationship between data structures and references analysis. Experimental results show that the proposed approach is effective, and can get more precise analysis results than other methods.(2) We proposed a novel approach to detect inefficient memory usage based on memory usage propagation profiling. Unlike existing methods that find the data structures which cause large amounts of memory consumption, and then analyze whether the use of memory is reasonable. We obtain memory usage information during program execution, and abstract them by a representation we refer to as a memory usage propagation graph(MUPG). This graph can provide all of the memory behavior information about the program. Then, several characterization analyses are proposed to discover the inefficient memory usage of the program, and we can get the root cause of inefficient memory usage via program context information provided by MUPG. Experimental results show that the proposed approach is effective, and can get more precise and effective analysis results than current methods.To sum up, this paper designed two kinds of memory usage analysis technology to help software developers to perform Java memory usage analysis, reveal the potential inefficient memory usage, and find the root causes of these problems.Although the implementation of these technologies are acrried out for the Java program, but we believe that the technology can also be provided to other object-oriented language system.