Atomic now extends platform-specific implementation; defaults to MutexAtomic.

Author: jdantonio

ext/com/concurrent_ruby/ext/AtomicReferenceLibrary.java

@@ -25,7 +25,7 @@
 public class AtomicReferenceLibrary implements Library {
     public void load(Ruby runtime, boolean wrap) throws IOException {
         RubyModule concurrentMod = runtime.defineModule("Concurrent");
-        RubyClass atomicCls = concurrentMod.defineClassUnder("Atomic", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomic", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
         try {
             sun.misc.Unsafe.class.getMethod("getAndSetObject", Object.class);
             atomicCls.setAllocator(JRUBYREFERENCE8_ALLOCATOR);

ext/rb_concurrent.c

@@ -13,7 +13,7 @@ void Init_concurrent_cruby() {
 
   // define modules and classes
   rb_mConcurrent = rb_define_module("Concurrent");
-  rb_cAtomic = rb_define_class_under(rb_mConcurrent, "Atomic", rb_cObject);
+  rb_cAtomic = rb_define_class_under(rb_mConcurrent, "CAtomic", rb_cObject);
 
   // CAtomic
   rb_define_alloc_func(rb_cAtomic, ir_alloc);
@@ -24,6 +24,5 @@ void Init_concurrent_cruby() {
   rb_define_method(rb_cAtomic, "value=", ir_set, 1);
   rb_define_method(rb_cAtomic, "get_and_set", ir_get_and_set, 1);
   rb_define_method(rb_cAtomic, "swap", ir_get_and_set, 1);
-  rb_define_method(rb_cAtomic, "compare_and_set", ir_compare_and_set, 2);
-  rb_define_method(rb_cAtomic, "compare_and_swap", ir_compare_and_set, 2);
+  rb_define_method(rb_cAtomic, "_compare_and_set", ir_compare_and_set, 2);
 }

lib/concurrent/atomic.rb

@@ -1,18 +1,44 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+require 'concurrent/atomic_reference/mutex_atomic'
+
 begin
   # force fallback impl with FORCE_ATOMIC_FALLBACK=1
   if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
-    ruby_engine = 'fallback'
+    ruby_engine = 'mutex_atomic'
   else
     ruby_engine = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
   end
 
   require "concurrent/atomic_reference/#{ruby_engine}"
 rescue LoadError
   warn "#{__FILE__}:#{__LINE__}: unsupported Ruby engine `#{RUBY_ENGINE}', using less-efficient Atomic impl"
-  require 'concurrent/atomic_reference/fallback'
+end
+
+if RUBY_PLATFORM == 'java'
+
+  class Concurrent::Atomic < Concurrent::JavaAtomic
+  end
+
+elsif defined? Concurrent::CAtomic
+
+  class Concurrent::Atomic < Concurrent::CAtomic
+  end
+
+elsif defined? Concurrent::RbxAtomic
+
+  class Concurrent::Atomic < Concurrent::RbxAtomic
+  end
+
+else
+
+  class Concurrent::Atomic < Concurrent::MutexAtomic
+  end
 end
 
 class Atomic < Concurrent::Atomic
+
+  ConcurrentUpdateError = Class.new(Concurrent::ConcurrentUpdateError)
+
   def initialize(*args)
     warn "[DEPRECATED] Please use Concurrent::Atomic instead."
     super

lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -1,9 +1,7 @@
 module Concurrent
 
-  class Atomic
-    class ConcurrentUpdateError < ThreadError
-      # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-      CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-    end
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
   end
 end

lib/concurrent/atomic_reference/direct_update.rb

@@ -3,7 +3,7 @@
 module Concurrent
 
   # Define update methods that use direct paths
-  class Atomic
+  module AtomicDirectUpdate
     # Pass the current value to the given block, replacing it
     # with the block's result. May retry if the value changes
     # during the block's execution.

lib/concurrent/atomic_reference/jruby.rb

@@ -1,2 +1,8 @@
 require 'concurrent_jruby'
 require 'concurrent/atomic_reference/direct_update'
+
+module Concurrent
+  class JavaAtomic
+    include Concurrent::AtomicDirectUpdate
+  end
+end

lib/concurrent/atomic_reference/fallback.rb renamed to lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -1,10 +1,14 @@
 require 'thread'
 require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
 module Concurrent
 
   # Portable/generic (but not very memory or scheduling-efficient) fallback
-  class Atomic #:nodoc: all
+  class MutexAtomic #:nodoc: all
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
     def initialize(value = nil)
       @mutex = Mutex.new
       @value = value
@@ -29,7 +33,7 @@ def get_and_set(new_value)
     end
     alias swap get_and_set
 
-    def compare_and_set(old_value, new_value)
+    def _compare_and_set(old_value, new_value)
       return false unless @mutex.try_lock
       begin
         return false unless @value.equal? old_value
@@ -39,7 +43,5 @@ def compare_and_set(old_value, new_value)
       end
       true
     end
-
-    require 'concurrent/atomic_reference/numeric_cas_wrapper'
   end
 end

lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -1,7 +1,8 @@
 module Concurrent
 
-  class Atomic
-    alias _compare_and_set compare_and_set
+  module AtomicNumericCompareAndSetWrapper
+    #alias _compare_and_set compare_and_set
+
     def compare_and_set(expected, new)
       if expected.kind_of? Numeric
         while true

lib/concurrent/atomic_reference/rbx.rb

@@ -1,12 +1,16 @@
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
 module Concurrent
 
   # extend Rubinius's version adding aliases and numeric logic
-  class Atomic < Rubinius::AtomicReference
+  class RbxAtomic < Rubinius::AtomicReference
+    alias _compare_and_set compare_and_set
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
     alias value get
     alias value= set
     alias swap get_and_set
   end
-
-  require 'concurrent/atomic_reference/direct_update'
-  require 'concurrent/atomic_reference/numeric_cas_wrapper'
 end

lib/concurrent/atomic_reference/ruby.rb

@@ -1,3 +1,10 @@
 require 'concurrent_cruby'
 require 'concurrent/atomic_reference/direct_update'
 require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+  class CAtomic
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+  end
+end