concurrent-ruby 1.0.0.pre1 → 1.0.0.pre2

data/lib/concurrent/synchronization/abstract_struct.rb

@@ -9,7 +9,6 @@ module Concurrent
       def initialize(*values)
         super()
         ns_initialize(*values)
-        ensure_ivar_visibility!
       end
 
       # @!macro [attach] struct_length
@@ -131,7 +130,7 @@ module Concurrent
       def self.define_struct_class(parent, base, name, members, &block)
         clazz = Class.new(base || Object) do
           include parent
-          self.const_set(:MEMBERS, members.collect{|member| member.to_s.to_sym}.freeze) 
+          self.const_set(:MEMBERS, members.collect{|member| member.to_s.to_sym}.freeze)
           def ns_initialize(*values)
             raise ArgumentError.new('struct size differs') if values.length > length
             @values = values.fill(nil, values.length..length-1)
@@ -142,7 +141,7 @@ module Concurrent
             parent.const_set(name, clazz)
             parent.const_get(name)
           rescue NameError
-            raise NameError.new("identifier #{name} needs to be constant") 
+            raise NameError.new("identifier #{name} needs to be constant")
           end
         end
         members.each_with_index do |member, index|

data/lib/concurrent/synchronization/condition.rb

@@ -1,14 +1,16 @@
 module Concurrent
   module Synchronization
-    class Condition < Object
+    class Condition < LockableObject
+      safe_initialization!
+
+      # TODO (pitr 12-Sep-2015): locks two objects, improve
 
       singleton_class.send :alias_method, :private_new, :new
       private_class_method :new
 
       def initialize(lock)
-        @Lock = lock
-        ensure_ivar_visibility!
         super()
+        @Lock = lock
       end
 
       def wait(timeout = nil)
@@ -44,7 +46,7 @@ module Concurrent
       end
     end
 
-    class Object < Implementation
+    class LockableObject < LockableObjectImplementation
       def new_condition
         Condition.private_new(self)
       end

data/lib/concurrent/synchronization/jruby_lockable_object.rb

@@ -0,0 +1,13 @@
+module Concurrent
+  module Synchronization
+
+    if Concurrent.on_jruby?
+
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JRubyLockableObject < AbstractLockableObject
+
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/{java_object.rb → jruby_object.rb}

@@ -1,5 +1,3 @@
-require 'concurrent/utility/native_extension_loader' # load native part first
-
 module Concurrent
   module Synchronization
 
@@ -7,7 +5,11 @@ module Concurrent
 
       # @!visibility private
       # @!macro internal_implementation_note
-      class JavaObject < AbstractObject
+      class JRubyObject < AbstractObject
+
+        def initialize
+          # nothing to do
+        end
 
         def self.attr_volatile(*names)
           names.each do |name|

data/lib/concurrent/synchronization/lock.rb

@@ -1,6 +1,7 @@
 module Concurrent
   module Synchronization
-    class Lock < Object
+    class Lock < LockableObject
+      # TODO use JavaReentrantLock on JRuby
 
       public :synchronize
 
@@ -21,7 +22,7 @@ module Concurrent
       end
 
       public :ns_signal
-      
+
       def broadcast
         synchronize { ns_broadcast }
       end

data/lib/concurrent/synchronization/lockable_object.rb

@@ -0,0 +1,59 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    LockableObjectImplementation = case
+                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
+                                     MriMonitorLockableObject
+                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
+                                     MriMutexLockableObject
+                                   when Concurrent.on_jruby?
+                                     JRubyLockableObject
+                                   when Concurrent.on_rbx?
+                                     RbxLockableObject
+                                   else
+                                     warn 'Possibly unsupported Ruby implementation'
+                                     MriMonitorLockableObject
+                                   end
+    private_constant :LockableObjectImplementation
+
+    # TODO (pitr 12-Sep-2015): make private for c-r, prohibit subclassing
+    class LockableObject < LockableObjectImplementation
+
+      # TODO (pitr 12-Sep-2015): we inherit too much ourselves :/
+      def self.allow_only_direct_descendants!
+        this = self
+        singleton_class.send :define_method, :inherited do |child|
+          # super child
+
+          if child.superclass != this
+            warn "all children of #{this} are final, subclassing is not supported use composition."
+          end
+        end
+      end
+
+      # @!method initialize(*args, &block)
+      #   @!macro synchronization_object_method_initialize
+
+      # @!method synchronize
+      #   @!macro synchronization_object_method_synchronize
+
+      # @!method initialize(*args, &block)
+      #   @!macro synchronization_object_method_ns_initialize
+
+      # @!method wait_until(timeout = nil, &condition)
+      #   @!macro synchronization_object_method_ns_wait_until
+
+      # @!method wait(timeout = nil)
+      #   @!macro synchronization_object_method_ns_wait
+
+      # @!method signal
+      #   @!macro synchronization_object_method_ns_signal
+
+      # @!method broadcast
+      #   @!macro synchronization_object_method_ns_broadcast
+
+    end
+  end
+end

data/lib/concurrent/synchronization/mri_lockable_object.rb

@@ -0,0 +1,71 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriLockableObject < AbstractLockableObject
+      protected
+
+      def ns_signal
+        @__condition__.signal
+        self
+      end
+
+      def ns_broadcast
+        @__condition__.broadcast
+        self
+      end
+    end
+
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriMutexLockableObject < MriLockableObject
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__lock__      = ::Mutex.new
+        @__condition__ = ::ConditionVariable.new
+      end
+
+      protected
+
+      def synchronize
+        if @__lock__.owned?
+          yield
+        else
+          @__lock__.synchronize { yield }
+        end
+      end
+
+      def ns_wait(timeout = nil)
+        @__condition__.wait @__lock__, timeout
+        self
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriMonitorLockableObject < MriLockableObject
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__lock__      = ::Monitor.new
+        @__condition__ = @__lock__.new_cond
+      end
+
+      protected
+
+      def synchronize # TODO may be a problem with lock.synchronize { lock.wait }
+        @__lock__.synchronize { yield }
+      end
+
+      def ns_wait(timeout = nil)
+        @__condition__.wait timeout
+        self
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/mri_object.rb

@@ -0,0 +1,35 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MriObject < AbstractObject
+
+      def initialize
+        # nothing to do
+      end
+
+      def full_memory_barrier
+        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
+        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
+      end
+
+      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

data/lib/concurrent/synchronization/object.rb

@@ -1,77 +1,149 @@
-require 'concurrent/synchronization/java_object'
-require 'concurrent/synchronization/monitor_object'
-require 'concurrent/synchronization/mutex_object'
-require 'concurrent/synchronization/rbx_object'
-
 module Concurrent
   module Synchronization
 
     # @!visibility private
     # @!macro internal_implementation_note
-    Implementation = case
-                     when Concurrent.on_jruby?
-                       JavaObject
-                     when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                       MonitorObject
-                     when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
-                       MutexObject
-                     when Concurrent.on_rbx?
-                       RbxObject
-                     else
-                       warn 'Possibly unsupported Ruby implementation'
-                       MutexObject
-                     end
-    private_constant :Implementation
+    ObjectImplementation = case
+                           when Concurrent.on_cruby?
+                             MriObject
+                           when Concurrent.on_jruby?
+                             JRubyObject
+                           when Concurrent.on_rbx?
+                             RbxObject
+                           else
+                             warn 'Possibly unsupported Ruby implementation'
+                             MriObject
+                           end
+    private_constant :ObjectImplementation
 
+    # TODO fix documentation
     # @!macro [attach] synchronization_object
-    #  
+    #
     #   Safe synchronization under any Ruby implementation.
     #   It provides methods like {#synchronize}, {#wait}, {#signal} and {#broadcast}.
     #   Provides a single layer which can improve its implementation over time without changes needed to
     #   the classes using it. Use {Synchronization::Object} not this abstract class.
-    #  
+    #
     #   @note this object does not support usage together with
     #     [`Thread#wakeup`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
     #     and [`Thread#raise`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
     #     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
     #     `Thread#wakeup` will not work on all platforms.
-    #  
+    #
     #   @see {Event} implementation as an example of this class use
-    #  
+    #
     #   @example simple
     #     class AnClass < Synchronization::Object
     #       def initialize
     #         super
     #         synchronize { @value = 'asd' }
     #       end
-    #  
+    #
     #       def value
     #         synchronize { @value }
     #       end
     #     end
     #
-    class Object < Implementation
+    class Object < ObjectImplementation
+
+      # Has to be called by children.
+      # Initializes default volatile fields with cas if any.
+      # @param [Array<Object>] defaults values for fields, in same order as they are defined
+      def initialize(*defaults)
+        super()
+        initialize_volatile_cas_fields(defaults)
+      end
+
+      # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
+      # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
+      # same behaviour as Java's final fields.
+      # @example
+      #   class AClass < Concurrent::Synchronization::Object
+      #     safe_initialization!
+      #
+      #     def initialize
+      #       @AFinalValue = 'value' # published safly, does not have to be synchronized
+      #     end
+      #   end
+      def self.safe_initialization!
+        # define only once, and not again in children
+        return if safe_initialization?
+
+        def self.new(*)
+          object = super
+        ensure
+          object.ensure_ivar_visibility! if object
+        end
+
+        @safe_initialization = true
+      end
+
+      def self.safe_initialization?
+        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
+      end
+
+      # For testing purposes, quite slow.
+      def self.ensure_safe_initialization_when_final_fields_are_present
+        Object.class_eval do
+          def self.new(*)
+            object = super
+          ensure
+            has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
+            if has_final_field && !safe_initialization?
+              raise "there was an instance of #{object.class} with final field but not marked with safe_initialization!"
+            end
+          end
+        end
+      end
+
+      # TODO documentation
+      def self.attr_volatile_with_cas(*names)
+        @volatile_cas_fields ||= []
+        @volatile_cas_fields += names
+        safe_initialization!
+
+        names.each do |name|
+          ivar = :"@VolatileCas_#{name}"
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              #{ivar}.get
+            end
 
-      # @!method initialize(*args, &block)
-      #   @!macro synchronization_object_method_initialize
+            def #{name}=(value)
+              #{ivar}.set value
+            end
 
-      # @!method synchronize
-      #   @!macro synchronization_object_method_synchronize
+            def swap_#{name}(value)
+              #{ivar}.swap value
+            end
 
-      # @!method initialize(*args, &block)
-      #   @!macro synchronization_object_method_ns_initialize
+            def compare_and_set_#{name}(expected, value)
+              #{ivar}.compare_and_set expected, value
+            end
 
-      # @!method wait_until(timeout = nil, &condition)
-      #   @!macro synchronization_object_method_ns_wait_until
+            def update_#{name}(&block)
+              #{ivar}.update &block
+            end
+          RUBY
+        end
+        names.map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}"] }.flatten
+      end
 
-      # @!method wait(timeout = nil)
-      #   @!macro synchronization_object_method_ns_wait
+      def self.volatile_cas_fields(inherited = true)
+        # TODO (pitr 11-Sep-2015): maybe use constant for better optimisation on Truffle since it will not speculate on ivar being final
+        @volatile_cas_fields ||= []
+        ((superclass.volatile_cas_fields if superclass.respond_to?(:volatile_cas_fields) && inherited) || []) +
+            @volatile_cas_fields
+      end
 
-      # @!method signal
-      #   @!macro synchronization_object_method_ns_signal
+      private
 
-      # @!method broadcast
-      #   @!macro synchronization_object_method_ns_broadcast
+      def initialize_volatile_cas_fields(defaults)
+        self.class.volatile_cas_fields.zip(defaults) do |name, default|
+          instance_variable_set :"@VolatileCas_#{name}", AtomicReference.new(default)
+        end
+        nil
+      end
 
       # @!method ensure_ivar_visibility!
       #   @!macro synchronization_object_method_ensure_ivar_visibility