Results 1 - 10
of
17
Algorithmic profiling
- In Proc. PLDI
, 2012
"... Traditional profilers identify where a program spends most of its resources. They do not provide information about why the pro-gram spends those resources or about how resource consumption would change for different program inputs. In this paper we intro-duce the idea of algorithmic profiling. While ..."
Abstract
-
Cited by 13 (0 self)
- Add to MetaCart
(Show Context)
Traditional profilers identify where a program spends most of its resources. They do not provide information about why the pro-gram spends those resources or about how resource consumption would change for different program inputs. In this paper we intro-duce the idea of algorithmic profiling. While a traditional profiler determines a set of measured cost values, an algorithmic profiler determines a cost function. It does that by automatically determin-ing the “inputs ” of a program, by measuring the program’s “cost” for any given input, and by inferring an empirical cost function.
Abstracting Runtime Heaps for Program Understanding
, 2012
"... Modern programming environments provide extensive support for inspecting, analyzing, and testing programs based on the algorithmic structure of a program. Unfortunately, support for inspecting and understanding runtime data structures during execution is typically much more limited. This paper provi ..."
Abstract
-
Cited by 12 (5 self)
- Add to MetaCart
(Show Context)
Modern programming environments provide extensive support for inspecting, analyzing, and testing programs based on the algorithmic structure of a program. Unfortunately, support for inspecting and understanding runtime data structures during execution is typically much more limited. This paper provides a general purpose technique for abstracting and summarizing entire runtime heaps. We describe the abstract heap model and the associated algorithms for transforming a concrete heap dump into the corresponding abstract model as well as algorithms for merging, comparing, and computing changes between abstract models. The abstract model is designed to emphasize high-level concepts about heap-based data structures, such as shape and size, as well as relationships between heap structures, such as sharing and connectivity. We demonstrate the utility and computational tractability of the abstract heap model by building a memory profiler. We then use this tool to check for, pinpoint, and correct sources of memory bloat from a suite of programs from DaCapo.
Collecting a Heap of Shapes
, 2011
"... Abstract. A large gap exists between the wide range of admissible heap structures and those that programmers actually build. To understand this gap, we empirically study heap structures and their sharing relations in real-world programs. Our goal is to characterize these heaps. Our study rests on a ..."
Abstract
-
Cited by 7 (6 self)
- Add to MetaCart
(Show Context)
Abstract. A large gap exists between the wide range of admissible heap structures and those that programmers actually build. To understand this gap, we empirically study heap structures and their sharing relations in real-world programs. Our goal is to characterize these heaps. Our study rests on a heap abstraction that uses structural indistinguishability principles to group objects that play the same role. Our results shed light on prevalence of recursive data-structures, aggregation, and the sharing patterns that occur in programs. We find, for example, that real-world heaps are dominated by atomic shapes (79 % on average) and the majority of sharing occurs via common programming idioms. In short, the heap is, in practice, a simple structure constructed out of a small number of simple structures. Our findings imply that garbage collection and program analysis may achieve a high return by focusing on simple heap structures. 1
Heap Analysis Design: An Empirical Approach
"... Despite extensive work on the subject, the construction of a precise, accurate, and scalable static heap analysis for object-oriented programs remains an open problem. This paper argues that much of this difficulty is the result of inappropriate, and empirically unvalidated, design decisions. We exa ..."
Abstract
-
Cited by 2 (0 self)
- Add to MetaCart
(Show Context)
Despite extensive work on the subject, the construction of a precise, accurate, and scalable static heap analysis for object-oriented programs remains an open problem. This paper argues that much of this difficulty is the result of inappropriate, and empirically unvalidated, design decisions. We examine three them and show that in practice: (1) strong updates are not necessary for obtaining accurate results (2) fixed naming schemes for defining abstract memory locations are fundamentally limiting and are not required for efficiency, and (3) shape/sharing in the heap is generally simple and can be described using a simple abstract heap model. Using these results we construct a new heap analysis and experimentally demonstrate that it is both precise and accurate, enabling program optimizations that are not possible with existing points-to analyses, and scalable, allowing the analysis of programs outside the scope of existing shape analyses. 1.
High-level heap abstractions for debugging programs
, 2010
"... The identification, isolation, and correction of program defects require the understanding of both the algorithmic structure of the code as well as the data structures that are being manipulated. While modern development environments provide substantial support for examining the program source code ..."
Abstract
-
Cited by 2 (0 self)
- Add to MetaCart
The identification, isolation, and correction of program defects require the understanding of both the algorithmic structure of the code as well as the data structures that are being manipulated. While modern development environments provide substantial support for examining the program source code (the algorithmic aspect of the program), they provide relatively weak support for examining heap-based data structures. The goal of our work is to provide support for understanding data structures on the heap and the relations between them. This paper introduces a novel approach that emphasizes highlevel concepts about heap based data structures (their layout and size) and relationships between them (sharing and connectivity). The proposed abstract representation of the program is designed to help the developer look past, often unimportant, details and focus on understanding the overall structure of the program’s computation. When used in conjunction with the low-level view of individual values and objects provided by traditional debuggers, the highlevel information in the abstract heap representation can be used to identify and diagnose subtle errors, as demonstrated via several case studies identifying heap related program defects. Further, we give an efficient algorithm for computing this abstract representation that scales quasilinearly with the size of the heap.
Identifying dynamic data structures by learning evolving patterns in memory
- In TACAS 2013, vol. 7795 of LNCS
, 2013
"... Abstract. We investigate whether dynamic data structures in pointer programs can be identified by analysing program executions only. This paper describes a first step towards solving this problem by applying ma-chine learning and pattern recognition techniques to analyse executions of C programs. By ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
(Show Context)
Abstract. We investigate whether dynamic data structures in pointer programs can be identified by analysing program executions only. This paper describes a first step towards solving this problem by applying ma-chine learning and pattern recognition techniques to analyse executions of C programs. By searching for repeating temporal patterns in mem-ory caused by multiple invocations of data-structure operations, we are able to first locate and then identify these operations. Applying a proto-typic tool implementing our approach to pointer programs that employ, e.g., lists, queues and stacks, we show that the identified operations can accurately determine the data structures used.
Enabling Modularity and Re-use in Dynamic Program Analysis Tools for the Java Virtual Machine
"... Abstract. Dynamic program analysis tools based on code instrumenta-tion serve many important software engineering tasks such as profiling, debugging, testing, program comprehension, and reverse engineering. Un-fortunately, constructing new analysis tools is unduly difficult, because existing framewo ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
Abstract. Dynamic program analysis tools based on code instrumenta-tion serve many important software engineering tasks such as profiling, debugging, testing, program comprehension, and reverse engineering. Un-fortunately, constructing new analysis tools is unduly difficult, because existing frameworks offer little or no support to the programmer beyond the incidental task of instrumentation. We observe that existing dynamic analysis tools re-address recurring requirements in their essential task: maintaining state which captures some property of the analysed program. This paper presents a general architecture for dynamic program analysis tools which treats the maintenance of analysis state in a modular fashion, consisting of mappers decomposing input events spatially, and updaters aggregating them over time. We show that this architecture captures the requirements of a wide variety of existing analysis tools. 1
Published online in Wiley InterScience (www.interscience.wiley.com). DOI: 10.1002/spe C-strider: Type-Aware Heap Traversal for C
"... Researchers have proposed many tools and techniques that work by traversing the heap, including checkpointing systems, heap profilers, heap assertion checkers, and dynamic software updating systems. Yet building a heap traversal for C remains difficult, and to our knowledge extant services have used ..."
Abstract
- Add to MetaCart
(Show Context)
Researchers have proposed many tools and techniques that work by traversing the heap, including checkpointing systems, heap profilers, heap assertion checkers, and dynamic software updating systems. Yet building a heap traversal for C remains difficult, and to our knowledge extant services have used their own application-specific traversals. This paper presents C-strider, a framework for writing C heap traversals and transformations. Writing a basic C-strider service requires implementing only four callbacks; C-strider then generates a program-specific traversal that invokes the callbacks as each heap location is visited. Critically, C-strider is type aware—it tracks types as it walks the heap, so every callback is supplied with the exact type of the associated location. We used C-strider to implement heap serialization, dynamic software updating, heap checking, and profiling, and then applied the resulting traversals to several programs. We found C-strider requires little programmer effort, and the resulting services are efficient and effective. Copyright ©
unknown title
"... The program heap is fundamentally a simple mathematical concept — a set of objects and a connectivity relation on them. However, a large gap exists between the set of heap structures that could be constructed and those that programmers actually build. To understand this gap, we empirically study hea ..."
Abstract
- Add to MetaCart
(Show Context)
The program heap is fundamentally a simple mathematical concept — a set of objects and a connectivity relation on them. However, a large gap exists between the set of heap structures that could be constructed and those that programmers actually build. To understand this gap, we empirically study heap structures and sharing relations in large object-oriented programs. To scale and make sense of real world heaps, any analysis must employ abstraction; our abstraction groups sets of objects by role and the aliasing present in pointer sets. We find that the heaps of real-world programs are, in practice, fundamentally simple structures that are largely constructed from a small number of simple structures and sharing idioms, such as the sharing of immutable or unique (e.g. singleton) objects. For instance, we find that, under our abstraction, 53–75 % of pointers build tree structures and we classify all but 7–18 % of aliasing pointers. These results provide actionable information for rethinking the design of annotation systems, memory allocation/collection, and program analyses.
