concurrent-ruby 1.0.3.pre3-java → 1.0.4-java

data/lib/concurrent/atomic/java_thread_local_var.rb

@@ -13,7 +13,7 @@ if Concurrent.on_jruby?
         value = @var.get
 
         if value.nil?
-          @default
+          default
         elsif value == NULL
           nil
         else
@@ -26,19 +26,6 @@ if Concurrent.on_jruby?
         @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

data/lib/concurrent/atomic/mutex_atomic_fixnum.rb

@@ -1,4 +1,5 @@
 require 'concurrent/synchronization'
+require 'concurrent/utility/native_integer'
 
 module Concurrent
 
@@ -7,10 +8,6 @@ module Concurrent
   # @!macro internal_implementation_note
   class MutexAtomicFixnum < Synchronization::LockableObject
 
-    # http://stackoverflow.com/questions/535721/ruby-max-integer
-    MIN_VALUE = -(2**(0.size * 8 - 2))
-    MAX_VALUE = (2**(0.size * 8 - 2) - 1)
-
     # @!macro atomic_fixnum_method_initialize
     def initialize(initial = 0)
       super()
@@ -71,21 +68,8 @@ module Concurrent
 
     # @!visibility private
     def ns_set(value)
-      range_check!(value)
+      Utility::NativeInteger.ensure_integer_and_bounds value
       @value = value
     end
-
-    # @!visibility private
-    def range_check!(value)
-      if !value.is_a?(Fixnum)
-        raise ArgumentError.new('value value must be a Fixnum')
-      elsif value > MAX_VALUE
-        raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
-      elsif value < MIN_VALUE
-        raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
-      else
-        value
-      end
-    end
   end
 end

data/lib/concurrent/atomic/mutex_count_down_latch.rb

@@ -9,9 +9,9 @@ module Concurrent
 
     # @!macro count_down_latch_method_initialize
     def initialize(count = 1)
-      unless count.is_a?(Fixnum) && count >= 0
-        raise ArgumentError.new('count must be in integer greater than or equal zero')
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds count
+      Utility::NativeInteger.ensure_positive count
+
       super()
       synchronize { ns_initialize count }
     end

data/lib/concurrent/atomic/mutex_semaphore.rb

@@ -1,4 +1,5 @@
 require 'concurrent/synchronization'
+require 'concurrent/utility/native_integer'
 
 module Concurrent
 
@@ -9,18 +10,17 @@ module Concurrent
 
     # @!macro semaphore_method_initialize
     def initialize(count)
-      unless count.is_a?(Fixnum) && count >= 0
-        fail ArgumentError, 'count must be an non-negative integer'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds count
+
       super()
       synchronize { ns_initialize count }
     end
 
     # @!macro semaphore_method_acquire
     def acquire(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds permits
+      Utility::NativeInteger.ensure_positive permits
+
       synchronize do
         try_acquire_timed(permits, nil)
         nil
@@ -45,9 +45,9 @@ module Concurrent
 
     # @!macro semaphore_method_try_acquire
     def try_acquire(permits = 1, timeout = nil)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds permits
+      Utility::NativeInteger.ensure_positive permits
+
       synchronize do
         if timeout.nil?
           try_acquire_now(permits)
@@ -59,9 +59,9 @@ module Concurrent
 
     # @!macro semaphore_method_release
     def release(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        fail ArgumentError, 'permits must be an integer greater than zero'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds permits
+      Utility::NativeInteger.ensure_positive permits
+
       synchronize do
         @free += permits
         permits.times { ns_signal }
@@ -81,9 +81,9 @@ module Concurrent
     #
     # @!visibility private
     def reduce_permits(reduction)
-      unless reduction.is_a?(Fixnum) && reduction >= 0
-        fail ArgumentError, 'reduction must be an non-negative integer'
-      end
+      Utility::NativeInteger.ensure_integer_and_bounds reduction
+      Utility::NativeInteger.ensure_positive reduction
+
       synchronize { @free -= reduction }
       nil
     end

data/lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -29,35 +29,25 @@ module Concurrent
     #   array, so we don't leak memory
 
     # @!visibility private
-    FREE = []
-    LOCK = Mutex.new
+    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
-
     # @!macro thread_local_var_method_get
     def value
       if array = get_threadlocal_array
         value = array[@index]
         if value.nil?
-          @default
+          default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        @default
+        default
       end
     end
 
@@ -76,28 +66,15 @@ module Concurrent
       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
       @index = LOCK.synchronize do
         FREE.pop || begin
-        result = @@next
-        @@next += 1
-        result
+          result = @@next
+          @@next += 1
+          result
         end
       end
       ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
@@ -106,13 +83,15 @@ module Concurrent
     # @!visibility private
     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
+        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
         end
       end
@@ -121,10 +100,12 @@ module Concurrent
     # @!visibility private
     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)
+        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
         end
       end
     end
@@ -158,12 +139,20 @@ module Concurrent
       if array = get_threadlocal_array(thread)
         value = array[@index]
         if value.nil?
-          @default
+          default_for(thread)
         elsif value.equal?(NULL)
           nil
         else
           value
         end
+      else
+        default_for(thread)
+      end
+    end
+
+    def default_for(thread)
+      if @default_block
+        raise "Cannot use default_for with default block"
       else
         @default
       end

data/lib/concurrent/atomic/thread_local_var.rb

@@ -11,6 +11,8 @@ module Concurrent
   #   Creates a thread local variable.
   #
   #   @param [Object] default the default value when otherwise unset
+  #   @param [Proc] default_block Optional block that gets called to obtain the
+  #     default value for each thread
 
   # @!macro [new] thread_local_var_method_get
   #
@@ -70,28 +72,28 @@ module Concurrent
   #   the current thread will ever see that change.
   #
   #   @!macro thread_safe_variable_comparison
-  #   
+  #
   #   @example
   #     v = ThreadLocalVar.new(14)
   #     v.value #=> 14
   #     v.value = 2
   #     v.value #=> 2
-  #   
+  #
   #   @example
   #     v = ThreadLocalVar.new(14)
-  #   
+  #
   #     t1 = Thread.new do
   #       v.value #=> 14
   #       v.value = 1
   #       v.value #=> 1
   #     end
-  #   
+  #
   #     t2 = Thread.new do
   #       v.value #=> 14
   #       v.value = 2
   #       v.value #=> 2
   #     end
-  #   
+  #
   #     v.value #=> 14
   #
   #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal

data/lib/concurrent/atomic_reference/jruby+truffle.rb

@@ -1 +1,2 @@
-require 'concurrent/atomic_reference/mutex_atomic'
+require 'atomic'
+require 'concurrent/atomic_reference/rbx'

data/lib/concurrent/collection/map/non_concurrent_map_backend.rb

@@ -95,6 +95,7 @@ module Concurrent
       end
 
       def each_pair
+        return enum_for :each_pair unless block_given?
         dupped_backend.each_pair do |k, v|
           yield k, v
         end

data/lib/concurrent/concern/obligation.rb

@@ -138,6 +138,7 @@ module Concurrent
       # @!visibility private
       def init_obligation
         @event = Event.new
+        @value = @reason = nil
       end
 
       # @!visibility private

data/lib/concurrent/configuration.rb

@@ -10,11 +10,43 @@ require 'concurrent/utility/processor_counter'
 module Concurrent
   extend Concern::Logging
 
-  autoload :Options,            'concurrent/options'
-  autoload :TimerSet,           'concurrent/executor/timer_set'
+  autoload :Options, 'concurrent/options'
+  autoload :TimerSet, 'concurrent/executor/timer_set'
   autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
 
   # @return [Logger] Logger with provided level and output.
+  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
+    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
+    lambda do |severity, progname, message = nil, &block|
+      return false if severity < level
+
+      message           = block ? block.call : message
+      formatted_message = case message
+                          when String
+                            message
+                          when Exception
+                            format "%s (%s)\n%s",
+                                   message.message, message.class, (message.backtrace || []).join("\n")
+                          else
+                            message.inspect
+                          end
+
+      output.print format "[%s] %5s -- %s: %s\n",
+                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
+                          Logger::SEV_LABEL[severity],
+                          progname,
+                          formatted_message
+      true
+    end
+  end
+
+  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
+  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
+    Concurrent.global_logger = create_simple_logger level, output
+  end
+
+  # @return [Logger] Logger with provided level and output.
+  # @deprecated
   def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
     logger           = Logger.new(output)
     logger.level     = level
@@ -24,32 +56,35 @@ module Concurrent
                             msg
                           when Exception
                             format "%s (%s)\n%s",
-                              msg.message, msg.class, (msg.backtrace || []).join("\n")
+                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
                           else
                             msg.inspect
                           end
       format "[%s] %5s -- %s: %s\n",
-        datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-        severity,
-        progname,
-        formatted_message
+             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
+             severity,
+             progname,
+             formatted_message
     end
 
     lambda do |loglevel, progname, message = nil, &block|
-    logger.add loglevel, message, progname, &block
+      logger.add loglevel, message, progname, &block
     end
   end
 
   # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
+  # @deprecated
   def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
     Concurrent.global_logger = create_stdlib_logger level, output
   end
 
+  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
+
   # Suppresses all output when used for logging.
   NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
 
   # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_stdlib_logger(Logger::WARN))
+  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
   private_constant :GLOBAL_LOGGER
 
   def self.global_logger
@@ -131,23 +166,23 @@ module Concurrent
 
   def self.new_fast_executor(opts = {})
     FixedThreadPool.new(
-      [2, Concurrent.processor_count].max,
-      auto_terminate:  opts.fetch(:auto_terminate, true),
-      idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
-      fallback_policy: :abort # shouldn't matter -- 0 max queue
+        [2, Concurrent.processor_count].max,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :abort # shouldn't matter -- 0 max queue
     )
   end
 
   def self.new_io_executor(opts = {})
     ThreadPoolExecutor.new(
-      min_threads:     [2, Concurrent.processor_count].max,
-      max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-      # max_threads:     1000,
-      auto_terminate:  opts.fetch(:auto_terminate, true),
-      idletime:        60, # 1 minute
-      max_queue:       0, # unlimited
-      fallback_policy: :abort # shouldn't matter -- 0 max queue
+        min_threads:     [2, Concurrent.processor_count].max,
+        max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
+        # max_threads:     1000,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :abort # shouldn't matter -- 0 max queue
     )
   end
 end