From b0c9286d98929db56514d8009040fe206b3d310f Mon Sep 17 00:00:00 2001
From: John Hawthorn <john@hawthorn.email>
Date: Sun, 2 Nov 2025 21:13:37 -0800
Subject: [PATCH 1/9] Use VWA for bignum

Previously we only allocated bignums from the 40 byte sizepool, and
embedded bignum used a fixed size.
---
 bignum.c                 | 62 ++++++++++++++++++++++++++++++++--------
 ext/-test-/bignum/depend | 12 ++++++++
 internal/bignum.h        | 25 +++++++++-------
 3 files changed, 77 insertions(+), 22 deletions(-)

diff --git a/bignum.c b/bignum.c
index 054b6c1cc9afe3..9e8d6a91f1004d 100644
--- a/bignum.c
+++ b/bignum.c
@@ -79,7 +79,6 @@ STATIC_ASSERT(sizeof_bdigit_and_dbl, SIZEOF_BDIGIT*2 <= SIZEOF_BDIGIT_DBL);
 STATIC_ASSERT(bdigit_signedness, 0 < (BDIGIT)-1);
 STATIC_ASSERT(bdigit_dbl_signedness, 0 < (BDIGIT_DBL)-1);
 STATIC_ASSERT(bdigit_dbl_signed_signedness, 0 > (BDIGIT_DBL_SIGNED)-1);
-STATIC_ASSERT(rbignum_embed_len_max, BIGNUM_EMBED_LEN_MAX <= (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT));
 
 #if SIZEOF_BDIGIT < SIZEOF_LONG
 STATIC_ASSERT(sizeof_long_and_sizeof_bdigit, SIZEOF_LONG % SIZEOF_BDIGIT == 0);
@@ -2990,25 +2989,56 @@ rb_cmpint(VALUE val, VALUE a, VALUE b)
             ((l) << BIGNUM_EMBED_LEN_SHIFT)) : \
      (void)(RBIGNUM(b)->as.heap.len = (l)))
 
+static size_t
+big_embed_capa(VALUE big)
+{
+    size_t size = rb_gc_obj_slot_size(big) - offsetof(struct RBignum, as.ary);
+    RUBY_ASSERT(size % sizeof(BDIGIT) == 0);
+    size_t capa = size / sizeof(BDIGIT);
+    RUBY_ASSERT(capa <= BIGNUM_EMBED_LEN_MAX);
+    return capa;
+}
+
+static size_t
+big_embed_size(size_t capa)
+{
+    size_t size = offsetof(struct RBignum, as.ary) + (sizeof(BDIGIT) * capa);
+    if (size < sizeof(struct RBignum)) {
+        size = sizeof(struct RBignum);
+    }
+    return size;
+}
+
+static bool
+big_embeddable_p(size_t capa)
+{
+    if (capa > BIGNUM_EMBED_LEN_MAX) {
+        return false;
+    }
+    return rb_gc_size_allocatable_p(big_embed_size(capa));
+}
+
 static void
 rb_big_realloc(VALUE big, size_t len)
 {
     BDIGIT *ds;
+    size_t embed_capa = big_embed_capa(big);
+
     if (BIGNUM_EMBED_P(big)) {
-        if (BIGNUM_EMBED_LEN_MAX < len) {
+        if (embed_capa < len) {
             ds = ALLOC_N(BDIGIT, len);
-            MEMCPY(ds, RBIGNUM(big)->as.ary, BDIGIT, BIGNUM_EMBED_LEN_MAX);
+            MEMCPY(ds, RBIGNUM(big)->as.ary, BDIGIT, embed_capa);
             RBIGNUM(big)->as.heap.len = BIGNUM_LEN(big);
             RBIGNUM(big)->as.heap.digits = ds;
             FL_UNSET_RAW(big, BIGNUM_EMBED_FLAG);
         }
     }
     else {
-        if (len <= BIGNUM_EMBED_LEN_MAX) {
+        if (len <= embed_capa) {
             ds = RBIGNUM(big)->as.heap.digits;
             FL_SET_RAW(big, BIGNUM_EMBED_FLAG);
             BIGNUM_SET_LEN(big, len);
-            (void)VALGRIND_MAKE_MEM_UNDEFINED((void*)RBIGNUM(big)->as.ary, sizeof(RBIGNUM(big)->as.ary));
+            (void)VALGRIND_MAKE_MEM_UNDEFINED((void*)RBIGNUM(big)->as.ary, embed_capa * sizeof(BDIGIT));
             if (ds) {
                 MEMCPY(RBIGNUM(big)->as.ary, ds, BDIGIT, len);
                 xfree(ds);
@@ -3035,16 +3065,24 @@ rb_big_resize(VALUE big, size_t len)
 static VALUE
 bignew_1(VALUE klass, size_t len, int sign)
 {
-    NEWOBJ_OF(big, struct RBignum, klass,
-            T_BIGNUM | (RGENGC_WB_PROTECTED_BIGNUM ? FL_WB_PROTECTED : 0), sizeof(struct RBignum), 0);
-    VALUE bigv = (VALUE)big;
-    BIGNUM_SET_SIGN(bigv, sign);
-    if (len <= BIGNUM_EMBED_LEN_MAX) {
-        FL_SET_RAW(bigv, BIGNUM_EMBED_FLAG);
+    VALUE bigv;
+
+    if (big_embeddable_p(len)) {
+        size_t size = big_embed_size(len);
+        RUBY_ASSERT(rb_gc_size_allocatable_p(size));
+        NEWOBJ_OF(big, struct RBignum, klass,
+                T_BIGNUM | BIGNUM_EMBED_FLAG | (RGENGC_WB_PROTECTED_BIGNUM ? FL_WB_PROTECTED : 0),
+                size, 0);
+        bigv = (VALUE)big;
+        BIGNUM_SET_SIGN(bigv, sign);
         BIGNUM_SET_LEN(bigv, len);
-        (void)VALGRIND_MAKE_MEM_UNDEFINED((void*)big->as.ary, sizeof(big->as.ary));
+        (void)VALGRIND_MAKE_MEM_UNDEFINED((void*)big->as.ary, len * sizeof(BDIGIT));
     }
     else {
+        NEWOBJ_OF(big, struct RBignum, klass,
+                T_BIGNUM | (RGENGC_WB_PROTECTED_BIGNUM ? FL_WB_PROTECTED : 0), sizeof(struct RBignum), 0);
+        bigv = (VALUE)big;
+        BIGNUM_SET_SIGN(bigv, sign);
         big->as.heap.digits = ALLOC_N(BDIGIT, len);
         big->as.heap.len = len;
     }
diff --git a/ext/-test-/bignum/depend b/ext/-test-/bignum/depend
index 049f0c7b520970..82972f10327311 100644
--- a/ext/-test-/bignum/depend
+++ b/ext/-test-/bignum/depend
@@ -6,6 +6,7 @@ big2str.o: $(hdrdir)/ruby/backward.h
 big2str.o: $(hdrdir)/ruby/backward/2/assume.h
 big2str.o: $(hdrdir)/ruby/backward/2/attributes.h
 big2str.o: $(hdrdir)/ruby/backward/2/bool.h
+big2str.o: $(hdrdir)/ruby/backward/2/gcc_version_since.h
 big2str.o: $(hdrdir)/ruby/backward/2/inttypes.h
 big2str.o: $(hdrdir)/ruby/backward/2/limits.h
 big2str.o: $(hdrdir)/ruby/backward/2/long_long.h
@@ -159,6 +160,7 @@ big2str.o: $(hdrdir)/ruby/ruby.h
 big2str.o: $(hdrdir)/ruby/st.h
 big2str.o: $(hdrdir)/ruby/subst.h
 big2str.o: $(top_srcdir)/internal/bignum.h
+big2str.o: $(top_srcdir)/internal/compilers.h
 big2str.o: big2str.c
 bigzero.o: $(RUBY_EXTCONF_H)
 bigzero.o: $(arch_hdrdir)/ruby/config.h
@@ -167,6 +169,7 @@ bigzero.o: $(hdrdir)/ruby/backward.h
 bigzero.o: $(hdrdir)/ruby/backward/2/assume.h
 bigzero.o: $(hdrdir)/ruby/backward/2/attributes.h
 bigzero.o: $(hdrdir)/ruby/backward/2/bool.h
+bigzero.o: $(hdrdir)/ruby/backward/2/gcc_version_since.h
 bigzero.o: $(hdrdir)/ruby/backward/2/inttypes.h
 bigzero.o: $(hdrdir)/ruby/backward/2/limits.h
 bigzero.o: $(hdrdir)/ruby/backward/2/long_long.h
@@ -320,6 +323,7 @@ bigzero.o: $(hdrdir)/ruby/ruby.h
 bigzero.o: $(hdrdir)/ruby/st.h
 bigzero.o: $(hdrdir)/ruby/subst.h
 bigzero.o: $(top_srcdir)/internal/bignum.h
+bigzero.o: $(top_srcdir)/internal/compilers.h
 bigzero.o: bigzero.c
 div.o: $(RUBY_EXTCONF_H)
 div.o: $(arch_hdrdir)/ruby/config.h
@@ -328,6 +332,7 @@ div.o: $(hdrdir)/ruby/backward.h
 div.o: $(hdrdir)/ruby/backward/2/assume.h
 div.o: $(hdrdir)/ruby/backward/2/attributes.h
 div.o: $(hdrdir)/ruby/backward/2/bool.h
+div.o: $(hdrdir)/ruby/backward/2/gcc_version_since.h
 div.o: $(hdrdir)/ruby/backward/2/inttypes.h
 div.o: $(hdrdir)/ruby/backward/2/limits.h
 div.o: $(hdrdir)/ruby/backward/2/long_long.h
@@ -481,6 +486,7 @@ div.o: $(hdrdir)/ruby/ruby.h
 div.o: $(hdrdir)/ruby/st.h
 div.o: $(hdrdir)/ruby/subst.h
 div.o: $(top_srcdir)/internal/bignum.h
+div.o: $(top_srcdir)/internal/compilers.h
 div.o: div.c
 init.o: $(RUBY_EXTCONF_H)
 init.o: $(arch_hdrdir)/ruby/config.h
@@ -650,6 +656,7 @@ intpack.o: $(hdrdir)/ruby/backward.h
 intpack.o: $(hdrdir)/ruby/backward/2/assume.h
 intpack.o: $(hdrdir)/ruby/backward/2/attributes.h
 intpack.o: $(hdrdir)/ruby/backward/2/bool.h
+intpack.o: $(hdrdir)/ruby/backward/2/gcc_version_since.h
 intpack.o: $(hdrdir)/ruby/backward/2/inttypes.h
 intpack.o: $(hdrdir)/ruby/backward/2/limits.h
 intpack.o: $(hdrdir)/ruby/backward/2/long_long.h
@@ -803,6 +810,7 @@ intpack.o: $(hdrdir)/ruby/ruby.h
 intpack.o: $(hdrdir)/ruby/st.h
 intpack.o: $(hdrdir)/ruby/subst.h
 intpack.o: $(top_srcdir)/internal/bignum.h
+intpack.o: $(top_srcdir)/internal/compilers.h
 intpack.o: intpack.c
 mul.o: $(RUBY_EXTCONF_H)
 mul.o: $(arch_hdrdir)/ruby/config.h
@@ -811,6 +819,7 @@ mul.o: $(hdrdir)/ruby/backward.h
 mul.o: $(hdrdir)/ruby/backward/2/assume.h
 mul.o: $(hdrdir)/ruby/backward/2/attributes.h
 mul.o: $(hdrdir)/ruby/backward/2/bool.h
+mul.o: $(hdrdir)/ruby/backward/2/gcc_version_since.h
 mul.o: $(hdrdir)/ruby/backward/2/inttypes.h
 mul.o: $(hdrdir)/ruby/backward/2/limits.h
 mul.o: $(hdrdir)/ruby/backward/2/long_long.h
@@ -964,6 +973,7 @@ mul.o: $(hdrdir)/ruby/ruby.h
 mul.o: $(hdrdir)/ruby/st.h
 mul.o: $(hdrdir)/ruby/subst.h
 mul.o: $(top_srcdir)/internal/bignum.h
+mul.o: $(top_srcdir)/internal/compilers.h
 mul.o: mul.c
 str2big.o: $(RUBY_EXTCONF_H)
 str2big.o: $(arch_hdrdir)/ruby/config.h
@@ -972,6 +982,7 @@ str2big.o: $(hdrdir)/ruby/backward.h
 str2big.o: $(hdrdir)/ruby/backward/2/assume.h
 str2big.o: $(hdrdir)/ruby/backward/2/attributes.h
 str2big.o: $(hdrdir)/ruby/backward/2/bool.h
+str2big.o: $(hdrdir)/ruby/backward/2/gcc_version_since.h
 str2big.o: $(hdrdir)/ruby/backward/2/inttypes.h
 str2big.o: $(hdrdir)/ruby/backward/2/limits.h
 str2big.o: $(hdrdir)/ruby/backward/2/long_long.h
@@ -1125,5 +1136,6 @@ str2big.o: $(hdrdir)/ruby/ruby.h
 str2big.o: $(hdrdir)/ruby/st.h
 str2big.o: $(hdrdir)/ruby/subst.h
 str2big.o: $(top_srcdir)/internal/bignum.h
+str2big.o: $(top_srcdir)/internal/compilers.h
 str2big.o: str2big.c
 # AUTOGENERATED DEPENDENCIES END
diff --git a/internal/bignum.h b/internal/bignum.h
index 0ba21a492334f1..e5b6b425631f80 100644
--- a/internal/bignum.h
+++ b/internal/bignum.h
@@ -9,6 +9,7 @@
  * @brief      Internal header for Bignums.
  */
 #include "ruby/internal/config.h"      /* for HAVE_LIBGMP */
+#include "internal/compilers.h"        /* for FLEX_ARY_LEN */
 #include <stddef.h>             /* for size_t */
 
 #ifdef HAVE_SYS_TYPES_H
@@ -76,18 +77,17 @@
 #define RBIGNUM(obj) ((struct RBignum *)(obj))
 #define BIGNUM_SIGN_BIT FL_USER1
 #define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
-#define BIGNUM_EMBED_LEN_NUMBITS 3
+
+/* This is likely more bits than we need today and will also need adjustment if
+ * we change GC slot sizes.
+ */
+#define BIGNUM_EMBED_LEN_NUMBITS 9
 #define BIGNUM_EMBED_LEN_MASK \
-    (~(~(VALUE)0U << BIGNUM_EMBED_LEN_NUMBITS) << BIGNUM_EMBED_LEN_SHIFT)
+    (RUBY_FL_USER11 | RUBY_FL_USER10 | RUBY_FL_USER9 | RUBY_FL_USER8 | RUBY_FL_USER7 | \
+     RUBY_FL_USER6 | RUBY_FL_USER5 | RUBY_FL_USER4 | RUBY_FL_USER3)
 #define BIGNUM_EMBED_LEN_SHIFT \
     (FL_USHIFT+3) /* bit offset of BIGNUM_EMBED_LEN_MASK */
-#ifndef BIGNUM_EMBED_LEN_MAX
-# if (SIZEOF_VALUE*RBIMPL_RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
-#  define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*RBIMPL_RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT)
-# else
-#  define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
-# endif
-#endif
+#define BIGNUM_EMBED_LEN_MAX (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)
 
 enum rb_int_parse_flags {
     RB_INT_PARSE_SIGN       = 0x01,
@@ -104,7 +104,12 @@ struct RBignum {
             size_t len;
             BDIGIT *digits;
         } heap;
-        BDIGIT ary[BIGNUM_EMBED_LEN_MAX];
+        /* This is a length 1 array because:
+         *   1. GCC has a bug that does not optimize C flexible array members
+         *      (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102452)
+         *   2. Zero length arrays are not supported by all compilers
+         */
+        BDIGIT ary[1];
     } as;
 };
 

From 930afa1c7ba747658cc4253c2cb6a367d7a6a36b Mon Sep 17 00:00:00 2001
From: John Hawthorn <john@hawthorn.email>
Date: Mon, 3 Nov 2025 15:48:28 -0800
Subject: [PATCH 2/9] Never shrink bignum on realloc

As far as I can tell, this only ever shrinks by one, and it's really not
worth the expensive realloc for that.
---
 bignum.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bignum.c b/bignum.c
index 9e8d6a91f1004d..8d3eac8e0a9173 100644
--- a/bignum.c
+++ b/bignum.c
@@ -3048,7 +3048,7 @@ rb_big_realloc(VALUE big, size_t len)
             if (BIGNUM_LEN(big) == 0) {
                 RBIGNUM(big)->as.heap.digits = ALLOC_N(BDIGIT, len);
             }
-            else {
+            else if (BIGNUM_LEN(big) < len) {
                 REALLOC_N(RBIGNUM(big)->as.heap.digits, BDIGIT, len);
             }
         }

From 65dbd571c1e0aae3b0919ae6e64704726f18b265 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89tienne=20Barri=C3=A9?= <etienne.barrie@gmail.com>
Date: Fri, 5 Dec 2025 15:33:44 +0100
Subject: [PATCH 3/9] [ruby/psych] Use Node#to_ruby parse_symbols option

https://github.com/ruby/psych/commit/907fd4fa97
---
 ext/psych/lib/psych/nodes/node.rb   | 2 +-
 test/psych/visitors/test_to_ruby.rb | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/ext/psych/lib/psych/nodes/node.rb b/ext/psych/lib/psych/nodes/node.rb
index f89c82b7f76df8..fc27448f2e5ec8 100644
--- a/ext/psych/lib/psych/nodes/node.rb
+++ b/ext/psych/lib/psych/nodes/node.rb
@@ -46,7 +46,7 @@ def each &block
       #
       # See also Psych::Visitors::ToRuby
       def to_ruby(symbolize_names: false, freeze: false, strict_integer: false, parse_symbols: true)
-        Visitors::ToRuby.create(symbolize_names: symbolize_names, freeze: freeze, strict_integer: strict_integer, parse_symbols: true).accept(self)
+        Visitors::ToRuby.create(symbolize_names: symbolize_names, freeze: freeze, strict_integer: strict_integer, parse_symbols: parse_symbols).accept(self)
       end
       alias :transform :to_ruby
 
diff --git a/test/psych/visitors/test_to_ruby.rb b/test/psych/visitors/test_to_ruby.rb
index 89c367665191f9..c9b501dfa274db 100644
--- a/test/psych/visitors/test_to_ruby.rb
+++ b/test/psych/visitors/test_to_ruby.rb
@@ -328,6 +328,12 @@ def test_mapping_with_str_tag
         mapping.children << Nodes::Scalar.new('bar')
         assert_equal({'foo' => 'bar'}, mapping.to_ruby)
       end
+
+      def test_parse_symbols
+        node = Nodes::Scalar.new(':foo')
+        assert_equal :foo, node.to_ruby
+        assert_equal ':foo', node.to_ruby(parse_symbols: false)
+      end
     end
   end
 end

From ec28bd75a869c2e525388582370239a9ff8c19e7 Mon Sep 17 00:00:00 2001
From: Koichi Sasada <ko1@atdot.net>
Date: Fri, 5 Dec 2025 01:49:31 +0900
Subject: [PATCH 4/9] [ruby/timeout] support Ractor

1. Introduce State to store all status.
2. Store State instance to the Ractor local storage if possible
3. Make `GET_TIME` (Method object) shareable if possible

3 is supporeted Ruby 4.0 and later, so the Rator support is works
only on Ruby 4.0 and later.

https://github.com/ruby/timeout/commit/54ff671c6c
---
 lib/timeout.rb       | 166 ++++++++++++++++++++++++++++---------------
 test/test_timeout.rb |  20 ++++++
 2 files changed, 127 insertions(+), 59 deletions(-)

diff --git a/lib/timeout.rb b/lib/timeout.rb
index f173d028a39d0a..2bf3e7514653f6 100644
--- a/lib/timeout.rb
+++ b/lib/timeout.rb
@@ -44,12 +44,107 @@ def self.handle_timeout(message) # :nodoc:
   end
 
   # :stopdoc:
-  CONDVAR = ConditionVariable.new
-  QUEUE = Queue.new
-  QUEUE_MUTEX = Mutex.new
-  TIMEOUT_THREAD_MUTEX = Mutex.new
-  @timeout_thread = nil
-  private_constant :CONDVAR, :QUEUE, :QUEUE_MUTEX, :TIMEOUT_THREAD_MUTEX
+
+  # We keep a private reference so that time mocking libraries won't break
+  # Timeout.
+  GET_TIME =
+    if defined?(Ractor.make_shareable)
+      begin
+        Ractor.make_shareable(Process.method(:clock_gettime))
+      rescue # failed on Ruby 3.4
+        Process.method(:clock_gettime)
+      end
+    else
+      Process.method(:clock_gettime)
+    end
+
+  private_constant :GET_TIME
+
+  class State
+    attr_reader :condvar, :queue, :queue_mutex # shared with Timeout.timeout()
+
+    def initialize
+      @condvar = ConditionVariable.new
+      @queue = Queue.new
+      @queue_mutex = Mutex.new
+
+      @timeout_thread = nil
+      @timeout_thread_mutex = Mutex.new
+    end
+
+    if defined?(Ractor.store_if_absent) &&
+       defined?(Ractor.shareble?) && Ractor.shareable?(GET_TIME)
+
+       # Ractor support if
+       # 1. Ractor.store_if_absent is available
+       # 2. Method object can be shareable (4.0~)
+
+       Ractor.store_if_absent :timeout_gem_state do
+         State.new
+       end
+
+       def self.instance
+         Ractor[:timeout_gem_state]
+       end
+
+       ::Timeout::RACTOR_SUPPORT = true # for test
+    else
+      @GLOBAL_STATE = State.new
+
+      def self.instance
+        @GLOBAL_STATE
+      end
+    end
+
+    def create_timeout_thread
+      watcher = Thread.new do
+        requests = []
+        while true
+          until @queue.empty? and !requests.empty? # wait to have at least one request
+            req = @queue.pop
+            requests << req unless req.done?
+          end
+          closest_deadline = requests.min_by(&:deadline).deadline
+
+          now = 0.0
+          @queue_mutex.synchronize do
+            while (now = GET_TIME.call(Process::CLOCK_MONOTONIC)) < closest_deadline and @queue.empty?
+              @condvar.wait(@queue_mutex, closest_deadline - now)
+            end
+          end
+
+          requests.each do |req|
+            req.interrupt if req.expired?(now)
+          end
+          requests.reject!(&:done?)
+        end
+      end
+
+      if !watcher.group.enclosed? && (!defined?(Ractor.main?) || Ractor.main?)
+        ThreadGroup::Default.add(watcher)
+      end
+
+      watcher.name = "Timeout stdlib thread"
+      watcher.thread_variable_set(:"\0__detached_thread__", true)
+      watcher
+    end
+
+    def ensure_timeout_thread_created
+      unless @timeout_thread&.alive?
+        # If the Mutex is already owned we are in a signal handler.
+        # In that case, just return and let the main thread create the Timeout thread.
+        return if @timeout_thread_mutex.owned?
+
+        @timeout_thread_mutex.synchronize do
+          unless @timeout_thread&.alive?
+            @timeout_thread = create_timeout_thread
+          end
+        end
+      end
+    end
+  end
+
+  private_constant :State
 
   class Request
     attr_reader :deadline
@@ -91,55 +186,6 @@ def finished
   end
   private_constant :Request
 
-  def self.create_timeout_thread
-    watcher = Thread.new do
-      requests = []
-      while true
-        until QUEUE.empty? and !requests.empty? # wait to have at least one request
-          req = QUEUE.pop
-          requests << req unless req.done?
-        end
-        closest_deadline = requests.min_by(&:deadline).deadline
-
-        now = 0.0
-        QUEUE_MUTEX.synchronize do
-          while (now = GET_TIME.call(Process::CLOCK_MONOTONIC)) < closest_deadline and QUEUE.empty?
-            CONDVAR.wait(QUEUE_MUTEX, closest_deadline - now)
-          end
-        end
-
-        requests.each do |req|
-          req.interrupt if req.expired?(now)
-        end
-        requests.reject!(&:done?)
-      end
-    end
-    ThreadGroup::Default.add(watcher) unless watcher.group.enclosed?
-    watcher.name = "Timeout stdlib thread"
-    watcher.thread_variable_set(:"\0__detached_thread__", true)
-    watcher
-  end
-  private_class_method :create_timeout_thread
-
-  def self.ensure_timeout_thread_created
-    unless @timeout_thread and @timeout_thread.alive?
-      # If the Mutex is already owned we are in a signal handler.
-      # In that case, just return and let the main thread create the @timeout_thread.
-      return if TIMEOUT_THREAD_MUTEX.owned?
-      TIMEOUT_THREAD_MUTEX.synchronize do
-        unless @timeout_thread and @timeout_thread.alive?
-          @timeout_thread = create_timeout_thread
-        end
-      end
-    end
-  end
-  private_class_method :ensure_timeout_thread_created
-
-  # We keep a private reference so that time mocking libraries won't break
-  # Timeout.
-  GET_TIME = Process.method(:clock_gettime)
-  private_constant :GET_TIME
-
   # :startdoc:
 
   # Perform an operation in a block, raising an error if it takes longer than
@@ -178,12 +224,14 @@ def self.timeout(sec, klass = nil, message = nil, &block)   #:yield: +sec+
       return scheduler.timeout_after(sec, klass || Error, message, &block)
     end
 
-    ensure_timeout_thread_created
+    state = State.instance
+    state.ensure_timeout_thread_created
+
     perform = Proc.new do |exc|
       request = Request.new(Thread.current, sec, exc, message)
-      QUEUE_MUTEX.synchronize do
-        QUEUE << request
-        CONDVAR.signal
+      state.queue_mutex.synchronize do
+        state.queue << request
+        state.condvar.signal
       end
       begin
         return yield(sec)
diff --git a/test/test_timeout.rb b/test/test_timeout.rb
index e367df757cc9b2..233f54eb82bf2d 100644
--- a/test/test_timeout.rb
+++ b/test/test_timeout.rb
@@ -280,4 +280,24 @@ def test_handling_enclosed_threadgroup
       }.join
     end;
   end
+
+  def test_ractor
+    assert_separately(%w[-rtimeout -W0], <<-'end;')
+      r = Ractor.new do
+        Timeout.timeout(1) { 42 }
+      end.value
+
+      assert_equal 42, r
+
+      r = Ractor.new do
+        begin
+          Timeout.timeout(0.1) { sleep }
+        rescue Timeout::Error
+          :ok
+        end
+      end.value
+
+      assert_equal :ok, r
+    end;
+  end if Timeout.const_defined?(:RACTOR_SUPPORT)
 end

From a523e9d872d51e64eecbf3feeaa8d4d8769f72bd Mon Sep 17 00:00:00 2001
From: Benoit Daloze <eregontp@gmail.com>
Date: Fri, 5 Dec 2025 19:14:28 +0100
Subject: [PATCH 5/9] [ruby/timeout] Minor tweaks

https://github.com/ruby/timeout/commit/daab9a2193
---
 lib/timeout.rb | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/lib/timeout.rb b/lib/timeout.rb
index 2bf3e7514653f6..3ad0193ac5f785 100644
--- a/lib/timeout.rb
+++ b/lib/timeout.rb
@@ -57,7 +57,6 @@ def self.handle_timeout(message) # :nodoc:
     else
       Process.method(:clock_gettime)
     end
-
   private_constant :GET_TIME
 
   class State
@@ -89,10 +88,10 @@ def self.instance
 
        ::Timeout::RACTOR_SUPPORT = true # for test
     else
-      @GLOBAL_STATE = State.new
+      GLOBAL_STATE = State.new
 
       def self.instance
-        @GLOBAL_STATE
+        GLOBAL_STATE
       end
     end
 
@@ -143,7 +142,6 @@ def ensure_timeout_thread_created
       end
     end
   end
-
   private_constant :State
 
   class Request

From dc406af9cb9a269ae550483fa1278eedf297fb92 Mon Sep 17 00:00:00 2001
From: Benoit Daloze <eregontp@gmail.com>
Date: Fri, 5 Dec 2025 19:19:13 +0100
Subject: [PATCH 6/9] [ruby/timeout] Fix condition and fix test to catch that
 broken condition

https://github.com/ruby/timeout/commit/82fb6f6925
---
 lib/timeout.rb       | 4 +---
 test/test_timeout.rb | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/lib/timeout.rb b/lib/timeout.rb
index 3ad0193ac5f785..47410af386295c 100644
--- a/lib/timeout.rb
+++ b/lib/timeout.rb
@@ -72,7 +72,7 @@ def initialize
     end
 
     if defined?(Ractor.store_if_absent) &&
-       defined?(Ractor.shareble?) && Ractor.shareable?(GET_TIME)
+       defined?(Ractor.shareable?) && Ractor.shareable?(GET_TIME)
 
        # Ractor support if
        # 1. Ractor.store_if_absent is available
@@ -85,8 +85,6 @@ def initialize
        def self.instance
          Ractor[:timeout_gem_state]
        end
-
-       ::Timeout::RACTOR_SUPPORT = true # for test
     else
       GLOBAL_STATE = State.new
 
diff --git a/test/test_timeout.rb b/test/test_timeout.rb
index 233f54eb82bf2d..3f94134fb04d9c 100644
--- a/test/test_timeout.rb
+++ b/test/test_timeout.rb
@@ -299,5 +299,5 @@ def test_ractor
 
       assert_equal :ok, r
     end;
-  end if Timeout.const_defined?(:RACTOR_SUPPORT)
+  end if defined?(::Ractor) && RUBY_VERSION >= '4.0'
 end

From 3e189ddb9db486d1bc7d5c15f395017b4fb0c136 Mon Sep 17 00:00:00 2001
From: Benoit Daloze <eregontp@gmail.com>
Date: Fri, 5 Dec 2025 19:21:37 +0100
Subject: [PATCH 7/9] [ruby/timeout] Fix logic for Ractor support

* Fix indentation to stay a multiple of 2 spaces.

https://github.com/ruby/timeout/commit/a1d784cb66
---
 lib/timeout.rb | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/lib/timeout.rb b/lib/timeout.rb
index 47410af386295c..eab1a1be9e19a4 100644
--- a/lib/timeout.rb
+++ b/lib/timeout.rb
@@ -45,8 +45,7 @@ def self.handle_timeout(message) # :nodoc:
 
   # :stopdoc:
 
-  # We keep a private reference so that time mocking libraries won't break
-  # Timeout.
+  # We keep a private reference so that time mocking libraries won't break Timeout.
   GET_TIME =
     if defined?(Ractor.make_shareable)
       begin
@@ -71,20 +70,15 @@ def initialize
       @timeout_thread_mutex = Mutex.new
     end
 
-    if defined?(Ractor.store_if_absent) &&
-       defined?(Ractor.shareable?) && Ractor.shareable?(GET_TIME)
-
-       # Ractor support if
-       # 1. Ractor.store_if_absent is available
-       # 2. Method object can be shareable (4.0~)
-
-       Ractor.store_if_absent :timeout_gem_state do
-         State.new
-       end
-
-       def self.instance
-         Ractor[:timeout_gem_state]
-       end
+    if defined?(Ractor.store_if_absent) && defined?(Ractor.shareable?) && Ractor.shareable?(GET_TIME)
+      # Ractor support if
+      # 1. Ractor.store_if_absent is available
+      # 2. Method object can be shareable (4.0~)
+      def self.instance
+        Ractor.store_if_absent :timeout_gem_state do
+          State.new
+        end
+      end
     else
       GLOBAL_STATE = State.new
 

From 00b91c727fdd0dd3bcd970dd4bc6c2b598cf4e1b Mon Sep 17 00:00:00 2001
From: Benoit Daloze <eregontp@gmail.com>
Date: Fri, 5 Dec 2025 19:25:22 +0100
Subject: [PATCH 8/9] [ruby/timeout] Simplify logic to make GET_TIME shareable

https://github.com/ruby/timeout/commit/281b2507e7
---
 lib/timeout.rb | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/lib/timeout.rb b/lib/timeout.rb
index eab1a1be9e19a4..36cd0f915bc7ff 100644
--- a/lib/timeout.rb
+++ b/lib/timeout.rb
@@ -46,16 +46,11 @@ def self.handle_timeout(message) # :nodoc:
   # :stopdoc:
 
   # We keep a private reference so that time mocking libraries won't break Timeout.
-  GET_TIME =
-    if defined?(Ractor.make_shareable)
-      begin
-        Ractor.make_shareable(Process.method(:clock_gettime))
-      rescue # failed on Ruby 3.4
-        Process.method(:clock_gettime)
-      end
-    else
-      Process.method(:clock_gettime)
-    end
+  GET_TIME = Process.method(:clock_gettime)
+  if defined?(Ractor.make_shareable)
+    # Ractor.make_shareable(Method) only works on Ruby 4+
+    Ractor.make_shareable(GET_TIME) rescue nil
+  end
   private_constant :GET_TIME
 
   class State

From 8c4f79d5f30fb2fe647c4f3fd262a5fdeacaeca2 Mon Sep 17 00:00:00 2001
From: Kazuki Yamaguchi <k@rhe.jp>
Date: Sat, 6 Dec 2025 03:33:12 +0900
Subject: [PATCH 9/9] [ruby/openssl] x509cert: handle invalid validity periods
 in Certificate#inspect

In a newly allocated OpenSSL X509 object, the notBefore and notAfter
fields contain an ASN1_STRING object with type V_ASN1_UNDEF rather than
an ASN1_TIME.

Commit https://github.com/ruby/openssl/commit/73484f67949a made asn1time_to_time() stricter and it now raises
an exception if the argument is not an ASN1_TIME. Previously, it would
print a verbose-mode warning and return nil.

OpenSSL::X509::Certificate#inspect should work even when the certificate
is invalid. Let's handle this.

https://github.com/ruby/openssl/commit/18c283f2b6
---
 ext/openssl/lib/openssl/x509.rb |  9 +++++++++
 ext/openssl/ossl_x509cert.c     | 15 ---------------
 test/openssl/test_x509cert.rb   |  8 ++++++++
 3 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/ext/openssl/lib/openssl/x509.rb b/ext/openssl/lib/openssl/x509.rb
index 6459d37b12766e..66765ffeabf0dc 100644
--- a/ext/openssl/lib/openssl/x509.rb
+++ b/ext/openssl/lib/openssl/x509.rb
@@ -346,6 +346,15 @@ class Certificate
       include Extension::CRLDistributionPoints
       include Extension::AuthorityInfoAccess
 
+      def inspect
+        "#<#{self.class}: " \
+          "subject=#{subject.inspect}, " \
+          "issuer=#{issuer.inspect}, " \
+          "serial=#{serial.inspect}, " \
+          "not_before=#{not_before.inspect rescue "(error)"}, " \
+          "not_after=#{not_after.inspect rescue "(error)"}>"
+      end
+
       def pretty_print(q)
         q.object_group(self) {
           q.breakable
diff --git a/ext/openssl/ossl_x509cert.c b/ext/openssl/ossl_x509cert.c
index b1e82a2790adf6..4d69008fdd9a81 100644
--- a/ext/openssl/ossl_x509cert.c
+++ b/ext/openssl/ossl_x509cert.c
@@ -665,20 +665,6 @@ ossl_x509_add_extension(VALUE self, VALUE extension)
     return extension;
 }
 
-static VALUE
-ossl_x509_inspect(VALUE self)
-{
-    return rb_sprintf("#<%"PRIsVALUE": subject=%+"PRIsVALUE", "
-                      "issuer=%+"PRIsVALUE", serial=%+"PRIsVALUE", "
-                      "not_before=%+"PRIsVALUE", not_after=%+"PRIsVALUE">",
-                      rb_obj_class(self),
-                      ossl_x509_get_subject(self),
-                      ossl_x509_get_issuer(self),
-                      ossl_x509_get_serial(self),
-                      ossl_x509_get_not_before(self),
-                      ossl_x509_get_not_after(self));
-}
-
 /*
  * call-seq:
  *    cert1 == cert2 -> true | false
@@ -1013,7 +999,6 @@ Init_ossl_x509cert(void)
     rb_define_method(cX509Cert, "extensions", ossl_x509_get_extensions, 0);
     rb_define_method(cX509Cert, "extensions=", ossl_x509_set_extensions, 1);
     rb_define_method(cX509Cert, "add_extension", ossl_x509_add_extension, 1);
-    rb_define_method(cX509Cert, "inspect", ossl_x509_inspect, 0);
     rb_define_method(cX509Cert, "==", ossl_x509_eq, 1);
     rb_define_method(cX509Cert, "tbs_bytes", ossl_x509_tbs_bytes, 0);
 }
diff --git a/test/openssl/test_x509cert.rb b/test/openssl/test_x509cert.rb
index 877eac69ce5e34..9e0aa4edf6b372 100644
--- a/test/openssl/test_x509cert.rb
+++ b/test/openssl/test_x509cert.rb
@@ -298,6 +298,14 @@ def test_eq
     assert_equal false, cert3 == cert4
   end
 
+  def test_inspect
+    cacert = issue_cert(@ca, @rsa1, 1, [], nil, nil)
+    assert_include(cacert.inspect, "subject=#{@ca.inspect}")
+
+    # Do not raise an exception for an invalid certificate
+    assert_instance_of(String, OpenSSL::X509::Certificate.new.inspect)
+  end
+
   def test_marshal
     now = Time.now
     cacert = issue_cert(@ca, @rsa1, 1, [], nil, nil,