atomic-ruby 0.15.0 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a3341865540be4c1099997f8a21e35ac9d16427f7ba2cf6898f568aba7d2372
-  data.tar.gz: cf4afb42fb8b9680fce99518f5f627827dad0dca8e4725a7ed1b7c409bffd024
+  metadata.gz: 9c6210195ad6d82fbbb6a84f66bc8ce5faef54d50ed3227c3655ec43a996a9f6
+  data.tar.gz: eef94abbb8c8bfb1d9a54d36f8f8b0404d49210e6e6a109851fa014a6512aaa5
 SHA512:
-  metadata.gz: d1e237a56143ea169b19593dd7564d21e1f0dfe25bdb34ed9fc32a7960e52f1dcea353b1f594d754aa47361b42ec5b7a1bbd06962896c0a2eeaea4cbb4197cac
-  data.tar.gz: b6592601f77c203782a67024bb075a2f018f8ab89b1e931474009c206b7705b295156f8ff7d31fc5fa54c869d5bd013107768806435703979f747a705addcad9
+  metadata.gz: c89b7c62bda07206115c80c45088d1ae44e5c3aa84288932fae8fad51312d3490bf9510af559178fe6311e5d8ce4ecf87dca0da3420ced47a0113783e63a741d
+  data.tar.gz: a5c5ecee1ce3f96b5e2c525897c1c979fa3f99b7be6cd971d6882e2a43bf9b735f0de58bcf67dbf1179b0298a006a25ba45e910ee0c104f965c305e4af93f6be

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.15.2] - 2026-08-30
+
+- Avoid thread event hook overhead for fixed thread pools
+
+## [0.15.1] - 2026-08-30
+
+- Prevent OS scheduling delays from stopping adaptive thread pool growth
+
 ## [0.15.0] - 2026-08-29
 
 - Add adaptive scaling to `AtomicThreadPool` with `max_size:`

data/README.md

@@ -122,8 +122,8 @@ p results.sort      #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
 Pass `max_size` to let the pool temporarily add workers when queued work is
 held up by blocking operations. The pool measures time spent blocked outside
-the GVL and waiting for it, so it does not add more threads when GVL contention
-is the bottleneck. It returns to `size` when the queue drains.
+the GVL and CPU time used by its workers, so it does not add more threads when
+Ruby execution is the bottleneck. It returns to `size` when the queue drains.
 
 ```ruby
 pool = AtomicThreadPool.new(size: 4, max_size: 16)
@@ -268,7 +268,7 @@ puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 
 ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
 concurrent-ruby version: 1.3.6
-atomic-ruby version:     0.15.0
+atomic-ruby version:     0.15.2
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -359,7 +359,7 @@ end
 
 ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
 concurrent-ruby version: 1.3.6
-atomic-ruby version:     0.15.0
+atomic-ruby version:     0.15.2
 
 Warming up --------------------------------------
           Synchronized Boolean Toggle   157.000 i/100ms
@@ -442,7 +442,7 @@ end
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_condition_variable_benchmark.rb
 
 ruby version:        ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-atomic-ruby version: 0.15.0
+atomic-ruby version: 0.15.2
 
 Warming up --------------------------------------
       Synchronized Condition Variable Wait/Signal     3.977k i/100ms
@@ -517,7 +517,7 @@ end
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_queue_benchmark.rb
 
 ruby version:        ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-atomic-ruby version: 0.15.0
+atomic-ruby version: 0.15.2
 
 Warming up --------------------------------------
       Synchronized Queue Push/Pop   181.000 i/100ms
@@ -587,11 +587,11 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 
 ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
 concurrent-ruby version: 1.3.8
-atomic-ruby version:     0.15.0
+atomic-ruby version:     0.15.2
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.030964 seconds
-Atomic Ruby Atomic Thread Pool: 4.676908 seconds
+Concurrent Ruby Thread Pool:    5.081233 seconds
+Atomic Ruby Atomic Thread Pool: 4.737824 seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -535,17 +535,39 @@ typedef struct {
   _Atomic unsigned long long running_time;
   _Atomic unsigned long long waiting_time;
   _Atomic unsigned long long blocked_time;
+  _Atomic unsigned long long running_cpu_time;
+  bool active;
 } atomic_ruby_thread_pool_monitor_t;
 
 typedef struct {
   atomic_ruby_thread_pool_monitor_t *monitor;
   atomic_ruby_thread_pool_worker_phase_t phase;
   unsigned long long phase_started_at;
+  unsigned long long running_cpu_started_at;
 } atomic_ruby_thread_pool_worker_state_t;
 
 static rb_internal_thread_specific_key_t atomic_ruby_thread_pool_worker_key;
+static rb_nativethread_lock_t atomic_ruby_thread_pool_monitor_lock;
+static unsigned int atomic_ruby_thread_pool_monitor_count;
+static rb_internal_thread_event_hook_t *atomic_ruby_thread_pool_event_hook;
+
+static void atomic_ruby_thread_pool_event_callback(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *user_data);
+
+static void atomic_ruby_thread_pool_monitor_stop(atomic_ruby_thread_pool_monitor_t *monitor) {
+  rb_nativethread_lock_lock(&atomic_ruby_thread_pool_monitor_lock);
+  if (monitor->active) {
+    monitor->active = false;
+    atomic_ruby_thread_pool_monitor_count--;
+    if (atomic_ruby_thread_pool_monitor_count == 0) {
+      rb_internal_thread_remove_event_hook(atomic_ruby_thread_pool_event_hook);
+      atomic_ruby_thread_pool_event_hook = NULL;
+    }
+  }
+  rb_nativethread_lock_unlock(&atomic_ruby_thread_pool_monitor_lock);
+}
 
 static void atomic_ruby_thread_pool_monitor_free(void *ptr) {
+  atomic_ruby_thread_pool_monitor_stop(ptr);
   xfree(ptr);
 }
 
@@ -569,14 +591,27 @@ static unsigned long long atomic_ruby_monotonic_time(void) {
   return (unsigned long long)time.tv_sec * 1000000000ULL + (unsigned long long)time.tv_nsec;
 }
 
+static unsigned long long atomic_ruby_thread_cpu_time(void) {
+  struct timespec time;
+  if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time) == -1) return 0;
+
+  return (unsigned long long)time.tv_sec * 1000000000ULL + (unsigned long long)time.tv_nsec;
+}
+
 static void atomic_ruby_thread_pool_worker_leave_phase(atomic_ruby_thread_pool_worker_state_t *state, unsigned long long now) {
   unsigned long long elapsed = now != 0 && state->phase_started_at != 0 && now >= state->phase_started_at ? now - state->phase_started_at : 0;
 
   switch (state->phase) {
-    case ATOMIC_RUBY_THREAD_POOL_WORKER_RUNNING:
+    case ATOMIC_RUBY_THREAD_POOL_WORKER_RUNNING: {
+      unsigned long long cpu_now = atomic_ruby_thread_cpu_time();
+      unsigned long long cpu_elapsed = cpu_now != 0 && state->running_cpu_started_at != 0 && cpu_now >= state->running_cpu_started_at
+        ? cpu_now - state->running_cpu_started_at
+        : 0;
       atomic_fetch_sub_explicit(&state->monitor->running_count, 1, memory_order_relaxed);
       atomic_fetch_add_explicit(&state->monitor->running_time, elapsed, memory_order_relaxed);
+      atomic_fetch_add_explicit(&state->monitor->running_cpu_time, cpu_elapsed, memory_order_relaxed);
       break;
+    }
     case ATOMIC_RUBY_THREAD_POOL_WORKER_WAITING:
       atomic_fetch_sub_explicit(&state->monitor->waiting_count, 1, memory_order_relaxed);
       atomic_fetch_add_explicit(&state->monitor->waiting_time, elapsed, memory_order_relaxed);
@@ -597,6 +632,7 @@ static void atomic_ruby_thread_pool_worker_enter_phase(atomic_ruby_thread_pool_w
   switch (phase) {
     case ATOMIC_RUBY_THREAD_POOL_WORKER_RUNNING:
       atomic_fetch_add_explicit(&state->monitor->running_count, 1, memory_order_relaxed);
+      state->running_cpu_started_at = atomic_ruby_thread_cpu_time();
       break;
     case ATOMIC_RUBY_THREAD_POOL_WORKER_WAITING:
       atomic_fetch_add_explicit(&state->monitor->waiting_count, 1, memory_order_relaxed);
@@ -638,9 +674,38 @@ static VALUE rb_cThreadPoolMonitor_allocate(VALUE klass) {
   atomic_init(&monitor->running_time, 0);
   atomic_init(&monitor->waiting_time, 0);
   atomic_init(&monitor->blocked_time, 0);
+  atomic_init(&monitor->running_cpu_time, 0);
+  monitor->active = false;
   return obj;
 }
 
+static VALUE rb_cThreadPoolMonitor_start(VALUE self) {
+  atomic_ruby_thread_pool_monitor_t *monitor;
+  TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
+  rb_nativethread_lock_lock(&atomic_ruby_thread_pool_monitor_lock);
+  if (!monitor->active) {
+    monitor->active = true;
+    if (atomic_ruby_thread_pool_monitor_count++ == 0) {
+      atomic_ruby_thread_pool_event_hook = rb_internal_thread_add_event_hook(
+        atomic_ruby_thread_pool_event_callback,
+        RUBY_INTERNAL_THREAD_EVENT_READY |
+          RUBY_INTERNAL_THREAD_EVENT_RESUMED |
+          RUBY_INTERNAL_THREAD_EVENT_SUSPENDED,
+        NULL
+      );
+    }
+  }
+  rb_nativethread_lock_unlock(&atomic_ruby_thread_pool_monitor_lock);
+  return Qnil;
+}
+
+static VALUE rb_cThreadPoolMonitor_stop(VALUE self) {
+  atomic_ruby_thread_pool_monitor_t *monitor;
+  TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
+  atomic_ruby_thread_pool_monitor_stop(monitor);
+  return Qnil;
+}
+
 static VALUE rb_cThreadPoolMonitor_register_worker(VALUE self) {
   atomic_ruby_thread_pool_monitor_t *monitor;
   TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
@@ -650,6 +715,7 @@ static VALUE rb_cThreadPoolMonitor_register_worker(VALUE self) {
   state->monitor = monitor;
   state->phase = ATOMIC_RUBY_THREAD_POOL_WORKER_INACTIVE;
   state->phase_started_at = 0;
+  state->running_cpu_started_at = 0;
   rb_internal_thread_specific_set(thread, atomic_ruby_thread_pool_worker_key, state);
   return Qnil;
 }
@@ -683,13 +749,14 @@ static VALUE rb_cThreadPoolMonitor_snapshot(VALUE self) {
   TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
 
   return rb_ary_new_from_args(
-    6,
+    7,
     UINT2NUM(atomic_load_explicit(&monitor->running_count, memory_order_relaxed)),
     UINT2NUM(atomic_load_explicit(&monitor->waiting_count, memory_order_relaxed)),
     UINT2NUM(atomic_load_explicit(&monitor->blocked_count, memory_order_relaxed)),
     ULL2NUM(atomic_load_explicit(&monitor->running_time, memory_order_relaxed)),
     ULL2NUM(atomic_load_explicit(&monitor->waiting_time, memory_order_relaxed)),
-    ULL2NUM(atomic_load_explicit(&monitor->blocked_time, memory_order_relaxed))
+    ULL2NUM(atomic_load_explicit(&monitor->blocked_time, memory_order_relaxed)),
+    ULL2NUM(atomic_load_explicit(&monitor->running_cpu_time, memory_order_relaxed))
   );
 }
 
@@ -737,15 +804,13 @@ RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
   rb_define_private_method(rb_cAtomicConditionVariable, "_waiter_count", rb_cAtomicConditionVariable_waiter_count, 0);
 
   atomic_ruby_thread_pool_worker_key = rb_internal_thread_specific_key_create();
-  rb_internal_thread_add_event_hook(
-    atomic_ruby_thread_pool_event_callback,
-    RUBY_INTERNAL_THREAD_EVENT_READY |
-      RUBY_INTERNAL_THREAD_EVENT_RESUMED |
-      RUBY_INTERNAL_THREAD_EVENT_SUSPENDED,
-    NULL
-  );
+  rb_nativethread_lock_initialize(&atomic_ruby_thread_pool_monitor_lock);
+  atomic_ruby_thread_pool_monitor_count = 0;
+  atomic_ruby_thread_pool_event_hook = NULL;
   VALUE rb_cThreadPoolMonitor = rb_define_class_under(rb_mAtomicRuby, "ThreadPoolMonitor", rb_cObject);
   rb_define_alloc_func(rb_cThreadPoolMonitor, rb_cThreadPoolMonitor_allocate);
+  rb_define_method(rb_cThreadPoolMonitor, "start", rb_cThreadPoolMonitor_start, 0);
+  rb_define_method(rb_cThreadPoolMonitor, "stop", rb_cThreadPoolMonitor_stop, 0);
   rb_define_method(rb_cThreadPoolMonitor, "register_worker", rb_cThreadPoolMonitor_register_worker, 0);
   rb_define_method(rb_cThreadPoolMonitor, "unregister_worker", rb_cThreadPoolMonitor_unregister_worker, 0);
   rb_define_method(rb_cThreadPoolMonitor, "start_work", rb_cThreadPoolMonitor_start_work, 0);

data/ext/atomic_ruby/atomic_ruby.h

@@ -4,6 +4,7 @@
 #include "ruby.h"
 #include "ruby/atomic.h"
 #include "ruby/thread.h"
+#include "ruby/thread_native.h"
 #include "ruby/version.h"
 
 #include <stdatomic.h>

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -69,7 +69,8 @@ module AtomicRuby
     #
     # When `max_size` is greater than `size`, the pool adds temporary workers
     # if work remains queued while its active workers spend most of their time
-    # blocked outside the GVL, but not when they are waiting for the GVL.
+    # blocked outside the GVL, but not when Ruby execution is using the
+    # available CPU.
     # Temporary workers leave after the queue remains empty, returning the pool
     # to its baseline size. Omitting `max_size` creates a fixed-size pool.
     #
@@ -124,6 +125,7 @@ module AtomicRuby
         @autoscale_available = AtomicConditionVariable.new
         @trim_requested = AtomicBoolean.new(false)
         @thread_pool_monitor = ThreadPoolMonitor.new
+        @thread_pool_monitor.start
       end
 
       start
@@ -263,6 +265,7 @@ module AtomicRuby
       @work_available.broadcast
       @autoscaler&.join
       @threads.each(&:join)
+      @thread_pool_monitor&.stop
     end
 
     private
@@ -403,7 +406,7 @@ module AtomicRuby
             pressure_started_at = now
             phase_samples.fill(0)
           elsif now - pressure_started_at >= AUTOSCALE_WINDOW
-            if should_grow?(previous_snapshot, snapshot, phase_samples)
+            if should_grow?(previous_snapshot, snapshot, phase_samples, now - pressure_started_at)
               growth_samples += 1
               if growth_samples >= AUTOSCALE_GROWTH_SAMPLES
                 spawn_worker(temporary: true)
@@ -427,25 +430,28 @@ module AtomicRuby
     # Returns whether another worker is likely to improve throughput.
     #
     # Requiring workers to spend a majority of their time blocked outside the
-    # GVL recognizes blocking operations. The pool only grows when less than
-    # two percent of their time was spent waiting for the GVL.
+    # GVL recognizes blocking operations. The pool only grows while its workers
+    # use less than half of one CPU, avoiding extra threads when Ruby
+    # execution is the bottleneck without mistaking OS scheduling delays for
+    # GVL contention.
     #
     # @param previous_snapshot [Array<Integer>] previous GVL state snapshot
     # @param snapshot [Array<Integer>] current GVL state snapshot
     # @param phase_samples [Array<Integer>] sampled current GVL states
+    # @param elapsed_time [Float] seconds covered by the snapshots
     # @return [true, false]
     #
-    # @rbs (Array[Integer] previous_snapshot, Array[Integer] snapshot, Array[Integer] phase_samples) -> bool
-    def should_grow?(previous_snapshot, snapshot, phase_samples)
+    # @rbs (Array[Integer] previous_snapshot, Array[Integer] snapshot, Array[Integer] phase_samples, Float elapsed_time) -> bool
+    def should_grow?(previous_snapshot, snapshot, phase_samples, elapsed_time)
       @threads.select!(&:alive?)
       workers = @threads
       return false if workers.length >= @max_size
       return false if @active_thread_count.value < workers.length
 
-      _running_count, _waiting_count, _blocked_count, running_time, waiting_time, blocked_time = snapshot
-      running_time -= previous_snapshot[3]
-      waiting_time -= previous_snapshot[4]
-      blocked_time -= previous_snapshot[5]
+      running_time = snapshot[3] - previous_snapshot[3]
+      waiting_time = snapshot[4] - previous_snapshot[4]
+      blocked_time = snapshot[5] - previous_snapshot[5]
+      running_cpu_time = snapshot[6] - previous_snapshot[6]
       total_time = running_time + waiting_time + blocked_time
 
       minimum_measured_time = (AUTOSCALE_WINDOW * 1_000_000_000 * workers.length / 2).to_i
@@ -455,8 +461,8 @@ module AtomicRuby
       end
 
       total_time.positive? &&
-        waiting_time * 50 < total_time &&
-        blocked_time * 2 > total_time
+        blocked_time * 2 > total_time &&
+        running_cpu_time * 2 < elapsed_time * 1_000_000_000
     end
   end
 end

data/lib/atomic-ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicRuby
-  VERSION = "0.15.0"
+  VERSION = "0.15.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.15.2
 platform: ruby
 authors:
 - Joshua Young