Merge pull request #473 from ruby-concurrency/synchronization

JRuby+Truffle support improvements

Author: Petr Chalupa

.travis.yml

@@ -1,16 +1,16 @@
 language: ruby
 
 rvm:
+  - 2.2.3
   - 2.2.2
   - 2.1.5
   - 2.1.4
   - 2.0.0
   - 1.9.3
   - ruby-head
   - jruby-1.7.19
-  - jruby-9.0.0.0
-  - jruby-9.0.1.0
   - jruby-9.0.3.0
+  - jruby-9.0.4.0
   - jruby-head
   - rbx-2
 

lib/concurrent/synchronization/lockable_object.rb

@@ -10,8 +10,10 @@ module Synchronization
                                      MriMutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
-                                   when Concurrent.on_rbx? || Concurrent.on_truffle?
+                                   when Concurrent.on_rbx?
                                      RbxLockableObject
+                                   when Concurrent.on_truffle?
+                                     TruffleLockableObject
                                    else
                                      warn 'Possibly unsupported Ruby implementation'
                                      MriMonitorLockableObject

lib/concurrent/synchronization/object.rb

@@ -8,8 +8,10 @@ module Synchronization
                              MriObject
                            when Concurrent.on_jruby?
                              JRubyObject
-                           when Concurrent.on_rbx? || Concurrent.on_truffle?
+                           when Concurrent.on_rbx?
                              RbxObject
+                           when Concurrent.on_truffle?
+                             TruffleObject
                            else
                              MriObject
                            end
@@ -49,8 +51,8 @@ def self.safe_initialization!
         # define only once, and not again in children
         return if safe_initialization?
 
-        def self.new(*)
-          object = super
+        def self.new(*args, &block)
+          object = super(*args, &block)
         ensure
           object.full_memory_barrier if object
         end

lib/concurrent/synchronization/rbx_object.rb

@@ -7,6 +7,7 @@ def self.included(base)
       end
 
       module ClassMethods
+
         def attr_volatile(*names)
           names.each do |name|
             ivar = :"@volatile_#{name}"
@@ -24,6 +25,7 @@ def #{name}=(value)
           end
           names.map { |n| [n, :"#{n}="] }.flatten
         end
+
       end
 
       def full_memory_barrier

lib/concurrent/synchronization/truffle_lockable_object.rb

@@ -0,0 +1,7 @@
+module Concurrent
+  module Synchronization
+    class TruffleLockableObject
+      raise NotImplementedError
+    end
+  end
+end

lib/concurrent/synchronization/truffle_object.rb

@@ -0,0 +1,32 @@
+module Concurrent
+  module Synchronization
+
+    module TruffleAttrVolatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def attr_volatile(*names)
+          # TODO may not always be available
+          attr_atomic(*names)
+        end
+      end
+
+      def full_memory_barrier
+        # Rubinius instance variables are not volatile so we need to insert barrier
+        Rubinius.memory_barrier
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class TruffleObject < AbstractObject
+      include TruffleAttrVolatile
+
+      def initialize
+        # nothing to do
+      end
+    end
+  end
+end