TechPrufer
Get started
Shopify
Shopify logoShopify · Feature trail

YJIT Compiler for Ruby

18 posts · Jan 2015 – Jul 2023

What this trail covers

Shopify engineers contributed to the upstream Ruby 3.1.0 release by developing and merging YJIT, a new just-in-time compiler. This post details the process of porting YJIT from C to Rust, highlighting the benefits of Rust's type safety and macro system for managing compiler complexity, as well as challenges with build systems and FFI. The team also explored Zig as an alternative. The Rust porting effort is ongoing, with plans to further decouple machine code generation and add ARM64 support. This work aims to improve performance for web and Rails workloads.

All Shopify trails
  1. Contributing support for a Wasm instruction to Winch - ShopifyThis post details the technical process of adding support for new WebAssembly instructions to Winch, Wasmtime's baseline compiler. It outlines the six key steps involved: modifying the visitor, MacroAssembler, CodeGenContext, and assembler; adding tests; and executing fuzzing. The post explains the roles of each component, the interaction between them, and how to emit machine instructions using Cranelift's ISLE definitions. It also describes the testing methodologies, including filetests and differential fuzzing, and the challenges of cross-ISA testing.
  2. Ruby 3.2’s YJIT is Production-Ready - ShopifyThis post details significant improvements to YJIT in Ruby 3.2, including a port to Rust for better maintainability and safety, reduced memory usage (cut by approximately one third), improved performance (38% speedup on railsbench over the interpreter), and the addition of ARM64 support. It also highlights additional improvements like object shapes for faster instance variable access, YJIT exit tracing, improved method call support, finer-grained constant cache invalidation, and variable width allocation for objects. Shopify has successfully deployed YJIT globally on its SFR infrastructure, measuring real speedups of 5% to 10%.
  3. Year in Review 2022: Tenderlove's Ruby and Rails Reflections and Predictions - ShopifyThis post details the development and enhancement of YJIT, including its port to Rust for improved maintainability and performance, and its new capability to generate machine code for ARM platforms. It also discusses the Variable Width Allocation project, which optimizes Ruby's memory layout by adjusting object slot sizes based on instance variable count, and the introduction of Object Shapes for Ruby 3.2, an optimization technique that uses object properties and their order as cache keys for inline caches, independent of the object's class. The post also introduces Ruby LSP, an implementation of the Language Server Protocol for Ruby and Rails, and the Error Highlight gem's integration with Rails error pages for enhanced debugging.
  4. When is JIT Faster Than A Compiler? - ShopifyThis post explains the fundamental differences between Ahead-Of-Time (AOT) compilers and Just-In-Time (JIT) compilers, particularly in the context of dynamic languages like Ruby. It details how JIT compilers leverage runtime information and de-optimization to achieve performance gains that AOT compilers struggle with due to the need for static correctness. The author, working on YJIT for CRuby, highlights Ruby's dynamic nature as a challenge for AOT compilation and explains how JITs can make assumptions about code behavior that are later invalidated and corrected. The post also provides information on how to try out YJIT and its development status.
  5. Shopify Invests in Research for Ruby at Scale - ShopifyThis post details Shopify's investment in academic research for Ruby, specifically highlighting contributions to language engineering, garbage collection (MMTk), and interpreter optimization. It introduces Professor Laurence Tratt's work on JIT compilers, Professor Steve Blackburn's MMTk for garbage collection, and Dr. Stefan Marr's research on interpreter startup and warmup time. The post emphasizes the importance of evaluating research against real-world workloads and the benefits of academic-industry collaboration for the Ruby community.
  7. Our Experience Porting the YJIT Ruby Compiler to Rust - ShopifyThis post details the experience of porting the YJIT Ruby compiler from C99 to Rust. It highlights the challenges of managing complexity in C, such as lack of modules, namespaces, and standard container types, and contrasts this with Rust's features like pattern matching, macros, and strong type safety. Specific challenges encountered include integrating with the CRuby codebase via FFI using bindgen, difficulties with Cargo's offline build capabilities and the reliance on the `libc` crate from `crates.io`, and issues with bindgen's allowlist filtering. The team adopted a direct translation strategy for the port and explored Zig as an alternative before settling on Rust.
  8. Code Ranges: A Deeper Look at Ruby Strings - ShopifyThis post provides a deep dive into Ruby's string implementation, specifically focusing on encoding-aware strings and the 'code range' mechanism. It explains how the code range is used to optimize string operations by caching information about character validity and boundaries. The post details the four code range values (`ENC_CODERANGE_UNKNOWN`, `ENC_CODERANGE_7BIT`, `ENC_CODERANGE_VALID`, `ENC_CODERANGE_BROKEN`), their mapping to Ruby methods, and how they are stored and managed across different Ruby implementations (MRI, JRuby, TruffleRuby). It also discusses how string operations can affect the code range and the strategies used to avoid unnecessary recalculations, such as lazy calculation and reasoning about code range preservation during operations. The post also touches upon the concept of 'single-byte optimizable' strings and how it relates to code range optimizations.
  9. After the Refactor: A Path to Faster Rendering with Liquid-C - ShopifyThis post details a refactor of the Liquid-C Virtual Machine to remove the constant pointer from its bytecode instructions. This change allows for more flexible instruction pointer movement, which is a prerequisite for implementing control flow tags like 'If' and 'For'. The refactor involves storing the index of constants in a hash table within the constants array, reducing duplicate elements and decreasing the size of the constants array. While this refactor slightly increased memory usage and parsing time, it is presented as a stepping stone for future performance improvements by enabling the implementation of control flow tags.
  10. RubyConf 2021: The Talks You Might Have Missed - ShopifyThis post details the development and enhancement of YJIT, a new just-in-time compiler for CRuby, led by a team at Shopify. It discusses the approach to implementing YJIT, its key advantages (high compatibility with existing Ruby code and support for latest Ruby features), and early performance results. It also mentions the porting of YJIT from C to Rust, highlighting Rust's benefits and challenges.
  11. Nerd Out on 10 of Our Favorite Posts From 2021 - ShopifyThis post announces the merging of YJIT into CRuby and highlights its importance to Shopify and the broader Ruby community. It also references additional posts for further reading on YJIT.
  12. GitHub Does My Operations Homework: A Ruby Speed Story - ShopifyThis post details the process of setting up a continuous integration and deployment pipeline using GitHub Actions and Jekyll to automatically run YJIT benchmarks, update a website with the results, and monitor performance regressions. It covers the setup of Jekyll for GitHub Pages, the challenges of managing reusable components and collections, and the intricacies of SSHing into AWS instances from GitHub Actions for benchmark execution. It also discusses generating graphs using D3.js and static SVGs from Ruby, and the use of matplotlib for fixed-size images.
  13. Try Out YJIT for Faster Rubying - ShopifyThis post details how to build and install YJIT-enabled CRuby from source, including prerequisite package installation for macOS and Linux. It explains how to verify YJIT installation and enable it via environment variables or command-line flags. The post also provides guidance on running YJIT with existing codebases and benchmarks, discusses its current production readiness based on early results and canary deployments, and outlines how to report crashes and provide feedback. It also introduces runtime statistics and debugging options for YJIT.
  14. YJIT: Building a New JIT Compiler for CRuby - ShopifyThis post details the development and merging of YJIT, a new JIT compiler for CRuby, with a focus on improving performance for web and Rails workloads. It explains the project's motivation, the YJIT architecture based on Basic Block Versioning (BBV), current benchmark results showing significant speedups, and the challenges and advantages of building YJIT within CRuby. It also outlines next steps, including potential improvements to CRuby's object model, type tagging, constant caching, calling conventions, and runtime methods.
  15. Diggin’ and Fetchin’ with TruffleRuby - ShopifyThis post details an investigation into a performance issue found in TruffleRuby, an alternative Ruby implementation. The investigation began with refactoring a clever but complex Ruby hash access pattern, leading to the exploration of `Hash#fetch` and `Hash#dig`. The author then prototyped a new method, `dig_fetch`, combining the flexibility of `fetch` with the traversal of `dig`, first by monkey-patching and then by contributing to TruffleRuby itself. Benchmarking revealed a significant performance degradation in `dig` and the prototype `dig_fetch` at deeper nesting levels, suggesting recursion might be a bottleneck and prompting further investigation into iterative solutions and compiler optimizations within TruffleRuby.
  16. Understanding Programs Using Graphs - ShopifyThis post introduces the concept of sea-of-nodes graphs as an intermediate representation used by the TruffleRuby JIT compiler. It explains the structure of these graphs, differentiating between control flow (red arrows) and data flow (green arrows), and between imperative (red boxes) and pure (green boxes) operations. It demonstrates how these graphs enable optimizations like de-duplication of common expressions (global value numbering) and floating expressions, and how they represent loops. The post also discusses the challenges of programming directly with graphs and highlights Shopify's efforts to build tools for visualizing and decompiling these graphs back to Ruby code to aid developer understanding of compiler optimizations.
  17. Optimizing Ruby Lazy Initialization in TruffleRuby with Deoptimization - ShopifyIntroduced an optimization for Ruby's lazy initialization (`||=`) operator in TruffleRuby. This optimization leverages deoptimization by replacing the standard `OrNode` with an `OrLazyValueDefinedNode`. The new node counts the executions of the right-hand side of the `||=` operator and triggers deoptimization if it's executed less than twice. This reduces the amount of machine code generated and speeds up compilation for this common idiom, improving performance and memory usage.
  18. Tuning Ruby's Global Method Cache - ShopifyThis post details the identification and resolution of a performance bottleneck in Ruby's MRI implementation related to the global method cache. The author used `perf` and `ftrace` user probes to analyze the `st_lookup` function and discovered that the default 2048-entry global method cache was insufficient for Shopify's large application. A new environment variable, `RUBY_GLOBAL_METHOD_CACHE_SIZE`, was introduced upstream to allow dynamic configuration of the cache size, and testing showed that increasing the cache size to around 64K-128K resulted in a ~3% cycle savings.