concurrent-ruby 1.0.0.pre2-java → 1.0.0.pre3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9bc638ed9105e5a5b16f99a65aa12ed6d46289a
-  data.tar.gz: b7dfc6934301f3adfe709805fe66cac6488c9608
+  metadata.gz: d934041ab8c5ca058c9777bf2e53331159f0b919
+  data.tar.gz: e9338663092968813848ba87e48d3e25d0b1b364
 SHA512:
-  metadata.gz: 565b6bab86511a7f2d62ee08296ec59388b18f2fbe6187c2dcb3e0c47adf17b2815e6b35acc070aa37fadee115303e51dbe0c1f61d584332e273dcc387ae5f0e
-  data.tar.gz: beda04d9ac9fd6b187a7b7b40d1c4c1fe5664f0f664e4fb39145fd10b0294d27fffe38269b406a32babc64d951f87245d79e9e6fdd9fbb2b69358ed45c7a7e5c
+  metadata.gz: c18201c8f8e58b24af2ef52b0445537af9d3709e8b1a6d817bf7ce70648189c3ba95fc8baabfe6830dc9c5a02c30d48b3834cd1cb0fd81d7c418ed6fb6deaddf
+  data.tar.gz: 00305a1e55e36dec21708d4b3e796fe235f0d73b3c77920501764062da50e10e228aedd0a0bda652dbb83131b7496ac49ea3b74609e0cc4166ab97e3a90175af

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: java
 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