concurrent-ruby-ext 0.8.0-x86-mingw32 → 0.9.0.pre2-x86-mingw32

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTQzZGQzNDk4NmE3MDA1MDU1NGQwNmRmOGFmZGI4ZGQ0MWVlYmVlMg==
+    YTBhMjY1ZTBjNTc1Mjc5N2M1YzUyYTYzYWZiN2MyN2MzZDIxMDRlMw==
   data.tar.gz: !binary |-
-    ZTM2ODRkZTM0YTU0MDhjYTI1Yjg0NzU2ZDVmZTQzNzYyNjI1N2ZjMQ==
+    N2JhZThlMTA1NGU0Yzk1MGIzNWZhNzI4OTBkOTBhMzgzMGNjZjQwOA==
 SHA512:
   metadata.gz: !binary |-
-    ZWE0MzQyMzBhOGJhYjAwYWM4MGZjY2VlNzgxZWE3ODA0NzNjNjM2YzQzMGZj
-    MTMzYzI1ODFiNmQ4MmZhZDRjZTliMGJhNmFkY2Y0NjRjNWZlMGU1OTY3NGQ3
-    ODUwOGM4MzE0ZDA5ZTRlNTlhNDg3MjRlOTZjNWQ3YzVmZjlhMWI=
+    NGIyZGExMWZhMWRkZDA2MDg5OTc4ZDMxM2IzNTQwNTlhMjY0OGZiN2EzYjg4
+    NWYwNmU3MTFiNmY2M2U1MDNjM2ZmNGJlMTc3ZWFjOTFjMWYyZWE4ZGRhMmI2
+    YjZiMDcyMTIyYThiNzg3NTI5MTk4ZTg1OGI3ZTZiMDI1NzdkNTY=
   data.tar.gz: !binary |-
-    YTZmOTdhNDM3MTYwYTYxNjQxYmU1MzA4ZDA2YjA5YmRiN2Y1YjUxYWRkMTQz
-    NzkwMzc1NzE3MTYzZjhkZmRhNzYzYmIyMDZhZDk2MzVmZjQ0NzdhMGM5NTdm
-    ZWNlMDc1NGRiMWQzOTY0ZDBmYzFhZTA0MDI2ZjQ4Mjk5ZDRiZTE=
+    YjdmODlkM2RlMjViYTFhYjc4MWIwYjNhZWI4YzNmOTRjZTM5NDg2ZWU5NWZj
+    OTMxNDgwYzkxZWFlMmJkODU5M2U1YTZlYTAwMzkwMWYwMjZjYTY5MTE2ZGRm
+    M2JhZTFiODExNjg1OTBmMWUwNWE3MWY2ZmI5MGEyYmJhYWRkYjA=

data/CHANGELOG.md

@@ -1,11 +1,106 @@
-### Next Release v0.8.0 (25 January 2015)
+### Next Release v0.9.0 (Target Date: 7 June 2015)
+
+* Pure Java implementations of
+  - `AtomicBoolean`
+  - `AtomicFixnum`
+  - `Semaphore`
+* Fixed bug when pruning Ruby thread pools
+* Fixed bug in time calculations within `ScheduledTask`
+* Default `count` in `CountDownLatch` to 1
+* Use monotonic clock for all timers via `Concurrent.monotonic_time`
+  - Use `Process.clock_gettime(Process::CLOCK_MONOTONIC)` when available
+  - Fallback to `java.lang.System.nanoTime()` on unsupported JRuby versions
+  - Pure Ruby implementation for everything else
+  - Effects `Concurrent.timer`, `Concurrent.timeout`, `TimerSet`, `TimerTask`, and `ScheduledTask`
+* Deprecated all clock-time based timer scheduling
+  - Only support scheduling by delay
+  - Effects `Concurrent.timer`, `TimerSet`, and `ScheduledTask`
+* Added new `ReadWriteLock` class
+* Consistent `at_exit` behavior for Java and Ruby thread pools.
+* Added `at_exit` handler to Ruby thread pools (already in Java thread pools)
+  - Ruby handler stores the object id and retrieves from `ObjectSpace`
+  - JRuby disables `ObjectSpace` by default so that handler stores the object reference
+* Added a `:stop_on_exit` option to thread pools to enable/disable `at_exit` handler
+* Updated thread pool docs to better explain shutting down thread pools
+* Simpler `:executor` option syntax for all abstractions which support this option
+* Added `Executor#auto_terminate?` predicate method (for thread pools)
+* Added `at_exit` handler to `TimerSet`
+* Simplified auto-termination of the global executors
+  - Can now disable auto-termination of global executors
+  - Added shutdown/kill/wait_for_termination variants for global executors
+* Can now disable auto-termination for *all* executors (the nuclear option)
+* Simplified auto-termination of the global executors
+* Deprecated terms "task pool" and "operation pool"
+  - New terms are "io executor" and "fast executor"
+  - New functions added with new names
+  - Deprecation warnings added to functions referencing old names
+* Moved all thread pool related functions from `Concurrent::Configuration` to `Concurrent`
+  - Old functions still exist with deprecation warnings
+  - New functions have updated names as appropriate
+* All high-level abstractions default to the "io executor"
+* Fixed bug in `Actor` causing it to prematurely warm global thread pools on gem load
+  - This also fixed a `RejectedExecutionError` bug when running with minitest/autorun via JRuby
+* Moved global logger up to the `Concurrent` namespace and refactored the code
+* Optimized the performance of `Delay`
+  - Fixed a bug in which no executor option on construction caused block execution on a global thread pool
+* Numerous improvements and bug fixes to `TimerSet`
+* Fixed deadlock of `Future` when the handler raises Exception
+* Added shared specs for more classes
+* New concurrency abstractions including:
+  - `Atom`
+  - `Maybe`
+  - `ImmutableStruct`
+  - `MutableStruct`
+  - `SettableStruct`
+* Created an Edge gem for unstable abstractions including
+  - `Actor`
+  - `Agent`
+  - `Channel`
+  - `Exchanger`
+  - `LazyRegister`
+  - **new Future Framework** <http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge.html> - 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 paths **lock-free** with exception of blocking threads on `#wait`.
+    It offers better performance and does not block threads when not required.
+* Actor framework changes:
+  - fixed reset loop in Pool
+  - Pool can use any actor as a worker, abstract worker class is no longer needed.
+  - Actor events not have format `[:event_name, *payload]` instead of just the Symbol.
+  - Actor now uses new Future/Promise Framework instead of `IVar` for better interoperability
+  - Behaviour definition array was simplified to `[BehaviourClass1, [BehaviourClass2, *initialization_args]]`
+  - Linking behavior responds to :linked message by returning array of linked actors
+  - Supervised behavior is removed in favour of just Linking
+  - RestartingContext is supervised by default now, `supervise: true` is not required any more
+  - Events can be private and public, so far only difference is that Linking will
+    pass to linked actors only public messages. Adding private :restarting and
+    :resetting events which are send before the actor restarts or resets allowing
+    to add callbacks to cleanup current child actors.
+  - Print also object_id in Reference to_s
+  - Add AbstractContext#default_executor to be able to override executor class wide
+  - Add basic IO example
+  - Documentation somewhat improved
+  - All messages should have same priority. It's now possible to send `actor << job1 << job2 << :terminate!` and 
+    be sure that both jobs are processed first.
+* Refactored `Channel` to use newer synchronization objects
+* Added `#reset` and `#cancel` methods to `TimerSet`
+* Added `#cancel` method to `Future` and `ScheduledTask`
+* Refactored `TimerSet` to use `ScheduledTask`
+* Updated `Async` with a factory that initializes the object
+* Deprecated `Concurrent.timer` and `Concurrent.timeout`
+* Reduced max threads on pure-Ruby thread pools (abends around 14751 threads)
+* Moved many private/internal classes/modules into "namespace" modules
+* Removed brute-force killing of threads in tests
+* Fixed a thread pool bug when the operating system cannot allocate more threads
+
+## Current Release v0.8.0 (25 January 2015)
 
 * C extension for MRI have been extracted into the `concurrent-ruby-ext` companion gem.
   Please see the README for more detail.
 * Better variable isolation in `Promise` and `Future` via an `:args` option
 * Continued to update intermittently failing tests
 
-## Current Release v0.7.2 (24 January 2015)
+### Release v0.7.2 (24 January 2015)
 
 * New `Semaphore` class based on [java.util.concurrent.Semaphore](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html)
 * New `Promise.all?` and `Promise.any?` class methods

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) [![Coverage Status](https://img.shields.io/coveralls/ruby-concurrency/concurrent-ruby/master.svg)](https://coveralls.io/r/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) [![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>
@@ -50,52 +50,91 @@ We also have a [mailing list](http://groups.google.com/group/concurrent-ruby).
 
 This library contains a variety of concurrency abstractions at high and low levels. One of the high-level abstractions is likely to meet most common needs. 
 
-### High-level, general-purpose asynchronous concurrency abstractions
+#### General-purpose Concurrency Abstractions
 
-* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html): Implements the Actor Model, where concurrent actors exchange messages.
-* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
 * [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.
+* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
 * [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/Dataflow.html): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+  * [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. 
-* [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html): Communicating Sequential Processes (CSP). 
 
-### Java-inspired ThreadPools and other executors
+#### Thread-safe Value Objects
 
-* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
+* `Maybe` 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` Lazy evaluation of a block yielding an immutable result. Based on Clojure's
+   [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
 
-### Thread-safe Observers
+#### Thread-safe Structures
 
-* [Concurrent::Observable](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Observable.html) mixin module
-* [CopyOnNotifyObserverSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CopyOnNotifyObserverSet.html)
-* [CopyOnWriteObserverSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CopyOnWriteObserverSet.html)
+Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
 
-### Thread synchronization classes and algorithms
+* `ImmutableStruct` Immutable struct where values are set at construction and cannot be changed later.
+* `MutableStruct` Synchronized, mutable struct where values can be safely changed at any time.
+* `SettableStruct` Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
 
-Lower-level abstractions mainly used as building blocks. 
+#### Java-inspired ThreadPools and Other Executors
 
-* [condition](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Condition.html)
-* [countdown latch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
-* [cyclic barrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
-* [event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
-* [exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
-* [semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
-* [timeout](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timeout-class_method)
-* [timer](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timer-class_method)
+* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
 
-### Thread-safe variables
+#### Thread Synchronization Classes and Algorithms
 
-Lower-level abstractions mainly used as building blocks. 
+* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
+* [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
+* [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
+* [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
+
+#### Thread-safe Variables
 
 * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
 * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
-* AtomicReference (no docs currently available, check source)
+* [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html)
 * [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
 * [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
-* [thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
-* [software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
+* [Thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
+* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
+* [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html)
+
+### Edge Features
+
+These are available in the `concurrent-ruby-edge` companion gem, installed with `gem install concurrent-ruby-edge`.
+
+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.
+
+* [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.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 paths **lock-free** with exception of blocking threads on `#wait`.
+  It offers better performance and does not block threads when not required.
+* [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).
+* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
+* [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
+* [New Future Promise Framework](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge.html) - new 
+  unified implementation of Futures and Promises which combines Features of previous `Future`,
+  `Promise`, `IVar`, `Probe`, `dataflow`, `Delay`, `TimerTask` into single framework. It uses extensively
+  new synchronization layer to make all the paths lock-free with exception of blocking threads on `#wait`.
+  It offers better performance and does not block threads (exception being `#wait` and similar methods where it's
+  intended).
+
+
+#### Statuses:
+
+*Why is 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.   
 
 ## Usage
 
@@ -112,29 +151,39 @@ require 'concurrent'                # everything
 
 # groups
 
-require 'concurrent/actor'          # Concurrent::Actor and supporting code
 require 'concurrent/atomics'        # atomic and thread synchronization classes
-require 'concurrent/channels'       # Concurrent::Channel and supporting code
 require 'concurrent/executors'      # Thread pools and other executors
-require 'concurrent/utilities'      # utility methods such as processor count and timers
 
 # individual abstractions
 
+require 'concurrent/async'            # Concurrent::Async
+require 'concurrent/atom'             # Concurrent::Atom
+require 'concurrent/dataflow'         # Concurrent::dataflow
+require 'concurrent/delay'            # Concurrent::Delay
+require 'concurrent/future'           # Concurrent::Future
+require 'concurrent/immutable_struct' # Concurrent::ImmutableStruct
+require 'concurrent/ivar'             # Concurrent::IVar
+require 'concurrent/maybe'            # Concurrent::Maybe
+require 'concurrent/mutable_struct'   # Concurrent::MutableStruct
+require 'concurrent/mvar'             # Concurrent::MVar
+require 'concurrent/promise'          # Concurrent::Promise
+require 'concurrent/scheduled_task'   # Concurrent::ScheduledTask
+require 'concurrent/settable_struct'  # Concurrent::SettableStruct
+require 'concurrent/timer_task'       # Concurrent::TimerTask
+require 'concurrent/tvar'             # Concurrent::TVar
+
+# experimental - available in `concurrent-ruby-edge` companion gem
+
+require 'concurrent/actor'          # Concurrent::Actor and supporting code
+require 'concurrent/edge/future'    # new Future Framework
 require 'concurrent/agent'          # Concurrent::Agent
-require 'concurrent/async'          # Concurrent::Async
-require 'concurrent/atomic'         # Concurrent::Atomic (formerly the `atomic` gem)
-require 'concurrent/dataflow'       # Concurrent::dataflow
-require 'concurrent/delay'          # Concurrent::Delay
+require 'concurrent/channel '       # Concurrent::Channel and supporting code
 require 'concurrent/exchanger'      # Concurrent::Exchanger
-require 'concurrent/future'         # Concurrent::Future
-require 'concurrent/ivar'           # Concurrent::IVar
-require 'concurrent/mvar'           # Concurrent::MVar
-require 'concurrent/promise'        # Concurrent::Promise
-require 'concurrent/scheduled_task' # Concurrent::ScheduledTask
-require 'concurrent/timer_task'     # Concurrent::TimerTask
-require 'concurrent/tvar'           # Concurrent::TVar
+require 'concurrent/lazy_register'  # Concurrent::LazyRegister
 ```
 
+If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
+
 ## Installation
 
 ```shell
@@ -153,8 +202,8 @@ and run `bundle install` from your shell.
 
 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. The extension gem lists `concurrent-ruby` as a dependency so it is not necessary to install both.
-Simply install the extension gen:
+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
@@ -191,22 +240,22 @@ any platform. *Documentation is forthcoming...*
 
 ```
 *MRI only*
-rake build:native       # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg directory
-rake compile:extension  # Compile extension
+bundle exec rake build:native       # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg dir
+bundle exec rake compile:extension  # Compile extension
 
 *JRuby only*
-rake build              # Build JRuby-specific core gem (alias for `build:core`)
-rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory
+bundle exec rake build              # Build JRuby-specific core gem (alias for `build:core`)
+bundle exec rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory
 
 *All except JRuby*
-rake build              # Build core and extension gems
-rake build:core         # Build concurrent-ruby-<version>.gem into the pkg directory
-rake build:ext          # Build concurrent-ruby-ext-<version>.gem into the pkg directory
+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
 
 *All*
-rake clean              # Remove any temporary products
-rake clobber            # Remove any generated file
-rake compile            # Compile all the extensions
+bundle exec rake clean              # Remove any temporary products
+bundle exec rake clobber            # Remove any generated file
+bundle exec rake compile            # Compile all the extensions
 ```
 
 ## Maintainers
@@ -218,7 +267,7 @@ rake compile            # Compile all the extensions
 * [Petr Chalupa](https://github.com/pitr-ch)
 * [Paweł Obrok](https://github.com/obrok)
 
-### Contributing
+## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/ext/concurrent/atomic_reference.c

@@ -50,9 +50,13 @@ VALUE ir_set(VALUE self, VALUE new_value) {
 }
 
 VALUE ir_get_and_set(VALUE self, VALUE new_value) {
-  VALUE old_value = ir_get(self);
-  ir_set(self, new_value);
-  return old_value;
+  VALUE old_value;
+  for (;;) {
+    old_value = ir_get(self);
+    if (ir_compare_and_set(self, old_value, new_value) == Qtrue) {
+      return old_value;
+    }
+  }
 }
 
 VALUE ir_compare_and_set(volatile VALUE self, VALUE expect_value, VALUE new_value) {

data/ext/concurrent/extconf.rb

@@ -1,6 +1,6 @@
 require 'fileutils'
 
-require_relative '../../lib/extension_helper'
+require 'concurrent/utility/native_extension_loader'
 
 EXTENSION_NAME = 'extension'
 
@@ -11,7 +11,7 @@ def create_dummy_makefile
   end
 end
 
-if defined?(JRUBY_VERSION) || ! Concurrent.allow_c_extensions? 
+if Concurrent.on_jruby? || ! Concurrent.allow_c_extensions?
   create_dummy_makefile
   warn 'C optimizations are not supported on this version of Ruby.'
 else

data/ext/concurrent/rb_concurrent.c

@@ -7,7 +7,7 @@
 // module and class definitions
 
 static VALUE rb_mConcurrent;
-static VALUE rb_cAtomic;
+static VALUE rb_cAtomicReference;
 static VALUE rb_cAtomicBoolean;
 static VALUE rb_cAtomicFixnum;
 
@@ -17,20 +17,20 @@ void Init_extension() {
 
   // define modules and classes
   rb_mConcurrent = rb_define_module("Concurrent");
-  rb_cAtomic = rb_define_class_under(rb_mConcurrent, "CAtomic", rb_cObject);
+  rb_cAtomicReference = rb_define_class_under(rb_mConcurrent, "CAtomicReference", rb_cObject);
   rb_cAtomicBoolean = rb_define_class_under(rb_mConcurrent, "CAtomicBoolean", rb_cObject);
   rb_cAtomicFixnum = rb_define_class_under(rb_mConcurrent, "CAtomicFixnum", rb_cObject);
 
-  // CAtomic
-  rb_define_alloc_func(rb_cAtomic, ir_alloc);
-  rb_define_method(rb_cAtomic, "initialize", ir_initialize, -1);
-  rb_define_method(rb_cAtomic, "get", ir_get, 0);
-  rb_define_method(rb_cAtomic, "set", ir_set, 1);
-  rb_define_method(rb_cAtomic, "get_and_set", ir_get_and_set, 1);
-  rb_define_method(rb_cAtomic, "_compare_and_set", ir_compare_and_set, 2);
-  rb_define_alias(rb_cAtomic, "value", "get");
-  rb_define_alias(rb_cAtomic, "value=", "set");
-  rb_define_alias(rb_cAtomic, "swap", "get_and_set");
+  // CAtomicReference
+  rb_define_alloc_func(rb_cAtomicReference, ir_alloc);
+  rb_define_method(rb_cAtomicReference, "initialize", ir_initialize, -1);
+  rb_define_method(rb_cAtomicReference, "get", ir_get, 0);
+  rb_define_method(rb_cAtomicReference, "set", ir_set, 1);
+  rb_define_method(rb_cAtomicReference, "get_and_set", ir_get_and_set, 1);
+  rb_define_method(rb_cAtomicReference, "_compare_and_set", ir_compare_and_set, 2);
+  rb_define_alias(rb_cAtomicReference, "value", "get");
+  rb_define_alias(rb_cAtomicReference, "value=", "set");
+  rb_define_alias(rb_cAtomicReference, "swap", "get_and_set");
 
   // CAtomicBoolean
   rb_define_alloc_func(rb_cAtomicBoolean, atomic_boolean_allocate);

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -3,6 +3,9 @@ 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

data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -1,6 +1,9 @@
 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-ext
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0.pre2
 platform: x86-mingw32
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-25 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0.pre2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.0.pre2
 description: ! "    C extensions to optimize the concurrent-ruby gem when running
   under MRI.\n    Please see http://concurrent-ruby.com for more information.\n"
 email: jerry.dantonio@gmail.com
@@ -52,7 +52,6 @@ files:
 - lib/concurrent/atomic_reference/concurrent_update_error.rb
 - lib/concurrent/atomic_reference/direct_update.rb
 - lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
-- lib/extension_helper.rb
 homepage: http://www.concurrent-ruby.com
 licenses:
 - MIT
@@ -69,12 +68,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 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.5
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: C extensions to optimize concurrent-ruby under MRI.

data/lib/extension_helper.rb

@@ -1,37 +0,0 @@
-module Concurrent
-
-  @@c_ext_loaded ||= false
-  @@java_ext_loaded ||= false
-
-  # @!visibility private
-  def self.allow_c_extensions?
-    defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-  end
-
-  # @!visibility private
-  def self.jruby?
-    RUBY_PLATFORM == 'java'
-  end
-
-  if allow_c_extensions? && !@@c_ext_loaded
-    begin
-      require 'concurrent/extension'
-      @@c_ext_loaded = true
-    rescue LoadError
-      # may be a Windows cross-compiled native gem
-      begin
-        require "concurrent/#{RUBY_VERSION[0..2]}/extension"
-        @@c_ext_loaded = true
-      rescue LoadError
-        warn 'Performance on MRI may be improved with the concurrent-ruby-ext gem. Please see http://concurrent-ruby.com'
-      end
-    end
-  elsif jruby? && !@@java_ext_loaded
-    begin
-      require 'concurrent_ruby_ext'
-      @@java_ext_loaded = true
-    rescue LoadError
-      warn 'Performance on JRuby may be improved by installing the pre-compiled Java extensions. Please see http://concurrent-ruby.com'
-    end
-  end
-end