March 2025 - ruby-core - ml.ruby-lang.org

[ruby-core:117684] [Ruby master Bug#20452] Ruby 3.3 on Alpine Linux results in a relatively shallow SystemStackError exception
by Earlopain (A S) 17 Jun '25

17 Jun '25

Issue #20452 has been reported by Earlopain (A S). ---------------------------------------- Bug #20452: Ruby 3.3 on Alpine Linux results in a relatively shallow SystemStackError exception https://bugs.ruby-lang.org/issues/20452 * Author: Earlopain (A S) * Status: Open * ruby -v: 3.3.1 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- This is a redo of https://bugs.ruby-lang.org/issues/14387, reported against a non-eol version. The same issue still applies on recent rubies, though I personally only have tested 3.3 and 3.2: ```rb n = 100000 res = {} 1.upto(n).to_a.inject(res) do |r, i| r[i] = {} end def f(x) x.each_value { |v| f(v) } end f(res) ``` The patch from https://bugs.ruby-lang.org/issues/14387#note-13 still works, though as per https://bugs.ruby-lang.org/issues/14387#note-16 it can't be accepted as is. With the patch applied: ``` (irb):8:in `block in f': stack level too deep (SystemStackError) from (irb):8:in `each_value' from (irb):8:in `f' from (irb):8:in `block in f' from (irb):8:in `each_value' from (irb):8:in `f' from (irb):8:in `block in f' from (irb):8:in `each_value' from (irb):8:in `f' ... 11549 levels... from /usr/local/lib/ruby/gems/3.3.0/gems/irb-1.11.0/exe/irb:9:in `<top (required)>' from /usr/local/bin/irb:25:in `load' from /usr/local/bin/irb:25:in `<main>' ``` Without the patch: ``` (irb):8:in `each_value': stack level too deep (SystemStackError) from (irb):8:in `f' from (irb):8:in `block in f' from (irb):8:in `each_value' from (irb):8:in `f' from (irb):8:in `block in f' from (irb):8:in `each_value' from (irb):8:in `f' from (irb):8:in `block in f' ... 286 levels... from /usr/local/lib/ruby/gems/3.3.0/gems/irb-1.11.0/exe/irb:9:in `<top (required)>' from /usr/local/bin/irb:25:in `load' from /usr/local/bin/irb:25:in `<main>' ``` To reproduce, I have removed lines 102-105 from https://github.com/docker-library/ruby/blob/f5753434bb23041dd9913bb7b650e7b…. Check out the previous ticket for more information, there are a few conversations about possible solutions. -- https://bugs.ruby-lang.org/

4 11

[ruby-core:120738] [Ruby master Bug#21048] [Prism] rescue in modifier form with condition behaves differently
by Earlopain (Earlopain _) 14 Jun '25

14 Jun '25

Issue #21048 has been reported by Earlopain (Earlopain _). ---------------------------------------- Bug #21048: [Prism] rescue in modifier form with condition behaves differently https://bugs.ruby-lang.org/issues/21048 * Author: Earlopain (Earlopain _) * Status: Open * ruby -v: 3.4.1 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- With the following code there is a discrepancy in how prism and parse.y consider precedence: ```rb $called = false def foo $called = true end foo rescue nil if false puts "Called: #{$called}" ``` Prism interprets it as `(foo rescue nil) if false`, not calling the method. `parse.y` does `foo rescue (nil if false)` since at least Ruby 2.0 ```sh $ ruby -v ruby 3.5.0dev (2025-01-19T12:44:20Z master f27ed98eff) +PRISM [x86_64-linux] $ ruby code.rb Called: true $ ruby --parser=parse.y code.rb Called: false ``` -- https://bugs.ruby-lang.org/

6 6

[ruby-core:118577] [Ruby master Bug#20631] Build failure with Xcode 16 beta and macOS 15 (Sequoia) Beta
by hsbt (Hiroshi SHIBATA) 11 Jun '25

11 Jun '25

Issue #20631 has been reported by hsbt (Hiroshi SHIBATA). ---------------------------------------- Bug #20631: Build failure with Xcode 16 beta and macOS 15 (Sequoia) Beta https://bugs.ruby-lang.org/issues/20631 * Author: hsbt (Hiroshi SHIBATA) * Status: Open * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- I found some issues with Xcode 16 beta and macOS 15 (Sequoia) Beta. `TestRubyOptions` and `TestVMDump` are failed with them. full log: https://gist.github.com/hsbt/378fe2ba47e734f2562ba9a154e1795b I'm not sure why macOS require `sudo` command for that. ---- And I and @katei also found the regression of https://bugs.ruby-lang.org/issues/18912#note-15. ``` >> pid = fork { p File.realpath "/" } >> Process.waitpid(pid) objc[82573]: +[NSPlaceholderMutableString initialize] may have been in progress in another thread when fork() was called. objc[82573]: +[NSPlaceholderMutableString initialize] may have been in progress in another thread when fork() was called. We cannot safely call it or ignore it in the fork() child process. Crashing instead. Set a breakpoint on objc_initializeAfterForkError to debug. => 82573 ``` -- https://bugs.ruby-lang.org/

2 8

[ruby-core:118412] [Ruby master Misc#20600] @ruby-lang.org has been migrated to Cloudflare
by shugo (Shugo Maeda) 10 Jun '25

10 Jun '25

Issue #20600 has been reported by shugo (Shugo Maeda). ---------------------------------------- Misc #20600: @ruby-lang.org has been migrated to Cloudflare https://bugs.ruby-lang.org/issues/20600 * Author: shugo (Shugo Maeda) * Status: Open ---------------------------------------- @ruby-lang.org has been migrated to Cloudflare, because ruby-lang.org was migrated from Google Domains to Squarespace, and Squarespace's e-mail forwarding doesn't work with custom MX records including subdomains:( I and Shibata-san are adding e-mail routing rules on Cloudflare, so if you have an e-mail address on ruby-lang.org, please verify the e-mail routing address when receiving an email from Cloudflare. -- https://bugs.ruby-lang.org/

6 13

[ruby-core:119683] [Ruby master Feature#20861] Add an environment variable for tuning the default thread quantum
by tenderlovemaking (Aaron Patterson) 08 Jun '25

08 Jun '25

Issue #20861 has been reported by tenderlovemaking (Aaron Patterson). ---------------------------------------- Feature #20861: Add an environment variable for tuning the default thread quantum https://bugs.ruby-lang.org/issues/20861 * Author: tenderlovemaking (Aaron Patterson) * Status: Open ---------------------------------------- The default thread quantum is currently [hard coded at 100ms](https://github.com/ruby/ruby/blob/c7708d22c33040a74ea7ac683bf7407d37…. This can impact multithreaded systems that are trying to process Ruby level CPU bound work at the same time as IO work. I would like to add an environment variable `RUBY_THREAD_DEFAULT_QUANTUM_MS` that allows users to specify the default thread quantum (in milliseconds) via an environment variable. It defaults to our current default of 100ms. I've submitted the patch [here](https://github.com/ruby/ruby/pull/11981). Here is a Ruby program to demonstrate the problem: ```ruby def measure x = Process.clock_gettime(Process::CLOCK_MONOTONIC) yield Process.clock_gettime(Process::CLOCK_MONOTONIC) - x end def fib(n) if n < 2 n else fib(n-2) + fib(n-1) end end # find fib that takes ~500ms fib_i = 50.times.find { |i| measure { fib(i) } >= 0.05 } sleep_i = measure { fib(fib_i) } threads = [ Thread.new { 100.times { sleep(sleep_i) # sometimes stalled waiting for fib's quantum to finish } puts "done 1" }, Thread.new { 100.times { fib(fib_i) }; puts "done 2" }, ] # We expect the total time to be about 100 * sleep_i (~5 seconds) because # theoretically the sleep thread could be done nearly completely in parallel to # the fib thread. # # But because the `sleep` thread is iterating over the sleep call, it must wait # for the `fib` thread to complete its quantum, before it can start the next iteration. # # This means each sleep iteration could take up to `sleep_i + 100ms` # # We're calling that stalled time "waste" total = measure { threads.each(&:join) } waste = total - (sleep_i * 100) p TOTAL: total, WASTE: waste ``` The program has two threads. One thread is using CPU time by computing `fib` in a loop. The other thread is simulating IO time by calling `sleep` in a loop. When the `sleep` call completes, it can stall, waiting for the quantum in the fib thread to expire. That means that each iteration on sleep can actually take `sleep time + thread quantum`, or in this case ~600ms when we expected it to only take ~500ms. Ideally, the above program would take `500ms * 100` since all `sleep` calls should be able to execute in parallel with the `fib` calls. Of course this isn't true because the sleep thread must acquire the GVL before it can continue the next iteration, so there will always be _some_ overhead. This feature is for allowing people to tune that overhead. If we run this program with the default quantum the output looks like this: ``` $ ./miniruby -v fibtest.rb ruby 3.4.0dev (2024-11-01T14:49:50Z quantum-computing c7708d22c3) +PRISM [arm64-darwin24] done 2 done 1 {TOTAL: 12.672821999993175, WASTE: 4.960721996147186} ``` The output shows that our program spent about 5 seconds stalled, waiting to acquire the GVL. With this patch we can lower the default quantum, and the output is like this: ``` $ RUBY_THREAD_DEFAULT_QUANTUM_MS=10 ./miniruby -v fibtest.rb ruby 3.4.0dev (2024-11-01T22:06:35Z quantum-computing 087500643d) +PRISM [arm64-darwin24] done 2 done 1 {TOTAL: 8.898526000091806, WASTE: 1.4168260043952614} ``` Specifying the ENV to change the quantum to 10ms lowered our waste in the program to ~1.4 seconds. It's common for web applications to do mixed CPU and IO bound tasks in threads (see the Puma webserver), so it would be great if there was a way to customize the thread quantum depending on your application's workload. -- https://bugs.ruby-lang.org/

11 23

[ruby-core:115981] [Ruby master Bug#20105] Introduce `IO::Stream` or something similar.
by ioquatix (Samuel Williams) 07 Jun '25

07 Jun '25

Issue #20105 has been reported by ioquatix (Samuel Williams). ---------------------------------------- Bug #20105: Introduce `IO::Stream` or something similar. https://bugs.ruby-lang.org/issues/20105 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal * Assignee: ioquatix (Samuel Williams) * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Ruby's IO class has a general model for streaming IO, including some hidden classes like `IO::generic_readable` and `IO::generic_writable`. As Ruby's core IO classes evolve, gems like `openssl` (see `OpenSSL::Buffering`) need to be updated to support changes to the interface. As it stands, there are changes in `IO` which are not copied to `OpenSSL::Buffering`. I'd like to propose we introduce some shared interface for streams that is used by `IO`, `Socket`, and `OpenSSL` to start with. The general interface would be similar to `IO` and allow code like `OpenSSL` to avoid re-implementing the `IO` interface. -- https://bugs.ruby-lang.org/

2 2

[ruby-core:121182] [Ruby master Bug#21158] Ractor using 'receive_if' sits in busy wait when there are skipped messages in the incoming queue
by NeilW (Neil Wilson) 06 Jun '25

06 Jun '25

Issue #21158 has been reported by NeilW (Neil Wilson). ---------------------------------------- Bug #21158: Ractor using 'receive_if' sits in busy wait when there are skipped messages in the incoming queue https://bugs.ruby-lang.org/issues/21158 * Author: NeilW (Neil Wilson) * Status: Open * ruby -v: ruby 3.4.2 (2025-02-15 revision d2930f8e7a) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- When using the conditional receive example from the Ractor documentation (either as a script, or within irb) <pre> r = Ractor.new do val = Ractor.receive_if{|msg| msg.is_a?(Array)} puts "Received successfully: #{val}" end r.send(1) r.send('test') </pre> ruby will sit in busy wait, pegging the processor at 100%, until it gets a message that matches the condition. Within irb it will often stop the REPL responding. The same problem occurs on ruby 3.02, 3.3.7 and 3.4.1 -- https://bugs.ruby-lang.org/

3 2

[ruby-core:121443] [Ruby Bug#21198] Fiber::Scheduler#blocking_operation_wait crash due to stack-use-after-return
by peterzhu2118 (Peter Zhu) 06 Jun '25

06 Jun '25

Issue #21198 has been reported by peterzhu2118 (Peter Zhu). ---------------------------------------- Bug #21198: Fiber::Scheduler#blocking_operation_wait crash due to stack-use-after-return https://bugs.ruby-lang.org/issues/21198 * Author: peterzhu2118 (Peter Zhu) * Status: Open * Backport: 3.1: DONTNEED, 3.2: DONTNEED, 3.3: DONTNEED, 3.4: REQUIRED ---------------------------------------- The Fiber::Scheduler#blocking_operation_wait method is passed a proc through the `rb_fiber_scheduler_blocking_operation_wait` function. This function stack allocates the arguments used for the proc ([source](https://github.com/ruby/ruby/blob/2183899fd184ab1cfee80d57c0dd6f4dc…) If this proc is captured anywhere, then calling it again will illegally read from and write to stack space. The following script demonstrates this issue using the [test/fiber/scheduler.rb](https://github.com/ruby/ruby/blob/master/test/fibe… scheduler: ```ruby require_relative "test/fiber/scheduler" class MyScheduler < Scheduler def blocking_operation_wait(work) super $work = work end end scheduler = MyScheduler.new Fiber.set_scheduler(scheduler) require "tempfile" Fiber.schedule do file = Tempfile.new file.write("hello world!") $work.call end scheduler.run ``` Crashes with: ``` test.rb:19: [BUG] Bus Error at 0xce0f57696add0045 ruby 3.4.2 (2025-02-15 revision d2930f8e7a) +PRISM [arm64-darwin24] -- Crash Report log information -------------------------------------------- See Crash Report log file in one of the following locations: * ~/Library/Logs/DiagnosticReports * /Library/Logs/DiagnosticReports for more details. Don't forget to include the above Crash Report log file in bug reports. -- Control frame information ----------------------------------------------- c:0003 p:---- s:0010 e:000009 IFUNC c:0002 p:0017 s:0007 e:000006 BLOCK test.rb:19 [FINISH] c:0001 p:---- s:0003 e:000002 DUMMY [FINISH] -- Ruby level backtrace information ---------------------------------------- test.rb:19:in 'block in <main>' -- Threading information --------------------------------------------------- Total ractor count: 1 Ruby thread count for this ractor: 1 Note that the Fiber scheduler is enabled -- Machine register context ------------------------------------------------ x0: 0x000000010063a5f0 x1: 0x000000014b80ce00 x2: 0x0000000000000000 x3: 0x000000014b60f060 x4: 0x0000000000000000 x5: 0x0000000000000000 x6: 0x0000000000000004 x7: 0x0000000000000000 x18: 0x0000000000000000 x19: 0x000000014b6a4840 x20: 0xce0f57696add0045 x21: 0x000000010063a5f0 x22: 0x000000014b60f060 x23: 0x0000000000000000 x24: 0x000000014b60f998 x25: 0x0000000000014273 x26: 0x000000014b60f060 x27: 0x000000014b60f060 x28: 0x000000014b80ce00 lr: 0x0000000100d881d8 fp: 0x000000011bb039f0 sp: 0x000000011bb03980 -- C level backtrace information ------------------------------------------- SEGV received in BUS handler [1] 52599 abort ruby test.rb ``` -- https://bugs.ruby-lang.org/

2 3

[ruby-core:120859] [Ruby master Bug#21108] C-c (SIGINT) crashes ruby when looping Ractors are not taken?
by osyoyu (Daisuke Aritomo) 05 Jun '25

05 Jun '25

Issue #21108 has been reported by osyoyu (Daisuke Aritomo). ---------------------------------------- Bug #21108: C-c (SIGINT) crashes ruby when looping Ractors are not taken? https://bugs.ruby-lang.org/issues/21108 * Author: osyoyu (Daisuke Aritomo) * Status: Open * ruby -v: ruby 3.5.0dev (2025-01-27T08:19:32Z master c3c7300b89) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Hitting C-c causes ruby to crash under these circumstances. ## Repro Hit C-c while the program is running. ```ruby r1 = Ractor.new do ary = [] loop do Ractor.receive Ractor.yield ary.push(1) end end r2 = Ractor.new(r1) do |r1| loop do |i| r1.send(nil) r1.take end end # r1.take # `take`ing r1 will fix this issue r2.take ``` ### Expected The process quits. ### Actual An `[BUG] unreachable` occurs. The rb_bug() is called inside `ractor_try_yield`. https://github.com/ruby/ruby/blob/ace39a3ed40cc32ff8d48893173413a7e05b8316/… ``` wrap.rb:1: warning: Ractor is experimental, and the behavior may change in future versions of Ruby! Also there are many implementation issues. <internal:ractor>:644: [BUG] unreachable ruby 3.5.0dev (2025-01-27T08:19:32Z master c3c7300b89) +PRISM [x86_64-linux] -- Control frame information ----------------------------------------------- c:0005 p:0003 s:0022 e:000021 METHOD <internal:ractor>:644 c:0004 p:0014 s:0015 e:000014 BLOCK wrap.rb:5 c:0003 p:0017 s:0012 e:000011 METHOD <internal:kernel>:168 c:0002 p:0008 s:0007 e:000006 BLOCK wrap.rb:3 [FINISH] c:0001 p:---- s:0003 e:000002 DUMMY [FINISH] -- Ruby level backtrace information ---------------------------------------- wrap.rb:3:in 'block in <main>' <internal:kernel>:168:in 'loop' wrap.rb:5:in 'block (2 levels) in <main>' <internal:ractor>:644:in 'yield' -- Threading information --------------------------------------------------- Total ractor count: 2 Ruby thread count for this ractor: 1 -- C level backtrace information ------------------------------------------- ruby(0x639a516dc55a) [0x639a516dc55a] [0x639a512af8dd] [0x639a512a3a31] [0x639a513876a1] [0x639a513877a6] [0x639a5149b0b3] [0x639a51487565] [0x639a514317db] [0x639a51433e71] [0x639a51434295] ``` See full log at: https://gist.github.com/osyoyu/2ae4fe3e41c139703bab5c321a81dda5 -- https://bugs.ruby-lang.org/

3 4

[ruby-core:117216] [Ruby master Bug#20346] FiberScheduler.unblock not called by Thread#join when Thread body contains Ractor.take
by forthoney (Seong-Heon Jung) 05 Jun '25

05 Jun '25

Issue #20346 has been reported by forthoney (Seong-Heon Jung). ---------------------------------------- Bug #20346: FiberScheduler.unblock not called by Thread#join when Thread body contains Ractor.take https://bugs.ruby-lang.org/issues/20346 * Author: forthoney (Seong-Heon Jung) * Status: Open * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- When using a `Ractor.take` inside a different thread, `Thread#join` on the thread running `Ractor.take` fails to call `FiberScheduler.unblock`. The below code can replicate this behavior ```ruby require "async" class RactorWrapper def initialize @ractor = Ractor.new do Ractor.recv # Ractor doesn't start until explicitly told to # Do some calculations fib = ->(x) { x < 2 ? 1 : fib.call(x - 1) + fib.call(x - 2) } fib.call(20) end end def take_async @ractor.send(nil) Thread.new { @ractor.take }.join.value end end Async do |task| 10000.times do |i| task.async do RactorWrapper.new.take_async puts i end end end ``` The above code deadlocks, and when we leave a debugging print statement inside of `Async`'s scheduler's `block` and `unblock` method, we can confirm that we only call `Scheduler.block`, and never `Scheduler.unblock` -- https://bugs.ruby-lang.org/

3 2