concurrent-ruby 0.9.0 → 0.9.1

data/lib/concurrent/atomic/thread_local_var.rb

@@ -1,4 +1,4 @@
-require 'concurrent/atomic/thread_local_var/weak_key_map'
+require 'thread'
 
 module Concurrent
 
@@ -56,45 +56,29 @@ module Concurrent
     #
     #   @return [Object] the current value
     def value
-      value = get
-
-      if value.nil?
-        @default
-      elsif value == NIL_SENTINEL
-        nil
-      else
-        value
-      end
+      raise NotImplementedError
     end
 
     # @!macro [attach] thread_local_var_method_set
     #
     #   Sets the current thread's copy of this thread-local variable to the specified value.
-    #   
+    #
     #   @param [Object] value the value to set
     #   @return [Object] the new value
     def value=(value)
-      bind value
+      raise NotImplementedError
     end
 
     # @!macro [attach] thread_local_var_method_bind
     #
     #   Bind the given value to thread local storage during
     #   execution of the given block.
-    #   
+    #
     #   @param [Object] value the value to bind
     #   @yield the operation to be performed with the bound variable
     #   @return [Object] the value
     def bind(value, &block)
-      if value.nil?
-        stored_value = NIL_SENTINEL
-      else
-        stored_value = value
-      end
-
-      set(stored_value, &block)
-
-      value
+      raise NotImplementedError
     end
 
     protected
@@ -103,46 +87,171 @@ module Concurrent
     def allocate_storage
       raise NotImplementedError
     end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class RubyThreadLocalVar < AbstractThreadLocalVar
+
+    # Each thread has a (lazily initialized) array of thread-local variable values
+    # Each time a new thread-local var is created, we allocate an "index" for it
+    # For example, if the allocated index is 1, that means slot #1 in EVERY
+    #   thread's thread-local array will be used for the value of that TLV
+    #
+    # The good thing about using a per-THREAD structure to hold values, rather
+    #   than a per-TLV structure, is that no synchronization is needed when
+    #    reading and writing those values (since the structure is only ever
+    #    accessed by a single thread)
+    #
+    # Of course, when a TLV is GC'd, 1) we need to recover its index for use
+    #   by other new TLVs (otherwise the thread-local arrays could get bigger
+    #   and bigger with time), and 2) we need to null out all the references
+    #   held in the now-unused slots (both to avoid blocking GC of those objects,
+    #   and also to prevent "stale" values from being passed on to a new TLV
+    #   when the index is reused)
+    # Because we need to null out freed slots, we need to keep references to
+    #   ALL the thread-local arrays -- ARRAYS is for that
+    # 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
-    def get
-      raise NotImplementedError
+    FREE = []
+    LOCK = Mutex.new
+    ARRAYS = {} # used as a hash set
+    @@next = 0
+    private_constant :FREE, :LOCK, :ARRAYS
+
+    # @!macro [attach] thread_local_var_method_initialize
+    #
+    #   Creates a thread local variable.
+    #
+    #   @param [Object] default the default value when otherwise unset
+    def initialize(default = nil)
+      @default = default
+      allocate_storage
     end
 
-    # @!visibility private
-    def set(value)
-      raise NotImplementedError
+    # @!macro thread_local_var_method_get
+    def value
+      if array = get_threadlocal_array
+        value = array[@index]
+        if value.nil?
+          @default
+        elsif value.equal?(NIL_SENTINEL)
+          nil
+        else
+          value
+        end
+      else
+        @default
+      end
     end
-  end
 
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class RubyThreadLocalVar < AbstractThreadLocalVar
+    # @!macro thread_local_var_method_set
+    def value=(value)
+      me = Thread.current
+      # 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)
+        array = set_threadlocal_array([], me)
+        LOCK.synchronize { ARRAYS[array.object_id] = array }
+        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
+      end
+      array[@index] = (value.nil? ? NIL_SENTINEL : value)
+      value
+    end
+
+    # @!macro thread_local_var_method_bind
+    def bind(value, &block)
+      if block_given?
+        old_value = self.value
+        begin
+          self.value = value
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
 
     protected
 
     # @!visibility private
     def allocate_storage
-      @storage = WeakKeyMap.new
+      @index = LOCK.synchronize do
+        FREE.pop || begin
+        result = @@next
+        @@next += 1
+        result
+        end
+      end
+      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
     end
 
     # @!visibility private
-    def get
-      @storage[Thread.current]
+    def self.threadlocal_finalizer(index)
+      proc do
+        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
+      end
     end
 
     # @!visibility private
-    def set(value)
-      key = Thread.current
+    def self.thread_finalizer(array)
+      proc do
+        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
+      end
+    end
 
-      @storage[key] = value
+    private
 
-      if block_given?
-        begin
-          yield
-        ensure
-          @storage.delete(key)
+    if Thread.instance_methods.include?(:thread_variable_get)
+
+      def get_threadlocal_array(thread = Thread.current)
+        thread.thread_variable_get(:__threadlocal_array__)
+      end
+
+      def set_threadlocal_array(array, thread = Thread.current)
+        thread.thread_variable_set(:__threadlocal_array__, array)
+      end
+
+    else
+
+      def get_threadlocal_array(thread = Thread.current)
+        thread[:__threadlocal_array__]
+      end
+
+      def set_threadlocal_array(array, thread = Thread.current)
+        thread[:__threadlocal_array__] = array
+      end
+    end
+
+    # This exists only for use in testing
+    # @!visibility private
+    def value_for(thread)
+      if array = get_threadlocal_array(thread)
+        value = array[@index]
+        if value.nil?
+          @default
+        elsif value.equal?(NIL_SENTINEL)
+          nil
+        else
+          value
         end
+      else
+        @default
       end
     end
   end
@@ -153,21 +262,42 @@ module Concurrent
     # @!macro internal_implementation_note
     class JavaThreadLocalVar < AbstractThreadLocalVar
 
-      protected
+      # @!macro thread_local_var_method_get
+      def value
+        value = @var.get
 
-      # @!visibility private
-      def allocate_storage
-        @var = java.lang.ThreadLocal.new
+        if value.nil?
+          @default
+        elsif value == NIL_SENTINEL
+          nil
+        else
+          value
+        end
       end
 
-      # @!visibility private
-      def get
-        @var.get
+      # @!macro thread_local_var_method_set
+      def value=(value)
+        @var.set(value)
+      end
+
+      # @!macro thread_local_var_method_bind
+      def bind(value, &block)
+        if block_given?
+          old_value = @var.get
+          begin
+            @var.set(value)
+            yield
+          ensure
+            @var.set(old_value)
+          end
+        end
       end
 
+      protected
+
       # @!visibility private
-      def set(value)
-        @var.set(value)
+      def allocate_storage
+        @var = java.lang.ThreadLocal.new
       end
     end
   end

data/lib/concurrent/collection/copy_on_notify_observer_set.rb

@@ -100,7 +100,7 @@ module Concurrent
       end
 
       def duplicate_observers
-        synchronize { observers = @observers.dup }
+        synchronize { @observers.dup }
       end
 
       def notify_to(observers, *args)

data/lib/concurrent/configuration.rb

@@ -1,9 +1,13 @@
 require 'thread'
-require 'concurrent/atomics'
+require 'concurrent/delay'
 require 'concurrent/errors'
-require 'concurrent/executors'
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/deprecation'
 require 'concurrent/concern/logging'
+require 'concurrent/executor/timer_set'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 
@@ -32,8 +36,8 @@ module Concurrent
              formatted_message
     end
 
-    lambda do |level, progname, message = nil, &block|
-      logger.add level, message, progname, &block
+    lambda do |loglevel, progname, message = nil, &block|
+      logger.add loglevel, message, progname, &block
     end
   end
 

data/lib/concurrent/delay.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'concurrent/configuration'
 require 'concurrent/concern/obligation'
 require 'concurrent/executor/executor'
 require 'concurrent/executor/immediate_executor'

data/lib/concurrent/errors.rb

@@ -15,6 +15,10 @@ module Concurrent
   # Raised when an attempt is made to violate an immutability guarantee.
   ImmutabilityError = Class.new(Error)
 
+  # Raised when an operation is attempted which is not legal given the
+  # receiver's current state
+  IllegalOperationError = Class.new(Error)
+
   # Raised when an object's methods are called when it has not been
   # properly initialized.
   InitializationError = Class.new(Error)

data/lib/concurrent/executor/executor.rb

@@ -1,5 +1,6 @@
-require 'concurrent/executor/executor_service'
+require 'concurrent/configuration'
 require 'concurrent/concern/deprecation'
+require 'concurrent/executor/executor_service'
 
 module Concurrent
 

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -166,7 +166,7 @@ module Concurrent
     def ns_kill_execution
       # TODO log out unprocessed tasks in queue
       # TODO try to shutdown first?
-      @pool.each &:kill
+      @pool.each(&:kill)
       @pool.clear
       @ready.clear
     end
@@ -297,32 +297,31 @@ module Concurrent
       private
 
       def create_worker(queue, pool, idletime)
-        Thread.new(queue, pool, idletime) do |queue, pool, idletime|
+        Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
           last_message = Concurrent.monotonic_time
           catch(:stop) do
             loop do
 
-              case message = queue.pop
+              case message = my_queue.pop
               when :idle_test
-                if (Concurrent.monotonic_time - last_message) > idletime
-                  pool.remove_busy_worker(self)
+                if (Concurrent.monotonic_time - last_message) > my_idletime
+                  my_pool.remove_busy_worker(self)
                   throw :stop
                 else
-                  pool.worker_not_old_enough(self)
+                  my_pool.worker_not_old_enough(self)
                 end
 
               when :stop
-                pool.remove_busy_worker(self)
+                my_pool.remove_busy_worker(self)
                 throw :stop
 
               else
                 task, args = message
-                run_task pool, task, args
+                run_task my_pool, task, args
                 last_message = Concurrent.monotonic_time
 
-                pool.ready_worker(self)
+                my_pool.ready_worker(self)
               end
-
             end
           end
         end

data/lib/concurrent/scheduled_task.rb

@@ -1,9 +1,7 @@
 require 'concurrent/errors'
 require 'concurrent/ivar'
-require 'concurrent/configuration'
 require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/executor/executor'
-require 'concurrent/executor/timer_set'
 require 'concurrent/utility/monotonic_time'
 require 'concurrent/concern/deprecation'
 

data/lib/concurrent/synchronization/monitor_object.rb

@@ -1,4 +1,5 @@
 require 'monitor'
+require 'concurrent/synchronization/mutex_object'
 
 module Concurrent
   module Synchronization

data/lib/concurrent/synchronization/object.rb

@@ -1,3 +1,8 @@
+require 'concurrent/synchronization/java_object'
+require 'concurrent/synchronization/monitor_object'
+require 'concurrent/synchronization/mutex_object'
+require 'concurrent/synchronization/rbx_object'
+
 module Concurrent
   module Synchronization
 

data/lib/concurrent/synchronization/rbx_object.rb

@@ -2,35 +2,48 @@ module Concurrent
   module Synchronization
 
     if Concurrent.on_rbx?
-      
+
       # @!visibility private
       # @!macro internal_implementation_note
       class RbxObject < AbstractObject
         def initialize
-          @Waiters = []
+          @__Waiters__ = []
+          @__owner__   = nil
           ensure_ivar_visibility!
         end
 
         protected
 
         def synchronize(&block)
-          Rubinius.synchronize(self, &block)
+          if @__owner__ == Thread.current
+            yield
+          else
+            Rubinius.lock(self)
+            begin
+              @__owner__ = Thread.current
+              result = yield
+            ensure
+              @__owner__ = nil
+              Rubinius.unlock(self)
+              result
+            end
+          end
         end
 
         def ns_wait(timeout = nil)
           wchan = Rubinius::Channel.new
 
           begin
-            @Waiters.push wchan
+            @__Waiters__.push wchan
             Rubinius.unlock(self)
             signaled = wchan.receive_timeout timeout
           ensure
             Rubinius.lock(self)
 
-            if !signaled && !@Waiters.delete(wchan)
+            if !signaled && !@__Waiters__.delete(wchan)
               # we timed out, but got signaled afterwards,
               # so pass that signal on to the next waiter
-              @Waiters.shift << true unless @Waiters.empty?
+              @__Waiters__.shift << true unless @__Waiters__.empty?
             end
           end
 
@@ -38,12 +51,12 @@ module Concurrent
         end
 
         def ns_signal
-          @Waiters.shift << true unless @Waiters.empty?
+          @__Waiters__.shift << true unless @__Waiters__.empty?
           self
         end
 
         def ns_broadcast
-          @Waiters.shift << true until @Waiters.empty?
+          @__Waiters__.shift << true until @__Waiters__.empty?
           self
         end