concurrent-ruby 1.0.0.pre2 → 1.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0148d111f8cfb5ce264c12f5a0cef91ca1bf36e3
-  data.tar.gz: 6d773f8549a2a1f989c5135d49e0a91ed51f04d6
+  metadata.gz: 0dc607165069d68d20f3cdc11dc2fda36987a341
+  data.tar.gz: 7e6c28de16b282bb4339ab3e07a786f3c468c8b4
 SHA512:
-  metadata.gz: 2bbee143971798fd8ea52f03fb361a9b5ce8fe3db4d5c8eecb45ee21b9ad29939dc458a9f20320496cc70f6fae22fe799d0b3d179e280b19180b28d9ba891d12
-  data.tar.gz: 45c8e415754d1148b839d28da1d386be611ba598b560d1c8e7acd7e7eb000621f0400b1901d94a1a10036836119f67c92b70a73484ae827adaecda74a496e108
+  metadata.gz: 5af93689cc08e9415e23aba1bda309226bbdff2a1b99f30ffd4e879f1e6190d86aba2b1be9b83b1681717e63f8e6d9c2fb53e4e542260f3e855ee12b6a74770e
+  data.tar.gz: 84030bd44e276836f3f329bace8489181de2c87c7aa311acd460bf714958ffe755dd555ba8aea0d8ecd621098f07b9f3dde6774913100d10e1998e26aa0d9f6f

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-## Current Release v1.0.0.pre2 (19 September 2015)
+### Upcoming Release v1.0.0 (TBD)
+
+## Current Release v1.0.0.pre3 (29 September 2015)
+
+* Removed interpreter warnings.
+* Shared constants now in `lib/concurrent/constants.rb`
+* Refactored many tests.
+* Improved synchronization layer/memory model documentation.
+* Bug fix in Edge `Future#flat`
+* Brand new `Channel` implementation in Edge gem.
+
+### Release v1.0.0.pre2 (19 September 2015)
 
 * Simplification of `RubySingleThreadExecutor`
 * `Async` improvements
@@ -10,8 +21,9 @@
   - Now `Observable`
   - Added a `#reset` method
 * Brand new `Agent` API and implementation. Now functionally equivalent to Clojure.
+* Continued improvements to the synchronization layer
 
-### Current Release v1.0.0.pre1 (19 August 2015)
+### Release v1.0.0.pre1 (19 August 2015)
 
 * Merged in the `thread_safe` gem
   - `Concurrent::Array`

data/README.md

@@ -130,8 +130,10 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
   `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.
-* [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html):
-  Communicating Sequential Processes (CSP).
+* [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/Channel.html):
+  Communicating Sequential Processes ([CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)).
+  Functionally equivalent to Go [channels](https://tour.golang.org/concurrency/2) with additional
+  inspiration from Clojure [core.async](https://clojure.github.io/core.async/).
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
 * [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
 * [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
@@ -142,10 +144,10 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 *Why are these not in core?*
 
 - **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.
-- **Channel** - Missing documentation; limited features; stability good.
+- **Channel** - Brand new implementation; partial documentation and tests; stability is good.
+- **Future/Promise Framework** - API changes; partial documentation and tests; stability is good.
 - **LazyRegister** - Missing documentation and tests.
-- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing
+- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing.
 
 ## Usage
 

data/lib/concurrent.rb

@@ -1,8 +1,9 @@
 require 'concurrent/version'
+require 'concurrent/constants'
+require 'concurrent/errors'
 require 'concurrent/configuration'
 
 require 'concurrent/atomics'
-require 'concurrent/errors'
 require 'concurrent/executors'
 require 'concurrent/synchronization'
 
@@ -126,9 +127,4 @@ require 'concurrent/options'
 # * Be small, lean, and loosely coupled
 module Concurrent
 
-  # Various classes within allows for +nil+ values to be stored,
-  # so a special +NULL+ token is required to indicate the "nil-ness".
-  # @!visibility private
-  NULL = Object.new
-
 end

data/lib/concurrent/atom.rb

@@ -3,6 +3,40 @@ require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/concern/observable'
 require 'concurrent/synchronization'
 
+# @!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
 
   # Atoms provide a way to manage shared, synchronous, independent state.
@@ -61,7 +95,7 @@ module Concurrent
     include Concern::Observable
 
     safe_initialization!
-    private *attr_volatile_with_cas(:value)
+    private(*attr_volatile_with_cas(:value))
     public :value
 
     # Create a new atom with the given initial value.

data/lib/concurrent/atomic/abstract_thread_local_var.rb

@@ -1,3 +1,5 @@
+require 'concurrent/constants'
+
 module Concurrent
 
   # @!macro thread_local_var
@@ -5,10 +7,6 @@ module Concurrent
   # @!visibility private
   class AbstractThreadLocalVar
 
-    # @!visibility private
-    NIL_SENTINEL = Object.new
-    private_constant :NIL_SENTINEL
-
     # @!macro thread_local_var_method_initialize
     def initialize(default = nil)
       @default = default

data/lib/concurrent/atomic/java_thread_local_var.rb

@@ -14,7 +14,7 @@ if Concurrent.on_jruby?
 
         if value.nil?
           @default
-        elsif value == NIL_SENTINEL
+        elsif value == NULL
           nil
         else
           value

data/lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -51,7 +51,7 @@ module Concurrent
         value = array[@index]
         if value.nil?
           @default
-        elsif value.equal?(NIL_SENTINEL)
+        elsif value.equal?(NULL)
           nil
         else
           value
@@ -72,7 +72,7 @@ module Concurrent
         LOCK.synchronize { ARRAYS[array.object_id] = array }
         ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
       end
-      array[@index] = (value.nil? ? NIL_SENTINEL : value)
+      array[@index] = (value.nil? ? NULL : value)
       value
     end
 
@@ -159,7 +159,7 @@ module Concurrent
         value = array[@index]
         if value.nil?
           @default
-        elsif value.equal?(NIL_SENTINEL)
+        elsif value.equal?(NULL)
           nil
         else
           value

data/lib/concurrent/collection/map/atomic_reference_map_backend.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/thread_safe/util'
 require 'concurrent/thread_safe/util/adder'
 require 'concurrent/thread_safe/util/cheap_lockable'

data/lib/concurrent/collection/map/non_concurrent_map_backend.rb

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

data/lib/concurrent/constants.rb

@@ -0,0 +1,8 @@
+module Concurrent
+
+  # Various classes within allows for +nil+ values to be stored,
+  # so a special +NULL+ token is required to indicate the "nil-ness".
+  # @!visibility private
+  NULL = Object.new
+
+end

data/lib/concurrent/exchanger.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/maybe'
 require 'concurrent/atomic/atomic_reference'
@@ -139,10 +140,6 @@ module Concurrent
     # not include the arena or the multi-processor spin loops.
     # http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/Exchanger.java
 
-    # @!visibility private
-    NIL_SENTINEL = Object.new
-    private_constant :NIL_SENTINEL
-
     # @!visibility private
     class Node < Concurrent::AtomicReference
       attr_reader :item, :latch
@@ -249,7 +246,7 @@ module Concurrent
       #     - Wake the sleeping occupier
       #     - Return the occupier's item
 
-      value = NIL_SENTINEL if value.nil?                # The sentinel allows nil to be a valid value
+      value = NULL if value.nil?                        # The sentinel allows nil to be a valid value
       slot = @slot                                      # Convenience to minimize typing @
       me = Node.new(value)                              # create my node in case I need to occupy
       end_at = Concurrent.monotonic_time + timeout.to_f # The time to give up
@@ -282,7 +279,7 @@ module Concurrent
         break CANCEL if timeout && Concurrent.monotonic_time >= end_at
       end
 
-      result == NIL_SENTINEL ? nil : result
+      result == NULL ? nil : result
     end
   end
 

data/lib/concurrent/future.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/ivar'
 require 'concurrent/executor/safe_task_executor'

data/lib/concurrent/ivar.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/obligation'

data/lib/concurrent/map.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'concurrent/constants'
 
 module Concurrent
   # @!visibility private

data/lib/concurrent/promise.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/ivar'
 

data/lib/concurrent/scheduled_task.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/configuration'
 require 'concurrent/ivar'

data/lib/concurrent/synchronization.rb

@@ -1,6 +1,8 @@
 require 'concurrent/utility/engine'
 
 require 'concurrent/synchronization/abstract_object'
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/synchronization/mri_object'
 require 'concurrent/synchronization/jruby_object'
 require 'concurrent/synchronization/rbx_object'
@@ -11,7 +13,6 @@ require 'concurrent/synchronization/mri_lockable_object'
 require 'concurrent/synchronization/jruby_lockable_object'
 require 'concurrent/synchronization/rbx_lockable_object'
 
-require 'concurrent/utility/native_extension_loader' # load native part first
 require 'concurrent/synchronization/lockable_object'
 
 require 'concurrent/synchronization/condition'

data/lib/concurrent/synchronization/object.rb

@@ -79,7 +79,7 @@ module Concurrent
       end
 
       def self.safe_initialization?
-        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
+        (defined?(@safe_initialization) && @safe_initialization) || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
       end
 
       # For testing purposes, quite slow.
@@ -122,7 +122,7 @@ module Concurrent
             end
 
             def update_#{name}(&block)
-              #{ivar}.update &block
+              #{ivar}.update(&block)
             end
           RUBY
         end

data/lib/concurrent/tvar.rb

@@ -1,39 +1,5 @@
 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

data/lib/concurrent/utility/native_extension_loader.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization' # has to be loaded before JRuby extensions
+require 'concurrent/synchronization/abstract_object' # must 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.pre2'
-  EDGE_VERSION = '0.2.0.pre2'
+  VERSION      = '1.0.0.pre3'
+  EDGE_VERSION = '0.2.0.pre3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre2
+  version: 1.0.0.pre3
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-19 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -73,6 +73,7 @@ files:
 - lib/concurrent/concern/obligation.rb
 - lib/concurrent/concern/observable.rb
 - lib/concurrent/configuration.rb
+- lib/concurrent/constants.rb
 - lib/concurrent/dataflow.rb
 - lib/concurrent/delay.rb
 - lib/concurrent/edge.rb
@@ -164,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,