arXiv subjects

Maxwell Bernstein

Publications and source records attributed to Maxwell Bernstein.

4 recordsLinked to original sources

arXiv2026

Support Local Variables

Ruby is a dynamically typed and object-oriented programming language. Its primary implementation, CRuby, contains a bytecode virtual machine and a mature lazy basic block versioning (LBBV) just-in-time (JIT) compiler called YJIT. In order to both implement more advanced optimizations than YJIT supports and also encourage more outside contributions, we present a new method-based JIT called ZJIT. Like YJIT, ZJIT compiles from bytecode to machine code. Unlike YJIT, ZJIT has multiple global and local optimization passes. ZJIT's high-level intermediate representation is in static single assignment (SSA) form. In order to optimize Ruby's local variables, ZJIT lifts local variables into SSA values. This is a departure from how other Ruby compilers handle locals: other JIT compilers either leave local variables as memory loads and stores or do advanced partial evaluation to recover SSA values from memory. While implementing locals, we (re-)discovered what features make local variables in Ruby especially challenging to compile correctly and efficiently. We demonstrate these features and illustrate how we solved these problems in ZJIT.

cs.PL↗

arXiv2025

Can Quantum Physics Help Fight Climate Change? A Thematic Analysis of Press Release Narratives

The climate crisis demands innovative solutions and quantum technologies are considered by some a potential solution (Berger et al., 2021; Calvin et al., 2023). The United Nations declared 2025 the International Year of Quantum Science and Technology (United Nations, 2024), focusing on applications for quantum technologies. Quantum technologies, leveraging quantum mechanics, offer unprecedented computational power (Ajagekar & You, 2022) and sensitivity (Schleich et al., 2016) that could revolutionize various sectors, including climate action. However, an understanding of how discourse from academia, government, and industry frames quantum technologies as a climate solution is lacking (Suter, Ma, & P\"ohlmann, 2024). This research aims to fill this gap by analyzing the narratives in press releases and helping inform a successful democratization of quantum technologies.

physics.soc-ph↗

arXiv2024

Partial Evaluation, Whole-Program Compilation

There is a tension in dynamic language runtime design between speed and correctness: state-of-the-art JIT compilation, the result of enormous industrial investment and significant research, achieves heroic speedups at the cost of complexity that can result in serious correctness bugs. Much of this complexity comes from the existence of multiple tiers and the need to maintain correspondence between these separate definitions of the language's semantics; also, from the indirect nature of the semantics implicitly encoded in a compiler backend. One way to address this complexity is to automatically derive, as much as possible, the compiled code from a single source-of-truth; for example, the interpreter tier. In this work, we introduce a partial evaluator that can derive compiled code ``for free'' by specializing an interpreter with its bytecode. This transform operates on the interpreter body at a basic-block IR level and is applicable to almost unmodified existing interpreters in systems languages such as C or C++. We show the effectiveness of this new tool by applying it to the interpreter tier of an existing industrial JavaScript engine, SpiderMonkey, yielding $2.17\times$ speedups, and the PUC-Rio Lua interpreter, yielding $1.84\times$ speedups with only three hours' effort. Finally, we outline an approach to carry this work further, deriving more of the capabilities of a JIT backend from first principles while retaining semantics-preserving correctness.

cs.PL↗

arXiv2024

Dr Wenowdis: Specializing dynamic language C extensions using type information

C-based interpreters such as CPython make extensive use of C "extension" code, which is opaque to static analysis tools and faster runtimes with JIT compilers, such as PyPy. Not only are the extensions opaque, but the interface between the dynamic language types and the C types can introduce impedance. We hypothesise that frequent calls to C extension code introduce significant overhead that is often unnecessary. We validate this hypothesis by introducing a simple technique, "typed methods", which allow selected C extension functions to have additional metadata attached to them in a backward-compatible way. This additional metadata makes it much easier for a JIT compiler (and as we show, even an interpreter!) to significantly reduce the call and return overhead. Although we have prototyped typed methods in PyPy, we suspect that the same technique is applicable to a wider variety of language runtimes and that the information can also be consumed by static analysis tooling.

cs.PL↗