process_shared 0.1.7 → 0.1.8

data/lib/mach/functions.rb

@@ -72,8 +72,8 @@ module Mach
 
     # Attach a function as with +attach_function+, but check the
     # return value and raise an exception on errors.
-    def self.attach_mach_function(sym, argtypes, rettype)
-      attach_function(sym, argtypes, rettype)
+    def self.attach_mach_function(sym, argtypes, rettype, options = nil)
+      attach_function(sym, argtypes, rettype, options)
       error_check(sym)
     end
 
@@ -208,10 +208,12 @@ module Mach
                          :kern_return_t)
     attach_mach_function(:semaphore_wait,
                          [:semaphore_t],
-                         :kern_return_t)
+                         :kern_return_t,
+                         :blocking => true)
     attach_mach_function(:semaphore_timedwait,
                          [:semaphore_t, TimeSpec.val],
-                         :kern_return_t)
+                         :kern_return_t,
+                         :blocking => true)
 
   end
 end

data/lib/process_shared/posix/semaphore.rb

@@ -26,9 +26,12 @@ module ProcessShared
 
         attach_function :sem_getvalue, [:sem_p, :pointer], :int
         attach_function :sem_post, [:sem_p], :int
-        attach_function :sem_wait, [:sem_p], :int
-        attach_function :sem_trywait, [:sem_p], :int
-        attach_function :sem_timedwait, [:sem_p, TimeSpec], :int
+        attach_function :sem_wait, [:sem_p], :int, :blocking => true
+        attach_function :sem_trywait, [:sem_p], :int, :blocking => true
+
+        # Workaround bug which only appears to affect Ruby 1.8.7 and REE
+        BLOCKING_SEM_TIMEDWAIT = (RUBY_VERSION != '1.8.7')
+        attach_function :sem_timedwait, [:sem_p, TimeSpec], :int, :blocking => BLOCKING_SEM_TIMEDWAIT
 
         error_check(:sem_close, :sem_unlink, :sem_init, :sem_destroy,
                     :sem_getvalue, :sem_post, :sem_wait, :sem_trywait,

data/lib/process_shared/posix/shared_array.rb

@@ -0,0 +1,71 @@
+module ProcessShared
+  module Posix
+    class SharedArray < SharedMemory
+      include Enumerable
+
+      # A fixed-size array in shared memory.  Processes forked from this
+      # one will be able to read and write shared data to the array.
+      # Access should be synchronized using a {Mutex}, {Semaphore}, or
+      # other means.
+      #
+      # Note that {Enumerable} methods such as {#map}, {#sort},
+      # etc. return new {Array} objects rather than modifying the shared
+      # array.
+      #
+      # @param [Symbol] type_or_count the data type as a symbol
+      # understood by FFI (e.g. :int, :double)
+      #
+      # @param [Integer] count number of array elements
+      def initialize(type_or_count = 1, count = 1)
+        super(type_or_count, count)
+
+        # See https://github.com/ffi/ffi/issues/118
+        ffi_type = FFI.find_type(self.type)
+
+        name = if ffi_type.inspect =~ /FFI::Type::Builtin:(\w+)*/
+                 # name will be something like int32
+                 $1.downcase
+               end
+
+        unless name
+          raise ArgumentError, "could not find FFI::Type for #{self.type}"
+        end
+        
+        getter = "get_#{name}"
+        setter = "put_#{name}"
+
+        # singleton class
+        sclass = class << self; self; end
+
+        unless sclass.method_defined?(getter)
+          raise ArgumentError, "no element getter for #{self.type} (#{getter})"
+        end
+
+        unless sclass.method_defined?(setter)
+          raise ArgumentError, "no element setter for #{self.type} (#{setter})"
+        end
+
+        sclass.send(:alias_method, :get_type, getter)
+        sclass.send(:alias_method, :put_type, setter)
+      end
+
+      def each
+        # NOTE: using @count because Enumerable defines its own count
+        # method...
+        @count.times { |i| yield self[i] }
+      end
+
+      def each_with_index
+        @count.times { |i| yield self[i], i }
+      end
+
+      def [](i)
+        get_type(i * self.type_size)
+      end
+
+      def []=(i, val)
+        put_type(i * self.type_size, val)
+      end
+    end
+  end
+end

data/lib/process_shared/thread.rb

@@ -0,0 +1,30 @@
+module ProcessShared
+  # API-compatible with Ruby Thread class but using ProcessShared
+  # primitives instead (i.e. each Thread will be a separate OS
+  # process).
+  class Process
+    class << self
+      # How the heck will I implement this...
+      def abort_on_exception
+      end
+
+      def abort_on_exception=(val)
+      end
+
+      # This can't really work since each thread is a separate process..
+      def current
+      end
+
+      def kill(process)
+        ::Process.kill(process.pid)
+      end
+    end
+
+    def join(limit = nil)
+      if limit
+      else
+        ::Process.wait(pid)
+      end
+    end
+  end
+end

data/lib/scratch.rb

@@ -0,0 +1,300 @@
+require 'ffi'
+
+module LibC
+  extend FFI::Library
+
+  ffi_lib FFI::Library::LIBC
+
+  attach_variable :errno, :int
+
+  attach_function :mmap, [:pointer, :size_t, :int, :int, :int, :off_t], :pointer
+  attach_function :munmap, [:pointer, :size_t], :int
+
+  attach_function :ftruncate, [:int, :off_t], :int
+
+  class << self
+    def call(err_msg = 'error in system call', &block)
+      ret = yield
+      err = LibC.errno
+
+      if ret.kind_of?(Fixnum) and ret < 0
+        raise SystemCallError.new(err_msg, err)
+      end
+      
+      ret
+    end
+  end
+end
+
+module RT
+  extend FFI::Library
+
+  ffi_lib 'rt'
+
+  attach_function :shm_open, [:string, :int, :mode_t], :int
+  attach_function :shm_unlink, [:string], :int
+end
+
+module PSem
+  extend FFI::Library
+
+  lib = File.join(File.expand_path(File.dirname(__FILE__)),
+                  'process_shared/libpsem.' + FFI::Platform::LIBSUFFIX)
+  ffi_lib lib
+
+  attach_function :psem_alloc, [], :pointer
+  attach_function :psem_free, [:pointer], :void
+
+  attach_function :psem_open, [:pointer, :string, :uint, :uint], :int
+  attach_function :psem_close, [:pointer], :int
+  attach_function :psem_unlink, [:string], :int
+  attach_function :psem_post, [:pointer], :int
+  attach_function :psem_wait, [:pointer], :int
+  attach_function :psem_trywait, [:pointer], :int
+  attach_function :psem_timedwait, [:pointer, :pointer], :int
+  attach_function :psem_getvalue, [:pointer, :pointer], :int
+
+  attach_function :bsem_alloc, [], :pointer
+  attach_function :bsem_free, [:pointer], :void
+
+  attach_function :bsem_open, [:pointer, :string, :uint, :uint], :int
+  attach_function :bsem_close, [:pointer], :int
+  attach_function :bsem_unlink, [:string], :int
+  attach_function :bsem_post, [:pointer], :int
+  attach_function :bsem_wait, [:pointer], :int
+  attach_function :bsem_trywait, [:pointer], :int
+  attach_function :bsem_timedwait, [:pointer, :pointer], :int
+  attach_function :bsem_getvalue, [:pointer, :pointer], :int
+
+  class << self
+    include PSem
+
+    def test
+      bsem = bsem_alloc()
+
+      class << bsem
+        def value
+          @int ||= FFI::MemoryPointer.new(:int)
+          LibC.call { PSem.bsem_getvalue(self, @int) }
+          @int.get_int(0)
+        end
+      end
+
+      puts "alloc'ed at #{bsem.inspect}"
+      puts LibC.call { bsem_open(bsem, "foobar", 1, 1) }
+      puts "opened at #{bsem.inspect}"
+      puts LibC.call { bsem_unlink("foobar") }
+      puts "unlinked"
+
+      puts "waiting for sem..."
+      puts "value is #{bsem.value}"
+      LibC.call { bsem_wait(bsem) }
+      puts "acquired!"
+      puts "value is #{bsem.value}"
+      LibC.call { bsem_post(bsem) }
+      puts "posted!"
+      puts "value is #{bsem.value}"
+
+      puts LibC.call { bsem_close(bsem) }
+      bsem_free(bsem)
+    end
+  end
+end
+
+module PThread
+  extend FFI::Library
+
+  ffi_lib '/lib/x86_64-linux-gnu/libpthread-2.13.so' # 'pthread'
+
+  attach_function :pthread_mutex_init, [:pointer, :pointer], :int
+  attach_function :pthread_mutex_lock, [:pointer], :int
+  attach_function :pthread_mutex_trylock, [:pointer], :int
+  attach_function :pthread_mutex_unlock, [:pointer], :int
+  attach_function :pthread_mutex_destroy, [:pointer], :int
+
+  attach_function :pthread_mutexattr_init, [:pointer], :int
+  attach_function :pthread_mutexattr_settype, [:pointer, :int], :int
+  attach_function :pthread_mutexattr_gettype, [:pointer, :pointer], :int
+
+  attach_function :pthread_mutexattr_setpshared, [:pointer, :int], :int
+
+  class << self
+    def call(err_msg = 'error in pthreads', &block)
+      ret = yield
+      raise SystemCallError.new(err_msg, ret) unless ret == 0
+    end
+  end
+
+  module Helper
+    extend FFI::Library
+
+    # FIXME: this might not alwasy be ".so"
+    lib = File.join(File.expand_path(File.dirname(__FILE__)), 'pthread_sync_helper.so')
+    ffi_lib lib
+
+    attach_variable :sizeof_pthread_mutex_t, :size_t
+    attach_variable :sizeof_pthread_mutexattr_t, :size_t
+
+    attach_variable :o_rdwr, :int
+    attach_variable :o_creat, :int
+
+    [:pthread_process_shared,
+
+     :o_rdwr,
+     :o_creat,
+
+     :prot_read,
+     :prot_write,
+     :prot_exec,
+     :prot_none,
+
+     :map_shared,
+     :map_private].each do |sym|
+      attach_variable sym, :int
+    end
+
+    attach_variable :map_failed, :pointer
+
+    PTHREAD_PROCESS_SHARED = pthread_process_shared
+
+    O_RDWR = o_rdwr
+    O_CREAT = o_creat
+
+    PROT_READ = prot_read
+    PROT_WRITE = prot_write
+    PROT_EXEC = prot_exec
+    PROT_NONE = prot_none
+
+    MAP_FAILED = map_failed
+    MAP_SHARED = map_shared
+    MAP_PRIVATE = map_private
+  end
+
+  class Mutex
+    include PThread
+    include PThread::Helper
+
+    class << self
+      def alloc
+        FFI::MemoryPointer.new(Helper.sizeof_pthread_mutex_t)
+      end
+    end
+
+    def initialize(mutex = Mutex.alloc, attr = nil)
+      @mutex = mutex
+      PThread.call { pthread_mutex_init(@mutex, attr) }
+    end
+
+    def destroy
+      PThread.call { pthread_mutex_destroy(@mutex) }
+    end
+
+    def lock
+      PThread.call { pthread_mutex_lock(@mutex) }
+    end
+
+    def try_lock
+      PThread.call { pthread_mutex_trylock(@mutex) }
+    end
+
+    def unlock
+      PThread.call { pthread_mutex_unlock(@mutex) }
+    end
+  end
+
+  class MutexAttr
+    include PThread
+    include PThread::Helper
+
+    class << self
+      def alloc
+        FFI::MemoryPointer.new(Helper.sizeof_pthread_mutexattr_t)
+      end
+    end
+
+    def initialize(ptr = MutexAttr.alloc)
+      puts "have #{ptr}"
+      @ptr = ptr
+      PThread.call { pthread_mutexattr_init(@ptr) }
+      self.type = type if type
+    end
+
+    def pointer
+      @ptr
+    end
+
+    def pshared=(val)
+      PThread.call { pthread_mutexattr_setpshared(@ptr, val) }
+    end
+
+    def type=(type)
+      PThread.call { pthread_mutexattr_settype(@ptr, type) }
+    end
+
+    def type
+      t = FFI::MemoryPointer.new(:int)
+      PThread.call { pthread_mutexattr_gettype(@ptr, t) }
+      t.get_int(0)
+    end
+  end
+
+  class Int < FFI::Struct
+      layout :val => :int
+  end
+
+  class << self
+    include Helper
+
+    def test
+      puts "hi #{Helper.sizeof_pthread_mutex_t}"
+      puts Mutex.new
+
+
+      fd = LibC.call { RT.shm_open("/foo", O_CREAT | O_RDWR, 0777) }
+      LibC.call { LibC.ftruncate(fd, 100) }
+      pointer = LibC.mmap(nil, 100, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
+      puts pointer
+      puts pointer == MAP_FAILED
+      puts MAP_FAILED
+
+      attr = MutexAttr.new
+      attr.pshared = PTHREAD_PROCESS_SHARED
+
+      mutex = Mutex.new(pointer, attr.pointer)
+
+
+      fd = LibC.call { RT.shm_open("/someint", O_CREAT | O_RDWR, 0777) }
+      LibC.call { LibC.ftruncate(fd, 100) }
+      pointer = LibC.mmap(nil, 100, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
+      abort "failed" if pointer == MAP_FAILED
+
+      value = Int.new(pointer)
+      value[:val] = 0
+      puts "int[0]: #{value[:val]}"
+
+      puts "parent has mutex #{mutex}"
+
+      n = 10000
+
+      child = fork do
+        puts "child and I have mutex: #{mutex}"
+
+        n.times do |i|
+          mutex.lock
+          value[:val] = (value[:val] + 1)
+          mutex.unlock
+        end
+      end
+
+      n.times do |i|
+        mutex.lock
+        value[:val] = (value[:val] + 1)
+        mutex.unlock
+      end
+
+      Process.wait(child)
+
+      puts "value is now #{value[:val]}"
+    end
+  end
+end

data/spec/mach/scratch.rb

@@ -0,0 +1,67 @@
+require 'mach'
+require 'mach/functions'
+
+include Mach
+include Mach::Functions
+
+sem = Semaphore.new(:value => 0)
+
+# puts ">parent has sem #{sem.port}"
+
+# fork do
+#   sleep 2                         # make parent wait a bit
+#   puts "in child..."
+#   sem = Mach::Semaphore.new(:port => Mach::Task.self.get_bootstrap_port)
+#   puts "child signaling sem #{sem.port}"
+#   sem.signal
+# end
+
+# puts ">parent waiting on sem..."
+# sem.wait
+# puts ">parent done waiting!"
+
+def struct(*layout)
+  yield FFI::Struct.new(nil, *layout)
+end
+
+puts "sizeof MsgPortDescriptor: #{MsgPortDescriptor.size}"
+port = Port.new
+port.insert_right(:make_send)
+
+Task.self.set_bootstrap_port(port)
+puts "> self:#{mach_task_self} bootstrap:#{port.port} (#{Mach::Functions::bootstrap_port.to_i})"
+
+child = fork do
+  parent_port = Task.self.get_bootstrap_port
+  puts "in child... self:#{mach_task_self} bootstrap:#{parent_port.port}"
+
+  #port = Port.new
+  #port.copy_send(parent_port)
+
+  #sem = port.receive_right
+
+  Task.self.copy_send(parent_port)
+  puts "child sleeping"
+  sleep 2
+  puts "child signaling semaphore"
+  sem.signal
+  puts "child out"
+  sleep 2
+end
+
+sleep 0.1
+if Process.wait(child, Process::WNOHANG)
+  puts "child died!"
+  #exit 1
+end
+
+Task.self.set_bootstrap_port(Mach::Functions::bootstrap_port)
+child_task_port = port.receive_right
+puts "parent: child task port is #{child_task_port}"
+
+sem.insert_right(:copy_send, :ipc_space => child_task_port)
+
+puts "parent waiting"
+sem.wait
+puts "parent done waiting!"
+