asynchronous 3.0.1 → 4.0.0.pre

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MWRlMTE2ZjM5MmYyYjRiN2I3NGIyYjJhMTdmNGY1NzcxNjMxMGJjMg==
-  data.tar.gz: !binary |-
-    OGNlZWE3MjliNGRhMzY3NGEzZTZkMGE4M2Q3NTExZGU0NGY0OWNhMQ==
+SHA1:
+  metadata.gz: 8b9e12c7186a3dc906e14faede2ecab396c1d6d1
+  data.tar.gz: 6ce4ccbbfe6fd0bbf064e323278fec86ecd3b814
 SHA512:
-  metadata.gz: !binary |-
-    MTY3MmUyNTI2ODkxODMzZGEwNDdkMDI2YzY1Y2Y0MDZlOWUyOTM0NDI0MDEx
-    YjMzN2U3NTBhNjMzNGM4Y2I1ODI1MDBhNTgyMTg2NzQ1YWM5YzM3MDhlNWIw
-    ZDBiOTlkMjI2MTM4OTcwYTg0YjA3YWNlOTlmZGRhN2E3MWI2NzI=
-  data.tar.gz: !binary |-
-    NDRlMmNhODk3NDQ0YjkwNWY4MzJiNDNiMDQwZTg3YjNkNDE5Yzg3ZTQwYTRk
-    OWNiZWRjZjg1NGMwODhmODE3OGU2NDNhYjQ5M2UwMTI4MzA2NWM4ZDc5OWRj
-    ZTdhNmUxZTRmMDI5NmZjNmFjYWRiOTIwMGZmYjczNDgxYjU1YmM=
+  metadata.gz: 69ec170beaa0e9ff62e3044f25aa67f07ef42e7b6f5b1117aad5de72f907e4244a1a58039214db3ad09ac4b93149a3ee4902ed444104968daaabc67a4856e3c6
+  data.tar.gz: 337e7edc8238f24a442f79f33ee265fbb4d51856e9bfa755a9ae41d4f21eaea4d0d855f045a64e0b9f8e1aed1c1482e83c58efc2aa0b464fb4e26c4be20b1f3f

data/Gemfile.lock

@@ -1,26 +1,14 @@
 PATH
   remote: .
   specs:
-    asynchronous (2.1.0)
-      process_shared
+    asynchronous (4.0.0.pre)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    columnize (0.3.6)
-    debugger (1.6.2)
-      columnize (>= 0.3.1)
-      debugger-linecache (~> 1.2.0)
-      debugger-ruby_core_source (~> 1.2.3)
-    debugger-linecache (1.2.0)
-    debugger-ruby_core_source (1.2.3)
-    ffi (1.9.3)
-    process_shared (0.2.0)
-      ffi (~> 1.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   asynchronous!
-  debugger

data/README.md

@@ -40,7 +40,7 @@ Like parsing (in some case)
 
 ```ruby
 
-calculation = async :parallelism do
+thr = async :parallelism do
 
   sleep 4
   # remember, everything you
@@ -51,8 +51,8 @@ calculation = async :parallelism do
 
 end
 
-# to call the value (syncronize):
-calculation
+# to call the value:
+thr.value
 
 ```
 
@@ -68,74 +68,40 @@ Remember well that GarbageCollector will affect the speed.
 
 ```ruby
 
-calculation= async { sleep 3; 4 * 3 }
-# to call the value (syncronize):
-calculation
+  thr = async { sleep 3; 4 * 3 }
+  
+  # to call the value:
+  calculation = thr.value
 
 ```
 
-### Shared Memory
-
-By default the last value will be returned (OS) in IO.pipe,
-but when you need something else, there is the shared_memory!
-
-Shared memory is good when you want make a ruby worked on native OS thread ,
-but need to update data back at the mother process.
-
-the usecase is simple like that:
-```ruby
-
-SharedMemory.anything_you_want_use_as_variable_name= {:some=>:object}
-SharedMemory.anything_you_want_use_as_variable_name #> {:some=>:object}
-
-# or
-
-shared_memory.anything_you_want_use_as_variable_name #> {:some=>:object}
-
-```
-
-by default i set the memory allocation to 16Mb because it common usecase to me (MongoDB),
-but feel free to change!:
-```ruby
-
-Asynchronous.memory_allocation_size= 1024 #INT!
-
-```
-
-## making shared memory obj static (constant)
-
-you can set a shared memory obj to be static if you dont want it to be changed later on
-```ruby
-shared_memory.test_value= Array.new.push(:something)
-Asynchronous.static_variables.push :test_value
-shared_memory.test_value= Array.new #> this wont happen
-```
-
-
 ### Example
 
-```ruby
-
-# 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
-#
-# Remember! if the hardware only got 1 cpu, it will be like a harder
-# to use concurrency with an expensive memory allocation
-calculation = async :OS do
+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
 
-  sleep 4
-  4 * 5
+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
 
-end
+Remember! if the hardware only got 1 cpu, it will be like a harder
+to use concurrency with an expensive memory allocation
 
-calculation += 1
+```ruby
 
-puts calculation
+  thr = async :OS do
+  
+    sleep 4
+    4 * 5
+  
+  end
+  
+  calculation = thr.value
+  calculation += 1
+  
+  puts calculation
 
 ```
 
@@ -145,32 +111,15 @@ there are other examples that you can check in the exampels folder
 ### known bugs
 
 In rare case when you get object_buffer error
-* use .sync method on the async variable
+* use .join method on the async variable
 
 ```ruby
-calculation = async :OS do
-  sleep 4
-  4 * 5
-end
 
-calculation.sync #> or synchronize
-```
-
-Kernel holding on Native threads with pipes can choke up
-* direct sleep commands can do this on multiple native threads
-** hard processing load not like that, only kernel sleep
-
-SharedMemory objects not updating on chain method obj manipulation
-
-```ruby
-shared_memory.var= {'jobs'=>[]}
+  thr = async :OS do
+    sleep 4
+    4 * 5
+  end
+  
+  thr.join #> thr
 
-{'jobs'=>[]}['jobs'].push 'data' #> {'jobs'=>[]}
-
-workaround is like that:
-
-local_variable= {'jobs'=>[]}
-local_variable['jobs'].push('data')
-
-shared_memory.var= local_variable
-```
+```

data/VERSION

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

data/asynchronous.gemspec

@@ -19,8 +19,4 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "process_shared"
-  spec.add_development_dependency(%q<debugger>, [">= 0"])
-
-
 end

data/examples/async_patterns.rb

@@ -1,12 +1,12 @@
 # Require Gemfile gems
-require_relative "../lib/asynchronous"
+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
-calculation = async :concurrency do
+thr1 = async :concurrency do
 
   sleep 2
   4 * 2
@@ -14,22 +14,24 @@ calculation = async :concurrency do
 end
 puts "hello concurrency"
 
-calculation += 1
+calculation1 = thr1.value
+calculation1 += 1
 
-puts calculation
+puts calculation1
 
 #>--------------------------------------------------
 # or you can use simple {} without sym and this will be by default a
 # :concurrency pattern
 
-calculation = async { sleep 3; 4 * 3 }
+thr2 = async { sleep 3; 4 * 3 }
 
 puts "hello simple concurrency"
 
-calculation += 1
+calculation2 = thr2.value
+calculation2 += 1
 
 # remember you have to use  to cal the return value from the code block!
-puts calculation
+puts calculation2
 
 
 #>--------------------------------------------------
@@ -41,7 +43,7 @@ puts calculation
 # 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
-calculation = async :parallelism do
+thr3 = async :parallelism do
 
   sleep 4
   4 * 5
@@ -49,16 +51,17 @@ calculation = async :parallelism do
 end
 puts "hello parallelism"
 
-calculation += 1
+calculation3 = thr3.value
+calculation3 += 1
 
-puts calculation
+puts calculation3
 
 #>--------------------------------------------------
 
 # more complex way
 
 puts "mixed usecase with arrays as return obj"
-calc1 = async :parallelism do
+thr4 = async :parallelism do
 
   sleep 4
   # some big database processing brutal memory eater stuff
@@ -66,10 +69,10 @@ calc1 = async :parallelism do
 
 end
 
-calc2 = async {
+thr5 = async {
   [5+1,"sup!"]
 }
 
-puts calc1 == calc2
-puts (calc1+calc2).inspect
+puts 'calc1 is eql calc2:',thr4.value == thr5.value
+puts (thr4.value+thr5.value).inspect
 

data/examples/bootstrap.rb

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

data/examples/no_zombie_test.rb

@@ -1,10 +1,11 @@
-require_relative "../lib/asynchronous"
+require_relative 'bootstrap'
 
-calculation = async :parallelism do
+thr = async :parallelism do
 
   # Zombie!
   loop do
     sleep 1
+    puts "brains(#{$$})"
   end
   # inf loop
   #
@@ -13,12 +14,14 @@ 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

data/examples/parallelism.rb

@@ -0,0 +1,35 @@
+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

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

data/lib/asynchronous.rb

@@ -1,12 +1,7 @@
 #encoding: UTF-8
 module Asynchronous
-
-  require 'process_shared'
-
-  require File.join(File.dirname(__FILE__),"asynchronous","clean_class")
-  require File.join(File.dirname(__FILE__),"asynchronous","concurrency")
-  require File.join(File.dirname(__FILE__),"asynchronous","parallelism")
-  require File.join(File.dirname(__FILE__),"asynchronous","shared_memory")
-  require File.join(File.dirname(__FILE__),"asynchronous","kernel")
-
+  require 'asynchronous/error'
+  require 'asynchronous/concurrency'
+  require 'asynchronous/parallelism'
+  require 'asynchronous/kernel'
 end

data/lib/asynchronous/concurrency.rb

@@ -1,78 +1,44 @@
-module Asynchronous
-
-  # 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 Concurrency < Asynchronous::CleanClass
-
-    def initialize callable
-      begin
-        @value= nil
-        @try_count= 0
-        @rescue_state= nil
-        @thread ||= ::Thread.new { callable.call }
+# 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
-      rescue ThreadError
-        @rescue_state ||= true
-        @try_count += 1
-        if 3 <= @try_count
-          @value= callable.call
-          @rescue_state= nil
-        else
-          sleep 5
-          retry
-        end
+      else
+        sleep 5
+        retry
       end
     end
 
-    def asynchronous_get_value
-
-      if @value.nil?
-        until @rescue_state.nil?
-          sleep 1
-        end
-        @value= @thread.value
-      end
-
-      return @value
-
-    end
-
-    def asynchronous_set_value(obj)
-      @value= obj
-    end
-    alias :asynchronous_set_value= :asynchronous_set_value
-
-    def synchronize
-      asynchronous_get_value
-    end
-    alias :sync :synchronize
-
-    def method_missing(method, *args)
-
-      new_value= asynchronous_get_value
-
-      begin
-        original_value= new_value.dup
-      rescue ::TypeError
-        original_value= new_value
-      end
+  end
 
-      return_value= new_value.__send__(method,*args)
-      unless new_value == original_value
-        asynchronous_set_value new_value
+  def join
+    if @value.nil?
+      until @rescue_state.nil?
+        sleep 1
       end
-
-      return return_value
-
+      @value= @thread.value
     end
+  end
 
-    #def respond_to_missing?(method, include_private = false)
-    #  value.respond_to?(method, include_private)
-    #end
-
+  def value
+    join; @value
   end
 
 end