The dual heap virtual implementation provided a new base for memory organization such that the heap storage can be virtually enlarged to include the extremely large disk space. Two simulation models were used to investigate aging in physical space as well as the dual heap implementation. The simulators generated results which measured the ability of each method to detect leaks generate false positives and false negatives. In comparison, the dual heap implementation showed a relatively better performance than the aging algorithm. The dual heap implementation is shown to produce less false positives and less false negatives. It has better capability of detecting memory leaks. Furthermore, dual heap implementation extends the space provide to the main heap such that programs with greedy memory consumption can also benefit from this implementation. The dual heap virtual model of the heap organization is a promising architecture, which at once masks the memory leak problem and extends the heap storage for greedy programs. The introduction and advancement of 64-bit address machine would not reduce the value of the dual virtual heap implementation, for the simple reasons that a large number of legacy programs will continue to run in a 32-bit environment, and for the fact that greedy programs and leaks will drain the heap storage of 64-bit machines as much as they did for the 32-bit machines.

With the developing of the software and network environment, software becomes more and more complex. The network attacks which exploit the software vulnerability make the traditional software testing face a crucible challenge. According to the report by the CSI/FBI, the lose cause from Denial-of-Service remains in top 5 highest rank of network attacks in the past 3 years. Besides the network bandwidth consuming, the commonest attack is to exploit the software vulnerabilities. In my research, I found the traditional testing technique could not find the software vulnerabilities efficiently for they just verify the correctness of software. This way of thinking would bypass many software vulnerabilities which do not belong to the logical error such as memory leak. In another way, some test techniques to solve the resource usage vulnerability were proposed in recent years but the results of them are very primitive. Thus, I try to give the software testing a new definition from the resource usage analysis. I propose 3 test criteria in this paper. Testers could combine these test criteria with existing tools as a guide to test the resource usage of the program. With these test criteria, testers can find out the unhealthy usage of software resource.

This thesis introduces a method that combines automated test data generation techniques with high volume testing and resource monitoring. High volume testing repeats test cases many times, simulating extended execution intervals. These testing techniques have been found useful for uncovering errors resulting from component coordination problems, as well as system resource consumption (e.g. memory leaks) or corruption. Coupling automated test data generation with high volume testing and resource monitoring could make this approach more scalable and effective in the field.

A memory leak is a common software vulnerability that will lead to performance degradation of the software or crash or both. A Memory leak is one typical cause of software aging. The phenomenon of memory leaks usually occurs in C/C++ because programmers need to manage memory by themselves when programs run. However, many think that Java does not suffer from memory leaks since Java provides automatic garbage collection. Actually, Java programs will run out of memory unexpectedly after executing for a long time. The reason for Java memory leaks is that reachable objects are no longer needed. These objects should be reclaimed but they can¡¦t because they are still referenced. This thesis introduces a method for filtering the leaked objects in Java memory leak programs. First, we monitor the heap growth after each full garbage collection and the numbers of full garbage collection to identify programs that might have potential memory management problems. Second, we periodically keep track of growth trend of each object of problematic programs and filter out the suspected one by time series analysis. Finally, we execute the program blocks that include objects that we find out to see if the program will run out of memory eventually. The method has been implemented and has been verified successful by four Java memory leak programs.

Large graph-based datasets are common to many applications because of the additional structure provided to data by graphs. Patterns extracted from graphs must adhere to these structural properties, making them a more complex class of patterns to identify. The role of graph mining is to efficiently extract these patterns and quantify their significance. In this thesis, we focus on two application domains and demonstrate the design of graph mining algorithms in these domains. First, we investigate the use of graph grammar mining as a tool for diagnosing potential memory leaks from Java heap dumps. Memory leaks occur when memory that is no longer in use fails to be reclaimed, resulting in significant slowdowns, exhaustion of available storage, and eventually application crashes. Analyzing the heap dump of a program is a common strategy used in memory leak diagnosis, but our work is the first to employ a graph mining approach to the problem. Memory leaks accumulate in the heap as classes of subgraphs and the allocation paths from which they emanate can be explored to contextualize the leak source. We show that it suffices to mine the dominator tree of the heap dump, which is significantly smaller than the underlying graph. We demonstrate several synthetic as well as real-world examples of heap dumps for which our approach provides more insight into the problem than state-of-the-art tools such as Eclipse's MAT. Second, we study the problem of multipartite graph clustering as an approach to database summarization on an integrated biological database. Construction of such databases has become a common theme in biological research, where heterogeneous data is consolidated into a single, centralized repository that provides a structured forum for data analysis. We present an efficient approximation algorithm for identifying clusters that form multipartite cliques spanning multiple database tables. We show that our algorithm computes a lossless compression of the database by summarizing it into a reduced set of biologically meaningful clusters. Our algorithm is applied to data from C. elegans, but we note its applicability to general relational databases. / Master of Science

This thesis has been a study in memory management in C/C++, with practical work in finding and solving memory leaks in a large project. A background theory of C++ and memory management has been presented along with the memory problems that can arise in development in C/C++. Several topics in minimizing memory problems with using inbuilt C++ libraries and the Boost libraries have also been presented. There is also an overview of the PLC-Opt 2.2 Beta application and its inner workings. The method was to learn all about memory management and solve the memory leaks in PLC-Opt. The results showed that there were approximately 28.000 instances of memory leaks and the end result showed that approximately 700 instances of leaks remained unresolved. A list with clues of the remaining memory leaks was provided in the Future work chapter.

Large-scale distributed computing systems such as data centers are hosted on heterogeneous and networked servers that execute in a dynamic and uncertain operating environment, caused by factors such as time-varying user workload and various failures. Therefore, achieving stringent quality-of-service goals is a challenging task, requiring a comprehensive approach to performance control, fault diagnosis, and failure recovery. This work presents a model-based approach for fault management, which integrates limited lookahead control (LLC), diagnosis, and fault-tolerance concepts that: (1) enables systems to adapt to environment variations, (2) maintains the availability and reliability of the system, (3) facilitates system recovery from failures. We focused on memory leak errors in this thesis. A characterization function is designed to detect memory leaks. Then, a LLC is applied to enable the computing system to adapt efficiently to variations in the workload, and to enable the system recover from memory leaks and maintain functionality.

No description available.

Despite the built-in garbage collector, Java programs can still suffer the memory leak problem resulted from the unhealthy programming style of retaining unwanted references. This paper presents an aspect-based tool for assisting programmers in locating such references to fix the problem. This tool, FindLeaks, utilizes an aspect to collect memory consumption statistics and object references created during a program’s execution and analyzes them for detecting memory leaks. The distinctive feature of FindLeaks is that it reports not only suspected classes of leaked objects but also where in the source the unwanted references were created. Besides, this paper also reports our experience with FindLeaks on three open source Java programs and how we enhanced it to lower its overhead.

This thesis describes design and implementation of effective memory management for multi-threaded applications. At first, the virtual memory possibilities are described, which can be found in the latest operating systems, such as Microsoft Windows and Linux. Afterwards the most frequently used algorithms for memory management are explained. Consequently, their features are used properly for a new memory manager. Final design includes particular tools for application debugging and profiling. At the end of the thesis a series of tests and evaluation of achieved results were done.