Maxine

Wimmer, Christian; Haupt, Michael; Vanter, Michael L. Van De; Jordan, Mick; Daynès, Laurent; Simon, Douglas N.

doi:10.1145/2400682.2400689

Cited by 69 publications

(21 citation statements)

References 29 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…There has been much previous work addressing the implementation of efficient collectors in safe languages [1,2,4,11,13,18]. The advantages of using safe languages demonstrated by these projects motivate our work.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Rust as a language for high performance GC implementation

et al. 2016

View full text Add to dashboard Cite

High performance garbage collectors build upon performancecritical low-level code, typically exhibit multiple levels of concurrency, and are prone to subtle bugs. Implementing, debugging and maintaining such collectors can therefore be extremely challenging. The choice of implementation language is a crucial consideration when building a collector. Typically, the drive for performance and the need for efficient support of low-level memory operations leads to the use of low-level languages like C or C++, which offer little by way of safety and software engineering benefits. This risks undermining the robustness and flexibility of the collector design.Rust's ownership model, lifetime specification, and reference borrowing deliver safety guarantees through a powerful static checker with little runtime overhead. These features make Rust a compelling candidate for a collector implementation language, but they come with restrictions that threaten expressiveness and efficiency.We describe our experience implementing an Immix garbage collector in Rust and C. We discuss the benefits of Rust, the obstacles encountered, and how we overcame them. We show that our Immix implementation has almost identical performance on micro benchmarks, compared to its implementation in C, and outperforms the popular BDW collector on the gcbench micro benchmark. We find that Rust's safety features do not create significant barriers to implementing a high performance collector. Though memory managers are usually considered low-level, our high performance implementation relies on very little unsafe code, with the vast majority of the implementation benefiting from Rust's safety. We see our experience as a compelling proof-of-concept of Rust as an implementation language for high performance garbage collection. } 132 } 133 134 // functions are inlined so we omit 135 // parameters/arguments 136 #[inline(always)] 137 #[cfg(feature = "parallel-gc")] 138 pub fn steal_trace_object(...) { 139 let addr = obj.to_address();

show abstract

Section: Related Workmentioning

confidence: 99%

“…We take the challenge to map GC features efficiently to the language semantics and we use Rust without changes to the base language. Previous work changed or augmented the semantics of the implementation languages to favor GC implementation [11,18].…”

Section: Related Workmentioning

confidence: 99%

Rust as a language for high performance GC implementation

et al. 2016

View full text Add to dashboard Cite

show abstract

“…Therefore, snippets need a raw pointer type. Metacircular Java VMs such as the Jikes RVM [Alpern et al 1999[Alpern et al , 2000Rogers and Grove 2009;Frampton et al 2009] and the Maxine VM [Wimmer et al 2013] pioneered this idea of low-level programming in Java. Similar to these VMs, we define a class Word to represent raw machine words.…”

Section: Low-level Java Programmingmentioning

confidence: 99%

“…However, metacircular VMs such as the Klein VM [Ungar et al 2005], the Jikes RVM [Alpern et al 1999[Alpern et al , 2000Rogers and Grove 2009], and the Maxine VM [Wimmer et al 2013] have demonstrated the feasibility of using a high-level language instead. High-level languages bring significant benefits: better modularity, memory safety, and automatic memory management.…”

Section: Related Workmentioning

confidence: 99%

“…The dynamic compiler in the Jikes RVM [Alpern et al 1999[Alpern et al , 2000Rogers and Grove 2009], the first metacircular Java VM, inlines these methods without formalization and without an abstraction layer between compiler and VM. The original dynamic compiler in the metacircular Maxine VM [Wimmer et al 2013], called CPS, first introduced the term snippet [Mathiske 2008;Simon 2009] to formalize the compiler-VM interface and to control inlining of Maxine snippets 1 via a bootstrapping process. CPS failed to meet the project's goals for machine code quality and compilation speed and was eventually replaced.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Snippets

Simon

Wimmer

Urban

et al. 2015

ACM Trans. Archit. Code Optim.

Self Cite

View full text Add to dashboard Cite

When building a compiler for a high-level language, certain intrinsic features of the language must be expressed in terms of the resulting low-level operations. Complex features are often expressed by explicitly weaving together bits of low-level IR, a process that is tedious, error prone, difficult to read, difficult to reason about, and machine dependent. In the Graal compiler for Java, we take a different approach: we use snippets of Java code to express semantics in a high-level, architecture-independent way. Two important restrictions make snippets feasible in practice: they are compiler specific, and they are explicitly prepared and specialized. Snippets make Graal simpler and more portable while still capable of generating machine code that can compete with other compilers of the Java HotSpot VM.

show abstract

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

et al. 2020

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

Maxine

Cited by 69 publications

References 29 publications

Rust as a language for high performance GC implementation

Rust as a language for high performance GC implementation

Snippets

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

Contact Info

Product

Resources

About