atomic-ruby 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b52931f98d46947d0d2f4dccffbe51e771c619d61b54457a223162be41624353
-  data.tar.gz: 3c91a27d99c3eb4d2a04f668bc5ebbc19c1c60b6a9fc688812df96c20bed37a4
+  metadata.gz: 4a9ae1ba9062331be3f6a5d74f170dbf88eb2ce6b142f3ef5077194ddeb1295e
+  data.tar.gz: 652fbf6d04d6efa3d57fc37643f85241e685950320d343e2341c155b0539bf93
 SHA512:
-  metadata.gz: b3f6d04175439390f6b9f29d91bf3cfad5b95018f7363e3cb341c7512857008e285d3a462363108cb54e613ed898153e157d7c41b1e113d92c38053a52e5d5be
-  data.tar.gz: aadb6f2b22fa068d8599b1e0aea30bc6e52d4b97198c4e4078e465d172f168b8548c9ab2f4bd174298aa2f5d02cd421c868a896c4b0d53689706edeb2414ff35
+  metadata.gz: 686a5aaeef7250102c57a7b5b9b2dbe5cdbe45105428a98217545d6c3b1183ef79696f64b5a7aa1135a0f260bdcb8c50b53b4455dc60785977687d62b8b3c47a
+  data.tar.gz: 2141ed20f4baf5e2f8cf175c69b8003bf62413e1e312b5b8bf402ea762d409bcbfc72bfc14955d6aa4319ee719c6d28880055e954d2bb69278f9154d71b5a970

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.11.1] - 2026-05-17
+
+- Replace `Thread.pass` busy-wait with `sleep` in idle `AtomicThreadPool` workers
+
+## [0.11.0] - 2026-05-10
+
+- Use `warn` in `AtomicThreadPool` error output
+- Add `on_error:` to `AtomicThreadPool`
+- Remove redundant `Thread.pass` spin in `AtomicThreadPool#shutdown`
+- Fix O(n) performance issue in `AtomicThreadPool` queue by using two-stack linked list
+
 ## [0.10.0] - 2025-11-09
 
 - Add `AtomicThreadPool#active_count`

data/README.md

@@ -1,7 +1,7 @@
 # AtomicRuby
 
 ![Version](https://img.shields.io/gem/v/atomic-ruby)
-![Build](https://img.shields.io/github/actions/workflow/status/joshuay03/atomic-ruby/.github/workflows/main.yml?branch=main)
+![Build](https://badge.buildkite.com/42198db99cf0eb852d54a6f125d99e68a5c0cd2e1d63026913.svg)
 
 Atomic ([CAS](https://en.wikipedia.org/wiki/Compare-and-swap)) primitives for Ruby.
 
@@ -210,9 +210,9 @@ puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 ```
 > bundle exec rake compile && bundle exec ruby examples/atom_benchmark.rb
 
-ruby version:            ruby 4.0.0dev (2025-11-08T15:08:09Z master 75d25a42e6) +YJIT +PRISM [arm64-darwin25]
-concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.10.0
+ruby version:            ruby 4.0.3 (2026-04-21 revision 85ddef263a) +YJIT +PRISM [arm64-darwin23]
+concurrent-ruby version: 1.3.6
+atomic-ruby version:     0.11.0
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -220,9 +220,9 @@ Concurrent Ruby Atomic Bank Account Balance: 975
 Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           5.112382 seconds
-Concurrent Ruby Atomic Bank Account: 5.113139 seconds
-Atomic Ruby Atomic Bank Account:     5.101891 seconds
+Synchronized Bank Account:           5.106931 seconds
+Concurrent Ruby Atomic Bank Account: 5.106199 seconds
+Atomic Ruby Atomic Bank Account:     5.101662 seconds
 ```
 
 </details>
@@ -301,29 +301,29 @@ end
 ```
 > bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
 
-ruby version:            ruby 4.0.0dev (2025-11-08T15:08:09Z master 75d25a42e6) +YJIT +PRISM [arm64-darwin25]
-concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.10.0
+ruby version:            ruby 4.0.3 (2026-04-21 revision 85ddef263a) +YJIT +PRISM [arm64-darwin23]
+concurrent-ruby version: 1.3.6
+atomic-ruby version:     0.11.0
 
 Warming up --------------------------------------
 Synchronized Boolean Toggle
-                       120.000 i/100ms
+                       135.000 i/100ms
 Concurrent Ruby Atomic Boolean Toggle
-                        94.000 i/100ms
+                       117.000 i/100ms
 Atomic Ruby Atomic Boolean Toggle
-                       100.000 i/100ms
+                       101.000 i/100ms
 Calculating -------------------------------------
 Synchronized Boolean Toggle
-                          1.188k (± 8.9%) i/s  (841.70 μs/i) -      5.880k in   5.002927s
+                          1.414k (± 1.4%) i/s  (707.15 μs/i) -      7.155k in   5.060692s
 Concurrent Ruby Atomic Boolean Toggle
-                        889.224 (±11.8%) i/s    (1.12 ms/i) -      4.418k in   5.073535s
+                          1.149k (± 2.9%) i/s  (870.53 μs/i) -      5.850k in   5.097019s
 Atomic Ruby Atomic Boolean Toggle
-                        999.426 (± 4.3%) i/s    (1.00 ms/i) -      5.000k in   5.012997s
+                          1.046k (± 2.1%) i/s  (955.57 μs/i) -      5.252k in   5.021118s
 
 Comparison:
-Synchronized Boolean Toggle:               1188.1 i/s
-Atomic Ruby Atomic Boolean Toggle:          999.4 i/s - 1.19x  slower
-Concurrent Ruby Atomic Boolean Toggle:      889.2 i/s - 1.34x  slower
+Synchronized Boolean Toggle:               1414.1 i/s
+Concurrent Ruby Atomic Boolean Toggle:     1148.7 i/s - 1.23x  slower
+Atomic Ruby Atomic Boolean Toggle:         1046.5 i/s - 1.35x  slower
 ```
 
 </details>
@@ -379,13 +379,13 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 ```
 > bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
 
-ruby version:            ruby 4.0.0dev (2025-11-08T15:08:09Z master 75d25a42e6) +YJIT +PRISM [arm64-darwin25]
-concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.10.0
+ruby version:            ruby 4.0.4 (2026-05-12 revision b89eb1bcbf) +YJIT +PRISM [arm64-darwin23]
+concurrent-ruby version: 1.3.6
+atomic-ruby version:     0.11.1
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.56943 seconds
-Atomic Ruby Atomic Thread Pool: 5.252876 seconds
+Concurrent Ruby Thread Pool:    5.869825 seconds
+Atomic Ruby Atomic Thread Pool: 5.387304 seconds
 ```
 
 </details>

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -10,6 +10,11 @@ module AtomicRuby
   # work items from an atomic queue. The pool uses compare-and-swap operations
   # for thread-safe work enqueueing and state management.
   #
+  # The queue is implemented as a two-stack structure (in/out) backed by
+  # immutable frozen linked-list nodes. Enqueueing prepends to the `in` stack
+  # in O(1); dequeueing pops from the `out` stack in O(1), reversing `in` into
+  # `out` only when `out` is exhausted (amortized O(1) per item).
+  #
   # @example Basic usage
   #   pool = AtomicThreadPool.new(size: 4)
   #   pool << proc { puts "Hello from worker thread!" }
@@ -52,9 +57,13 @@ module AtomicRuby
     #
     # @param size [Integer] The number of worker threads to create (must be positive)
     # @param name [String, nil] Optional name for the thread pool (used in thread names)
+    # @param on_error [Proc, nil] Optional error handler called with the exception when
+    #   a work item raises. Receives the exception as its argument. When nil, errors
+    #   are printed to stderr
     #
     # @raise [ArgumentError] if size is not a positive integer
     # @raise [ArgumentError] if name is provided but not a string
+    # @raise [ArgumentError] if on_error is provided but not a Proc
     #
     # @example Create a basic pool
     #   pool = AtomicThreadPool.new(size: 4)
@@ -62,15 +71,21 @@ module AtomicRuby
     # @example Create a named pool
     #   pool = AtomicThreadPool.new(size: 2, name: "Database Workers")
     #
-    # @rbs (size: Integer, ?name: String?) -> void
-    def initialize(size:, name: nil)
+    # @example Create a pool with a custom error handler
+    #   errors = []
+    #   pool = AtomicThreadPool.new(size: 2, on_error: ->(err) { errors << err })
+    #
+    # @rbs (size: Integer, ?name: String?, ?on_error: Proc?) -> void
+    def initialize(size:, name: nil, on_error: nil)
       raise ArgumentError, "size must be a positive Integer" unless size.is_a?(Integer) && size > 0
       raise ArgumentError, "name must be a String" unless name.nil? || name.is_a?(String)
+      raise ArgumentError, "on_error must be a Proc" unless on_error.nil? || on_error.is_a?(Proc)
 
       @size = size
       @name = name
+      @on_error = on_error
 
-      @state = Atom.new(queue: [], shutdown: false)
+      @state = Atom.new(in: nil, out: nil, count: 0, shutdown: false)
       @started_thread_count = Atom.new(0)
       @active_thread_count = Atom.new(0)
       @threads = []
@@ -83,6 +98,7 @@ module AtomicRuby
     # The work item must respond to #call (typically a Proc or lambda).
     # Work items are executed in FIFO order by available worker threads.
     # If all workers are busy, the work is queued atomically.
+    # Enqueueing is O(1) regardless of current queue depth.
     #
     # @param work [#call] A callable object to be executed by a worker thread
     #
@@ -105,7 +121,8 @@ module AtomicRuby
         if current_state[:shutdown]
           current_state
         else
-          current_state.merge(queue: [*current_state[:queue], work])
+          new_node = { value: work, next: current_state[:in] }.freeze
+          current_state.merge(in: new_node, count: current_state[:count] + 1)
         end
       end
       raise EnqueuedWorkAfterShutdownError if state[:shutdown]
@@ -130,6 +147,7 @@ module AtomicRuby
       @threads.select(&:alive?).length
     end
     # Alias for {#length}.
+    #
     # @rbs () -> Integer
     alias size length
 
@@ -148,9 +166,10 @@ module AtomicRuby
     #
     # @rbs () -> Integer
     def queue_length
-      @state.value[:queue].length
+      @state.value[:count]
     end
     # Alias for {#queue_length}.
+    #
     # @rbs () -> Integer
     alias queue_size queue_length
 
@@ -215,8 +234,6 @@ module AtomicRuby
       end
       return if already_shutdown
 
-      Thread.pass until @state.value[:queue].empty?
-
       @threads.each(&:join)
     end
 
@@ -229,6 +246,7 @@ module AtomicRuby
     # for all threads to be fully started before returning.
     #
     # @return [void]
+    #
     # @rbs () -> void
     def start
       @size.times do |num|
@@ -244,14 +262,18 @@ module AtomicRuby
             should_shutdown = false
 
             @state.swap do |current_state|
-              if current_state[:shutdown] && current_state[:queue].empty?
+              if current_state[:shutdown] && current_state[:in].nil? && current_state[:out].nil?
                 should_shutdown = true
                 current_state
-              elsif current_state[:queue].empty?
-                current_state
+              elsif current_state[:out]
+                work = current_state[:out][:value]
+                current_state.merge(out: current_state[:out][:next], count: current_state[:count] - 1)
+              elsif current_state[:in]
+                new_out = reverse_list(current_state[:in])
+                work = new_out[:value]
+                current_state.merge(in: nil, out: new_out[:next], count: current_state[:count] - 1)
               else
-                work = current_state[:queue].first
-                current_state.merge(queue: current_state[:queue].drop(1))
+                current_state
               end
             end
 
@@ -262,14 +284,17 @@ module AtomicRuby
               begin
                 work.call
               rescue => err
-                puts "#{thread_name} rescued:"
-                puts "#{err.class}: #{err.message}"
-                puts err.backtrace.join("\n")
+                if @on_error
+                  @on_error.call(err)
+                else
+                  warn "#{thread_name} rescued:"
+                  warn err.full_message
+                end
               ensure
                 @active_thread_count.swap { |current_count| current_count - 1 }
               end
             else
-              Thread.pass
+              sleep 0.001
             end
           end
         end
@@ -278,6 +303,22 @@ module AtomicRuby
 
       Thread.pass until @started_thread_count.value == @size
     end
+
+    # Reverses a linked-list of frozen nodes, returning a new reversed list.
+    # Each node in the returned list is a new frozen hash.
+    #
+    # @param node [Hash, nil] Head of the list to reverse
+    # @return [Hash, nil] Head of the reversed list
+    #
+    # @rbs (Hash? node) -> Hash?
+    def reverse_list(node)
+      reversed = nil
+      while node
+        reversed = { value: node[:value], next: reversed }.freeze
+        node = node[:next]
+      end
+      reversed
+    end
   end
 end
 

data/lib/atomic-ruby/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Joshua Young
@@ -50,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.0.dev
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Atomic primitives for Ruby
 test_files: []