concurrent-ruby-ext 0.1.0.pre1-x86-mingw32

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZDkyZGNhOGQxOGM0MGE0M2JiMzM5NTEyMGNlZTFlYjQyMDZjNTM3NA==
+  data.tar.gz: !binary |-
+    ZGYwNzA3NGIyMTY5YTdjNGJiYmU5NWMyNTVmNjE0MjE3ZWRjYTIyYw==
+SHA512:
+  metadata.gz: !binary |-
+    YTlkNTk4MmI0ZThmMmVhNzIxZTY4YzNmMTA2NWE5ODA4ZjBkMDExMzBlNDJj
+    Mzc4YTM2ZDBjNTQ3OTg3NTg4MzQ5MGFkZTBmMjRhNTg2ODcxNzc4ZTE0Zjdm
+    YjIwNTRjZDQwMWIxYTllOGNmNGYwZjZkOWEyMGJjMjdlNzlmZGY=
+  data.tar.gz: !binary |-
+    YzVlMWEyN2MxY2E3NmRhNGJhYWE0MjkxNDY3NDk0NDY5MjE3ZGZlYjZkZmEw
+    ZGUzZWVjNmE4OGNkNmI1YThkZDZjMDVkMmRiZGExNmM5MzI4YjIwMjE2Zjcz
+    Yjg3Y2MwYWIwZWY4NDJlZDMxNzc4YTE2ZWY5MjVkNzRhYzg4ODY=

data/CHANGELOG.md

@@ -0,0 +1,149 @@
+### Next Release v0.7.2 (TBD)
+
+* New `Promise.all?` and `Promise.any?` class methods
+* Renamed `:overflow_policy` on thread pools to `:fallback_policy`
+* Thread pools still accept the `:overflow_policy` option but display a warning
+* Thread pools now implement `fallback_policy` behavior when not running (rather than universally rejecting tasks)
+* Fixed minor `set_deref_options` constructor bug in `Promise` class
+* Numerous non-functional updates to clear warning when running in debug mode
+* Fixed more intermittently failing tests
+* Tests now run on new Travis build environment
+
+## Current Release v0.7.1 (4 December 2014)
+
+Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/issues/142) for more information on the next planned release.
+
+* Added `flat_map` method to `Promise`
+* Added `zip` method to `Promise`
+* Fixed bug with logging in `Actor`
+* Improvements to `Promise` tests
+* Removed actor-experimental warning
+* Added an `IndirectImmediateExecutor` class
+* Allow disabling auto termination of global executors
+* Fix thread leaking in `ThreadLocalVar` (uses `Ref` gem on non-JRuby systems)
+* Fix thread leaking when pruning pure-Ruby thread pools
+* Prevent `Actor` from using an `ImmediateExecutor` (causes deadlock)
+* Added missing synchronizations to `TimerSet`
+* Fixed bug with return value of `Concurrent::Actor::Utils::Pool#ask`
+* Fixed timing bug in `TimerTask`
+* Fixed bug when creating a `JavaThreadPoolExecutor` with minimum pool size of zero
+* Removed confusing warning when not using native extenstions
+* Improved documentation
+
+### Release v0.7.0 (13 August 2014)
+
+* Merge the [atomic](https://github.com/ruby-concurrency/atomic) gem
+  - Pure Ruby `MutexAtomic` atomic reference class
+  - Platform native atomic reference classes `CAtomic`, `JavaAtomic`, and `RbxAtomic`
+  - Automated [build process](https://github.com/ruby-concurrency/rake-compiler-dev-box)
+  - Fat binary releases for [multiple platforms](https://rubygems.org/gems/concurrent-ruby/versions) including Windows (32/64), Linux (32/64), OS X (64-bit), Solaris (64-bit), and JRuby
+* C native `CAtomicBoolean`
+* C native `CAtomicFixnum`
+* Refactored intermittently failing tests
+* Added `dataflow!` and `dataflow_with!` methods to match `Future#value!` method
+* Better handling of timeout in `Agent`
+* Actor Improvements
+  - Fine-grained implementation using chain of behaviors. Each behavior is responsible for single aspect like: `Termination`, `Pausing`, `Linking`, `Supervising`, etc. Users can create custom Actors easily based on their needs.
+  - Supervision was added. `RestartingContext` will pause on error waiting on its supervisor to decide what to do next ( options are `:terminate!`, `:resume!`, `:reset!`, `:restart!`). Supervising behavior also supports strategies `:one_for_one` and `:one_for_all`.
+  - Linking was added to be able to monitor actor's events like: `:terminated`, `:paused`, `:restarted`, etc.
+  - Dead letter routing added. Rejected envelopes are collected in a configurable actor (default: `Concurrent::Actor.root.ask!(:dead_letter_routing)`)
+  - Old `Actor` class removed and replaced by new implementation previously called `Actress`. `Actress` was kept as an alias for `Actor` to keep compatibility.
+  - `Utils::Broadcast` actor which allows Publish–subscribe pattern.
+* More executors for managing serialized operations
+  - `SerializedExecution` mixin module
+  - `SerializedExecutionDelegator` for serializing *any* executor
+* Updated `Async` with serialized execution
+* Updated `ImmediateExecutor` and `PerThreadExecutor` with full executor service lifecycle
+* Added a `Delay` to root `Actress` initialization 
+* Minor bug fixes to thread pools
+* Refactored many intermittently failing specs
+* Removed Java interop warning `executor.rb:148 warning: ambiguous Java methods found, using submit(java.lang.Runnable)`
+* Fixed minor bug in `RubyCachedThreadPool` overflow policy
+* Updated tests to use [RSpec 3.0](http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3)
+* Removed deprecated `Actor` class
+* Better support for Rubinius
+
+### Release v0.6.1 (14 June 2014)
+
+* Many improvements to `Concurrent::Actress`
+* Bug fixes to `Concurrent::RubyThreadPoolExecutor`
+* Fixed several brittle tests
+* Moved documentation to http://ruby-concurrency.github.io/concurrent-ruby/frames.html
+
+### Release v0.6.0 (25 May 2014)
+
+* Added `Concurrent::Observable` to encapsulate our thread safe observer sets
+* Improvements to new `Channel`
+* Major improvements to `CachedThreadPool` and `FixedThreadPool`
+* Added `SingleThreadExecutor`
+* Added `Current::timer` function
+* Added `TimerSet` executor
+* Added `AtomicBoolean`
+* `ScheduledTask` refactoring
+* Pure Ruby and JRuby-optimized `PriorityQueue` classes
+* Updated `Agent` behavior to more closely match Clojure
+* Observer sets support block callbacks to the `add_observer` method
+* New algorithm for thread creation in `RubyThreadPoolExecutor`
+* Minor API updates to `Event`
+* Rewritten `TimerTask` now an `Executor` instead of a `Runnable`
+* Fixed many brittle specs
+* Renamed `FixedThreadPool` and `CachedThreadPool` to `RubyFixedThreadPool` and `RubyCachedThreadPool`
+* Created JRuby optimized `JavaFixedThreadPool` and `JavaCachedThreadPool`
+* Consolidated fixed thread pool tests into `spec/concurrent/fixed_thread_pool_shared.rb` and  `spec/concurrent/cached_thread_pool_shared.rb`
+* `FixedThreadPool` now subclasses `RubyFixedThreadPool` or `JavaFixedThreadPool` as appropriate
+* `CachedThreadPool` now subclasses `RubyCachedThreadPool` or `JavaCachedThreadPool` as appropriate
+* New `Delay` class
+* `Concurrent::processor_count` helper function
+* New `Async` module
+* Renamed `NullThreadPool` to `PerThreadExecutor`
+* Deprecated `Channel` (we are planning a new implementation based on [Go](http://golangtutorials.blogspot.com/2011/06/channels-in-go.html))
+* Added gem-level [configuration](http://robots.thoughtbot.com/mygem-configure-block)
+* Deprecated `$GLOBAL_THREAD_POOL` in lieu of gem-level configuration
+* Removed support for Ruby [1.9.2](https://www.ruby-lang.org/en/news/2013/12/17/maintenance-of-1-8-7-and-1-9-2/)
+* New `RubyThreadPoolExecutor` and `JavaThreadPoolExecutor` classes
+* All thread pools now extend the appropriate thread pool executor classes
+* All thread pools now support `:overflow_policy` (based on Java's [reject policies](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html))
+* Deprecated `UsesGlobalThreadPool` in lieu of explicit `:executor` option (dependency injection) on `Future`, `Promise`, and `Agent`
+* Added `Concurrent::dataflow_with(executor, *inputs)` method to support executor dependency injection for dataflow
+* Software transactional memory with `TVar` and `Concurrent::atomically`
+* First implementation of [new, high-performance](https://github.com/ruby-concurrency/concurrent-ruby/pull/49) `Channel`
+* `Actor` is deprecated in favor of new experimental actor implementation [#73](https://github.com/ruby-concurrency/concurrent-ruby/pull/73). To avoid namespace collision it is living in `Actress` namespace until `Actor` is removed in next release.
+
+### Release v0.5.0
+
+This is the most significant release of this gem since its inception. This release includes many improvements and optimizations. It also includes several bug fixes. The major areas of focus for this release were:
+
+* Stability improvements on Ruby versions with thread-level parallelism ([JRuby](http://jruby.org/) and [Rubinius](http://rubini.us/))
+* Creation of new low-level concurrency abstractions
+* Internal refactoring to use the new low-level abstractions
+
+Most of these updates had no effect on the gem API. There are a few notable exceptions which were unavoidable. Please read the [release notes](API-Updates-in-v0.5.0) for more information.
+
+Specific changes include:
+
+* New class `IVar`
+* New class `MVar`
+* New class `ThreadLocalVar`
+* New class `AtomicFixnum`
+* New class method `dataflow`
+* New class `Condition`
+* New class `CountDownLatch`
+* New class `DependencyCounter`
+* New class `SafeTaskExecutor`
+* New class `CopyOnNotifyObserverSet`
+* New class `CopyOnWriteObserverSet`
+* `Future` updated with `execute` API
+* `ScheduledTask` updated with `execute` API
+* New `Promise` API
+* `Future` now extends `IVar`
+* `Postable#post?` now returns an `IVar`
+* Thread safety fixes to `Dereferenceable`
+* Thread safety fixes to `Obligation`
+* Thread safety fixes to `Supervisor`
+* Thread safety fixes to `Event`
+* Various other thread safety (race condition) fixes
+* Refactored brittle tests
+* Implemented pending tests
+* Added JRuby and Rubinius as Travis CI build targets
+* Added [CodeClimate](https://codeclimate.com/) code review
+* Improved YARD documentation

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) Jerry D'Antonio -- released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy  
+of this software and associated documentation files (the "Software"), to deal  
+in the Software without restriction, including without limitation the rights  
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+copies of the Software, and to permit persons to whom the Software is  
+furnished to do so, subject to the following conditions:  
+ 
+The above copyright notice and this permission notice shall be included in  
+all copies or substantial portions of the Software.  
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+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

@@ -0,0 +1,200 @@
+# 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)
+
+<table>
+  <tr>
+    <td align="left" valign="top">
+      <p>
+        Modern concurrency tools for Ruby. Inspired by
+        <a href="http://www.erlang.org/doc/reference_manual/processes.html">Erlang</a>,
+        <a href="http://clojure.org/concurrent_programming">Clojure</a>,
+        <a href="http://akka.io/">Scala</a>,
+        <a href="http://www.haskell.org/haskellwiki/Applications_and_libraries/Concurrency_and_parallelism#Concurrent_Haskell">Haskell</a>,
+        <a href="http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx">F#</a>,
+        <a href="http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx">C#</a>,
+        <a href="http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html">Java</a>,
+        and classic concurrency patterns.
+      </p>
+      <p>
+        The design goals of this gem are:
+        <ul>
+          <li>Be an 'unopinionated' toolbox that provides useful utilities without debating which is better or why</li>
+          <li>Remain free of external gem dependencies</li>
+          <li>Stay true to the spirit of the languages providing inspiration</li>
+          <li>But implement in a way that makes sense for Ruby</li>
+          <li>Keep the semantics as idiomatic Ruby as possible</li>
+          <li>Support features that make sense in Ruby</li>
+          <li>Exclude features that don't make sense in Ruby</li>
+          <li>Be small, lean, and loosely coupled</li>
+        </ul>
+      </p>
+    </td>
+    <td align="right" valign="top">
+      <img src="https://raw.githubusercontent.com/ruby-concurrency/concurrent-ruby/master/doc/logo/concurrent-ruby-logo-300x300.png"/>
+    </td>
+  </tr>
+</table>
+
+### Supported Ruby versions
+
+MRI 1.9.3, 2.0, 2.1, JRuby (1.9 mode), 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.
+
+## Features & Documentation
+
+We have a roadmap guiding our work toward the [v1.0.0 release](https://github.com/ruby-concurrency/concurrent-ruby/wiki/v1.0-Roadmap).
+
+The primary site for documentation is the automatically generated [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
+
+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
+
+* [Actor](./doc/actor/main.md): Implements the Actor Model, where concurrent actors exchange messages. 
+* [Agent](./doc/agent.md): A single atomic value that represents an identity.
+* [Async](./doc/async.md): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
+* [Future](./doc/future.md): An asynchronous operation that produces a value.
+  * [Dataflow](./doc/dataflow.md): 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](./doc/scheduled_task.md): 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
+
+* See [ThreadPool](./doc/thread_pools.md) overview, which also contains a list of other Executors available.
+
+### Thread-safe Observers
+
+* [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)
+
+### Thread synchronization classes and algorithms
+Lower-level abstractions mainly used as building blocks. 
+
+* [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)
+* [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)
+
+### Thread-safe variables
+Lower-level abstractions mainly used as building blocks. 
+
+* [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)
+* [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](./doc/tvar.md) (TVar)
+
+## Usage
+
+All abstractions within this gem can be loaded simply by requiring it:
+
+```ruby
+require 'concurrent'
+```
+
+To reduce the amount of code loaded at runtime, subsets of this gem can be required:
+
+```ruby
+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/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/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
+```
+
+## Installation
+
+```shell
+gem install concurrent-ruby
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'concurrent-ruby'
+```
+
+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. The extension gem lists `concurrent-ruby` as a dependency so it is not necessary to install both.
+Simply install the extension gen:
+
+```shell
+gem install concurrent-ruby-ext
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'concurrent-ruby-ext'
+```
+
+and run `bundle install` from your shell.
+
+In code it is only necessary to
+
+```shell
+require 'concurrent'
+```
+
+The `concurrent-ruby` gem will automatically detect the presence of the `concurrent-ruby-ext` gem
+and load the appropriate C extensions.
+
+## Maintainers
+
+* [Jerry D'Antonio](https://github.com/jdantonio)
+* [Michele Della Torre](https://github.com/mighe)
+* [Chris Seaton](https://github.com/chrisseaton)
+* [Lucas Allan](https://github.com/lucasallan)
+* [Petr Chalupa](https://github.com/pitr-ch)
+* [Paweł Obrok](https://github.com/obrok)
+
+### Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License and Copyright
+
+*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.

data/ext/concurrent_ruby_ext/atomic_boolean.c

@@ -0,0 +1,48 @@
+#include <ruby.h>
+
+#include "atomic_boolean.h"
+#include "atomic_reference.h"
+#include "ruby_193_compatible.h"
+
+void atomic_boolean_mark(void *value) {
+  rb_gc_mark_maybe((VALUE) value);
+}
+
+VALUE atomic_boolean_allocate(VALUE klass) {
+  return rb_data_object_alloc(klass, (void *) Qfalse, atomic_boolean_mark, NULL);
+}
+
+VALUE method_atomic_boolean_initialize(int argc, VALUE* argv, VALUE self) {
+  VALUE value = Qfalse;
+  rb_check_arity(argc, 0, 1);
+  if (argc == 1) value = TRUTHY(argv[0]);
+  DATA_PTR(self) = (void *) value;
+  return(self);
+}
+
+VALUE method_atomic_boolean_value(VALUE self) {
+  return (VALUE) DATA_PTR(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);
+}
+
+VALUE method_atomic_boolean_true_question(VALUE self) {
+  return(method_atomic_boolean_value(self));
+}
+
+VALUE method_atomic_boolean_false_question(VALUE self) {
+  VALUE current = method_atomic_boolean_value(self);
+  return(current == Qfalse ? Qtrue : Qfalse);
+}
+
+VALUE method_atomic_boolean_make_true(VALUE self) {
+  return(ir_compare_and_set(self, Qfalse, Qtrue));
+}
+
+VALUE method_atomic_boolean_make_false(VALUE self) {
+  return(ir_compare_and_set(self, Qtrue, Qfalse));
+}

data/ext/concurrent_ruby_ext/atomic_boolean.h

@@ -0,0 +1,16 @@
+#ifndef __ATOMIC_BOOLEAN_H__
+#define __ATOMIC_BOOLEAN_H__
+
+#define TRUTHY(value)(value == Qfalse || value == Qnil ? Qfalse : Qtrue)
+
+void atomic_boolean_mark(void*);
+VALUE atomic_boolean_allocate(VALUE);
+VALUE method_atomic_boolean_initialize(int, VALUE*, VALUE);
+VALUE method_atomic_boolean_value(VALUE);
+VALUE method_atomic_boolean_value_set(VALUE, VALUE);
+VALUE method_atomic_boolean_true_question(VALUE);
+VALUE method_atomic_boolean_false_question(VALUE);
+VALUE method_atomic_boolean_make_true(VALUE);
+VALUE method_atomic_boolean_make_false(VALUE);
+
+#endif

data/ext/concurrent_ruby_ext/atomic_fixnum.c

@@ -0,0 +1,50 @@
+#include <ruby.h>
+
+#include "atomic_fixnum.h"
+#include "atomic_reference.h"
+#include "ruby_193_compatible.h"
+
+void atomic_fixnum_mark(void *value) {
+  rb_gc_mark_maybe((VALUE) value);
+}
+
+VALUE atomic_fixnum_allocate(VALUE klass) {
+  return rb_data_object_alloc(klass, (void *) Qnil, atomic_fixnum_mark, NULL);
+}
+
+VALUE method_atomic_fixnum_initialize(int argc, VALUE* argv, VALUE self) {
+  VALUE value = LL2NUM(0);
+  rb_check_arity(argc, 0, 1);
+  if (argc == 1) {
+    Check_Type(argv[0], T_FIXNUM);
+    value = argv[0];
+  }
+  DATA_PTR(self) = (void *) value;
+  return(self);
+}
+
+VALUE method_atomic_fixnum_value(VALUE self) {
+  return (VALUE) DATA_PTR(self);
+}
+
+VALUE method_atomic_fixnum_value_set(VALUE self, VALUE value) {
+  Check_Type(value, T_FIXNUM);
+  DATA_PTR(self) = (void *) value;
+  return(value);
+}
+
+VALUE method_atomic_fixnum_increment(VALUE self) {
+  long long value = NUM2LL((VALUE) DATA_PTR(self));
+  return method_atomic_fixnum_value_set(self, LL2NUM(value + 1));
+}
+
+VALUE method_atomic_fixnum_decrement(VALUE self) {
+  long long value = NUM2LL((VALUE) DATA_PTR(self));
+  return method_atomic_fixnum_value_set(self, LL2NUM(value - 1));
+}
+
+VALUE method_atomic_fixnum_compare_and_set(VALUE self, VALUE rb_expect, VALUE rb_update) {
+  Check_Type(rb_expect, T_FIXNUM);
+  Check_Type(rb_update, T_FIXNUM);
+  return ir_compare_and_set(self, rb_expect, rb_update);
+}

data/ext/concurrent_ruby_ext/atomic_fixnum.h

@@ -0,0 +1,13 @@
+#ifndef __ATOMIC_FIXNUM_H__
+#define __ATOMIC_FIXNUM_H__
+
+void atomic_fixnum_mark(void*);
+VALUE atomic_fixnum_allocate(VALUE);
+VALUE method_atomic_fixnum_initialize(int, VALUE*, VALUE);
+VALUE method_atomic_fixnum_value(VALUE);
+VALUE method_atomic_fixnum_value_set(VALUE, VALUE);
+VALUE method_atomic_fixnum_increment(VALUE);
+VALUE method_atomic_fixnum_decrement(VALUE);
+VALUE method_atomic_fixnum_compare_and_set(VALUE, VALUE, VALUE);
+
+#endif

data/ext/concurrent_ruby_ext/atomic_reference.c

@@ -0,0 +1,91 @@
+#include <ruby.h>
+/*#if defined(__sun)*/
+/*#include <atomic.h>*/
+/*#endif*/
+
+/*#ifdef HAVE_LIBKERN_OSATOMIC_H*/
+/*#include <libkern/OSAtomic.h>*/
+/*#endif*/
+
+#include "atomic_reference.h"
+
+void ir_mark(void *value) {
+  rb_gc_mark_maybe((VALUE) value);
+}
+
+VALUE ir_alloc(VALUE klass) {
+  return rb_data_object_alloc(klass, (void *) Qnil, ir_mark, NULL);
+}
+
+VALUE ir_initialize(int argc, VALUE* argv, VALUE self) {
+  VALUE value = Qnil;
+  if (rb_scan_args(argc, argv, "01", &value) == 1) {
+    value = argv[0];
+  }
+  DATA_PTR(self) = (void *) value;
+  return Qnil;
+}
+
+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
+  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
+  return 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 ir_compare_and_set(volatile VALUE self, VALUE expect_value, VALUE new_value) {
+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
+  if (OSAtomicCompareAndSwap64(expect_value, new_value, &DATA_PTR(self))) {
+    return Qtrue;
+  }
+#elif defined(__sun)
+  /*  Assuming VALUE is uintptr_t */
+  /*  Based on the definition of uintptr_t from /usr/include/sys/int_types.h */
+#if defined(_LP64) || defined(_I32LPx)
+  /*  64-bit: uintptr_t === unsigned long */
+  if (atomic_cas_ulong((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
+    return Qtrue;
+  }
+#else
+  /*  32-bit: uintptr_t === unsigned int */
+  if (atomic_cas_uint((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
+    return Qtrue;
+  }
+#endif
+#elif defined _MSC_VER && defined _M_AMD64
+  if (InterlockedCompareExchange64((LONGLONG*)&DATA_PTR(self), new_value, expect_value)) {
+    return Qtrue;
+  }
+#elif defined _MSC_VER && defined _M_IX86
+  if (InterlockedCompareExchange((LONG*)&DATA_PTR(self), new_value, expect_value)) {
+    return Qtrue;
+  }
+#else
+  if (__sync_bool_compare_and_swap(&DATA_PTR(self), expect_value, new_value)) {
+    return Qtrue;
+  }
+#endif
+  return Qfalse;
+}

data/ext/concurrent_ruby_ext/atomic_reference.h

@@ -0,0 +1,20 @@
+#ifndef __ATOMIC_REFERENCE_H__
+#define __ATOMIC_REFERENCE_H__
+
+#if defined(__sun)
+#include <atomic.h>
+#endif
+
+#ifdef HAVE_LIBKERN_OSATOMIC_H
+#include <libkern/OSAtomic.h>
+#endif
+
+void ir_mark(void*);
+VALUE ir_alloc(VALUE);
+VALUE ir_initialize(int, VALUE*, VALUE);
+VALUE ir_get(VALUE);
+VALUE ir_set(VALUE, VALUE);
+VALUE ir_get_and_set(VALUE, VALUE);
+VALUE ir_compare_and_set(volatile VALUE, VALUE, VALUE);
+
+#endif

data/ext/concurrent_ruby_ext/extconf.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+
+$:.push File.join(File.dirname(__FILE__), '../../lib')
+require 'extension_helper'
+
+EXTENSION_NAME = 'concurrent_ruby_ext'
+
+def create_dummy_makefile
+  File.open('Makefile', 'w') do |f|
+    f.puts 'all:'
+    f.puts 'install:'
+  end
+end
+
+if defined?(JRUBY_VERSION) || ! 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(EXTENSION_NAME)
+  rescue
+    create_dummy_makefile
+    warn 'C optimizations cannot be compiled on this version of Ruby.'
+  end
+end

data/ext/concurrent_ruby_ext/rb_concurrent.c

@@ -0,0 +1,57 @@
+#include <ruby.h>
+
+#include "atomic_reference.h"
+#include "atomic_boolean.h"
+#include "atomic_fixnum.h"
+
+// module and class definitions
+
+static VALUE rb_mConcurrent;
+static VALUE rb_cAtomic;
+static VALUE rb_cAtomicBoolean;
+static VALUE rb_cAtomicFixnum;
+
+// Init_concurrent_ruby_ext
+
+void Init_concurrent_ruby_ext() {
+
+  // define modules and classes
+  rb_mConcurrent = rb_define_module("Concurrent");
+  rb_cAtomic = rb_define_class_under(rb_mConcurrent, "CAtomic", 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");
+
+  // CAtomicBoolean
+  rb_define_alloc_func(rb_cAtomicBoolean, atomic_boolean_allocate);
+  rb_define_method(rb_cAtomicBoolean, "initialize", method_atomic_boolean_initialize, -1);
+  rb_define_method(rb_cAtomicBoolean, "value", method_atomic_boolean_value, 0);
+  rb_define_method(rb_cAtomicBoolean, "value=", method_atomic_boolean_value_set, 1);
+  rb_define_method(rb_cAtomicBoolean, "true?", method_atomic_boolean_true_question, 0);
+  rb_define_method(rb_cAtomicBoolean, "false?", method_atomic_boolean_false_question, 0);
+  rb_define_method(rb_cAtomicBoolean, "make_true", method_atomic_boolean_make_true, 0);
+  rb_define_method(rb_cAtomicBoolean, "make_false", method_atomic_boolean_make_false, 0);
+
+  // CAtomicFixnum
+  rb_define_const(rb_cAtomicFixnum, "MIN_VALUE", LL2NUM(LLONG_MIN));
+  rb_define_const(rb_cAtomicFixnum, "MAX_VALUE", LL2NUM(LLONG_MAX));
+  rb_define_alloc_func(rb_cAtomicFixnum, atomic_fixnum_allocate);
+  rb_define_method(rb_cAtomicFixnum, "initialize", method_atomic_fixnum_initialize, -1);
+  rb_define_method(rb_cAtomicFixnum, "value", method_atomic_fixnum_value, 0);
+  rb_define_method(rb_cAtomicFixnum, "value=", method_atomic_fixnum_value_set, 1);
+  rb_define_method(rb_cAtomicFixnum, "increment", method_atomic_fixnum_increment, 0);
+  rb_define_method(rb_cAtomicFixnum, "decrement", method_atomic_fixnum_decrement, 0);
+  rb_define_method(rb_cAtomicFixnum, "compare_and_set", method_atomic_fixnum_compare_and_set, 2);
+  rb_define_alias(rb_cAtomicFixnum, "up", "increment");
+  rb_define_alias(rb_cAtomicFixnum, "down", "decrement");
+}

data/ext/concurrent_ruby_ext/ruby_193_compatible.h

@@ -0,0 +1,28 @@
+#ifndef rb_check_arity
+
+// https://github.com/ruby/ruby/blob/ruby_2_0_0/include/ruby/intern.h
+// rb_check_arity was added in Ruby 2.0
+
+#define UNLIMITED_ARGUMENTS (-1)
+
+static inline void rb_error_arity(int argc, int min, int max)
+{
+  VALUE err_mess = 0;
+  if (min == max) {
+    err_mess = rb_sprintf("wrong number of arguments (%d for %d)", argc, min);
+  }
+  else if (max == UNLIMITED_ARGUMENTS) {
+    err_mess = rb_sprintf("wrong number of arguments (%d for %d+)", argc, min);
+  }
+  else {
+    err_mess = rb_sprintf("wrong number of arguments (%d for %d..%d)", argc, min, max);
+  }
+  rb_raise(rb_eTypeError, err_mess);
+}
+
+#define rb_check_arity(argc, min, max) do { \
+  if (((argc) < (min)) || ((argc) > (max) && (max) != UNLIMITED_ARGUMENTS)) \
+  rb_error_arity(argc, min, max); \
+} while(0)
+
+#endif

data/lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,50 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+
+module Concurrent
+
+  # Define update methods that use direct paths
+  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. 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
+    #
+    # @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

@@ -0,0 +1,25 @@
+module Concurrent
+
+  # Special "compare and set" handling of numeric values.
+  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

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: concurrent-ruby-ext
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre1
+platform: x86-mingw32
+authors:
+- Jerry D'Antonio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0.pre1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0.pre1
+description: ! "    Modern concurrency tools including agents, futures, promises,
+  thread pools, actors, supervisors, and more.\n    Inspired by Erlang, Clojure, Go,
+  JavaScript, actors, and classic concurrency patterns.\n"
+email: jerry.dantonio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.txt
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- 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/1.9/concurrent_ruby_ext.so
+- lib/2.0/concurrent_ruby_ext.so
+- lib/concurrent/atomic_reference/concurrent_update_error.rb
+- lib/concurrent/atomic_reference/direct_update.rb
+- lib/concurrent/atomic_reference/numeric_cas_wrapper.rb
+homepage: http://www.concurrent-ruby.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: C extensions to optimize concurrent-ruby under MRI.
+test_files: []