asynchronous 3.0.1 → 4.0.0.pre

data/examples/array_of_value_with_native_threads.rb

@@ -1,23 +0,0 @@
-require_relative "../lib/asynchronous"
-
-
-async1= async :OS do
-  1000000*5
-end
-
-async2= async :OS do
-
-  var = ("sup" * 1000000)
-  puts "the superHuge String length in the pipe is: #{var.length}"
-
-  var
-end
-
-
-async3= async :OS do
-  1000000*5.0
-end
-
-puts async1
-
-puts [ async3, async2[0..5], async1 ]

data/examples/ruby_worker.rb

@@ -1,54 +0,0 @@
-require_relative "../lib/asynchronous"
-
-shared_memory.ruby_worker_jobs= Array.new
-shared_memory.static_variables.push :ruby_worker_jobs
-
-class Worker
-
-  def self.do_some_hard_work! *args
-
-    puts "heavy db load job here with params #{args.inspect}"
-    #some brutal DB work here
-
-  end
-
-  def self.add_job *array
-    shared_memory.ruby_worker_jobs.push array
-  end
-
-end
-
-
-async :OS do
-
-  loop do
-
-    unless shared_memory.ruby_worker_jobs.empty?
-
-      puts "job to do again..."
-      job= shared_memory.ruby_worker_jobs.pop
-
-      model_name  = job.shift
-      method_name = job.shift
-
-      model_name.__send__(method_name,*job)
-
-      puts "everything is done, so... nothing to do here... *sigh*"
-
-    else
-      sleep 0.1
-    end
-
-
-  end
-
-end
-
-
-
-loop do
-
-  sleep 6
-  Worker.add_job Worker,:do_some_hard_work!,{random: Random.srand}
-
-end

data/examples/shared_memory1.rb

@@ -1,19 +0,0 @@
-require_relative "../lib/asynchronous"
-
-SharedMemory.test_value= 0
-async :OS do
-
-  loop do
-    SharedMemory.test_value += 1
-    sleep 3
-  end
-
-end
-
-loop do
-  if shared_memory.test_value >= 10
-    Process.exit
-  end
-  puts SharedMemory.test_value
-  sleep 1
-end

data/examples/shared_memory2.rb

@@ -1,29 +0,0 @@
-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/clean_class.rb

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

data/lib/asynchronous/shared_memory.rb

@@ -1,214 +0,0 @@
-module Asynchronous
-
-  class << self
-    attr_accessor :global_mutex
-  end
-  self.global_mutex = false
-
-  class << self
-    attr_accessor :memory_allocation_size
-  end
-  self.memory_allocation_size= 16384
-
-  module Global
-
-    def self.mutex
-      @@mutex
-    end
-
-    @@mutex  = ProcessShared::Mutex.new
-
-  end
-
-
-  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
-    alias :asynchronous_set_value= :asynchronous_set_value
-
-    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)
-
-        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}")
-            rescue ::NameError
-              return nil
-            end
-        end
-
-      end
-    end
-  end
-
-  def self.static_variables
-    SharedMemory.static_variables
-  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
-