Revert "Consolidated attr_volatile from c-r and thread_safe."

This reverts commit dbb75a1.

Author: pitr-ch

README.md

@@ -97,8 +97,6 @@ Thread-safe variables:
 * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.
 * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html) An object reference that may be updated atomically.
 * [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html) A variable where the value is different for each thread.
-* [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`.
 
 #### Java-inspired ThreadPools and Other Executors
 

lib/concurrent.rb

@@ -28,7 +28,6 @@
 require 'concurrent/timer_task'
 require 'concurrent/tuple'
 require 'concurrent/tvar'
-require 'concurrent/volatile'
 
 # @!macro [new] internal_implementation_note
 #

lib/concurrent/synchronization/abstract_object.rb

@@ -1,19 +1,16 @@
-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)
-        super(&nil)
+        raise NotImplementedError
       end
 
       protected
@@ -141,6 +138,26 @@ 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

lib/concurrent/synchronization/java_object.rb

@@ -8,6 +8,26 @@ 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

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(*attr_names)
+      # @!method self.attr_volatile(*names)
       #   @!macro synchronization_object_method_self_attr_volatile
     end
   end

lib/concurrent/synchronization/rbx_object.rb

@@ -64,6 +64,24 @@ 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

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 Concurrent::Volatile
+        extend Util::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 Concurrent::Volatile
+      extend Util::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

lib/concurrent/thread_safe/util.rb

@@ -11,10 +11,10 @@ module Util
       CPU_COUNT       = 16 # is there a way to determine this?
 
       autoload :Tuple,           'concurrent/tuple'
-      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 :Volatile,        'concurrent/thread_safe/util/volatile'
       autoload :Striped64,       'concurrent/thread_safe/util/striped64'
       autoload :XorShiftRandom,  'concurrent/thread_safe/util/xor_shift_random'
     end

lib/concurrent/thread_safe/util/cheap_lockable.rb

@@ -85,7 +85,7 @@ def cheap_broadcast
         else
           require 'thread'
 
-          extend Concurrent::Volatile
+          extend Volatile
           attr_volatile :mutex
 
           # Non-reentrant Mutex#syncrhonize

lib/concurrent/thread_safe/util/striped64.rb

@@ -92,7 +92,7 @@ def cas_computed
           end
         end
 
-        extend Concurrent::Volatile
+        extend 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.