concurrently 1.0.1 → 1.1.0

data/lib/mruby/concurrently/event_loop/io_selector.rb

@@ -0,0 +1,46 @@
+module Concurrently
+  # @private
+  class EventLoop::IOSelector
+    def initialize(event_loop)
+      @run_queue = event_loop.run_queue
+      @poll = Poll.new
+      @fds = {}
+      @evaluations = {}
+    end
+
+    def awaiting?
+      @evaluations.size > 0
+    end
+
+    def await_reader(io, evaluation)
+      fd = @poll.add(io, Poll::In)
+      @fds.store io, fd
+      @evaluations.store fd, evaluation
+    end
+
+    def await_writer(io, evaluation)
+      fd = @poll.add(io, Poll::Out)
+      @fds.store io, fd
+      @evaluations.store fd, evaluation
+    end
+
+    def cancel_reader(io)
+      fd = @fds.delete io
+      @poll.remove fd
+      @evaluations.delete fd
+    end
+
+    def cancel_writer(io)
+      fd = @fds.delete io
+      @poll.remove fd
+      @evaluations.delete fd
+    end
+
+    def process_ready_in(waiting_time)
+      waiting_time = -1 if waiting_time == Float::INFINITY
+      if ready = @poll.wait(waiting_time)
+        ready.each{ |fd| @run_queue.resume_evaluation! @evaluations[fd], true }
+      end
+    end
+  end
+end

data/lib/mruby/kernel.rb

@@ -4,7 +4,7 @@ module Kernel
   # Reimplements Kernel#concurrently. mruby does not support Proc.new without
   # a block.
   private def concurrently(*args, &block)
-    Concurrently::Proc.new(&block).call_and_forget *args
+    Concurrently::Proc.new(&block).call_detached *args
   end
 
   # Reimplements Kernel#concurrent_proc. mruby does not support Proc.new without

data/mrbgem.rake

@@ -3,19 +3,23 @@ require_relative 'lib/all/concurrently/version'
 MRuby::Gem::Specification.new('mruby-concurrently') do |spec|
   spec.version      = Concurrently::VERSION
   spec.summary      = %q{A concurrency framework based on fibers}
-  spec.description  = <<-DESC
-Concurrently is a concurrency framework for Ruby and mruby. With it, concurrent
-code can be written sequentially similar to async/await.
+  spec.description  = <<'DESC'
+Concurrently is a concurrency framework for Ruby and mruby based on
+fibers. With it code can be evaluated independently in its own execution
+context similar to a thread:
 
-The concurrency primitive of Concurrently is the concurrent proc. It is very
-similar to a regular proc. Calling a concurrent proc creates a concurrent
-evaluation which is kind of a lightweight thread: It can wait for stuff without
-blocking other concurrent evaluations.
-
-Under the hood, concurrent procs are evaluated inside fibers. They can wait for
-readiness of I/O or a period of time (or the result of other concurrent
-evaluations).
-  DESC
+    hello = concurrently do
+      wait 0.2 # seconds
+      "hello"
+    end
+    
+    world = concurrently do
+      wait 0.1 # seconds
+      "world"
+    end
+    
+    puts "#{hello.await_result} #{world.await_result}"
+DESC
 
   spec.homepage     = "https://github.com/christopheraue/m-ruby-concurrently"
   spec.license      = 'Apache-2.0'
@@ -32,11 +36,18 @@ evaluations).
     Dir["#{spec.dir}/lib/mruby/**/*.rb"].sort
   spec.test_rbfiles = Dir["#{spec.dir}/test/mruby/*.rb"]
 
-  spec.add_dependency 'mruby-array-ext'
-  spec.add_dependency 'mruby-numeric-ext'
-  spec.add_dependency 'mruby-enumerator'
-  spec.add_dependency 'mruby-fiber'
-  spec.add_dependency 'mruby-time'
+  spec.add_dependency 'mruby-array-ext', :core => 'mruby-array-ext'
+  spec.add_dependency 'mruby-numeric-ext', :core => 'mruby-numeric-ext'
+  spec.add_dependency 'mruby-enumerator', :core => 'mruby-enumerator'
+  spec.add_dependency 'mruby-fiber', :core => 'mruby-fiber'
+  spec.add_dependency 'mruby-time', :core => 'mruby-time'
   spec.add_dependency 'mruby-io'
   spec.add_dependency 'mruby-callbacks_attachable', '~> 2.2', github: 'christopheraue/m-ruby-callbacks_attachable'
+
+  # use mruby-poll only on unix-like OSes
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    spec.rbfiles.delete "#{spec.dir}/lib/mruby/concurrently/event_loop/io_selector.rb"
+  else
+    spec.add_dependency 'mruby-poll'
+  end
 end

data/mruby_builds/build_config.rb

@@ -0,0 +1,67 @@
+MRuby::Build.new do
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
+
+  enable_debug
+end
+
+MRuby::Build.new 'test', File.dirname(__FILE__) do
+  self.gem_clone_dir = "#{MRUBY_ROOT}/build/mrbgems"
+
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
+
+  enable_test
+  gem File.expand_path File.dirname File.dirname __FILE__
+end
+
+MRuby::Build.new 'benchmark', File.dirname(__FILE__) do
+  self.gem_clone_dir = "#{MRUBY_ROOT}/build/mrbgems"
+
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+    cc.flags << '-O3'
+  end
+
+  gem core: 'mruby-bin-mruby'
+  gem core: 'mruby-bin-mirb'
+  gem core: 'mruby-proc-ext'
+  gem core: 'mruby-sprintf'
+  gem core: 'mruby-eval'
+
+  gem_dir = File.expand_path File.dirname File.dirname __FILE__
+  gem gem_dir do |gem|
+    gem.rbfiles += Dir["#{gem_dir}/perf/{stage.rb,stage/**/*.rb}"]
+  end
+end
+
+MRuby::Build.new 'profile', File.dirname(__FILE__) do
+  self.gem_clone_dir = "#{MRUBY_ROOT}/build/mrbgems"
+
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
+
+  enable_debug
+  cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
+
+  gem github: 'miura1729/mruby-profiler'
+  gem core: 'mruby-bin-mruby'
+  gem core: 'mruby-proc-ext'
+  gem core: 'mruby-sprintf'
+
+  gem_dir = File.expand_path File.dirname File.dirname __FILE__
+  gem gem_dir do |gem|
+    gem.rbfiles << "#{gem_dir}/perf/stage.rb" << "#{gem_dir}/perf/mruby/stage.rb"
+  end
+end

data/perf/Ruby/stage.rb

@@ -0,0 +1,23 @@
+require 'bundler'
+
+Bundler.require :default
+Bundler.require :perf
+
+perf = File.dirname File.dirname __FILE__
+Dir["#{perf}/{stage.rb,stage/**/*.rb}"].sort.each{ |f| require f }
+
+class Stage
+  def profile(seconds: 1, printer: 'flat')
+    gc_disabled do
+      profile = RubyProf::Profile.new(merge_fibers: true).tap(&:start)
+
+      result = execute(seconds: seconds){ yield }
+
+      printer[0] = printer[0].capitalize
+      RubyProf.const_get("#{printer}Printer").new(profile.stop).print(STDOUT, sort_method: :self_time)
+
+      result
+    end
+  end
+end
+

data/perf/benchmark_call_methods.rb

@@ -0,0 +1,32 @@
+stage = Stage.new
+batch_size = ARGV.fetch(0, 1).to_i
+print_results_only = ARGV[1] == 'skip_header'
+
+stage.benchmark 'proc.call',
+  batch_size: batch_size,
+  proc: "proc{}",
+  call: :call
+
+stage.benchmark 'conproc.call',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call
+
+stage.benchmark 'conproc.call_nonblock',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call_nonblock
+
+stage.benchmark 'conproc.call_detached',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call_detached,
+  sync: :wait
+
+stage.benchmark 'conproc.call_and_forget',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call_and_forget,
+  sync: :wait
+
+stage.perform print_results_only

data/perf/benchmark_call_methods_waiting.rb

@@ -0,0 +1,52 @@
+stage = Stage.new
+batch_size = ARGV.fetch(0, 1).to_i
+print_results_only = ARGV[1] == 'skip_header'
+
+stage.benchmark 'call',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call,
+  sync: true
+
+stage.benchmark 'call_nonblock',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call_nonblock
+
+stage.benchmark 'call_detached',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call_detached,
+  sync: true
+
+stage.benchmark 'call_and_forget',
+  batch_size: batch_size,
+  proc: "concurrent_proc{}",
+  call: :call_and_forget,
+  sync: true
+
+stage.benchmark 'waiting call',
+  batch_size: batch_size,
+  proc: "concurrent_proc{ wait 0 }",
+  call: :call,
+  sync: true
+
+stage.benchmark 'waiting call_nonblock',
+  batch_size: batch_size,
+  proc: "concurrent_proc{ wait 0 }",
+  call: :call_nonblock,
+  sync: true
+
+stage.benchmark 'waiting call_detached',
+  batch_size: batch_size,
+  proc: "concurrent_proc{ wait 0 }",
+  call: :call_detached,
+  sync: true
+
+stage.benchmark 'waiting call_and_forget',
+  batch_size: batch_size,
+  proc: "concurrent_proc{ wait 0 }",
+  call: :call_and_forget,
+  sync: true
+
+stage.perform print_results_only

data/perf/benchmark_wait_methods.rb

@@ -0,0 +1,38 @@
+stage = Stage.new
+batch_size = ARGV.fetch(0, 1).to_i
+print_results_only = ARGV[1] == 'skip_header'
+
+stage.benchmark :wait,
+  batch_size: batch_size,
+  proc: <<RUBY, call: :call
+proc do
+  wait 0 # schedule the proc be resumed ASAP
+end
+RUBY
+
+stage.benchmark "await_readable",
+  batch_size: batch_size,
+  proc: <<RUBY, call: :call, args: <<RUBY
+proc do |r,w|
+  r.await_readable
+end
+RUBY
+IO.pipe.tap{ |r,w| w.write '0' }
+RUBY
+
+stage.benchmark "await_writable",
+  batch_size: batch_size,
+  proc: <<RUBY, call: :call, args: <<RUBY
+proc do |r,w|
+  w.await_writable
+end
+RUBY
+IO.pipe
+RUBY
+
+# Warm up
+wait_proc = concurrent_proc{ wait 0 }
+stage.execute{ wait_proc.call }
+
+# Performance
+stage.perform print_results_only

data/perf/mruby/stage.rb

@@ -0,0 +1,8 @@
+class Stage
+  def profile(opts = {})
+    gc_disabled do
+      execute(opts){ yield }
+    end
+  end
+end
+

data/perf/profile_await_readable.rb

@@ -0,0 +1,10 @@
+stage = Stage.new
+
+r,w = IO.pipe
+w.write '0'
+
+result = stage.profile(seconds: 1) do
+  r.await_readable
+end
+
+puts "#{result[:iterations]} executions in #{result[:time].round 4} seconds"

data/perf/{concurrent_proc_call.rb → profile_call.rb}

@@ -1,12 +1,8 @@
-#!/bin/env ruby
-
-require_relative "_shared/stage"
-
 stage = Stage.new
 
 conproc = concurrent_proc{}
 
-result = stage.measure(seconds: 1) do
+result = stage.profile(seconds: 1) do
   conproc.call
 end
 

data/perf/{concurrent_proc_call_and_forget.rb → profile_call_and_forget.rb}

@@ -1,13 +1,9 @@
-#!/bin/env ruby
-
-require_relative "_shared/stage"
-
 stage = Stage.new
 
 evaluation = Concurrently::Evaluation.current
 conproc = concurrent_proc{ evaluation.resume! }
 
-result = stage.measure(seconds: 1) do
+result = stage.profile(seconds: 1) do
   conproc.call_and_forget
   await_resume!
 end

data/perf/{concurrent_proc_call_detached.rb → profile_call_detached.rb}

@@ -1,13 +1,9 @@
-#!/bin/env ruby
-
-require_relative "_shared/stage"
-
 stage = Stage.new
 
 evaluation = Concurrently::Evaluation.current
 conproc = concurrent_proc{ evaluation.resume! }
 
-result = stage.measure(seconds: 1) do
+result = stage.profile(seconds: 1) do
   conproc.call_detached
   await_resume!
 end

data/perf/{concurrent_proc_call_nonblock.rb → profile_call_nonblock.rb}

@@ -1,12 +1,8 @@
-#!/bin/env ruby
-
-require_relative "_shared/stage"
-
 stage = Stage.new
 
 conproc = concurrent_proc{}
 
-result = stage.measure(seconds: 1) do
+result = stage.profile(seconds: 1) do
   conproc.call_nonblock
 end
 

data/perf/profile_wait.rb

@@ -0,0 +1,7 @@
+stage = Stage.new
+
+result = stage.profile(seconds: 1) do
+  wait 0
+end
+
+puts "#{result[:iterations]} executions in #{result[:time].round 4} seconds"

data/perf/stage.rb

@@ -0,0 +1,47 @@
+class Stage
+  def initialize
+    @benchmarks = []
+  end
+
+  def gc_disabled
+    GC.start
+    GC.disable
+    yield
+  ensure
+    GC.enable
+  end
+
+  def execute(opts = {})
+    seconds = opts[:seconds] || 1
+    event_loop = Concurrently::EventLoop.current
+    event_loop.reinitialize!
+    iterations = 0
+    start_time = event_loop.lifetime
+    end_time = start_time + seconds
+    while event_loop.lifetime < end_time
+      yield
+      iterations += 1
+    end
+    stop_time = event_loop.lifetime
+    { iterations: iterations, time: (stop_time-start_time) }
+  end
+
+  def benchmark(*args)
+    @benchmarks << Benchmark.new(self, *args)
+  end
+
+  def perform(print_results_only = false)
+    if @benchmarks.size
+      unless print_results_only
+        puts Benchmark.header
+        @benchmarks.each do |b|
+          puts b.desc
+        end
+      end
+      puts Benchmark.result_header
+      @benchmarks.each{ |b| b.run }
+      puts
+    end
+  end
+end
+