Data layouts for object-oriented programs

HirzelMartin,

doi:10.1145/1269899.1254915

Cited by 7 publications

(7 citation statements)

References 68 publications

(43 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Hirzel studies the locality benefits of 12 data layouts on 32 benchmarks in a garbage collection environment and shows that 6 Personal communication with the author almost all layouts yield the best performance for some applications and the worst for others (15). We believe that the wide performance variance of different data layouts reported by the author encourages explicit locality improving techniques, due to their ability to customize an application's data layout.…”

Section: Related Workmentioning

confidence: 92%

Two memory allocators that use hints to improve locality

Jula¹,

Rauchwerger

2009

Proceedings of the 2009 International Symposium on Memory Management

View full text Add to dashboard Cite

Dynamic memory allocators affect an application's performance through their data layout quality. They can use an application's allocation hints to improve the spatial locality of this layout. However, a practical approach needs to be automatic, without user intervention. In this paper we present two locality improving allocators, that use allocation hints provided automatically from the C++ STL library to improve an application's spatial locality. When compared to state-of-the-art allocators on seven real world applications, our allocators run on average 7% faster than the Lea allocator, and 17% faster than the FreeBSD's allocator, with the same memory fragmentation as the Lea allocator, one of the best allocators.While considering locality as an important goal, locality improving allocators must not abandon the existing constraints of fast allocation speed and low fragmentation. These constraints further challenge their design and implementation. We experimentally show that within a memory allocator, allocation speed, memory fragmentation, and spatial locality compete with each other in a game of rock, paper, scissors: when one tries to improve one trait, the others suffer. We conclude that our allocators achieve a good balance of these traits, and they can easily be adjusted to optimize the most important trait for each application.

show abstract

Section: Related Workmentioning

confidence: 92%

Two memory allocators that use hints to improve locality

Jula¹,

Rauchwerger

2009

Proceedings of the 2009 International Symposium on Memory Management

View full text Add to dashboard Cite

show abstract

“…Tuning Placement Strategy Hirzel experiments with different placement strategies for garbage collection [Hirzel 2007]. He finds that every placement strategy (allocation order, depth-first, breadth-first, etc.)…”

Section: Garbage Collection and Compactionmentioning

confidence: 99%

“…Garbage Collection for Program Locality Hirzel [Hirzel 2007] uses a moving garbage collector in order to implement several data layouts of object oriented programs and evaluate which layout presents the best performance.…”

Section: Related Workmentioning

confidence: 99%

You can have it all: abstraction and good cache performance

Franco

Hagelin

Wrigstad

et al. 2017

Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Sof

View full text Add to dashboard Cite

On current architectures, the optimisation of an application's performance often involves data being stored according to access affinity -what is accessed together should be stored together, rather than logical affinity -what belongs together logically stays together. Such low level techniques lead to faster, but more error prone code, and end up tangling the program's logic with low-level data layout details.Our vision, which we call SHAPES-Safe, High-level, Abstractions for oPtimisation of mEmory cacheS -is that the layout of a data structure should be defined only once, upon instantiation, and the remainder of the code should be layout agnostic. This enables performance improvements while also guaranteeing memory safety, and supports the separation of program logic from low level concerns. In this paper we investigate how this vision can be supported by extending a programming language.We describe the core language features supporting this vision: classes can be customized to support different layouts, and layout information is carried around in types; the remaining source code is layout-unaware and the compiler emits layout-aware code. We then discuss our SHAPES implementation through a prototype library, which we also used for preliminary evaluations. Finally, we discuss how the core could be expanded so as to deliver SHAPES's full potential: the incorporation of compacting garbage collection, * Work done while at Uppsala University.

show abstract

“…The memory space composes the locations in which the elements in memory actually reside. The translation of virtual address to memory address is accomplished by the translation lookaside buffer (TLB) [Hirzel, 2007]. Virtual memory allows decoupling of memory access from machine dependent memory configuration and location.…”

Section: Virtual Memorymentioning

confidence: 99%

“…Once a query is executed, another 3 Refer to Hirzel [2007] and Lattner and Adve [2005] for efforts to provide fine-grained control of the data layouts of object-oriented programs. query in the execution queue is selected and assigned one or more buffers based on the demand, current availability, and currently executing queries [Faloutsos et al, 1995].…”

Section: Buffer Managementmentioning

confidence: 99%

JDiet: Footprint Reduction for Memory-constrained Systems

Huffman¹

View full text Add to dashboard Cite

Main memory remains a scarce computing resource. Even though main memory is becoming more abundant, software applications are inexorably engineered to consume as much memory as is available. For example, expert systems, scientific computing, data mining, and embedded systems commonly suffer from the lack of main memory availability. This thesis introduces JDiet, an innovative memory management system for Java applications. The goal of JDiet is to provide the developer with a highly configurable framework to reduce the memory footprint of a memory-constrained system, enabling it to operate on much larger working sets. Inspired by buffer management techniques common in modern database management systems, JDiet frees main memory by evicting non-essential data to a disk-based store. A buffer retains a fixed amount of managed objects in main memory. As non-resident objects are accessed, they are swapped from the store to the buffer using an extensible replacement policy.While the Java virtual machine naïvely delegates virtual memory management to the operating system, JDiet empowers the system designer to select both the managed data and replacement policy.

show abstract

Data layouts for object-oriented programs

Cited by 7 publications

References 68 publications

Two memory allocators that use hints to improve locality

Two memory allocators that use hints to improve locality

You can have it all: abstraction and good cache performance

JDiet: Footprint Reduction for Memory-constrained Systems

Contact Info

Product

Resources

About