Automatic pool allocation: improving performance by controlling data structure layout in the heap

@inproceedings{Lattner2005AutomaticPA,
  title={Automatic pool allocation: improving performance by controlling data structure layout in the heap},
  author={Chris Lattner and Vikram S. Adve},
  booktitle={PLDI '05},
  year={2005}
}
This paper describes Automatic Pool Allocation, a transformation framework that segregates distinct instances of heap-based data structures into seperate memory pools and allows heuristics to be used to partially control the internal layout of those data structures. The primary goal of this work is performance improvement, not automatic memory management, and the paper makes several new contributions. The key contribution is a new compiler algorithm for partitioning heap objects in imperative… Expand
A Compilation Framework for the Automatic Restructuring of Pointer-Linked Data Structures
TLDR
This chapter describes a new, generic restructuring framework for the optimization of data layout of pointer-linked data structures and describes and evaluates the restructuring methodology, which involves compile-time analysis, run-time rewriting of memory regions and updating referring pointers on both the heap and the stack. Expand
Layout Transformations for Heap Objects Using Static Access Patterns
TLDR
The experiments with the Olden benchmarks demonstrate that layout transformations for heap objects based on the static access pattern analysis improve cache locality by 38% and performance by 24%. Expand
Macroscopic data structure analysis and optimization
TLDR
A new class of techniques named "Macroscopic Data Structure Analyses and Optimizations" is presented, which is a new approach to the problem of analyzing and optimizing pointer-intensive programs, and a large class of potential applications for the work in fields such as heap safety and reliability, program understanding, distributed computing, and static garbage collection are described. Expand
Automatic Restructuring of Linked Data Structures
TLDR
This paper presents a compilation and run-time framework that enables fully automatic restructuring of pointer- linked data structures for type-unsafe languages, such as C, and shows that restructuring pointer-linked data structures can yield substantial speedups. Expand
Abstracting access patterns of dynamic memory using regular expressions
TLDR
This work describes how to extract memory access patterns as regular expressions in detail and devise and apply new abstraction techniques, which build and interpret access patterns for the whole programs in a bottom-up fashion, to make a scalable framework. Expand
Whole-program optimization of global variable layout
TLDR
This paper discusses Global Variable Layout (GVL), an optimization of the placement of entire static global data objects in the binary, and describes two practical methods for GVL in the HP-UX Integrity optimizing compiler for the Itanium © architecture. Expand
Practical structure layout optimization and advice
TLDR
This paper describes a practical implementation of the data layout optimizations structure splitting, structure peeling, structure field reordering and dead field removal, both for profile and non-profile based compilations. Expand
On improving heap memory layout by dynamic pool allocation
TLDR
A lightweight dynamic optimizer, named Dynamic Pool Allocation, which aims to exploit the affinity of the allocated heap objects and improve their layout at run-time, and examines the factors that could affect the effectiveness of such layout. Expand
Automatic Restructuring of Linked Data Structures
TLDR
This paper presents a compilation and run-time framework that enables fully au- tomatic restructuring of pointer-linked data structures for type-unsafe languages, such as C, and shows that restructuring pointer- linked data structures can yield substantial speedups. Expand
Palloc: parallel dynamic memory allocation
TLDR
PALLOC2's performance is superior to PALLOC1 and to other state-of-the-art allocators including Hoard, DLMalloc, and Stream ow for allocations of all sizes and the capabilities of baggy bounds checking with no performance impact. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 50 REFERENCES
Macroscopic data structure analysis and optimization
TLDR
A new class of techniques named "Macroscopic Data Structure Analyses and Optimizations" is presented, which is a new approach to the problem of analyzing and optimizing pointer-intensive programs, and a large class of potential applications for the work in fields such as heap safety and reliability, program understanding, distributed computing, and static garbage collection are described. Expand
Automatic pool allocation for disjoint data structures
This paper presents an analysis technique and a novel program transformation that can enable powerful optimizations for entire linked data structures. The fully automatic transformation convertsExpand
Supporting dynamic data structures on distributed-memory machines
TLDR
An execution model for supporting programs that use pointer-based dynamic data structures is described that uses a simple mechanism for migrating a thread of control based on the layout of heap-allocated data and introduces parallelism using a technique based on futures and lazy task creation. Expand
Better static memory management: improving region-based analysis of higher-order languages
TLDR
This work improves upon the Tofte/Talpin region-based scheme for compile-time memory management and reduces memory requirements significantly, in some cases asymptotically. Expand
Using generational garbage collection to implement cache-conscious data placement
TLDR
This paper studies a technique for using a generational garbage collector to reorganize data structures to produce a cache-conscious data layout, in which objects with high temporal affinity are placed next to each other, so that they are likely to reside in the same cache block. Expand
Reconsidering custom memory allocation
TLDR
The results indicate that programmers needing fast regions should use reaps, and that most programmers considering custom allocators should instead use the Lea allocator. Expand
The garbage collection advantage: improving program locality
TLDR
This paper introduces OOR, a new dynamic, online class analysis for Java that detects program traversal patterns and exploits them in a copying collector and compares program performance of OOR to static class-oblivious copying orders (e.g., breadth and depth first). Expand
Region analysis and transformation for Java programs
TLDR
The results indicate that, for several of the benchmarks, the transformation can allocate most of the data on stack or in short-lived regions, and can yield substantial memory savings. Expand
Escape analysis for Java
TLDR
A new program abstraction for escape analysis, the connection graph, that is used to establish reachability relationships between objects and object references is introduced and it is shown that the connectiongraph can be summarized for each method such that the same summary information may be used effectively in different calling contexts. Expand
Memory safety without garbage collection for embedded applications
TLDR
A compiler technique is described that ensures that dereferencing dangling pointers to freed memory does not violate memory safety, without annotations, run-time checks, or garbage collection, and works for arbitrary type-safe C programs. Expand
...
1
2
3
4
5
...