Counter in ReadWriteLock is now an AtomicFixnum

Author: jdantonio

lib/concurrent/atomic/read_write_lock.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
 require 'concurrent/synchronization'
 
@@ -33,7 +33,7 @@ class ReadWriteLock < Synchronization::Object
     WAITING_WRITER = 1 << 15
 
     # @!visibility private
-    RUNNING_WRITER = 1 << 30
+    RUNNING_WRITER = 1 << 29
 
     # @!visibility private
     MAX_READERS    = WAITING_WRITER - 1
@@ -50,11 +50,11 @@ class ReadWriteLock < Synchronization::Object
     # Each reader increments the counter by 1 when acquiring a read lock
     #   (and decrements by 1 when releasing the read lock)
     # The counter is increased by (1 << 15) for each writer waiting to acquire the
-    #   write lock, and by (1 << 30) if the write lock is taken
+    #   write lock, and by (1 << 29) if the write lock is taken
 
     # Create a new `ReadWriteLock` in the unlocked state.
     def initialize
-      @Counter   = AtomicReference.new(0) # single integer which represents lock state
+      @Counter   = AtomicFixnum.new(0) # single integer which represents lock state
       @ReadLock  = Synchronization::Lock.new
       @WriteLock = Synchronization::Lock.new
       ensure_ivar_visibility!
@@ -122,11 +122,11 @@ def acquire_read_lock
             if running_writer?(c)
               @ReadLock.wait_until { !running_writer? }
             else
-              return if @Counter.compare_and_swap(c, c+1)
+              return if @Counter.compare_and_set(c, c+1)
             end
           end
         else
-          break if @Counter.compare_and_swap(c, c+1)
+          break if @Counter.compare_and_set(c, c+1)
         end
       end
       true
@@ -138,7 +138,7 @@ def acquire_read_lock
     def release_read_lock
       while true
         c = @Counter.value
-        if @Counter.compare_and_swap(c, c-1)
+        if @Counter.compare_and_set(c, c-1)
           # If one or more writers were waiting, and we were the last reader, wake a writer up
           if waiting_writer?(c) && running_readers(c) == 1
             @WriteLock.signal
@@ -162,8 +162,8 @@ def acquire_write_lock
 
         if c == 0 # no readers OR writers running
           # if we successfully swap the RUNNING_WRITER bit on, then we can go ahead
-          break if @Counter.compare_and_swap(0, RUNNING_WRITER)
-        elsif @Counter.compare_and_swap(c, c+WAITING_WRITER)
+          break if @Counter.compare_and_set(0, RUNNING_WRITER)
+        elsif @Counter.compare_and_set(c, c+WAITING_WRITER)
           while true
             # Now we have successfully incremented, so no more readers will be able to increment
             #   (they will wait instead)
@@ -180,7 +180,7 @@ def acquire_write_lock
             # Then we are OK to stop waiting and go ahead
             # Otherwise go back and wait again
             c = @Counter.value
-            break if !running_writer?(c) && !running_readers?(c) && @Counter.compare_and_swap(c, c+RUNNING_WRITER-WAITING_WRITER)
+            break if !running_writer?(c) && !running_readers?(c) && @Counter.compare_and_set(c, c+RUNNING_WRITER-WAITING_WRITER)
           end
           break
         end

spec/concurrent/atomic/read_write_lock_spec.rb

@@ -142,8 +142,8 @@ module Concurrent
       end
 
       it 'raises an exception if maximum lock limit is exceeded' do
-        counter = Concurrent::AtomicReference.new(ReadWriteLock::MAX_READERS)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(ReadWriteLock::MAX_READERS)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         expect {
           subject.with_read_lock { nil }
         }.to raise_error(Concurrent::ResourceLimitError)
@@ -183,8 +183,8 @@ module Concurrent
       end
 
       it 'raises an exception if maximum lock limit is exceeded' do
-        counter = Concurrent::AtomicReference.new(ReadWriteLock::MAX_WRITERS)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(ReadWriteLock::MAX_WRITERS)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         expect {
           subject.with_write_lock { nil }
         }.to raise_error(Concurrent::ResourceLimitError)
@@ -202,8 +202,8 @@ module Concurrent
     context '#acquire_read_lock' do
 
       it 'increments the lock count' do
-        counter = Concurrent::AtomicReference.new(0)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(0)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         subject.acquire_read_lock
         expect(counter.value).to eq 1
       end
@@ -243,8 +243,8 @@ module Concurrent
       end
 
       it 'does not wait for any running readers' do
-        counter = Concurrent::AtomicReference.new(0)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(0)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
 
         latch_1 = Concurrent::CountDownLatch.new(1)
         latch_2 = Concurrent::CountDownLatch.new(1)
@@ -282,8 +282,8 @@ module Concurrent
       end
 
       it 'raises an exception if maximum lock limit is exceeded' do
-        counter = Concurrent::AtomicReference.new(ReadWriteLock::MAX_WRITERS)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(ReadWriteLock::MAX_WRITERS)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         expect {
           subject.acquire_write_lock { nil }
         }.to raise_error(Concurrent::ResourceLimitError)
@@ -297,8 +297,8 @@ module Concurrent
     context '#release_read_lock' do
 
       it 'decrements the counter' do
-        counter = Concurrent::AtomicReference.new(0)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(0)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         subject.acquire_read_lock
         expect(counter.value).to eq 1
         subject.release_read_lock
@@ -340,8 +340,8 @@ module Concurrent
     context '#acquire_write_lock' do
 
       it 'increments the lock count' do
-        counter = Concurrent::AtomicReference.new(0)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(0)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         subject.acquire_write_lock
         expect(counter.value).to be > 1
       end
@@ -415,8 +415,8 @@ module Concurrent
       end
 
       it 'raises an exception if maximum lock limit is exceeded' do
-        counter = Concurrent::AtomicReference.new(ReadWriteLock::MAX_WRITERS)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(ReadWriteLock::MAX_WRITERS)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         expect {
           subject.acquire_write_lock { nil }
         }.to raise_error(Concurrent::ResourceLimitError)
@@ -430,8 +430,8 @@ module Concurrent
     context '#release_write_lock' do
 
       it 'decrements the counter' do
-        counter = Concurrent::AtomicReference.new(0)
-        allow(Concurrent::AtomicReference).to receive(:new).with(anything).and_return(counter)
+        counter = Concurrent::AtomicFixnum.new(0)
+        allow(Concurrent::AtomicFixnum).to receive(:new).with(anything).and_return(counter)
         subject.acquire_write_lock
         expect(counter.value).to be > 1
         subject.release_write_lock