Merge branch 'master' into devel

* master: (16 commits)
  Deprecated Concurrent::Atomic in lieu of Concurrent::AtomicReference.
  ...

Author: pitr-ch

Gemfile

@@ -7,7 +7,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

@@ -11,10 +11,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/agent.rb

@@ -22,18 +22,7 @@ class Agent
     #
     # @param [Object] initial the initial value
     #
-    # @!macro [attach] executor_and_deref_options
-    #  
-    #   @param [Hash] opts the options used to define the behavior at update and deref
-    #     and to specify the executor on which to perform actions
-    #   @option opts [Executor] :executor when set use the given `Executor` instance.
-    #     Three special values are also supported: `:task` returns the global task pool,
-    #     `:operation` returns the global operation pool, and `:immediate` returns a new
-    #     `ImmediateExecutor` object.
-    #   @option opts [Boolean] :dup_on_deref (false) call `#dup` before returning the data
-    #   @option opts [Boolean] :freeze_on_deref (false) call `#freeze` before returning the data
-    #   @option opts [Proc] :copy_on_deref (nil) call the given `Proc` passing
-    #     the internal value and returning the value returned from the proc
+    # @!macro executor_and_deref_options
     def initialize(initial, opts = {})
       @value                = initial
       @rescuers             = []

lib/concurrent/async.rb

@@ -82,14 +82,11 @@ def method_missing(method, *args, &block)
         self.define_singleton_method(method) do |*args2|
           Async::validate_argc(@delegate, method, *args2)
           ivar = Concurrent::IVar.new
-          value, reason = nil, nil
           @serializer.post(@executor.value) do
             begin
-              value = @delegate.send(method, *args2, &block)
+              ivar.set(@delegate.send(method, *args2, &block))
             rescue => reason
-              # caught
-            ensure
-              ivar.complete(reason.nil?, value, reason)
+              ivar.fail(reason)
             end
           end
           ivar.value if @blocking

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

@@ -33,40 +33,38 @@ def add_observer(observer=nil, func=:update, &block)
       begin
         @mutex.lock
         @observers[observer] = func
+        observer
       ensure
         @mutex.unlock
       end
-
-        observer
     end
 
     # @param [Object] observer the observer to remove
     # @return [Object] the deleted observer
     def delete_observer(observer)
       @mutex.lock
       @observers.delete(observer)
-      @mutex.unlock
-
       observer
+    ensure
+      @mutex.unlock
     end
 
     # Deletes all observers
     # @return [CopyOnWriteObserverSet] self
     def delete_observers
       @mutex.lock
       @observers.clear
-      @mutex.unlock
-
       self
+    ensure
+      @mutex.unlock
     end
 
     # @return [Integer] the observers count
     def count_observers
       @mutex.lock
-      result = @observers.count
+      @observers.count
+    ensure
       @mutex.unlock
-
-      result
     end
 
     # Notifies all registered observers with optional args
@@ -75,7 +73,6 @@ def count_observers
     def notify_observers(*args, &block)
       observers = duplicate_observers
       notify_to(observers, *args, &block)
-
       self
     end
 
@@ -86,7 +83,6 @@ def notify_observers(*args, &block)
     def notify_and_delete_observers(*args, &block)
       observers = duplicate_and_clear_observers
       notify_to(observers, *args, &block)
-
       self
     end
 
@@ -96,17 +92,17 @@ def duplicate_and_clear_observers
       @mutex.lock
       observers = @observers.dup
       @observers.clear
-      @mutex.unlock
-
       observers
+    ensure
+      @mutex.unlock
     end
 
     def duplicate_observers
       @mutex.lock
       observers = @observers.dup
-      @mutex.unlock
-
       observers
+    ensure
+      @mutex.unlock
     end
 
     def notify_to(observers, *args)

lib/concurrent/atomic/copy_on_notify_observer_set.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.