concurrent-ruby 1.0.0.pre1 → 1.0.0.pre2

data/lib/concurrent/synchronization/rbx_lockable_object.rb

@@ -0,0 +1,64 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class RbxLockableObject < AbstractLockableObject
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__Waiters__ = []
+        @__owner__   = nil
+      end
+
+      protected
+
+      def synchronize(&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
+          Rubinius.unlock(self)
+          signaled = wchan.receive_timeout timeout
+        ensure
+          Rubinius.lock(self)
+
+          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?
+          end
+        end
+
+        self
+      end
+
+      def ns_signal
+        @__Waiters__.shift << true unless @__Waiters__.empty?
+        self
+      end
+
+      def ns_broadcast
+        @__Waiters__.shift << true until @__Waiters__.empty?
+        self
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/rbx_object.rb

@@ -1,74 +1,23 @@
 module Concurrent
   module Synchronization
 
-    if Concurrent.on_rbx?
 
-      # @!visibility private
-      # @!macro internal_implementation_note
-      class RbxObject < AbstractObject
-        def initialize
-          @__Waiters__ = []
-          @__owner__   = nil
-          ensure_ivar_visibility!
-        end
-
-        protected
-
-        def synchronize(&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
-            Rubinius.unlock(self)
-            signaled = wchan.receive_timeout timeout
-          ensure
-            Rubinius.lock(self)
-
-            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?
-            end
-          end
-
-          self
-        end
-
-        def ns_signal
-          @__Waiters__.shift << true unless @__Waiters__.empty?
-          self
-        end
-
-        def ns_broadcast
-          @__Waiters__.shift << true until @__Waiters__.empty?
-          self
-        end
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class RbxObject < AbstractObject
+      def initialize
+        # nothing to do
+      end
 
-        def ensure_ivar_visibility!
-          # Rubinius instance variables are not volatile so we need to insert barrier
-          Rubinius.memory_barrier
-        end
+      def full_memory_barrier
+        # Rubinius instance variables are not volatile so we need to insert barrier
+        Rubinius.memory_barrier
+      end
 
-        def self.attr_volatile *names
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def self.attr_volatile *names
+        names.each do |name|
+          ivar = :"@volatile_#{name}"
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}
               Rubinius.memory_barrier
               #{ivar}
@@ -78,11 +27,11 @@ module Concurrent
               #{ivar} = value
               Rubinius.memory_barrier
             end
-            RUBY
-          end
-          names.map { |n| [n, :"#{n}="] }.flatten
+          RUBY
         end
+        names.map { |n| [n, :"#{n}="] }.flatten
       end
     end
+
   end
 end

data/lib/concurrent/thread_safe/util.rb

@@ -12,12 +12,3 @@ module Concurrent
     end
   end
 end
-
-require 'concurrent/tuple'
-require 'concurrent/thread_safe/util/xor_shift_random'
-require 'concurrent/thread_safe/util/volatile'
-require 'concurrent/thread_safe/util/striped64'
-require 'concurrent/thread_safe/util/adder'
-require 'concurrent/thread_safe/util/cheap_lockable'
-require 'concurrent/thread_safe/util/power_of_two_tuple'
-require 'concurrent/thread_safe/util/array_hash_rbx'

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

@@ -1,3 +1,6 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/thread_safe/util/striped64'
+
 module Concurrent
 
   # @!visibility private

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

@@ -1,3 +1,5 @@
+require 'concurrent/thread_safe/util'
+
 module Concurrent
   module ThreadSafe
     module Util
@@ -25,4 +27,4 @@ module Concurrent
       end
     end
   end
-end
+end

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

@@ -1,3 +1,6 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/thread_safe/util/volatile'
+
 module Concurrent
 
   # @!visibility private

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

@@ -1,3 +1,4 @@
+require 'concurrent/thread_safe/util'
 require 'concurrent/tuple'
 
 module Concurrent

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

@@ -1,3 +1,8 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/thread_safe/util/power_of_two_tuple'
+require 'concurrent/thread_safe/util/volatile'
+require 'concurrent/thread_safe/util/xor_shift_random'
+
 module Concurrent
 
   # @!visibility private
@@ -83,7 +88,7 @@ module Concurrent
 
           # TODO: this only adds padding after the :value slot, need to find a way to add padding before the slot
           # @!visibility private
-          attr_reader *(Array.new(12).map {|i| :"padding_#{i}"})
+          attr_reader *(12.times.collect{ |i| "padding_#{i}".to_sym })
 
           alias_method :cas, :compare_and_set
 

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

@@ -1,3 +1,5 @@
+require 'concurrent/thread_safe/util'
+
 module Concurrent
 
   # @!visibility private

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

@@ -1,3 +1,5 @@
+require 'concurrent/thread_safe/util'
+
 module Concurrent
 
   # @!visibility private

data/lib/concurrent/tvar.rb

@@ -1,10 +1,46 @@
 require 'set'
 
+# @!macro [new] thread_safe_variable_comparison
+#
+#   ## Thread-safe Variable Classes
+#
+#   Each of the thread-safe variable classes is designed to solve a different
+#   problem. In general:
+#
+#   * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#     uncoordinated, *asynchronous* change of individual values. Best used when
+#     the value will undergo frequent, complex updates. Suitable when the result
+#     of an update does not need to be known immediately.
+#   * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#     uncoordinated, *synchronous* change of individual values. Best used when
+#     the value will undergo frequent reads but only occasional, though complex,
+#     updates. Suitable when the result of an update must be known immediately.
+#   * *{Concurrent::AtomicReference}:* A simple object reference that can be
+#     atomically. Updates are synchronous but fast. Bast used when updates a
+#     simple set operations. Not suitable when updates are complex.
+#     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#     but optimized for the given data type.
+#   * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#     when two or more threads need to exchange data. The threads will pair then
+#     block on each other until the exchange is complete.
+#   * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#     must give a value to another, which must take the value. The threads will
+#     block on each other until the exchange is complete.
+#   * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#     holds a different value for each thread which has access. Often used as
+#     an instance variable in objects which must maintain different state
+#     for different threads.
+#   * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#     *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#     value must change together, in an all-or-nothing transaction.
+
 module Concurrent
 
   # A `TVar` is a transactional variable - a single-element container that
   # is used as part of a transaction - see `Concurrent::atomically`.
   #
+  # @!macro thread_safe_variable_comparison
+  #
   # {include:file:doc/tvar.md}
   class TVar
 

data/lib/concurrent/utility/at_exit.rb

@@ -7,7 +7,7 @@ module Concurrent
   # Each handler is executed at most once.
   #
   # @!visibility private
-  class AtExitImplementation < Synchronization::Object
+  class AtExitImplementation < Synchronization::LockableObject
     include Logger::Severity
 
     def initialize(*args)

data/lib/concurrent/utility/monotonic_time.rb

@@ -2,11 +2,10 @@ require 'concurrent/synchronization'
 
 module Concurrent
 
-  class_definition = Class.new(Synchronization::Object) do
+  class_definition = Class.new(Synchronization::LockableObject) do
     def initialize
-      super()
       @last_time = Time.now.to_f
-      ensure_ivar_visibility!
+      super()
     end
 
     if defined?(Process::CLOCK_MONOTONIC)
@@ -44,7 +43,7 @@ module Concurrent
   private_constant :GLOBAL_MONOTONIC_CLOCK
 
   # @!macro [attach] monotonic_get_time
-  # 
+  #
   #   Returns the current time a tracked by the application monotonic clock.
   #
   #   @return [Float] The current monotonic time when `since` not given else

data/lib/concurrent/utility/native_extension_loader.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization/abstract_object' # for JRuby
+require 'concurrent/synchronization' # has to be loaded before JRuby extensions
 require 'concurrent/utility/engine'
 
 module Concurrent

data/lib/concurrent/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre1
+  version: 1.0.0.pre2
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-19 00:00:00.000000000 Z
+date: 2015-09-19 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -28,6 +28,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/concurrent.rb
+- lib/concurrent/agent.rb
 - lib/concurrent/array.rb
 - lib/concurrent/async.rb
 - lib/concurrent/atom.rb
@@ -79,7 +80,6 @@ files:
 - 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
@@ -108,18 +108,23 @@ files:
 - lib/concurrent/maybe.rb
 - lib/concurrent/mutable_struct.rb
 - lib/concurrent/mvar.rb
+- lib/concurrent/options.rb
 - lib/concurrent/promise.rb
 - lib/concurrent/scheduled_task.rb
 - lib/concurrent/settable_struct.rb
 - lib/concurrent/synchronization.rb
+- lib/concurrent/synchronization/abstract_lockable_object.rb
 - lib/concurrent/synchronization/abstract_object.rb
 - lib/concurrent/synchronization/abstract_struct.rb
 - lib/concurrent/synchronization/condition.rb
-- lib/concurrent/synchronization/java_object.rb
+- lib/concurrent/synchronization/jruby_lockable_object.rb
+- lib/concurrent/synchronization/jruby_object.rb
 - lib/concurrent/synchronization/lock.rb
-- lib/concurrent/synchronization/monitor_object.rb
-- lib/concurrent/synchronization/mutex_object.rb
+- lib/concurrent/synchronization/lockable_object.rb
+- lib/concurrent/synchronization/mri_lockable_object.rb
+- lib/concurrent/synchronization/mri_object.rb
 - lib/concurrent/synchronization/object.rb
+- lib/concurrent/synchronization/rbx_lockable_object.rb
 - lib/concurrent/synchronization/rbx_object.rb
 - lib/concurrent/thread_safe/synchronized_delegator.rb
 - lib/concurrent/thread_safe/util.rb
@@ -159,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,

data/lib/concurrent/synchronization/monitor_object.rb

@@ -1,27 +0,0 @@
-require 'monitor'
-require 'concurrent/synchronization/mutex_object'
-
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class MonitorObject < MutexObject
-      def initialize
-        @__lock__      = ::Monitor.new
-        @__condition__ = @__lock__.new_cond
-      end
-
-      protected
-
-      def synchronize
-        @__lock__.synchronize { yield }
-      end
-
-      def ns_wait(timeout = nil)
-        @__condition__.wait timeout
-        self
-      end
-    end
-  end
-end

data/lib/concurrent/synchronization/mutex_object.rb

@@ -1,43 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class MutexObject < AbstractObject
-      def initialize
-        @__lock__      = ::Mutex.new
-        @__condition__ = ::ConditionVariable.new
-      end
-
-      protected
-
-      def synchronize
-        if @__lock__.owned?
-          yield
-        else
-          @__lock__.synchronize { yield }
-        end
-      end
-
-      def ns_signal
-        @__condition__.signal
-        self
-      end
-
-      def ns_broadcast
-        @__condition__.broadcast
-        self
-      end
-
-      def ns_wait(timeout = nil)
-        @__condition__.wait @__lock__, timeout
-        self
-      end
-
-      def ensure_ivar_visibility!
-        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
-        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
-      end
-    end
-  end
-end