Uniqueness inference for compile-time object deallocation

Cherem, Sigmund; Rugina, Radu

doi:10.1145/1296907.1296923

“…The approaches closest to ours are compile-time deallocation for Java [23,31,32]. These approaches insert dedicated deallocation statements into Java bytecode to reduce the number of references needed to be scanned by the garbage collector, so as to enhance runtime performance.…”

Section: Related Workmentioning

confidence: 99%

“…For example, Free-me [23] uses live analysis to find the place for deallocation, and live analysis fundamentally only identifies uses of memory chunks but not whether they are freed. Furthermore, Cherem and Rugina's approach [31,32] strictly obeys the semantic of Java, reclaiming an object only when all its references are lost. This will lead to inefficient memory usage because an object may be referenced for a long time without being used.…”

Section: Related Workmentioning

confidence: 99%

Safe Memory-Leak Fixing for C Programs

Gao

¹

,

Xiong

²

,

Mi

³

et al. 2015

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering

View full text Add to dashboard Cite

Abstract-Automatic bug fixing has become a promising direction for reducing manual effort in debugging. However, general approaches to automatic bug fixing may face some fundamental difficulties. In this paper, we argue that automatic fixing of specific types of bugs can be a useful complement.This paper reports our first attempt towards automatically fixing memory leaks in C programs. Our approach generates only safe fixes, which are guaranteed not to interrupt normal execution of the program. To design such an approach, we have to deal with several challenging problems such as inter-procedural leaks, global variables, loops, and leaks from multiple allocations. We propose solutions to all the problems and integrate the solutions into a coherent approach.We implemented our inter-procedural memory leak fixing into a tool named LeakF ix and evaluated LeakF ix on 15 programs with 522k lines of code. Our evaluation shows that LeakF ix is able to successfully fix a substantial number of memory leaks, and LeakF ix is scalable for large applications.

show abstract

“…Cherem and Rugina [7] propose an algorithm to identify object variables and object fields that hold unique references, and then instrument the programs with explicit deallocation of individual objects. The algorithm can only work with mark-sweep GC.…”

Section: Related Workmentioning

confidence: 99%

Cycler: Improve Heap Management for Allocation-Intensive Applications with On-the-Fly Object Reuse

Xiao¹,

Li²

2012

Parallel and Distributed Computing and Systems

0

View full text Add to dashboard Cite

Tracing garbage collection (GC) identifies dead objects by scanning the object-graph from the root set references. It is proven to be highly efficient and widely used in commercial managed runtime systems for Java, C# and scripting languages. However, tracing GC cannot identify the dead objects before finishing object-graph traversal. Hence the application cannot reuse the space of the dead objects in realtime when the objects are no longer live. Even there are lots of dead objects, the system has to keep allocating new space for new objects until the object-graph is scanned, which has negative impact on both space efficiency, bandwidth efficiency and cache efficiency. The issue becomes serious with allocation-intensive applications. Some prior work tries to improve tracing GC with compilation analysis to identify the dead objects in compilation time. But they can only work with sub-optimal GC algorithm such as mark-sweep, and/or can only discover a small portion of the dead objects. In this paper we propose an algorithm Cycler that can reuse the dead objects in real-time before the object graph scanning. Cycler enhances the existing high-performance tracing GC with reference counting. The novelty of the algorithm is that it does not interfere with the existing optimal tracing GC, so it can effectively improve the overall performance, as long as the runtime overhead of reference counting is well constrained. To control the runtime overhead, Cycler only counts the object references of major types. In this paper, we describe Cycler design and implementation, and also present our evaluations with standard benchmarks.

show abstract

“…There is previous work [2,7,8] employing compilation-time analysis to identify dead objects and trying to work together with the tracing GC. Cherem and Rugina [7] propose an algorithm to identify object variables and object fields that hold unique references, and then instrument the programs with explicit deallocation of individual objects.…”

Section: Related Workmentioning

confidence: 99%

Cycler: Improve Heap Management for Allocation-Intensive Applications with On-the-Fly Object Reuse

Li-juan¹,

Li²

2011

Parallel and Distributed Computing and Systems

0

View full text Add to dashboard Cite

Tracing garbage collection (GC) identifies dead objects by scanning the object-graph from the root set references. It is proven to be highly efficient and widely used in commercial managed runtime systems for Java, C# and scripting languages. However, tracing GC cannot identify the dead objects before finishing object-graph traversal. Hence the application cannot reuse the space of the dead objects in realtime when the objects are no longer live. Even there are lots of dead objects, the system has to keep allocating new space for new objects until the object-graph is scanned, which has negative impact on both space efficiency, bandwidth efficiency and cache efficiency. The issue becomes serious with allocation-intensive applications. Some prior work tries to improve tracing GC with compilation analysis to identify the dead objects in compilation time. But they can only work with sub-optimal GC algorithm such as mark-sweep, and/or can only discover a small portion of the dead objects. In this paper we propose an algorithm Cycler that can reuse the dead objects in real-time before the object graph scanning. Cycler enhances the existing high-performance tracing GC with reference counting. The novelty of the algorithm is that it does not interfere with the existing optimal tracing GC, so it can effectively improve the overall performance, as long as the runtime overhead of reference counting is well constrained. To control the runtime overhead, Cycler only counts the object references of major types. In this paper, we describe Cycler design and implementation, and also present our evaluations with standard benchmarks.

show abstract

Uniqueness inference for compile-time object deallocation

Cited by 19 publications

References 19 publications

Safe Memory-Leak Fixing for C Programs

Safe Memory-Leak Fixing for C Programs

Cycler: Improve Heap Management for Allocation-Intensive Applications with On-the-Fly Object Reuse

Cycler: Improve Heap Management for Allocation-Intensive Applications with On-the-Fly Object Reuse

Contact Info

Product

Resources

About