Two decades of smalltalk VM development: live VM development through simulation tools

@article{Miranda2018TwoDO,
  title={Two decades of smalltalk VM development: live VM development through simulation tools},
  author={Eliot Miranda and Cl{\'e}ment B{\'e}ra and Elisa Gonzalez Boix and Daniel H. H. Ingalls},
  journal={Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages},
  year={2018}
}
  • E. Miranda, Clément Béra, +1 author D. Ingalls
  • Published 4 November 2018
  • Computer Science
  • Proceedings of the 10th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages
OpenSmalltalk-VM is a virtual machine (VM) for languages in the Smalltalk family (e.g. Squeak, Pharo) which is itself written in a subset of Smalltalk that can easily be translated to C. Development is done in Smalltalk, an activity we call “Simulation”. The production VM is derived by translating the core VM code to C. As a result, two execution models coexist: simulation, where the Smalltalk code is executed on top of a Smalltalk VM, and production, where the same code is compiled to an… Expand

Figures and Tables from this paper

Two decades of live coding and debugging of virtual machines through simulation
TLDR
The VM simulation infrastructure is detailed and the experiences developing and debugging VM features within it such as the garbage collector and the JIT compiler are reported. Expand
Illicium A modular transpilation toolchain from Pharo to C
The Pharo programming language runs on the OpenSmalltalkVM. This Virtual Machine (VM) is mainly written in Slang, a subset of the Smalltalk language dedicated to VM development. Slang is transpiledExpand
Let them fail: towards VM built-in behavior that falls back to the program
TLDR
It is argued that the sphere of influence of programs on VMS is extensible with regard to built-in behavior, and to let built- in behavior fail and let programs decide whether to raise exceptions, try again, or simply do nothing at all. Expand
GraalSqueak: toward a smalltalk-based tooling platform for polyglot programming
TLDR
This paper presents GraalSqueak, a Squeak/Smalltalk virtual machine implementation for the GraalVM, and evaluates the performance of the language and the programming environment, and discusses how the system can be used as a tooling platform for polyglot programming. Expand
The evolution of Smalltalk: from Smalltalk-72 through Squeak
  • D. Ingalls
  • Computer Science
  • Proc. ACM Program. Lang.
  • 2020
TLDR
The forces that brought each generation of Smalltalk into existence are described, the technical innovations that characterized it, and the growth in understanding of object-orientation and personal computing that emerged. Expand
GraalSqueak
Polyglot programming provides software developers with a broader choice in terms of software libraries and frameworks available for building applications. Previous research and engineering activitiesExpand
Framework-aware debugging with stack tailoring
TLDR
This paper introduces Sarto, a call-stack instrumentation layer that allows developers to tailor the stack to make debugging framework-aware, and proposes a set of six stack operations that combined hide irrelevant information, introduce missing information, and relate dispersed debugging sources to the debugger. Expand
Cross-ISA testing of the Pharo VM: lessons learned while porting to ARMv8
TLDR
This paper extended the pre-existing simulation environment with a testing infrastructure and a methodology that allow us to have fine-grained control of testing scenarios, making tests small, fast, reproducible, and cross-ISA. Expand

References

SHOWING 1-10 OF 34 REFERENCES
How to Build a High-Performance VM for Squeak/Smalltalk in Your Spare Time: An Experience Report of Using the RPython Toolchain
TLDR
The benefits and drawbacks of RSqueak/VM are discussed as a research vehicle for developing and evaluating Smalltalk language extensions without having to learn the deep secrets of VM development. Expand
The Cog Smalltalk Virtual Machine writing a JIT in a high-level dynamic language
Cog adds a just-in-time compiler for x86 to the existing interpreter. At this stage in its evolution Cog produces a VM that runs language-intensive (rather than library intensive) benchmarks from theExpand
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.Expand
Sista: Saving Optimized Code in Snapshots for Fast Start-Up
TLDR
Sista (Speculative Inlining SmallTalk Architecture) is proposed to persist optimized code in a platform-independent representation as part of a snapshot to reach peak performance almost immediately after start-up when using a snapshot where optimized code was persisted. Expand
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. Expand
A bytecode set for adaptive optimizations
TLDR
A new bytecode set is implemented, which includes additional bytecodes that allow the Just-in-time compiler to generate less generic, and hence simpler and faster code sequences for frequently executed primitives. Expand
Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools
TLDR
Experience with Truffle Instrumentation validates the notion that addressing developer tools support as a forethought can change expectations about the availability of practical, efficient tools for high-performance languages. Expand
Efficient implementation of the smalltalk-80 system
TLDR
The most significant optimization techniques developed over the course of the Smalltalk-80 programming system are discussed, many of which are applicable to other languages. Expand
Bootstrapping reflective systems: The case of Pharo
TLDR
A definition of bootstrap for object-oriented reflective systems is proposed, the architecture and components it should contain and the challenges it has to overcome are described, and a reference bootstrap process for a reflective system is presented. Expand
A partial read barrier for efficient support of live object-oriented programming
TLDR
Spur, a new object representation and memory manager for Smalltalk-like languages, uses direct pointers but still provides a fast become operation in large heaps, thanks to forwarding objects that when read conceptually answer another object and a partial read barrier that avoids the cost of explicitly checking for forwarding objects on the vast majority of object accesses. Expand
...
1
2
3
4
...