DOCSLIB.ORG

Cork: Dynamic Memory Leak Detection for Garbage-Collected Languages £

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Cork: Dynamic Memory Leak Detection for Garbage-Collected Languages £ Cork: Dynamic Memory Leak Detection for Garbage-Collected Languages £ Maria Jump and Kathryn S. McKinley Department of Computer Sciences, The University of Texas at Austin, Austin, Texas 78712, USA g fmjump,mckinley @cs.utexas.edu Abstract agement. For example, C and C++ memory-related errors include A memory leak in a garbage-collected program occurs when the (1) dangling pointers – dereferencing pointers to objects that the program inadvertently maintains references to objects that it no program previously freed, (2) lost pointers – losing all pointers to longer needs. Memory leaks cause systematic heap growth, de- objects that the program neglects to free, and (3) unnecessary ref- grading performance and resulting in program crashes after per- erences – keeping pointers to objects the program never uses again. haps days or weeks of execution. Prior approaches for detecting Garbage collection corrects the first two errors, but not the last. memory leaks rely on heap differencing or detailed object statis- Since garbage collection is conservative, it cannot detect or reclaim tics which store state proportional to the number of objects in the objects referred to by unnecessary references. Thus, a memory leak heap. These overheads preclude their use on the same processor for in a garbage-collected language occurs when a program maintains deployed long-running applications. references to objects that it no longer needs, preventing the garbage This paper introduces a dynamic heap-summarization technique collector from reclaiming space. In the best case, unnecessary ref- based on type that accurately identifies leaks, is space efficient erences degrade program performance by increasing memory re- (adding less than 1% to the heap), and is time efficient (adding 2.3% quirements and consequently collector workload. In the worst case, on average to total execution time). We implement this approach a growing data structure with unused parts will cause the program in Cork which utilizes dynamic type information and garbage col- to run out of memory and crash. Even if a growing data structure is lection to summarize the live objects in a type points-from graph not a true leak, application reliability and performance can suffer. (TPFG) whose nodes (types) and edges (references between types) In long-running applications, small leaks can take days or weeks to are annotated with volume. Cork compares TPFGs across multiple manifest. These bugs are notoriously difficult to find because the collections, identifies growing data structures, and computes a type allocation that finally exhausts memory is not necessarily related to slice for the user. Cork is accurate: it identifies systematic heap the source of the heap growth. growth with no false positives in 4 of 15 benchmarks we tested. Previous approaches for finding leaks use heap diagnosis tools Cork’s slice report enabled us (non-experts) to quickly eliminate that rely on a combination of heap differencing [10, 11, 20] and growing data structures in SPECjbb2000 and Eclipse, something allocation and/or fine-grain object tracking [7, 8, 9, 13, 19, 24, 25, their developers had not previously done. Cork is accurate, scal- 28, 29]. These techniques degrade performance by a factor of two able, and efficient enough to consider using online. or more, incur substantial memory overheads, rely on multiple ex- ecutions, and/or offload work to a separate processor. Additionally, Categories and Subject Descriptors D.2.5 [Software Engineer- they yield large amounts of low-level details about individual ob- ing]: Testing and Debugging—Debugging aids jects. These reports require a lot of time and expertise to interpret. General Terms Memory Leak Detection Thus, prior work lacks precision and efficiency. This paper introduces Cork, an accurate, scalable, online, and Keywords memory leaks, runtime analysis, dynamic, garbage low-overhead memory leak detection tool for typed garbage- collection collected languages. Cork uses a novel approach to summarize, 1. Introduction identify, and report data structures with systematic heap growth. We show that it provides both efficiency and precision. Cork pig- Memory-related bugs are a substantial source of errors, and are gybacks on full-heap garbage collections. As the collector scans the especially problematic for languages with explicit memory man- heap, Cork summarizes the dynamic object graph by type (class) £ This work is supported by NSF CCR-0311829, NSF ITR CCR-0085792, in a summary type points-from graph (TPFG). The nodes of the NSF CCF-0429859, NSF EIA-0303609, DARPA F33615-03-C-4106, graph represent the volume of live objects of each type. The edges DARPA NBCH30390004, Intel, IBM, and Microsoft. Any opinions, find- represent the points-from relationship between types weighted by ings and conclusions expressed herein are the authors’ and do not necessar- volume. At the end of each collection, the TPFG completely sum- ily reflect those of the sponsors. marizes the live-object points-from relationships in the heap. For space efficiency, Cork stores type nodes together with global type information block (TIB). The TIB, or equivalent, is a required implementation element for languages such as Java and Permission to make digital or hard copies of all or part of this work for personal or C# that instructs the compiler on how to generate correct code and classroom use is granted without fee provided that copies are not made or distributed instructs the garbage collector on how to scan objects. The num- for profit or commercial advantage and that copies bear this notice and the full citation ber of nodes in the TPFG scales with the type system. While the on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. number of edges between types are quadratic in theory, programs POPL ’07 January 17-19, 2007, Nice, France. implement simpler type relations in practice; we find that the edges Copyright ­c 2007 ACM [to be supplied]. $5.00. 1 void scanObject(TraceLocal trace, Type Symbol Size 2 ObjectReference object) { HashTable H 256 3 MMType type = ObjectModel.getObjectType(object); Queue N 256 4 type.incVolumeTraced(object); // added 5 if (!type.isDelegated()) { Queue B 256 6 int references = type.getReferences(object); Company C 64 7 for (int i = 0; i < references; i++) { People P 32 8 Address slot = type.getSlot(object, i); 9 type.pointsTo(object, slot); // added (a) Object statistics 10 trace.traceObjectLocation(slot); 11 }} else { 12 Scanning.scanObject(trace, object); 13 }} H 1 Figure 2. Object Scanning C P P C P P C 1 1 2 2 3 4 3 to the user along with the data structure which contains them and the allocation sites that generate them. For clarity of exposition, we describe Cork in the context of a full-heap collector using an example program whose types are defined in Figure 1(a). B 1 N 1 2.1 Building the Type Points-From Graph (b) Object points-to graph To detect growth, Cork summarizes the heap in a type points- from graph (TPFG) annotated with instance and reference volumes. The TPFG consists of type nodes and reference edges. The type C|B:128 C:192 B:256 nodes represent the total volume of objects of type t (Vt ). The C|H:192 C|N:64 reference edges are directed edges from type node t ¼ to type node H:256 t and represent the volume of objects of type t ¼ that are referred P|H:128 to by objects of type t (V ¼ ). To minimize the costs associated t jt P:128P|N:64 N:256 with building the TPFG, Cork piggybacks its construction on the scanning phase of garbage collection which detects live objects by starting with the roots (statics, stacks, and registers) and performing (c) Type points-from graph a transitive closure through all the live object references in the heap. For each reachable (live) object o visited, Cork determines Figure 1. The type points-from graph summarizes the object the object’s type t and increments the corresponding type node by points-to graph the object’s size. Then for each reference from o to object o¼ , it ¼ increments the reference edge from t ¼ to t by the size of o . At the end of the collection, the TPFG completely summarizes the volume are linear in the number of types. The TPFG never adds more than of all types and references that are live at the time of the collection. 0.5% to heap memory. Figure 1(b) shows an object points-to graph (i.e., the heap it- Cork stores and compares TPGFs from multiple collections to self). Each vertex represents a different object in the heap and each detect and report a dynamic type slice with systematic heap growth. arrow represents a reference between two objects. Figure 2 shows We store points-from instead of points-to information to efficiently the modified scanning code from MMTk in Jikes RVM: Cork re- compute the candidate type slice. We demonstrate that the construc- quires two simple additions that appear as lines 4 and 9. Assume tion and comparison of TPFGs across multiple collections adds on scanObject is processing an object of type B that refers to an ob- average 2.3% to total time to a system with a generational collector. ject of type C (from Figure 1(b)). It takes the tracing routine and We apply Cork to 14 popular benchmarks from DaCapo object as parameters and finds the object type. Line 4 increments b.050224 [5] and SPECjvm [26, 27] benchmark suites. Cork the volume of type B (VB) in the node for this instance. Since the identifies and reports unbounded heap growth in three of them. We collector scans (detects liveness of) an object only once, Cork in- confirm no additional memory leaks in the other 11 benchmarks crements the total volume of this type only once per object instance.
Load more

Recommended publications
  • Memory Diagrams and Memory Debugging
    CSCI-1200 Data Structures | Spring 2020 Lab 4 | Memory Diagrams and Memory Debugging Checkpoint 1 (focusing on Memory Diagrams) will be available at the start of Wednesday's lab. Checkpoints 2 and 3 focus on using a memory debugger. It is highly recommended that you thoroughly read the instructions for Checkpoint 2 and Checkpoint 3 before starting. Memory debuggers will be a useful tool in many of the assignments this semester, and in C++ development if you work with the language outside of this course. While a traditional debugger lets you step through your code and examine variables, a memory debugger instead reports memory-related errors during execution and can help find memory leaks after your program has terminated. The next time you see a \segmentation fault", or it works on your machine but not on Submitty, try running a memory debugger! Please download the following 4 files needed for this lab: http://www.cs.rpi.edu/academics/courses/spring20/csci1200/labs/04_memory_debugging/buggy_lab4. cpp http://www.cs.rpi.edu/academics/courses/spring20/csci1200/labs/04_memory_debugging/first.txt http://www.cs.rpi.edu/academics/courses/spring20/csci1200/labs/04_memory_debugging/middle. txt http://www.cs.rpi.edu/academics/courses/spring20/csci1200/labs/04_memory_debugging/last.txt Checkpoint 2 estimate: 20-40 minutes For Checkpoint 2 of this lab, we will revisit the final checkpoint of the first lab of this course; only this time, we will heavily rely on dynamic memory to find the average and smallest number for a set of data from an input file. You will use a memory debugging tool such as DrMemory or Valgrind to fix memory errors and leaks in buggy lab4.cpp.
    [Show full text]
  • Automatic Detection of Uninitialized Variables
    Automatic Detection of Uninitialized Variables Thi Viet Nga Nguyen, Fran¸cois Irigoin, Corinne Ancourt, and Fabien Coelho Ecole des Mines de Paris, 77305 Fontainebleau, France {nguyen,irigoin,ancourt,coelho}@cri.ensmp.fr Abstract. One of the most common programming errors is the use of a variable before its definition. This undefined value may produce incorrect results, memory violations, unpredictable behaviors and program failure. To detect this kind of error, two approaches can be used: compile-time analysis and run-time checking. However, compile-time analysis is far from perfect because of complicated data and control flows as well as arrays with non-linear, indirection subscripts, etc. On the other hand, dynamic checking, although supported by hardware and compiler tech- niques, is costly due to heavy code instrumentation while information available at compile-time is not taken into account. This paper presents a combination of an efficient compile-time analysis and a source code instrumentation for run-time checking. All kinds of variables are checked by PIPS, a Fortran research compiler for program analyses, transformation, parallelization and verification. Uninitialized array elements are detected by using imported array region, an efficient inter-procedural array data flow analysis. If exact array regions cannot be computed and compile-time information is not sufficient, array elements are initialized to a special value and their utilization is accompanied by a value test to assert the legality of the access. In comparison to the dynamic instrumentation, our method greatly reduces the number of variables to be initialized and to be checked. Code instrumentation is only needed for some array sections, not for the whole array.
    [Show full text]
  • Ben Livshits 1 Basic Instrumentation
    Runtime monitoring CO444H Ben Livshits 1 Basic Instrumentation • Insert additional code into the program • This code is designed to record important events as they occur at runtime • Some examples • A particular function is being hit or a statement is being hit • This leads to function-level or line-level coverage • Each allocation to measure overall memory allocation 2 Levels of Instrumentation • Native code • Instrument machine code • Tools like LLVM are often used for rewriting • Bytecode • Common for languages such as Java and C# • A variety of tools are available for each bytecode format • JoeQ is in this category as well, although it’s a lot more general • Source code • Common for languages like JavaScript • Often the easiest option – parse the code and add more statements 3 Runtime Code Monitoring •Three major examples of monitoring • Purify/Valgrind • Detecting data races • Detecting memory leaks 4 5 Memory Error Detection Purify • C and C++ are not type-safe • The type system and the runtime fail to enforce type safety • What are some of the examples? • Possible to read and write outside of your intended data structures • Write beyond loop bounds • Or object bounds • Or overwrite the code pointer, etc. 6 Track Each Byte of Memory • Three states for every byte of tracker memory • Unallocated: cannot be read or written • Allocated but not initialized: cannot be read • Allocated and initialized: all operations are allowed 7 Instrumentation for Purify • Check the state of each byte at every access • Binary instrumentation: • Add
    [Show full text]
  • Memory Debugging
    Center for Information Services and High Performance Computing (ZIH) Memory Debugging HRSK Practical on Debugging, 03.04.2009 Zellescher Weg 12 Willers-Bau A106 Tel. +49 351 - 463 - 31945 Matthias Lieber ([email protected]) Tobias Hilbrich ([email protected]) Content Introduction Tools – Valgrind – DUMA Demo Exercise Memory Debugging 2 Memory Debugging Segmentation faults sometimes happen far behind the incorrect code Memory debuggers help to find the real cause of memory bugs Detect memory management bugs – Access non-allocated memory – Access memory out off allocated bounds – Memory leaks – when pointers to allocated areas get lost forever – etc. Different approaches – Valgrind: Simulation of the program run in a virtual machine which accurately observes memory operations – Libraries like ElectricFence, DMalloc, and DUMA: Replace memory management functions through own versions Memory Debugging 3 Memory Debugging with Valgrind Valgrind detects: – Use of uninitialized memory – Access free’d memory – Access memory out off allocated bounds – Access inappropriate areas on the stack – Memory leaks – Mismatched use of malloc and free (C, Fortran), new and delete (C++) – Wrong use of memcpy() and related functions Available on Deimos via – module load valgrind Simply run program under Valgrind: – valgrind ./myprog More Information: http://www.valgrind.org Memory Debugging 4 Memory Debugging with Valgrind Memory Debugging 5 Memory Debugging with DUMA DUMA detects: – Access memory out off allocated bounds – Using a
    [Show full text]
  • Memory Leak Or Dangling Pointer
    Modern C++ for Computer Vision and Image Processing Igor Bogoslavskyi Outline Using pointers Pointers are polymorphic Pointer “this” Using const with pointers Stack and Heap Memory leaks and dangling pointers Memory leak Dangling pointer RAII 2 Using pointers in real world Using pointers for classes Pointers can point to objects of custom classes: 1 std::vector<int> vector_int; 2 std::vector<int >* vec_ptr = &vector_int; 3 MyClass obj; 4 MyClass* obj_ptr = &obj; Call object functions from pointer with -> 1 MyClass obj; 2 obj.MyFunc(); 3 MyClass* obj_ptr = &obj; 4 obj_ptr->MyFunc(); obj->Func() (*obj).Func() ↔ 4 Pointers are polymorphic Pointers are just like references, but have additional useful properties: Can be reassigned Can point to ‘‘nothing’’ (nullptr) Can be stored in a vector or an array Use pointers for polymorphism 1 Derived derived; 2 Base* ptr = &derived; Example: for implementing strategy store a pointer to the strategy interface and initialize it with nullptr and check if it is set before calling its methods 5 1 #include <iostream > 2 #include <vector > 3 using std::cout; 4 struct AbstractShape { 5 virtual void Print() const = 0; 6 }; 7 struct Square : public AbstractShape { 8 void Print() const override { cout << "Square\n";} 9 }; 10 struct Triangle : public AbstractShape { 11 void Print() const override { cout << "Triangle\n";} 12 }; 13 int main() { 14 std::vector<AbstractShape*> shapes; 15 Square square; 16 Triangle triangle; 17 shapes.push_back(&square); 18 shapes.push_back(&triangle); 19 for (const auto* shape : shapes) { shape->Print(); } 20 return 0; 21 } 6 this pointer Every object of a class or a struct holds a pointer to itself This pointer is called this Allows the objects to: Return a reference to themselves: return *this; Create copies of themselves within a function Explicitly show that a member belongs to the current object: this->x(); 7 Using const with pointers Pointers can point to a const variable: 1 // Cannot change value , can reassign pointer.
    [Show full text]
  • Effective and Efficient Memory Protection Using Dynamic Tainting
    1 Effective and Efficient Memory Protection Using Dynamic Tainting Ioannis Doudalis, Student Member, IEEE, James Clause, Member, IEEE, Guru Venkataramani, Member, IEEE, Milos Prvulovic, Senior Member, IEEE, and Alessandro Orso, Member, IEEE, ! Abstract—Programs written in languages allowing direct access to pointer p or a pointer derived from p and 2) if the access memory through pointers often contain memory-related faults, which occurs during the interval when p is valid, (i.e. between the cause non-deterministic failures and security vulnerabilities. We present allocation and deallocation of m). All other accesses to m are a new dynamic tainting technique to detect illegal memory accesses. illegal memory accesses (IMAs), where a pointer is used to When memory is allocated, at runtime, we taint both the memory and the corresponding pointer using the same taint mark. Taint marks access memory outside the bounds of the memory area with are then propagated and checked every time a memory address m which it was originally associated, or outside the time period is accessed through a pointer p; if the associated taint marks differ, during which the pointer is valid. an illegal access is reported. To allow always-on checking using a IMAs are especially relevant for several reasons. First, they low-overhead, hardware-assisted implementation, we make several key are caused by typical programming errors, such as array-out- technical decisions. We use a configurable, low number of reusable taint of-bounds accesses and stale pointer dereferences, and are thus marks instead of a unique mark for each allocated area of memory, reducing the performance overhead without losing the ability to target widespread and common.
    [Show full text]
  • GC Assertions: Using the Garbage Collector to Check Heap Properties
    GC Assertions: Using the Garbage Collector to Check Heap Properties Edward Aftandilian Samuel Z. Guyer Tufts University Tufts University 161 College Ave 161 College Ave Medford MA Medford MA [email protected] [email protected] ABSTRACT The goal of this work is to develop a general mechanism, which GC assertion ex- This paper introduces GC assertions, a system interface that pro- we call a , that allows the programmer to express pected grammers can use to check for errors, such as data structure in- properties of data structures and convey this information to variant violations, and to diagnose performance problems, such as the garbage collector. The key is that many useful, non-trivial prop- memory leaks. GC assertions are checked by the garbage collec- erties can be easily checked by the garbage collector at GC time, tor, which is in a unique position to gather information and answer imposing little or no run-time overhead. The collector triggers the questions about the lifetime and connectivity of objects in the heap. assertion if it finds that the expected properties have been violated. We introduce several kinds of GC assertions, and we describe how While GC assertions require extra programmer effort, they cap- they are implemented in the collector. We also describe our report- ture application-specific properties that programmers want to check ing mechanism, which provides a complete path through the heap and can easily express. For example, we provide a GC assertion to to the offending objects. We show results for one type of asser- verify that a data structure is reclaimed at the next collection when tion that allows the programmer to indicate that an object should the programmer expects it to be garbage.
    [Show full text]
  • Heapviz: Interactive Heap Visualization for Program Understanding and Debugging
    Heapviz: Interactive Heap Visualization for Program Understanding and Debugging 1 Abstract Understanding the data structures in a program is crucial to understanding how the program works, or why it doesn’t work. Inspecting the code that implements the data structures, however, is an arduous task and often fails to yield insights into the global organization of a program’s data. Inspecting the actual contents of the heap solves these problems but presents a significant challenge of its own: finding an effective way to present the enormous number of objects it contains. In this paper we present Heapviz, a tool for visualizing and exploring snapshots of the heap obtained from a running Java program. Unlike existing tools, such as tra- ditional debuggers, Heapviz presents a global view of the program state as a graph, together with powerful interactive capabilities for navigating it. Our tool employs sev- eral key techniques that help manage the scale of the data. First, we reduce the size and complexity of the graph by using algorithms inspired by static shape analysis to aggregate the nodes that make up a data structure. Second, we implement a power- ful visualization component whose interactive interface provides extensive support for exploring the graph. The user can search for objects based on type, connectivity, and field values; group objects; and color or hide and show each group. The user may also inspect individual objects to see their field values and neighbors in the graph. These interactive abilities help the user manage the complexity of these huge graphs. By applying Heapviz to both constructed and real-world examples, we show that Heapviz provides programmers with a powerful and intuitive tool for exploring program behavior.
    [Show full text]
  • Tutorial on Debugging, Memory Leaks and Profiling
    High Performance Computing for Science and Engineering I Tutorial on debugging, memory leaks and profiling Michalis Chatzimanolakis Computational Science & Engineering Laboratory OUTLINE - Approaches to debug your code •Using assertions •Using a debugger •Memory sanitation •Using a profiler Assertions in C++ An assertion is a logical statement that will cause your code to abort execution, if it is false. Example: Assertions can affect performance, Assertions perform checks that make sure that as they are essentially ‘if’ statements. some conditions are met. However, it is good practice to add assertions in a code. A simple compilation flag can ignore all assertions, so it is generally a good idea to use them. It is useful to combine assertions with the std functions isinf and isnan They can also be used with screen output. Compiler warnings Compiler warnings are compilation flags that you can (should) add to your Makefiles. Enabling warnings makes the compiler check for several issues in your source file, such as: • Forgetting to initialize a variable • Not using a declared variable • Using a function before declaring it • Having screen/file output with incorrect format (for example, treating doubles as integers) Generally, you should add warnings and try to fix all of them, before proceeding with further debugging your code. Note that different compilers may produce different warnings. The most common compiler warning flags are listed below: -Wall : enables several construction/declaration warnings -Wextra : more warnings than Wall including warnings for unused variables -Werror: will treat all warnings as errors -Wpedantic: warnings related to the use of non standard C++ extensions Using a debugger What is a debugger? A debugger is a program.
    [Show full text]
  • Efficient and Programmable Support for Memory Access Monitoring And
    Appears in the Proceedings of the 13th International Symposium on High-Performance Computer Architecture (HPCA-13), February 2007. MemTracker: Efficient and Programmable Support for Memory Access Monitoring and Debugging ∗ Guru Venkataramani Brandyn Roemer Yan Solihin Milos Prvulovic Georgia Tech Georgia Tech North Carolina State University Georgia Tech [email protected] [email protected] [email protected] [email protected] Abstract many of these tasks, performance overheads of such tools are prohibitive, especially in post-deployment monitoring of live Memory bugs are a broad class of bugs that is becoming (production) runs where end users are directly affected by the increasingly common with increasing software complexity, overheads of the monitoring scheme. and many of these bugs are also security vulnerabilities. Un- One particularly important and broad class of program- fortunately, existing software and even hardware approaches ming errors is erroneous use or management of memory for finding and identifying memory bugs have considerable (memory bugs). This class of errors includes pointer arith- performance overheads, target only a narrow class of bugs, metic errors, use of dangling pointers, reads from unini- are costly to implement, or use computational resources in- tialized locations, out-of-bounds accesses (e.g. buffer over- efficiently. flows), memory leaks, etc. Many software tools have been This paper describes MemTracker, a new hardware sup- developed to detect some of these errors. For example, Pu- port mechanism that can be configured to perform different rify [8] and Valgrind [13] detect memory leaks, accesses to kinds of memory access monitoring tasks. MemTracker as- unallocated memory, reads from uninitialized memory, and sociates each word of data in memory with a few bits of some dangling pointer and out-of-bounds accesses.
    [Show full text]
  • Memory Vulnerability Diagnosis for Binary Program
    ITM Web of Conferences 7 03004 , (2016) DOI: 10.1051/itmconf/20160703004 ITA 2016 Memory Vulnerability Diagnosis for Binary Program Feng-Yi TANG, Chao FENG and Chao-Jing TANG College of Electronic Science and Engineering National University of Defense Technology Changsha, China Abstract. Vulnerability diagnosis is important for program security analysis. It is a further step to understand the vulnerability after it is detected, as well as a preparatory step for vulnerability repair or exploitation. This paper mainly analyses the inner theories of major memory vulnerabilities and the threats of them. And then suggests some methods to diagnose several types of memory vulnerabilities for the binary programs, which is a difficult task due to the lack of source code. The diagnosis methods target at buffer overflow, use after free (UAF) and format string vulnerabilities. We carried out some tests on the Linux platform to validate the effectiveness of the diagnosis methods. It is proved that the methods can judge the type of the vulnerability given a binary program. 1 Introduction (or both) the memory area. These headers can contain some information like size, used or not, and etc. Memory vulnerabilities are difficult to detect and diagnose Therefore, we can monitor the allocator so as to especially for those do not crash the program. Due to its determine the base address and the size of the allocation importance, vulnerability diagnosis problem has been areas. Then, check all STORE and LOAD accesses in intensively studied. Researchers have proposed different memory to see which one is outside the allocated area. techniques to diagnose memory vulnerabilities.
    [Show full text]
  • A Statistical Approach for Identifying Memory Leaks in Cloud Applications
    A STATISTICAL APPROACH FOR IDENTIFYING MEMORY LEAKS IN CLOUD APPLICATIONS Vladimir Sorˇ and Satish Narayana Srirama Institute of Computer Science, University of Tartu, J. Liivi 2, Tartu, Estonia Keywords: Troubleshooting, JavaTM Virtual Machine, Byte code instrumentation, Cloud computing, Tools. Abstract: This position paper describes the attempt to automate the statistical approach for memory leak detection in JavaTM applications. Proposed system extends the basic statistical memory leak detection method with further intelligence to pinpoint the source of the memory leak in the source code. As the method adds only small overhead in runtime it is designed to be used in production systems and will help detecting memory leaks in production environments without constraint to the source of the leak. Architecture of the proposed approach is intended to use in cloud applications. 1 INTRODUCTION in production under very specific circumstances (of- ten hardly specifiable) can be very hard to find and fix Memory leaks can be a major problem in distributed in development and test environments. applications, depleting their performance, even if they This is the area we think we can improve by de- run on platforms with automatic memory manage- veloping the solution that uses efficient statistical al- ment like Java Virtual Machine. Finding memory gorithm to detect memory leaks in advance, imposes leaks is coveredby many researches and there are sev- low overhead in production system and would help eral tools and methodologies to find memory leaks. tracking down the source of the leak. The rest of the However, these tools are incorporated in profilers and paper is organized as follows.
    [Show full text]