concurrent-ruby 0.9.2 → 1.0.0.pre1

data/lib/concurrent/thread_safe/util/volatile.rb

@@ -0,0 +1,73 @@
+module Concurrent
+
+  # @!visibility private
+  module ThreadSafe
+
+    # @!visibility private
+    module Util
+      
+      # @!visibility private
+      module Volatile
+
+        # Provides +volatile+ (in the JVM's sense) attribute accessors implemented
+        # atop of +Concurrent::AtomicReference+.
+        #
+        # Usage:
+        #   class Foo
+        #     extend Concurrent::ThreadSafe::Util::Volatile
+        #     attr_volatile :foo, :bar
+        #
+        #     def initialize(bar)
+        #       super() # must super() into parent initializers before using the volatile attribute accessors
+        #       self.bar = bar
+        #     end
+        #
+        #     def hello
+        #       my_foo = foo # volatile read
+        #       self.foo = 1 # volatile write
+        #       cas_foo(1, 2) # => true | a strong CAS
+        #     end
+        #   end
+        def attr_volatile(*attr_names)
+          return if attr_names.empty?
+          include(Module.new do
+            atomic_ref_setup = attr_names.map {|attr_name| "@__#{attr_name} = Concurrent::AtomicReference.new"}
+            initialize_copy_setup = attr_names.zip(atomic_ref_setup).map do |attr_name, ref_setup|
+              "#{ref_setup}(other.instance_variable_get(:@__#{attr_name}).get)"
+            end
+            class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            def initialize(*)
+              super
+            #{atomic_ref_setup.join('; ')}
+            end
+
+            def initialize_copy(other)
+              super
+            #{initialize_copy_setup.join('; ')}
+            end
+            RUBY_EVAL
+
+            attr_names.each do |attr_name|
+              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+              def #{attr_name}
+                @__#{attr_name}.get
+              end
+
+              def #{attr_name}=(value)
+                @__#{attr_name}.set(value)
+              end
+
+              def compare_and_set_#{attr_name}(old_value, new_value)
+                @__#{attr_name}.compare_and_set(old_value, new_value)
+              end
+              RUBY_EVAL
+
+              alias_method :"cas_#{attr_name}", :"compare_and_set_#{attr_name}"
+              alias_method :"lazy_set_#{attr_name}", :"#{attr_name}="
+            end
+          end)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/thread_safe/util/xor_shift_random.rb

@@ -0,0 +1,48 @@
+module Concurrent
+
+  # @!visibility private
+  module ThreadSafe
+
+    # @!visibility private
+    module Util
+
+      # A xorshift random number (positive +Fixnum+s) generator, provides
+      # reasonably cheap way to generate thread local random numbers without
+      # contending for the global +Kernel.rand+.
+      #
+      # Usage:
+      #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
+      #   while true
+      #     if (x = XorShiftRandom.xorshift).odd? # thread-localy generate a next random number
+      #       do_something_at_random
+      #     end
+      #   end
+      module XorShiftRandom
+        extend self
+        MAX_XOR_SHIFTABLE_INT = MAX_INT - 1
+
+        # Generates an initial non-zero positive +Fixnum+ via +Kernel.rand+.
+        def get
+          Kernel.rand(MAX_XOR_SHIFTABLE_INT) + 1 # 0 can't be xorshifted
+        end
+
+        # xorshift based on: http://www.jstatsoft.org/v08/i14/paper
+        if 0.size == 4
+          # using the "yˆ=y>>a; yˆ=y<<b; yˆ=y>>c;" transform with the (a,b,c) tuple with values (3,1,14) to minimise Bignum overflows
+          def xorshift(x)
+            x ^= x >> 3
+            x ^= (x << 1) & MAX_INT # cut-off Bignum overflow
+            x ^= x >> 14
+          end
+        else
+          # using the "yˆ=y>>a; yˆ=y<<b; yˆ=y>>c;" transform with the (a,b,c) tuple with values (1,1,54) to minimise Bignum overflows
+          def xorshift(x)
+            x ^= x >> 1
+            x ^= (x << 1) & MAX_INT # cut-off Bignum overflow
+            x ^= x >> 54
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/timer_task.rb

@@ -268,7 +268,7 @@ module Concurrent
 
     private :post, :<<
 
-    protected
+    private
 
     def ns_initialize(opts, &task)
       init_mutex(self)
@@ -284,13 +284,13 @@ module Concurrent
     end
 
     # @!visibility private
-    def shutdown_execution
+    def ns_shutdown_execution
       @running.make_false
       super
     end
 
     # @!visibility private
-    def kill_execution
+    def ns_kill_execution
       @running.make_false
       super
     end

data/lib/concurrent/tuple.rb

@@ -0,0 +1,86 @@
+require 'concurrent/atomic/atomic_reference'
+
+module Concurrent
+
+  # A fixed size array with volatile (synchronized, thread safe) getters/setters.
+  # Mixes in Ruby's `Enumerable` module for enhanced search, sort, and traversal.
+  #
+  # @example
+  #   tuple = Concurrent::Tuple.new(16)
+  #
+  #   tuple.set(0, :foo)                   #=> :foo  | volatile write
+  #   tuple.get(0)                         #=> :foo  | volatile read
+  #   tuple.compare_and_set(0, :foo, :bar) #=> true  | strong CAS
+  #   tuple.cas(0, :foo, :baz)             #=> false | strong CAS
+  #   tuple.get(0)                         #=> :bar  | volatile read
+  #
+  # @see https://en.wikipedia.org/wiki/Tuple Tuple entry at Wikipedia
+  # @see http://www.erlang.org/doc/reference_manual/data_types.html#id70396 Erlang Tuple
+  # @see http://ruby-doc.org/core-2.2.2/Enumerable.html Enumerable
+  class Tuple
+    include Enumerable
+
+    # The (fixed) size of the tuple.
+    attr_reader :size
+
+    # @!visibility private
+    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : Array
+    private_constant :Tuple
+
+    # Create a new tuple of the given size.
+    #
+    # @param [Integer] size the number of elements in the tuple
+    def initialize(size)
+      @size = size
+      @tuple = tuple = Tuple.new(size)
+      i = 0
+      while i < size
+        tuple[i] = Concurrent::AtomicReference.new
+        i += 1
+      end
+    end
+
+    # Get the value of the element at the given index.
+    #
+    # @param [Integer] i the index from which to retrieve the value
+    # @return [Object] the value at the given index or nil if the index is out of bounds
+    def get(i)
+      return nil if i >= @size || i < 0
+      @tuple[i].get
+    end
+    alias_method :volatile_get, :get
+
+    # Set the element at the given index to the given value
+    #
+    # @param [Integer] i the index for the element to set
+    # @param [Object] value the value to set at the given index
+    #
+    # @return [Object] the new value of the element at the given index or nil if the index is out of bounds
+    def set(i, value)
+      return nil if i >= @size || i < 0
+      @tuple[i].set(value)
+    end
+    alias_method :volatile_set, :set
+
+    # Set the value at the given index to the new value if and only if the current
+    # value matches the given old value.
+    #
+    # @param [Integer] i the index for the element to set
+    # @param [Object] old_value the value to compare against the current value
+    # @param [Object] new_value the value to set at the given index
+    #
+    # @return [Boolean] true if the value at the given element was set else false
+    def compare_and_set(i, old_value, new_value)
+      return false if i >= @size || i < 0
+      @tuple[i].compare_and_set(old_value, new_value)
+    end
+    alias_method :cas, :compare_and_set
+
+    # Calls the given block once for each element in self, passing that element as a parameter.
+    #
+    # @yieldparam [Object] ref the `Concurrent::AtomicReference` object at the current index
+    def each
+      @tuple.each {|ref| yield ref.get}
+    end
+  end
+end

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '0.9.2'
-  EDGE_VERSION = '0.1.2'
+  VERSION      = '1.0.0.pre1'
+  EDGE_VERSION = '0.2.0.pre1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 1.0.0.pre1
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2015-08-19 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -28,17 +28,25 @@ files:
 - LICENSE.txt
 - README.md
 - lib/concurrent.rb
+- lib/concurrent/array.rb
 - lib/concurrent/async.rb
 - lib/concurrent/atom.rb
+- lib/concurrent/atomic/abstract_thread_local_var.rb
 - lib/concurrent/atomic/atomic_boolean.rb
 - lib/concurrent/atomic/atomic_fixnum.rb
 - lib/concurrent/atomic/atomic_reference.rb
-- lib/concurrent/atomic/condition.rb
 - lib/concurrent/atomic/count_down_latch.rb
 - lib/concurrent/atomic/cyclic_barrier.rb
 - lib/concurrent/atomic/event.rb
+- lib/concurrent/atomic/java_count_down_latch.rb
+- lib/concurrent/atomic/java_thread_local_var.rb
+- lib/concurrent/atomic/mutex_atomic_boolean.rb
+- lib/concurrent/atomic/mutex_atomic_fixnum.rb
+- lib/concurrent/atomic/mutex_count_down_latch.rb
+- lib/concurrent/atomic/mutex_semaphore.rb
 - lib/concurrent/atomic/read_write_lock.rb
 - lib/concurrent/atomic/reentrant_read_write_lock.rb
+- lib/concurrent/atomic/ruby_thread_local_var.rb
 - lib/concurrent/atomic/semaphore.rb
 - lib/concurrent/atomic/thread_local_var.rb
 - lib/concurrent/atomic_reference/concurrent_update_error.rb
@@ -51,7 +59,13 @@ files:
 - lib/concurrent/atomics.rb
 - lib/concurrent/collection/copy_on_notify_observer_set.rb
 - lib/concurrent/collection/copy_on_write_observer_set.rb
-- lib/concurrent/collection/priority_queue.rb
+- lib/concurrent/collection/java_non_concurrent_priority_queue.rb
+- lib/concurrent/collection/map/atomic_reference_map_backend.rb
+- lib/concurrent/collection/map/mri_map_backend.rb
+- lib/concurrent/collection/map/non_concurrent_map_backend.rb
+- lib/concurrent/collection/map/synchronized_map_backend.rb
+- lib/concurrent/collection/non_concurrent_priority_queue.rb
+- lib/concurrent/collection/ruby_non_concurrent_priority_queue.rb
 - lib/concurrent/concern/deprecation.rb
 - lib/concurrent/concern/dereferenceable.rb
 - lib/concurrent/concern/logging.rb
@@ -63,27 +77,34 @@ files:
 - lib/concurrent/edge.rb
 - lib/concurrent/errors.rb
 - lib/concurrent/exchanger.rb
+- lib/concurrent/executor/abstract_executor_service.rb
 - lib/concurrent/executor/cached_thread_pool.rb
 - lib/concurrent/executor/executor.rb
 - lib/concurrent/executor/executor_service.rb
 - lib/concurrent/executor/fixed_thread_pool.rb
 - lib/concurrent/executor/immediate_executor.rb
 - lib/concurrent/executor/indirect_immediate_executor.rb
+- lib/concurrent/executor/java_executor_service.rb
 - lib/concurrent/executor/java_single_thread_executor.rb
 - lib/concurrent/executor/java_thread_pool_executor.rb
+- lib/concurrent/executor/ruby_executor_service.rb
 - lib/concurrent/executor/ruby_single_thread_executor.rb
 - lib/concurrent/executor/ruby_thread_pool_executor.rb
 - lib/concurrent/executor/safe_task_executor.rb
+- lib/concurrent/executor/serial_executor_service.rb
 - lib/concurrent/executor/serialized_execution.rb
+- lib/concurrent/executor/serialized_execution_delegator.rb
 - lib/concurrent/executor/simple_executor_service.rb
 - lib/concurrent/executor/single_thread_executor.rb
 - lib/concurrent/executor/thread_pool_executor.rb
 - lib/concurrent/executor/timer_set.rb
 - lib/concurrent/executors.rb
 - lib/concurrent/future.rb
+- lib/concurrent/hash.rb
 - lib/concurrent/immutable_struct.rb
 - lib/concurrent/ivar.rb
 - lib/concurrent/lazy_register.rb
+- lib/concurrent/map.rb
 - lib/concurrent/maybe.rb
 - lib/concurrent/mutable_struct.rb
 - lib/concurrent/mvar.rb
@@ -100,18 +121,24 @@ files:
 - lib/concurrent/synchronization/mutex_object.rb
 - lib/concurrent/synchronization/object.rb
 - lib/concurrent/synchronization/rbx_object.rb
+- lib/concurrent/thread_safe/synchronized_delegator.rb
+- lib/concurrent/thread_safe/util.rb
+- lib/concurrent/thread_safe/util/adder.rb
+- lib/concurrent/thread_safe/util/array_hash_rbx.rb
+- lib/concurrent/thread_safe/util/cheap_lockable.rb
+- lib/concurrent/thread_safe/util/power_of_two_tuple.rb
+- lib/concurrent/thread_safe/util/striped64.rb
+- lib/concurrent/thread_safe/util/volatile.rb
+- lib/concurrent/thread_safe/util/xor_shift_random.rb
 - lib/concurrent/timer_task.rb
+- lib/concurrent/tuple.rb
 - lib/concurrent/tvar.rb
-- lib/concurrent/utilities.rb
 - lib/concurrent/utility/at_exit.rb
 - lib/concurrent/utility/engine.rb
 - lib/concurrent/utility/monotonic_time.rb
 - lib/concurrent/utility/native_extension_loader.rb
 - lib/concurrent/utility/processor_counter.rb
-- lib/concurrent/utility/timeout.rb
-- lib/concurrent/utility/timer.rb
 - lib/concurrent/version.rb
-- lib/concurrent_ruby.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
 - MIT
@@ -127,9 +154,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.8

data/lib/concurrent/atomic/condition.rb

@@ -1,78 +0,0 @@
-require 'concurrent/utility/monotonic_time'
-require 'concurrent/concern/deprecation'
-
-module Concurrent
-
-  # Condition is a better implementation of standard Ruby ConditionVariable. The
-  # biggest difference is the wait return value: Condition#wait returns
-  # Condition::Result which make possible to know if waiting thread has been
-  # woken up by an another thread (using #signal or #broadcast) or due to
-  # timeout.
-  #
-  # Every #wait must be guarded by a locked Mutex or a ThreadError will be
-  # risen. Although it's not mandatory, it's recommended to call also #signal
-  # and #broadcast within the same mutex
-  #
-  # @deprecated
-  class Condition
-    include Concern::Deprecation
-
-    class Result
-      def initialize(remaining_time)
-        @remaining_time = remaining_time
-      end
-
-      attr_reader :remaining_time
-
-      # @return [Boolean] true if current thread has been waken up by a #signal
-      #  or a #broadcast call , otherwise false
-      def woken_up?
-        @remaining_time.nil? || @remaining_time > 0
-      end
-
-      # @return [Boolean] true if current thread has been waken up due to a
-      #   timeout, otherwise false
-      def timed_out?
-        @remaining_time != nil && @remaining_time <= 0
-      end
-
-      alias_method :can_wait?, :woken_up?
-
-    end
-
-    def initialize
-      deprecated 'Will be replaced with Synchronization::Object in v1.0.'
-      @condition = ConditionVariable.new
-    end
-
-    # @param [Mutex] mutex the locked mutex guarding the wait
-    # @param [Object] timeout nil means no timeout
-    # @return [Result]
-    #
-    # @!macro monotonic_clock_warning
-    def wait(mutex, timeout = nil)
-      start_time = Concurrent.monotonic_time
-      @condition.wait(mutex, timeout)
-
-      if timeout.nil?
-        Result.new(nil)
-      else
-        Result.new(start_time + timeout - Concurrent.monotonic_time)
-      end
-    end
-
-    # Wakes up a waiting thread
-    # @return [true]
-    def signal
-      @condition.signal
-      true
-    end
-
-    # Wakes up all waiting threads
-    # @return [true]
-    def broadcast
-      @condition.broadcast
-      true
-    end
-  end
-end