concurrently 1.0.1

data/lib/mruby/concurrently/proc.rb

@@ -0,0 +1,21 @@
+module Concurrently
+  # @api mruby_patches
+  # @since 1.0.0
+  #
+  # mruby's Proc does not support instance variables. So, whe have to make
+  # it a normal class that does not inherit from Proc :(
+  class Proc
+    def initialize(evaluation_class = Evaluation, &proc)
+      @evaluation_class = evaluation_class
+      @proc = proc
+    end
+
+    def arity
+      @proc.arity
+    end
+
+    def __proc_call__(*args)
+      @proc.call *args
+    end
+  end
+end

data/lib/mruby/kernel.rb

@@ -0,0 +1,15 @@
+# @api mruby_patches
+# @since 1.0.0
+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
+  end
+
+  # Reimplements Kernel#concurrent_proc. mruby does not support Proc.new without
+  # a block.
+  private def concurrent_proc(evaluation_class = Concurrently::Proc::Evaluation, &block)
+    Concurrently::Proc.new(evaluation_class, &block)
+  end
+end

data/mrbgem.rake

@@ -0,0 +1,42 @@
+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.
+
+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
+
+  spec.homepage     = "https://github.com/christopheraue/m-ruby-concurrently"
+  spec.license      = 'Apache-2.0'
+  spec.authors      = ['Christopher Aue']
+
+  # patch build process so we can set source files with spec.rbfiles
+  @generate_functions = true
+  @objs << objfile("#{build_dir}/gem_init")
+
+  spec.rbfiles      =
+    Dir["#{spec.dir}/ext/all/**/*.rb"].sort +
+    Dir["#{spec.dir}/ext/mruby/**/*.rb"].sort +
+    Dir["#{spec.dir}/lib/all/**/*.rb"].sort +
+    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-io'
+  spec.add_dependency 'mruby-callbacks_attachable', '~> 2.2', github: 'christopheraue/m-ruby-callbacks_attachable'
+end

data/perf/_shared/stage.rb

@@ -0,0 +1,33 @@
+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_call.rb

@@ -0,0 +1,13 @@
+#!/bin/env ruby
+
+require_relative "_shared/stage"
+
+stage = Stage.new
+
+conproc = concurrent_proc{}
+
+result = stage.measure(seconds: 1) do
+  conproc.call
+end
+
+puts "#{result[:iterations]} executions in #{result[:time].round 4} seconds"

data/perf/concurrent_proc_call_and_forget.rb

@@ -0,0 +1,15 @@
+#!/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
+  conproc.call_and_forget
+  await_resume!
+end
+
+puts "#{result[:iterations]} executions in #{result[:time].round 4} seconds"

data/perf/concurrent_proc_call_detached.rb

@@ -0,0 +1,15 @@
+#!/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
+  conproc.call_detached
+  await_resume!
+end
+
+puts "#{result[:iterations]} executions in #{result[:time].round 4} seconds"

data/perf/concurrent_proc_call_nonblock.rb

@@ -0,0 +1,13 @@
+#!/bin/env ruby
+
+require_relative "_shared/stage"
+
+stage = Stage.new
+
+conproc = concurrent_proc{}
+
+result = stage.measure(seconds: 1) do
+  conproc.call_nonblock
+end
+
+puts "#{result[:iterations]} executions in #{result[:time].round 4} seconds"

data/perf/concurrent_proc_calls.rb

@@ -0,0 +1,49 @@
+#!/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

@@ -0,0 +1,48 @@
+#!/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])

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: concurrently
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Christopher Aue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nio4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: hitimes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: callbacks_attachable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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).
+email:
+- rubygems@christopheraue.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- RELEASE_NOTES.md
+- Rakefile
+- 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
+- guides/Overview.md
+- 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/all/concurrently/error.rb
+- lib/all/concurrently/evaluation.rb
+- lib/all/concurrently/evaluation/error.rb
+- lib/all/concurrently/event_loop.rb
+- lib/all/concurrently/event_loop/fiber.rb
+- lib/all/concurrently/event_loop/io_selector.rb
+- lib/all/concurrently/event_loop/proc_fiber_pool.rb
+- lib/all/concurrently/event_loop/run_queue.rb
+- lib/all/concurrently/proc.rb
+- lib/all/concurrently/proc/evaluation.rb
+- lib/all/concurrently/proc/fiber.rb
+- lib/all/concurrently/version.rb
+- lib/all/io.rb
+- lib/all/kernel.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
+homepage: https://github.com/christopheraue/m-ruby-concurrently
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib/Ruby
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: A concurrency framework based on fibers
+test_files: []