Skip to content

[pull] master from ruby:master - #1358

Merged
pull[bot] merged 7 commits into
turkdevops:masterfrom
ruby:master
Aug 29, 2026
Merged

[pull] master from ruby:master#1358
pull[bot] merged 7 commits into
turkdevops:masterfrom
ruby:master

Conversation

@pull

@pull pull Bot commented Aug 29, 2026

Copy link
Copy Markdown

See Commits and Changes for more details.


Created by pull[bot] (v2.0.0-alpha.4)

Can you help keep this open source service alive? 💖 Please sponsor : )

peterzhu2118 and others added 7 commits August 28, 2026 22:23
We keep a singleton of iseq wrappers (RubyVM::InstructionSequence). However,
this is rarely used and causes 8 bytes to be wasted on all iseq objects.
Since we now have the 32-byte slot size in the default GC, we can save that
memory.
Pass the input encoding through `date__strptime` so non-ASCII trailing
data is treated as a parse failure instead of raising an encoding error.

Fixes ruby/date#179.

ruby/date@edf7cf016c
Reject week numbers outside -53..-1 and 1..53 before conversion so
integer overflow cannot make invalid input appear valid.

Fixes ruby/date#180.

ruby/date@e9c07010c7
Every branch of offset_to_sec range-checks the resulting number of
seconds except one path through the Rational branch: when the day
fraction is an integral Rational, n is assigned inside the if arm and
reaches *rof without passing the guard that sits in the else arm.

DateTime.new(2024, 1, 1, 0, 0, 0, Rational(2, 1)) therefore produced a
48-hour offset, while the equivalent Integer 2 is rejected and falls
back to +00:00. Rational(49710, 1) is 4_294_944_000 seconds, over
INT_MAX, so the (int) narrowing turned a large positive offset into a
negative one.

Move the check below the if/else so it covers both arms. That also
bounds n before the narrowing. Rational(1, 1) is exactly
DAY_IN_SECONDS and the guard is inclusive, so in-range values are
unaffected.

ruby/date@7524d7c41f
Currently dates are allocated in a 40B slot plus a 32B (simple)
or 48B (complex) external struct.

Once embedded they entirely fit into a 80B slot.

ruby/date@e8a1442c60
Windows carried a second, much weaker scheduler: a single Win32 mutex as
the GVL, vm->clock for preemption, its own VM barrier over
vm->ractor.sync.barrier_*, its own Ractor wait/wakeup on a per-Ractor
condvar, no ready queue and no time slice. Keeping two made the rest of
the interpreter branch on which one was compiled in, and left Ractors on
Windows without real scheduling.

Move the scheduler out of thread_pthread.c into thread_sched.c and let
both platforms use it. thread.c now includes thread_sched.c, which
declares the scheduler <-> platform contract, includes THREAD_IMPL_SRC,
and then builds the scheduler on the primitives that file provides.
thread_pthread.c keeps only those primitives: synchronization, thread
local storage, native thread creation and stacks, the communication pipe,
the timer thread backend, the fork lock and the event hooks.

The data structures the scheduler works on move to a new thread_sched.h,
included from both platform headers, so struct rb_thread_sched,
struct rb_native_thread and struct rb_thread_sched_item are now shared.

thread_pthread_mn.c becomes thread_sched_mn.c: it is the M:N scheduler,
not a pthread detail. Most of it -- the coroutine threads, the native
thread stack pool, the timer wheel and the fd -> waiters map -- is
platform independent; only the readiness backend is not, and that section
is now marked as the seam where an epoll/kqueue split (or an IOCP backend,
which is what Windows would need for M:N) would go.

What Windows had to add is small: native_thread_interrupt(),
native_thread_default_max_cpu(), timer_thread_polling(),
timer_thread_wakeup_force(), RB_NATIVE_COND_MONOTONIC_P() and
RB_NATIVE_MUTEX_TRYLOCK_DETECTS_SELF() -- the last because a
CRITICAL_SECTION is recursive, so trylock cannot back a "somebody holds
this" assertion. It sets USE_MN_THREADS to 0 and supplies the stubs
thread_sched_mn.c provides elsewhere, so every thread there is dedicated,
as it already was.

With one scheduler the platform branches go away: all 16 uses of
RUBY_THREAD_PTHREAD_H / RUBY_THREAD_WIN32_H are removed from vm_core.h,
ractor.c, ractor_core.h, ractor_sync.c, vm_sync.c, vm.c and thread.c.
ractor_check_blocking() went with them -- it only ever fed the win32
scheduler's vm->ractor.blocking_cnt -- and so did USE_VM_CLOCK, now that
the common time slice drives preemption on Windows too.

Verified on both platforms. Linux: 11 rounds of make test-all (36236
tests) and btest (2066 tests) with no failures, plus 474 runs of a
scheduler and Ractor stress soak. Windows: no test fails that does not
also fail on the same tree without this change, btest passes, and two
40-minute soaks of 438 and 460 runs are clean. Ractors now run in
parallel there -- 3.6x on four Ractors, where before they could not.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@pull pull Bot locked and limited conversation to collaborators Aug 29, 2026
@pull pull Bot added the ⤵️ pull label Aug 29, 2026
@pull
pull Bot merged commit 90e729c into turkdevops:master Aug 29, 2026
1 of 4 checks passed
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.

Projects

None yet

Development

Successfully merging this pull request may close these issues.

5 participants