asynchronous 4.0.0.pre → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b9e12c7186a3dc906e14faede2ecab396c1d6d1
-  data.tar.gz: 6ce4ccbbfe6fd0bbf064e323278fec86ecd3b814
+  metadata.gz: b45ba44d151028eeee66d2cd93f6dccf1da66940
+  data.tar.gz: 50e3542ab8a04221d7f3cef1cad1afd400fd2adb
 SHA512:
-  metadata.gz: 69ec170beaa0e9ff62e3044f25aa67f07ef42e7b6f5b1117aad5de72f907e4244a1a58039214db3ad09ac4b93149a3ee4902ed444104968daaabc67a4856e3c6
-  data.tar.gz: 337e7edc8238f24a442f79f33ee265fbb4d51856e9bfa755a9ae41d4f21eaea4d0d855f045a64e0b9f8e1aed1c1482e83c58efc2aa0b464fb4e26c4be20b1f3f
+  metadata.gz: 8698c24aaf589aa730a168b15ec1803d9c4575325470a8799d31e2f2fdfc6efb07918a1d3e2d1d39317ceca7827c63a18df52407954df812ed7c71dff29f8ff0
+  data.tar.gz: 81e768d82ad49ff3333ff7ba4b3b2f837c701077fc4a367d9d76adb34245feac5ee6d407b25970c2eafdb23250da2a1f35058b43f66a40a0ae6d6b1cca7acf9c

data/Gemfile

@@ -1,2 +1,4 @@
 source "http://rubygems.org"
-gemspec
+gemspec
+
+gem 'rspec'

data/Gemfile.lock

@@ -1,14 +1,32 @@
 PATH
   remote: .
   specs:
-    asynchronous (4.0.0.pre)
+    asynchronous (4.0.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    diff-lcs (1.3)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   asynchronous!
+  rspec
+
+BUNDLED WITH
+   1.16.0

data/README.md

@@ -2,19 +2,32 @@ Asynchronous
 ============
 
 Asynchronous Patterns for Ruby Based on Pure MRI CRuby code
-The goal is to use the original MRI C libs for achive
-real async patterns in ruby
+The goal is to use the original MRI C libs for achieve
+real async processing in ruby
 
-Well it is achived in Ruby really simple, and elegant way.
+This is good for where cpu focused for included,
+for example csv transformation
+
+### Example
+
+```ruby
+require 'asynchronous/core_ext'
+
+thr = async do
+    "some expensive work"
+end
+
+thr.value #> "some expensive work"
+```
 
 
 ### Quoting Sun's Multithreaded Programming Guide:
 
-Parallelism: 
+Parallelism:
 - A condition that arises when at least two threads are executing simultaneously.
 
-Concurrency: 
-- A condition that exists when at least two threads are making progress. 
+Concurrency:
+- A condition that exists when at least two threads are making progress.
 - A more generalized form of parallelism that can include time-slicing as a form of virtual parallelism
 
 #### for short:
@@ -25,101 +38,3 @@ Eg. multitasking on a single-core machine.
 
 Parallelism is when tasks literally run at the same time.
 Eg. on a multicore processor.
-
-
-### OS managed thread (Native Threads)
-
-copy on write memory share,
-so you cant change anything in the mother process
-only with the return value later.
-This method is stronger the more CPU core the os have
-
-Ideal for Big jobs that require lot of memory allocation or
-heavy CPU load to get a value
-Like parsing (in some case)
-
-```ruby
-
-thr = async :parallelism do
-
-  sleep 4
-  # remember, everything you
-  # write here only mather in this block
-  # will not affect the real process only
-  # the last return value of the block
-  4 * 5
-
-end
-
-# to call the value:
-thr.value
-
-```
-
-## VM managed thread (Green Threads)
-
-you can use simple :c also instead of :concurrency as sym,
-remember :concurrency is all about GIL case, so
-you can modify the objects in memory
-This is ideal for little operations in simultaneously or
-when you need to update objects in the memory and not the
-return value what is mather.
-Remember well that GarbageCollector will affect the speed.
-
-```ruby
-
-  thr = async { sleep 3; 4 * 3 }
-  
-  # to call the value:
-  calculation = thr.value
-
-```
-
-### Example
-
-you can use simple :p or :parallelism as nametag
-remember :parallelism is all about real OS thread case, 
-so you CANT modify the objects in the memory,
-the normal variables will only be copy on write modify
-
-This is ideal for big operations where you need do a big process
-w/o the fear of the Garbage collector slowness or the GIL lock
-when you need to update objects in the memory use SharedMemory
-
-Remember! if the hardware only got 1 cpu, it will be like a harder
-to use concurrency with an expensive memory allocation
-
-```ruby
-
-  thr = async :OS do
-  
-    sleep 4
-    4 * 5
-  
-  end
-  
-  calculation = thr.value
-  calculation += 1
-  
-  puts calculation
-
-```
-
-
-there are other examples that you can check in the exampels folder
-
-### known bugs
-
-In rare case when you get object_buffer error
-* use .join method on the async variable
-
-```ruby
-
-  thr = async :OS do
-    sleep 4
-    4 * 5
-  end
-  
-  thr.join #> thr
-
-```

data/VERSION

@@ -1 +1 @@
-4.0.0.pre
+4.0.0

data/examples/basic.rb

@@ -0,0 +1,11 @@
+# Require Gemfile gems
+require_relative 'bootstrap'
+
+thr1 = async do
+  sleep 2
+  4 * 2
+end
+
+calculation1 = thr1.value
+calculation1 += 1
+puts calculation1

data/examples/bootstrap.rb

@@ -1,2 +1,2 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__),'..','lib'))
-require 'asynchronous'
+require 'asynchronous/core_ext'

data/lib/asynchronous.rb

@@ -1,7 +1,7 @@
 #encoding: UTF-8
 module Asynchronous
+  require 'asynchronous/utils'
   require 'asynchronous/error'
-  require 'asynchronous/concurrency'
-  require 'asynchronous/parallelism'
-  require 'asynchronous/kernel'
+  require 'asynchronous/thread'
+  require 'asynchronous/zombi_killer'
 end

data/lib/asynchronous/core_ext.rb

@@ -0,0 +1,13 @@
+require 'asynchronous'
+#
+# kernel method for asyncron calls
+# basic version is :
+#
+# thr = async { "ruby Code here" }
+# thr.value #> "ruby Code here"
+#
+Kernel.class_eval do
+  def async(&block)
+    ::Asynchronous::Thread.new(&block)
+  end
+end

data/lib/asynchronous/thread.rb

@@ -0,0 +1,87 @@
+class Asynchronous::Thread
+  def initialize(&callable)
+    @value = nil
+    @value_received = false
+    @read, @write = ::IO.pipe
+    read_buffer
+
+    @pid = fork(&callable)
+  end
+
+  def join
+    wait
+    receive_value! unless @value_received
+    raise(@value.wrapped_error) if @value.is_a?(::Asynchronous::Error)
+    self
+  end
+
+  def kill
+    ::Process.kill('KILL', @pid)
+
+    wait
+  rescue Errno::ESRCH
+    nil
+  end
+
+  def status
+    alive? ? 'run' : false
+  end
+
+  def value
+    join; @value
+  end
+
+  protected
+
+  def alive?
+    ::Asynchronous::Utils.alive?(@pid)
+  end
+
+  def receive_value!
+    @write.close
+    read_buffer.join
+    @read.close
+    @value_received = true
+  end
+
+  def wait(flag = 0)
+    ::Process.wait(@pid, flag)
+  rescue Errno::ECHILD
+    nil
+  end
+
+  def fork(&callable)
+    ::Kernel.fork { main(&callable) }
+  end
+
+  def read_buffer
+    @read_buffer ||= ::Thread.new do
+      @value = Marshal.load(@read)
+    end
+  end
+
+  def main
+    ::Asynchronous::ZombiKiller.antidote
+
+    @read.close
+
+    result = begin
+      yield
+    rescue ::Exception => ex
+      ::Asynchronous::Error.new(ex)
+    end
+
+    write_result!(result)
+  end
+
+  def write_result!(result)
+    return unless Asynchronous::ZombiKiller.how_is_mom?
+    ::Marshal.dump(result, @write)
+    @write.flush
+    @write.close
+  rescue Errno::EPIPE
+    nil
+  end
+end
+
+# Marshal.load(File.binread(FNAME))

data/lib/asynchronous/utils.rb

@@ -0,0 +1,10 @@
+module Asynchronous::Utils
+  def alive?(pid)
+    ::Process.kill(0, pid)
+    return true
+  rescue ::Errno::ESRCH
+    return false
+  end
+
+  module_function :alive?
+end

data/lib/asynchronous/zombi_killer.rb

@@ -0,0 +1,20 @@
+module Asynchronous::ZombiKiller
+  MOTHER_PID ||= $$
+
+  def how_is_mom?
+    Asynchronous::Utils.alive?(MOTHER_PID)
+  end
+
+  def antidote
+    Thread.main[:ZombiKiller] ||= ::Thread.new do
+      loop do
+        ::Kernel.exit unless how_is_mom?
+
+        ::Kernel.sleep(1)
+      end
+    end
+  end
+
+  module_function :antidote, :how_is_mom?
+
+end

data/spec/asynchronous/thread_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+RSpec.describe Asynchronous::Thread do
+  subject(:thread) { described_class.new(&block) }
+
+  describe '#join' do
+    subject(:joining) { thread.join }
+    let(:block) { proc { sleep(1.5) } }
+
+    it { is_expected.to be thread }
+    it { expect { 3.times { thread.join } }.to_not raise_error }
+    it { expect { Timeout.timeout(1) { joining } }.to raise_error(Timeout::Error) }
+    it { expect { joining; Process.kill(0, thread.instance_variable_get(:@pid)) }.to raise_error(Errno::ESRCH) }
+
+    context 'when exception raised in the thread' do
+      let(:block) { proc { raise 'boom' } }
+
+      it { expect { joining }.to raise_error 'boom' }
+    end
+  end
+
+  describe '#value' do
+    subject(:value) { thread.value }
+
+    [
+      true,
+      false,
+
+      42,
+      -42,
+      (2**30),
+      (2**30) - 1,
+
+      42.13,
+      -42.13,
+      (2**30) + 0.1,
+      (2**30) + 0.1 - 1,
+
+      [1, 2, 3],
+
+      { :a => :b },
+
+      'hello world!',
+      :hello_world,
+      :"hello world!",
+
+      StandardError.new('Boom!')
+    ].each do |expected_value|
+      context "when the return value is a #{expected_value.class}" do
+        let(:block) { proc { expected_value } }
+
+        it { is_expected.to eq expected_value }
+        it { is_expected.to be_a expected_value.class }
+      end
+    end
+
+    context "when it's a custom class" do
+      expected_value = ExampleCustomClassForValue.new('test')
+      let(:block) { proc { expected_value } }
+
+      get_instance_variables = lambda do |object|
+        object.instance_variables.map { |iv| object.instance_variable_get(iv) }.sort
+      end
+
+      it { is_expected.to be_a expected_value.class }
+      it { expect(get_instance_variables.call(value)).to eq get_instance_variables.call(expected_value) }
+    end
+
+    context "when it's a huge string" do
+      long_string = 'X' * 1024 * 100
+      let(:block) { proc { long_string } }
+      it { is_expected.to eq long_string }
+    end
+
+    context 'when an exception raised in the async process' do
+      let(:block) { proc { raise 'boom!' } }
+      it { expect { value }.to raise_error 'boom!' }
+    end
+  end
+
+  describe '#kill' do
+    subject(:killing) { thread.kill }
+
+    context 'given the thread running in the background' do
+      let(:block) { proc { sleep(10) } }
+
+      it { expect { killing }.to_not raise_error }
+    end
+
+    context 'given thread not running in the background anymore' do
+      let(:block) { proc {} }
+
+      it { expect { sleep(1); killing }.to_not raise_error }
+    end
+
+    context 'given thread already killed' do
+      let(:block) { proc {} }
+
+      it { expect { sleep(1); 3.times { thread.kill } }.to_not raise_error }
+    end
+  end
+
+  describe '#status' do
+    subject(:status) { thread.status }
+
+    context 'when thread is alive' do
+      let(:block) { proc { sleep(5) } }
+
+      it { is_expected.to eq 'run' }
+    end
+
+    context 'when thread is completed' do
+      let(:block) { proc {} }
+      before { thread.join }
+      it { is_expected.to eq false }
+    end
+
+    context 'when thread is killed' do
+      let(:block) { proc { sleep(10) } }
+      before { thread.kill }
+      it { is_expected.to be false }
+    end
+  end
+
+  describe 'no zombies' do
+    subject(:pid) { `ruby -r "#{BOOTSTRAP_FILE_PATH}" -e "pid = async { sleep(15) }.instance_variable_get(:@pid); puts pid "`.to_i }
+
+    it { expect { pid; sleep(2); Process.kill(0, pid) }.to raise_error Errno::ESRCH }
+  end
+end
+
+# http://ruby-doc.org/core-2.2.0/Thread.html
+# join
+# key?
+# keys
+# kill
+# pending_interrupt?
+# priority
+# priority=
+# raise
+# run
+# safe_level
+# set_trace_func
+# status
+# stop?
+# terminate
+# thread_variable?
+# thread_variable_get
+# thread_variable_set
+# thread_variables
+# value
+# wakeup

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'rspec'
+require 'timeout'
+require 'asynchronous'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end
+
+Kernel.at_exit do
+  if Asynchronous::ZombiKiller::MOTHER_PID == $PROCESS_ID
+    begin
+      loop { Process.kill('KILL', Process.wait(-1, Process::WUNTRACED)) }
+    rescue Errno::ESRCH, Errno::ECHILD
+      puts 'done'
+    end
+  end
+end
+
+class ExampleCustomClassForValue
+  attr_reader :a
+  def initialize(a)
+    @a = a
+  end
+end
+
+BOOTSTRAP_FILE_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..', 'examples', 'bootstrap.rb'))

data/t.rb

@@ -0,0 +1,10 @@
+
+
+begin
+  10_000.times do
+    Kernel.fork { sleep(10) }
+  end
+rescue Exception => exception
+  puts exception.class
+  puts exception
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asynchronous
 version: !ruby/object:Gem::Version
-  version: 4.0.0.pre
+  version: 4.0.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-22 00:00:00.000000000 Z
+date: 2018-01-26 00:00:00.000000000 Z
 dependencies: []
 description: 'DSL for for dead simple to use asynchronous patterns in both VM managed
   and OS managed way (Concurrency and Parallelism) '
@@ -24,17 +24,18 @@ files:
 - Rakefile
 - VERSION
 - asynchronous.gemspec
-- examples/async_patterns.rb
+- examples/basic.rb
 - examples/bootstrap.rb
-- examples/no_zombie_test.rb
-- examples/parallelism.rb
 - files.rb
-- lib/async.rb
 - lib/asynchronous.rb
-- lib/asynchronous/concurrency.rb
+- lib/asynchronous/core_ext.rb
 - lib/asynchronous/error.rb
-- lib/asynchronous/kernel.rb
-- lib/asynchronous/parallelism.rb
+- lib/asynchronous/thread.rb
+- lib/asynchronous/utils.rb
+- lib/asynchronous/zombi_killer.rb
+- spec/asynchronous/thread_spec.rb
+- spec/spec_helper.rb
+- t.rb
 homepage: https://github.com/adamluzsi/asynchronous
 licenses: []
 metadata: {}
@@ -49,13 +50,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Simple Async Based on standard CRuby
-test_files: []
+test_files:
+- spec/asynchronous/thread_spec.rb
+- spec/spec_helper.rb

data/examples/async_patterns.rb

@@ -1,78 +0,0 @@
-# Require Gemfile gems
-require_relative 'bootstrap'
-
-# you can use simple :c also instead of :concurrency
-# remember :concurrency is all about GIL case, so
-# you can modify the objects in memory
-# This is ideal for little operations in simultaneously or
-# when you need to update objects in the memory
-thr1 = async :concurrency do
-
-  sleep 2
-  4 * 2
-
-end
-puts "hello concurrency"
-
-calculation1 = thr1.value
-calculation1 += 1
-
-puts calculation1
-
-#>--------------------------------------------------
-# or you can use simple {} without sym and this will be by default a
-# :concurrency pattern
-
-thr2 = async { sleep 3; 4 * 3 }
-
-puts "hello simple concurrency"
-
-calculation2 = thr2.value
-calculation2 += 1
-
-# remember you have to use  to cal the return value from the code block!
-puts calculation2
-
-
-#>--------------------------------------------------
-# now let's see the Parallelism
-# you can use simple :p or :parallelism as nametag
-# remember :parallelism is all about real OS thread case, so
-# you CANT modify the objects in memory only in sharedmemories,
-# the normal variables will only be copy on write modify
-# This is ideal for big operations where you need do a big process
-# w/o the fear of the Garbage collector slowness or the GIL lock
-# when you need to update objects in the memory use SharedMemory
-thr3 = async :parallelism do
-
-  sleep 4
-  4 * 5
-
-end
-puts "hello parallelism"
-
-calculation3 = thr3.value
-calculation3 += 1
-
-puts calculation3
-
-#>--------------------------------------------------
-
-# more complex way
-
-puts "mixed usecase with arrays as return obj"
-thr4 = async :parallelism do
-
-  sleep 4
-  # some big database processing brutal memory eater stuff
-  [4*5,"hy"]
-
-end
-
-thr5 = async {
-  [5+1,"sup!"]
-}
-
-puts 'calc1 is eql calc2:',thr4.value == thr5.value
-puts (thr4.value+thr5.value).inspect
-

data/examples/no_zombie_test.rb

@@ -1,29 +0,0 @@
-require_relative 'bootstrap'
-
-thr = async :parallelism do
-
-  # Zombie!
-  loop do
-    sleep 1
-    puts "brains(#{$$})"
-  end
-  # inf loop
-  #
-
-end
-
-puts $$
-Thread.new do
-
-  sleep 5
-
-  # this want to demonstrate that,
-  # if the main process is killed,
-  # you wont leave zombies behind!
-  system "kill -9 #{$$}"
-
-end
-
-loop do
-  sleep 1
-end

data/examples/parallelism.rb

@@ -1,35 +0,0 @@
-require_relative 'bootstrap'
-
-async1= async :OS do
-  1000000*5
-end
-
-async2= async :OS do
-
-  var = ("!" * 1000000)
-  puts "the superHuge String length in the pipe is: #{var.length}"
-
-  var
-end
-
-async2_error= async :OS do
-
-  raise(SystemExit)
-  puts 'never happen, to system error happened!'
-
-end
-
-async3= async :OS do
-  1000000*5.0
-end
-
-begin
-  async2_error.value
-rescue Exception => ex
-  puts "\n",'when error happen:',ex
-end
-
-puts "\n",'result length based on string form:'
-puts async1.value.to_s.length
-puts async2.value.to_s.length
-puts async3.value.to_s.length

data/lib/async.rb

@@ -1 +0,0 @@
-require 'asynchronous'

data/lib/asynchronous/concurrency.rb

@@ -1,44 +0,0 @@
-# you can use simple :c also instead of :concurrency
-# remember :concurrency is all about GIL case, so
-# you can modify the objects in memory
-# This is ideal for little operations in simultaneously or
-# when you need to update objects in the memory
-class Asynchronous::Concurrency
-
-  def initialize(&block)
-
-    @rescue_state= nil
-    @try_count = 0
-
-    begin
-      @value= nil
-      @thread ||= ::Thread.new { block.call }
-      @rescue_state= nil
-    rescue ThreadError
-      @rescue_state ||= true
-      @try_count += 1
-      if 3 <= @try_count
-        @value= block.call
-        @rescue_state= nil
-      else
-        sleep 5
-        retry
-      end
-    end
-
-  end
-
-  def join
-    if @value.nil?
-      until @rescue_state.nil?
-        sleep 1
-      end
-      @value= @thread.value
-    end
-  end
-
-  def value
-    join; @value
-  end
-
-end

data/lib/asynchronous/kernel.rb

@@ -1,42 +0,0 @@
-# kernel method for asyncron calls
-# basic version is :
-#
-# var= async { "ruby Code here" }
-# var.value #> "ruby Code here"
-#
-# or
-#
-# var = async :parallelism do
-#  "some awsome ruby code here!"
-# end
-#
-module Asynchronous::DCI
-
-  extend self
-
-  def async(type= :VM, &block)
-    case type.to_s.downcase[0]
-
-      # Concurrency / VM / Green
-      when *%W[ c v g ]
-        ::Asynchronous::Concurrency.new(&block)
-
-      # Parallelism / OS / Native
-      when *%W[ p o n ]
-        ::Asynchronous::Parallelism.new(&block)
-
-      else
-        ::Asynchronous::Concurrency.new(&block)
-
-    end
-  end
-
-end
-
-Kernel.class_eval do
-
-  def async(type=nil, &block)
-    ::Asynchronous::DCI.async(type, &block)
-  end
-
-end

data/lib/asynchronous/parallelism.rb

@@ -1,135 +0,0 @@
-# now let's see the Parallelism
-# you can use simple :p also instead of :parallelism
-# remember :parallelism is all about real OS thread case, so
-# you CANT modify the objects in memory only copy on write modify
-# This is ideal for big operations where you need do a big process
-# and only get the return value so you can do big works without the fear of the
-# Garbage collector slowness or the GIL lock
-# when you need to update objects in the memory use :concurrency
-class Asynchronous::Parallelism
-
-  attr_reader :pid
-
-  @@pids ||= []
-  @@motherpid ||= $$
-
-  def initialize(disable_gc=true,&callable)
-
-    @disable_gc = !!disable_gc
-
-    @comm_line = ::IO.pipe
-
-    @value = nil
-    @read_buffer = nil
-
-    read_buffer
-
-    @pid = fork(&callable)
-    @@pids.push(@pid)
-
-  end
-
-  def self.alive?(pid)
-    ::Process.kill(0, pid)
-    return true
-  rescue ::Errno::ESRCH
-    return false
-  end
-
-  def join
-    if @value.nil?
-
-      ::Process.wait(@pid, ::Process::WNOHANG)
-
-      @comm_line[1].close
-      @read_buffer.join
-      @comm_line[0].close
-
-      if @value.is_a?(::Asynchronous::Error)
-        raise(@value.wrapped_error)
-      end
-
-    end; self
-  end
-
-  def value
-    join; @value
-  end
-
-  protected
-
-  def pipe_read
-    @comm_line[0]
-  end
-
-  def pipe_write
-    @comm_line[1]
-  end
-
-  def fork(&block)
-    return ::Kernel.fork do
-
-      GC.disable if @disable_gc
-
-      begin
-        ::Kernel.trap("TERM") do
-          ::Kernel.exit
-        end
-        ::Thread.new do
-          ::Kernel.loop do
-            begin
-              ::Kernel.sleep 1
-              if ::Asynchronous::Parallelism.alive?(@@motherpid) == false
-                ::Kernel.exit!
-              end
-            end
-          end
-        end
-      end
-
-      @comm_line[0].close
-
-      result = begin
-        block.call
-      rescue ::Exception => ex
-        ::Asynchronous::Error.new(ex)
-      end
-
-      dumped_result = ::Marshal.dump(result).to_s
-
-      @comm_line[1].write(dumped_result)
-      ::Kernel.sleep(dumped_result.length.to_f*0.005)
-
-      @comm_line[1].flush
-      @comm_line[1].close
-
-    end
-  end
-
-  def read_buffer
-    @read_buffer = ::Thread.new do
-      while !@comm_line[0].eof?
-
-        begin
-          @value = ::Marshal.load(@comm_line[0])
-        rescue ::ArgumentError => ex
-          sleep(1)
-          retry if ex.respond_to?(:message) && ex.message =~ /marshal data too short/i
-        end
-
-      end
-    end
-  end
-
-  # kill kidos at Kernel Exit
-  ::Kernel.at_exit do
-    @@pids.each do |pid|
-      begin
-        ::Process.kill(:TERM, pid)
-      rescue ::Errno::ESRCH, ::Errno::ECHILD
-        #::STDOUT.puts "`kill': No such process (Errno::ESRCH)"
-      end
-    end
-  end
-
-end