concurrent-ruby-ext 1.0.5-x86-mingw32 → 1.1.0.pre1-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2e4d46f89301a6e95e8e71a39ee9a6450f156635
-  data.tar.gz: 0a6ab125cdb70ceb6a466b114336d944e65347f8
+SHA256:
+  metadata.gz: 72d0162f39f4f866b2264d7faff867084011facebbe96474755e9e5eb0230da9
+  data.tar.gz: 277cc283fbb48e6c5257644f062147ae8393d2aceda020466611fddd12e0ceeb
 SHA512:
-  metadata.gz: 234ac8a6d53b8aab741e455201e7f61553fe1dd7ffc985912bf3416f95ee78e891ca183e64a83872cb17377ae18c1df3b5946ee2ff8b05f223a180ba2e2cd250
-  data.tar.gz: 0152b6b657328ad59d71eb1db1a21fb784b8095fa2be74a45bf173d61c56cc624be6af55ccfa1a9466128bfb4bbc87e8266ba3e78e5f582fea8f40eb3f73582d
+  metadata.gz: 571309ea27c0c62013bfa4e708c0e4f0b2642c67f85d6e039d8f92dcd140f5bab0aa564e1fa5d7b21ac58f1704f046ff86340a579b3f7ec469264fdea526c6e6
+  data.tar.gz: f1957aeec7a4dec181cf563a4e40e7fae5b342b62304262f94cd84c78273bc7a4f0d538370b79da720da3f098bed5b35e67eb8c66865e3f0e218e759f953aa1c

data/CHANGELOG.md

@@ -1,9 +1,52 @@
-## Release v1.0.5, edge v0.3.1 (1 Feb 2017)
+## Current
+
+concurrent-ruby:
+
+* [Promises](http://ruby-concurrency.github.io/concurrent-ruby/1.1.0/Concurrent/Promises.html)
+  are moved from `concurrent-ruby-edge` to `concurrent-ruby`
+* Add support for TruffleRuby
+  * (#734) Fix Array/Hash/Set construction broken on TruffleRuby
+  * AtomicReference fixed    
+* CI stabilization
+* remove sharp dependency edge -> core
+* remove warnings
+* documentation updates
+* Exchanger is no longer documented as edge since it was already available in 
+  `concurrent-ruby`
+* (#644) Fix Map#each and #each_pair not returning enumerator outside of MRI
+* (#659) Edge promises fail during error handling
+* (#741) Raise on recursive Delay#value call
+* (#727) #717 fix global IO executor on JRuby
+* (#740) Drop support for CRuby 1.9, JRuby 1.7, Rubinius.
+* (#737) Move AtomicMarkableReference out of Edge
+* (#708) Prefer platform specific memory barriers 
+* (#735) Fix wrong expected exception in channel spec assertion
+* (#729) Allow executor option in `Promise#then`
+* (#725) fix timeout check to use timeout_interval
+* (#719) update engine detection
+* (#660) Add specs for Promise#zip/Promise.zip ordering
+* (#654) Promise.zip execution changes
+* (#666) Add thread safe set implementation
+* (#651) #699 #to_s, #inspect should not output negative object IDs.
+* (#685) Avoid RSpec warnings about raise_error
+* (#680) Avoid RSpec monkey patching, persist spec results locally, use RSpec
+  v3.7.0
+* (#665) Initialize the monitor for new subarrays on Rubinius
+* (#661) Fix error handling in edge promises
+  
+concurrent-ruby-edge:
+
+* (#659) Edge promises fail during error handling
+* Edge files clearly separated in `lib-edge`
+* added ReInclude
+
+## Release v1.0.5, edge v0.3.1 (26 Feb 2017)
 
 concurrent-ruby:
 
 * Documentation for Event and Semaphore
 * Use Unsafe#fullFence and #loadFence directly since the shortcuts were removed in JRuby
+* Do not depend on org.jruby.util.unsafe.UnsafeHolder
 
 concurrent-ruby-edge:
 
@@ -11,6 +54,7 @@ concurrent-ruby-edge:
 * (#624) Delayed promises did not interact correctly with flatting
   * Fix arguments yielded by callback methods
 * Overridable default executor in promises factory methods
+* Asking actor to terminate will always resolve to `true`
 
 ## Release v1.0.4, edge v0.3.0 (27 Dec 2016)
 

data/{LICENSE.txt → LICENSE.md}

@@ -1,3 +1,4 @@
+```
 Copyright (c) Jerry D'Antonio -- released under the MIT license.
 
 http://www.opensource.org/licenses/mit-license.php  
@@ -19,3 +20,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
 THE SOFTWARE. 
+```

data/README.md

@@ -3,9 +3,6 @@
 [![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](https://img.shields.io/badge/IRC%20(gitter)-devs%20%26%20users-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
@@ -19,129 +16,223 @@ Modern concurrency tools for Ruby. Inspired by
 [Java](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html),
 and classic concurrency patterns.
 
-<img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png" align="right" style="margin-left: 20px;" />
+<img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/docs-source/logo/concurrent-ruby-logo-300x300.png" align="right" style="margin-left: 20px;" />
 
 The design goals of this gem are:
 
-* Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why
-* Remain free of external gem dependencies
-* Stay true to the spirit of the languages providing inspiration
-* But implement in a way that makes sense for Ruby
-* Keep the semantics as idiomatic Ruby as possible
-* Support features that make sense in Ruby
-* Exclude features that don't make sense in Ruby
-* Be small, lean, and loosely coupled
-
-### Supported Ruby versions
-
-MRI 1.9.3, 2.0 and above, JRuby 1.7x in 1.9 mode, JRuby 9000, 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 preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
+*   Be an 'unopinionated' toolbox that provides useful utilities without debating which is better 
+    or why
+*   Remain free of external gem dependencies
+*   Stay true to the spirit of the languages providing inspiration
+*   But implement in a way that makes sense for Ruby
+*   Keep the semantics as idiomatic Ruby as possible
+*   Support features that make sense in Ruby
+*   Exclude features that don't make sense in Ruby
+*   Be small, lean, and loosely coupled
+*   Thread-safety
+*   Backward compatibility
+
+## Contributing
+
+**This gem depends on 
+[contributions](https://github.com/ruby-concurrency/concurrent-ruby/graphs/contributors) and we 
+appreciate your help. Would you like to contribute? Great! Have a look at 
+[issues with `looking-for-contributor` label](https://github.com/ruby-concurrency/concurrent-ruby/issues?q=is%3Aissue+is%3Aopen+label%3Alooking-for-contributor).** And if you pick something up let us know on the issue.
 
 ## Thread Safety
 
-*Concurrent Ruby makes the strongest thread safety guarantees of any Ruby concurrency library. We are the only library with a published [memory model](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/doc/synchronization.md) which provides consistent behavior and guarantees on all three of the main Ruby interpreters (MRI/CRuby, JRuby, and Rubinius).*
+*Concurrent Ruby makes one of the strongest thread safety guarantees of any Ruby concurrency 
+library, providing consistent behavior and guarantees on all three of the main Ruby interpreters 
+(MRI/CRuby, JRuby, and Rubinius).*
+
+Every abstraction in this library is thread safe. Specific thread safety guarantees are documented 
+with each abstraction.
 
-Every abstraction in this library is thread safe. Similarly, all are deadlock free and many are fully lock free. Specific thread safety guarantees are documented with each abstraction.
+It is critical to remember, however, that Ruby is a language of mutable references. *No*
+concurrency library for Ruby can ever prevent the user from making thread safety mistakes (such as
+sharing a mutable object between threads and modifying it on both threads) or from creating
+deadlocks through incorrect use of locks. All the library can do is provide safe abstractions which
+encourage safe practices. Concurrent Ruby provides more safe concurrency abstractions than any
+other Ruby library, many of which support the mantra of 
+["Do not communicate by sharing memory; instead, share memory by communicating"](https://blog.golang.org/share-memory-by-communicating).
+Concurrent Ruby is also the only Ruby library which provides a full suite of thread safe and
+immutable variable types and data structures.
 
-It is critical to remember, however, that Ruby is a language of mutable references. *No* concurrency library for Ruby can ever prevent the user from making thread safety mistakes (such as sharing a mutable object between threads and modifying it on both threads) or from creating deadlocks through incorrect use of locks. All the library can do is provide safe abstractions which encourage safe practices. Concurrent Ruby provides more safe concurrency abstractions than any other Ruby library, many of which support the mantra of ["Do not communicate by sharing memory; instead, share memory by communicating"](https://blog.golang.org/share-memory-by-communicating). Concurrent Ruby is also the only Ruby library which provides a full suite of thread safe and immutable variable types and data structures.
+We've also initiated discussion to document [memory model](docs-source/synchronization.md) of Ruby which 
+would provide consistent behaviour and guarantees on all three of the main Ruby interpreters 
+(MRI/CRuby, JRuby, Rubinius, TruffleRuby).
 
 ## Features & Documentation
 
-The primary site for documentation is the automatically generated [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
+**The primary site for documentation is the automatically generated 
+[API documentation](http://ruby-concurrency.github.io/concurrent-ruby/index.html) which is up to 
+date with latest release.** This readme matches the master so may contain new stuff not yet 
+released.
+
+We also have a [IRC (gitter)](https://gitter.im/ruby-concurrency/concurrent-ruby).
+
+### Versioning
+
+*   `concurrent-ruby` uses [Semantic Versioning](http://semver.org/)
+*   `concurrent-ruby-ext` has always same version as `concurrent-ruby`
+*   `concurrent-ruby-edge` will always be 0.y.z therefore following 
+    [point 4](http://semver.org/#spec-item-4) applies *"Major version zero 
+    (0.y.z) is for initial development. Anything may change at any time. The 
+    public API should not be considered stable."* However we additionally use 
+    following rules:
+    *   Minor version increment means incompatible changes were made
+    *   Patch version increment means only compatible changes were made
 
-We also have a [mailing list](http://groups.google.com/group/concurrent-ruby) and [IRC (gitter)](https://gitter.im/ruby-concurrency/concurrent-ruby).
 
 #### General-purpose Concurrency Abstractions
 
-* [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.
-* [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
-* [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals.
+*   [Async](http://ruby-concurrency.github.io/concurrent-ruby/master/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).
+*   [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ScheduledTask.html):
+    Like a Future scheduled for a specific future time.
+*   [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/TimerTask.html):
+    A Thread that periodically wakes up to perform work at regular intervals.
+*   [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html):
+    Unified implementation of futures and promises which combines features of previous `Future`,
+    `Promise`, `IVar`, `Event`, `dataflow`, `Delay`, and (partially) `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.    
 
 #### Thread-safe Value Objects, Structures, and Collections
 
 Collection classes that were originally part of the (deprecated) `thread_safe` gem:
 
-* [Array](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Array.html) A thread-safe subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
-* [Hash](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Hash.html) A thread-safe subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
-* [Map](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Map.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
-* [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Tuple.html) A fixed size array with volatile (synchronized, thread safe) getters/setters.
+*   [Array](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Array.html) A thread-safe
+    subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
+*   [Hash](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Hash.html) A thread-safe
+    subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
+*   [Set](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Set.html) A thread-safe
+    subclass of Ruby's standard [Set](http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html).
+*   [Map](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Map.html) A hash-like object
+    that should have much better performance characteristics, especially under high concurrency, 
+    than `Concurrent::Hash`.
+*   [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Tuple.html) A fixed size
+    array with volatile (synchronized, thread safe) getters/setters.
 
 Value objects inspired by other languages:
 
-* [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).
+*   [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/master/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).
 
 Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
 
-* [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ImmutableStruct.html) Immutable struct where values are set at construction and cannot be changed later.
-* [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutableStruct.html) Synchronized, mutable struct where values can be safely changed at any time.
-* [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/SettableStruct.html) Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
+*   [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ImmutableStruct.html)
+    Immutable struct where values are set at construction and cannot be changed later.
+*   [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MutableStruct.html)
+    Synchronized, mutable struct where values can be safely changed at any time.
+*   [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/SettableStruct.html)
+    Synchronized, write-once struct where values can be set at most once, either at construction 
+    or any time thereafter.
 
 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).
+*   [Agent](http://ruby-concurrency.github.io/concurrent-ruby/master/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/master/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/master/Concurrent/AtomicBoolean.html)
+    A boolean value that can be updated atomically.
+*   [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/AtomicFixnum.html)
+    A numeric value that can be updated atomically.
+*   [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/MutexAtomic.html)
+    An object reference that may be updated atomically.
+*   [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/master/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/master/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/master/Concurrent/ThreadLocalVar.html)
+    A variable where the value is different for each thread.
+*   [TVar](http://ruby-concurrency.github.io/concurrent-ruby/master/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
 
-* See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
+*   See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/master/file.thread_pools.html)
+    overview, which also contains a list of other Executors available.
 
 #### 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.
-* [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.
-* [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.
-
+*   [CountDownLatch](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/CountDownLatch.html)
+    A synchronization object that allows one thread to wait on multiple other threads.
+*   [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/master/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/master/Concurrent/Event.html) Old school
+    kernel-style event.
+*   [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ReadWriteLock.html)
+    A lock that supports multiple readers but only one writer.
+*   [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ReentrantReadWriteLock.html)
+    A read/write lock with reentrant and upgrade features.
+*   [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Semaphore.html)
+    A counting-based locking mechanism that uses permits.
+*   [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Atomic/AtomicMarkableReference.html)
+
+#### Deprecated
+
+Deprecated features are still available and bugs are being fixed, but new features will not be added.
+  
+*   ~~[Future](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Future.html):
+    An asynchronous operation that produces a value.~~ Replaced by 
+    [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
+    *   ~~[.dataflow](http://ruby-concurrency.github.io/concurrent-ruby/master/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.~~ Replaced by 
+        [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
+*   ~~[Promise](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promise.html): Similar
+    to Futures, with more features.~~ Replaced by 
+    [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
+*   ~~[Delay](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Delay.html) Lazy evaluation
+    of a block yielding an immutable result. Based on Clojure's 
+    [delay](https://clojuredocs.org/clojure.core/delay).~~ Replaced by 
+    [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
+*   ~~[IVar](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/IVar.html) Similar to a
+    "future" but can be manually assigned once, after which it becomes immutable.~~ Replaced by 
+    [Promises](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html).
+    
 ### Edge Features
 
 These are available in the `concurrent-ruby-edge` companion gem.
 
 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
-be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to `concurrent-ruby` when final.
-
-* [Promises Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promises.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.
-* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html):
-  Implements the Actor Model, where concurrent actors exchange messages.
-* [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)
-* [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LockFreeStack.html)
-
-#### Statuses:
-
-*Why are these not in core?*
-
-- **Promises Framework** - They are being finalized to be able to be moved to core. They'll deprecate old 
-  implementation.
-- **Actor** - Partial documentation and tests; depends on new future/promise framework; stability is good.
-- **Channel** - Brand new implementation; partial documentation and tests; stability is good.
-- **LazyRegister** - Missing documentation and tests.
-- **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Need real world battle testing.
+be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to
+`concurrent-ruby` when final.
+
+*   [Actor](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Actor.html): Implements
+    the Actor Model, where concurrent actors exchange messages.
+    *Status: Partial documentation and tests; depends on new future/promise framework; stability is good.*
+*   [Channel](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/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/).
+    *Status: Partial documentation and tests.*
+*   [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/LazyRegister.html)
+*   [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Edge/LockFreeLinkedSet.html)
+    *Status: will be moved to core soon.*
+*   [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/LockFreeStack.html)
+    *Status: missing documentation and tests.*
+
+## Supported Ruby versions
+
+MRI 2.0 and above, JRuby 9000, TruffleRuby are supported. 
+This gem should be fully compatible with any interpreter that is compliant with Ruby 2.0 or newer.
+Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
+
+The legacy support for Rubinius is kept but it is no longer maintained, if you would like to help 
+please respond to [#739](https://github.com/ruby-concurrency/concurrent-ruby/issues/739).
 
 ## Usage
 
@@ -151,13 +242,16 @@ Everything within this gem can be loaded simply by requiring it:
 require 'concurrent'
 ```
 
+*Requiring only specific abstractions from Concurrent Ruby is not yet supported.*
+
 To use the tools in the Edge gem it must be required separately:
 
 ```ruby
 require 'concurrent-edge'
 ```
 
-If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
+If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could 
+help to reveal the problem.
 
 ## Installation
 
@@ -193,9 +287,9 @@ and run `bundle install` from your shell.
 ### C Extensions for MRI
 
 Potential performance improvements may be achieved under MRI by installing optional C extensions.
-To minimize installation errors the C extensions are available in the `concurrent-ruby-ext` extension
-gem. `concurrent-ruby` and `concurrent-ruby-ext` are always released together with same version.
-Simply install the extension gem too:
+To minimise installation errors the C extensions are available in the `concurrent-ruby-ext`
+extension gem. `concurrent-ruby` and `concurrent-ruby-ext` are always released together with same
+version. Simply install the extension gem too:
 
 ```ruby
 gem install concurrent-ruby-ext
@@ -220,28 +314,32 @@ and load the appropriate C extensions.
 
 #### Note For gem developers
 
-No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users.
-The best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
+No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users. The
+best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
 
 ## Maintainers
 
-* [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer)
-* [Jerry D'Antonio](https://github.com/jdantonio) (creator)
-* [Michele Della Torre](https://github.com/mighe)
-* [Chris Seaton](https://github.com/chrisseaton)
-* [Paweł Obrok](https://github.com/obrok)
-* [Lucas Allan](https://github.com/lucasallan)
+*   [Petr Chalupa](https://github.com/pitr-ch) (lead maintainer, point-of-contact)
+*   [Jerry D'Antonio](https://github.com/jdantonio) (creator)
+*   [Chris Seaton](https://github.com/chrisseaton)
+
+### Special Thanks to
+
+*   [Brian Durand](https://github.com/bdurand) for the `ref` gem
+*   [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
+*   [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
 
-### Special Thanks
+and to the past maintainers
 
-* [Brian Durand](https://github.com/bdurand) for the `ref` gem
-* [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
-* [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
+*   [Michele Della Torre](https://github.com/mighe)
+*   [Paweł Obrok](https://github.com/obrok)
+*   [Lucas Allan](https://github.com/lucasallan)
 
 ## License and Copyright
 
-*Concurrent Ruby* is free software released under the [MIT License](http://www.opensource.org/licenses/MIT).
+*Concurrent Ruby* is free software released under the 
+[MIT License](http://www.opensource.org/licenses/MIT).
 
-The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo)
-was designed by [David Jones](https://twitter.com/zombyboy).
-It is Copyright &copy; 2014 [Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.
+The *Concurrent Ruby* [logo](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Logo) was
+designed by [David Jones](https://twitter.com/zombyboy). It is Copyright &copy; 2014 
+[Jerry D'Antonio](https://twitter.com/jerrydantonio). All Rights Reserved.

data/ext/{concurrent → concurrent-ruby-ext}/atomic_boolean.c

@@ -21,13 +21,12 @@ VALUE method_atomic_boolean_initialize(int argc, VALUE* argv, VALUE self) {
 }
 
 VALUE method_atomic_boolean_value(VALUE self) {
-  return (VALUE) DATA_PTR(self);
+  return(ir_get(self));
 }
 
 VALUE method_atomic_boolean_value_set(VALUE self, VALUE value) {
   VALUE new_value = TRUTHY(value);
-  DATA_PTR(self) = (void *) new_value;
-  return(new_value);
+  return(ir_set(self, new_value));
 }
 
 VALUE method_atomic_boolean_true_question(VALUE self) {

data/ext/{concurrent → concurrent-ruby-ext}/atomic_reference.c

@@ -7,8 +7,38 @@
 /*#include <libkern/OSAtomic.h>*/
 /*#endif*/
 
+/*
+Following the wisdom of postgres, we opt to use platform specific memory barriers when available.
+These are generally more performant. In this PR, we add specific cases for i386, x86_64.
+
+In the future, we could look at using pg's atomics library directly:
+https://github.com/postgres/postgres/tree/9d4649ca49416111aee2c84b7e4441a0b7aa2fac/src/include/port/atomics
+
+Point of contact @ianks
+*/
+
 #include "atomic_reference.h"
 
+#if (defined(__i386__) || defined(__i386)) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
+#define memory_barrier() \
+  __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory", "cc")
+#elif defined(__x86_64__) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
+#define memory_barrier() \
+  __asm__ __volatile__ ("lock; addl $0,0(%%rsp)" : : : "memory", "cc")
+#elif defined(HAVE_GCC__ATOMIC_INT32_CAS)
+#define memory_barrier() \
+  __atomic_thread_fence(__ATOMIC_SEQ_CST)
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
+#define memory_barrier() \
+  __sync_synchronize();
+#elif defined _MSC_VER
+#define memory_barrier() \
+  MemoryBarrier();
+#elif __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
+#define memory_barrier() \
+  OSMemoryBarrier();
+#endif
+
 void ir_mark(void *value) {
   rb_gc_mark_maybe((VALUE) value);
 }
@@ -27,25 +57,13 @@ VALUE ir_initialize(int argc, VALUE* argv, VALUE self) {
 }
 
 VALUE ir_get(VALUE self) {
-#if HAVE_GCC_SYNC
-  __sync_synchronize();
-#elif defined _MSC_VER
-  MemoryBarrier();
-#elif __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
-  OSMemoryBarrier();
-#endif
+  memory_barrier();
   return (VALUE) DATA_PTR(self);
 }
 
 VALUE ir_set(VALUE self, VALUE new_value) {
   DATA_PTR(self) = (void *) new_value;
-#if HAVE_GCC_SYNC
-  __sync_synchronize();
-#elif defined _MSC_VER
-  MemoryBarrier();
-#elif __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
-  OSMemoryBarrier();
-#endif
+  memory_barrier();
   return new_value;
 }
 

data/ext/concurrent-ruby-ext/extconf.rb

@@ -0,0 +1,22 @@
+require 'fileutils'
+
+extension_name = 'concurrent_ruby_ext'
+
+require 'mkmf'
+dir_config(extension_name)
+have_header "libkern/OSAtomic.h"
+
+compiler_is_gcc = (CONFIG["GCC"] && !CONFIG["GCC"].empty?) ||
+    # This could stand to be more generic...  but I am afraid.
+    CONFIG["CC"] =~ /\bgcc\b/
+
+if compiler_is_gcc
+  case CONFIG["arch"]
+  when /mswin32|mingw|solaris/
+    $CFLAGS += " -march=native"
+  when 'i686-linux'
+    $CFLAGS += " -march=i686"
+  end
+end
+
+create_makefile File.join('concurrent', extension_name)

data/ext/{concurrent → concurrent-ruby-ext}/rb_concurrent.c

@@ -13,7 +13,7 @@ static VALUE rb_cAtomicFixnum;
 
 // Init_extension
 
-void Init_extension() {
+void Init_concurrent_ruby_ext() {
 
   // define modules and classes
   rb_mConcurrent = rb_define_module("Concurrent");

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-ext
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0.pre1
 platform: x86-mingw32
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-24 00:00:00.000000000 Z
+date: 2018-08-15 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.5
+        version: 1.1.0.pre1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.1.0.pre1
 description: |2
       C extensions to optimize the concurrent-ruby gem when running under MRI.
       Please see http://concurrent-ruby.com for more information.
@@ -33,28 +33,27 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
-- LICENSE.txt
+- LICENSE.md
 - CHANGELOG.md
 files:
 - CHANGELOG.md
-- LICENSE.txt
+- LICENSE.md
 - README.md
-- ext/concurrent/atomic_boolean.c
-- ext/concurrent/atomic_boolean.h
-- ext/concurrent/atomic_fixnum.c
-- ext/concurrent/atomic_fixnum.h
-- ext/concurrent/atomic_reference.c
-- ext/concurrent/atomic_reference.h
-- ext/concurrent/extconf.rb
-- ext/concurrent/rb_concurrent.c
-- ext/concurrent/ruby_193_compatible.h
-- lib/concurrent/1.9/extension.so
-- lib/concurrent/2.0/extension.so
-- lib/concurrent/2.1/extension.so
-- lib/concurrent/2.2/extension.so
-- lib/concurrent/atomic_reference/concurrent_update_error.rb
-- lib/concurrent/atomic_reference/direct_update.rb
-- lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
+- ext/concurrent-ruby-ext/atomic_boolean.c
+- ext/concurrent-ruby-ext/atomic_boolean.h
+- ext/concurrent-ruby-ext/atomic_fixnum.c
+- ext/concurrent-ruby-ext/atomic_fixnum.h
+- ext/concurrent-ruby-ext/atomic_reference.c
+- ext/concurrent-ruby-ext/atomic_reference.h
+- ext/concurrent-ruby-ext/extconf.rb
+- ext/concurrent-ruby-ext/rb_concurrent.c
+- ext/concurrent-ruby-ext/ruby_193_compatible.h
+- lib/concurrent/2.0/concurrent_ruby_ext.so
+- lib/concurrent/2.1/concurrent_ruby_ext.so
+- lib/concurrent/2.2/concurrent_ruby_ext.so
+- lib/concurrent/2.3/concurrent_ruby_ext.so
+- lib/concurrent/2.4/concurrent_ruby_ext.so
+- lib/concurrent/2.5/concurrent_ruby_ext.so
 homepage: http://www.concurrent-ruby.com
 licenses:
 - MIT
@@ -63,20 +62,22 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
-- ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: C extensions to optimize concurrent-ruby under MRI.

data/ext/concurrent/extconf.rb

@@ -1,58 +0,0 @@
-require 'fileutils'
-
-$:.unshift(File.expand_path('../../../lib', __FILE__))
-require 'concurrent/utility/native_extension_loader'
-
-EXTENSION_NAME = 'extension'
-
-def create_dummy_makefile
-  File.open('Makefile', 'w') do |f|
-    f.puts 'all:'
-    f.puts 'install:'
-  end
-end
-
-if Concurrent.on_jruby? || ! Concurrent.allow_c_extensions?
-  create_dummy_makefile
-  warn 'C optimizations are not supported on this version of Ruby.'
-else
-  begin
-
-    require 'mkmf'
-    dir_config(EXTENSION_NAME)
-
-    have_header "libkern/OSAtomic.h"
-
-    def compiler_is_gcc
-      if CONFIG["GCC"] && CONFIG["GCC"] != ""
-        return true
-      elsif ( # This could stand to be more generic...  but I am afraid.
-             CONFIG["CC"] =~ /\bgcc\b/
-            )
-        return true
-      end
-      return false
-    end
-
-    if compiler_is_gcc
-      case CONFIG["arch"]
-      when /mswin32|mingw|solaris/
-        $CFLAGS += " -march=native"
-      when 'i686-linux'
-        $CFLAGS += " -march=i686"
-      end
-    end
-
-    try_run(<<CODE,$CFLAGS) && ($defs << '-DHAVE_GCC_SYNC')
-      int main() {
-        __sync_synchronize();
-        return 0;
-      }
-CODE
-
-    create_makefile('concurrent/' + EXTENSION_NAME)
-  rescue
-    create_dummy_makefile
-    warn 'C optimizations cannot be compiled on this version of Ruby.'
-  end
-end

data/lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -1,8 +0,0 @@
-module Concurrent
-
-  # @!macro atomic_reference
-  class ConcurrentUpdateError < ThreadError
-    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-  end
-end

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -1,81 +0,0 @@
-require 'concurrent/atomic_reference/concurrent_update_error'
-
-module Concurrent
-
-  # Define update methods that use direct paths
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicDirectUpdate
-
-    # @!macro [attach] atomic_reference_method_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. May retry if the value changes
-    # during the block's execution.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @return [Object] the new value
-    def update
-      true until compare_and_set(old_value = get, new_value = yield(old_value))
-      new_value
-    end
-
-    # @!macro [attach] atomic_reference_method_try_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Return nil if the update fails.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @note This method was altered to avoid raising an exception by default.
-    # Instead, this method now returns `nil` in case of failure. For more info,
-    # please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #
-    # @return [Object] the new value, or nil if update failed
-    def try_update
-      old_value = get
-      new_value = yield old_value
-
-      return unless compare_and_set old_value, new_value
-
-      new_value
-    end
-
-    # @!macro [attach] atomic_reference_method_try_update!
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Raise an exception if the update
-    # fails.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @note This behavior mimics the behavior of the original
-    # `AtomicReference#try_update` API. The reason this was changed was to
-    # avoid raising exceptions (which are inherently slow) by default. For more
-    # info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #
-    # @return [Object] the new value
-    #
-    # @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update!
-      old_value = get
-      new_value = yield old_value
-      unless compare_and_set(old_value, new_value)
-        if $VERBOSE
-          raise ConcurrentUpdateError, "Update failed"
-        else
-          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
-        end
-      end
-      new_value
-    end
-  end
-end

data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -1,28 +0,0 @@
-module Concurrent
-
-  # Special "compare and set" handling of numeric values.
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicNumericCompareAndSetWrapper
-
-    # @!macro atomic_reference_method_compare_and_set
-    def compare_and_set(old_value, new_value)
-      if old_value.kind_of? Numeric
-        while true
-          old = get
-
-          return false unless old.kind_of? Numeric
-
-          return false unless old == old_value
-
-          result = _compare_and_set(old, new_value)
-          return result if result
-        end
-      else
-        _compare_and_set(old_value, new_value)
-      end
-    end
-    alias_method :compare_and_swap, :compare_and_set
-  end
-end