4.2BSD and 4.3BSD as examples of the UNIX system
ACM Computing Surveys (CSUR) - The MIT Press scientific computation series
A comparative performance evaluation of write barrier implementation
OOPSLA '92 conference proceedings on Object-oriented programming systems, languages, and applications
Design, implementation, and evaluation of optimizations in a just-in-time compiler
JAVA '99 Proceedings of the ACM 1999 conference on Java Grande
ABCD: eliminating array bounds checks on demand
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Eliminating external fragmentation in a non-moving garbage collector for Java
CASES '00 Proceedings of the 2000 international conference on Compilers, architecture, and synthesis for embedded systems
A real-time garbage collector based on the lifetimes of objects
Communications of the ACM
The case for profile-directed selection of garbage collectors
Proceedings of the 2nd international symposium on Memory management
Hoard: a scalable memory allocator for multithreaded applications
ASPLOS IX Proceedings of the ninth international conference on Architectural support for programming languages and operating systems
In or out?: putting write barriers in their place
Proceedings of the 3rd international symposium on Memory management
A real-time garbage collector with low overhead and consistent utilization
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Data size optimizations for java programs
Proceedings of the 2003 ACM SIGPLAN conference on Language, compiler, and tool for embedded systems
Proceedings of the 2003 ACM SIGPLAN conference on Language, compiler, and tool for embedded systems
Generation Scavenging: A non-disruptive high performance storage reclamation algorithm
SDE 1 Proceedings of the first ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments
Heap compression for memory-constrained Java environments
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
Myths and realities: the performance impact of garbage collection
Proceedings of the joint international conference on Measurement and modeling of computer systems
IBM Systems Journal
Proceedings of the 4th international symposium on Memory management
Proceedings of the 1st ACM/USENIX international conference on Virtual execution environments
The DaCapo benchmarks: java benchmarking development and analysis
Proceedings of the 21st annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Valgrind: a framework for heavyweight dynamic binary instrumentation
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Proceedings of the 6th international symposium on Memory management
The causes of bloat, the limits of health
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
No bit left behind: the limits of heap data compression
Proceedings of the 7th international symposium on Memory management
Demystifying magic: high-level low-level programming
Proceedings of the 2009 ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Dynamic filtering: multi-purpose architecture support for language runtime systems
Proceedings of the fifteenth edition of ASPLOS on Architectural support for programming languages and operating systems
Schism: fragmentation-tolerant real-time garbage collection
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Decoupled zero-compressed memory
Proceedings of the 6th International Conference on High Performance and Embedded Architectures and Compilers
Continuous object access profiling and optimizations to overcome the memory wall and bloat
ASPLOS XVII Proceedings of the seventeenth international conference on Architectural Support for Programming Languages and Operating Systems
Finding reusable data structures
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
About 15 years of real-time Java
Proceedings of the 10th International Workshop on Java Technologies for Real-time and Embedded Systems
Using managed runtime systems to tolerate holes in wearable memories
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Pacman: program-assisted cache management
Proceedings of the 2013 international symposium on memory management
Hi-index | 0.00 |
Arrays are the ubiquitous organization for indexed data. Throughout programming language evolution, implementations have laid out arrays contiguously in memory. This layout is problematic in space and time. It causes heap fragmentation, garbage collection pauses in proportion to array size, and wasted memory for sparse and over-provisioned arrays. Because of array virtualization in managed languages, an array layout that consists of indirection pointers to fixed-size discontiguous memory blocks can mitigate these problems transparently. This design however incurs significant overhead, but is justified when real-time deadlines and space constraints trump performance. This paper proposes z-rays, a discontiguous array design with flexibility and efficiency. A z-ray has a spine with indirection pointers to fixed-size memory blocks called arraylets, and uses five optimizations: (1) inlining the first N array bytes into the spine, (2) lazy allocation, (3) zero compression, (4) fast array copy, and (5) arraylet copy-on-write. Whereas discontiguous arrays in prior work improve responsiveness and space efficiency, z-rays combine time efficiency and flexibility. On average, the best z-ray configuration performs within 12.7% of an unmodified Java Virtual Machine on 19 benchmarks, whereas previous designs have two to three times higher overheads. Furthermore, language implementers can configure z-ray optimizations for various design goals. This combination of performance and flexibility creates a better building block for past and future array optimization.