Language: Ruby · Versions: Ruby 3.3.6 (Ractor)
The problem
I'm moving a CPU-bound worker pool to Ruby 3.3 Ractors. I used define_method to generate fast dispatch helpers and froze the configuration object with Ractor.make_shareable(config). However, calling the define_method-generated method inside a non-main Ractor immediately raises Ractor::IsolationError (can not access non-shareable objects in constant/lexical scope by non-main Ractor) because define_method captures the enclosing lexical Binding (self of the class/module definition scope)!
Minimal example
class Processor
multiplier = 3
# Captures the enclosing lexical environment:
define_method(:compute) do |x|
x * multiplier
end
end
r = Ractor.new do
Processor.new.compute(14)
end
puts r.take
Expected
42 returned from the worker Ractor.
What happens instead
Processor.new.compute(14) inside Ractor.new raises:
Ractor::IsolationError: Proc's self is not shareable
Because define_method takes a block whose self and outer lexical environment were created in the main Ractor, the method body's Proc is bound to an unshareable lexical environment unless explicitly isolated via Ractor.make_shareable(proc, copy: true) or defined without closure capture.
In Ruby 3.3, how can you dynamically generate parameterized methods (like define_method) whose bodies are 100% Ractor-safe without resorting to class_eval string interpolation?
class Processor
multiplier = 3 # must hold a shareable value (Integer, frozen String, etc.)
define_method(:compute, &Ractor.make_shareable(proc { |x| x * multiplier }))
end
r = Ractor.new { Processor.new.compute(14) }
p r.take # => 42
For generated families, wrap it once:
module ShareableDefine
def define_shareable_method(name, &body)
define_method(name, &Ractor.make_shareable(body))
end
end
class Processor
extend ShareableDefine
CONFIG = Ractor.make_shareable({ double: 2, triple: 3 })
CONFIG.each do |name, k|
define_shareable_method(name) { |x| x * k }
end
end
Why this works
The premise is slightly off. In the class body, self is Processor, and classes and modules are always shareable. So self isn't the problem. The real problem is the unshareable Proc. In 3.0+, a method made from a non-shareable Proc can only be called from the Ractor that defined it. If I remember the VM's bmethod call path and the Ractor bootstrap tests correctly, a call from another Ractor raises RuntimeError ("defined with an un-shareable Proc in a different Ractor"), not Ractor::IsolationError. From r.take, it arrives wrapped in Ractor::RemoteError, so look at #cause.
The message you quoted, "Proc's self is not shareable", comes from Ractor.make_shareable itself. You get it when the block's self is unshareable, typically because you wrote the block at the top level, where self is main, or inside an instance method. Write the block in the class or module body, where self is the class, and it goes away.
Ractor.make_shareable(proc) also checks what the block captures:
- Captured values must already be shareable. Freeze the config first, as with
CONFIGabove, or it raisesRactor::IsolationError. - The block can't assign to captured variables. It can only read them.
copy: truedoesn't help here. It makes copies of objects. It doesn't make a closure safe.
Without closures at all
Keep the parameters in shareable constants and write ordinary def methods that read them. A non-main Ractor can read a constant or class-level instance variable as long as its value is shareable.
What I checked
I can't run code here. The error message and the call-site check are from my memory of CRuby's vm_insnhelper.c and bootstraptest/test_ractor.rb. define_method duplicates the Proc internally, and as I understand it, rb_proc_dup keeps it marked shareable. That's what makes the &Ractor.make_shareable(...) form work. Running the first snippet on 3.3.6 will confirm it, and printing e.cause.class on the original will confirm the premise point.