concurrently 1.0.1 → 1.1.0

data/perf/stage/benchmark.rb

@@ -0,0 +1,47 @@
+class Stage
+  class Benchmark
+    SECONDS = 1
+    RESULT_HEADER = "Results for #{RUBY_ENGINE} #{RUBY_ENGINE_VERSION}"
+    RESULT_FORMAT = "  %-25s %8d executions in %2.4f seconds"
+
+    def self.header
+      <<DOC
+Benchmarks
+----------
+DOC
+    end
+
+    def self.result_header
+      "#{RESULT_HEADER}\n#{'-'*RESULT_HEADER.length}"
+    end
+
+    def initialize(stage, name, opts = {})
+      @stage = stage
+      @name = name
+      @opts = opts
+
+      opts[:call] ||= :call_nonblock
+      opts[:batch_size] ||= 1
+
+      code_gen = CodeGen.const_get(opts[:batch_size] > 1 ? :Batch : :Single).new(opts)
+      proc_lines = code_gen.proc_lines
+      args_lines = code_gen.args_lines
+      call_lines = code_gen.call_lines
+
+      @code = eval [*proc_lines, *args_lines, *call_lines].join "\n"
+
+      proc_lines << "" if proc_lines.size > 1
+      call_lines[0] = "while elapsed_seconds < #{SECONDS}"
+      @desc = ["  #{@name}:", *proc_lines, *args_lines, "", *call_lines, ""].join "\n    "
+    end
+
+    attr_reader :desc
+
+    def run
+      result = @stage.gc_disabled do
+        @stage.execute(seconds: SECONDS, &@code)
+      end
+      puts sprintf(RESULT_FORMAT, "#{@name}:", @opts[:batch_size]*result[:iterations], result[:time])
+    end
+  end
+end

data/perf/stage/benchmark/code_gen.rb

@@ -0,0 +1,29 @@
+class Stage
+  class Benchmark
+    class CodeGen
+      def initialize(opts)
+        opts.each do |key, value|
+          instance_variable_set "@#{key}", value
+        end
+      end
+
+      def proc_lines
+        @proc.chomp.split("\n").tap do |lines|
+          lines[0] = "test_proc = #{lines[0]}"
+        end
+      end
+
+      def args_lines
+        if @args
+          @args.chomp.split("\n")
+        else
+          []
+        end
+      end
+
+      def call_lines
+        ["proc do", "test_proc.#{@call}#{(@args ? "(*args)" : "")}", "end"]
+      end
+    end
+  end
+end

data/perf/stage/benchmark/code_gen/batch.rb

@@ -0,0 +1,41 @@
+class Stage
+  class Benchmark
+    class CodeGen
+      class Batch < CodeGen
+        def args_lines
+          case (lines = super).size
+          when 0
+            ["batch = Array.new(#{@batch_size})"]
+          else
+            lines.each{ |l| l.replace "  #{l}" }
+            lines.unshift "batch = Array.new(#{@batch_size}) do |idx|"
+            lines.push "end"
+          end
+        end
+
+        def call_lines
+          lines = super
+          blk = "{#{@args ? " |*args|" : nil} #{lines[1]} }"
+          if @sync
+            @sync = @call if @sync == true
+            case @sync
+            when :call_nonblock, :call_detached, :await_result
+              lines[1] = "evaluations = batch.map#{blk}"
+              lines.insert 2, "evaluations.each{ |evaluation| evaluation.await_result }"
+            when :call
+              lines[1] = "batch.each#{blk}"
+              lines.insert 2, "# Concurrently::Proc#call already synchronizes the results of evaluations"
+            when :call_and_forget, :wait
+              lines[1] = "batch.each#{blk}"
+              lines.insert 2, "wait 0"
+            end
+          else
+            lines[1] = "batch.each#{blk}"
+          end
+          lines[1..-2].each{ |l| l.replace "  #{l}" }
+          lines
+        end
+      end
+    end
+  end
+end

data/perf/stage/benchmark/code_gen/single.rb

@@ -0,0 +1,38 @@
+class Stage
+  class Benchmark
+    class CodeGen
+      class Single < CodeGen
+        def args_lines
+          case (lines = super).size
+          when 0
+            lines
+          when 1
+            lines[0] = "args = #{lines[0]}"
+          else
+            lines.each{ |l| l.replace "  #{l}" }
+            lines.unshift "args = begin"
+            lines.push "end"
+          end
+        end
+
+        def call_lines
+          lines = super
+          if @sync
+            @sync = @call if @sync == true
+            case @sync
+            when :call_nonblock, :call_detached, :await_result
+              lines[1] = "evaluation = #{lines[1]}"
+              lines.insert 2, "evaluation.await_result"
+            when :call
+              lines.insert 2, "# Concurrently::Proc#call already synchronizes the results of evaluations"
+            when :call_and_forget, :wait
+              lines.insert 2, "wait 0"
+            end
+          end
+          lines[1..-2].each{ |l| l.replace "  #{l}" }
+          lines
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrently
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Christopher Aue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-26 00:00:00.000000000 Z
+date: 2017-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -52,18 +52,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-description: |
-  Concurrently is a concurrency framework for Ruby and mruby. With it, concurrent
-  code can be written sequentially similar to async/await.
-
-  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).
+description: "Concurrently is a concurrency framework for Ruby and mruby based on\nfibers.
+  With it code can be evaluated independently in its own execution\ncontext similar
+  to a thread:\n\n    hello = concurrently do\n      wait 0.2 # seconds\n      \"hello\"\n
+  \   end\n    \n    world = concurrently do\n      wait 0.1 # seconds\n      \"world\"\n
+  \   end\n    \n    puts \"#{hello.await_result} #{world.await_result}\"\n"
 email:
 - rubygems@christopheraue.net
 executables: []
@@ -82,7 +75,6 @@ files:
 - concurrently.gemspec
 - ext/Ruby/thread.rb
 - ext/all/array.rb
-- ext/mruby/array.rb
 - ext/mruby/fiber.rb
 - ext/mruby/io.rb
 - guides/Installation.md
@@ -90,9 +82,9 @@ files:
 - guides/Performance.md
 - guides/Troubleshooting.md
 - lib/Ruby/concurrently.rb
-- lib/Ruby/concurrently/error.rb
 - lib/Ruby/concurrently/event_loop.rb
 - lib/Ruby/concurrently/event_loop/io_selector.rb
+- lib/Ruby/concurrently/proc/evaluation/error.rb
 - lib/all/concurrently/error.rb
 - lib/all/concurrently/evaluation.rb
 - lib/all/concurrently/evaluation/error.rb
@@ -103,20 +95,32 @@ files:
 - lib/all/concurrently/event_loop/run_queue.rb
 - lib/all/concurrently/proc.rb
 - lib/all/concurrently/proc/evaluation.rb
+- lib/all/concurrently/proc/evaluation/error.rb
 - lib/all/concurrently/proc/fiber.rb
 - lib/all/concurrently/version.rb
 - lib/all/io.rb
 - lib/all/kernel.rb
+- lib/mruby/concurrently/event_loop/io_selector.rb
 - lib/mruby/concurrently/proc.rb
 - lib/mruby/kernel.rb
 - mrbgem.rake
-- perf/_shared/stage.rb
-- perf/concurrent_proc_call.rb
-- perf/concurrent_proc_call_and_forget.rb
-- perf/concurrent_proc_call_detached.rb
-- perf/concurrent_proc_call_nonblock.rb
-- perf/concurrent_proc_calls.rb
-- perf/concurrent_proc_calls_awaiting.rb
+- mruby_builds/build_config.rb
+- perf/Ruby/stage.rb
+- perf/benchmark_call_methods.rb
+- perf/benchmark_call_methods_waiting.rb
+- perf/benchmark_wait_methods.rb
+- perf/mruby/stage.rb
+- perf/profile_await_readable.rb
+- perf/profile_call.rb
+- perf/profile_call_and_forget.rb
+- perf/profile_call_detached.rb
+- perf/profile_call_nonblock.rb
+- perf/profile_wait.rb
+- perf/stage.rb
+- perf/stage/benchmark.rb
+- perf/stage/benchmark/code_gen.rb
+- perf/stage/benchmark/code_gen/batch.rb
+- perf/stage/benchmark/code_gen/single.rb
 homepage: https://github.com/christopheraue/m-ruby-concurrently
 licenses:
 - Apache-2.0

data/ext/mruby/array.rb

@@ -1,19 +0,0 @@
-# @api mruby_patches
-# @since 1.0.0
-class Array
-  # Alias for original Array#pop
-  alias_method :pop_single, :pop
-
-  # Reimplements Array#pop to add support for popping multiple items at once.
-  #
-  # By default, Array#pop can only pop a single item in mruby
-  def pop(n = nil)
-    if n
-      res = []
-      n.times{ res << pop_single }
-      res.reverse!
-    else
-      pop_single
-    end
-  end
-end

data/lib/Ruby/concurrently/error.rb

@@ -1,4 +0,0 @@
-module Concurrently
-  # Ruby has additional error classes
-  RESCUABLE_ERRORS << NoMemoryError << SecurityError
-end

data/perf/_shared/stage.rb

@@ -1,33 +0,0 @@
-require 'bundler'
-
-Bundler.require :default
-Bundler.require :perf
-
-class Stage
-  def measure(seconds: 1) # &test
-    GC.start
-    GC.disable
-    profile = RubyProf::Profile.new(merge_fibers: true).tap(&:start) if ARGV[0] == 'profile'
-
-    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
-
-    if ARGV[0] == 'profile'
-      printer = ARGV[1].dup || 'flat'
-      printer[0] = printer[0].capitalize
-      RubyProf.const_get("#{printer}Printer").new(profile.stop).print(STDOUT, sort_method: :self_time)
-    end
-    GC.enable
-
-    { iterations: iterations, time: (stop_time-start_time) }
-  end
-end
-

data/perf/concurrent_proc_calls.rb

@@ -1,49 +0,0 @@
-#!/bin/env ruby
-
-require_relative "_shared/stage"
-
-stage = Stage.new
-format = "  %-25s %7d executions in %2.4f seconds"
-
-puts <<-DOC
-Benchmarked Code
-----------------
-  proc = proc{}
-  conproc = concurrent_proc{}
-  
-  while elapsed_seconds < 1
-    # CODE #
-  end
-
-Results
--------
-  # CODE #
-DOC
-
-proc = proc{}
-conproc = concurrent_proc{}
-
-result = stage.measure(seconds: 1) do
-  proc.call
-end
-puts sprintf(format, "proc.call:", result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  conproc.call
-end
-puts sprintf(format, "conproc.call:", result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  conproc.call_nonblock
-end
-puts sprintf(format, "conproc.call_nonblock:", result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  conproc.call_detached
-end
-puts sprintf(format, "conproc.call_detached:", result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  conproc.call_and_forget
-end
-puts sprintf(format, "conproc.call_and_forget:", result[:iterations], result[:time])

data/perf/concurrent_proc_calls_awaiting.rb

@@ -1,48 +0,0 @@
-#!/bin/env ruby
-
-require_relative "_shared/stage"
-
-stage = Stage.new
-format = "  %-25s %7d executions in %2.4f seconds"
-factor = ARGV.fetch(0, 1).to_i
-
-puts <<-DOC
-Benchmarked Code
-----------------
-  conproc = concurrent_proc{ wait 0 }
-  
-  while elapsed_seconds < 1
-    #{factor}.times{ # CODE # }
-    wait 0 # to enter the event loop
-  end
-
-Results
--------
-  # CODE #
-DOC
-
-conproc = concurrent_proc{ wait 0 }
-
-result = stage.measure(seconds: 1) do
-  factor.times{ conproc.call }
-  # no need to enter the event loop manually. It already happens in #call
-end
-puts sprintf(format, "conproc.call:", factor*result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  factor.times{ conproc.call_nonblock }
-  wait 0
-end
-puts sprintf(format, "conproc.call_nonblock:", factor*result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  factor.times{ conproc.call_detached }
-  wait 0
-end
-puts sprintf(format, "conproc.call_detached:", factor*result[:iterations], result[:time])
-
-result = stage.measure(seconds: 1) do
-  factor.times{ conproc.call_and_forget }
-  wait 0
-end
-puts sprintf(format, "conproc.call_and_forget:", factor*result[:iterations], result[:time])