Removed LazyReference now that Delay is better, stronger, faster.

Author: jdantonio

CHANGELOG.md

@@ -40,9 +40,9 @@
 * 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
-* Added `LazyReference`, a simpler and faster varition of `Delay`
-  - Updated most internal uses of `Delay` with `LazyReference`
 * 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
 
 ## Current Release v0.8.0 (25 January 2015)
 

README.md

@@ -83,7 +83,6 @@ This library contains a variety of concurrency abstractions at high and low leve
 * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
 * [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html)
 * [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html)
-* [LazyReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyReference.html)
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.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)
@@ -123,7 +122,6 @@ require 'concurrent/exchanger'      # Concurrent::Exchanger
 require 'concurrent/future'         # Concurrent::Future
 require 'concurrent/ivar'           # Concurrent::IVar
 require 'concurrent/lazy_register'  # Concurrent::LazyRegister
-require 'concurrent/lazy_reference' # Concurrent::LazyReference
 require 'concurrent/mvar'           # Concurrent::MVar
 require 'concurrent/promise'        # Concurrent::Promise
 require 'concurrent/scheduled_task' # Concurrent::ScheduledTask

examples/lazy_and_delay.rb

@@ -3,14 +3,36 @@
 $: << File.expand_path('../../lib', __FILE__)
 
 require 'benchmark'
-
-require 'concurrent/delay'
-require 'concurrent/lazy_reference'
+require 'thread'
+require 'concurrent'
 
 n = 500_000
 
+class LazyReference
+  def initialize(&block)
+    raise ArgumentError.new('no block given') unless block_given?
+    @task = block
+    @mutex = Mutex.new
+    @value = nil
+    @fulfilled = false
+  end
+
+  def value
+    @mutex.synchronize do
+      unless @fulfilled
+        begin
+          @value = @task.call
+        ensure
+          @fulfilled = true
+        end
+      end
+    end
+    return @value
+  end
+end
+
 delay = Concurrent::Delay.new{ nil }
-lazy = Concurrent::LazyReference.new{ nil }
+lazy = LazyReference.new{ nil }
 
 delay.value
 lazy.value

lib/concurrent.rb

@@ -19,7 +19,6 @@
 require 'concurrent/exchanger'
 require 'concurrent/future'
 require 'concurrent/ivar'
-require 'concurrent/lazy_reference'
 require 'concurrent/lazy_register'
 require 'concurrent/mvar'
 require 'concurrent/promise'

lib/concurrent/actor.rb

@@ -40,7 +40,7 @@ def self.current
       Thread.current[:__current_actor__]
     end
 
-    @root = Delay.new(executor: :immediate) do
+    @root = Delay.new do
       Core.new(parent: nil, name: '/', class: Root, initialized: ivar = IVar.new).reference.tap do
         ivar.no_error!
       end

lib/concurrent/async.rb

@@ -1,7 +1,6 @@
 require 'thread'
 require 'concurrent/configuration'
 require 'concurrent/delay'
-require 'concurrent/lazy_reference'
 require 'concurrent/errors'
 require 'concurrent/ivar'
 require 'concurrent/executor/immediate_executor'
@@ -197,15 +196,15 @@ def init_mutex
       @__async_initialized__ = true
       serializer = Concurrent::SerializedExecution.new
 
-      @__async_executor__ = Delay.new(executor: :immediate) {
+      @__async_executor__ = Delay.new {
         Concurrent.global_io_executor
       }
 
-      @__await_delegator__ = Delay.new(executor: :immediate) {
-        AsyncDelegator.new(self, LazyReference.new{ Concurrent::ImmediateExecutor.new }, serializer, true)
+      @__await_delegator__ = Delay.new {
+        AsyncDelegator.new(self, Delay.new{ Concurrent::ImmediateExecutor.new }, serializer, true)
       }
 
-      @__async_delegator__ = Delay.new(executor: :immediate) {
+      @__async_delegator__ = Delay.new {
         AsyncDelegator.new(self, @__async_executor__, serializer, false)
       }
     end

lib/concurrent/configuration.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'concurrent/lazy_reference'
 require 'concurrent/atomics'
 require 'concurrent/errors'
 require 'concurrent/executors'
@@ -25,21 +24,21 @@ module Concurrent
   private_constant :AUTO_TERMINATE_ALL_EXECUTORS
 
   # @!visibility private
-  GLOBAL_FAST_EXECUTOR = LazyReference.new do
+  GLOBAL_FAST_EXECUTOR = Delay.new do
     Concurrent.new_fast_executor(
       stop_on_exit: AUTO_TERMINATE_GLOBAL_EXECUTORS.value)
   end
   private_constant :GLOBAL_FAST_EXECUTOR
 
   # @!visibility private
-  GLOBAL_IO_EXECUTOR = LazyReference.new do
+  GLOBAL_IO_EXECUTOR = Delay.new do
     Concurrent.new_io_executor(
       stop_on_exit: AUTO_TERMINATE_GLOBAL_EXECUTORS.value)
   end
   private_constant :GLOBAL_IO_EXECUTOR
 
   # @!visibility private
-  GLOBAL_TIMER_SET = LazyReference.new do
+  GLOBAL_TIMER_SET = Delay.new do
     TimerSet.new(stop_on_exit: AUTO_TERMINATE_GLOBAL_EXECUTORS.value)
   end
   private_constant :GLOBAL_TIMER_SET

lib/concurrent/delay.rb

@@ -36,21 +36,7 @@ module Concurrent
   #     constructor option. This will cause the delayed operation to be
   #     execute on the given executor, allowing the call to timeout.
   #
-  # Because of its simplicity `LazyReference` is much faster than `Delay`:
-  #
-  #     Rehearsal -------------------------------------------------------
-  #     Delay#value           0.210000   0.000000   0.210000 (  0.208207)
-  #     Delay#value!          0.240000   0.000000   0.240000 (  0.247136)
-  #     LazyReference#value   0.160000   0.000000   0.160000 (  0.158399)
-  #     ---------------------------------------------- total: 0.610000sec
-  #     
-  #                               user     system      total        real
-  #     Delay#value           0.200000   0.000000   0.200000 (  0.203602)
-  #     Delay#value!          0.250000   0.000000   0.250000 (  0.252535)
-  #     LazyReference#value   0.150000   0.000000   0.150000 (  0.154053)
-  #
   # @see Concurrent::Dereferenceable
-  # @see Concurrent::LazyReference
   class Delay
     include Obligation
     include ExecutorOptions
@@ -66,14 +52,12 @@ def initialize(opts = {}, &block)
       raise ArgumentError.new('no block given') unless block_given?
 
       init_obligation
+      set_deref_options(opts)
+      @task_executor = get_executor_from(opts)
 
-      @state     = :pending
       @task      = block
+      @state     = :pending
       @computing = false
-
-      set_deref_options(opts)
-
-      @task_executor = get_executor_from(opts)
     end
 
     # Return the value this object represents after applying the options

lib/concurrent/lazy_reference.rb

@@ -1,12 +1,12 @@
 require 'rbconfig'
-require 'concurrent/lazy_reference'
+require 'concurrent/delay'
 
 module Concurrent
 
   class ProcessorCounter
     def initialize
-      @processor_count          = LazyReference.new { compute_processor_count }
-      @physical_processor_count = LazyReference.new { compute_physical_processor_count }
+      @processor_count          = Delay.new { compute_processor_count }
+      @physical_processor_count = Delay.new { compute_physical_processor_count }
     end
 
     # Number of processors seen by the OS and used for process scheduling. For