concurrent-ruby 1.1.4 → 1.1.8

data/ext/concurrent-ruby/com/concurrent_ruby/ext/SynchronizationLibrary.java

@@ -23,6 +23,7 @@ import java.lang.reflect.Method;
 public class SynchronizationLibrary implements Library {
 
     private static final Unsafe UNSAFE = loadUnsafe();
+    private static final boolean FULL_FENCE = supportsFences();
 
     private static Unsafe loadUnsafe() {
         try {
@@ -140,17 +141,17 @@ public class SynchronizationLibrary implements Library {
         // volatile threadContext is used as a memory barrier per the JVM memory model happens-before semantic
         // on volatile fields. any volatile field could have been used but using the thread context is an
         // attempt to avoid code elimination.
-        private static volatile ThreadContext threadContext = null;
+        private static volatile int volatileField;
 
         @JRubyMethod(name = "full_memory_barrier", visibility = Visibility.PUBLIC)
         public static IRubyObject fullMemoryBarrier(ThreadContext context, IRubyObject self) {
             // Prevent reordering of ivar writes with publication of this instance
-            if (!supportsFences()) {
+            if (!FULL_FENCE) {
                 // Assuming that following volatile read and write is not eliminated it simulates fullFence.
                 // If it's eliminated it'll cause problems only on non-x86 platforms.
                 // http://shipilev.net/blog/2014/jmm-pragmatics/#_happens_before_test_your_understanding
-                final ThreadContext oldContext = threadContext;
-                threadContext = context;
+                final int volatileRead = volatileField;
+                volatileField = context.getLine();
             } else {
                 UNSAFE.fullFence();
             }
@@ -163,9 +164,9 @@ public class SynchronizationLibrary implements Library {
                 IRubyObject self,
                 IRubyObject name) {
             // Ensure we ses latest value with loadFence
-            if (!supportsFences()) {
+            if (!FULL_FENCE) {
                 // piggybacking on volatile read, simulating loadFence
-                final ThreadContext oldContext = threadContext;
+                final int volatileRead = volatileField;
                 return ((RubyBasicObject) self).instance_variable_get(context, name);
             } else {
                 UNSAFE.loadFence();
@@ -180,10 +181,10 @@ public class SynchronizationLibrary implements Library {
                 IRubyObject name,
                 IRubyObject value) {
             // Ensure we make last update visible
-            if (!supportsFences()) {
+            if (!FULL_FENCE) {
                 // piggybacking on volatile write, simulating storeFence
                 final IRubyObject result = ((RubyBasicObject) self).instance_variable_set(name, value);
-                threadContext = context;
+                volatileField = context.getLine();
                 return result;
             } else {
                 // JRuby uses StampedVariableAccessor which calls fullFence

data/lib/{concurrent → concurrent-ruby/concurrent}/array.rb

@@ -10,19 +10,20 @@ module Concurrent
   #   or writing at a time. This includes iteration methods like `#each`.
   #
   #   @note `a += b` is **not** a **thread-safe** operation on
-  #   `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
-  #   which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
-  #   The read and write are independent operations they do not form a single atomic
-  #   operation therefore when two `+=` operations are executed concurrently updates
-  #   may be lost. Use `#concat` instead.
+  #     `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
+  #     which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
+  #     The read and write are independent operations they do not form a single atomic
+  #     operation therefore when two `+=` operations are executed concurrently updates
+  #     may be lost. Use `#concat` instead.
   #
-  #   @see http://ruby-doc.org/core-2.2.0/Array.html Ruby standard library `Array`
+  #   @see http://ruby-doc.org/core/Array.html Ruby standard library `Array`
 
   # @!macro internal_implementation_note
   ArrayImplementation = case
                         when Concurrent.on_cruby?
-                          # Because MRI never runs code in parallel, the existing
-                          # non-thread-safe structures should usually work fine.
+                          # Array is thread-safe in practice because CRuby runs
+                          # threads one at a time and does not do context
+                          # switching during the execution of C functions.
                           ::Array
 
                         when Concurrent.on_jruby?
@@ -63,4 +64,3 @@ module Concurrent
   end
 
 end
-

data/lib/{concurrent → concurrent-ruby/concurrent}/async.rb

@@ -58,26 +58,6 @@ module Concurrent
   # end
   # ```
   #
-  # When defining a constructor it is critical that the first line be a call to
-  # `super` with no arguments. The `super` method initializes the background
-  # thread and other asynchronous components.
-  #
-  # ```
-  # class BackgroundLogger
-  #   include Concurrent::Async
-  #
-  #   def initialize(level)
-  #     super()
-  #     @logger = Logger.new(STDOUT)
-  #     @logger.level = level
-  #   end
-  #
-  #   def info(msg)
-  #     @logger.info(msg)
-  #   end
-  # end
-  # ```
-  #
   # Mixing this module into a class provides each object two proxy methods:
   # `async` and `await`. These methods are thread safe with respect to the
   # enclosing object. The former proxy allows methods to be called
@@ -309,6 +289,7 @@ module Concurrent
         @delegate = delegate
         @queue = []
         @executor = Concurrent.global_io_executor
+        @ruby_pid = $$
       end
 
       # Delegates method calls to the wrapped object.
@@ -326,6 +307,7 @@ module Concurrent
 
         ivar = Concurrent::IVar.new
         synchronize do
+          reset_if_forked
           @queue.push [ivar, method, args, block]
           @executor.post { perform } if @queue.length == 1
         end
@@ -333,6 +315,13 @@ module Concurrent
         ivar
       end
 
+      # Check whether the method is responsive
+      #
+      # @param [Symbol] method the method being called
+      def respond_to_missing?(method, include_private = false)
+        @delegate.respond_to?(method) || super
+      end
+
       # Perform all enqueued tasks.
       #
       # This method must be called from within the executor. It must not be
@@ -354,6 +343,13 @@ module Concurrent
           end
         end
       end
+
+      def reset_if_forked
+        if $$ != @ruby_pid
+          @queue.clear
+          @ruby_pid = $$
+        end
+      end
     end
     private_constant :AsyncDelegator
 
@@ -383,6 +379,13 @@ module Concurrent
         ivar.wait
         ivar
       end
+
+      # Check whether the method is responsive
+      #
+      # @param [Symbol] method the method being called
+      def respond_to_missing?(method, include_private = false)
+        @delegate.respond_to?(method) || super
+      end
     end
     private_constant :AwaitDelegator
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atom.rb

@@ -18,7 +18,7 @@ require 'concurrent/synchronization'
 #     uncoordinated, *synchronous* change of individual values. Best used when
 #     the value will undergo frequent reads but only occasional, though complex,
 #     updates. Suitable when the result of an update must be known immediately.
-#   * *{Concurrent::AtomicReference}:* A simple object reference that can be
+#   * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
 #     atomically. Updates are synchronous but fast. Best used when updates a
 #     simple set operations. Not suitable when updates are complex.
 #     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/atomic_boolean.rb

@@ -41,13 +41,13 @@ module Concurrent
   #
   #   Explicitly sets the value to true.
   #
-  #   @return [Boolean] true is value has changed, otherwise false
+  #   @return [Boolean] true if value has changed, otherwise false
 
   # @!macro atomic_boolean_method_make_false
   #
   #   Explicitly sets the value to false.
   #
-  #   @return [Boolean] true is value has changed, otherwise false
+  #   @return [Boolean] true if value has changed, otherwise false
 
   ###################################################################
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/atomic_fixnum.rb

@@ -79,10 +79,10 @@ module Concurrent
   #   @!method value=(value)
   #     @!macro atomic_fixnum_method_value_set
   #
-  #   @!method increment(delta)
+  #   @!method increment(delta = 1)
   #     @!macro atomic_fixnum_method_increment
   #
-  #   @!method decrement(delta)
+  #   @!method decrement(delta = 1)
   #     @!macro atomic_fixnum_method_decrement
   #
   #   @!method compare_and_set(expect, update)

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/count_down_latch.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/mutex_count_down_latch'
 require 'concurrent/atomic/java_count_down_latch'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/ruby_thread_local_var.rb

@@ -28,16 +28,31 @@ module Concurrent
     # But when a Thread is GC'd, we need to drop the reference to its thread-local
     #   array, so we don't leak memory
 
-    # @!visibility private
-    FREE   = []
-    LOCK   = Mutex.new
-    ARRAYS = {} # used as a hash set
-    @@next = 0
-    private_constant :FREE, :LOCK, :ARRAYS
+    FREE                = []
+    LOCK                = Mutex.new
+    THREAD_LOCAL_ARRAYS = {} # used as a hash set
+
+    # synchronize when not on MRI
+    # on MRI using lock in finalizer leads to "can't be called from trap context" error
+    # so the code is carefully written to be tread-safe on MRI relying on GIL
+
+    if Concurrent.on_cruby?
+      # @!visibility private
+      def self.semi_sync(&block)
+        block.call
+      end
+    else
+      # @!visibility private
+      def self.semi_sync(&block)
+        LOCK.synchronize(&block)
+      end
+    end
+
+    private_constant :FREE, :LOCK, :THREAD_LOCAL_ARRAYS
 
     # @!macro thread_local_var_method_get
     def value
-      if array = get_threadlocal_array
+      if (array = get_threadlocal_array)
         value = array[@index]
         if value.nil?
           default
@@ -57,10 +72,10 @@ module Concurrent
       # We could keep the thread-local arrays in a hash, keyed by Thread
       # But why? That would require locking
       # Using Ruby's built-in thread-local storage is faster
-      unless array = get_threadlocal_array(me)
+      unless (array = get_threadlocal_array(me))
         array = set_threadlocal_array([], me)
-        LOCK.synchronize { ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
+        self.class.semi_sync { THREAD_LOCAL_ARRAYS[array.object_id] = array }
+        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
       end
       array[@index] = (value.nil? ? NULL : value)
       value
@@ -70,48 +85,52 @@ module Concurrent
 
     # @!visibility private
     def allocate_storage
-      @index = LOCK.synchronize do
-        FREE.pop || begin
-          result = @@next
-          @@next += 1
-          result
-        end
-      end
-      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+      @index = FREE.pop || next_index
+
+      ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
     end
 
     # @!visibility private
-    def self.threadlocal_finalizer(index)
+    def self.thread_local_finalizer(index)
       proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            FREE.push(index)
-            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-            # But that is natural! More threads means more storage is used per TLV
-            # So naturally more CPU time is required to free more storage
-            ARRAYS.each_value do |array|
-              array[index] = nil
-            end
-          end
+        semi_sync do
+          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
+          # But that is natural! More threads means more storage is used per TLV
+          # So naturally more CPU time is required to free more storage
+          #
+          # DO NOT use each_value which might conflict with new pair assignment
+          # into the hash in #value= method
+          THREAD_LOCAL_ARRAYS.values.each { |array| array[index] = nil }
+          # free index has to be published after the arrays are cleared
+          FREE.push(index)
         end
       end
     end
 
     # @!visibility private
-    def self.thread_finalizer(array)
+    def self.thread_finalizer(id)
       proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            # The thread which used this thread-local array is now gone
-            # So don't hold onto a reference to the array (thus blocking GC)
-            ARRAYS.delete(array.object_id)
-          end
+        semi_sync do
+          # The thread which used this thread-local array is now gone
+          # So don't hold onto a reference to the array (thus blocking GC)
+          THREAD_LOCAL_ARRAYS.delete(id)
         end
       end
     end
 
     private
 
+    # noinspection RubyClassVariableUsageInspection
+    @@next = 0
+    # noinspection RubyClassVariableUsageInspection
+    def next_index
+      LOCK.synchronize do
+        result = @@next
+        @@next += 1
+        result
+      end
+    end
+
     if Thread.instance_methods.include?(:thread_variable_get)
 
       def get_threadlocal_array(thread = Thread.current)
@@ -136,21 +155,22 @@ module Concurrent
     # This exists only for use in testing
     # @!visibility private
     def value_for(thread)
-      if array = get_threadlocal_array(thread)
+      if (array = get_threadlocal_array(thread))
         value = array[@index]
         if value.nil?
-          default_for(thread)
+          get_default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        default_for(thread)
+        get_default
       end
     end
 
-    def default_for(thread)
+    # @!visibility private
+    def get_default
       if @default_block
         raise "Cannot use default_for with default block"
       else

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/thread_local_var.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/ruby_thread_local_var'
 require 'concurrent/atomic/java_thread_local_var'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/lock_free_stack.rb

@@ -53,7 +53,7 @@ module Concurrent
 
     # @param [Node] head
     # @return [true, false]
-    def empty?(head = self.head)
+    def empty?(head = head())
       head.equal? EMPTY
     end
 

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/map/mri_map_backend.rb

@@ -19,7 +19,7 @@ module Concurrent
       end
 
       def compute_if_absent(key)
-        if stored_value = _get(key) # fast non-blocking path for the most likely case
+        if NULL != (stored_value = @backend.fetch(key, NULL)) # fast non-blocking path for the most likely case
           stored_value
         else
           @write_lock.synchronize { super }