concurrent-ruby-ext 1.0.0.pre1-x64-mingw32 → 1.0.0.pre2-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3f98b24f2f54b303db8b0786c17bacdbf354128
-  data.tar.gz: c382e502fff37f2f73131dc314d08693a64b7722
+  metadata.gz: f399a4578591c98f870c437d8cf0e72a366d40f2
+  data.tar.gz: 8dfa1fa0ac51092edce644fdce7bf17679fe436d
 SHA512:
-  metadata.gz: 69de2c7f7e8b19be79d70885aaa79f28fb2d6ba66f83912c0e982efc1dec74462edefd1adb64634a0b94fd0cc63c3d5ffbbd8f321ea87c007901f672744a66b4
-  data.tar.gz: bb18f390443ff3c78e87cbe2d7c6197d22256a953398107ee4c3893ae3bbbb7e7b0097be9dd129497bd284c325c2d8511f9af030109697420b10e6682dd872bd
+  metadata.gz: bf56b5828dc40a09d44402d5c127aafe839c82d3209fde07545b5daf9b258190ae75d778b7a9571f25e8eb63c0414fd09543e0b240f20fb520b554d2bed9cbdc
+  data.tar.gz: 70a702c9b5e36395a0c81290f7d94d2728e910a5366a2eaf661110ef1d4e4de30a97d2bef77c1f8e8f7701050e4a84e864610de74de7111c577b5ca1c239bf2e

data/CHANGELOG.md

@@ -1,4 +1,17 @@
-## Current Release v1.0.0.pre1 (19 Aug 2015)
+## Current Release v1.0.0.pre2 (19 September 2015)
+
+* Simplification of `RubySingleThreadExecutor`
+* `Async` improvements
+  - Each object uses its own `SingleThreadExecutor` instead of the global thread pool.
+  - No longers supports executor injection
+  - Much better documentation
+* `Atom` updates
+  - No longer `Dereferenceable`
+  - Now `Observable`
+  - Added a `#reset` method
+* Brand new `Agent` API and implementation. Now functionally equivalent to Clojure.
+
+### Current Release v1.0.0.pre1 (19 August 2015)
 
 * Merged in the `thread_safe` gem
   - `Concurrent::Array`

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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-ext
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre1
+  version: 1.0.0.pre2
 platform: x64-mingw32
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-19 00:00:00.000000000 Z
+date: 2015-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -17,14 +17,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: |2
       C extensions to optimize the concurrent-ruby gem when running under MRI.
       Please see http://concurrent-ruby.com for more information.