Toward Ractor local GC

The talk presented by Koichi Sasada at RubyKaigi 2025 focuses on the challenges and solutions regarding garbage collection (GC) in Ruby, particularly in a multi-Ractor environment. Sasada highlights the need for better performance and concurrency in GC processes, as the current method of shared global heaps requires stopping all Ractors during GC, severely limiting performance.

Key Points Discussed:

Introduction to Ractor Model: Ractors, introduced in Ruby 3.0, allow for parallel computation and isolated object spaces, improving concurrency and safety in Ruby applications.
Challenges of Current Garbage Collection: The global garbage collection approach causes all Ractors to halt, leading to inefficient performance. It retrieves roots and marks live objects, yet misses parallel execution benefits.
Proposal for Ractor-local GC:
- Local GC Idea: Each Ractor could run its own GC independently, targeting non-shareable objects in parallel.
- Complexities with Shareable Objects: Tracking references to shared objects (like classes and modules) is crucial due to their potential accessibility from multiple Ractors, which complicates independent GC operations.
- Conservative Local GC Implementation: Sasada proposes treating shared objects as always alive during local GC runs, which means marking them as roots, thereby reducing the chances of inadvertently freeing them. This restricts memory but allows significant performance gains.
Performance Testing and Results: The implementation showed substantial improvements in microbenchmarks, with speedups reaching nearly five times in specific cases, especially when many Ractors handle short-lived objects more efficiently than the current global collection method.
Future Goals: The aim is to finalize the implementation for Ruby 3.5 and expand parallelization into global GC as necessary, enhancing overall performance while gradually exploring more complex solutions in the future.

Conclusion:

Sasada concludes that while the proposed Ractor-local GC is not the perfect solution, it promises significant performance improvements for Ruby's garbage collection by leveraging the isolation provided by Ractors, allowing them to operate concurrently without the bottlenecks seen in the current global GC approach.

Toward Ractor local GC
Koichi Sasada • Matsuyama, Ehime, Japan • Talk

Date: April 18, 2025
Published: May 27, 2025
Announced: unknown

Garbage collection (GC) is a big challenge in multi-Ractor systems. In the current implementation, all Ractors share a global heap, and GC requires stopping all Ractors to perform GC. This approach negatively impacts object allocation and GC performance.

Ideally, GC should be executed in parallel for each Ractor's local heap. However, shareable objects make it difficult to track references and implement fully parallel GC.

To address this, we propose Ractor-local GC, which focuses on collecting non-shareable, Ractor-local objects in parallel, while continuing to perform global GC for shareable objects by pausing all Ractors, as in the current system. This hybrid approach allows most GC operations to run in parallel, improving overall performance. Furthermore, since shareable objects are expected to be relatively few compared to non-shareable objects, the frequency of global GC should remain low.

This talk will present the design of Ractor-local GC and the progress of its implementation.

https://rubykaigi.org/2025/presentations/ko1.html

RubyKaigi 2025