Record data structures in racket: usage analysis and optimization

@article{Pape2017RecordDS,
  title={Record data structures in racket: usage analysis and optimization},
  author={Tobias Pape and Vasily Kirilichev and Carl Friedrich Bolz-Tereick and Robert Hirschfeld},
  journal={ACM Sigapp Applied Computing Review},
  year={2017},
  volume={16},
  pages={25-37}
}
Built-in data structures are a key contributor to the performance of dynamic languages. Record data structures, or records, are one of the common advanced, but not easily optimizable built-in data structures supported by those languages. Records may be used in an object-oriented fashion or to implement object orientation itself. In this paper, we analyze how records are used in different applications in the Scheme dialect Racket. Based on the data obtained, we suggest the application of… 

Figures and Tables from this paper

References

SHOWING 1-10 OF 27 REFERENCES
A run-time representation of scheme record types
TLDR
The run-time representation used in the implementation provides an extended model for record types allowing record types to represent foreign scalar data types, and allows the base record type to be extended to create non-R6RS record-type systems.
Meta-tracing makes a fast Racket
TLDR
The result of spending just a couple person-months implementing and tuning an implementation of Racket written in RPython is presented, with a geometric mean equal to Racket’s performance and within a factor of 2 slower than Gambit and Larceny on a collection of standard Scheme benchmarks.
Adaptive just-in-time value class optimization: transparent data structure inlining for fast execution
TLDR
This paper presents a technique to detect and compress commonly occurring patterns of value class usage to improve memory usage and performance and shows two to ten-fold speedup of a small prototypical implementation over the implementation of value classes in other object-oriented language implementations.
Pycket: a tracing JIT for a functional language
TLDR
Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more, and outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers.
An object storage model for the truffle language implementation framework
TLDR
The initial evaluation indicates that the Truffle OSM can be used to implement high-performance language runtimes, with no performance overhead when compared to language-specific solutions.
PyPy's approach to virtual machine construction
The PyPy project seeks to prove both on a research and a practical level the feasibility of constructing a virtual machine (VM) for a dynamic language in a dynamic language - in this case, Python.
Storage strategies for collections in dynamically typed languages
TLDR
This paper describes storage strategies, which dynamically optimise collections whose elements are instances of the same primitive type, and implements storage strategies in the PyPy virtual machine, giving a performance increase of 18% on wide-ranging benchmarks of real Python programs.
Late data layout: unifying data representation transformations
TLDR
The Late Data Layout mechanism is presented, a simple but versatile type-driven generalization that subsumes and improves the state-of-the-art representation transformations and makes two key observations: annotated types conveniently capture the semantics of using multiple representations and local type inference can be used to consistently and optimally introduce coercions.
Space- and Time-Efficient Implementation of the Java Object Model
TLDR
It is shown that with careful engineering, a high-performance virtual machine can instantiate most Java objects with only a single-word object header, which provides fast access to the virtual method table, allowing for quick method invocation.
One VM to rule them all
TLDR
This work describes a new approach to virtual machine (VM) construction that amortizes much of the effort in initial construction by allowing new languages to be implemented with modest additional effort, and suggests that high performance is attainable while preserving a modular and layered architecture.
...
...