concurrent-ruby-edge 0.2.0.pre1 → 0.2.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09cfa6d29b8c6ad451d4d5805fe16ff7fe490703
-  data.tar.gz: 721b15c9fa7a8c38e88c9d5f1e8597e0528386c6
+  metadata.gz: c02c328ebe5aaf45aaf86106223e979107a4ea99
+  data.tar.gz: 425af0cce7f688a07e0546922c916877c2b4277a
 SHA512:
-  metadata.gz: ce588f1344ce16ab7c0d166bdc1f5c86c02c908083d7fcc10c7ead35a665af4325c1e9ccabfc925f289fdb15db1d68a4fff621d67b921b6b75f6115fc4ffc22b
-  data.tar.gz: 479a2bb45adde98a74aa5ced4fea11d1112ccedb64d07e5dc5783d07cf750d905888effd97d8108b3dc2b928f394055423aa5bc6b8343bc26647b62bf4422300
+  metadata.gz: 877ef401c5cb31943832dd1a27f592e65b261608744b1d1b00e0210f82d9ae7d246fd3d224a78cbe64aa1533cf88b5c77338985bcaf7a29a8ceb7f29174bbb32
+  data.tar.gz: d3aa66b036246d9af5f5ba0fff8ec7b46943a7c5d8fcbfcf52e4166c40a9b3fd1a80e335aaea539a756f21210a12ccd981243409d94a99fb9c4c874fe31d74bb

data/README.md

@@ -61,7 +61,7 @@ This library contains a variety of concurrency abstractions at high and low leve
 
 #### General-purpose Concurrency Abstractions
 
-* [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
+* [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to a class. Loosely based on Erlang's [gen_server](http://www.erlang.org/doc/man/gen_server.html).
 * [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
   * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#dataflow-class_method): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
 * [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
@@ -79,11 +79,9 @@ Collection classes that were originally part of the (deprecated) `thread_safe` g
 
 Value objects inspired by other languages:
 
-* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
 * [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Maybe.html) A thread-safe, immutable object representing an optional value, based on
   [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
-* [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html) Lazy evaluation of a block yielding an immutable result. Based on Clojure's
-   [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
+* [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html) Lazy evaluation of a block yielding an immutable result. Based on Clojure's [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
 
 Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
 
@@ -93,10 +91,15 @@ Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/St
 
 Thread-safe variables:
 
+* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A way to manage shared, mutable, *asynchronous*, independent, state. Based on Clojure's [Agent](http://clojure.org/agents).
+* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, mutable, *synchronous*, independent state. Based on Clojure's [Atom](http://clojure.org/atoms).
 * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html) A boolean value that can be updated atomically.
 * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.
 * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html) An object reference that may be updated atomically.
+* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html) A synchronization point at which threads can pair and swap elements within pairs. Based on Java's [Exchanger](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html).
+* [MVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) A synchronized single element container. Based on Haskell's [MVar](https://hackage.haskell.org/package/base-4.8.1.0/docs/Control-Concurrent-MVar.html) and Scala's [MVar](http://docs.typelevel.org/api/scalaz/nightly/index.html#scalaz.concurrent.MVar$).
 * [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html) A variable where the value is different for each thread.
+* [TVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) A transactional variable implementing software transactional memory (STM). Based on Clojure's [Ref](http://clojure.org/refs).
 
 #### Java-inspired ThreadPools and Other Executors
 
@@ -104,16 +107,13 @@ Thread-safe variables:
 
 #### Thread Synchronization Classes and Algorithms
 
-* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html) A synchronization object that allows one thread to wait on multiple other threads.
+* [CountDownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html) A synchronization object that allows one thread to wait on multiple other threads.
 * [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html) A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
 * [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html) Old school kernel-style event.
-* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
-* [I-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar) Similar to a "future" but can be manually assigned once, after which it becomes immutable.
-* [M-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar) A synchronized single element container.
+* [IVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) Similar to a "future" but can be manually assigned once, after which it becomes immutable.
 * [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html) A lock that supports multiple readers but only one writer.
 * [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html) A read/write lock with reentrant and upgrade features.
 * [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html) A counting-based locking mechanism that uses permits.
-* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar) A transactional variable - a single-element container that is used as part of a transaction.
 
 ### Edge Features
 
@@ -125,12 +125,11 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 
 * [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
   Implements the Actor Model, where concurrent actors exchange messages.
-* [new Future Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/FutureShortcuts.html) - new
-  unified implementation of Futures and Promises which combines Features of previous `Future`,
-  `Promise`, `IVar`, `Event`, `Probe`, `dataflow`, `Delay`, `TimerTask` into single framework. It uses extensively
-  new synchronization layer to make all the features **non-blocking** and **lock-free** with exception of obviously blocking
+* [New Future Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/FutureShortcuts.html):
+  Unified implementation of futures and promises which combines features of previous `Future`,
+  `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and `TimerTask` into a single framework. It extensively uses the
+  new synchronization layer to make all the features **non-blocking** and **lock-free**, with the exception of obviously blocking
   operations like `#wait`, `#value`. It also offers better performance.
-* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
 * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html):
   Communicating Sequential Processes (CSP).
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
@@ -142,12 +141,11 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 
 *Why are these not in core?*
 
-- **Actor** - Partial documentation and tests; stability is good.
+- **Actor** - Partial documentation and tests; depends on new future/promise framework; stability is good.
 - **Future/Promise Framework** - API changes; partial documentation and tests; stability good.
-- **Agent** - Incomplete behaviour compared to Clojure's models; stability good.
-- **Channel** - Missing documentation; limted features; stability good.
+- **Channel** - Missing documentation; limited features; stability good.
 - **LazyRegister** - Missing documentation and tests.
-- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Needs real world battle testing
+- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing
 
 ## Usage
 

data/lib/concurrent/actor/context.rb

@@ -15,7 +15,7 @@ module Concurrent
     #     > {include:Actor::RestartingContext}
     #
     # Example of ac actor definition:
-    # 
+    #
     # {include:file:doc/actor/define.out.rb}
     #
     # See methods of {AbstractContext} what else can be tweaked, e.g {AbstractContext#default_reference_class}

data/lib/concurrent/actor/core.rb

@@ -10,7 +10,7 @@ module Concurrent
     # @note Whole class should be considered private. An user should use {Context}s and {Reference}s only.
     # @note devel: core should not block on anything, e.g. it cannot wait on children to terminate
     #   that would eat up all threads in task pool and deadlock
-    class Core < Synchronization::Object
+    class Core < Synchronization::LockableObject
       include TypeCheck
       include Concern::Logging
 

data/lib/concurrent/channel/blocking_ring_buffer.rb

@@ -5,7 +5,7 @@ module Concurrent
 
     # @api Channel
     # @!macro edge_warning
-    class BlockingRingBuffer < Synchronization::Object
+    class BlockingRingBuffer < Synchronization::LockableObject
 
       def initialize(capacity)
         super()

data/lib/concurrent/channel/buffered_channel.rb

@@ -6,7 +6,7 @@ module Concurrent
 
     # @api Channel
     # @!macro edge_warning
-    class BufferedChannel < Synchronization::Object
+    class BufferedChannel < Synchronization::LockableObject
 
       def initialize(size)
         super()
@@ -14,7 +14,7 @@ module Concurrent
       end
 
       def probe_set_size
-        @probe_set.size
+        @probe_set.size # TODO (pitr 12-Sep-2015): unsafe?
       end
 
       def buffer_queue_size

data/lib/concurrent/channel/waitable_list.rb

@@ -5,7 +5,7 @@ module Concurrent
 
     # @api Channel
     # @!macro edge_warning
-    class WaitableList < Synchronization::Object
+    class WaitableList < Synchronization::LockableObject
 
       def initialize
         super()

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -11,11 +11,11 @@ module Concurrent
     #   @api Edge
     class AtomicMarkableReference < ::Concurrent::Synchronization::Object
 
+      private *attr_volatile_with_cas(:reference)
+
       # @!macro [attach] atomic_markable_reference_method_initialize
       def initialize(value = nil, mark = false)
-        super()
-        @Reference = AtomicReference.new ImmutableArray[value, mark]
-        ensure_ivar_visibility!
+        super(ImmutableArray[value, mark]) # ensures visibility
       end
 
       # @!macro [attach] atomic_markable_reference_method_compare_and_set
@@ -36,7 +36,7 @@ module Concurrent
       def compare_and_set(expected_val, new_val, expected_mark, new_mark)
         # Memoize a valid reference to the current AtomicReference for
         # later comparison.
-        current = @Reference.get
+        current = reference
         curr_val, curr_mark = current
 
         # Ensure that that the expected marks match.
@@ -56,7 +56,7 @@ module Concurrent
 
         prospect = ImmutableArray[new_val, new_mark]
 
-        @Reference.compare_and_set current, prospect
+        compare_and_set_reference current, prospect
       end
       alias_method :compare_and_swap, :compare_and_set
 
@@ -66,7 +66,7 @@ module Concurrent
       #
       #   @return [ImmutableArray] the current reference and marked values
       def get
-        @Reference.get
+        reference
       end
 
       # @!macro [attach] atomic_markable_reference_method_value
@@ -75,7 +75,7 @@ module Concurrent
       #
       #   @return [Object] the current value of the reference
       def value
-        @Reference.get[0]
+        reference[0]
       end
 
       # @!macro [attach] atomic_markable_reference_method_mark
@@ -84,7 +84,7 @@ module Concurrent
       #
       #   @return [Boolean] the current marked value
       def mark
-        @Reference.get[1]
+        reference[1]
       end
       alias_method :marked?, :mark
 
@@ -98,7 +98,7 @@ module Concurrent
       #
       #   @return [ImmutableArray] both the new value and the new mark
       def set(new_val, new_mark)
-        @Reference.set ImmutableArray[new_val, new_mark]
+        self.reference = ImmutableArray[new_val, new_mark]
       end
 
       # @!macro [attach] atomic_markable_reference_method_update
@@ -115,7 +115,7 @@ module Concurrent
       # @return [ImmutableArray] the new value and new mark
       def update
         loop do
-          old_val, old_mark = @Reference.get
+          old_val, old_mark = reference
           new_val, new_mark = yield old_val, old_mark
 
           if compare_and_set old_val, new_val, old_mark, new_mark
@@ -139,7 +139,7 @@ module Concurrent
       #
       # @raise [Concurrent::ConcurrentUpdateError] if the update fails
       def try_update!
-        old_val, old_mark = @Reference.get
+        old_val, old_mark = reference
         new_val, new_mark = yield old_val, old_mark
 
         unless compare_and_set old_val, new_val, old_mark, new_mark
@@ -165,7 +165,7 @@ module Concurrent
       # @return [ImmutableArray] the new value and marked state, or nil if
       # the update failed
       def try_update
-        old_val, old_mark = @Reference.get
+        old_val, old_mark = reference
         new_val, new_mark = yield old_val, old_mark
 
         return unless compare_and_set old_val, new_val, old_mark, new_mark

data/lib/concurrent/edge/future.rb

@@ -125,7 +125,8 @@ module Concurrent
     include FutureShortcuts
 
     # Represents an event which will happen in future (will be completed). It has to always happen.
-    class Event < Synchronization::Object
+    class Event < Synchronization::LockableObject
+      safe_initialization!
       include Concern::Deprecation
 
       # @!visibility private
@@ -167,14 +168,15 @@ module Concurrent
       COMPLETED = Completed.new
 
       def initialize(promise, default_executor)
+        super()
         @Promise         = promise
         @DefaultExecutor = default_executor
         @Touched         = AtomicBoolean.new(false)
         @Callbacks       = LockFreeStack.new
-        @Waiters         = LockFreeStack.new # TODO replace with AtomicFixnum, avoid aba problem
+        # TODO (pitr 12-Sep-2015): replace with AtomicFixnum, avoid aba problem
+        # TODO (pitr 12-Sep-2015): look at java.util.concurrent solution
+        @Waiters         = LockFreeStack.new
         @State           = AtomicReference.new PENDING
-        super()
-        ensure_ivar_visibility!
       end
 
       # @return [:pending, :completed]
@@ -878,9 +880,11 @@ module Concurrent
     # @abstract
     # @!visibility private
     class AbstractPromise < Synchronization::Object
+      safe_initialization!
+
       def initialize(future)
+        super()
         @Future = future
-        ensure_ivar_visibility!
       end
 
       def future
@@ -1374,11 +1378,12 @@ module Concurrent
 
     # @note proof of concept
     class Channel < Synchronization::Object
+      safe_initialization!
+
       # TODO make lock free
       def initialize
-        super
+        super()
         @ProbeSet = Concurrent::Channel::WaitableList.new
-        ensure_ivar_visibility!
       end
 
       def probe_set_size

data/lib/concurrent/edge/lock_free_linked_set.rb

@@ -55,7 +55,7 @@ module Concurrent
 
           node = Node.new item, curr
 
-          if pred.Successor_reference.compare_and_set curr, node, false, false
+          if pred.successor_reference.compare_and_set curr, node, false, false
             return true
           end
         end
@@ -88,7 +88,7 @@ module Concurrent
 
         while curr < item
           curr = curr.next_node
-          marked = curr.Successor_reference.marked?
+          marked = curr.successor_reference.marked?
         end
 
         curr == item && !marked
@@ -109,11 +109,11 @@ module Concurrent
           return false if curr != item
 
           succ = curr.next_node
-          removed = curr.Successor_reference.compare_and_set succ, succ, false, true
+          removed = curr.successor_reference.compare_and_set succ, succ, false, true
 
           next_node unless removed
 
-          pred.Successor_reference.compare_and_set curr, succ, false, false
+          pred.successor_reference.compare_and_set curr, succ, false, false
 
           return true
         end
@@ -134,9 +134,9 @@ module Concurrent
 
         until curr.last?
           curr = curr.next_node
-          marked = curr.Successor_reference.marked?
+          marked = curr.successor_reference.marked?
 
-          yield curr.Data unless marked
+          yield curr.data unless marked
         end
 
         self

data/lib/concurrent/edge/lock_free_linked_set/node.rb

@@ -6,27 +6,36 @@ module Concurrent
       class Node < Synchronization::Object
         include Comparable
 
-        attr_reader :Data, :Successor_reference, :Key
+        safe_initialization!
 
         def initialize(data = nil, successor = nil)
           super()
+          @SuccessorReference = AtomicMarkableReference.new(successor || Tail.new)
+          @Data                = data
+          @Key                 = key_for data
+        end
+
+        def data
+          @Data
+        end
 
-          @Successor_reference = AtomicMarkableReference.new(successor || Tail.new)
-          @Data = data
-          @Key = key_for data
+        def successor_reference
+          @SuccessorReference
+        end
 
-          ensure_ivar_visibility!
+        def key
+          @Key
         end
 
         # Check to see if the node is the last in the list.
         def last?
-          @Successor_reference.value.is_a? Tail
+          @SuccessorReference.value.is_a? Tail
         end
 
         # Next node in the list. Note: this is not the AtomicMarkableReference
         # of the next node, this is the actual Node itself.
         def next_node
-          @Successor_reference.value
+          @SuccessorReference.value
         end
 
         # This method provides a unqiue key for the data which will be used for
@@ -49,7 +58,7 @@ module Concurrent
       # a self-loop.
       class Tail < Node
         def initialize(_data = nil, _succ = nil)
-          @Successor_reference = AtomicMarkableReference.new self
+          @SuccessorReference = AtomicMarkableReference.new self
         end
 
         # Always greater than other nodes. This means that traversal will end

data/lib/concurrent/edge/lock_free_linked_set/window.rb

@@ -20,17 +20,17 @@ module Concurrent
             curr = pred.next_node
 
             loop do
-              succ, marked = curr.Successor_reference.get
+              succ, marked = curr.successor_reference.get
 
               # Remove sequence of marked nodes
               while marked
-                removed = pred.Successor_reference.compare_and_set curr, succ, false, false
+                removed = pred.successor_reference.compare_and_set curr, succ, false, false
 
                 # If could not remove node, try again
                 break_inner_loops = true && break unless removed
 
                 curr = succ
-                succ, marked = curr.Successor_reference.get
+                succ, marked = curr.successor_reference.get
               end
 
               break if break_inner_loops

data/lib/concurrent/edge/lock_free_stack.rb

@@ -2,6 +2,8 @@ module Concurrent
   module Edge
     class LockFreeStack < Synchronization::Object
 
+      safe_initialization!
+
       class Node
         attr_reader :value, :next_node
 
@@ -21,50 +23,51 @@ module Concurrent
 
       EMPTY = Empty[nil, nil]
 
+      private *attr_volatile_with_cas(:head)
+
       def initialize
-        @Head = AtomicReference.new EMPTY
-        ensure_ivar_visibility!
+        super(EMPTY)
       end
 
       def empty?
-        @Head.get.equal? EMPTY
+        head.equal? EMPTY
       end
 
       def compare_and_push(head, value)
-        @Head.compare_and_set head, Node[value, head]
+        compare_and_set_head head, Node[value, head]
       end
 
       def push(value)
         while true
-          head = @Head.get
-          return self if @Head.compare_and_set head, Node[value, head]
+          current_head = head
+          return self if compare_and_set_head current_head, Node[value, current_head]
         end
       end
 
       def peek
-        @Head.get
+        head
       end
 
       def compare_and_pop(head)
-        @Head.compare_and_set head, head.next_node
+        compare_and_set_head head, head.next_node
       end
 
       def pop
         while true
-          head = @Head.get
-          return head.value if @Head.compare_and_set head, head.next_node
+          current_head = head
+          return current_head.value if compare_and_set_head current_head, current_head.next_node
         end
       end
 
       def compare_and_clear(head)
-        @Head.compare_and_set head, EMPTY
+        compare_and_set_head head, EMPTY
       end
 
       def clear
         while true
-          head = @Head.get
-          return false if head == EMPTY
-          return true if @Head.compare_and_set head, EMPTY
+          current_head = head
+          return false if current_head == EMPTY
+          return true if compare_and_set_head current_head, EMPTY
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre1
+  version: 0.2.0.pre2
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,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:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre1
+        version: 1.0.0.pre2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre1
+        version: 1.0.0.pre2
 description: |
   These features are under active development and may change frequently. They are expected not to
   keep backward compatibility (there may also lack tests and documentation). Semantic versions will
@@ -71,7 +71,6 @@ files:
 - lib/concurrent/actor/utils/balancer.rb
 - lib/concurrent/actor/utils/broadcast.rb
 - lib/concurrent/actor/utils/pool.rb
-- lib/concurrent/agent.rb
 - lib/concurrent/channel.rb
 - lib/concurrent/channel/blocking_ring_buffer.rb
 - lib/concurrent/channel/buffered_channel.rb
@@ -105,7 +104,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: Edge features and additions to the concurrent-ruby gem.

data/lib/concurrent/agent.rb

@@ -1,259 +0,0 @@
-require 'concurrent/collection/copy_on_write_observer_set'
-require 'concurrent/concern/dereferenceable'
-require 'concurrent/concern/observable'
-require 'concurrent/concern/logging'
-require 'concurrent/executor/executor'
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # `Agent`s are inspired by [Clojure's](http://clojure.org/) [agent](http://clojure.org/agents) function. An `Agent` is a single atomic value that represents an identity. The current value of the `Agent` can be requested at any time (`deref`). Each `Agent` has a work queue and operates on the global thread pool (see below). Consumers can `post` code blocks to the `Agent`. The code block (function) will receive the current value of the `Agent` as its sole parameter. The return value of the block will become the new value of the `Agent`. `Agent`s support two error handling modes: fail and continue. A good example of an `Agent` is a shared incrementing counter, such as the score in a video game. 
-  # 
-  # An `Agent` must be initialize with an initial value. This value is always accessible via the `value` (or `deref`) methods. Code blocks sent to the `Agent` will be processed in the order received. As each block is processed the current value is updated with the result from the block. This update is an atomic operation so a `deref` will never block and will always return the current value. 
-  # 
-  # When an `Agent` is created it may be given an optional `validate` block and zero or more `rescue` blocks. When a new value is calculated the value will be checked against the validator, if present. If the validator returns `true` the new value will be accepted. If it returns `false` it will be rejected. If a block raises an exception during execution the list of `rescue` blocks will be seacrhed in order until one matching the current exception is found. That `rescue` block will then be called an passed the exception object. If no matching `rescue` block is found, or none were configured, then the exception will be suppressed. 
-  # 
-  # `Agent`s also implement Ruby's [Observable](http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html). Code that observes an `Agent` will receive a callback with the new value any time the value is changed. 
-  #
-  # @!macro copy_options
-  # 
-  # @example Simple Example
-  # 
-  #   require 'concurrent'
-  #   
-  #   score = Concurrent::Agent.new(10)
-  #   score.value #=> 10
-  #   
-  #   score << proc{|current| current + 100 }
-  #   sleep(0.1)
-  #   score.value #=> 110
-  #   
-  #   score << proc{|current| current * 2 }
-  #   sleep(0.1)
-  #   score.value #=> 220
-  #   
-  #   score << proc{|current| current - 50 }
-  #   sleep(0.1)
-  #   score.value #=> 170
-  # 
-  # @example With Validation and Error Handling
-  # 
-  #   score = Concurrent::Agent.new(0).validate{|value| value <= 1024 }.
-  #             rescue(NoMethodError){|ex| puts "Bam!" }.
-  #             rescue(ArgumentError){|ex| puts "Pow!" }.
-  #             rescue{|ex| puts "Boom!" }
-  #   score.value #=> 0
-  #   
-  #   score << proc{|current| current + 2048 }
-  #   sleep(0.1)
-  #   score.value #=> 0
-  #   
-  #   score << proc{|current| raise ArgumentError }
-  #   sleep(0.1)
-  #   #=> puts "Pow!"
-  #   score.value #=> 0
-  #   
-  #   score << proc{|current| current + 100 }
-  #   sleep(0.1)
-  #   score.value #=> 100
-  # 
-  # @example With Observation
-  # 
-  #   bingo = Class.new{
-  #     def update(time, score)
-  #       puts "Bingo! [score: #{score}, time: #{time}]" if score >= 100
-  #     end
-  #   }.new
-  #   
-  #   score = Concurrent::Agent.new(0)
-  #   score.add_observer(bingo)
-  #   
-  #   score << proc{|current| sleep(0.1); current += 30 }
-  #   score << proc{|current| sleep(0.1); current += 30 }
-  #   score << proc{|current| sleep(0.1); current += 30 }
-  #   score << proc{|current| sleep(0.1); current += 30 }
-  #   
-  #   sleep(1)
-  #   #=> Bingo! [score: 120, time: 2013-07-22 21:26:08 -0400]
-  #
-  # @!attribute [r] timeout
-  #   @return [Fixnum] the maximum number of seconds before an update is cancelled
-  #
-  # @!macro edge_warning
-  class Agent < Synchronization::Object
-    include Concern::Dereferenceable
-    include Concern::Observable
-    include Concern::Logging
-
-    attr_reader :timeout, :io_executor, :fast_executor
-
-    # Initialize a new Agent with the given initial value and provided options.
-    #
-    # @param [Object] initial the initial value
-    #
-    # @!macro executor_and_deref_options
-    def initialize(initial, opts = {})
-      super()
-      synchronize { ns_initialize(initial, opts) }
-    end
-
-    # Specifies a block fast to be performed when an update fast raises
-    # an exception. Rescue blocks will be checked in order they were added. The first
-    # block for which the raised exception "is-a" subclass of the given `clazz` will
-    # be called. If no `clazz` is given the block will match any caught exception.
-    # This behavior is intended to be identical to Ruby's `begin/rescue/end` behavior.
-    # Any number of rescue handlers can be added. If no rescue handlers are added then
-    # caught exceptions will be suppressed.
-    #
-    # @param [Exception] clazz the class of exception to catch
-    # @yield the block to be called when a matching exception is caught
-    # @yieldparam [StandardError] ex the caught exception
-    #
-    # @example
-    #   score = Concurrent::Agent.new(0).
-    #             rescue(NoMethodError){|ex| puts "Bam!" }.
-    #             rescue(ArgumentError){|ex| puts "Pow!" }.
-    #             rescue{|ex| puts "Boom!" }
-    #
-    #   score << proc{|current| raise ArgumentError }
-    #   sleep(0.1)
-    #   #=> puts "Pow!"
-    def rescue(clazz = StandardError, &block)
-      unless block.nil?
-        synchronize { @rescuers << Rescuer.new(clazz, block) }
-      end
-      self
-    end
-
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    # A block task to be performed after every update to validate if the new
-    # value is valid. If the new value is not valid then the current value is not
-    # updated. If no validator is provided then all updates are considered valid.
-    #
-    # @yield the block to be called after every update fast to determine if
-    #   the result is valid
-    # @yieldparam [Object] value the result of the last update fast
-    # @yieldreturn [Boolean] true if the value is valid else false
-    def validate(&block)
-
-      unless block.nil?
-        synchronize { @validator = block }
-      end
-      self
-    end
-
-    alias_method :validates, :validate
-    alias_method :validate_with, :validate
-    alias_method :validates_with, :validate
-
-    # Update the current value with the result of the given block fast,
-    # block should not do blocking calls, use #post_off for blocking calls
-    #
-    # @yield the fast to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    # @return [true, nil] nil when no block is given
-    def post(&block)
-      post_on(@fast_executor, &block)
-    end
-
-    # Update the current value with the result of the given block fast,
-    # block can do blocking calls
-    #
-    # @yield the fast to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    # @return [true, nil] nil when no block is given
-    def post_off(&block)
-      post_on(@io_executor, &block)
-    end
-
-    # Update the current value with the result of the given block fast,
-    # block should not do blocking calls, use #post_off for blocking calls
-    #
-    # @yield the fast to be performed with the current value in order to calculate
-    #   the new value
-    # @yieldparam [Object] value the current value
-    # @yieldreturn [Object] the new value
-    def <<(block)
-      post(&block)
-      self
-    end
-
-    # Waits/blocks until all the updates sent before this call are done.
-    #
-    # @param [Numeric] timeout the maximum time in second to wait.
-    # @return [Boolean] false on timeout, true otherwise
-    def await(timeout = nil)
-      done = Event.new
-      post { |val| done.set; val }
-      done.wait timeout
-    end
-
-    protected
-
-    def ns_initialize(initial, opts)
-      init_mutex(self)
-      @value                = initial
-      @rescuers             = []
-      @validator            = Proc.new { |result| true }
-      self.observers        = Collection::CopyOnWriteObserverSet.new
-      @serialized_execution = SerializedExecution.new
-      @io_executor          = Executor.executor_from_options(opts) || Concurrent.global_io_executor
-      @fast_executor        = Executor.executor_from_options(opts) || Concurrent.global_fast_executor
-      set_deref_options(opts)
-    end
-
-    private
-
-    def post_on(executor, &block)
-      return nil if block.nil?
-      @serialized_execution.post(executor) { work(&block) }
-      true
-    end
-
-    # @!visibility private
-    Rescuer = Struct.new(:clazz, :block) # :nodoc:
-
-    # @!visibility private
-    def try_rescue(ex) # :nodoc:
-      rescuer = synchronize do
-        @rescuers.find { |r| ex.is_a?(r.clazz) }
-      end
-      rescuer.block.call(ex) if rescuer
-    rescue Exception => ex
-      # suppress
-      log DEBUG, ex
-    end
-
-    # @!visibility private
-    def work(&handler) # :nodoc:
-      validator, value = synchronize { [@validator, @value] }
-
-      begin
-        result = handler.call(value)
-        valid  = validator.call(result)
-      rescue Exception => ex
-        exception = ex
-      end
-
-      should_notify = synchronize do
-        if !exception && valid
-          @value = result
-          true
-        end
-      end
-
-      if should_notify
-        time = Time.now
-        observers.notify_observers { [time, self.value] }
-      end
-
-      try_rescue(exception)
-    end
-  end
-end