Smaller footprint for Java collections

Gil, Joseph; Shimron, Yuval

doi:10.1145/2048147.2048201

Cited by 8 publications

(11 citation statements)

References 4 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In Java every object is 8-byte memory aligned, allowing for memory compaction techniques [7]. Consequently, if an object's header together with the size of all fields do not sum to a multiple of eight, your object will be aligned to the nearest 8-byte boundary and consume more memory than strictly necessary.…”

Section: Modeling and Measuring Memorymentioning

confidence: 99%

Code specialization for memory efficient hash tries (short paper)

Steindorfer

Vinju

2014

Proceedings of the 2014 International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

The hash trie data structure is a common part in standard collection libraries of JVM programming languages such as Clojure and Scala. It enables fast immutable implementations of maps, sets, and vectors, but it requires considerably more memory than an equivalent array-based data structure. This hinders the scalability of functional programs and the further adoption of this otherwise attractive style of programming.In this paper we present a product family of hash tries. We generate Java source code to specialize them using knowledge of JVM object memory layout. The number of possible specializations is exponential. The optimization challenge is thus to find a minimal set of variants which lead to a maximal loss in memory footprint on any given data. Using a set of experiments we measured the distribution of internal tree node sizes in hash tries. We used the results as a guidance to decide which variants of the family to generate and which variants should be left to the generic implementation.A preliminary validating experiment on the implementation of sets and maps shows that this technique leads to a median decrease of 55% in memory footprint for maps (and 78% for sets), while still maintaining comparable performance. Our combination of data analysis and code specialization proved to be effective.

show abstract

Section: Modeling and Measuring Memorymentioning

confidence: 99%

Code specialization for memory efficient hash tries (short paper)

Steindorfer

Vinju

2014

Proceedings of the 2014 International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

show abstract

“…Instead, dynamic information was summarized as advice to the programmer to make source code changes. Other work [13] [38] has addressed specific representation issues in collections. Some JVMs represent arrays with discontiguous array-lets [3,7,29] which save memory with zero-compression, copy-on-write, and lazy allocation and improve garbage collection pause times by limiting the maximum object size.…”

Section: Related Workmentioning

confidence: 99%

Memento mori: dynamic allocation-site-based optimizations

Clifford¹,

Payer²,

Stanton³

et al. 2015

Proceedings of the 2015 International Symposium on Memory Management

View full text Add to dashboard Cite

Languages that lack static typing are ubiquitous in the world of mobile and web applications. The rapid rise of larger applications like interactive web GUIs, games, and cryptography presents a new range of implementation challenges for modern virtual machines to close the performance gap between typed and untyped languages. While all languages can benefit from efficient automatic memory management, languages like JavaScript present extra thrill with innocentlooking but difficult features like dynamically-sized arrays, deletable properties, and prototypes. Optimizing such languages requires complex dynamic techniques with more radical object layout strategies such as dynamically evolving representations for arrays. This paper presents a general approach for gathering temporal allocation site feedback that tackles both the general problem of object lifetime estimation and improves optimization of these problematic language features. We introduce a new implementation technique where allocation mementos processed by the garbage collector and runtime system efficiently tie objects back to allocation sites in the program and dynamically estimate object lifetime, representation, and size to inform three optimizations: pretenuring, pretransitioning, and presizing. Unlike previous work on pretenuring, our system utilizes allocation mementos to achieve fully dynamic allocation-sitebased pretenuring in a production system. We implement all of our techniques in V8, a high performance virtual machine for JavaScript, and demonstrate solid performance improvements across a range of benchmarks.

show abstract

“…It is implemented as an extension to JUnit [13], a popular unit-testing framework, and thereby allows developers to check calculation coverage, along with ordinary function testing by JUnit. The HPCUnit provides for developers' annotations and helper classes to describe which method is a kernel function and which invocations to the kernel functions are logged with their arguments to construct a calculation group.…”

Section: Hpcunitmentioning

confidence: 99%

“…However, that requires changing the HPCUNit API design, which we carefully designed for application development productivity. We plan to apply several optimizing techniques to reduce overheads for collecting runtime logs [37] and to reduce the Java collections memory footprint [13].…”

Section: Empirical Study With Benchmarksmentioning

confidence: 99%

Calculation coverage testing in scientific applications

Satô

Hozumi

Chiba

2015

Proceedings of the 2015 International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

A typical implementation of scientific applications includes a large number of iterative calculations. For performance optimization, these calculations are often partitioned, grouped, and reordered for execution. Since this refactoring is repeatedly performed during development, it is one of the major source of bugs and thus tool support is necessary for debugging. This study discusses this problem and proposes tool support through a testing framework. This testing framework can help developers perform the tests we call calculation coverage testing. It investigates whether the grouped calculations cover all the calculations performed by the original (and often naively implemented) program. It also investigates whether their execution order is correct. To demonstrate this idea, we also presents HPCUnit, our prototype testing framework for Java, and then reports an empirical study applying it to the Java Grande Forum Benchmark Suite.

show abstract

Smaller footprint for Java collections

Cited by 8 publications

References 4 publications

Code specialization for memory efficient hash tries (short paper)

Code specialization for memory efficient hash tries (short paper)

Memento mori: dynamic allocation-site-based optimizations

Calculation coverage testing in scientific applications

Contact Info

Product

Resources

About