atomic-ruby 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afd2aac6df8cbc6d73dc79f925ab4f1d17288c3b1a146e2a52fea1ea1c343a30
-  data.tar.gz: 77ed011cf73f079f07b09eb7d9f74d7db2da564bee8aa0e878d61241582b7fe6
+  metadata.gz: fc55b63bd9de85a395232f89184e97aa80e08e8e082981f2b17012fd1b56b5c0
+  data.tar.gz: 25cffc0cbb45f1d145d3b99380decc91a39ef82415833781bed40ba2583286a8
 SHA512:
-  metadata.gz: 5053ea8e8d7158bf72fadf6d63b49a63a56550918df555237e1af42189bb2fddccc386d7ab485bbb1dbbb49cfe4633b827ff5c96ac94ab8e08f04da8c074e8b0
-  data.tar.gz: 3eea3c132563bab777877c5e1785fe4ef4e11ae089c06aa4acd46d0db6465309de68ec728fdead66de0c51ca71ac8ce46d58dfc034407115582bb97f3010ecaa
+  metadata.gz: 1420ff50010eec4386301619d4866c1e96aec8f91936e464b2ed56276607fd6dfaf88d0cc5582ee255c06a15928a2b1390f1a2e18ceb443ee0d74fa190a36ee9
+  data.tar.gz: 80ceb6dd2348ea38bbd8b63223fc7ab27a6d36026d0e028fc0aef60dd9f92885b29adb5fa997b551b54c9aadbaca24fdd71a4f7b1d94337f3a3887955c108a5b

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.3.1] - 2025-06-08
+
+- Fix current queue being mutated in `AtomicThreadPool#<<`
+
+## [0.3.0] - 2025-06-08
+
+- Add `AtomicBoolean`
+
 ## [0.2.0] - 2025-06-07
 
 - Add `AtomicThreadPool`

data/README.md

@@ -27,11 +27,26 @@ gem install atomic-ruby
 require "atomic-ruby"
 
 atom = AtomicRuby::Atom.new(0)
-p atom.value # => 0
+p atom.value #=> 0
 atom.swap { |current_value| current_value + 1 }
-p atom.value # => 1
+p atom.value #=> 1
 atom.swap { |current_value| current_value + 1 }
-p atom.value # => 2
+p atom.value #=> 2
+```
+
+`AtomicRuby::AtomicBoolean`:
+
+```ruby
+require "atomic-ruby"
+
+atom = AtomicRuby::AtomicBoolean.new(false)
+p atom.value  #=> false
+p atom.false? #=> true
+p atom.true?  #=> false
+atom.make_true
+p atom.true?  #=> true
+atom.toggle
+p atom.false? #=> true
 ```
 
 `AtomicRuby::AtomicThreadPool`:
@@ -78,18 +93,22 @@ require "benchmark"
 require "concurrent-ruby"
 require_relative "../lib/atomic-ruby"
 
-class AtomicRubyAtomicBankAccount
+class SynchronizedBankAccount
   def initialize(balance)
-    @balance = AtomicRuby::Atom.new(balance)
+    @balance = balance
+    @mutex = Mutex.new
   end
 
   def balance
-    @balance.value
+    @mutex.synchronize do
+      @balance
+    end
   end
 
   def deposit(amount)
-    sleep(rand(0.1..0.2))
-    @balance.swap { |current| current + amount }
+    @mutex.synchronize do
+      @balance += amount
+    end
   end
 end
 
@@ -103,51 +122,51 @@ class ConcurrentRubyAtomicBankAccount
   end
 
   def deposit(amount)
-    sleep(rand(0.1..0.2))
-    @balance.swap { |current| current + amount }
+    @balance.swap { |current_balance| current_balance + amount }
   end
 end
 
-class SynchronizedBankAccount
-  attr_reader :balance
-
+class AtomicRubyAtomicBankAccount
   def initialize(balance)
-    @balance = balance
-    @mutex = Mutex.new
+    @balance = AtomicRuby::Atom.new(balance)
+  end
+
+  def balance
+    @balance.value
   end
 
   def deposit(amount)
-    sleep(rand(0.1..0.2))
-    @mutex.synchronize do
-      @balance += amount
-    end
+    @balance.swap { |current_balance| current_balance + amount }
   end
 end
 
 balances = []
+results = []
 
-r1 = Benchmark.measure do
-  account = SynchronizedBankAccount.new(100)
-  10_000.times.map { |i|
-    Thread.new { account.deposit(i) }
-  }.each(&:join)
-  balances << account.balance
-end
+3.times do |idx|
+  klass = case idx
+  when 0 then SynchronizedBankAccount
+  when 1 then ConcurrentRubyAtomicBankAccount
+  when 2 then AtomicRubyAtomicBankAccount
+  end
 
-r2 = Benchmark.measure do
-  account = ConcurrentRubyAtomicBankAccount.new(100)
-  10_000.times.map { |i|
-    Thread.new { account.deposit(i) }
-  }.each(&:join)
-  balances << account.balance
-end
+  result = Benchmark.measure do
+    account = klass.new(100)
+
+    5.times.map do |idx|
+      Thread.new do
+        25.times do
+          account.deposit(idx + 1)
+          sleep(0.2)
+          account.deposit(idx + 2)
+        end
+      end
+    end.each(&:join)
+
+    balances << account.balance
+  end
 
-r3 = Benchmark.measure do
-  account = AtomicRubyAtomicBankAccount.new(100)
-  10_000.times.map { |i|
-    Thread.new { account.deposit(i) }
-  }.each(&:join)
-  balances << account.balance
+  results << result
 end
 
 puts "ruby version:            #{RUBY_DESCRIPTION}"
@@ -160,9 +179,9 @@ puts "Concurrent Ruby Atomic Bank Account Balance: #{balances[1]}"
 puts "Atomic Ruby Atomic Bank Account Balance:     #{balances[2]}"
 puts "\n"
 puts "Benchmark Results:"
-puts "Synchronized Bank Account:           #{r1.real.round(6)} seconds"
-puts "Concurrent Ruby Atomic Bank Account: #{r2.real.round(6)} seconds"
-puts "Atomic Ruby Atomic Bank Account:     #{r3.real.round(6)} seconds"
+puts "Synchronized Bank Account:           #{results[0].real.round(6)} seconds"
+puts "Concurrent Ruby Atomic Bank Account: #{results[1].real.round(6)} seconds"
+puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 ```
 
 ```
@@ -170,17 +189,98 @@ puts "Atomic Ruby Atomic Bank Account:     #{r3.real.round(6)} seconds"
 
 ruby version:            ruby 3.4.4 (2025-05-14 revision a38531fd3f) +YJIT +PRISM [arm64-darwin24]
 concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.1.0
+atomic-ruby version:     0.3.0
 
 Balances:
-Synchronized Bank Account Balance:           49995100
-Concurrent Ruby Atomic Bank Account Balance: 49995100
-Atomic Ruby Atomic Bank Account Balance:     49995100
+Synchronized Bank Account Balance:           975
+Concurrent Ruby Atomic Bank Account Balance: 975
+Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           1.900873 seconds
-Concurrent Ruby Atomic Bank Account: 1.840683 seconds
-Atomic Ruby Atomic Bank Account:     1.755343 seconds
+Synchronized Bank Account:           5.125638 seconds
+Concurrent Ruby Atomic Bank Account: 5.114936 seconds
+Atomic Ruby Atomic Bank Account:     5.108171 seconds
+```
+
+</details>
+
+<details>
+
+<summary>AtomicRuby::AtomicBoolean</summary>
+
+```ruby
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "concurrent-ruby"
+require_relative "../lib/atomic-ruby"
+
+Benchmark.ips do |x|
+  x.report("Synchronized Boolean Toggle") do
+    boolean = false
+    mutex = Mutex.new
+    20.times.map do
+      Thread.new do
+        100.times do
+          mutex.synchronize do
+            boolean = !boolean
+          end
+        end
+      end
+    end.each(&:join)
+  end
+
+  x.report("Concurrent Ruby Atomic Boolean Toggle") do
+    boolean = Concurrent::AtomicBoolean.new(false)
+    20.times.map do
+      Thread.new do
+        100.times do
+          # Not exactly atomic, but this
+          # is the closest matching API.
+          boolean.value = !boolean.value
+        end
+      end
+    end.each(&:join)
+  end
+
+  x.report("Atomic Ruby Atomic Boolean Toggle") do
+    boolean = AtomicRuby::AtomicBoolean.new(false)
+    20.times.map do
+      Thread.new do
+        100.times do
+          boolean.toggle
+        end
+      end
+    end.each(&:join)
+  end
+
+  x.compare!
+end
+```
+
+```
+> bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
+
+ruby 3.4.4 (2025-05-14 revision a38531fd3f) +YJIT +PRISM [arm64-darwin24]
+Warming up --------------------------------------
+Synchronized Boolean Toggle
+                        83.000 i/100ms
+Concurrent Ruby Atomic Boolean Toggle
+                        58.000 i/100ms
+Atomic Ruby Atomic Boolean Toggle
+                        88.000 i/100ms
+Calculating -------------------------------------
+Synchronized Boolean Toggle
+                        775.552 (± 6.2%) i/s    (1.29 ms/i) -      3.901k in   5.051649s
+Concurrent Ruby Atomic Boolean Toggle
+                        741.655 (± 3.5%) i/s    (1.35 ms/i) -      3.712k in   5.011183s
+Atomic Ruby Atomic Boolean Toggle
+                        881.916 (± 2.8%) i/s    (1.13 ms/i) -      4.488k in   5.092910s
+
+Comparison:
+Atomic Ruby Atomic Boolean Toggle:      881.9 i/s
+Synchronized Boolean Toggle:            775.6 i/s - 1.14x  slower
+Concurrent Ruby Atomic Boolean Toggle:  741.7 i/s - 1.19x  slower
 ```
 
 </details>
@@ -203,16 +303,16 @@ results = []
 2.times do |idx|
   result = Benchmark.measure do
     pool = case idx
-    when 0 then Concurrent::FixedThreadPool.new(5)
-    when 1 then AtomicRuby::AtomicThreadPool.new(size: 5)
+    when 0 then Concurrent::FixedThreadPool.new(20)
+    when 1 then AtomicRuby::AtomicThreadPool.new(size: 20)
     end
 
-    20.times do
-      pool << -> { sleep(0.25) }
+    100.times do
+      pool << -> { sleep(0.2) }
     end
 
-    20.times do
-      pool << -> { 100_000.times.map(&:itself).sum }
+    100.times do
+      pool << -> { 1_000_000.times.map(&:itself).sum }
     end
 
     # concurrent-ruby does not wait for threads to die on shutdown
@@ -240,11 +340,11 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 
 ruby version:            ruby 3.4.4 (2025-05-14 revision a38531fd3f) +YJIT +PRISM [arm64-darwin24]
 concurrent-ruby version: 1.3.5
-atomic-ruby version:     0.1.0
+atomic-ruby version:     0.3.0
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    1.133100 seconds
-Atomic Ruby Atomic Thread Pool: 1.088543 seconds
+Concurrent Ruby Thread Pool:    5.136456 seconds
+Atomic Ruby Atomic Thread Pool: 4.700981 seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -48,6 +48,12 @@ static VALUE rb_cAtom_initialize(VALUE self, VALUE value) {
   return self;
 }
 
+static VALUE rb_cAtom_value(VALUE self) {
+  atomic_ruby_atom_t *atomic_ruby_atom;
+  TypedData_Get_Struct(self, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
+  return (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_atom->value);
+}
+
 static VALUE rb_cAtom_swap(VALUE self) {
   atomic_ruby_atom_t *atomic_ruby_atom;
   TypedData_Get_Struct(self, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
@@ -61,18 +67,12 @@ static VALUE rb_cAtom_swap(VALUE self) {
   return new_value;
 }
 
-static VALUE rb_cAtom_value(VALUE self) {
-  atomic_ruby_atom_t *atomic_ruby_atom;
-  TypedData_Get_Struct(self, atomic_ruby_atom_t, &atomic_ruby_atom_type, atomic_ruby_atom);
-  return (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_atom->value);
-}
-
 RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
   VALUE rb_mAtomicRuby = rb_define_module("AtomicRuby");
   VALUE rb_cAtom = rb_define_class_under(rb_mAtomicRuby, "Atom", rb_cObject);
 
   rb_define_alloc_func(rb_cAtom, rb_cAtom_allocate);
   rb_define_method(rb_cAtom, "_initialize", rb_cAtom_initialize, 1);
-  rb_define_method(rb_cAtom, "_swap", rb_cAtom_swap, 0);
   rb_define_method(rb_cAtom, "_value", rb_cAtom_value, 0);
+  rb_define_method(rb_cAtom, "_swap", rb_cAtom_swap, 0);
 }

data/lib/atomic-ruby/atomic_boolean.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "atom"
+
+module AtomicRuby
+  class AtomicBoolean
+    class InvalidBooleanError < StandardError; end
+
+    def initialize(value)
+      unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        raise InvalidBooleanError, "expected boolean to be a `TrueClass` or `FalseClass`, got #{value.class}"
+      end
+
+      @atom = Atom.new(value)
+    end
+
+    def value
+      @atom.value
+    end
+
+    def true?
+      value == true
+    end
+
+    def false?
+      value == false
+    end
+
+    def make_true
+      @atom.swap { true }
+    end
+
+    def make_false
+      @atom.swap { false }
+    end
+
+    def toggle
+      @atom.swap { |current_value| !current_value }
+    end
+  end
+end

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "atom"
+require_relative "atomic_boolean"
 
 module AtomicRuby
   class AtomicThreadPool
@@ -12,21 +13,21 @@ module AtomicRuby
       @queue = Atom.new([])
       @threads = []
       @started_threads = Atom.new(0)
-      @stopping = Atom.new(false)
+      @stopping = AtomicBoolean.new(false)
 
       start
     end
 
     def <<(work)
-      unless Proc === work || work == :stop
-        raise UnsupportedWorkTypeError, "queued work must be a Proc"
+      unless work.is_a?(Proc) || work == :stop
+        raise UnsupportedWorkTypeError, "expected work to be a `Proc`, got #{work.class}"
       end
 
-      if @stopping.value
+      if @stopping.true?
         raise InvalidWorkQueueingError, "cannot queue work during or after pool shutdown"
       end
 
-      @queue.swap { |queue| queue << work }
+      @queue.swap { |current_queue| current_queue += [work] }
       true
     end
 
@@ -52,11 +53,11 @@ module AtomicRuby
           name = "AtomicRuby::AtomicThreadPool thread #{idx}"
           Thread.current.name = name
 
-          @started_threads.swap { |count| count + 1 }
+          @started_threads.swap { |current_count| current_count + 1 }
 
           loop do
             work = nil
-            @queue.swap { |queue| work = queue.last; queue[0..-2] }
+            @queue.swap { |current_queue| work = current_queue.last; current_queue[0..-2] }
             case work
             when Proc
               begin
@@ -67,9 +68,9 @@ module AtomicRuby
                 puts err.backtrace.join("\n")
               end
             when :stop
-              @stopping.swap { true }
+              @stopping.make_true
             when NilClass
-              if @stopping.value
+              if @stopping.true?
                 break
               else
                 Thread.pass

data/lib/atomic-ruby/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Joshua Young
@@ -26,6 +26,7 @@ files:
 - ext/atomic_ruby/extconf.rb
 - lib/atomic-ruby.rb
 - lib/atomic-ruby/atom.rb
+- lib/atomic-ruby/atomic_boolean.rb
 - lib/atomic-ruby/atomic_ruby.bundle
 - lib/atomic-ruby/atomic_thread_pool.rb
 - lib/atomic-ruby/version.rb