atomic-ruby 0.15.2 → 0.15.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c6210195ad6d82fbbb6a84f66bc8ce5faef54d50ed3227c3655ec43a996a9f6
-  data.tar.gz: eef94abbb8c8bfb1d9a54d36f8f8b0404d49210e6e6a109851fa014a6512aaa5
+  metadata.gz: e7c0136cf37fe5133affc1f090fa517636f5bfda0f5f43564a4877eee15bae3f
+  data.tar.gz: 0ae3a3aadabcc2bb69621df62188800451289a46032fa57a49c1af9326bcc31e
 SHA512:
-  metadata.gz: c89b7c62bda07206115c80c45088d1ae44e5c3aa84288932fae8fad51312d3490bf9510af559178fe6311e5d8ce4ecf87dca0da3420ced47a0113783e63a741d
-  data.tar.gz: a5c5ecee1ce3f96b5e2c525897c1c979fa3f99b7be6cd971d6882e2a43bf9b735f0de58bcf67dbf1179b0298a006a25ba45e910ee0c104f965c305e4af93f6be
+  metadata.gz: 1786faa43a25379cbe68c9de2372c6168a62ab225436c45bbf5049791c39191e3ed75955ab2f5f6385069ddeb86640aa11ba431ce9f2ab54335005a61bd42092
+  data.tar.gz: 704c7e7224c9eec351aa0174f597c10c992f4e1594921b8ca91e9ad2df43a6b3eb2c260b9b25ab2d47f8fb0934afa9739ed5312fb00d5d7519d9283c6bf68170

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.15.4] - 2026-09-01
+
+- Keep temporary `AtomicThreadPool` workers alive for five seconds
+- Speed up `AtomicThreadPool` scaling for blocking work
+
+## [0.15.3] - 2026-08-31
+
+- Prevent enqueues from racing `AtomicThreadPool#shutdown`
+- Remove interrupted waiters from `AtomicConditionVariable`
+- Replace `Thread.pass` busy-wait with `sleep` in `AtomicCountDownLatch#wait`
+
 ## [0.15.2] - 2026-08-30
 
 - Avoid thread event hook overhead for fixed thread pools

data/README.md

@@ -267,8 +267,8 @@ puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atom_benchmark.rb
 
 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.2
+concurrent-ruby version: 1.3.8
+atomic-ruby version:     0.15.4
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -276,9 +276,9 @@ Concurrent Ruby Atomic Bank Account Balance: 975
 Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           5.117072 seconds
-Concurrent Ruby Atomic Bank Account: 5.128366 seconds
-Atomic Ruby Atomic Bank Account:     5.110595 seconds
+Synchronized Bank Account:           5.104959 seconds
+Concurrent Ruby Atomic Bank Account: 5.120305 seconds
+Atomic Ruby Atomic Bank Account:     5.102732 seconds
 ```
 
 </details>
@@ -358,22 +358,22 @@ end
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
 
 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.2
+concurrent-ruby version: 1.3.8
+atomic-ruby version:     0.15.4
 
 Warming up --------------------------------------
-          Synchronized Boolean Toggle   157.000 i/100ms
-Concurrent Ruby Atomic Boolean Toggle   134.000 i/100ms
-    Atomic Ruby Atomic Boolean Toggle   120.000 i/100ms
+          Synchronized Boolean Toggle   165.000 i/100ms
+Concurrent Ruby Atomic Boolean Toggle   132.000 i/100ms
+    Atomic Ruby Atomic Boolean Toggle   119.000 i/100ms
 Calculating -------------------------------------
-          Synchronized Boolean Toggle      1.629k (± 2.0%) i/s  (613.87 μs/i) -      8.164k in   5.011636s
-Concurrent Ruby Atomic Boolean Toggle      1.325k (± 2.0%) i/s  (754.96 μs/i) -      6.700k in   5.058203s
-    Atomic Ruby Atomic Boolean Toggle      1.190k (± 2.6%) i/s  (840.11 μs/i) -      6.000k in   5.040665s
+          Synchronized Boolean Toggle      1.647k (± 2.1%) i/s  (606.98 μs/i) -      8.250k in   5.007598s
+Concurrent Ruby Atomic Boolean Toggle      1.343k (± 1.9%) i/s  (744.55 μs/i) -      6.732k in   5.012307s
+    Atomic Ruby Atomic Boolean Toggle      1.207k (± 1.9%) i/s  (828.31 μs/i) -      6.069k in   5.027033s
 
 Comparison:
-          Synchronized Boolean Toggle:     1629.0 i/s
-Concurrent Ruby Atomic Boolean Toggle:     1324.6 i/s - 1.23x  slower
-    Atomic Ruby Atomic Boolean Toggle:     1190.3 i/s - 1.37x  slower
+          Synchronized Boolean Toggle:     1647.5 i/s
+Concurrent Ruby Atomic Boolean Toggle:     1343.1 i/s - 1.23x  slower
+    Atomic Ruby Atomic Boolean Toggle:     1207.3 i/s - 1.36x  slower
 ```
 
 </details>
@@ -442,18 +442,18 @@ 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.2
+atomic-ruby version: 0.15.4
 
 Warming up --------------------------------------
-      Synchronized Condition Variable Wait/Signal     3.977k i/100ms
-Atomic Ruby Atomic Condition Variable Wait/Signal     3.885k i/100ms
+      Synchronized Condition Variable Wait/Signal     4.062k i/100ms
+Atomic Ruby Atomic Condition Variable Wait/Signal     4.133k i/100ms
 Calculating -------------------------------------
-      Synchronized Condition Variable Wait/Signal     39.458k (± 4.2%) i/s   (25.34 μs/i) -    198.850k in   5.039596s
-Atomic Ruby Atomic Condition Variable Wait/Signal     39.046k (± 4.2%) i/s   (25.61 μs/i) -    198.135k in   5.074411s
+      Synchronized Condition Variable Wait/Signal     41.923k (± 3.5%) i/s   (23.85 μs/i) -    211.224k in   5.038330s
+Atomic Ruby Atomic Condition Variable Wait/Signal     40.666k (± 3.8%) i/s   (24.59 μs/i) -    206.650k in   5.081595s
 
 Comparison:
-      Synchronized Condition Variable Wait/Signal:    39457.5 i/s
-Atomic Ruby Atomic Condition Variable Wait/Signal:    39045.9 i/s - same-ish: difference falls within error
+      Synchronized Condition Variable Wait/Signal:    41923.4 i/s
+Atomic Ruby Atomic Condition Variable Wait/Signal:    40666.4 i/s - same-ish: difference falls within error
 ```
 
 </details>
@@ -517,18 +517,18 @@ 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.2
+atomic-ruby version: 0.15.4
 
 Warming up --------------------------------------
-      Synchronized Queue Push/Pop   181.000 i/100ms
-Atomic Ruby Atomic Queue Push/Pop   132.000 i/100ms
+      Synchronized Queue Push/Pop   184.000 i/100ms
+Atomic Ruby Atomic Queue Push/Pop   149.000 i/100ms
 Calculating -------------------------------------
-      Synchronized Queue Push/Pop      1.845k (± 2.1%) i/s  (541.91 μs/i) -      9.231k in   5.002394s
-Atomic Ruby Atomic Queue Push/Pop      1.431k (± 6.8%) i/s  (698.64 μs/i) -      7.260k in   5.072143s
+      Synchronized Queue Push/Pop      1.819k (± 2.0%) i/s  (549.73 μs/i) -      9.200k in   5.057550s
+Atomic Ruby Atomic Queue Push/Pop      1.493k (± 1.9%) i/s  (669.87 μs/i) -      7.599k in   5.090319s
 
 Comparison:
-      Synchronized Queue Push/Pop:     1845.3 i/s
-Atomic Ruby Atomic Queue Push/Pop:     1431.3 i/s - 1.29x  slower
+      Synchronized Queue Push/Pop:     1819.1 i/s
+Atomic Ruby Atomic Queue Push/Pop:     1492.8 i/s - 1.22x  slower
 
 ```
 
@@ -547,7 +547,7 @@ require "benchmark"
 require "concurrent-ruby"
 require_relative "../lib/atomic-ruby"
 
-results = []
+fixed_results = []
 
 2.times do |idx|
   result = Benchmark.measure do
@@ -569,6 +569,101 @@ results = []
     pool.wait_for_termination if idx == 0
   end
 
+  fixed_results << result
+end
+
+adaptive_results = []
+
+2.times do |idx|
+  result = Benchmark.measure do
+    pool = case idx
+    when 0 then Concurrent.new_io_executor
+    when 1 then AtomicThreadPool.new(size: 1, max_size: Float::INFINITY)
+    end
+    latch = case idx
+    when 0 then Concurrent::CountDownLatch.new(100)
+    when 1 then AtomicCountDownLatch.new(100)
+    end
+
+    100.times do
+      pool << proc do
+        sleep(0.2)
+        latch.count_down
+      end
+    end
+
+    latch.wait
+    pool.shutdown
+    # concurrent-ruby's #shutdown does not wait for threads to terminate
+    pool.wait_for_termination if idx == 0
+  end
+
+  adaptive_results << result
+end
+
+puts "\n"
+puts "ruby version:            #{RUBY_DESCRIPTION}"
+puts "concurrent-ruby version: #{Concurrent::VERSION}"
+puts "atomic-ruby version:     #{AtomicRuby::VERSION}"
+puts "\n"
+puts "Fixed Pool Results:"
+puts "Concurrent Ruby Fixed Thread Pool: #{fixed_results[0].real.round(6)} seconds"
+puts "Atomic Ruby Fixed Thread Pool:     #{fixed_results[1].real.round(6)} seconds"
+puts "\n"
+puts "Adaptive Pool Results:"
+puts "Concurrent Ruby IO Thread Pool:   #{adaptive_results[0].real.round(6)} seconds"
+puts "Atomic Ruby Adaptive Thread Pool: #{adaptive_results[1].real.round(6)} seconds"
+```
+
+```
+> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
+
+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.4
+
+Fixed Pool Results:
+Concurrent Ruby Fixed Thread Pool: 5.069464 seconds
+Atomic Ruby Fixed Thread Pool:     4.791382 seconds
+
+Adaptive Pool Results:
+Concurrent Ruby IO Thread Pool:   0.22309 seconds
+Atomic Ruby Adaptive Thread Pool: 0.61561 seconds
+```
+
+</details>
+
+<details>
+
+<summary>AtomicCountDownLatch</summary>
+
+<br>
+
+```ruby
+# frozen_string_literal: true
+
+require "benchmark"
+require "concurrent-ruby"
+require_relative "../lib/atomic-ruby"
+
+results = []
+
+2.times do |idx|
+  result = Benchmark.measure do
+    latch = case idx
+    when 0 then Concurrent::CountDownLatch.new(1)
+    when 1 then AtomicCountDownLatch.new(1)
+    end
+
+    thread = Thread.new do
+      sleep(2)
+      latch.count_down
+    end
+
+    latch.wait
+    thread.join
+  end
+
   results << result
 end
 
@@ -578,20 +673,20 @@ puts "concurrent-ruby version: #{Concurrent::VERSION}"
 puts "atomic-ruby version:     #{AtomicRuby::VERSION}"
 puts "\n"
 puts "Benchmark Results:"
-puts "Concurrent Ruby Thread Pool:    #{results[0].real.round(6)} seconds"
-puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
+puts "Concurrent Ruby Count Down Latch:    #{results[0].total.round(6)} CPU seconds, #{results[0].real.round(6)} elapsed seconds"
+puts "Atomic Ruby Atomic Count Down Latch: #{results[1].total.round(6)} CPU seconds, #{results[1].real.round(6)} elapsed seconds"
 ```
 
 ```
-> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
+> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_count_down_latch_benchmark.rb
 
 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.2
+atomic-ruby version:     0.15.4
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.081233 seconds
-Atomic Ruby Atomic Thread Pool: 4.737824 seconds
+Concurrent Ruby Count Down Latch:    0.000511 CPU seconds, 2.001465 elapsed seconds
+Atomic Ruby Atomic Count Down Latch: 0.023529 CPU seconds, 2.00364 elapsed seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -172,6 +172,7 @@ typedef struct {
   volatile VALUE head;
   volatile VALUE tail;
   volatile rb_atomic_t count;
+  bool closed;
 } atomic_ruby_queue_t;
 
 static void atomic_ruby_queue_mark(void *ptr) {
@@ -211,6 +212,7 @@ static VALUE rb_cAtomicQueue_allocate(VALUE klass) {
   RB_OBJ_WRITE(obj, &atomic_ruby_queue->head, Qnil);
   RB_OBJ_WRITE(obj, &atomic_ruby_queue->tail, Qnil);
   atomic_ruby_queue->count = 0;
+  atomic_ruby_queue->closed = false;
   return obj;
 }
 
@@ -228,6 +230,7 @@ static VALUE rb_cAtomicQueue_initialize(VALUE self) {
 static VALUE rb_cAtomicQueue_push(VALUE self, VALUE value) {
   atomic_ruby_queue_t *atomic_ruby_queue;
   TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  if (atomic_ruby_queue->closed) return Qfalse;
 
   VALUE new_node = atomic_ruby_queue_node_new(value, Qnil);
 
@@ -259,6 +262,13 @@ static VALUE rb_cAtomicQueue_push(VALUE self, VALUE value) {
   return self;
 }
 
+static VALUE rb_cAtomicQueue_close(VALUE self) {
+  atomic_ruby_queue_t *atomic_ruby_queue;
+  TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  atomic_ruby_queue->closed = true;
+  return Qnil;
+}
+
 static VALUE rb_cAtomicQueue_pop(VALUE self) {
   atomic_ruby_queue_t *atomic_ruby_queue;
   TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
@@ -787,6 +797,7 @@ RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
   rb_define_alloc_func(rb_cAtomicQueue, rb_cAtomicQueue_allocate);
   rb_define_private_method(rb_cAtomicQueue, "_initialize", rb_cAtomicQueue_initialize, 0);
   rb_define_private_method(rb_cAtomicQueue, "_push", rb_cAtomicQueue_push, 1);
+  rb_define_private_method(rb_cAtomicQueue, "_close", rb_cAtomicQueue_close, 0);
   rb_define_private_method(rb_cAtomicQueue, "_pop", rb_cAtomicQueue_pop, 0);
   rb_define_private_method(rb_cAtomicQueue, "_size", rb_cAtomicQueue_size, 0);
   rb_define_private_method(rb_cAtomicQueue, "_empty_p", rb_cAtomicQueue_empty_p, 0);

data/lib/atomic-ruby/atomic_condition_variable.rb

@@ -8,19 +8,10 @@ module AtomicRuby
   #
   # AtomicConditionVariable lets one or more threads park until another
   # thread signals them, without the paired `Mutex` that Ruby's
-  # `ConditionVariable` requires. The set of parked threads is tracked
-  # in a native doubly-linked list, so registering a waiter, removing a
-  # waiter, and shifting the head off for a signal are all O(1) and
-  # allocation-light. Parking still uses `Thread.stop` and
-  # `Thread#wakeup`, which are the standard kernel-level primitives Ruby
-  # exposes for sleeping a thread.
+  # `ConditionVariable` requires.
   #
-  # The lost-wakeup race in a naive `check-then-park` consumer is avoided
-  # by the {#wait} contract: a waiter registers itself before re-evaluating
-  # the predicate, so any signal that fires after the producer makes the
-  # predicate true is guaranteed to see the waiter and wake it. Ruby also
-  # remembers pending wakeups across `Thread.stop`, so a wakeup that
-  # arrives between the predicate check and the actual park is not lost.
+  # Waiters supply a predicate that is checked again after registration,
+  # preventing signals sent after a relevant state change from being lost.
   #
   # @example Basic usage
   #   condvar = AtomicConditionVariable.new
@@ -72,10 +63,6 @@ module AtomicRuby
 
     # Wakes one parked waiter, or no-ops if none are parked.
     #
-    # If a waiter has registered itself but is not yet inside `Thread.stop`,
-    # Ruby remembers the wakeup and the next `Thread.stop` returns
-    # immediately.
-    #
     # @return [true, false] true if a waiter was signalled, false otherwise
     #
     # @example
@@ -93,8 +80,6 @@ module AtomicRuby
 
     # Wakes every parked waiter.
     #
-    # Each woken thread observes the wake the same way as with {#signal}.
-    #
     # @return [Integer] The number of waiters signalled
     #
     # @example
@@ -111,12 +96,10 @@ module AtomicRuby
     # Blocks until the given block returns a truthy value, then returns that
     # value.
     #
-    # The block is evaluated optimistically first. If it returns truthy on
-    # that pass, no waiter is registered and the call returns immediately.
-    # Otherwise the calling thread registers itself, re-evaluates the
-    # block, and parks via `Thread.stop` until a {#signal} or {#broadcast}
-    # wakes it. The block may run more than once and may run concurrently
-    # with a signalling thread.
+    # The block may run more than once and may run concurrently with a
+    # signalling thread. Rechecking it after registration prevents lost
+    # wakeups. Interrupted waits are unregistered before the exception is
+    # propagated.
     #
     # @yieldreturn [untyped] Truthy to wake, falsy to keep waiting
     # @return [untyped] The first truthy value returned by the block
@@ -140,15 +123,19 @@ module AtomicRuby
 
       self_thread = Thread.current
       loop do
-        waiter = _add_waiter(self_thread)
-        result = yield
-        if result
-          _remove_waiter(waiter)
-          return result
-        end
+        Thread.handle_interrupt(Exception => :never) do
+          waiter = _add_waiter(self_thread)
+          begin
+            Thread.handle_interrupt(Exception => :immediate) do
+              result = yield
+              return result if result
 
-        Thread.stop
-        _remove_waiter(waiter)
+              Thread.stop
+            end
+          ensure
+            _remove_waiter(waiter)
+          end
+        end
       end
     end
   end

data/lib/atomic-ruby/atomic_count_down_latch.rb

@@ -133,10 +133,6 @@ module AtomicRuby
 
     # Blocks the current thread until the count reaches zero.
     #
-    # This method will block the calling thread until other threads have
-    # called {#count_down} enough times to reduce the count to zero.
-    # The method uses busy-waiting (Thread.pass) to check the count.
-    #
     # @return [void]
     #
     # @example Simple wait
@@ -166,7 +162,7 @@ module AtomicRuby
     #
     # @rbs () -> void
     def wait
-      Thread.pass while @count.value > 0
+      sleep 0.001 while @count.value > 0
     end
   end
 end

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -51,11 +51,10 @@ module AtomicRuby
   # @note This class is NOT Ractor-safe as it contains mutable thread state
   #   that cannot be safely shared across ractors.
   class AtomicThreadPool
-    AUTOSCALE_GROWTH_SAMPLES = 3
-    AUTOSCALE_IDLE_TIME = 1
+    AUTOSCALE_IDLE_TIME = 5
     AUTOSCALE_INTERVAL = 0.01
     AUTOSCALE_WINDOW = 0.05
-    private_constant :AUTOSCALE_GROWTH_SAMPLES, :AUTOSCALE_IDLE_TIME, :AUTOSCALE_INTERVAL, :AUTOSCALE_WINDOW
+    private_constant :AUTOSCALE_IDLE_TIME, :AUTOSCALE_INTERVAL, :AUTOSCALE_WINDOW
 
     class Error < StandardError; end
 
@@ -71,7 +70,7 @@ module AtomicRuby
     # if work remains queued while its active workers spend most of their time
     # 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
+    # Temporary workers remain available between bursts before the pool returns
     # to its baseline size. Omitting `max_size` creates a fixed-size pool.
     #
     # @param size [Integer] The baseline number of worker threads (must be positive)
@@ -155,12 +154,13 @@ module AtomicRuby
     #
     # @rbs (Proc work) -> void
     def <<(work)
-      raise EnqueuedWorkAfterShutdownError if @shutdown.true?
+      Thread.handle_interrupt(Exception => :never) do
+        @trim_requested&.make_false
+        raise EnqueuedWorkAfterShutdownError unless @queue.push(work)
 
-      @trim_requested&.make_false
-      @queue.push(work)
-      @work_available.signal
-      @autoscale_available&.signal
+        @work_available.signal
+        @autoscale_available&.signal
+      end
     end
 
     # Returns the number of currently alive worker threads.
@@ -242,6 +242,9 @@ module AtomicRuby
     # 2. Waits for all currently queued work to complete
     # 3. Waits for all worker threads to terminate
     #
+    # Enqueues accepted before shutdown are processed before the workers
+    # terminate.
+    #
     # After shutdown, all worker threads will be terminated and the pool
     # cannot be restarted. Attempting to enqueue work after shutdown
     # will raise an exception.
@@ -258,11 +261,12 @@ module AtomicRuby
     #
     # @rbs () -> void
     def shutdown
-      return if @shutdown.true?
-
-      @shutdown.make_true
-      @autoscale_available&.broadcast
-      @work_available.broadcast
+      Thread.handle_interrupt(Exception => :never) do
+        @queue.send(:_close)
+        @shutdown.make_true
+        @autoscale_available&.broadcast
+        @work_available.broadcast
+      end
       @autoscaler&.join
       @threads.each(&:join)
       @thread_pool_monitor&.stop
@@ -374,7 +378,6 @@ module AtomicRuby
       previous_snapshot = @thread_pool_monitor.snapshot
       pressure_started_at = nil
       idle_started_at = nil
-      growth_samples = 0
       phase_samples = [0, 0, 0]
 
       loop do
@@ -390,7 +393,6 @@ module AtomicRuby
           pressure_started_at = nil
           previous_snapshot = snapshot
           idle_started_at ||= now
-          growth_samples = 0
           phase_samples.fill(0)
 
           if now - idle_started_at >= AUTOSCALE_IDLE_TIME
@@ -407,13 +409,9 @@ module AtomicRuby
             phase_samples.fill(0)
           elsif now - pressure_started_at >= AUTOSCALE_WINDOW
             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)
-                growth_samples = 0
-              end
-            else
-              growth_samples = 0
+              worker_count = @threads.length
+              workers_to_add = [worker_count, @queue.size, @max_size - worker_count].min
+              workers_to_add.times { spawn_worker(temporary: true) }
             end
             previous_snapshot = snapshot
             pressure_started_at = now

data/lib/atomic-ruby/version.rb

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

metadata

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