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

[ruby-core:115203] [Ruby master Bug#19981] bootstraptest/test_ractor.rb: Segmentation fault on arm32
by jaruga (Jun Aruga) 02 Jul '25

02 Jul '25

Issue #19981 has been reported by jaruga (Jun Aruga). ---------------------------------------- Bug #19981: bootstraptest/test_ractor.rb: Segmentation fault on arm32 https://bugs.ruby-lang.org/issues/19981 * Author: jaruga (Jun Aruga) * Status: Open * Priority: Normal * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN ---------------------------------------- I faced the following segmentation fault on Ubuntu jammy arm32 (emulated environment by `SETARCH='setarch linux32 --verbose --32bit'`) in both Travis CI arm64 [log](https://app.travis-ci.com/github/ruby/ruby/jobs/612418476#L2422 ) and RubyCI arm64-neoverse server. I tested it on the latest ruby master branch `14fa5e39d72c84d3e12e10dc5d77a6e6200c10f5`. I was able to reproduce this issue on RubyCI arm64-neoverse server, and prepared the reproducing script. So, you can try to debug on the server. It seems that the `-O3` flag triggered the issue. Because I didn't see the issue when Travis CI setting `- optflags=-O1` in `.travis.yml` on the current master branch. https://github.com/junaruga/report-ruby-ractor-segmentation-fault ``` + arm-linux-gnueabihf-gcc --version arm-linux-gnueabihf-gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0 + setarch linux32 --verbose --32bit make -s test Switching on ADDR_LIMIT_32BIT. Execute command `make'. Fstderr output is not empty <internal:ractor>:760: [BUG] Segmentation fault at 0x0000000c ruby 3.3.0dev (2023-10-30T09:27:06Z master 14fa5e39d7) [armv8l-linux-eabihf] -- Control frame information ----------------------------------------------- c:0005 p:0003 s:0021 e:000020 METHOD <internal:ractor>:760 c:0004 p:0008 s:0014 e:000013 BLOCK bootstraptest.test_ractor.rb_541_1260.rb:4 c:0003 p:0018 s:0011 e:000010 METHOD <internal:kernel>:187 c:0002 p:0004 s:0006 e:000005 BLOCK bootstraptest.test_ractor.rb_541_1260.rb:3 [FINISH] c:0001 p:---- s:0003 e:000002 DUMMY [FINISH] -- Ruby level backtrace information ---------------------------------------- bootstraptest.test_ractor.rb_541_1260.rb:3:in `block in <main>' <internal:kernel>:187:in `loop' bootstraptest.test_ractor.rb_541_1260.rb:4:in `block (2 levels) in <main>' <internal:ractor>:760:in `yield' -- Threading information --------------------------------------------------- Total ractor count: 2 Ruby thread count for this ractor: 1 -- Machine register context ------------------------------------------------ r0: 0x00000000 r1: 0x00000001 r2: 0x00000007 r3: 0x00000000 r4: 0x00c935c8 r5: 0x00000002 r6: 0x00000002 r7: 0x00000000 r8: 0x00000004 r9: 0x00c646b0 r10: 0x00000002 sp: 0xd5d91c90 fau: 0x0000000c -- Other runtime information ----------------------------------------------- * Loaded script: bootstraptest.test_ractor.rb_541_1260.rb * Loaded features: 0 enumerator.so 1 thread.rb 2 fiber.so 3 rational.so 4 complex.so 5 ruby2_keywords.rb 6 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so 7 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so * Process memory map: 00640000-0093a000 r-xp 00000000 103:03 29263803 /home/jaruga/git/ruby/ruby/build/ruby 0094a000-0094e000 r--p 002fa000 103:03 29263803 /home/jaruga/git/ruby/ruby/build/ruby 0094e000-0094f000 rw-p 002fe000 103:03 29263803 /home/jaruga/git/ruby/ruby/build/ruby 0094f000-00956000 rw-p 00000000 00:00 0 00bf3000-00cba000 rw-p 00000000 00:00 0 [heap] d5700000-d5721000 rw-p 00000000 00:00 0 d5721000-d5800000 ---p 00000000 00:00 0 d5900000-d5921000 rw-p 00000000 00:00 0 d5921000-d5a00000 ---p 00000000 00:00 0 d5a00000-d5a21000 rw-p 00000000 00:00 0 d5a21000-d5b00000 ---p 00000000 00:00 0 d5b00000-d5b21000 rw-p 00000000 00:00 0 d5b21000-d5c00000 ---p 00000000 00:00 0 d5c5f000-d5c60000 ---p 00000000 00:00 0 d5c60000-d5c90000 rw-p 00000000 00:00 0 d5c9f000-d5ca0000 ---p 00000000 00:00 0 d5ca0000-d5cd0000 rw-p 00000000 00:00 0 d5cde000-d5cdf000 ---p 00000000 00:00 0 d5cdf000-d5cef000 rw-p 00000000 00:00 0 d5cef000-d5cf0000 ---p 00000000 00:00 0 d5cf0000-d5d81000 rw-p 00000000 00:00 0 d5d81000-d5d82000 ---p 00000000 00:00 0 d5d82000-d5e12000 rw-p 00000000 00:00 0 d5e12000-d5e13000 ---p 00000000 00:00 0 d5e13000-d5ea3000 rw-p 00000000 00:00 0 d5ea3000-d5ea4000 ---p 00000000 00:00 0 d5ea4000-d5f34000 rw-p 00000000 00:00 0 d5f34000-d5f35000 ---p 00000000 00:00 0 d5f35000-d5fc5000 rw-p 00000000 00:00 0 d5fc5000-d5fc6000 ---p 00000000 00:00 0 d5fc6000-d6056000 rw-p 00000000 00:00 0 d6056000-d6057000 ---p 00000000 00:00 0 d6057000-d60e7000 rw-p 00000000 00:00 0 d60e7000-d60e8000 ---p 00000000 00:00 0 d60e8000-d6178000 rw-p 00000000 00:00 0 d6178000-d6179000 ---p 00000000 00:00 0 d6179000-d6209000 rw-p 00000000 00:00 0 d6209000-d620a000 ---p 00000000 00:00 0 d620a000-d629a000 rw-p 00000000 00:00 0 d629a000-d629b000 ---p 00000000 00:00 0 d629b000-d632b000 rw-p 00000000 00:00 0 d632b000-d632c000 ---p 00000000 00:00 0 d632c000-f5d10000 rw-p 00000000 00:00 0 f5d10000-f5d12000 r-xp 00000000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d12000-f5d21000 ---p 00002000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d21000-f5d22000 r--p 00001000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d22000-f5d23000 rw-p 00002000 103:03 29263555 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/trans/transdb.so f5d30000-f5d32000 r-xp 00000000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d32000-f5d41000 ---p 00002000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d41000-f5d42000 r--p 00001000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d42000-f5d43000 rw-p 00002000 103:03 29263548 /home/jaruga/git/ruby/ruby/build/.ext/armv8l-linux-eabihf/enc/encdb.so f5d4f000-f5d50000 ---p 00000000 00:00 0 f5d50000-f5d71000 rw-p 00000000 00:00 0 f5d71000-f5d72000 ---p 00000000 00:00 0 f5d72000-f5d93000 rw-p 00000000 00:00 0 f5d93000-f5d94000 ---p 00000000 00:00 0 f5d94000-f5db5000 rw-p 00000000 00:00 0 f5db5000-f5db6000 ---p 00000000 00:00 0 f5db6000-f5dd7000 rw-p 00000000 00:00 0 f5dd7000-f5dd8000 ---p 00000000 00:00 0 f5dd8000-f5df9000 rw-p 00000000 00:00 0 f5df9000-f5dfa000 ---p 00000000 00:00 0 f5dfa000-f5e1b000 rw-p 00000000 00:00 0 f5e1b000-f5e1c000 ---p 00000000 00:00 0 f5e1c000-f5e3d000 rw-p 00000000 00:00 0 f5e3d000-f5e3e000 ---p 00000000 00:00 0 f5e3e000-f5e5f000 rw-p 00000000 00:00 0 f5e5f000-f5e60000 ---p 00000000 00:00 0 f5e60000-f66a0000 rw-p 00000000 00:00 0 f66af000-f73b0000 rw-p 00000000 00:00 0 f73b5000-f7436000 rw-p 00000000 00:00 0 f7436000-f76b0000 r--p 0006f000 103:03 11802136 /usr/lib/locale/locale-archive f76b0000-f78b0000 r--p 00000000 103:03 11802136 /usr/lib/locale/locale-archive f78b0000-f79bc000 r-xp 00000000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79bc000-f79cc000 ---p 0010c000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79cc000-f79ce000 r--p 0010c000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79ce000-f79cf000 rw-p 0010e000 103:03 11670018 /usr/lib/arm-linux-gnueabihf/libc.so.6 f79cf000-f79d9000 rw-p 00000000 00:00 0 f79e0000-f7a21000 r-xp 00000000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a21000-f7a30000 ---p 00041000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a30000-f7a31000 r--p 00040000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a31000-f7a32000 rw-p 00041000 103:03 11670021 /usr/lib/arm-linux-gnueabihf/libm.so.6 f7a40000-f7a6b000 r-xp 00000000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a6b000-f7a7b000 ---p 0002b000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a7b000-f7a7c000 r--p 0002b000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a7c000-f7a7d000 rw-p 0002c000 103:03 11670013 /usr/lib/arm-linux-gnueabihf/libcrypt.so.1.1.0 f7a7d000-f7a85000 rw-p 00000000 00:00 0 f7a88000-f7aa7000 r-xp 00000000 103:03 11670015 /usr/lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 f7aac000-f7ab3000 r--s 00000000 103:03 11670285 /usr/lib/arm-linux-gnueabihf/gconv/gconv-modules.cache f7ab3000-f7ab5000 rw-p 00000000 00:00 0 f7ab5000-f7ab6000 r-xp 00000000 00:00 0 [sigpage] f7ab6000-f7ab8000 r--p 0001e000 103:03 11670015 /usr/lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 f7ab8000-f7ab9000 rw-p 00020000 103:03 11670015 /usr/lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 ff7dd000-fffdc000 rw-p 00000000 00:00 0 [stack] ffff0000-ffff1000 r-xp 00000000 00:00 0 [vectors] ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:120601] [Ruby master Bug#21024] Ruby including <cstdbool> generates compilation warning with GCC 15, header is deprecated in C++17,
by jprokop (Jarek Prokop) 02 Jul '25

02 Jul '25

Issue #21024 has been reported by jprokop (Jarek Prokop). ---------------------------------------- Bug #21024: Ruby including <cstdbool> generates compilation warning with GCC 15, header is deprecated in C++17, https://bugs.ruby-lang.org/issues/21024 * Author: jprokop (Jarek Prokop) * Status: Open * ruby -v: ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- C++ compiler in GCC 15 now generates a warning when trying to include `<cstdbool>`. This file is being included when compiling with C++ compiler from `include/ruby/internal/stdbool.h`. In C++, true, false and bool are keywords so including headers for boolean definitions should not be necessary. Alternatively, just including <stdbool.h> should be sufficient as that is what the `#include <cstdbool>` results in with GCC. Simplest fix is just deleting the lines that are including the file (see attached patch and comments 2 and 3 from downstream issue linked in the bottom section "Additional info"). Considering the wide array of compilers Ruby aims to support to be compiled with I wanted to make an issue here first to make sure there isn't a supported compiler that wouldn't agree with this approach. Reproduction: Obtain GCC 15, for Fedora Rawhide there is currently a repo of maintainer, I use it in Fedora Rawhide container (podman is replaceable for docker here): ``` host$ podman run -it --rm registry.fedoraproject.org/fedora:rawhide bash container# echo "[gcc_15] name=pre-release GCC 15 Repo baseurl=https://fedorapeople.org/~dmalcolm/gcc/gcc-15-mass-prebuild/$basear… type=rpm-md skip_if_unavailable=True gpgcheck=0 repo_gpgcheck=0 enabled=1 enabled_metadata=1" > /etc/yum.repos.d/gcc_15.repo container# dnf install --assumeyes g++ ruby-devel ``` ^ should install `g++-15.0.0` and `ruby.h` needed for the reproducer. Note: that baseurl is a custom space of a Fedora maintainer. Have a file named for example `main.cpp`: ``` cpp #include <ruby.h> int main(void) { return 0; } ``` Compile with GCC 15 ``` $ g++ main.cpp ``` Current behavior: Compiling throws warning: ``` $ g++ main.cpp In file included from /usr/include/ruby/internal/stdbool.h:30, from /usr/include/ruby/backward/2/bool.h:22, from /usr/include/ruby/defines.h:74, from /usr/include/ruby/ruby.h:25, from /usr/include/ruby.h:38, from reproducer.cpp:1: /usr/include/c++/15/cstdbool:48:6: warning: #warning "<cstdbool> is deprecated in C++17, remove the #include" [-Wcpp] 48 | # warning "<cstdbool> is deprecated in C++17, remove the #include" | ^~~~~~~ ``` Expected: Compilation throws no warnings and compiles the executable: ``` $ g++ reproducer.cpp $ echo $? 0 ``` Additional info: ``` $ g++ --version g++ (GCC) 15.0.0 20241203 (Red Hat 15.0.0-0) Copyright (C) 2024 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ``` This was met during recompilation of libdnf5 that includes `-Werror` in their compilation flags, See downstream discussion: https://bugzilla.redhat.com/show_bug.cgi?id=2336567 Considering the inclusion of the <cstdbool> throws me up to 5 years ago back ( https://github.com/ruby/ruby/blob/9e6e39c3512f7a962c44dc3729c98a0f8be90341/… ), I assume this warning will be the case with older rubies as well as newest master when using GCC 15. ---Files-------------------------------- 0001-Stop-including-cstdbool-in-include-ruby-internal-std.patch (869 Bytes) -- https://bugs.ruby-lang.org/

5 6

[ruby-core:120315] [Ruby master Bug#20968] `Array#fetch_values` unexpected method name in stack trace
by koic (Koichi ITO) 24 Jun '25

24 Jun '25

Issue #20968 has been reported by koic (Koichi ITO). ---------------------------------------- Bug #20968: `Array#fetch_values` unexpected method name in stack trace https://bugs.ruby-lang.org/issues/20968 * Author: koic (Koichi ITO) * Status: Open * ruby -v: ruby 3.4.0dev (2024-12-19T04:44:56Z master 2783868de2) +PRISM [x86_64-darwin23] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- It seems that the current Ruby implementation is displaying unexpected method name in stack trace. ## Expected Similar to `Hash#fetch_values`, the method name `Array#fetch_values` is expected to be displayed in the stack trace. ```console $ ruby -e '{k: 42}.fetch_values(:unknown)' -e:1:in 'Hash#fetch_values': key not found: :unknown (KeyError) from -e:1:in '<main>' $ ruby -e '[1].fetch_values(42)' -e:1:in 'Array#fetch_values': index 42 outside of array bounds: -1...1 (IndexError) from -e:1:in '<main>' ``` ## Actual The stack trace displays the `Array#fetch` method, which user is not aware of, along with the `<internal.array>` stack trace. ```console $ ruby -e '[1].fetch_values(42)' <internal:array>:211:in 'Array#fetch': index 42 outside of array bounds: -1...1 (IndexError) from <internal:array>:211:in 'block in Array#fetch_values' from <internal:array>:211:in 'Array#map!' from <internal:array>:211:in 'Array#fetch_values' from -e:1:in '<main>' ``` It likely requires an approach such as implementing it in C, as suggested in https://github.com/ruby/ruby/pull/11555. -- https://bugs.ruby-lang.org/

10 21

[ruby-core:119041] [Ruby master Bug#20714] Handle optional dependencies in `bundled_gems.rb`
by Earlopain (A S) 23 Jun '25

23 Jun '25

Issue #20714 has been reported by Earlopain (A S). ---------------------------------------- Bug #20714: Handle optional dependencies in `bundled_gems.rb` https://bugs.ruby-lang.org/issues/20714 * Author: Earlopain (A S) * Status: Open * ruby -v: 3.3.5 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- I've encountered a few places around bundled gems where the library doesn't care if the gem is available, but will still provide some functionallity if it is. The way to accomplish that right now seems to be by setting `$VERBOSE = nil` and resetting it later again to not bother the user with the warning about the gem. However, this has the effect of silencing the warning about other gems as well, that may not be prepared about the bundling. From `ruby/reline` for example: https://github.com/ruby/reline/blob/c90f08f7e308d2f1cdd7cfaf9939fe45ce546fd… Or the `logging` gem: https://github.com/TwP/logging/blob/df41715364f7eb8c65098cd3c3316677ef1f378… I propose to simply delay the warning to the next require. GitHub PR at ... -- https://bugs.ruby-lang.org/

5 30

[ruby-core:120465] [Ruby master Bug#20998] rb_str_locktmp() changes flags of frozen strings and string literals
by Eregon (Benoit Daloze) 17 Jun '25

17 Jun '25

Issue #20998 has been reported by Eregon (Benoit Daloze). ---------------------------------------- Bug #20998: rb_str_locktmp() changes flags of frozen strings and string literals https://bugs.ruby-lang.org/issues/20998 * Author: Eregon (Benoit Daloze) * Status: Open * ruby -v: ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +PRISM [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- ```ruby # frozen_string_literal: true # BOILERPLATE START require 'tmpdir' require 'rbconfig' def inline_c_extension(c_code) Dir.mktmpdir('inline_c_extension') do |dir| File.write("#{dir}/cext.c", c_code) File.write("#{dir}/extconf.rb", <<~RUBY) require 'mkmf' create_makefile('cext') RUBY out = IO.popen([RbConfig.ruby, 'extconf.rb'], chdir: dir, &:read) raise "ruby extconf.rb failed: #{$?.inspect}\n#{out}" unless $?.success? out = IO.popen(['make'], chdir: dir, &:read) raise "make failed: #{$?.inspect}\n#{out}" unless $?.success? require "#{dir}/cext.#{RbConfig::CONFIG['DLEXT']}" end end inline_c_extension <<~C #include "ruby.h" static VALUE foo(VALUE self, VALUE str) { rb_str_locktmp(str); return str; } void Init_cext(void) { VALUE c = rb_define_class("Foo", rb_cObject); rb_define_singleton_method(c, "foo", foo, 1); } C # BOILERPLATE END a = "str" # imagine a million line of codes in between b = "str" Foo.foo(a) b << "." # can't modify string; temporarily locked (RuntimeError) # What? Who "locked" that immutable frozen string literal? # It should be: can't modify frozen String: "str" (FrozenError) ``` Same problem with: ```ruby Foo.foo("abc") # imagine a million line of codes in between Foo.foo("abc") # emporal locking already locked string (RuntimeError) ``` Related: https://github.com/oracle/truffleruby/issues/3752 It seems a clear bug to mutate a frozen string (with visible side effects), even more so for shared frozen string literals. I think rb_str_locktmp() should raise (a FrozenError, as it's effectively attempting to mutate it, same as calling `rb_str_modify()`) if called on a frozen string, because it makes little sense, I think "locking a string" only makes sense for mutable strings. The alternative would be to noop on frozen strings for rb_str_locktmp() and rb_str_unlocktmp(), I think that's susprising, and potentially hiding more bugs, e.g. if one by mistake tries to mutate the RSTRING_PTR() or so. Any attempt to mutate a frozen string should fail, so might as well fail early. -- https://bugs.ruby-lang.org/

7 16

[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