Cleanup names

pitr-ch · pitr-ch · commit 759c02595cec · 2015-04-20T17:57:16.000+02:00
diff --git a/ext/ConcurrentRubyExtService.java b/ext/ConcurrentRubyExtService.java
@@ -9,7 +9,7 @@ public boolean basicLoad(final Ruby runtime) throws IOException {
         new com.concurrent_ruby.ext.JavaAtomicBooleanLibrary().load(runtime, false);
         new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);
         new com.concurrent_ruby.ext.JavaSemaphoreLibrary().load(runtime, false);
-        new com.concurrent_ruby.ext.JavaSynchronizedObjectLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.SynchronizationLibrary().load(runtime, false);
         return true;
     }
 }
diff --git a/ext/com/concurrent_ruby/ext/SynchronizationLibrary.java b/ext/com/concurrent_ruby/ext/SynchronizationLibrary.java
@@ -17,32 +17,33 @@
 import org.jruby.RubyNil;
 import org.jruby.runtime.ThreadContext;
 
-public class JavaSynchronizedObjectLibrary implements Library {
+public class SynchronizationLibrary implements Library {
 
     public void load(Ruby runtime, boolean wrap) throws IOException {
-        RubyModule concurrentModule = runtime.
+        RubyModule synchronizationModule = runtime.
                 defineModule("Concurrent").
-                defineModuleUnder("SynchronizedObjectImplementations");
-        RubyClass parent = concurrentModule.
-                getClass("Abstract");
-        if (parent == null) throw runtime.newRuntimeError("Concurrent::SynchronizedObject::Abstract is missing");
+                defineModuleUnder("Synchronization");
+        RubyClass parentClass = synchronizationModule.getClass("AbstractObject");
 
-        RubyClass synchronizedObjectJavaClass = concurrentModule.
-                defineClassUnder("Java", parent, JRUBYREFERENCE_ALLOCATOR);
+        if (parentClass == null)
+            throw runtime.newRuntimeError("Concurrent::Synchronization::AbstractObject is missing");
 
-        synchronizedObjectJavaClass.defineAnnotatedMethods(Java.class);
+        RubyClass synchronizedObjectJavaClass =
+                synchronizationModule.defineClassUnder("JavaObject", parentClass, JRUBYREFERENCE_ALLOCATOR);
+
+        synchronizedObjectJavaClass.defineAnnotatedMethods(JavaObject.class);
     }
 
     private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
-            return new Java(runtime, klazz);
+            return new JavaObject(runtime, klazz);
         }
     };
 
-    @JRubyClass(name = "Java", parent = "Abstract")
-    public static class Java extends RubyObject {
+    @JRubyClass(name = "JavaObject", parent = "AbstractObject")
+    public static class JavaObject extends RubyObject {
 
-        public Java(Ruby runtime, RubyClass metaClass) {
+        public JavaObject(Ruby runtime, RubyClass metaClass) {
             super(runtime, metaClass);
         }
 
diff --git a/lib/concurrent.rb b/lib/concurrent.rb
@@ -1,6 +1,6 @@
 require 'concurrent/version'
 
-require 'concurrent/synchronized_object'
+require 'concurrent/synchronization'
 
 require 'concurrent/configuration'
 
diff --git a/lib/concurrent/actor.rb b/lib/concurrent/actor.rb
@@ -3,7 +3,7 @@
 require 'concurrent/executor/serialized_execution'
 require 'concurrent/ivar'
 require 'concurrent/logging'
-require 'concurrent/synchronized_object'
+require 'concurrent/synchronization'
 
 module Concurrent
   # TODO https://github.com/celluloid/celluloid/wiki/Supervision-Groups ?
diff --git a/lib/concurrent/actor/core.rb b/lib/concurrent/actor/core.rb
@@ -9,7 +9,7 @@ module Actor
     # @note devel: core should not block on anything, e.g. it cannot wait on
     #   children to terminate that would eat up all threads in task pool and
     #   deadlock
-    class Core < SynchronizedObject
+    class Core < Synchronization::Object
       include TypeCheck
       include Concurrent::Logging
 
diff --git a/lib/concurrent/atomic/count_down_latch.rb b/lib/concurrent/atomic/count_down_latch.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronized_object'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -11,7 +11,7 @@ module Concurrent
   #   method. Each of the other threads calls `#count_down` when done with its work.
   #   When the latch counter reaches zero the waiting thread is unblocked and continues
   #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
-  class PureCountDownLatch < SynchronizedObject
+  class PureCountDownLatch < Synchronization::Object
 
     # @!macro [attach] count_down_latch_method_initialize
     #
diff --git a/lib/concurrent/atomic/cyclic_barrier.rb b/lib/concurrent/atomic/cyclic_barrier.rb
@@ -1,8 +1,8 @@
-require 'concurrent/synchronized_object'
+require 'concurrent/synchronization'
 
 module Concurrent
 
-  class CyclicBarrier < SynchronizedObject
+  class CyclicBarrier < Synchronization::Object
 
     Generation = Struct.new(:status)
     private_constant :Generation
diff --git a/lib/concurrent/atomic/event.rb b/lib/concurrent/atomic/event.rb
@@ -1,5 +1,5 @@
 require 'thread'
-require 'concurrent/synchronized_object'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -13,7 +13,7 @@ module Concurrent
   # `#reset` at any time once it has been set.
   #
   # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
-  class Event < SynchronizedObject
+  class Event < Synchronization::Object
 
     # Creates a new `Event` in the unset state. Threads calling `#wait` on the
     # `Event` will block.
diff --git a/lib/concurrent/executor/serialized_execution.rb b/lib/concurrent/executor/serialized_execution.rb
@@ -1,12 +1,12 @@
 require 'delegate'
 require 'concurrent/executor/executor'
 require 'concurrent/logging'
-require 'concurrent/synchronized_object'
+require 'concurrent/synchronization'
 
 module Concurrent
 
   # Ensures passed jobs in a serialized order never running at the same time.
-  class SerializedExecution < SynchronizedObject
+  class SerializedExecution < Synchronization::Object
     include Logging
 
     Job = Struct.new(:executor, :args, :block) do
diff --git a/lib/concurrent/native_extensions/before.rb b/lib/concurrent/native_extensions/before.rb
@@ -1 +1 @@
-require 'concurrent/synchronized_object_implementations/abstract'
+require 'concurrent/synchronization/abstract_object'
diff --git a/lib/concurrent/synchronization.rb b/lib/concurrent/synchronization.rb
@@ -0,0 +1,28 @@
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/abstract_object'
+require 'concurrent/native_extensions' # JavaObject
+require 'concurrent/synchronization/mutex_object'
+require 'concurrent/synchronization/monitor_object'
+require 'concurrent/synchronization/rbx_object'
+
+module Concurrent
+  module Synchronization
+    class Object < case
+                           when Concurrent.on_jruby?
+                             JavaObject
+
+                           when Concurrent.on_cruby? && (RUBY_VERSION.split('.').map(&:to_i) <=> [1, 9, 3]) <= 0
+                             MonitorObject
+
+                           when Concurrent.on_cruby?
+                             MutexObject
+
+                           when Concurrent.on_rbx?
+                             RbxObject
+
+                           else
+                             MutexObject
+                           end
+    end
+  end
+end
diff --git a/lib/concurrent/synchronization/abstract_object.rb b/lib/concurrent/synchronization/abstract_object.rb
@@ -1,18 +1,20 @@
 module Concurrent
-  module SynchronizedObjectImplementations
+  # TODO rename to Synchronization
+  # TODO add newCondition
+  module Synchronization
     # 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 {SynchronizedObject} not this abstract class.
+    # the classes using it. Use {Synchronization::Object} not this abstract class.
     #
     # @note this object does not support usage together with {Thread#wakeup} and {Thread#raise}.
-    #   `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `SynchronizedObject#wait` and
+    #   `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 < SynchronizedObject
+    #   class AnClass < Synchronization::Object
     #     def initialize
     #       super
     #       synchronize { @value = 'asd' }
@@ -22,7 +24,7 @@ module SynchronizedObjectImplementations
     #       synchronize { @value }
     #     end
     #   end
-    class Abstract
+    class AbstractObject
 
       # @abstract for helper ivar initialization if needed,
       #     otherwise it can be left empty.
@@ -116,6 +118,78 @@ def ns_signal
       def ns_broadcast
         raise NotImplementedError
       end
+
+      # @example
+      # def initialize
+      #   @val = :val # final never changed value
+      #   ensure_ivar_visibility!
+      #   # not it can be shared as Java's immutable objects with final fields
+      # end
+      def ensure_ivar_visibility!
+        raise NotImplementedError
+      end
+
+      def self.attr_volatile *names
+        attr_accessor *names.map { |name| :"volatile_#{name}" }
+      end
+
+      module CasAttributes
+        def list_attr_volatile_cas
+          @attr_volatile_cas_names ||= []
+          # @attr_volatile_cas_names +
+          #     if superclass.respond_to?(:list_attr_volatile_cas)
+          #       superclass.list_attr_volatile_cas
+          #     else
+          #       []
+          #     end
+        end
+
+        def attr_volatile_cas *names
+          names.each do |name|
+            class_eval <<-RUBY
+            def #(name}
+              #{CasAttributes.ivar_name(name)}.get
+            end
+
+            def #(name}=(value)
+              #{CasAttributes.ivar_name(name)}.set value
+            end
+
+            def #(name}_cas(old, value)
+              #{CasAttributes.ivar_name(name)}.compare_and_set old, value
+            end
+
+            RUBY
+
+            define_method name do
+              instance_variable_get CasAttributes.ivar_name(name)
+            end
+
+            define_method "#{name}=" do |value|
+              instance_variable_set CasAttributes.ivar_name(name), value
+              Rubinius.memory_barrier
+            end
+          end
+        end
+
+        def self.ivar_name(name)
+          :"@volatile_cas_#{name}"
+        end
+
+        def self.extended(base)
+          base.include InstanceMethods
+        end
+
+        module InstanceMethods
+          def initialize
+            self.class.list_attr_volatile_cas.each do |name|
+              isntance_variable_set CasAttributes.ivar_name(name), Atomic.new(nil)
+            end
+            ensure_ivar_visibility!
+            super
+          end
+        end
+      end
     end
   end
 end
diff --git a/lib/concurrent/synchronization/java_pure_object.rb b/lib/concurrent/synchronization/java_pure_object.rb
@@ -1,10 +1,10 @@
 module Concurrent
-  module SynchronizedObjectImplementations
+  module Synchronization
 
     if Concurrent.on_jruby?
       require 'jruby'
 
-      class JavaPure < Abstract
+      class JavaPureObject < AbstractObject
         def initialize
         end
 
@@ -17,6 +17,8 @@ def synchronize
         def ns_wait(timeout = nil)
           success = JRuby.reference0(Thread.current).wait_timeout(JRuby.reference0(self), timeout)
           self
+        rescue java.lang.InterruptedException => e
+          raise ThreadError(e.message)
         ensure
           ns_signal unless success
         end
@@ -30,6 +32,10 @@ def ns_signal
           JRuby.reference0(self).notify
           self
         end
+
+        def ensure_ivar_visibility!
+          # relying on undocumented behavior of JRuby, ivar access is volatile
+        end
       end
     end
   end
diff --git a/lib/concurrent/synchronization/monitor_object.rb b/lib/concurrent/synchronization/monitor_object.rb
@@ -1,6 +1,6 @@
 module Concurrent
-  module SynchronizedObjectImplementations
-    class Monitor < Mutex
+  module Synchronization
+    class MonitorObject < MutexObject
       def initialize
         @__lock__do_not_use_directly      = ::Monitor.new
         @__condition__do_not_use_directly = @__lock__do_not_use_directly.new_cond
@@ -16,6 +16,10 @@ def ns_wait(timeout = nil)
         @__condition__do_not_use_directly.wait timeout
         self
       end
+
+      def ensure_ivar_visibility!
+        # relying on undocumented behavior of CRuby, GVL quire has lock which ensures visibility of ivars
+      end
     end
   end
 end
diff --git a/lib/concurrent/synchronization/mutex_object.rb b/lib/concurrent/synchronization/mutex_object.rb
@@ -1,6 +1,6 @@
 module Concurrent
-  module SynchronizedObjectImplementations
-    class Mutex < Abstract
+  module Synchronization
+    class MutexObject < AbstractObject
       def initialize
         @__lock__do_not_use_directly      = ::Mutex.new
         @__condition__do_not_use_directly = ::ConditionVariable.new
@@ -30,6 +30,10 @@ def ns_wait(timeout = nil)
         @__condition__do_not_use_directly.wait @__lock__do_not_use_directly, timeout
         self
       end
+
+      def ensure_ivar_visibility!
+        # relying on undocumented behavior of CRuby, GVL quire has lock which ensures visibility of ivars
+      end
     end
   end
 end
diff --git a/lib/concurrent/synchronization/rbx_object.rb b/lib/concurrent/synchronization/rbx_object.rb
@@ -1,7 +1,7 @@
 module Concurrent
-  module SynchronizedObjectImplementations
+  module Synchronization
     if Concurrent.on_rbx?
-      class Rbx < Abstract
+      class RbxObject < AbstractObject
         def initialize
           @waiters = []
         end
@@ -42,6 +42,25 @@ def ns_broadcast
           self
         end
       end
+
+      def ensure_ivar_visibility!
+        Rubinius.memory_barrier
+      end
+
+      def self.attr_volatile *names
+        names.each do |name|
+          ivar = :"@volatile_#{name}"
+          define_method name do
+            Rubinius.memory_barrier
+            instance_variable_get ivar
+          end
+
+          define_method "#{name}=" do |value|
+            instance_variable_set ivar, value
+            Rubinius.memory_barrier
+          end
+        end
+      end
     end
   end
 end
diff --git a/lib/concurrent/synchronized_object.rb b/lib/concurrent/synchronized_object.rb

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public boolean basicLoad(final Ruby runtime) throws IOException {`
`9`	`9`	`new com.concurrent_ruby.ext.JavaAtomicBooleanLibrary().load(runtime, false);`
`10`	`10`	`new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);`
`11`	`11`	`new com.concurrent_ruby.ext.JavaSemaphoreLibrary().load(runtime, false);`
`12`		`- new com.concurrent_ruby.ext.JavaSynchronizedObjectLibrary().load(runtime, false);`
	`12`	`+ new com.concurrent_ruby.ext.SynchronizationLibrary().load(runtime, false);`
`13`	`13`	`return true;`
`14`	`14`	`}`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-require 'concurrent/synchronized_object_implementations/abstract'`
	`1`	`+require 'concurrent/synchronization/abstract_object'`