process_shared 0.0.4 → 0.1.0

data/lib/process_shared/posix/time_val.rb

@@ -0,0 +1,23 @@
+require 'ffi'
+
+require 'process_shared/posix/time_spec'
+
+module ProcessShared
+  module Posix
+    class TimeVal < FFI::Struct
+      US_PER_NS = 1000
+
+      layout(:tv_sec, :time_t,
+             :tv_usec, :suseconds_t)
+
+      def to_time_spec
+        ts = TimeSpec.new
+
+        ts[:tv_sec] = self[:tv_sec];
+        ts[:tv_nsec] = self[:tv_usec] * US_PER_NS
+
+        ts
+      end
+    end
+  end
+end

data/lib/process_shared/semaphore.rb

@@ -1,84 +1,37 @@
-require 'process_shared/psem'
-require 'process_shared/abstract_semaphore'
+require 'process_shared/with_self'
 
 module ProcessShared
-  class Semaphore < AbstractSemaphore
-    # With no associated block, open is a synonym for
-    # Semaphore.new. If the optional code block is given, it will be
-    # passed +sem+ as an argument, and the Semaphore object will
-    # automatically be closed when the block terminates. In this
-    # instance, Semaphore.open returns the value of the block.
-    #
-    # @param [Integer] value the initial semaphore value
-    # @param [String] name not currently supported
-    def self.open(value = 1, name = nil, &block)
-      new(value, name).with_self(&block)
-    end
+  module Semaphore
+    include ProcessShared::WithSelf
 
-    # Create a new semaphore with initial value +value+.  After
-    # Kernel#fork, the semaphore will be shared across two (or more)
-    # processes. The semaphore must be closed with #close in each
-    # process that no longer needs the semaphore.
-    #
-    # (An object finalizer is registered that will close the semaphore
-    # to avoid memory leaks, but this should be considered a last
-    # resort).
-    #
-    # @param [Integer] value the initial semaphore value
-    # @param [String] name not currently supported
-    def initialize(value = 1, name = nil)
-      init(PSem.sizeof_psem_t, 'psem', name) do |sem_name|
-        psem_open(sem, sem_name, value, err)
+    class << self
+      # the implementation to use to create semaphores.  impl is set
+      # based on the platform in 'process_shared'
+      attr_accessor :impl
+      
+      def new(*args)
+        impl.new(*args)
       end
-    end
 
-    # Decrement the value of the semaphore.  If the value is zero,
-    # wait until another process increments via {#post}.
-    def wait
-      psem_wait(sem, err)
-    end
-
-    # Decrement the value of the semaphore if it can be done
-    # immediately (i.e. if it was non-zero).  Otherwise, wait up to
-    # +timeout+ seconds until another process increments via {#post}.
-    #
-    # @param timeout [Numeric] the maximum seconds to wait, or nil to not wait
-    #
-    # @return If +timeout+ is nil and the semaphore cannot be
-    # decremented immediately, raise Errno::EAGAIN.  If +timeout+
-    # passed before the semaphore could be decremented, raise
-    # Errno::ETIMEDOUT.
-    def try_wait(timeout = nil)
-      if timeout
-        psem_timedwait(sem, timeout, err)
-      else
-        psem_trywait(sem, err)
+      # With no associated block, open is a synonym for
+      # Semaphore.new. If the optional code block is given, it will be
+      # passed +sem+ as an argument, and the Semaphore object will
+      # automatically be closed when the block terminates. In this
+      # instance, Semaphore.open returns the value of the block.
+      #
+      # @param [Integer] value the initial semaphore value
+      def open(value = 1, &block)
+        new(value).with_self(&block)
       end
     end
 
-    # Increment the value of the semaphore.  If other processes are
-    # waiting on this semaphore, one will be woken.
-    def post
-      psem_post(sem, err)
-    end
-
-    # Get the current value of the semaphore. Raises {Errno::NOTSUP} on
-    # platforms that don't support this (e.g. Mac OS X).
-    #
-    # @return [Integer] the current value of the semaphore.
-    def value
-      int = FFI::MemoryPointer.new(:int)
-      psem_getvalue(sem, int, err)
-      int.get_int(0)
-    end
-
-    # Release the resources associated with this semaphore.  Calls to
-    # other methods are undefined after {#close} has been called.
-    #
-    # Close must be called when the semaphore is no longer needed.  An
-    # object finalizer will close the semaphore as a last resort.
-    def close
-      psem_close(sem, err)
+    def synchronize
+      wait
+      begin
+        yield
+      ensure
+        post
+      end
     end
   end
 end

data/lib/process_shared/shared_array.rb

@@ -1,5 +1,7 @@
+require 'process_shared'
+
 module ProcessShared
-  class SharedArray < SharedMemory
+  class SharedArray < SharedMemory.impl
     include Enumerable
 
     # A fixed-size array in shared memory.  Processes forked from this

data/lib/process_shared/shared_memory.rb

@@ -1,58 +1,21 @@
-require 'process_shared/rt'
-require 'process_shared/libc'
 require 'process_shared/with_self'
 require 'process_shared/shared_memory_io'
 
 module ProcessShared
   # Memory block shared across processes.
-  class SharedMemory < FFI::Pointer
-    include WithSelf
+  module SharedMemory
+    include ProcessShared::WithSelf
 
-    attr_reader :size, :type, :type_size, :count, :fd
+    class << self
+      attr_accessor :impl
 
-    def self.open(size, &block)
-      new(size).with_self(&block)
-    end
-
-    def self.make_finalizer(addr, size, fd)
-      proc do
-        pointer = FFI::Pointer.new(addr)
-        LibC.munmap(pointer, size)
-        LibC.close(fd)
+      def new(*args)
+        impl.new(*args)
       end
-    end
-
-    def initialize(type_or_count = 1, count = 1)
-      @type, @count = case type_or_count
-                      when Symbol
-                        [type_or_count, count]
-                      else
-                        [:uchar, type_or_count]
-                      end
-
-      @type_size = FFI.type_size(@type)
-      @size = @type_size * @count
 
-      name = "/ps-shm#{rand(10000)}"
-      @fd = RT.shm_open(name,
-                        LibC::O_CREAT | LibC::O_RDWR | LibC::O_EXCL,
-                        0777)
-      RT.shm_unlink(name)
-      
-      LibC.ftruncate(@fd, @size)
-      @pointer = LibC.mmap(nil,
-                           @size,
-                           LibC::PROT_READ | LibC::PROT_WRITE,
-                           LibC::MAP_SHARED,
-                           @fd,
-                           0).
-        slice(0, size) # slice to get FFI::Pointer that knows its size
-                       # (and thus does bounds checking)
-
-      @finalize = self.class.make_finalizer(@pointer.address, @size, @fd)
-      ObjectSpace.define_finalizer(self, @finalize)
-
-      super(@pointer)
+      def open(size, &block)
+        new(size).with_self(&block)
+      end
     end
 
     # Write the serialization of +obj+ (using Marshal.dump) to this
@@ -99,12 +62,7 @@ module ProcessShared
       Marshal.load(to_shm_io)
     end
 
-    def close
-      ObjectSpace.undefine_finalizer(self)
-      @finalize.call
-    end
-
-    private
+    protected
 
     def to_shm_io
       SharedMemoryIO.new(self)

data/lib/process_shared/time_spec.rb

@@ -0,0 +1,22 @@
+module ProcessShared
+  module TimeSpec
+    NS_PER_S = 1e9
+    US_PER_NS = 1000
+    TV_NSEC_MAX = (NS_PER_S - 1)
+
+    # Assuming self responds to setting the value of [:tv_sec] and
+    # [:tv_nsec], add +secs+ to the time spec.
+    def add_seconds!(float_sec)
+      # add timeout in seconds to abs_timeout; careful with rounding
+      sec = float_sec.floor
+      nsec = ((float_sec - sec) * NS_PER_S).floor
+
+      self[:tv_sec] += sec
+      self[:tv_nsec] += nsec
+      while self[:tv_nsec] > TV_NSEC_MAX
+        self[:tv_sec] += 1
+        self[:tv_nsec] -= NS_PER_S
+      end
+    end
+  end
+end

data/spec/mach/port_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'mach/port'
+
+module Mach
+  describe Port do
+    it 'creates a port' do
+      port = Port.new
+      port.destroy
+    end
+
+    it 'raises exception with invalid args' do
+      p = proc { Port.new(:right => 1234) }
+      p.must_raise Error::FAILURE
+    end
+
+    it 'inserts rights' do
+      port = Port.new
+      port.insert_right(:make_send)
+    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!"
+

data/spec/mach/scratch2.rb

@@ -0,0 +1,78 @@
+require 'ffi'
+
+require 'mach'
+require 'mach/functions'
+
+include Mach
+include Mach::Functions
+
+def setup_recv_port
+  port = new_memory_pointer :mach_port_t
+  mach_port_allocate(mach_task_self, :receive, port)
+  p = port.get_uint(0)
+  mach_port_insert_right(mach_task_self, p, p, :make_send)
+  p
+end
+
+def send_port(remote_port, port)
+  puts "send_port: (in #{mach_task_self}) sending #{port} -> #{remote_port}"
+  msg = FFI::Struct.new(nil,
+                        :header, MsgHeader,
+                        :body, MsgBody,
+                        :task_port, MsgPortDescriptor)
+  msg[:header].tap do |h|
+    h[:remote_port] = remote_port
+    h[:local_port] = 0
+    h[:bits] = (MachMsgType[:copy_send] | (0 << 8)) | 0x80000000 # MACH_MSGH_BITS_COMPLEX
+    h[:size] = msg.size
+  end
+
+  msg[:body][:descriptor_count] = 1
+  
+  msg[:task_port].tap do |p|
+    p[:name] = port
+    p[:disposition] = MachMsgType[:copy_send]
+    p[:type] = 0 # MACH_MSG_PORT_DESCRIPTOR;
+  end
+
+  mach_msg_send(msg)
+end
+
+def recv_port(recv_port)
+  msg = FFI::Struct.new(nil,
+                        :header, MsgHeader,
+                        :body, MsgBody,
+                        :task_port, MsgPortDescriptor,
+                        :trailer, MsgTrailer)
+
+  mach_msg(msg, 2, 0, msg.size, recv_port, 0, 0)
+
+  msg.size.times do |i|
+    print "%02x " % msg.to_ptr.get_uint8(i)
+  end
+  puts
+
+  msg[:task_port][:name]
+end
+
+def sampling_fork
+  parent_recv_port = setup_recv_port
+  task_set_special_port(mach_task_self, :bootstrap, parent_recv_port)
+
+  fork do
+    parent_recv_port_p = new_memory_pointer :mach_port_t
+    task_get_special_port(mach_task_self, :bootstrap, parent_recv_port_p)
+    parent_recv_port = parent_recv_port_p.get_uint(0)
+    puts "child self:#{mach_task_self} parent_recv:#{parent_recv_port}"
+
+    child_recv_port = setup_recv_port
+    puts "child sending #{mach_task_self}"
+    send_port(parent_recv_port, mach_task_self)
+  end
+
+  task_set_special_port(mach_task_self, :bootstrap, Mach::Functions::bootstrap_port)
+  child_task = recv_port(parent_recv_port)
+  puts "parent received #{child_task}"
+end
+
+sampling_fork

data/spec/mach/semaphore_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'mach'
+
+module Mach
+  describe 'low level semaphore functions' do
+    include Functions
+
+    it 'raises exception with invalid args' do
+      p = proc { semaphore_create(mach_task_self, nil, 1234, 1) }
+      p.must_raise Error::INVALID_ARGUMENT
+    end
+  end
+
+  describe Semaphore do
+    it 'creates a semaphore' do
+      sem = Semaphore.new
+      sem.destroy
+    end
+
+    it 'raises exception with invalid args' do
+      p = proc { Semaphore.new(:sync_policy => :no_such) }
+      p.must_raise ArgumentError # Error::INVALID_ARGUMENT
+    end
+
+    it 'signals/waits in same task' do
+      sem = Semaphore.new(:value => 0)
+      sem.signal
+      sem.wait
+      sem.destroy
+    end
+
+    it 'coordinates access to shared resource between two tasks' do
+      sem = Semaphore.new(:value => 0)
+
+      port = Port.new
+      port.insert_right(:make_send)
+      Task.self.set_bootstrap_port(port)
+
+      child = fork do
+        parent_port = Task.self.get_bootstrap_port
+        Task.self.copy_send(parent_port)
+        # parent will copy send rights to sem into child task
+        sleep 0.5
+        sem.signal
+        Kernel.exit!
+      end
+
+      child_task_port = port.receive_right
+
+      start = Time.now.to_f
+      sem.insert_right(:copy_send, :ipc_space => child_task_port)
+      sem.wait
+      elapsed = Time.now.to_f - start
+
+      Process.wait child
+
+      elapsed.must be_gt(0.4)
+    end
+  end
+end