Practical Validation of Bytecode to Bytecode JIT Compiler Dynamic Deoptimization.

Béra, Clément; Miranda, Eliot; Denker, Marcus; Ducasse, Sté́phane

doi:10.5381/jot.2016.15.2.a1

Cited by 11 publications

(9 citation statements)

References 32 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The generated runtime, i.e., the machine code compiled methods generated by the JIT compiler, is executed using a machine code simulator. In Pharo, we have extended the original machine code simulation infrastructure to use Unicorn 3 , a QEMU-based machine code simulation library. Unicorn provides a small yet powerful API to simulate machine code on multiple architectures.…”

Section: An Iterative Test-based Methodologymentioning

confidence: 99%

Cross-ISA testing of the Pharo VM: lessons learned while porting to ARMv8

Polito

Tesone

Ducasse

et al. 2021

Proceedings of the 18th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes

Self Cite

View full text Add to dashboard Cite

Testing and debugging a Virtual Machine is a laborious task without the proper tooling. This is particularly true for VMs with JIT compilation and dynamic code patching for techniques such as inline caching. In addition, this situation is getting worse when the VM builds and runs on multiple target architectures.In this paper, we report on several lessons we learned while testing the Pharo VM, particularly during the port of its Cogit JIT compiler to the AArch64 architecture. The Pharo VM presented already a simulation environment that is very handy to simulate full executions and live-develop the VM. However, this full simulation environment makes it difficult to reproduce short and simple testing scenarios. We 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.We report on how this testing infrastructure allowed us to cope with two different development scenarios: (1) porting the Cogit JIT compiler to AArch64 without early access to real hardware and (2) debugging memory corruptions due to GC bugs.CCS Concepts: • Software and its engineering → Runtime environments.

show abstract

Section: An Iterative Test-based Methodologymentioning

confidence: 99%

Cross-ISA testing of the Pharo VM: lessons learned while porting to ARMv8

Polito

Tesone

Ducasse

et al. 2021

Proceedings of the 18th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes

Self Cite

View full text Add to dashboard Cite

show abstract

“…This is done through a bytecode‐to‐bytecode optimizer, 22 re‐using the existing template JIT as a back‐end. To be able to generate efficient code in the bytecode‐to‐bytecode optimizer, we introduced new unsafe bytecodes enabling, for example, to access arrays without type and bounds checks 23 . For each new bytecode, we introduced new templates in the existing JIT to generate efficient machine code for the optimized methods using the new bytecodes.…”

Section: Experiences Debugging Within the Simulatormentioning

confidence: 99%

Two decades of live coding and debugging of virtual machines through simulation

et al. 2020

Self Cite

View full text Add to dashboard Cite

OpenSmalltalk-VM is a virtual machine (VM) for languages in the Smalltalk family (eg, Squeak and Pharo), which is itself written in a subset of Smalltalk that can easily be translated to C. VM development is done in Smalltalk, an activity we call "simulation." The production VM is then 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 executable through a C compiler. The whole VM execution can be simulated: the heap is represented as a huge byte array, the VM code is executed as Smalltalk, and the native code generated by the just-in-time (JIT) compiler is executed by a processor simulator. All the Smalltalk development tools, such as the debugger, are then available while simulating. In addition, in simulation, it is also possible to use debugging features such as single stepping in the machine code generated by the JIT compiler. The Smalltalk development tools combined with the simulation debugging features provide developers with a productive environment in which to extend and debug the VM. In this article, we detail the VM simulation infrastructure and report our experiences developing and debugging VM features within it such as the garbage collector and the JIT compiler.

show abstract

“…There are formalizations for tracing compilers [Dissegna, Logozzo, and Ranzato 2014;Guo and Palsberg 2011], but we are unaware of any other formalization effort for speculative optimizations in general. Béra, Miranda, Denker, and Ducasse [2016] present a verifier for a bytecode-to-bytecode optimizer. By symbolically executing optimized and unoptimized code, they verify that the deoptimization metadata produced by their optimizer correctly maps the symbolic values of the former to the latter at all deoptimization points.…”

Section: Related Workmentioning

confidence: 99%

Correctness of speculative optimizations with dynamic deoptimization

Flückiger

Scherer

Yee

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

High-performance dynamic language implementations make heavy use of speculative optimizations to achieve speeds close to statically compiled languages. These optimizations are typically performed by a just-in-time compiler that generates code under a set of assumptions about the state of the program and its environment. In certain cases, a program may execute code compiled under assumptions that are no longer valid. The implementation must then deoptimize the program on-the-fly; this entails finding semantically equivalent code that does not rely on invalid assumptions, translating program state to that expected by the target code, and transferring control. This paper looks at the interaction between optimization and deoptimization, and shows that reasoning about speculation is surprisingly easy when assumptions are made explicit in the program representation. This insight is demonstrated on a compiler intermediate representation, named sourir, modeled after the high-level representation for a dynamic language. Traditional compiler optimizations such as constant folding, unreachable code elimination, and function inlining are shown to be correct in the presence of assumptions. Furthermore, the paper establishes the correctness of compiler transformations specific to deoptimization: namely unrestricted deoptimization, predicate hoisting, and assume composition.

show abstract

Practical Validation of Bytecode to Bytecode JIT Compiler Dynamic Deoptimization.

Cited by 11 publications

References 32 publications

Cross-ISA testing of the Pharo VM: lessons learned while porting to ARMv8

Cross-ISA testing of the Pharo VM: lessons learned while porting to ARMv8

Two decades of live coding and debugging of virtual machines through simulation

Correctness of speculative optimizations with dynamic deoptimization

Contact Info

Product

Resources

About