atomic-ruby 0.15.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a3341865540be4c1099997f8a21e35ac9d16427f7ba2cf6898f568aba7d2372
-  data.tar.gz: cf4afb42fb8b9680fce99518f5f627827dad0dca8e4725a7ed1b7c409bffd024
+  metadata.gz: af7a35affcaa2790e6944ee01eb6af8f4d92b5c2479bb1995128742a562fd395
+  data.tar.gz: d3908277e6ef09a70f7d46a057a5db7f60c179885d980b4fbbf407bdade6b073
 SHA512:
-  metadata.gz: d1e237a56143ea169b19593dd7564d21e1f0dfe25bdb34ed9fc32a7960e52f1dcea353b1f594d754aa47361b42ec5b7a1bbd06962896c0a2eeaea4cbb4197cac
-  data.tar.gz: b6592601f77c203782a67024bb075a2f018f8ab89b1e931474009c206b7705b295156f8ff7d31fc5fa54c869d5bd013107768806435703979f747a705addcad9
+  metadata.gz: f5a3525b194636ddb439c0c8e9597e3ed1870a8c0165bc1582cb120a45c49b30a8cf6bd60f393a9e3e0c848abf760b181dce1b9b3026199ff8ffb2ba833dcc1a
+  data.tar.gz: e89a1f593774fc1722bfc8a9229385682e33a10df705ba78da3c67f904ab566c770b7aebdebc32069ed7f4dfc2781ad52165f08f10cf3fd4e4d723c41687e02f

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [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.1
 
 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.1
 
 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.1
 
 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.1
 
 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.1
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.030964 seconds
-Atomic Ruby Atomic Thread Pool: 4.676908 seconds
+Concurrent Ruby Thread Pool:    5.079561 seconds
+Atomic Ruby Atomic Thread Pool: 4.99168 seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -535,12 +535,14 @@ 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;
 } 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;
@@ -569,14 +571,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 +612,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,6 +654,7 @@ 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);
   return obj;
 }
 
@@ -650,6 +667,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 +701,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))
   );
 }
 

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.
     #
@@ -403,7 +404,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 +428,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 +459,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.1"
 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.1
 platform: ruby
 authors:
 - Joshua Young