Merge pull request #277 from ruby-concurrency/namespacing

Deprecated Concurrent::Atomic in lieu of Concurrent::AtomicReference.

Author: jdantonio

Gemfile

@@ -6,7 +6,7 @@ group :development do
   gem 'rake', '~> 10.4.2'
   gem 'rake-compiler', '~> 0.9.5'
   gem 'gem-compiler', '~> 0.3.0'
-  gem 'benchmark-ips'
+  gem 'benchmark-ips', '~> 2.1.1'
 end
 
 group :testing do

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("JavaAtomic", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicReference", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
         try {
             sun.misc.Unsafe.class.getMethod("getAndSetObject", Object.class);
             atomicCls.setAllocator(JRUBYREFERENCE8_ALLOCATOR);

ext/concurrent/rb_concurrent.c

@@ -7,7 +7,7 @@
 // module and class definitions
 
 static VALUE rb_mConcurrent;
-static VALUE rb_cAtomic;
+static VALUE rb_cAtomicReference;
 static VALUE rb_cAtomicBoolean;
 static VALUE rb_cAtomicFixnum;
 
@@ -17,20 +17,20 @@ void Init_extension() {
 
   // define modules and classes
   rb_mConcurrent = rb_define_module("Concurrent");
-  rb_cAtomic = rb_define_class_under(rb_mConcurrent, "CAtomic", rb_cObject);
+  rb_cAtomicReference = rb_define_class_under(rb_mConcurrent, "CAtomicReference", rb_cObject);
   rb_cAtomicBoolean = rb_define_class_under(rb_mConcurrent, "CAtomicBoolean", rb_cObject);
   rb_cAtomicFixnum = rb_define_class_under(rb_mConcurrent, "CAtomicFixnum", rb_cObject);
 
-  // CAtomic
-  rb_define_alloc_func(rb_cAtomic, ir_alloc);
-  rb_define_method(rb_cAtomic, "initialize", ir_initialize, -1);
-  rb_define_method(rb_cAtomic, "get", ir_get, 0);
-  rb_define_method(rb_cAtomic, "set", ir_set, 1);
-  rb_define_method(rb_cAtomic, "get_and_set", ir_get_and_set, 1);
-  rb_define_method(rb_cAtomic, "_compare_and_set", ir_compare_and_set, 2);
-  rb_define_alias(rb_cAtomic, "value", "get");
-  rb_define_alias(rb_cAtomic, "value=", "set");
-  rb_define_alias(rb_cAtomic, "swap", "get_and_set");
+  // CAtomicReference
+  rb_define_alloc_func(rb_cAtomicReference, ir_alloc);
+  rb_define_method(rb_cAtomicReference, "initialize", ir_initialize, -1);
+  rb_define_method(rb_cAtomicReference, "get", ir_get, 0);
+  rb_define_method(rb_cAtomicReference, "set", ir_set, 1);
+  rb_define_method(rb_cAtomicReference, "get_and_set", ir_get_and_set, 1);
+  rb_define_method(rb_cAtomicReference, "_compare_and_set", ir_compare_and_set, 2);
+  rb_define_alias(rb_cAtomicReference, "value", "get");
+  rb_define_alias(rb_cAtomicReference, "value=", "set");
+  rb_define_alias(rb_cAtomicReference, "swap", "get_and_set");
 
   // CAtomicBoolean
   rb_define_alloc_func(rb_cAtomicBoolean, atomic_boolean_allocate);

lib/concurrent.rb

@@ -13,10 +13,9 @@
 require 'concurrent/executors'
 require 'concurrent/utilities'
 
-require 'concurrent/atomic'
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/agent'
 require 'concurrent/async'
-require 'concurrent/atomic'
 require 'concurrent/dataflow'
 require 'concurrent/delay'
 require 'concurrent/exchanger'

lib/concurrent/atomic.rb

@@ -0,0 +1,49 @@
+require 'concurrent/native_extensions'
+require 'concurrent/utility/engine'
+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 = 'mutex_atomic'
+  else
+    ruby_engine = Concurrent.ruby_engine
+  end
+
+  require "concurrent/atomic_reference/#{ruby_engine}"
+rescue LoadError
+  #warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
+end
+
+if defined? Concurrent::JavaAtomicReference
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::JavaAtomicReference
+  end
+
+elsif defined? Concurrent::RbxAtomicReference
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::RbxAtomicReference
+  end
+
+elsif defined? Concurrent::CAtomicReference
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::CAtomicReference
+  end
+
+else
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
+  end
+end
+
+module Concurrent
+
+  # @see Concurrent::AtomicReference
+  # @deprecated Use Concurrent::AtomicReference instead.
+  Atomic = AtomicReference
+end

lib/concurrent/atomic/atomic_reference.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'concurrent/atomic'
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/errors'
 
 module Concurrent
@@ -53,11 +53,11 @@ class ReadWriteLock
 
     # Create a new `ReadWriteLock` in the unlocked state.
     def initialize
-      @counter      = Atomic.new(0)         # single integer which represents lock state
-      @reader_q     = ConditionVariable.new # queue for waiting readers
-      @reader_mutex = Mutex.new             # to protect reader queue
-      @writer_q     = ConditionVariable.new # queue for waiting writers
-      @writer_mutex = Mutex.new             # to protect writer queue
+      @counter      = AtomicReference.new(0)  # single integer which represents lock state
+      @reader_q     = ConditionVariable.new   # queue for waiting readers
+      @reader_mutex = Mutex.new               # to protect reader queue
+      @writer_q     = ConditionVariable.new   # queue for waiting writers
+      @writer_mutex = Mutex.new               # to protect writer queue
     end
 
     # Execute a block operation within a read lock.

lib/concurrent/atomic/read_write_lock.rb

@@ -1,5 +1,3 @@
-require 'concurrent/atomic'
-
 module Concurrent
 
   # @!macro [attach] abstract_thread_local_var

lib/concurrent/atomic/thread_local_var.rb

@@ -1,12 +1,12 @@
 require 'concurrent/native_extensions'
 
-if defined?(Concurrent::JavaAtomic)
+if defined?(Concurrent::JavaAtomicReference)
   require 'concurrent/atomic_reference/direct_update'
 
   module Concurrent
 
     # @!macro atomic_reference
-    class JavaAtomic
+    class JavaAtomicReference
       include Concurrent::AtomicDirectUpdate
     end
   end

lib/concurrent/atomic_reference/jruby.rb

@@ -5,7 +5,7 @@
 module Concurrent
 
   # @!macro atomic_reference
-  class MutexAtomic
+  class MutexAtomicReference
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper