concurrent-ruby 0.6.0 → 0.7.0.rc0

data/lib/concurrent/agent.rb

@@ -62,14 +62,14 @@ module Concurrent
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing the internal value and
     #   returning the value returned from the proc
     def initialize(initial, opts = {})
-      @value              = initial
-      @rescuers           = []
-      @validator          = Proc.new { |result| true }
-      @timeout            = opts.fetch(:timeout, TIMEOUT).freeze
-      self.observers      = CopyOnWriteObserverSet.new
-      @one_by_one         = OneByOne.new
-      @task_executor      = OptionsParser.get_task_executor_from(opts)
-      @operation_executor = OptionsParser.get_operation_executor_from(opts)
+      @value                = initial
+      @rescuers             = []
+      @validator            = Proc.new { |result| true }
+      @timeout              = opts.fetch(:timeout, TIMEOUT).freeze
+      self.observers        = CopyOnWriteObserverSet.new
+      @serialized_execution = SerializedExecution.new
+      @task_executor        = OptionsParser.get_task_executor_from(opts)
+      @operation_executor   = OptionsParser.get_operation_executor_from(opts)
       init_mutex
       set_deref_options(opts)
     end
@@ -180,7 +180,7 @@ module Concurrent
 
     def post_on(executor, &block)
       return nil if block.nil?
-      @one_by_one.post(executor) { work(&block) }
+      @serialized_execution.post(executor) { work(&block) }
       true
     end
 

data/lib/concurrent/atomic.rb

@@ -0,0 +1,46 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+require 'concurrent/atomic_reference/mutex_atomic'
+
+begin
+  # force fallback impl with FORCE_ATOMIC_FALLBACK=1
+  if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
+    ruby_engine = 'mutex_atomic'
+  else
+    ruby_engine = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
+  end
+
+  require "concurrent/atomic_reference/#{ruby_engine}"
+rescue LoadError
+  warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
+end
+
+if defined? Concurrent::JavaAtomic
+
+  class Concurrent::Atomic < Concurrent::JavaAtomic
+  end
+
+elsif defined? Concurrent::CAtomic
+
+  class Concurrent::Atomic < Concurrent::CAtomic
+  end
+
+elsif defined? Concurrent::RbxAtomic
+
+  class Concurrent::Atomic < Concurrent::RbxAtomic
+  end
+
+else
+
+  class Concurrent::Atomic < Concurrent::MutexAtomic
+  end
+end
+
+class Atomic < Concurrent::Atomic
+
+  ConcurrentUpdateError = Class.new(Concurrent::ConcurrentUpdateError)
+
+  def initialize(*args)
+    warn "[DEPRECATED] Please use Concurrent::Atomic instead."
+    super
+  end
+end

data/lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -0,0 +1,7 @@
+module Concurrent
+
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
+  end
+end

data/lib/concurrent/atomic_reference/delegated_update.rb

@@ -0,0 +1,28 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+
+module Concurrent
+
+  # Define update methods that delegate to @ref field
+  class Atomic
+    # Pass the current value to the given block, replacing it
+    # with the block's result. May retry if the value changes
+    # during the block's execution.
+    def update
+      true until @ref.compare_and_set(old_value = @ref.get, new_value = yield(old_value))
+      new_value
+    end
+
+    def try_update
+      old_value = @ref.get
+      new_value = yield old_value
+      unless @ref.compare_and_set(old_value, new_value)
+        if $VERBOSE
+          raise ConcurrentUpdateError, "Update failed"
+        else
+          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+        end
+      end
+      new_value
+    end
+  end
+end

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -0,0 +1,28 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+
+module Concurrent
+
+  # Define update methods that use direct paths
+  module AtomicDirectUpdate
+    # Pass the current value to the given block, replacing it
+    # with the block's result. May retry if the value changes
+    # during the block's execution.
+    def update
+      true until compare_and_set(old_value = get, new_value = yield(old_value))
+      new_value
+    end
+
+    def try_update
+      old_value = get
+      new_value = yield old_value
+      unless compare_and_set(old_value, new_value)
+        if $VERBOSE
+          raise ConcurrentUpdateError, "Update failed"
+        else
+          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+        end
+      end
+      new_value
+    end
+  end
+end

data/lib/concurrent/atomic_reference/jruby.rb

@@ -0,0 +1,8 @@
+require 'concurrent_ruby_ext'
+require 'concurrent/atomic_reference/direct_update'
+
+module Concurrent
+  class JavaAtomic
+    include Concurrent::AtomicDirectUpdate
+  end
+end

data/lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -0,0 +1,47 @@
+require 'thread'
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # Portable/generic (but not very memory or scheduling-efficient) fallback
+  class MutexAtomic #:nodoc: all
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    def initialize(value = nil)
+      @mutex = Mutex.new
+      @value = value
+    end
+
+    def get
+      @mutex.synchronize { @value }
+    end
+    alias value get
+
+    def set(new_value)
+      @mutex.synchronize { @value = new_value }
+    end
+    alias value= set
+
+    def get_and_set(new_value)
+      @mutex.synchronize do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+    alias swap get_and_set
+
+    def _compare_and_set(old_value, new_value)
+      return false unless @mutex.try_lock
+      begin
+        return false unless @value.equal? old_value
+        @value = new_value
+      ensure
+        @mutex.unlock
+      end
+      true
+    end
+  end
+end

data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -0,0 +1,24 @@
+module Concurrent
+
+  module AtomicNumericCompareAndSetWrapper
+    #alias _compare_and_set compare_and_set
+
+    def compare_and_set(expected, new)
+      if expected.kind_of? Numeric
+        while true
+          old = get
+
+          return false unless old.kind_of? Numeric
+
+          return false unless old == expected
+
+          result = _compare_and_set(old, new)
+          return result if result
+        end
+      else
+        _compare_and_set(expected, new)
+      end
+    end
+    alias compare_and_swap compare_and_set
+  end
+end

data/lib/concurrent/atomic_reference/rbx.rb

@@ -0,0 +1,16 @@
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # extend Rubinius's version adding aliases and numeric logic
+  class RbxAtomic < Rubinius::AtomicReference
+    alias _compare_and_set compare_and_set
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    alias value get
+    alias value= set
+    alias swap get_and_set
+  end
+end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -0,0 +1,16 @@
+begin
+  require 'concurrent_ruby_ext'
+rescue LoadError
+  # may be a Windows cross-compiled native gem
+  require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+end
+
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+  class CAtomic
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+  end
+end

data/lib/concurrent/atomics.rb

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

data/lib/concurrent/configuration.rb

@@ -1,6 +1,7 @@
 require 'thread'
 require 'concurrent/delay'
 require 'concurrent/errors'
+require 'concurrent/atomic'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
 require 'concurrent/utility/processor_count'
@@ -111,8 +112,12 @@ module Concurrent
   end
 
   # create the default configuration on load
-  @configuration = Configuration.new
-  singleton_class.send :attr_reader, :configuration
+  @configuration = Atomic.new Configuration.new
+
+  # @return [Configuration]
+  def self.configuration
+    @configuration.value
+  end
 
   # Perform gem-level configuration.
   #

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -172,7 +172,6 @@ module Concurrent
 
     # @!visibility private
     def shutdown_execution
-      @queue.clear
       if @pool.empty?
         stopped_event.set
       else

data/lib/concurrent/executor/{one_by_one.rb → serialized_execution.rb}

@@ -1,8 +1,10 @@
+require 'concurrent/logging'
+
 module Concurrent
 
-  # Ensures that jobs are passed to the given executors one by one,
-  # never running at the same time.
-  class OneByOne
+  # Ensures passed jobs in a serialized order never running at the same time.
+  class SerializedExecution
+    include Logging
 
     Job = Struct.new(:executor, :args, :block) do
       def call
@@ -30,10 +32,6 @@ module Concurrent
     # @raise [ArgumentError] if no task is given
     def post(executor, *args, &task)
       return nil if task.nil?
-      # FIXME Agent#send-off will blow up here
-      # if executor.can_overflow?
-      #   raise ArgumentError, 'OneByOne cannot be used in conjunction with executor which may overflow'
-      # end
 
       job = Job.new executor, args, task
 
@@ -56,7 +54,22 @@ module Concurrent
     private
 
     def call_job(job)
-      job.executor.post { work(job) }
+      did_it_run = begin
+        job.executor.post { work(job) }
+        true
+      rescue RejectedExecutionError => ex
+        false
+      end
+
+      # TODO not the best idea to run it myself
+      unless did_it_run
+        begin
+          work job
+        rescue => ex
+          # let it fail
+          log DEBUG, ex
+        end
+      end
     end
 
     # ensures next job is executed if any is stashed

data/lib/concurrent/executor/timer_set.rb

@@ -61,7 +61,12 @@ module Concurrent
 
     end
 
-    alias_method :kill, :shutdown
+    # For a timer, #kill is like an orderly shutdown, except we need to manually
+    # (and destructively) clear the queue first
+    def kill
+      @queue.clear
+      shutdown
+    end
 
     # Calculate an Epoch time with milliseconds at which to execute a
     # task. If the given time is a `Time` object it will be converted

data/lib/concurrent/executors.rb

@@ -6,4 +6,4 @@ require 'concurrent/executor/safe_task_executor'
 require 'concurrent/executor/single_thread_executor'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
-require 'concurrent/executor/one_by_one'
+require 'concurrent/executor/serialized_execution'

data/lib/concurrent/logging.rb

@@ -9,7 +9,7 @@ module Concurrent
     # @param [Integer] level one of Logger::Severity constants
     # @param [String] progname e.g. a path of an Actor
     # @param [String, nil] message when nil block is used to generate the message
-    # @yields_return [String] a message
+    # @yieldreturn [String] a message
     def log(level, progname, message = nil, &block)
       (@logger || Concurrent.configuration.logger).call level, progname, message, &block
     end

data/lib/concurrent/observable.rb

@@ -10,7 +10,7 @@ module Concurrent
       observers.add_observer(*args, &block)
     end
 
-    # as #add_observer but it can be used for chaning
+    # as #add_observer but it can be used for chaining
     # @return [Observable] self
     def with_observer(*args, &block)
       add_observer *args, &block

data/lib/concurrent/supervisor.rb

@@ -1,7 +1,6 @@
 require 'thread'
 
 require 'concurrent/errors'
-require 'concurrent/runnable'
 
 module Concurrent
 
@@ -61,6 +60,7 @@ module Concurrent
     alias_method :max_t, :max_time
 
     def initialize(opts = {})
+      warn '[EXPERIMENTAL] Supervisor is being completely rewritten and will change soon.'
       @restart_strategy = opts[:restart_strategy] || opts[:strategy] || :one_for_one
       @monitor_interval = (opts[:monitor_interval] || DEFAULT_MONITOR_INTERVAL).to_f
       @max_restart = (opts[:max_restart] || opts[:max_r] || DEFAULT_MAX_RESTART).to_i

data/lib/concurrent/timer_task.rb

@@ -4,9 +4,6 @@ require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/executor/executor'
 require 'concurrent/executor/safe_task_executor'
 
-# deprecated Updated to use `Executor` instead of `Runnable`
-require 'concurrent/runnable'
-
 module Concurrent
 
   # A very common currency pattern is to run a thread that performs a task at regular
@@ -295,32 +292,6 @@ module Concurrent
       end
     end
 
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    def terminate(*args) deprecated(:terminate, :kill, *args); end
-
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    def stop(*args) deprecated(:stop, :shutdown, *args); end
-
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    def cancel(*args) deprecated(:cancel, :shutdown, *args); end
-
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    def run!(*args) deprecated(:run!, :execute); end
-
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    def self.run!(*args, &block)
-      warn "[DEPRECATED] `run!` is deprecated, please use `execute` instead."
-      Concurrent::Runnable::Context.new(TimerTask.new(*args, &block))
-    end
-
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    def run
-      raise Concurrent::Runnable::LifecycleError.new('already running') if @running.true?
-      self.execute
-      self.wait_for_termination
-      true
-    end
-
     private :post, :<<
 
     protected
@@ -366,12 +337,5 @@ module Concurrent
         observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
       end
     end
-
-    # @deprecated Updated to use `Executor` instead of `Runnable`
-    # @!visibility private
-    def deprecated(old, new, *args)
-      warn "[DEPRECATED] `#{old}` is deprecated, please use `#{new}` instead."
-      self.send(new, *args)
-    end
   end
 end

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.6.0'
+  VERSION = '0.7.0.rc0'
 end

data/lib/concurrent.rb

@@ -1,13 +1,15 @@
 require 'concurrent/version'
+
 require 'concurrent/configuration'
 
 require 'concurrent/atomics'
-require 'concurrent/actors'
 require 'concurrent/channels'
 require 'concurrent/collections'
 require 'concurrent/executors'
 require 'concurrent/utilities'
 
+require 'concurrent/actress'
+require 'concurrent/atomic'
 require 'concurrent/agent'
 require 'concurrent/async'
 require 'concurrent/dataflow'
@@ -22,13 +24,10 @@ require 'concurrent/obligation'
 require 'concurrent/observable'
 require 'concurrent/options_parser'
 require 'concurrent/promise'
-require 'concurrent/runnable'
 require 'concurrent/scheduled_task'
-require 'concurrent/stoppable'
 require 'concurrent/supervisor'
 require 'concurrent/timer_task'
 require 'concurrent/tvar'
-require 'concurrent/actress'
 
 # Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
 # F#, C#, Java, and classic concurrency patterns.

data/lib/extension_helper.rb

@@ -0,0 +1,9 @@
+require 'rbconfig'
+
+module Concurrent
+  def self.use_c_extensions?
+    host_os = RbConfig::CONFIG['host_os']
+    ruby_name = RbConfig::CONFIG['ruby_install_name']
+    (ruby_name =~ /^ruby$/i || host_os =~ /mswin32/i || host_os =~ /mingw32/i)
+  end
+end