Miniboxing

Abstract

Parametric polymorphism enables code reuse and type safety. Underneath the uniform interface exposed to programmers, however, its low level implementation has to cope with inherently non-uniform data: value types of different sizes and semantics (bytes, integers, floating point numbers) and reference types (pointers to heap objects). On the Java Virtual Machine, parametric polymorphism is currently translated to bytecode using two competing approaches: homogeneous and heterogeneous. Homogeneous translation requires boxing, and thus introduces indirect access delays. Heterogeneous translation duplicates and adapts code for each value type individually, producing more bytecode. Therefore bytecode speed and size are at odds with each other. This paper proposes a novel translation that significantly reduces the bytecode size without affecting the execution speed. The key insight is that larger value types (such as integers) can hold smaller ones (such as bytes) thus reducing the duplication necessary in heterogeneous translations. In our implementation, on the Scala compiler, we encode all primitive value types in long integers. The resulting bytecode approaches the performance of monomorphic code, matches the performance of the heterogeneous translation and obtains speedups of up to 22x over the homogeneous translation, all with modest increases in size.

Automating ad hoc data representation transformations

“…The Late Data Layout (LDL) mechanism [47] is the underlying transformation used in Scala to implement multiparameter value class inlining and to specialize classes using the miniboxed encoding [46]. It is a flexible and reliable mechanism, tested on thousands of lines of Scala code.…”

“…This avoids the creation of intermediate lists and thus significantly reduces the garbage produced. We tried using two versions of LazyList: one using erased generics (adrt generic) and one using miniboxing [46] specialization (adrt miniboxed).…”

“…The adrt scoped transformation is a conceptual generalization of a mechanism motivated by library transformation scenarios. In particular, the resulting data representation transformation is used in conjunction with the miniboxing transformation [6,46] functions and tuples by custom, optimized versions adequate for miniboxed code [48]. The scope of this data representation transformation is miniboxing-transformed code.…”

“…The scope of this data representation transformation is miniboxing-transformed code. The miniboxing transformation [46] proposes an alternative to erasure, allowing generic methods and classes to work efficiently with unboxed primitive types. Unlike the current specialization transformation in the Scala compiler [21], which duplicates and adapts the generic code once for every primitive type, the miniboxing transformation only duplicates the code once and encodes all primitive types in long integers.…”

“…As discussed earlier, the standard optimizations that are closest to our approach are value classes [9] and class specialization [21,46]. These are optimizations with great practical value, and most modern languages have felt a need for them.…”