Topic
Collection
About: Collection is a research topic. Over the lifetime, 25 publications have been published within this topic receiving 519 citations.
Papers
TL;DR: In this article, the authors propose an end-to-end static analysis to distinguish live objects from reachable objects and use this information to make dead objects unreachable by modifying the program.
Abstract: Despite significant progress in the theory and practice of program analysis, analyzing properties of heap data has not reached the same level of maturity as the analysis of static and stack data The spatial and temporal structure of stack and static data is well understood while that of heap data seems arbitrary and is unbounded We devise bounded representations that summarize properties of the heap data This summarization is based on the structure of the program that manipulates the heap The resulting summary representations are certain kinds of graphs called access graphs The boundedness of these representations and the monotonicity of the operations to manipulate them make it possible to compute them through data flow analysis An important application that benefits from heap reference analysis is garbage collection, where currently liveness is conservatively approximated by reachability from program variables As a consequence, current garbage collectors leave a lot of garbage uncollected, a fact that has been confirmed by several empirical studies We propose the first ever end-to-end static analysis to distinguish live objects from reachable objects We use this information to make dead objects unreachable by modifying the program This application is interesting because it requires discovering data flow information representing complex semantics In particular, we formulate the following new analyses for heap data: liveness, availability, and anticipability and propose solution methods for them Together, they cover various combinations of directions of analysis (ie, forward and backward) and confluence of information (ie union and intersection) Our analysis can also be used for plugging memory leaks in C/Cpp languages
142 citations
Patent•
30 May 1997TL;DR: In this paper, the authors describe a generational garbage collection on a shared heap memory shared by multiple processing units, where one of the processing units detects that the free space available for node creation is below a threshold, and signals the other processing units to also pause mutation.
Abstract: Apparatus, methods, systems and computer program products are disclosed describing generational garbage collection on a card-marked heap memory shared by multiple processing units. When one of the processing units detects that the free space available for node creation is below a threshold, that processing unit pauses its heap mutation processes and signals the other processing units to also pause mutation. After the other processing units pause heap mutation, the processing units then proceed to execute generational garbage collection procedures on the shared heap. The generational garbage collection procedures for each processing unit are driven by pointers stored in each processing unit's register, stack and static variables along with pointers within a specified partition of the shared card-marked heap. The processing units resume mutation of the heap once they all complete their garbage collection processes.
68 citations
Patent•
26 Feb 2002
TL;DR: In this article, a partitioned scheduling heap data structure is proposed for data packet transmission scheduling using a plurality of levels for storing scheduling values for data packets according to their relative priorities.
Abstract: The present invention is directed toward methods and apparatus for data packet transmission scheduling using a partitioned scheduling heap data structure. The scheduling heap data structure has a plurality of levels for storing scheduling values for data packets according to their relative priorities. A highest level in the heap has a single position and each succeeding lower level has twice the number of positions as the preceding level. The data structure may be adapted to store a plurality of logical heaps within the heap data structure by assigning a highest level of each logical heap to a level in the heap data structure that is lower than the highest level. Thus, a single physical memory may be adapted to store plural logical heaps. This is useful because a single physical memory can be adapted to prioritize packets of various different transmission protocols and speeds.
62 citations
Patent•
IBM1
TL;DR: In this paper, a library heap management facility is used to manage the supply of memory managed in multiple heaps by a user-supplied heap management system, and a callback function notifies the user when a supplied unit of memory is no longer required by the heap and may be disposed of.
Abstract: Control and administration of the supply of memory managed in multiple heaps by a library heap management facility. Control data used by the heap management facility is located in user-supplied memory. Heaps are created dynamically through calls from the application to a runtime library. Allocation within a heap is performed through calls to the runtime library that canvass the available heap memory for each allocation request. If no suitable block of heap memory is located, additional user supplied memory is requested for the application through a callback function. A second callback function notifies the user when a supplied unit of memory is no longer required by the heap and may be disposed of. The callback functions are specified separately for each heap. The user may also set the default heap in the runtime library by allocation requests from a vendor library that do not specify a heap. This can be done a per thread basis in multithreaded applications so that different executing threads can use different default heaps in a non-interfering manner.
62 citations
TL;DR: This work describes various summarization techniques based on k-limiting, allocation sites, patterns, variables, other generic instrumentation predicates, and higher-order logics and classify the heap models as storeless, store based, and hybrid.
Abstract: Heap data is potentially unbounded and seemingly arbitrary. Hence, unlike stack and static data, heap data cannot be abstracted in terms of a fixed set of program variables. This makes it an interesting topic of study and there is an abundance of literature employing heap abstractions. Although most studies have addressed similar concerns, insights gained in one description of heap abstraction may not directly carry over to some other description. In our search of a unified theme, we view heap abstraction as consisting of two steps: (a) heap modelling, which is the process of representing a heap memory (i.e., an unbounded set of concrete locations) as a heap model (i.e., an unbounded set of abstract locations), and (b) summarization, which is the process of bounding the heap model by merging multiple abstract locations into summary locations. We classify the heap models as storeless, store based, and hybrid. We describe various summarization techniques based on k-limiting, allocation sites, patterns, variables, other generic instrumentation predicates, and higher-order logics. This approach allows us to compare the insights of a large number of seemingly dissimilar heap abstractions and also paves the way for creating new abstractions by mix and match of models and summarization techniques.
58 citations
Related Topics (5)
Performance Metrics
| Year | Papers |
|---|---|
| 2016 | 2 |
| 2015 | 3 |
| 2014 | 1 |
| 2013 | 1 |
| 2012 | 3 |
| 2008 | 1 |