asynchronous 3.0.1 → 4.0.0.pre

data/lib/asynchronous/error.rb

@@ -0,0 +1,8 @@
+class Asynchronous::Error < StandardError
+
+  attr_reader :wrapped_error
+  def initialize(wrapped_error)
+    @wrapped_error= wrapped_error
+  end
+
+end

data/lib/asynchronous/kernel.rb

@@ -10,32 +10,33 @@
 #  "some awsome ruby code here!"
 # end
 #
-module Kernel
+module Asynchronous::DCI
 
-  def async type= :VM ,&block
+  extend self
 
+  def async(type= :VM, &block)
     case type.to_s.downcase[0]
+
       # Concurrency / VM / Green
-      when "c","v","g"
-        begin
-          Asynchronous::Concurrency.new(block)
-        end
+      when *%W[ c v g ]
+        ::Asynchronous::Concurrency.new(&block)
+
       # Parallelism / OS / Native
-      when "p","o","n"
-        begin
-          Asynchronous::Parallelism.new(block)
-        end
+      when *%W[ p o n ]
+        ::Asynchronous::Parallelism.new(&block)
+
       else
-        begin
-          Asynchronous::Concurrency.new(block)
-        end
+        ::Asynchronous::Concurrency.new(&block)
 
     end
-
   end
 
-  def shared_memory
-    Asynchronous::SharedMemory
-  end unless method_defined? :shared_memory
+end
+
+Kernel.class_eval do
+
+  def async(type=nil, &block)
+    ::Asynchronous::DCI.async(type, &block)
+  end
 
 end

data/lib/asynchronous/parallelism.rb

@@ -1,139 +1,135 @@
-module Asynchronous
-  # 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 Parallelism < Asynchronous::CleanClass
-
-    @@pids      ||= []
-    @@motherpid ||= $$
-
-    def asynchronous_fork callable
-      return ::Kernel.fork do
+# 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
 
-        begin
-          ::Kernel.trap("TERM") do
-            ::Kernel.exit
-          end
-          ::Thread.new do
-            ::Kernel.loop do
-              begin
-                ::Kernel.sleep 1
-                if ::Asynchronous::Parallelism.asynchronous_alive?(@@motherpid) == false
-                  ::Kernel.exit
-                end
-              end
-            end
-          end
-        end
+  attr_reader :pid
 
-        @comm_line[0].close
-        @comm_line[1].write ::Marshal.dump(callable.call)
-        @comm_line[1].flush
+  @@pids ||= []
+  @@motherpid ||= $$
 
-        #::Kernel.loop do
-        #  #::Kernel.puts @comm_line[0].closed?
-        #  #::Kernel.puts @comm_line[1].closed?
-        #  ::Kernel.sleep 1
-        #end
+  def initialize(disable_gc=true,&callable)
 
+    @disable_gc = !!disable_gc
 
-      end
-    end
+    @comm_line = ::IO.pipe
 
-    def asynchronous_read_buffer
-      @read_buffer = ::Thread.new do
-        while !@comm_line[0].eof?
-          @value = ::Marshal.load(@comm_line[0])
-        end
-      end
-    end
+    @value = nil
+    @read_buffer = nil
+
+    read_buffer
 
+    @pid = fork(&callable)
+    @@pids.push(@pid)
 
-    def initialize callable
+  end
 
-      @comm_line   = ::IO.pipe
-      @value       = nil
-      @read_buffer = nil
+  def self.alive?(pid)
+    ::Process.kill(0, pid)
+    return true
+  rescue ::Errno::ESRCH
+    return false
+  end
 
-      asynchronous_read_buffer
-      @pid= asynchronous_fork callable
-      @@pids.push(@pid)
+  def join
+    if @value.nil?
 
-    end
+      ::Process.wait(@pid, ::Process::WNOHANG)
 
-    def asynchronous_get_pid
-      return @pid
-    end
+      @comm_line[1].close
+      @read_buffer.join
+      @comm_line[0].close
 
-    def self.asynchronous_alive?(pid)
-      begin
-        ::Process.kill(0,pid)
-        return true
-        rescue ::Errno::ESRCH
-        return false
+      if @value.is_a?(::Asynchronous::Error)
+        raise(@value.wrapped_error)
       end
-    end
 
-    def asynchronous_get_value
+    end; self
+  end
 
-      if @value.nil?
+  def value
+    join; @value
+  end
 
-        ::Process.wait(@pid, ::Process::WNOHANG )
+  protected
 
-        @comm_line[1].close
-        @read_buffer.join
-        @comm_line[0].close
+  def pipe_read
+    @comm_line[0]
+  end
 
-      end
+  def pipe_write
+    @comm_line[1]
+  end
 
-      return @value
+  def fork(&block)
+    return ::Kernel.fork do
 
-    end
+      GC.disable if @disable_gc
 
-    def asynchronous_set_value(obj)
-      @value= obj
-    end
-    alias :asynchronous_set_value= :asynchronous_set_value
-
-    def synchronize
-      asynchronous_get_value
-    end
-    alias :sync :synchronize
-
-    # kill kidos at Kernel Exit
-    ::Kernel.at_exit {
-        @@pids.each { |pid|
-          begin
-            ::Process.kill(:TERM, pid)
-          rescue ::Errno::ESRCH, ::Errno::ECHILD
-            #::STDOUT.puts "`kill': No such process (Errno::ESRCH)"
+      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
 
-    def method_missing(method, *args)
+      @comm_line[0].close
 
-      return_value= nil
-      new_value= asynchronous_get_value
-      begin
-        original_value= new_value.dup
-      rescue ::TypeError
-        original_value= new_value
+      result = begin
+        block.call
+      rescue ::Exception => ex
+        ::Asynchronous::Error.new(ex)
       end
-      return_value= new_value.__send__(method,*args)
-      unless new_value == original_value
-          asynchronous_set_value new_value
-        end
 
-      return return_value
+      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

metadata

@@ -1,44 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: asynchronous
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 4.0.0.pre
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-17 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: process_shared
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: debugger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-description: ! 'DSL for for dead simple to use asynchronous patterns in both VM managed
+date: 2015-06-22 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) '
 email:
 - adamluzsi@gmail.com
@@ -52,21 +24,17 @@ files:
 - Rakefile
 - VERSION
 - asynchronous.gemspec
-- dump/async.rb
-- dump/shared_memory.rb
-- examples/array_of_value_with_native_threads.rb
 - examples/async_patterns.rb
+- examples/bootstrap.rb
 - examples/no_zombie_test.rb
-- examples/ruby_worker.rb
-- examples/shared_memory1.rb
-- examples/shared_memory2.rb
+- examples/parallelism.rb
 - files.rb
+- lib/async.rb
 - lib/asynchronous.rb
-- lib/asynchronous/clean_class.rb
 - lib/asynchronous/concurrency.rb
+- lib/asynchronous/error.rb
 - lib/asynchronous/kernel.rb
 - lib/asynchronous/parallelism.rb
-- lib/asynchronous/shared_memory.rb
 homepage: https://github.com/adamluzsi/asynchronous
 licenses: []
 metadata: {}
@@ -76,19 +44,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Simple Async Based on standard CRuby
 test_files: []
-has_rdoc: 

data/dump/async.rb

@@ -1,4 +0,0 @@
-#encoding: UTF-8
-module Asynchronous
-  require 'asynchronous'
-end

data/dump/shared_memory.rb

@@ -1,138 +0,0 @@
-require 'process_shared'
-require_relative "clean_class"
-module Asynchronous
-
-
-  module Allocation
-
-    class << self
-      attr_accessor :memory_allocation_size
-    end
-
-    self.memory_allocation_size= 16384
-
-    def self.mutex
-      @@mutex
-    end
-
-    @@mutex  = ProcessShared::Mutex.new
-
-  end
-
-
-  class SharedMemory < CleanClass
-    class << self
-      def method_missing(method, *args)
-
-        ::Asynchronous::Allocation.mutex.synchronize do
-          if method.to_s.include?('=')
-            begin
-              self.class_variable_get("@@#{method.to_s.sub('=','')}").write_object(args[0])
-            rescue ::NameError
-              self.class_variable_set(
-                  "@@#{method.to_s.sub('=','')}",
-                  ::ProcessShared::SharedMemory.new( ::Asynchronous::Allocation.memory_allocation_size )
-              )
-              self.class_variable_get("@@#{method.to_s.sub('=','')}").write_object(args[0])
-            end
-          else
-            begin
-              self.class_variable_get("@@#{method.to_s}").read_object
-            rescue ::NameError
-              return nil
-            end
-          end
-        end
-
-      end
-    end
-  end
-
-
-end
-
-SharedMemory ||= Asynchronous::SharedMemory
-
-
-
-=begin
-
-
-      # The C void type; only useful for function return types
-      :void => Type::VOID,
-
-      # C boolean type
-      :bool => Type::BOOL,
-
-      # C nul-terminated string
-      :string => Type::STRING,
-
-      # C signed char
-      :char => Type::CHAR,
-      # C unsigned char
-      :uchar => Type::UCHAR,
-
-      # C signed short
-      :short => Type::SHORT,
-      # C unsigned short
-      :ushort => Type::USHORT,
-
-      # C signed int
-      :int => Type::INT,
-      # C unsigned int
-      :uint => Type::UINT,
-
-      # C signed long
-      :long => Type::LONG,
-
-      # C unsigned long
-      :ulong => Type::ULONG,
-
-      # C signed long long integer
-      :long_long => Type::LONG_LONG,
-
-      # C unsigned long long integer
-      :ulong_long => Type::ULONG_LONG,
-
-      # C single precision float
-      :float => Type::FLOAT,
-
-      # C double precision float
-      :double => Type::DOUBLE,
-
-      # C long double
-      :long_double => Type::LONGDOUBLE,
-
-      # Native memory address
-      :pointer => Type::POINTER,
-
-      # 8 bit signed integer
-      :int8 => Type::INT8,
-      # 8 bit unsigned integer
-      :uint8 => Type::UINT8,
-
-      # 16 bit signed integer
-      :int16 => Type::INT16,
-      # 16 bit unsigned integer
-      :uint16 => Type::UINT16,
-
-      # 32 bit signed integer
-      :int32 => Type::INT32,
-      # 32 bit unsigned integer
-      :uint32 => Type::UINT32,
-
-      # 64 bit signed integer
-      :int64 => Type::INT64,
-      # 64 bit unsigned integer
-      :uint64 => Type::UINT64,
-
-      :buffer_in => Type::BUFFER_IN,
-      :buffer_out => Type::BUFFER_OUT,
-      :buffer_inout => Type::BUFFER_INOUT,
-
-      # Used in function prototypes to indicate the arguments are variadic
-      :varargs => Type::VARARGS,
-
-
-=end
-