concurrent-ruby 1.0.0.pre5-java → 1.0.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d7b579740ce1202c660c37eb72e05a0097c49ab
-  data.tar.gz: 37f19da839100f7d8002f64edcbcada96b751ccc
+  metadata.gz: 793ecb127939757bfebe945aaf8d0a04abed1ba6
+  data.tar.gz: efd7bf4be657e131700a904377e5d7d792c4e1f8
 SHA512:
-  metadata.gz: ef72505a341a9a6b984b4946f754540df39fdba7a052c6dbdd6830ce3e9fedd5856b1e7563592557c3044ec6f30a92e845402bae1aa6447a6f7c93fb5ccb458d
-  data.tar.gz: 29ac27d5f288f2fb6f7fb86894fa83b79a3e837cf3a0623a03d85cc4d00f0076f7fb49ea30ae313fc4d547e935ed2a7eb6903eb0cea1316c280e086631d750c8
+  metadata.gz: 01704d17b959dabf4ef3eb38c1d1f83ec5a1008298b344e242d59ae8a9ec64fa0978eabe75e62d4c259f0122a666f3bdf6a6932c31b468571695a02a8bf337f1
+  data.tar.gz: b3c7a588c628f74126b0cdec12e64ba7cc283bdae8a31f075e81616bf06d18e0668e1a7f578c573d8e6b1f537ccf21a7d387624f53ae2dc7d91ee58c604e7fa3

data/CHANGELOG.md

@@ -1,7 +1,21 @@
-### Upcoming Release v1.0.0 (TBD)
-
-## Current Release v1.0.0.pre5 (04 November 2015)
-
+## Current Release v1.0.1 (27 February 2016)
+
+* Fix "uninitialized constant Concurrent::ReentrantReadWriteLock" error.
+* Better handling of `autoload` vs. `require`.
+* Improved API for Edge `Future` zipping.
+* Fix reference leak in Edge `Future` constructor .
+* Fix bug which prevented thread pools from surviving a `fork`.
+* Fix bug in which `TimerTask` did not correctly specify all its dependencies.
+* Improved support for JRuby+Truffle
+* Improved error messages.
+* Improved documentation.
+* Updated README and CONTRIBUTING.
+
+### Release v1.0.0 (13 November 2015)
+
+* Rename `attr_volatile_with_cas` to `attr_atomic`
+* Add `clear_each` to `LockFreeStack`
+* Update `AtomicReference` documentation
 * Further updates and improvements to the synchronization layer.
 * Performance and memory usage performance with `Actor` logging.
 * Fixed `ThreadPoolExecutor` task count methods.
@@ -9,9 +23,6 @@
 * Fixed bug in `LockFreeLinkedSet`.
 * Fixed bug in which `Agent#await` triggered a validation failure.
 * Further `Channel` updates.
-
-### Release v1.0.0.pre4 (08 October 2015)
-
 * Adopted a project Code of Conduct
 * Cleared interpreter warnings
 * Fixed bug in `ThreadPoolExecutor` task count methods
@@ -19,18 +30,12 @@
 * Improved Java extension loading
 * Handle Exception children in Edge::Future
 * Continued improvements to channel
-
-### Release v1.0.0.pre3 (29 September 2015)
-
 * Removed interpreter warnings.
 * Shared constants now in `lib/concurrent/constants.rb`
 * Refactored many tests.
 * Improved synchronization layer/memory model documentation.
 * Bug fix in Edge `Future#flat`
 * Brand new `Channel` implementation in Edge gem.
-
-### Release v1.0.0.pre2 (19 September 2015)
-
 * Simplification of `RubySingleThreadExecutor`
 * `Async` improvements
   - Each object uses its own `SingleThreadExecutor` instead of the global thread pool.
@@ -42,9 +47,6 @@
   - Added a `#reset` method
 * Brand new `Agent` API and implementation. Now functionally equivalent to Clojure.
 * Continued improvements to the synchronization layer
-
-### Release v1.0.0.pre1 (19 August 2015)
-
 * Merged in the `thread_safe` gem
   - `Concurrent::Array`
   - `Concurrent::Hash`

data/README.md

@@ -45,9 +45,9 @@
 
 ### Supported Ruby versions
 
-MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
+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 will be supported.
+Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs is supported.
 
 ## Thread Safety
 
@@ -59,14 +59,10 @@ It is critical to remember, however, that Ruby is a language of mutable referenc
 
 ## Features & Documentation
 
-We have a roadmap guiding our work toward the [v1.0.0 release](https://github.com/ruby-concurrency/concurrent-ruby/issues/257).
-
 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) and [IRC (gitter)](https://gitter.im/ruby-concurrency/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.
-
 #### 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).
@@ -182,7 +178,7 @@ gem install concurrent-ruby
 or add the following line to Gemfile:
 
 ```ruby
-gem 'concurrent-ruby'
+gem 'concurrent-ruby', require: 'concurrent'
 ```
 
 and run `bundle install` from your shell.
@@ -198,7 +194,7 @@ gem install concurrent-ruby-edge
 or add the following line to Gemfile:
 
 ```ruby
-gem 'concurrent-ruby-edge'
+gem 'concurrent-ruby-edge', require: 'concurrent-edge'
 ```
 
 and run `bundle install` from your shell.

data/lib/concurrent/array.rb

@@ -25,7 +25,7 @@ module Concurrent
       include JRuby::Synchronized
     end
 
-  elsif Concurrent.on_rbx?
+  elsif Concurrent.on_rbx? || Concurrent.on_truffle?
     require 'monitor'
     require 'concurrent/thread_safe/util/array_hash_rbx'
 

data/lib/concurrent/async.rb

@@ -58,7 +58,7 @@ module Concurrent
   # end
   # ```
   #
-  # When defining a constructor it is critica that the first line be a call to
+  # When defining a constructor it is critical that the first line be a call to
   # `super` with no arguments. The `super` method initializes the background
   # thread and other asynchronous components.
   #
@@ -153,7 +153,7 @@ module Concurrent
   # subtly different.
   #
   # When internal state is accessed via the `async` and `await` proxy methods,
-  # the returned value represents the object's sate *at the time the call is
+  # the returned value represents the object's state *at the time the call is
   # processed*, which may *not* be the state of the object at the time the call
   # is made.
   #

data/lib/concurrent/atom.rb

@@ -95,7 +95,7 @@ module Concurrent
     include Concern::Observable
 
     safe_initialization!
-    private(*attr_volatile_with_cas(:value))
+    private(*attr_atomic(:value))
     public :value
 
     # Create a new atom with the given initial value.

data/lib/concurrent/atomic_reference/jruby+truffle.rb

@@ -1 +1 @@
-require 'concurrent/atomic_reference/rbx'
+require 'concurrent/atomic_reference/mutex_atomic'

data/lib/concurrent/atomics.rb

@@ -1,6 +1,7 @@
 # @!macro [new] atomic_reference
 #
-#   An object reference that may be updated atomically.
+#   An object reference that may be updated atomically. All read and write
+#   operations have java volatile semantic.
 #
 #   @!macro thread_safe_variable_comparison
 #
@@ -47,5 +48,6 @@ require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
 require 'concurrent/atomic/read_write_lock'
+require 'concurrent/atomic/reentrant_read_write_lock'
 require 'concurrent/atomic/semaphore'
 require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/dataflow.rb

@@ -39,7 +39,7 @@ module Concurrent
     call_dataflow(:value, executor, *inputs, &block)
   end
   module_function :dataflow_with
-  
+
   def dataflow!(*inputs, &block)
     dataflow_with!(Concurrent.global_io_executor, *inputs, &block)
   end
@@ -50,12 +50,14 @@ module Concurrent
   end
   module_function :dataflow_with!
 
-  private 
+  private
 
   def call_dataflow(method, executor, *inputs, &block)
     raise ArgumentError.new('an executor must be provided') if executor.nil?
     raise ArgumentError.new('no block given') unless block_given?
-    raise ArgumentError.new('not all dependencies are IVars') unless inputs.all? { |input| input.is_a? IVar }
+    unless inputs.all? { |input| input.is_a? IVar }
+      raise ArgumentError.new("Not all dependencies are IVars.\nDependencies: #{ inputs.inspect }")
+    end
 
     result = Future.new(executor: executor) do
       values = inputs.map { |input| input.send(method) }

data/lib/concurrent/delay.rb

@@ -5,6 +5,7 @@ require 'concurrent/synchronization'
 
 module Concurrent
 
+  # This file has circular require issues. It must be autoloaded here.
   autoload :Options, 'concurrent/options'
 
   # Lazy evaluation of a block yielding an immutable result. Useful for

data/lib/concurrent/exchanger.rb

@@ -143,7 +143,7 @@ module Concurrent
     safe_initialization!
 
     class Node < Concurrent::Synchronization::Object
-      attr_volatile_with_cas :value
+      attr_atomic :value
       safe_initialization!
 
       def initialize(item)
@@ -170,7 +170,7 @@ module Concurrent
 
     private
 
-    attr_volatile_with_cas(:slot)
+    attr_atomic(:slot)
 
     # @!macro exchanger_method_do_exchange
     #

data/lib/concurrent/executor/fixed_thread_pool.rb

@@ -116,8 +116,8 @@ module Concurrent
   #
   #   * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
   #   * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
-  #     any one time. When the queue size reaches `max_queue` subsequent tasks will be
-  #     rejected in accordance with the configured `fallback_policy`.
+  #     any one time. When the queue size reaches `max_queue` and no new threads can be created,
+  #     subsequent tasks will be rejected in accordance with the configured `fallback_policy`.
   #   * `auto_terminate`: When true (default) an `at_exit` handler will be registered which
   #     will stop the thread pool when the application exits. See below for more information
   #     on shutting down thread pools.
@@ -146,7 +146,7 @@ module Concurrent
   #   On some runtime platforms (most notably the JVM) the application will not
   #   exit until all thread pools have been shutdown. To prevent applications from
   #   "hanging" on exit all thread pools include an `at_exit` handler that will
-  #   stop the thread pool when the application exists. This handler uses a brute
+  #   stop the thread pool when the application exits. This handler uses a brute
   #   force method to stop the pool and makes no guarantees regarding resources being
   #   used by any tasks still running. Registration of this `at_exit` handler can be
   #   prevented by setting the thread pool's constructor `:auto_terminate` option to
@@ -171,8 +171,8 @@ module Concurrent
 
   # @!macro [attach] fixed_thread_pool
   #
-  #   A thread pool with a set number of threads. The number of threads in the pool
-  #   is set on construction and remains constant. When all threads are busy new
+  #   A thread pool that reuses a fixed number of threads operating off an unbounded queue.
+  #   At any point, at most `num_threads` will be active processing tasks. When all threads are busy new
   #   tasks `#post` to the thread pool are enqueued until a thread becomes available.
   #   Should a thread crash for any reason the thread will immediately be removed
   #   from the pool and replaced.

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -131,6 +131,7 @@ module Concurrent
       @scheduled_task_count = 0
       @completed_task_count = 0
       @largest_length       = 0
+      @ruby_pid             = $$ # detects if Ruby has forked
 
       @gc_interval  = opts.fetch(:gc_interval, @idletime / 2.0).to_i # undocumented
       @next_gc_time = Concurrent.monotonic_time + @gc_interval
@@ -143,6 +144,8 @@ module Concurrent
 
     # @!visibility private
     def ns_execute(*args, &task)
+      ns_reset_if_forked
+
       if ns_assign_worker(*args, &task) || ns_enqueue(*args, &task)
         @scheduled_task_count += 1
       else
@@ -150,21 +153,21 @@ module Concurrent
       end
 
       ns_prune_pool if @next_gc_time < Concurrent.monotonic_time
-      # raise unless @ready.empty? || @queue.empty? # assert
     end
 
     # @!visibility private
     def ns_shutdown_execution
+      ns_reset_if_forked
+
       if @pool.empty?
         # nothing to do
         stopped_event.set
       end
+
       if @queue.empty?
         # no more tasks will be accepted, just stop all workers
         @pool.each(&:stop)
       end
-
-      # raise unless @ready.empty? || @queue.empty? # assert
     end
 
     # @!visibility private
@@ -273,6 +276,18 @@ module Concurrent
       @next_gc_time = Concurrent.monotonic_time + @gc_interval
     end
 
+    def ns_reset_if_forked
+      if $$ != @ruby_pid
+        @queue.clear
+        @ready.clear
+        @pool.clear
+        @scheduled_task_count = 0
+        @completed_task_count = 0
+        @largest_length       = 0
+        @ruby_pid             = $$
+      end
+    end
+
     # @!visibility private
     class Worker
       include Concern::Logging

data/lib/concurrent/executor/thread_pool_executor.rb

@@ -18,16 +18,22 @@ module Concurrent
   # @!macro [attach] thread_pool_executor
   #
   #   An abstraction composed of one or more threads and a task queue. Tasks
-  #   (blocks or `proc` objects) are submit to the pool and added to the queue.
+  #   (blocks or `proc` objects) are submitted to the pool and added to the queue.
   #   The threads in the pool remove the tasks and execute them in the order
-  #   they were received. When there are more tasks queued than there are
-  #   threads to execute them the pool will create new threads, up to the
-  #   configured maximum. Similarly, threads that are idle for too long will
-  #   be garbage collected, down to the configured minimum options. Should a
-  #   thread crash it, too, will be garbage collected.
+  #   they were received.
+  #
+  #   A `ThreadPoolExecutor` will automatically adjust the pool size according
+  #   to the bounds set by `min-threads` and `max-threads`. When a new task is
+  #   submitted and fewer than `min-threads` threads are running, a new thread
+  #   is created to handle the request, even if other worker threads are idle.
+  #   If there are more than `min-threads` but less than `max-threads` threads
+  #   running, a new thread will be created only if the queue is full.
+  #
+  #   Threads that are idle for too long will be garbage collected, down to the
+  #   configured minimum options. Should a thread crash it, too, will be garbage collected.
   #
   #   `ThreadPoolExecutor` is based on the Java class of the same name. From
-  #   the official Java documentationa;
+  #   the official Java documentation;
   #
   #   > Thread pools address two different problems: they usually provide
   #   > improved performance when executing large numbers of asynchronous tasks,
@@ -57,8 +63,8 @@ module Concurrent
     #  
     #   @option opts [Integer] :max_threads (DEFAULT_MAX_POOL_SIZE) the maximum
     #     number of threads to be created
-    #   @option opts [Integer] :min_threads (DEFAULT_MIN_POOL_SIZE) the minimum
-    #     number of threads to be retained
+    #   @option opts [Integer] :min_threads (DEFAULT_MIN_POOL_SIZE) When a new task is submitted
+    #      and fewer than `min_threads` are running, a new thread is created
     #   @option opts [Integer] :idletime (DEFAULT_THREAD_IDLETIMEOUT) the maximum
     #     number of seconds a thread may be idle before being reclaimed
     #   @option opts [Integer] :max_queue (DEFAULT_MAX_QUEUE_SIZE) the maximum

data/lib/concurrent/executor/timer_set.rb

@@ -4,9 +4,9 @@ require 'concurrent/collection/non_concurrent_priority_queue'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/single_thread_executor'
 
-module Concurrent
+require 'concurrent/options'
 
-  autoload :Options, 'concurrent/options'
+module Concurrent
 
   # Executes a collection of tasks, each after a given delay. A master task
   # monitors the set and schedules each task for execution at the appropriate
@@ -21,7 +21,7 @@ module Concurrent
     # Create a new set of timed tasks.
     #
     # @!macro [attach] executor_options
-    #  
+    #
     #   @param [Hash] opts the options used to specify the executor on which to perform actions
     #   @option opts [Executor] :executor when set use the given `Executor` instance.
     #     Three special values are also supported: `:task` returns the global task pool,

data/lib/concurrent/future.rb

@@ -4,9 +4,9 @@ require 'concurrent/errors'
 require 'concurrent/ivar'
 require 'concurrent/executor/safe_task_executor'
 
-module Concurrent
+require 'concurrent/options'
 
-  autoload :Options, 'concurrent/options'
+module Concurrent
 
   # {include:file:doc/future.md}
   #

data/lib/concurrent/hash.rb

@@ -22,7 +22,7 @@ module Concurrent
       include JRuby::Synchronized
     end
 
-  elsif Concurrent.on_rbx?
+  elsif Concurrent.on_rbx? || Concurrent.on_truffle?
     require 'monitor'
     require 'concurrent/thread_safe/util/array_hash_rbx'
 

data/lib/concurrent/lazy_register.rb

@@ -18,7 +18,7 @@ module Concurrent
   # @!macro edge_warning
   class LazyRegister < Synchronization::Object
 
-    private(*attr_volatile_with_cas(:data))
+    private(*attr_atomic(:data))
 
     def initialize
       super

data/lib/concurrent/map.rb

@@ -18,6 +18,9 @@ module Concurrent
                           when 'rbx'
                             require 'concurrent/collection/map/atomic_reference_map_backend'
                             AtomicReferenceMapBackend
+                          when 'jruby+truffle'
+                            require 'concurrent/collection/map/atomic_reference_map_backend'
+                            AtomicReferenceMapBackend
                           else
                             warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation' if $VERBOSE
                             require 'concurrent/collection/map/synchronized_map_backend'
@@ -38,8 +41,43 @@ module Concurrent
   # > require 'concurrent'
   # >
   # > map = Concurrent::Map.new
-
   class Map < Collection::MapImplementation
+
+    # @!macro [new] map_method_is_atomic
+    #   This method is atomic. Atomic methods of `Map` which accept a block
+    #   do not allow the `self` instance to be used within the block. Doing
+    #   so will cause a deadlock.
+
+    # @!method put_if_absent
+    #   @!macro map_method_is_atomic
+
+    # @!method compute_if_absent
+    #   @!macro map_method_is_atomic
+
+    # @!method compute_if_present
+    #   @!macro map_method_is_atomic
+
+    # @!method compute
+    #   @!macro map_method_is_atomic
+
+    # @!method merge_pair
+    #   @!macro map_method_is_atomic
+
+    # @!method replace_pair
+    #   @!macro map_method_is_atomic
+
+    # @!method replace_if_exists
+    #   @!macro map_method_is_atomic
+
+    # @!method get_and_set
+    #   @!macro map_method_is_atomic
+
+    # @!method delete
+    #   @!macro map_method_is_atomic
+
+    # @!method delete_pair
+    #   @!macro map_method_is_atomic
+
     def initialize(options = nil, &block)
       if options.kind_of?(::Hash)
         validate_options_hash!(options)
@@ -68,6 +106,15 @@ module Concurrent
     alias_method :get, :[]
     alias_method :put, :[]=
 
+    # @!macro [attach] map_method_not_atomic
+    #   The "fetch-then-act" methods of `Map` are not atomic. `Map` is intended
+    #   to be use as a concurrency primitive with strong happens-before
+    #   guarantees. It is not intended to be used as a high-level abstraction
+    #   supporting complex operations. All read and write operations are
+    #   thread safe, but no guarantees are made regarding race conditions
+    #   between the fetch operation and yielding to the block. Additionally,
+    #   this method does not support recursion. This is due to internal
+    #   constraints that are very unlikely to change in the near future.
     def fetch(key, default_value = NULL)
       if NULL != (value = get_or_default(key, NULL))
         value
@@ -80,12 +127,14 @@ module Concurrent
       end
     end
 
+    # @!macro map_method_not_atomic
     def fetch_or_store(key, default_value = NULL)
       fetch(key) do
         put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
       end
     end
 
+    # @!macro map_method_is_atomic
     def put_if_absent(key, value)
       computed = false
       result = compute_if_absent(key) do

data/lib/concurrent/options.rb

@@ -1,5 +1,3 @@
-# This file has circular require issues. It must be autoloaded.
-
 require 'concurrent/configuration'
 
 module Concurrent

data/lib/concurrent/promise.rb

@@ -3,9 +3,9 @@ require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/ivar'
 
-module Concurrent
+require 'concurrent/options'
 
-  autoload :Options, 'concurrent/options'
+module Concurrent
 
   PromiseExecutionError = Class.new(StandardError)
 

data/lib/concurrent/scheduled_task.rb

@@ -5,9 +5,9 @@ require 'concurrent/ivar'
 require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/utility/monotonic_time'
 
-module Concurrent
+require 'concurrent/options'
 
-  autoload :Options, 'concurrent/options'
+module Concurrent
 
   # `ScheduledTask` is a close relative of `Concurrent::Future` but with one
   # important difference: A `Future` is set to execute as soon as possible

data/lib/concurrent/synchronization.rb

@@ -7,6 +7,7 @@ Concurrent.load_native_extensions
 require 'concurrent/synchronization/mri_object'
 require 'concurrent/synchronization/jruby_object'
 require 'concurrent/synchronization/rbx_object'
+require 'concurrent/synchronization/truffle_object'
 require 'concurrent/synchronization/object'
 require 'concurrent/synchronization/volatile'
 
@@ -14,6 +15,7 @@ require 'concurrent/synchronization/abstract_lockable_object'
 require 'concurrent/synchronization/mri_lockable_object'
 require 'concurrent/synchronization/jruby_lockable_object'
 require 'concurrent/synchronization/rbx_lockable_object'
+require 'concurrent/synchronization/truffle_lockable_object'
 
 require 'concurrent/synchronization/lockable_object'
 

data/lib/concurrent/synchronization/abstract_lockable_object.rb

@@ -2,7 +2,7 @@ module Concurrent
   module Synchronization
 
     # @!visibility private
-    class AbstractLockableObject < Object
+    class AbstractLockableObject < Synchronization::Object
 
       protected
 

data/lib/concurrent/synchronization/lockable_object.rb

@@ -10,8 +10,10 @@ module Concurrent
                                      MriMutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
-                                   when Concurrent.on_rbx? || Concurrent.on_truffle?
+                                   when Concurrent.on_rbx?
                                      RbxLockableObject
+                                   when Concurrent.on_truffle?
+                                     MriMutexLockableObject
                                    else
                                      warn 'Possibly unsupported Ruby implementation'
                                      MriMonitorLockableObject

data/lib/concurrent/synchronization/object.rb

@@ -8,8 +8,10 @@ module Concurrent
                              MriObject
                            when Concurrent.on_jruby?
                              JRubyObject
-                           when Concurrent.on_rbx? || Concurrent.on_truffle?
+                           when Concurrent.on_rbx?
                              RbxObject
+                           when Concurrent.on_truffle?
+                             TruffleObject
                            else
                              MriObject
                            end
@@ -18,7 +20,7 @@ module Concurrent
     # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
     # - final instance variables see {Object.safe_initialization!}
     # - volatile instance variables see {Object.attr_volatile}
-    # - volatile instance variables see {Object.attr_volatile_with_cas}
+    # - volatile instance variables see {Object.attr_atomic}
     class Object < ObjectImplementation
 
       # @!method self.attr_volatile(*names)
@@ -49,8 +51,8 @@ module Concurrent
         # define only once, and not again in children
         return if safe_initialization?
 
-        def self.new(*)
-          object = super
+        def self.new(*args, &block)
+          object = super(*args, &block)
         ensure
           object.full_memory_barrier if object
         end
@@ -87,14 +89,14 @@ module Concurrent
       # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
       # @param [Array<Symbol>] names of the instance variables to be volatile with CAS.
       # @return [Array<Symbol>] names of defined method names.
-      def self.attr_volatile_with_cas(*names)
+      def self.attr_atomic(*names)
         @volatile_cas_fields ||= []
         @volatile_cas_fields += names
         safe_initialization!
         define_initialize_volatile_with_cas
 
         names.each do |name|
-          ivar = :"@VolatileCas#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
+          ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}
               #{ivar}.get
@@ -131,7 +133,7 @@ module Concurrent
       private
 
       def self.define_initialize_volatile_with_cas
-        assignments = @volatile_cas_fields.map { |name| "@VolatileCas#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = AtomicReference.new(nil)" }.join("\n")
+        assignments = @volatile_cas_fields.map { |name| "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = AtomicReference.new(nil)" }.join("\n")
         class_eval <<-RUBY
           def initialize_volatile_with_cas
             super

data/lib/concurrent/synchronization/rbx_object.rb

@@ -7,6 +7,7 @@ module Concurrent
       end
 
       module ClassMethods
+
         def attr_volatile(*names)
           names.each do |name|
             ivar = :"@volatile_#{name}"
@@ -24,6 +25,7 @@ module Concurrent
           end
           names.map { |n| [n, :"#{n}="] }.flatten
         end
+
       end
 
       def full_memory_barrier

data/lib/concurrent/synchronization/truffle_lockable_object.rb

@@ -0,0 +1,9 @@
+module Concurrent
+  module Synchronization
+    class TruffleLockableObject < AbstractLockableObject
+      def new(*)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/concurrent/synchronization/truffle_object.rb

@@ -0,0 +1,32 @@
+module Concurrent
+  module Synchronization
+
+    module TruffleAttrVolatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def attr_volatile(*names)
+          # TODO may not always be available
+          attr_atomic(*names)
+        end
+      end
+
+      def full_memory_barrier
+        # Rubinius instance variables are not volatile so we need to insert barrier
+        Rubinius.memory_barrier
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class TruffleObject < AbstractObject
+      include TruffleAttrVolatile
+
+      def initialize
+        # nothing to do
+      end
+    end
+  end
+end

data/lib/concurrent/timer_task.rb

@@ -3,7 +3,9 @@ require 'concurrent/concern/dereferenceable'
 require 'concurrent/concern/observable'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/executor/executor_service'
+require 'concurrent/executor/ruby_executor_service'
 require 'concurrent/executor/safe_task_executor'
+require 'concurrent/scheduled_task'
 
 module Concurrent
 

data/lib/concurrent/utility/engine.rb

@@ -27,6 +27,14 @@ module Concurrent
         !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
       end
 
+      def on_osx?
+        !(RbConfig::CONFIG['host_os'] =~ /darwin|mac os/).nil?
+      end
+
+      def on_linux?
+        !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
+      end
+
       def ruby_engine
         defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
       end

data/lib/concurrent/utility/processor_counter.rb

@@ -75,6 +75,8 @@ module Concurrent
       def compute_processor_count
         if Concurrent.on_jruby?
           java.lang.Runtime.getRuntime.availableProcessors
+        elsif Concurrent.on_truffle?
+          Truffle::Primitive.logical_processors
         else
           os_name = RbConfig::CONFIG["target_os"]
           if os_name =~ /mingw|mswin/

data/lib/concurrent/version.rb

@@ -1,4 +1,4 @@
 module Concurrent
-  VERSION      = '1.0.0.pre5'
-  EDGE_VERSION = '0.2.0.pre5'
+  VERSION      = '1.0.1'
+  EDGE_VERSION = '0.2.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre5
+  version: 1.0.1
 platform: java
 authors:
 - Jerry D'Antonio
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2016-02-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -128,6 +128,8 @@ files:
 - lib/concurrent/synchronization/object.rb
 - lib/concurrent/synchronization/rbx_lockable_object.rb
 - lib/concurrent/synchronization/rbx_object.rb
+- lib/concurrent/synchronization/truffle_lockable_object.rb
+- lib/concurrent/synchronization/truffle_object.rb
 - lib/concurrent/synchronization/volatile.rb
 - lib/concurrent/thread_safe/synchronized_delegator.rb
 - lib/concurrent/thread_safe/util.rb
@@ -163,9 +165,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
 rubygems_version: 2.4.8