Smaller Footprint for Java Collections

Gil, Joseph; Shimron, Yuval

doi:10.1007/978-3-642-31057-7_17

“…On the side of mutable collections, Gil et al [14] identified sources of memory inefficiencies and proposed memory compaction techniques [14] to counter them. They improved the memory efficiency of Java's mutable Hash{Map,Set} and Tree{Map,Set} data structures by 20-77 % while keeping the runtime characteristics mostly unchanged.…”

Section: Related Workmentioning

confidence: 99%

Optimizing hash-array mapped tries for fast and lean immutable JVM collections

Steindorfer

¹

,

Vinju

²

2015

Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applicatio

View full text Add to dashboard Cite

The data structures under-pinning collection API (e.g. lists, sets, maps) in the standard libraries of programming languages are used intensively in many applications.The standard libraries of recent Java Virtual Machine languages, such as Clojure or Scala, contain scalable and well-performing immutable collection data structures that are implemented as Hash-Array Mapped Tries (HAMTs). HAMTs already feature efficient lookup, insert, and delete operations, however due to their tree-based nature their memory footprints and the runtime performance of iteration and equality checking lag behind array-based counterparts. This particularly prohibits their application in programs which process larger data sets.In this paper, we propose changes to the HAMT design that increase the overall performance of immutable sets and maps. The resulting general purpose design increases cache locality and features a canonical representation. It outperforms Scala's and Clojure's data structure implementations in terms of memory footprint and runtime efficiency of iteration (1.3-6.7 x) and equality checking (3-25.4 x).

show abstract

“…To add memoization to CHAMP, we use a technique called field consolidation [14]. Instead of storing cached hash codes in a large number of leaf nodes as Scala does, we consolidate the hashes of all elements of a node, to store them in a single integer array per node.…”

Section: Adding Memoization Of Element Hash Codes To Champmentioning

confidence: 99%

Optimizing hash-array mapped tries for fast and lean immutable JVM collections

Steindorfer

¹

,

Vinju

²

2015

View full text Add to dashboard Cite

The data structures under-pinning collection API (e.g. lists, sets, maps) in the standard libraries of programming languages are used intensively in many applications.The standard libraries of recent Java Virtual Machine languages, such as Clojure or Scala, contain scalable and well-performing immutable collection data structures that are implemented as Hash-Array Mapped Tries (HAMTs). HAMTs already feature efficient lookup, insert, and delete operations, however due to their tree-based nature their memory footprints and the runtime performance of iteration and equality checking lag behind array-based counterparts. This particularly prohibits their application in programs which process larger data sets.In this paper, we propose changes to the HAMT design that increase the overall performance of immutable sets and maps. The resulting general purpose design increases cache locality and features a canonical representation. It outperforms Scala's and Clojure's data structure implementations in terms of memory footprint and runtime efficiency of iteration (1.3-6.7 x) and equality checking (3-25.4 x).

show abstract

“…Function recalculateIndex is shown in lines 35-46. Next, we add this incoming object x into the active container Γ i (lines [4][5][6][7][8][9][10][11][12][13][14][15]. If the element at newIndex is an abstract element (line 6), this abstraction is split into two separate abstractions (line 9) and then x is inserted between them (line 10).…”

Section: List Combomentioning

confidence: 99%

“…Both of them can profile programs to make recommendations on appropriate container implementations that should be used. Recent work from [10] develops memory compaction techniques to reduce the footprint of Java collection objects. Our proposal differs from this category of research in two major aspects.…”

Section: Related Workmentioning

confidence: 99%

“…Previous studies [4,7,8,3,9,10] have found that an important source of run-time bloat is the inefficient use of container implementations. Standard libraries of object-oriented languages such as Java and C# contain collection frameworks that provide with users, for each abstract data type (such as List), many different implementations (such as ArrayList and LinkedList), each of which features a different design choice suitable for a specific execution scenario.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

CoCo: Sound and Adaptive Replacement of Java Collections

Xu

¹

2013

ECOOP 2013 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. Inefficient use of Java containers is an important source of run-time inefficiencies in large applications. This paper presents an application-level dynamic optimization technique called CoCo, that exploits algorithmic advantages of Java collections to improve performance. CoCo dynamically identifies optimal Java collection objects and safely performs run-time collection replacement, both using pure Java code. At the heart of this technique is a framework that abstracts container elements to achieve efficiency and that concretizes abstractions to achieve soundness. We have implemented part of the Java collection framework as instances of this framework, and developed a static CoCo compiler to generate Java code that performs optimizations. This work is the first step towards achieving the ultimate goal of automatically optimizing away semantic inefficiencies.

show abstract

Smaller Footprint for Java Collections

Cited by 10 publications

References 24 publications

Optimizing hash-array mapped tries for fast and lean immutable JVM collections

Optimizing hash-array mapped tries for fast and lean immutable JVM collections

Optimizing hash-array mapped tries for fast and lean immutable JVM collections

CoCo: Sound and Adaptive Replacement of Java Collections

Contact Info

Product

Resources

About