[ruby-core:116008] [Ruby master Bug#20112] Ractors not working properly in ruby 3.3.0

4 Jan 2024

      Issue #20112 has been updated by shadoe (Matthias Mueller).

I stumbled across the same problem. Using the example code taken from https://www.honeybadger.io/blog/ractors/ I also get unexpected results using Ractors in Ruby 3.3.0 in contrast to 3.2.2.

The code:

```
def tarai(x, y, z) =
  x <= y ? y : tarai(tarai(x-1, y, z),
                     tarai(y-1, z, x),
                     tarai(z-1, x, y))
require 'benchmark'
Benchmark.bm do |x|
  # sequential version
  x.report('seq'){ 4.times{ tarai(14, 7, 0) } }

  # parallel version
  x.report('par'){
    4.times.map do
      Ractor.new { tarai(14, 7, 0) }
    end.each(&:take)
  }
end
```

The results on my machine (Fedora 39, Kernel 6.6.8, AMD Ryzen 3 5300U (4 cores, 8 threads)):

```
Ruby 3.2.2:

       user     system      total        real
seq 70.461697   0.012965  70.474662 ( 71.029432)
par 70.103737   0.009663  70.113400 ( 17.677001)

Ruby 3.3.0:

       user     system      total        real
seq 74.018553   0.010097  74.028650 ( 74.329446)
par381.260338   0.070133 381.330471 ( 96.591537)

```

----------------------------------------
Bug #20112: Ractors not working properly in ruby 3.3.0
https://bugs.ruby-lang.org/issues/20112#change-106002

* Author: ariasdiniz (Aria Diniz)
* Status: Assigned
* Priority: Normal
* Assignee: ko1 (Koichi Sasada)
* ruby -v: 3.3.0
* Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN
----------------------------------------
I recently installed Ruby 3.3.0, and noticed that some of my scripts that use Ractors started to struggle with performance. After doing some benchmarks, I noticed that, while Ractors seem to be working well on Ruby 3.2.2, they're not working properly on 3.3.0.

I'm using Ubuntu 22.04.3 LTS

Here is the benchmark code:

``` ruby
# frozen_string_literal: true

require 'benchmark'

Ractor.new { :warmup } if defined?(Ractor)

Benchmark.bmbm do |x|
  x.report("Thread: ") do
    threads = []
    8.times do |i|
      threads << Thread.new do
        20000000.times do |j|
          ((i * 20000000) + j)**2
        end
      end
    end
    threads.each(&:join)
  end
  x.report("Ractor: ") do
    ractors = []
    0..8.times do |i|
      ractors << Ractor.new(i) do |k|
        20000000.times do |j|
          ((k * 20000000) + j)**2
        end
      end
    end
    ractors.map(&:take)
  end
end

```

Here is the results for Ruby 3.2.2:

Rehearsal --------------------------------------------
Thread:    7.666909   0.001091   7.668000 (  7.675266)
Ractor:   19.318528   0.012017  19.330545 (  2.505888)
---------------------------------- total: 26.998545sec

               user     system      total        real
Thread:    7.918141   0.004011   7.922152 (  7.928772)
Ractor:   19.366414   0.003954  19.370368 (  2.517993)

Here is the results for Ruby 3.3.0:

Rehearsal --------------------------------------------
Thread:    8.634152   0.010895   8.645047 (  8.645104)
Ractor:  100.172179   0.035985 100.208164 ( 15.213245)
--------------------------------- total: 108.853211sec

               user     system      total        real
Thread:    9.451236   0.004002   9.455238 (  9.460132)
Ractor:  118.463294   0.119942 118.583236 ( 18.462157)

-- 
https://bugs.ruby-lang.org/