concurrent-ruby 0.6.0.pre.2 → 0.6.0

data/lib/concurrent/atomic/atomic.rb

@@ -0,0 +1,48 @@
+module Concurrent
+
+  class MutexAtomic
+
+    def initialize(init = nil)
+      @value = init
+      @mutex = Mutex.new
+    end
+
+    def value
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    def value=(value)
+      @mutex.lock
+      @value = value
+    ensure
+      @mutex.unlock
+    end
+
+    def modify
+      @mutex.lock
+      result = yield @value
+      @value = result
+    ensure
+      @mutex.unlock
+    end
+
+    def compare_and_set(expect, update)
+      @mutex.lock
+      if @value == expect
+        @value = update
+        true
+      else
+        false
+      end
+    ensure
+      @mutex.unlock
+    end
+  end
+
+  class Atomic < MutexAtomic
+  end
+
+end

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -14,7 +14,7 @@ module Concurrent
     #
     # Creates a new `AtomicBoolean` with the given initial value.
     #
-    # @param [Boolean] init the initial value
+    # @param [Boolean] initial the initial value
     def initialize(initial = false)
       @value = !!initial
       @mutex = Mutex.new
@@ -27,9 +27,9 @@ module Concurrent
     #   @return [Boolean] the current value
     def value
       @mutex.lock
-      result = @value
+      @value
+    ensure
       @mutex.unlock
-      result
     end
 
     # @!macro [attach] atomic_boolean_method_value_eq
@@ -42,9 +42,9 @@ module Concurrent
     def value=(value)
       @mutex.lock
       @value = !!value
-      result = @value
+      @value
+    ensure
       @mutex.unlock
-      result
     end
 
     # @!macro [attach] atomic_boolean_method_is_true
@@ -54,9 +54,9 @@ module Concurrent
     #   @return [Boolean] true if the current value is `true`, else false
     def true?
       @mutex.lock
-      result = @value
+      @value
+    ensure
       @mutex.unlock
-      result
     end
 
     # @!macro [attach] atomic_boolean_method_is_false
@@ -66,9 +66,9 @@ module Concurrent
     #   @return [Boolean] true if the current value is `false`, else false
     def false?
       @mutex.lock
-      result = !@value
+      !@value
+    ensure
       @mutex.unlock
-      result
     end
 
     # @!macro [attach] atomic_boolean_method_make_true
@@ -80,9 +80,9 @@ module Concurrent
       @mutex.lock
       old = @value
       @value = true
-      @mutex.unlock
-
       !old
+    ensure
+      @mutex.unlock
     end
 
     # @!macro [attach] atomic_boolean_method_make_false
@@ -94,9 +94,9 @@ module Concurrent
       @mutex.lock
       old = @value
       @value = false
-      @mutex.unlock
-
       old
+    ensure
+      @mutex.unlock
     end
   end
 

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -29,10 +29,9 @@ module Concurrent
     #   @return [Fixnum] the current value
     def value
       @mutex.lock
-      result = @value
+      @value
+    ensure
       @mutex.unlock
-
-      result
     end
 
     # @!macro [attach] atomic_fixnum_method_value_eq
@@ -47,10 +46,9 @@ module Concurrent
     def value=(value)
       raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
       @mutex.lock
-      result = @value = value
+      @value = value
+    ensure
       @mutex.unlock
-
-      result
     end
 
     # @!macro [attach] atomic_fixnum_method_increment
@@ -61,10 +59,8 @@ module Concurrent
     def increment
       @mutex.lock
       @value += 1
-      result = @value
+    ensure
       @mutex.unlock
-
-      result
     end
 
     alias_method :up, :increment
@@ -77,10 +73,8 @@ module Concurrent
     def decrement
       @mutex.lock
       @value -= 1
-      result = @value
+    ensure
       @mutex.unlock
-
-      result
     end
 
     alias_method :down, :decrement
@@ -95,17 +89,15 @@ module Concurrent
     #
     #   @return [Boolean] true if the value was updated else false 
     def compare_and_set(expect, update)
-
       @mutex.lock
       if @value == expect
         @value = update
-        result = true
+        true
       else
-        result = false
+        false
       end
+    ensure
       @mutex.unlock
-
-      result
     end
   end
 

data/lib/concurrent/atomic/copy_on_notify_observer_set.rb

@@ -28,11 +28,14 @@ module Concurrent
         func = :call
       end
 
-      @mutex.lock
-      @observers[observer] = func
-      @mutex.unlock
+      begin
+        @mutex.lock
+        @observers[observer] = func
+      ensure
+        @mutex.unlock
+      end
 
-      observer
+        observer
     end
 
     # @param [Object] observer the observer to remove

data/lib/concurrent/atomic/copy_on_write_observer_set.rb

@@ -27,13 +27,15 @@ module Concurrent
         func = :call
       end
 
-      @mutex.lock
-      new_observers = @observers.dup
-      new_observers[observer] = func
-      @observers = new_observers
-      @mutex.unlock
-
-      observer
+      begin
+        @mutex.lock
+        new_observers = @observers.dup
+        new_observers[observer] = func
+        @observers = new_observers
+        observer
+      ensure
+        @mutex.unlock
+      end
     end
 
     # @param [Object] observer the observer to remove
@@ -43,9 +45,9 @@ module Concurrent
       new_observers = @observers.dup
       new_observers.delete(observer)
       @observers = new_observers
-      @mutex.unlock
-
       observer
+    ensure
+      @mutex.unlock
     end
 
     # Deletes all observers
@@ -91,15 +93,15 @@ module Concurrent
 
     def observers
       @mutex.lock
-      o = @observers
+      @observers
+    ensure
       @mutex.unlock
-
-      o
     end
 
     def observers=(new_set)
       @mutex.lock
       @observers = new_set
+    ensure
       @mutex.unlock
     end
 
@@ -107,9 +109,9 @@ module Concurrent
       @mutex.lock
       old_observers = @observers
       @observers = {}
-      @mutex.unlock
-
       old_observers
+    ensure
+      @mutex.unlock
     end
   end
 end

data/lib/concurrent/atomic/event.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'concurrent/utilities'
 require 'concurrent/atomic/condition'
 
 module Concurrent
@@ -29,10 +28,9 @@ module Concurrent
     # @return [Boolean] indicating whether or not the `Event` has been set
     def set?
       @mutex.lock
-      result = @set
+      @set
+    ensure
       @mutex.unlock
-
-      result
     end
 
     # Trigger the event, setting the state to `set` and releasing all threads
@@ -45,25 +43,24 @@ module Concurrent
         @set = true
         @condition.broadcast
       end
-      @mutex.unlock
-
       true
+    ensure
+      @mutex.unlock
     end
 
     def try?
       @mutex.lock
 
       if @set
-        result = false
+        false
       else
         @set = true
         @condition.broadcast
-        result = true
+        true
       end
 
+    ensure
       @mutex.unlock
-
-      result
     end
 
     # Reset a previously set event back to the `unset` state.
@@ -73,9 +70,9 @@ module Concurrent
     def reset
       @mutex.lock
       @set = false
-      @mutex.unlock
-
       true
+    ensure
+      @mutex.unlock
     end
 
     # Wait a given number of seconds for the `Event` to be set by another
@@ -93,11 +90,9 @@ module Concurrent
         end
       end
 
-      result = @set
-
+      @set
+    ensure
       @mutex.unlock
-
-      result
     end
   end
 end

data/lib/concurrent/atomics.rb

@@ -1,3 +1,4 @@
+require 'concurrent/atomic/atomic'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/atomic/condition'

data/lib/concurrent/channel/channel.rb

@@ -1,7 +1,9 @@
+require 'concurrent/ivar'
+
 module Concurrent
   module Channel
 
-    class Probe < IVar
+    class Probe < Concurrent::IVar
 
       def initialize(value = NO_VALUE, opts = {})
         super(value, opts)
@@ -36,4 +38,4 @@ module Concurrent
       result
     end
   end
-end
+end

data/lib/concurrent/collection/blocking_ring_buffer.rb

@@ -31,7 +31,7 @@ module Concurrent
       @mutex.synchronize { @buffer.full? }
     end
 
-    # @param [Object] value. This methods blocks until an empty slot is available
+    # @param [Object] value the value to be inserted
     # @return [Boolean] true if value has been inserted, false otherwise
     def put(value)
       @mutex.synchronize do

data/lib/concurrent/configuration.rb

@@ -1,64 +1,45 @@
 require 'thread'
+require 'concurrent/delay'
+require 'concurrent/errors'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
 require 'concurrent/utility/processor_count'
 
 module Concurrent
-
-  # An error class to be raised when errors occur during configuration.
-  ConfigurationError = Class.new(StandardError)
-
-  class << self
-    attr_accessor :configuration
-  end
-
-  # Perform gem-level configuration.
-  #
-  # @yield the configuration commands
-  # @yieldparam [Configuration] the current configuration object
-  def self.configure
-    (@mutex ||= Mutex.new).synchronize do
-      yield(configuration)
-
-      # initialize the global thread pools if necessary
-      configuration.global_task_pool
-      configuration.global_operation_pool
-      configuration.global_timer_set
-    end
-  end
+  extend Logging
 
   # A gem-level configuration object.
   class Configuration
 
+    # a proc defining how to log messages, its interface has to be:
+    #   lambda { |level, progname, message = nil, &block| _ }
+    attr_accessor :logger
+
     # Create a new configuration object.
     def initialize
-      @cores ||= Concurrent::processor_count
+      @global_task_pool      = Delay.new { new_task_pool }
+      @global_operation_pool = Delay.new { new_operation_pool }
+      @global_timer_set      = Delay.new { Concurrent::TimerSet.new }
+      @logger                = no_logger
+    end
+
+    # if assigned to {#logger}, it will log nothing.
+    def no_logger
+      lambda { |level, progname, message = nil, &block| }
     end
 
     # Global thread pool optimized for short *tasks*.
     #
     # @return [ThreadPoolExecutor] the thread pool
     def global_task_pool
-      @global_task_pool ||= Concurrent::ThreadPoolExecutor.new(
-        min_threads: [2, @cores].max,
-        max_threads: [20, @cores * 15].max,
-        idletime: 2 * 60,                   # 2 minutes
-        max_queue: 0,                       # unlimited
-        overflow_policy: :abort             # raise an exception
-      )
+      @global_task_pool.value
     end
 
     # Global thread pool optimized for long *operations*.
     #
     # @return [ThreadPoolExecutor] the thread pool
     def global_operation_pool
-      @global_operation_pool ||= Concurrent::ThreadPoolExecutor.new(
-        min_threads: [2, @cores].max,
-        max_threads: [2, @cores].max,
-        idletime: 10 * 60,                  # 10 minutes
-        max_queue: [20, @cores * 15].max,
-        overflow_policy: :abort             # raise an exception
-      )
+      @global_operation_pool.value
     end
 
     # Global thread pool optimized for *timers*
@@ -67,7 +48,7 @@ module Concurrent
     #
     # @see Concurrent::timer
     def global_timer_set
-      @global_timer_set ||= Concurrent::TimerSet.new
+      @global_timer_set.value
     end
 
     # Global thread pool optimized for short *tasks*.
@@ -83,10 +64,10 @@ module Concurrent
     #
     # @return [ThreadPoolExecutor] the new thread pool
     #
-    # @raise [ConfigurationError] if this thread pool has already been set
+    # @raise [Concurrent::ConfigurationError] if this thread pool has already been set
     def global_task_pool=(executor)
-      raise ConfigurationError.new('global task pool was already set') unless @global_task_pool.nil?
-      @global_task_pool = executor
+      @global_task_pool.reconfigure { executor } or
+          raise ConfigurationError.new('global task pool was already set')
     end
 
     # Global thread pool optimized for long *operations*.
@@ -102,11 +83,43 @@ module Concurrent
     #
     # @return [ThreadPoolExecutor] the new thread pool
     #
-    # @raise [ConfigurationError] if this thread pool has already been set
+    # @raise [Concurrent::ConfigurationError] if this thread pool has already been set
     def global_operation_pool=(executor)
-      raise ConfigurationError.new('global operation pool was already set') unless @global_operation_pool.nil?
-      @global_operation_pool = executor
+      @global_operation_pool.reconfigure { executor } or
+          raise ConfigurationError.new('global operation pool was already set')
     end
+
+    def new_task_pool
+      Concurrent::ThreadPoolExecutor.new(
+          min_threads:     [2, Concurrent.processor_count].max,
+          max_threads:     [20, Concurrent.processor_count * 15].max,
+          idletime:        2 * 60, # 2 minutes
+          max_queue:       0, # unlimited
+          overflow_policy: :abort # raise an exception
+      )
+    end
+
+    def new_operation_pool
+      Concurrent::ThreadPoolExecutor.new(
+          min_threads:     [2, Concurrent.processor_count].max,
+          max_threads:     [2, Concurrent.processor_count].max,
+          idletime:        10 * 60, # 10 minutes
+          max_queue:       [20, Concurrent.processor_count * 15].max,
+          overflow_policy: :abort # raise an exception
+      )
+    end
+  end
+
+  # create the default configuration on load
+  @configuration = Configuration.new
+  singleton_class.send :attr_reader, :configuration
+
+  # Perform gem-level configuration.
+  #
+  # @yield the configuration commands
+  # @yieldparam [Configuration] the current configuration object
+  def self.configure
+    yield(configuration)
   end
 
   private
@@ -125,12 +138,11 @@ module Concurrent
       executor.kill
     end
     true
-  rescue
+  rescue => ex
+    log DEBUG, ex
     false
   end
 
-  # create the default configuration on load
-  self.configuration = Configuration.new
 
   # set exit hook to shutdown global thread pools
   at_exit do