Consolidated attr_volatile from c-r and thread_safe.

jdantonio · jdantonio · commit dbb75a1195cf · 2015-08-10T10:50:04.000-04:00
diff --git a/README.md b/README.md
@@ -114,6 +114,8 @@ Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
 * [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
 * [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html)
 * [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html)
+* [Volatile](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Volatile.html)
+  Provides `volatile` (in the JVM's sense) attribute accessors implemented atop of `Concurrent::AtomicReference`.
 
 ### Edge Features
 
diff --git a/lib/concurrent.rb b/lib/concurrent.rb
@@ -27,6 +27,7 @@
 require 'concurrent/settable_struct'
 require 'concurrent/timer_task'
 require 'concurrent/tvar'
+require 'concurrent/volatile'
 
 # @!macro [new] internal_implementation_note
 #
diff --git a/lib/concurrent/synchronization/abstract_object.rb b/lib/concurrent/synchronization/abstract_object.rb
@@ -1,16 +1,19 @@
+require 'concurrent/volatile'
+
 module Concurrent
   module Synchronization
 
     # @!macro synchronization_object
     # @!visibility private
     class AbstractObject
+      extend Concurrent::Volatile
 
       # @!macro [attach] synchronization_object_method_initialize
       #  
       #   @abstract for helper ivar initialization if needed,
       #     otherwise it can be left empty. It has to call ns_initialize.
       def initialize(*args, &block)
-        raise NotImplementedError
+        super(&nil)
       end
 
       protected
@@ -138,26 +141,6 @@ def ns_broadcast
       def ensure_ivar_visibility!
         raise NotImplementedError
       end
-
-      # @!macro [attach] synchronization_object_method_self_attr_volatile
-      #    
-      #   creates methods for reading and writing to a instance variable with volatile (Java semantic) instance variable
-      #   return [Array<Symbol>] names of defined method names
-      def self.attr_volatile(*names)
-        names.each do |name|
-          ivar = :"@volatile_#{name}"
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}
-              #{ivar}
-            end
-
-            def #{name}=(value)
-              #{ivar} = value
-            end
-          RUBY
-        end
-        names.map { |n| [n, :"#{n}="] }.flatten
-      end
     end
   end
 end
diff --git a/lib/concurrent/synchronization/java_object.rb b/lib/concurrent/synchronization/java_object.rb
@@ -8,26 +8,6 @@ module Synchronization
       # @!visibility private
       # @!macro internal_implementation_note
       class JavaObject < AbstractObject
-
-        def self.attr_volatile(*names)
-          names.each do |name|
-
-            ivar = :"@volatile_#{name}"
-
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                instance_variable_get_volatile(:#{ivar})
-              end
-
-              def #{name}=(value)
-                instance_variable_set_volatile(:#{ivar}, value)
-              end
-            RUBY
-
-          end
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
-
       end
     end
   end
diff --git a/lib/concurrent/synchronization/object.rb b/lib/concurrent/synchronization/object.rb
@@ -76,7 +76,7 @@ class Object < Implementation
       # @!method ensure_ivar_visibility!
       #   @!macro synchronization_object_method_ensure_ivar_visibility
 
-      # @!method self.attr_volatile(*names)
+      # @!method self.attr_volatile(*attr_names)
       #   @!macro synchronization_object_method_self_attr_volatile
     end
   end
diff --git a/lib/concurrent/synchronization/rbx_object.rb b/lib/concurrent/synchronization/rbx_object.rb
@@ -64,24 +64,6 @@ def ensure_ivar_visibility!
           # Rubinius instance variables are not volatile so we need to insert barrier
           Rubinius.memory_barrier
         end
-
-        def self.attr_volatile *names
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}
-              Rubinius.memory_barrier
-              #{ivar}
-            end
-
-            def #{name}=(value)
-              #{ivar} = value
-              Rubinius.memory_barrier
-            end
-            RUBY
-          end
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
       end
     end
   end
diff --git a/lib/concurrent/thread_safe/atomic_reference_map_backend.rb b/lib/concurrent/thread_safe/atomic_reference_map_backend.rb
@@ -234,7 +234,7 @@ def delete_node_at(i, node, predecessor_node)
       #
       # @!visibility private
       class Node
-        extend Util::Volatile
+        extend Concurrent::Volatile
         attr_volatile :hash, :value, :next
 
         include Util::CheapLockable
@@ -354,7 +354,7 @@ def locked_hash?(hash)
       # most locking stalls during resizes.
       TRANSFER_BUFFER_SIZE = 32
 
-      extend Util::Volatile
+      extend Concurrent::Volatile
       attr_volatile :table, # The array of bins. Lazily initialized upon first insertion. Size is always a power of two.
 
         # Table initialization and resizing control.  When negative, the
diff --git a/lib/concurrent/thread_safe/util.rb b/lib/concurrent/thread_safe/util.rb
@@ -10,11 +10,11 @@ module Util
       MAX_INT         = (2 ** FIXNUM_BIT_SIZE) - 1
       CPU_COUNT       = 16 # is there a way to determine this?
 
+      autoload :Volatile,        'concurrent/volatile'
       autoload :Adder,           'concurrent/thread_safe/util/adder'
       autoload :CheapLockable,   'concurrent/thread_safe/util/cheap_lockable'
       autoload :PowerOfTwoTuple, 'concurrent/thread_safe/util/power_of_two_tuple'
       autoload :Striped64,       'concurrent/thread_safe/util/striped64'
-      autoload :Volatile,        'concurrent/thread_safe/util/volatile'
       autoload :VolatileTuple,   'concurrent/thread_safe/util/volatile_tuple'
       autoload :XorShiftRandom,  'concurrent/thread_safe/util/xor_shift_random'
     end
diff --git a/lib/concurrent/thread_safe/util/cheap_lockable.rb b/lib/concurrent/thread_safe/util/cheap_lockable.rb
@@ -85,7 +85,7 @@ def cheap_broadcast
         else
           require 'thread'
 
-          extend Volatile
+          extend Concurrent::Volatile
           attr_volatile :mutex
 
           # Non-reentrant Mutex#syncrhonize
diff --git a/lib/concurrent/thread_safe/util/striped64.rb b/lib/concurrent/thread_safe/util/striped64.rb
@@ -92,7 +92,7 @@ def cas_computed
           end
         end
 
-        extend Volatile
+        extend Concurrent::Volatile
         attr_volatile :cells, # Table of cells. When non-null, size is a power of 2.
           :base,  # Base value, used mainly when there is no contention, but also as a fallback during table initialization races. Updated via CAS.
           :busy   # Spinlock (locked via CAS) used when resizing and/or creating Cells.
diff --git a/lib/concurrent/thread_safe/util/volatile.rb b/lib/concurrent/thread_safe/util/volatile.rb
diff --git a/lib/concurrent/volatile.rb b/lib/concurrent/volatile.rb
@@ -0,0 +1,89 @@
+module Concurrent
+
+  # Provides `volatile` (in the JVM's sense) attribute accessors implemented
+  # atop of `Concurrent::AtomicReference`.
+  #
+  # Additionally, the including class will also receive a `initialize_copy(other)` method.
+  # This method will copy all attribute values from `other` and set the corresponding values
+  # in `self`. Both objects must be of the same class (or subclass).
+  #
+  # @see https://docs.oracle.com/javase/tutorial/essential/concurrency/atomic.html Java AtomicAccess
+  module Volatile
+
+    # @!macro [new] synchronization_object_method_self_attr_volatile
+    #    
+    #   Creates methods for reading and writing to a instance variable with volatile (Java semantic) instance variable.
+    #
+    #   Several methods will be defined for each volatile attribute:
+    #   * `<attr_name>()`: attribute reader
+    #   * `<attr_name>=(value)`: attribute writer
+    #   * `compare_and_set_<attr_name>(old_value, new_value)`: write `new_value` if and only if the
+    #     current value equals `old_value`
+    #   * `cas_<attr_name>(old_value, new_value)`: alias for `compare_and_set_<attr_name>`
+    #   * `lazy_set_<attr_name>(value)`: alias for `<attr_name>=`
+    #
+    #   @example
+    #     class Foo
+    #       extend Concurrent::Volatile
+    #       attr_volatile :foo, :bar
+    #
+    #       def initialize(foo, bar = nil)
+    #         super() # must super() into parent initializers before using the volatile attribute accessors
+    #         self.foo = foo
+    #         self.bar = bar
+    #       end
+    #     end
+    #
+    #     baz = Foo.new(10)
+    #
+    #     puts baz.foo                  #=> 10    | volatile read
+    #     baz.foo = 1                   #=> 1     | volatile write
+    #     baz.lazy_set_foo(2)           #=> 2     | volatile write
+    #     baz.compare_and_set_foo(2, 3) #=> true  | strong CAS
+    #     baz.cas_foo(1, 2)             #=> false | strong CAS
+    #
+    #   @param [Array<Symbol>] attr_names names of the accessors to be defined
+    #   @return [Array<Symbol>] names of defined accessor methods
+
+    # @!macro synchronization_object_method_self_attr_volatile
+    def attr_volatile(*attr_names)
+      return if attr_names.empty?
+      include(Module.new do
+        atomic_ref_setup = attr_names.map {|attr_name| "@__#{attr_name} = Concurrent::AtomicReference.new"}
+        initialize_copy_setup = attr_names.zip(atomic_ref_setup).map do |attr_name, ref_setup|
+          "#{ref_setup}(other.instance_variable_get(:@__#{attr_name}).get)"
+        end
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def initialize(*)
+            super
+            #{atomic_ref_setup.join('; ')}
+          end
+
+          def initialize_copy(other)
+            super
+            #{initialize_copy_setup.join('; ')}
+          end
+        RUBY_EVAL
+
+        attr_names.each do |attr_name|
+          class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def #{attr_name}
+              @__#{attr_name}.get
+            end
+
+            def #{attr_name}=(value)
+              @__#{attr_name}.set(value)
+            end
+
+            def compare_and_set_#{attr_name}(old_value, new_value)
+              @__#{attr_name}.compare_and_set(old_value, new_value)
+            end
+          RUBY_EVAL
+
+          alias_method :"cas_#{attr_name}", :"compare_and_set_#{attr_name}"
+          alias_method :"lazy_set_#{attr_name}", :"#{attr_name}="
+        end
+      end)
+    end
+  end
+end
diff --git a/lib/concurrent/volatile_tuple.rb b/lib/concurrent/volatile_tuple.rb

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@`
`27`	`27`	`require 'concurrent/settable_struct'`
`28`	`28`	`require 'concurrent/timer_task'`
`29`	`29`	`require 'concurrent/tvar'`
	`30`	`+require 'concurrent/volatile'`
`30`	`31`
`31`	`32`	`# @!macro [new] internal_implementation_note`
`32`	`33`	`#`