asynchronous 2.1.0 → 3.0.0.pre.pre

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODFiY2RkZGRlOGIyZTRmZDA4NTIyNWY1OWY2ZjJhNjRiYmI3YjVmMQ==
+    MzI1NjQ3MTczMjQ3YjNhNThlNjY4ZDZiMjA0MmI0MWNiYzgxODJlNw==
   data.tar.gz: !binary |-
-    MTgwNmU5NWVkZmYyNGI0MTFhYTUyMjAwODE0ZDY1M2M3Nzc4MDBlZQ==
+    ZjAyZTNlNDYwZWY5NTJlOWViMWFmYTYzYjY3ZmEwNWQ5NmJhNWNkMg==
 SHA512:
   metadata.gz: !binary |-
-    ZjZjMzE2NjQxZmQ1MjMzZWY3MWNiOTNhMDFiMWUzNGMyNDI0MmNhN2U2YzFl
-    YmEyMGUzNjBjYmU0NDk1NzZhNjYyY2Y4YzM4ZWMxYjExNjhmYjdmNjQ5NWRj
-    Y2UxYTE3NmQzMTMyOTQ0N2E0YmZhZTE3ZWZiOGJiMTE1YzZlZTM=
+    YjZjY2FiOWY3YzFmNjk0ZDRhNjVjZmQwYzc1NjdiOWEwMzVkZmI3MWY3NTg1
+    NDFkM2E5Njg2ZGZkMjQ0MjBmZmU1YTliYTk0MTc0YzEyYTZmZmU0MGJlNzM0
+    OWE4ZTdmMzIxNTViM2VkNzc0YzljNWJkOTg2Mzk5OTE5NTljZDE=
   data.tar.gz: !binary |-
-    MTAyZjY2YTQyYzc3MDU1ZDFiODhiZjJiMTlhNjNmZmE3NmExZDIyZDAxMDMw
-    OGEzZjk2Y2ExZTM4MjYxOGFjNTllMjljNTFjNWMwZTZmNWFiZjk1YzM0MzA1
-    NzY5MmM5MDFjZWMyMzMxYWI5ZDY2NDIwMDYyNTIyMDk0NTYxMzA=
+    Y2Y1MmY4NGRkMTJlYzU2NGU4ZjJhODNkMTNiMjEwNDQ4Y2QxYTc2YWZiNjg4
+    YzM2NDc4ZjM0Njk5MTE5YzFjMDg4NGNlOWViM2VmNGU3MWMzZDliODY5OGJi
+    ZjcwNWQ0ODc2YmIxMjcwZjBhNDY3NjMwZDNhODM0MGI5YjgyZTk=

data/Gemfile.lock

@@ -1,12 +1,19 @@
 PATH
   remote: .
   specs:
-    asynchronous (1.1.0.pre.pre)
+    asynchronous (2.1.0)
       process_shared
 
 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)
@@ -16,3 +23,4 @@ PLATFORMS
 
 DEPENDENCIES
   asynchronous!
+  debugger

data/README.md

@@ -52,7 +52,7 @@ calculation = async :parallelism do
 end
 
 # to call the value (syncronize):
-calculation.value
+calculation
 
 ```
 
@@ -70,7 +70,7 @@ Remember well that GarbageCollector will affect the speed.
 
 calculation= async { sleep 3; 4 * 3 }
 # to call the value (syncronize):
-calculation.value
+calculation
 
 ```
 
@@ -98,11 +98,21 @@ by default i set the memory allocation to 16Mb because it common usecase to me (
 but feel free to change!:
 ```ruby
 
-Asynchronous::Allocation.memory_allocation_size= 1024 #INT!
+Asynchronous.memory_allocation_size= 1024 #INT!
 
 ```
 
-## Example
+## 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
 
@@ -123,10 +133,30 @@ calculation = async :OS do
 
 end
 
-calculation.value += 1
+calculation += 1
+
+puts calculation
+
+```
+
 
-puts calculation.value
+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
+
+```ruby
+calculation = async :OS do
+  sleep 4
+  4 * 5
+end
+
+calculation.sync #> or synchronize
 ```
 
-there are other examples that you can check in the exampels folder
+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
+

data/VERSION

@@ -1 +1 @@
-2.1.0
+3.0.0-pre

data/asynchronous.gemspec

@@ -20,5 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "process_shared"
+  spec.add_development_dependency(%q<debugger>, [">= 0"])
+
 
 end

data/dump/shared_memory.rb

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

data/examples/array_of_value_with_native_threads.rb

@@ -1,31 +1,23 @@
 require_relative "../lib/asynchronous"
 
-async1= async :OS do
 
+async1= async :OS do
   1000000*5
-
 end
 
 async2= async :OS do
 
-  sleep 10
-
-  "sup" * 10000
-
+  var = ("sup" * 1000000)
+  puts "the superHuge String length in the pipe is: #{var.length}"
 
+  var
 end
 
 
 async3= async :OS do
-
   1000000*5.0
-
 end
 
-# please do remember that parsing an object into
-# Marshal String can take up time if you have big Strings like
-# "sup" * 100000000
+puts async1
 
-puts async1.value,
-     async2.value[0..5],
-     async3.value
+puts [ async3, async2[0..5], async1 ]

data/examples/async_patterns.rb

@@ -14,9 +14,9 @@ calculation = async :concurrency do
 end
 puts "hello concurrency"
 
-calculation.value += 1
+calculation += 1
 
-puts calculation.value
+puts calculation
 
 #>--------------------------------------------------
 # or you can use simple {} without sym and this will be by default a
@@ -26,10 +26,10 @@ calculation = async { sleep 3; 4 * 3 }
 
 puts "hello simple concurrency"
 
-calculation.value += 1
+calculation += 1
 
-# remember you have to use .value to cal the return value from the code block!
-puts calculation.value
+# remember you have to use  to cal the return value from the code block!
+puts calculation
 
 
 #>--------------------------------------------------
@@ -49,9 +49,9 @@ calculation = async :parallelism do
 end
 puts "hello parallelism"
 
-calculation.value += 1
+calculation += 1
 
-puts calculation.value
+puts calculation
 
 #>--------------------------------------------------
 
@@ -70,6 +70,6 @@ calc2 = async {
   [5+1,"sup!"]
 }
 
-puts calc1.value == calc2.value
-puts (calc1.value+calc2.value).inspect
+puts calc1 == calc2
+puts (calc1+calc2).inspect
 

data/examples/shared_memory2.rb

@@ -0,0 +1,29 @@
+require_relative "../lib/asynchronous"
+
+shared_memory.test_value  = Array.new
+shared_memory.ready_state = Hash.new
+times_value= 5
+
+times_value.times do
+
+  # remember! IO pipes cant be made too fast!
+  # this does not mean the Shared memory cant handle the speed
+
+  var= async :OS do
+
+    shared_memory.test_value.push $$
+    shared_memory.ready_state[$$]= true
+
+    nil
+  end
+  shared_memory.ready_state[var.asynchronous_get_pid] ||= false
+
+end
+
+
+while shared_memory.ready_state.values.include?(false)
+  sleep 0.5
+end
+
+puts shared_memory.test_value.inspect
+puts "#{times_value} OS thread should made this much shared memory update: #{times_value} / and it's #{shared_memory.test_value.count}"

data/lib/asynchronous.rb

@@ -2,6 +2,7 @@
 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")

data/lib/asynchronous/clean_class.rb

@@ -1,19 +1,14 @@
-class CleanClass < BasicObject
-
-  # remove methods from the class!
-  #def self.purge_methods
+module Asynchronous
+  class CleanClass < BasicObject
 
+    # remove methods from the class!
     (self.instance_methods-[
-        :undef_method,
         :object_id,
         :__send__,
-        :methods,
         :alias,
-        :new
     ]).each do |method|
       undef_method method
     end
 
-  #end
-
+  end
 end

data/lib/asynchronous/concurrency.rb

@@ -5,9 +5,9 @@ module Asynchronous
   # 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 < CleanClass
+  class Concurrency < Asynchronous::CleanClass
 
-    def initialize(callable)
+    def initialize callable
       begin
         @value= nil
         @try_count= 0
@@ -27,7 +27,7 @@ module Asynchronous
       end
     end
 
-    def value
+    def asynchronous_get_value
 
       if @value.nil?
         until @rescue_state.nil?
@@ -40,35 +40,39 @@ module Asynchronous
 
     end
 
-    def value=(obj)
+    def asynchronous_set_value(obj)
       @value= obj
     end
+    alias :asynchronous_set_value= :asynchronous_set_value
 
-    def inspect
-      if @thread.alive?
-        "#<Async running>"
-      else
-        value.inspect
-      end
+    def synchronize
+      asynchronous_get_value
     end
+    alias :sync :synchronize
 
     def method_missing(method, *args)
-      value.__send__(method, *args)
-    end
 
-    def respond_to_missing?(method, include_private = false)
-      value.respond_to?(method, include_private)
+      new_value= asynchronous_get_value
+
+      begin
+        original_value= new_value.dup
+      rescue ::TypeError
+        original_value= new_value
+      end
+
+      return_value= new_value.__send__(method,*args)
+      unless new_value == original_value
+        asynchronous_set_value new_value
+      end
+
+      return return_value
+
     end
 
-  end
+    #def respond_to_missing?(method, include_private = false)
+    #  value.respond_to?(method, include_private)
+    #end
 
-  # alias
-  begin
-    #alias :v        :value
-    #alias :get      :value
-    #alias :gets     :value
-    #alias :response :value
-    #alias :return   :value
   end
 
 end

data/lib/asynchronous/kernel.rb

@@ -12,7 +12,8 @@
 #
 module Kernel
 
-  def async(type= :Concurrency ,&block)
+  def async type= :VM ,&block
+
     case type.to_s.downcase[0]
       # Concurrency / VM / Green
       when "c","v","g"
@@ -30,6 +31,7 @@ module Kernel
         end
 
     end
+
   end
 
   def shared_memory

data/lib/asynchronous/parallelism.rb

@@ -7,127 +7,106 @@ module Asynchronous
   # 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 < CleanClass
+  class Parallelism < Asynchronous::CleanClass
 
-    # Basic class variables
-    begin
+    def asynchronous_fork callable
+      return ::Kernel.fork do
 
-      @@pids      ||= []
-      @@tmpdir    ||= nil
-      @@motherpid ||= $$
-      @@agent     ||= nil
-      @@zombie    ||= true
-      ::Kernel.require 'yaml'
-
-    end
-
-    # main def for logic
-    begin
-      def initialize callable
-
-        # defaults
         begin
-          @value= nil
-          @rd, @wr = ::IO.pipe
-        end
-
-        # create a process
-        begin
-          @pid= ::Kernel.fork do
-
-            # anti zombie
-            begin
-              ::Kernel.trap("TERM") do
-                ::Kernel.exit
-              end
-              ::Thread.new do
-                ::Kernel.loop do
-                  begin
-                    ::Kernel.sleep 1
-                    if alive?(@@motherpid) == false
-                      ::Kernel.exit!
-                    end
-                  end
+          ::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
 
-            # return the value
-            begin
-
-              #::Kernel.puts callable.class
-
-              return_value= callable.call
-
-              @rd.close
+        @comm_line[0].close
+        @comm_line[1].write ::Marshal.dump(callable.call)
+        @comm_line[1].flush
 
-              #@wr.write ::Marshal.dump(return_value)
-              @wr.write return_value.to_yaml
+        #::Kernel.loop do
+        #  #::Kernel.puts @comm_line[0].closed?
+        #  #::Kernel.puts @comm_line[1].closed?
+        #  ::Kernel.sleep 1
+        #end
 
-              @wr.close
 
-              ::Process.exit!
-            end
+      end
+    end
 
-          end
-          @@pids.push(@pid)
+    def asynchronous_read_buffer
+      @read_buffer = ::Thread.new do
+        while !@comm_line[0].eof?
+          @value = ::Marshal.load(@comm_line[0])
         end
-
       end
     end
 
-    # connection for in case of mother die
-    begin
 
-      def alive?(pid)
-        begin
-          ::Process.kill(0,pid)
-          return true
-          rescue ::Errno::ESRCH
-          return false
-        end
-      end
+    def initialize callable
 
-    end
+      @@pids      ||= []
+      @@motherpid ||= $$
 
-    # return value
-    begin
+      @comm_line   = ::IO.pipe
+      @value       = nil
+      @read_buffer = nil
 
-      def value
+      asynchronous_read_buffer
+      @pid= asynchronous_fork callable
+      @@pids.push(@pid)
 
-        if @value.nil?
+    end
 
-          #while alive?(@pid)
-          #  ::Kernel.puts alive? @pid
-          #  ::Kernel.sleep 1
-          #  #sleep 1
-          #end
+    def asynchronous_get_pid
+      return @pid
+    end
 
-          @wr.close
-          return_value= @rd.read
-          @rd.close
+    def self.asynchronous_alive?(pid)
+      begin
+        ::Process.kill(0,pid)
+        return true
+        rescue ::Errno::ESRCH
+        return false
+      end
+    end
 
-          #return_value= ::Marshal.load(return_value)
-          return_value= ::YAML.load(return_value)
+    def asynchronous_get_value
 
-          @@pids.delete(@pid)
-          @value= return_value
+      if @value.nil?
 
-        end
+        ::Process.wait(@pid, ::Process::WNOHANG )
 
-        return @value
+        @comm_line[1].close
+        @read_buffer.join
+        @comm_line[0].close
 
       end
 
-      def value=(obj)
-        @value= obj
-      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
+
     # kill kidos at Kernel Exit
-    begin
-      ::Kernel.at_exit {
+    ::Kernel.at_exit {
         @@pids.each { |pid|
           begin
             ::Process.kill(:TERM, pid)
@@ -136,16 +115,25 @@ module Asynchronous
           end
         }
       }
-    end
 
-    # alias
-    begin
-      alias :v        :value
-      #alias :get      :value
-      #alias :gets     :value
-      #alias :response :value
-      #alias :return   :value
+    def method_missing(method, *args)
+
+      return_value= nil
+      new_value= asynchronous_get_value
+      begin
+        original_value= new_value.dup
+      rescue ::TypeError
+        original_value= new_value
+      end
+      return_value= new_value.__send__(method,*args)
+      unless new_value == original_value
+          asynchronous_set_value new_value
+        end
+
+      return return_value
+
     end
 
+
   end
 end

data/lib/asynchronous/shared_memory.rb

@@ -1,15 +1,16 @@
-require 'process_shared'
-require_relative "clean_class"
 module Asynchronous
 
+  class << self
+    attr_accessor :global_mutex
+  end
+  self.global_mutex = false
 
-  module Allocation
-
-    class << self
-      attr_accessor :memory_allocation_size
-    end
+  class << self
+    attr_accessor :memory_allocation_size
+  end
+  self.memory_allocation_size= 16384
 
-    self.memory_allocation_size= 16384
+  module Global
 
     def self.mutex
       @@mutex
@@ -20,34 +21,112 @@ module Asynchronous
   end
 
 
-  class SharedMemory < CleanClass
+  class MemoryObj < Asynchronous::CleanClass
+
+    @data  = nil
+    @mutex = nil
+
+    def initialize(obj)
+
+      @data= ::ProcessShared::SharedMemory.new(
+      ::Asynchronous.memory_allocation_size)
+
+      @mutex= ::ProcessShared::Mutex.new
+
+      @data.write_object(obj)
+
+    end
+
+    def asynchronous_set_value obj
+      return @data.write_object obj
+    end
+
+    def asynchronous_set_value= obj
+      self.asynchronous_set_value(obj)
+    end
+
+    def asynchronous_get_value
+      return @data.read_object
+    end
+
+
+    def method_missing(method, *args, &block)
+
+      #::Kernel.puts "method: #{method}, #{args}, #{block}"
+
+      new_value= nil
+      original_value= nil
+      return_value= nil
+      mutex_obj= nil
+
+      if ::Asynchronous.global_mutex == true
+        mutex_obj= ::Asynchronous::Global.mutex
+      else
+        mutex_obj= @mutex
+      end
+
+      mutex_obj.synchronize do
+
+        new_value= asynchronous_get_value
+
+        begin
+          original_value= new_value.dup
+        rescue ::TypeError
+          original_value= new_value
+        end
+
+        return_value= new_value.__send__(method,*args,&block)
+        unless new_value == original_value
+          asynchronous_set_value new_value
+        end
+
+      end
+
+      return return_value
+
+    end
+
+  end
+
+  class SharedMemory < Asynchronous::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])
+        case true
+
+          when method.to_s.include?('=')
+
+            @@static_variables ||= ::Asynchronous::MemoryObj.new(Array.new.push(:static_variables))
+            if @@static_variables.include?(method.to_s.sub!('=','').to_sym)
+              $stdout.puts "Warning! static varieble cant be changed without removing from the Asynchronous.static_variables array collection (sym)"
+              return nil
+            else
+
+              begin
+                self.class_variable_get("@@#{method.to_s.sub('=','')}").asynchronous_set_value= args[0]
+              rescue ::NameError
+                self.class_variable_set(
+                    "@@#{method.to_s.sub('=','')}",
+                    ::Asynchronous::MemoryObj.new(args[0]))
+              end
+
             end
+
           else
             begin
-              self.class_variable_get("@@#{method.to_s}").read_object
+              self.class_variable_get("@@#{method.to_s}")
             rescue ::NameError
               return nil
             end
-          end
         end
 
       end
     end
   end
 
+  def self.static_variables
+    SharedMemory.static_variables
+  end
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asynchronous
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0.pre.pre
 platform: ruby
 authors:
 - Adam Luzsi
@@ -24,6 +24,20 @@ dependencies:
     - - ! '>='
       - !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
   and OS managed way (Concurrency and Parallelism) '
 email:
@@ -39,10 +53,12 @@ files:
 - VERSION
 - asynchronous.gemspec
 - dump/async.rb
+- dump/shared_memory.rb
 - examples/array_of_value_with_native_threads.rb
 - examples/async_patterns.rb
 - examples/no_zombie_test.rb
-- examples/shared_memory.rb
+- examples/shared_memory1.rb
+- examples/shared_memory2.rb
 - files.rb
 - lib/asynchronous.rb
 - lib/asynchronous/clean_class.rb
@@ -50,7 +66,6 @@ files:
 - lib/asynchronous/kernel.rb
 - lib/asynchronous/parallelism.rb
 - lib/asynchronous/shared_memory.rb
-- test/test.rb
 homepage: https://github.com/adamluzsi/asynchronous
 licenses: []
 metadata: {}
@@ -65,15 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       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
 signing_key: 
 specification_version: 4
 summary: Simple Async Based on standard CRuby
-test_files:
-- test/test.rb
+test_files: []
 has_rdoc: