concurrent-ruby-edge 0.1.0.pre3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3b0a6f42dd53529fb35370f6d9d6b1957aa576c
-  data.tar.gz: b960e25b2834254aaa00685cf38e41fc3a481e9f
+  metadata.gz: 3d078f232b2a8d30df70a0d008daeaee93884f58
+  data.tar.gz: 767e96651e435eb373a2751fb11bd45fc336ab51
 SHA512:
-  metadata.gz: aec6112c612dbfa9f709181cef273ba892ae5db92915875e7750d18e159c821e613f5c02520530eb27805e60531e55e68021ac003279a94b8d78b63ef184948e
-  data.tar.gz: bb59836fc4e5da39fc2c3f7885d1a123f0a9100850c9c486871830d9421c5b2e0756f45e9f7c7dee7f538adfd030f765b3a54fa33fd94726c13e05b8d08b4977
+  metadata.gz: 231af4d7c79ca4bba8ec44d262b893a62a1a935bf6345a55dae736e55dc524e1939c8ee869b6c6c1f727e8f42a8134f71392f6dcac2056e717975db991b9a58a
+  data.tar.gz: 5f1df67b0ba95a112067cbf69dfd3301c26e44430d97c6f7120ee30efad6a2261d7c52decdfa70c572ac567e7710f355c194b148b6f7944ea3d07a313ecbd5f1

data/README.md

@@ -1,5 +1,5 @@
 # Concurrent Ruby
-[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.svg)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.svg)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.svg)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.svg)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT) [![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
+[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.svg)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Build status](https://ci.appveyor.com/api/projects/status/iq8aboyuu3etad4w?svg=true)](https://ci.appveyor.com/project/rubyconcurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.svg)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.svg)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.svg)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![License](https://img.shields.io/badge/license-MIT-green.svg)](http://opensource.org/licenses/MIT) [![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
 <table>
   <tr>
@@ -39,6 +39,7 @@
 
 MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
 This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
+Java 8 is required for JRuby (Java 7 support is deprecated in version 0.9 and will be removed in 1.0).
 
 ## Features & Documentation
 
@@ -127,14 +128,14 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 
 #### Statuses:
 
-*Why is not in core?*
+*Why are these not in core?*
 
-- **Actor** - partial documentation and tests, stability good. 
-- **Future/Promise Framework** - partial documentation and tests, stability good.
-- **Agent** - incomplete behaviour compared to Clojure's model, stability good.
-- **Channel** - missing documentation, stability good.
-- **Exchanger** - known race issue.
-- **LazyRegister** - missing documentation and tests.   
+- **Actor** - Partial documentation and tests; 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.
+- **Exchanger** - Known race condition requiring a new implementation.
+- **LazyRegister** - Missing documentation and tests.   
 
 ## Usage
 
@@ -248,10 +249,16 @@ bundle exec rake build              # Build JRuby-specific core gem (alias for `
 bundle exec rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory
 
 *All except JRuby*
-bundle exec rake build              # Build core and extension gems
 bundle exec rake build:core         # Build concurrent-ruby-<version>.gem into the pkg directory
 bundle exec rake build:ext          # Build concurrent-ruby-ext-<version>.gem into the pkg directory
 
+*When Docker IS installed*
+bundle exec rake build:windows      # Build the windows binary <version> gems per rake-compiler-dock
+bundle exec rake build              # Build core, extension, and edge gems, including Windows binaries
+
+*When Docker is NOT installed*
+bundle exec rake build              # Build core, extension, and edge gems (excluding Windows binaries)
+
 *All*
 bundle exec rake clean              # Remove any temporary products
 bundle exec rake clobber            # Remove any generated file
@@ -260,7 +267,7 @@ bundle exec rake compile            # Compile all the extensions
 
 ## Maintainers
 
-* [Jerry D'Antonio](https://github.com/jdantonio)
+* [Jerry D'Antonio](https://github.com/jdantonio) (creator)
 * [Michele Della Torre](https://github.com/mighe)
 * [Chris Seaton](https://github.com/chrisseaton)
 * [Lucas Allan](https://github.com/lucasallan)

data/lib/concurrent-edge.rb

@@ -9,3 +9,4 @@ require 'concurrent/lazy_register'
 require 'concurrent/edge/future'
 require 'concurrent/edge/lock_free_stack'
 require 'concurrent/edge/atomic_markable_reference'
+require 'concurrent/edge/lock_free_linked_set'

data/lib/concurrent/actor/behaviour.rb

@@ -37,10 +37,6 @@ module Concurrent
     #
     #     > {include:Actor::Behaviour::Termination}
     #
-    # -   {Behaviour::TerminatesChildren}:
-    #
-    #     > {include:Actor::Behaviour::TerminatesChildren}
-    #
     # -   {Behaviour::RemovesChild}:
     #
     #     > {include:Actor::Behaviour::RemovesChild}
@@ -66,14 +62,12 @@ module Concurrent
       require 'concurrent/actor/behaviour/sets_results'
       require 'concurrent/actor/behaviour/supervising'
       require 'concurrent/actor/behaviour/termination'
-      require 'concurrent/actor/behaviour/terminates_children'
 
       # Array of behaviours and their construction parameters.
       #
       #     [[Behaviour::SetResults, :terminate!],
       #      [Behaviour::RemovesChild],
       #      [Behaviour::Termination],
-      #      [Behaviour::TerminatesChildren],
       #      [Behaviour::Linking],
       #      [Behaviour::Awaits],
       #      [Behaviour::ExecutesContext],
@@ -91,7 +85,6 @@ module Concurrent
       #     [[Behaviour::SetResults, :pause!],
       #      [Behaviour::RemovesChild],
       #      [Behaviour::Termination],
-      #      [Behaviour::TerminatesChildren],
       #      [Behaviour::Linking],
       #      [Behaviour::Pausing],
       #      [Behaviour::Supervising, :reset!, :one_for_one],
@@ -113,8 +106,7 @@ module Concurrent
         [[SetResults, on_error],
          # has to be before Termination to be able to remove children from terminated actor
          RemovesChild,
-         Termination,
-         TerminatesChildren]
+         Termination]
       end
 
       # @see '' its source code

data/lib/concurrent/actor/behaviour/termination.rb

@@ -2,22 +2,22 @@ module Concurrent
   module Actor
     module Behaviour
 
-      # Handles actor termination.
+      # Handles actor termination. Waits until all its children are terminated,
+      # can be configured on behaviour initialization.
       # @note Actor rejects envelopes when terminated.
       # @note TODO missing example
       class Termination < Abstract
 
         # @!attribute [r] terminated
         #   @return [Edge::Event] event which will become set when actor is terminated.
-        # @!attribute [r] reason
-        attr_reader :terminated, :reason
+        attr_reader :terminated
 
-        def initialize(core, subsequent, core_options, trapping = false)
+        def initialize(core, subsequent, core_options, trapping = false, terminate_children = true)
           super core, subsequent, core_options
-          @terminated        = Concurrent.event
-          @public_terminated = @terminated.hide_completable
-          @reason            = nil
-          @trapping          = trapping
+          @terminated         = Concurrent.future
+          @public_terminated  = @terminated.hide_completable
+          @trapping           = trapping
+          @terminate_children = terminate_children
         end
 
         # @note Actor rejects envelopes when terminated.
@@ -43,7 +43,7 @@ module Concurrent
             if trapping? && reason != :kill
               pass envelope
             else
-              terminate! reason
+              terminate! reason, envelope
             end
           when :termination_event
             @public_terminated
@@ -59,14 +59,23 @@ module Concurrent
 
         # Terminates the actor. Any Envelope received after termination is rejected.
         # Terminates all its children, does not wait until they are terminated.
-        def terminate!(reason = :normal)
-          # TODO return after all children are terminated
+        def terminate!(reason = nil, envelope = nil)
           return true if terminated?
-          @reason = reason
-          terminated.complete
+
+          self_termination = Concurrent.completed_future(reason.nil?, reason.nil? || nil, reason)
+          all_terminations = if @terminate_children
+                               Concurrent.zip(*children.map { |ch| ch.ask(:terminate!) }, self_termination)
+                             else
+                               self_termination
+                             end
+
+          all_terminations.chain_completable(@terminated)
+          all_terminations.chain_completable(envelope.future) if envelope && envelope.future
+
           broadcast(true, [:terminated, reason]) # TODO do not end up in Dead Letter Router
           parent << :remove_child if parent
-          true
+
+          MESSAGE_PROCESSED
         end
       end
     end

data/lib/concurrent/actor/internal_delegations.rb

@@ -18,10 +18,10 @@ module Concurrent
         behaviour!(Behaviour::Termination).terminated?
       end
 
-      # @see Termination#reason
-      def reason
-        behaviour!(Behaviour::Termination).reason
-      end
+      # # @see Termination#reason
+      # def reason
+      #   behaviour!(Behaviour::Termination).reason
+      # end
 
       # delegates to core.log
       # @see Logging#log

data/lib/concurrent/actor/utils/ad_hoc.rb

@@ -18,7 +18,6 @@ module Concurrent
       #     # this block has to return proc defining #on_message behaviour
       #     -> message { where.tell message  }
       #   end
-      # @note TODO remove in favor of the module
       class AdHoc < Context
         include AsAdHoc
       end

data/lib/concurrent/edge/future.rb

@@ -39,9 +39,19 @@ module Concurrent
         end
       end
 
-      # @return [Future] which is already completed with value
-      def completed_future(value, default_executor = :io)
-        ImmediateFuturePromise.new(default_executor, value).future
+      # @return [Future] which is already completed
+      def completed_future(success, value, reason, default_executor = :io)
+        ImmediateFuturePromise.new(default_executor, success, value, reason).future
+      end
+
+      # @return [Future] which is already completed in success state with value
+      def succeeded_future(value, default_executor = :io)
+        completed_future true, value, nil, default_executor
+      end
+
+      # @return [Future] which is already completed in failed state with reason
+      def failed_future(reason, default_executor = :io)
+        completed_future false, nil, reason, default_executor
       end
 
       # @return [Event] which is already completed
@@ -678,10 +688,10 @@ module Concurrent
 
       alias_method :|, :any
 
-      # only proof of concept
       # @note may block
+      # @note only proof of concept
       def then_push(channel)
-        on_success { |value| channel.push value }
+        on_success(:io) { |value| channel.push value }
       end
 
       # @yield [value] executed async on `executor` when success
@@ -1057,7 +1067,7 @@ module Concurrent
             evaluate_to lambda { done_future.apply task }
           end
         else
-          complete_with Future::Failed.new(done_future.reason)
+          complete_with done_future.internal_state
         end
       end
     end
@@ -1104,8 +1114,9 @@ module Concurrent
 
     # @!visibility private
     class ImmediateFuturePromise < InnerPromise
-      def initialize(default_executor, value)
-        super Future.new(self, default_executor).complete_with(Future::Success.new(value))
+      def initialize(default_executor, success, value, reason)
+        super Future.new(self, default_executor).
+                  complete_with(success ? Future::Success.new(value) : Future::Failed.new(reason))
       end
     end
 
@@ -1360,7 +1371,7 @@ module Concurrent
       end
     end
 
-    # proof of concept
+    # @note proof of concept
     class Channel < Synchronization::Object
       # TODO make lock free
       def initialize

data/lib/concurrent/edge/lock_free_linked_set.rb

@@ -0,0 +1,146 @@
+require 'concurrent/edge/lock_free_linked_set/node'
+require 'concurrent/edge/lock_free_linked_set/window'
+
+module Concurrent
+  module Edge
+    # This class implements a lock-free linked set. The general idea of this
+    # implementation is this: each node has a successor which is an Atomic
+    # Markable Reference. This is used to ensure that all modifications to the
+    # list are atomic, preserving the structure of the linked list under _any_
+    # circumstance in a multithreaded application.
+    #
+    # One interesting aspect of this algorithm occurs with removing a node.
+    # Instead of physically removing a node when remove is called, a node is
+    # logically removed, by 'marking it.' By doing this, we prevent calls to
+    # `remove` from traversing the list twice to perform a physical removal.
+    # Instead, we have have calls to `add` and `remove` clean up all marked
+    # nodes they encounter while traversing the list.
+    #
+    # This algorithm is a variation of the Nonblocking Linked Set found in
+    # 'The Art of Multiprocessor Programming' by Herlihy and Shavit.
+    class LockFreeLinkedSet
+      include Enumerable
+
+      # @!macro [attach] lock_free_linked_list_method_initialize
+      #
+      # @param [Fixnum] initial_size the size of the linked_list to initialize
+      def initialize(initial_size = 0, val = nil)
+        @head = Head.new
+
+        initial_size.times do
+          val = block_given? ? yield : val
+          add val
+        end
+      end
+
+      # @!macro [attach] lock_free_linked_list_method_add
+      #
+      #   Atomically adds the item to the set if it does not yet exist. Note:
+      #   internally the set uses `Object#hash` to compare equality of items,
+      #   meaning that Strings and other objects will be considered equal
+      #   despite being different objects.
+      #
+      #   @param [Object] item the item you wish to insert
+      #
+      #   @return [Boolean] `true` if successful. A `false` return indicates
+      #   that the item was already in the set.
+      def add(item)
+        loop do
+          window = Window.find @head, item
+
+          pred, curr = window.pred, window.curr
+
+          # Item already in set
+          return false if curr == item
+
+          node = Node.new item, curr
+
+          if pred.Successor_reference.compare_and_set curr, node, false, false
+            return true
+          end
+        end
+      end
+
+      # @!macro [attach] lock_free_linked_list_method_<<
+      #
+      #   Atomically adds the item to the set if it does not yet exist.
+      #
+      #   @param [Object] item the item you wish to insert
+      #
+      #   @return [Oject] the set on which the :<< method was invoked
+      def <<(item)
+        add item
+        self
+      end
+
+      # @!macro [attach] lock_free_linked_list_method_contains
+      #
+      #   Atomically checks to see if the set contains an item. This method
+      #   compares equality based on the `Object#hash` method, meaning that the
+      #   hashed contents of an object is what determines equality instead of
+      #   `Object#object_id`
+      #
+      #   @param [Object] item the item you to check for presence in the set
+      #
+      #   @return [Boolean] whether or not the item is in the set
+      def contains?(item)
+        curr = @head
+
+        while curr < item
+          curr = curr.next_node
+          marked = curr.Successor_reference.marked?
+        end
+
+        curr == item && !marked
+      end
+
+      # @!macro [attach] lock_free_linked_list_method_remove
+      #
+      #   Atomically attempts to remove an item, comparing using `Object#hash`.
+      #
+      #   @param [Object] item the item you to remove from the set
+      #
+      #   @return [Boolean] whether or not the item was removed from the set
+      def remove(item)
+        loop do
+          window = Window.find @head, item
+          pred, curr = window.pred, window.curr
+
+          return false if curr != item
+
+          succ = curr.next_node
+          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
+
+          return true
+        end
+      end
+
+      # @!macro [attach] lock_free_linked_list_method_each
+      #
+      #   An iterator to loop through the set.
+      #
+      #   @param [Object] item the item you to remove from the set
+      #   @yeild [Object] each item in the set
+      #
+      #   @return [Object] self: the linked set on which each was called
+      def each
+        return to_enum unless block_given?
+
+        curr = @head
+
+        until curr.last?
+          curr = curr.next_node
+          marked = curr.Successor_reference.marked?
+
+          yield curr.Data unless marked
+        end
+
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'concurrent/edge/atomic_markable_reference'
+
+module Concurrent
+  module Edge
+    class LockFreeLinkedSet
+      class Node < Synchronization::Object
+        include Comparable
+
+        attr_reader :Data, :Successor_reference, :Key
+
+        def initialize(data = nil, successor = nil)
+          super()
+
+          @Successor_reference = AtomicMarkableReference.new(successor || Tail.new)
+          @Data = data
+          @Key = key_for data
+
+          ensure_ivar_visibility!
+        end
+
+        # Check to see if the node is the last in the list.
+        def last?
+          @Successor_reference.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
+        end
+
+        # This method provides a unqiue key for the data which will be used for
+        # ordering. This is configurable, and changes depending on how you wish
+        # the nodes to be ordered.
+        def key_for(data)
+          data.hash
+        end
+
+        # We use `Object#hash` as a way to enforce ordering on the nodes. This
+        # can be configurable in the future; for example, you could enforce a
+        # split-ordering on the nodes in the set.
+        def <=>(other)
+          @Key <=> other.hash
+        end
+      end
+
+      # Internal sentinel node for the Tail. It is always greater than all
+      # other nodes, and  it is self-referential; meaning its successor is
+      # a self-loop.
+      class Tail < Node
+        def initialize(_data = nil, _succ = nil)
+          @Successor_reference = AtomicMarkableReference.new self
+        end
+
+        # Always greater than other nodes. This means that traversal will end
+        # at the tail node since we are comparing node size in the traversal.
+        def <=>(_other)
+          1
+        end
+      end
+
+
+      # Internal sentinel node for the Head of the set. Head is always smaller
+      # than any other node.
+      class Head < Node
+        def <=>(_other)
+          -1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Concurrent
+  module Edge
+    class LockFreeLinkedSet
+      class Window
+        attr_accessor :pred, :curr
+
+        def initialize(pred, curr)
+          @pred, @curr = pred, curr
+        end
+
+        # This method is used to find a 'window' for which `add` and `remove`
+        # methods can use to know where to add and remove from the list. However,
+        # it has another responsibilility, which is to physically unlink any
+        # nodes marked for removal in the set. This prevents adds/removes from
+        # having to retraverse the list to physically unlink nodes.
+        def self.find(head, item)
+          loop do
+            break_inner_loops = false
+            pred = head
+            curr = pred.next_node
+
+            loop do
+              succ, marked = curr.Successor_reference.get
+
+              # Remove sequence of marked nodes
+              while marked
+                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
+              end
+
+              break if break_inner_loops
+
+              # We have found a window
+              return new pred, curr if curr >= item
+
+              pred = curr
+              curr = succ
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre3
+  version: 0.1.0
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-22 00:00:00.000000000 Z
+date: 2015-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0.pre3
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0.pre3
+        version: 0.9.0
 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
@@ -55,7 +55,6 @@ files:
 - lib/concurrent/actor/behaviour/removes_child.rb
 - lib/concurrent/actor/behaviour/sets_results.rb
 - lib/concurrent/actor/behaviour/supervising.rb
-- lib/concurrent/actor/behaviour/terminates_children.rb
 - lib/concurrent/actor/behaviour/termination.rb
 - lib/concurrent/actor/context.rb
 - lib/concurrent/actor/core.rb
@@ -82,6 +81,9 @@ files:
 - lib/concurrent/channel/waitable_list.rb
 - lib/concurrent/edge/atomic_markable_reference.rb
 - lib/concurrent/edge/future.rb
+- lib/concurrent/edge/lock_free_linked_set.rb
+- lib/concurrent/edge/lock_free_linked_set/node.rb
+- lib/concurrent/edge/lock_free_linked_set/window.rb
 - lib/concurrent/edge/lock_free_stack.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
@@ -98,9 +100,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: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.8

data/lib/concurrent/actor/behaviour/terminates_children.rb

@@ -1,14 +0,0 @@
-module Concurrent
-  module Actor
-    module Behaviour
-      # Terminates all children when the actor terminates.
-      class TerminatesChildren < Abstract
-        def on_event(public, event)
-          event_name, _ = event
-          children.map { |ch| ch << :terminate! } if event_name == :terminated
-          super public, event
-        end
-      end
-    end
-  end
-end