Merge pull request #267 from ruby-concurrency/refactor/time-and-delay

Various updates and refactoring

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/at_exit_tester.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'concurrent'
+
+# with this, a JRuby process will never exit
+Concurrent.disable_auto_termination_of_all_executors!
+
+SIZE = 5
+
+pool = Concurrent::FixedThreadPool.new(SIZE)
+
+latch = Concurrent::CountDownLatch.new(SIZE)
+
+print "Posting #{SIZE} tasks...\n"
+
+SIZE.times do |i|
+  pool.post do
+    this = i
+    sleep(1)
+    print "Completing task #{i}\n"
+    latch.count_down
+  end
+end
+
+print "Waiting for all tasks to complete...\n"
+latch.wait
+print "Done\n"

examples/atomic_example.rb

@@ -1,3 +1,7 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
 require 'concurrent/atomic'
 
 my_atomic = Concurrent::Atomic.new(0)

examples/benchmark_atomic_boolean.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.push File.join(File.dirname(__FILE__), '../lib')
+$: << File.expand_path('../../lib', __FILE__)
 
 require 'concurrent/atomics'
 require 'benchmark'

examples/benchmark_atomic_fixnum.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.push File.join(File.dirname(__FILE__), '../lib')
+$: << File.expand_path('../../lib', __FILE__)
 
 require 'concurrent/atomics'
 require 'benchmark'

examples/benchmark_read_write_lock.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.push File.join(File.dirname(__FILE__), '../lib')
+$: << File.expand_path('../../lib', __FILE__)
 
 require 'concurrent/atomic/read_write_lock'
 require 'benchmark'

examples/graph_atomic_bench.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+$: << File.expand_path('../../lib', __FILE__)
+
 require 'optparse'
 
 conf = {
@@ -35,7 +37,7 @@
 
     ret = []
     10.times do
-      ret << `ruby ./bench_atomic_1.rb -l #{conf[:lock]} -t #{i}`.to_f
+      ret << `ruby #{File.dirname(__FILE__)}/bench_atomic_1.rb -l #{conf[:lock]} -t #{i}`.to_f
     end
 
     line = ([i] + ret).join(', ')
@@ -58,7 +60,7 @@
 
     ret = []
     10.times do
-      ret << `ruby ./bench_atomic_1.rb -l #{conf[:lock]} -s #{i}`.to_f
+      ret << `ruby #{File.dirname(__FILE__)}/bench_atomic_1.rb -l #{conf[:lock]} -s #{i}`.to_f
     end
 
     line = ([i] + ret).join(', ')

examples/lazy_and_delay.rb

@@ -3,21 +3,42 @@
 $: << 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
 
-Benchmark.bm do |x|
-  puts 'Benchmarking Delay...'
-  x.report { n.times{ delay.value } }
-  puts 'Benchmarking Lazy...'
-  x.report { n.times{ lazy.value } }
+Benchmark.bmbm do |x|
+  x.report('Delay#value') { n.times{ delay.value } }
+  x.report('Delay#value!') { n.times{ delay.value! } }
+  x.report('LazyReference#value') { n.times{ lazy.value } }
 end

examples/test_clock_variations.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'benchmark'
+require 'thread'
+
+class MonotonicClock
+  def initialize
+    @mutex = Mutex.new
+    @last_time = Time.now.to_f
+  end
+
+  def get_time_native
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def get_interval_native(since)
+    Process.clock_gettime(Process::CLOCK_MONOTONIC) - since.to_f
+  end
+
+  def get_time_ruby
+    @mutex.synchronize do
+      now = Time.now.to_f
+      if @last_time < now
+        @last_time = now 
+      else # clock has moved back in time
+        @last_time +=  0.000_001
+      end
+    end
+  end
+
+  def get_interval_ruby(since)
+    get_time_ruby - since.to_f
+  end
+end
+
+COUNT = 2_000_000
+CLOCK = MonotonicClock.new
+
+native_now = CLOCK.get_time_native
+ruby_now = CLOCK.get_time_ruby
+
+puts "Native: #{native_now}, Ruby: #{ruby_now}"
+
+Benchmark.bmbm do |bm|
+
+  bm.report('Native time') do
+    COUNT.times{ CLOCK.get_time_native }
+  end
+
+  bm.report('Ruby time') do
+    COUNT.times{ CLOCK.get_time_ruby }
+  end
+
+  bm.report('Native interval') do
+    COUNT.times{ CLOCK.get_interval_native(native_now) }
+  end
+
+  bm.report('Ruby interval') do
+    COUNT.times{ CLOCK.get_interval_ruby(ruby_now) }
+  end
+end
+
+puts "Native: #{CLOCK.get_time_native}, Ruby: #{CLOCK.get_time_ruby}"