process_shared 0.1.0 → 0.1.2

data/lib/mach.rb

@@ -1,12 +1,109 @@
-require 'mach/port'
-require 'mach/semaphore'
-require 'mach/task'
-require 'mach/functions'
+require 'ffi'
+
+require 'mach/types'
 
 module Mach
+  extend Mach::Types
+
+  class MsgHeader < FFI::Struct
+    layout(:bits, :mach_msg_bits_t,
+           :size, :mach_msg_size_t,
+           :remote_port, :mach_port_t,
+           :local_port, :mach_port_t,
+           :reserved, :mach_msg_size_t,
+           :id, :mach_msg_id_t)
+  end
+
+  class MsgBody < FFI::Struct
+    layout(:descriptor_count, :mach_msg_size_t)
+  end
+
+  class MsgBase < FFI::Struct
+    layout(:header, MsgHeader,
+           :body, MsgBody)
+  end
+
+  class MsgTrailer < FFI::Struct
+    layout(:type, :mach_msg_trailer_type_t,
+           :size, :mach_msg_trailer_size_t)
+  end
+
+  class MsgPortDescriptor < FFI::Struct
+    layout(:name, :mach_port_t,
+           :pad1, :mach_msg_size_t, # FIXME: leave oout on __LP64__
+           :pad2, :uint16, # :uint
+           :disposition, :uint8, # :mach_msg_type_name_t
+           :type, :uint8) # :mach_msg_descriptor_type_t
+  end
+
+  SyncPolicy = enum( :fifo, 0x0,
+                     :fixed_priority, 0x1,
+                     :reversed, 0x2,
+                     :order_mask, 0x3,
+                     :lifo, 0x0 | 0x2, # um...
+                     :max, 0x7 )
+
+  PortRight = enum( :send, 0,
+                    :receive,
+                    :send_once,
+                    :port_set,
+                    :dead_name,
+                    :labelh,
+                    :number )
+
+  # port type macro
+  def self.pt(*syms)
+    acc = 0
+    syms.each do |sym|
+      acc |= (1 << (PortRight[sym] + 16))
+    end
+    acc
+  end
+
+  PORT_NULL = 0
+  MSG_TIMEOUT_NONE = 0
+  
+  PortType =
+    enum(:none, 0,
+         :send, pt(:send),
+         :receive, pt(:receive),
+         :send_once, pt(:send_once),
+         :port_set, pt(:port_set),
+         :dead_name, pt(:dead_name),
+         :labelh, pt(:labelh),
+         
+         :send_receive, pt(:send, :receive),
+         :send_rights, pt(:send, :send_once),
+         :port_rights, pt(:send, :send_once, :receive),
+         :port_or_dead, pt(:send, :send_once, :receive, :dead_name),
+         :all_rights, pt(:send, :send_once, :receive, :dead_name, :port_set))
+
+  MsgType =
+    enum( :move_receive, 16, # must hold receive rights
+          :move_send,        # must hold send rights
+          :move_send_once,   # must hold sendonce rights
+          :copy_send,        # must hold send rights
+          :make_send,        # must hold receive rights
+          :make_send_once,   # must hold receive rights
+          :copy_receive )    # must hold receive rights
+
+  SpecialPort =
+    enum( :kernel, 1,
+          :host,
+          :name,
+          :bootstrap )
+
+  KERN_SUCCESS = 0
+
+
   # @return [Port] the original bootstrap port; different from that
   # affected by {get,set}_special_port
   def self.bootstrap_port
     @bootstrap_port ||= Mach::Port.new(:port => Mach::Functions::bootstrap_port)
   end
 end
+
+require 'mach/port'
+require 'mach/semaphore'
+require 'mach/task'
+require 'mach/functions'

data/lib/mach/functions.rb

@@ -1,5 +1,6 @@
 require 'ffi'
 
+require 'mach/types'
 require 'mach/time_spec'
 
 module Mach
@@ -7,134 +8,10 @@ module Mach
   # specific).
   module Functions
     extend FFI::Library
+    extend Types
 
     ffi_lib 'c'
 
-    typedef :__darwin_mach_port_t, :mach_port_t
-    typedef :__darwin_natural_t, :natural_t
-
-    typedef :int, :integer_t
-    typedef :int, :kern_return_t # true for 64 bit??
-    typedef :int, :mach_error_t
-    typedef :int, :sync_policy_t # SyncPolicy
-    typedef :int, :clock_id_t
-    typedef :int, :clock_res_t
-
-    typedef :string, :name_t
-
-    typedef :mach_port_t, :host_t
-    typedef :mach_port_t, :task_t
-    typedef :mach_port_t, :ipc_space_t
-    typedef :mach_port_t, :semaphore_t
-    typedef :pointer, :mach_port_pointer_t
-
-    typedef :natural_t, :mach_port_name_t
-    typedef :natural_t, :mach_port_right_t # MachPortRight
-    typedef :pointer, :mach_port_name_array_t
-    typedef :pointer, :mach_port_name_pointer_t
-
-    typedef :uint, :mach_msg_type_name_t
-    typedef :uint, :mach_msg_bits_t
-    typedef :uint, :mach_msg_trailer_type_t
-    typedef :uint, :mach_msg_trailer_size_t
-    typedef :uint, :mach_msg_descriptor_type_t
-    typedef :natural_t, :mach_msg_timeout_t
-
-    typedef :natural_t, :mach_msg_size_t
-    typedef :integer_t, :mach_msg_id_t
-    typedef :integer_t, :mach_msg_options_t
-    typedef :integer_t, :mach_msg_option_t
-
-    class MsgHeader < FFI::Struct
-      layout(:bits, :mach_msg_bits_t,
-             :size, :mach_msg_size_t,
-             :remote_port, :mach_port_t,
-             :local_port, :mach_port_t,
-             :reserved, :mach_msg_size_t,
-             :id, :mach_msg_id_t)
-    end
-
-    class MsgBody < FFI::Struct
-      layout(:descriptor_count, :mach_msg_size_t)
-    end
-
-    class MsgBase < FFI::Struct
-      layout(:header, MsgHeader,
-             :body, MsgBody)
-    end
-
-    class MsgTrailer < FFI::Struct
-      layout(:type, :mach_msg_trailer_type_t,
-             :size, :mach_msg_trailer_size_t)
-    end
-
-    class MsgPortDescriptor < FFI::Struct
-      layout(:name, :mach_port_t,
-             :pad1, :mach_msg_size_t, # FIXME: leave oout on __LP64__
-             :pad2, :uint16, # :uint
-             :disposition, :uint8, # :mach_msg_type_name_t
-             :type, :uint8) # :mach_msg_descriptor_type_t
-    end
-
-    SyncPolicy = enum( :fifo, 0x0,
-                       :fixed_priority, 0x1,
-                       :reversed, 0x2,
-                       :order_mask, 0x3,
-                       :lifo, 0x0 | 0x2, # um...
-                       :max, 0x7 )
-
-    MachPortRight = enum( :send, 0,
-                          :receive,
-                          :send_once,
-                          :port_set,
-                          :dead_name,
-                          :labelh,
-                          :number )
-
-    # port type
-    def self.pt(*syms)
-      acc = 0
-      syms.each do |sym|
-        acc |= (1 << (MachPortRight[sym] + 16))
-      end
-      acc
-    end
-
-    MACH_PORT_NULL = 0
-    MACH_MSG_TIMEOUT_NONE = 0
-    
-    MachPortType =
-      enum(:none, 0,
-           :send, pt(:send),
-           :receive, pt(:receive),
-           :send_once, pt(:send_once),
-           :port_set, pt(:port_set),
-           :dead_name, pt(:dead_name),
-           :labelh, pt(:labelh),
-           
-           :send_receive, pt(:send, :receive),
-           :send_rights, pt(:send, :send_once),
-           :port_rights, pt(:send, :send_once, :receive),
-           :port_or_dead, pt(:send, :send_once, :receive, :dead_name),
-           :all_rights, pt(:send, :send_once, :receive, :dead_name, :port_set))
-
-    MachMsgType =
-      enum( :move_receive, 16, # must hold receive rights
-            :move_send,        # must hold send rights
-            :move_send_once,   # must hold sendonce rights
-            :copy_send,        # must hold send rights
-            :make_send,        # must hold receive rights
-            :make_send_once,   # must hold receive rights
-            :copy_receive )    # must hold receive rights
-
-    MachSpecialPort =
-      enum( :kernel, 1,
-            :host,
-            :name,
-            :bootstrap )
-
-    KERN_SUCCESS = 0
-
     # Replace methods in +syms+ with error checking wrappers that
     # invoke the original method and raise a {SystemCallError}.
     #
@@ -232,7 +109,7 @@ module Mach
 
     attach_mach_function(:mach_port_allocate,
                          [:ipc_space_t,
-                          MachPortRight,
+                          PortRight,
                           :mach_port_name_pointer_t],
                          :kern_return_t)
     
@@ -250,7 +127,7 @@ module Mach
                          [:ipc_space_t,
                           :mach_port_name_t,
                           :mach_port_t,
-                          MachMsgType],
+                          MsgType],
                          :kern_return_t)
 
     ##################
@@ -271,13 +148,13 @@ module Mach
 
     attach_mach_function(:task_get_special_port,
                          [:task_t,
-                          MachSpecialPort,
+                          SpecialPort,
                           :mach_port_pointer_t],
                          :kern_return_t)
 
     attach_mach_function(:task_set_special_port,
                          [:task_t,
-                          MachSpecialPort,
+                          SpecialPort,
                           :mach_port_t],
                          :kern_return_t)
 

data/lib/mach/port.rb

@@ -76,7 +76,7 @@ module Mach
     # Insert +right+ into another ipc space.  The current task must
     # have sufficient rights to insert the requested right.
     #
-    # @param [MachMsgType] right
+    # @param [MsgType] right
     #
     # @param [Hash] opts
     #
@@ -100,9 +100,9 @@ module Mach
 
       msg[:header].tap do |h|
         h[:remote_port] = remote_port.to_i
-        h[:local_port] = MACH_PORT_NULL
+        h[:local_port] = PORT_NULL
         h[:bits] =
-          (MachMsgType[right] | (0 << 8)) | 0x80000000 # MACH_MSGH_BITS_COMPLEX
+          (MsgType[right] | (0 << 8)) | 0x80000000 # MACH_MSGH_BITS_COMPLEX
         h[:size] = 40 # msg.size
       end
 
@@ -110,8 +110,8 @@ module Mach
 
       msg[:port].tap do |p|
         p[:name] = port
-        p[:disposition] = MachMsgType[right]
-        p[:type] = 0 # MACH_MSG_PORT_DESCRIPTOR;
+        p[:disposition] = MsgType[right]
+        p[:type] = 0 # MSG_PORT_DESCRIPTOR;
       end
       
       mach_msg_send msg
@@ -130,12 +130,12 @@ module Mach
       msg = ReceiveRightMsg.new
   
       mach_msg(msg,
-               2, # MACH_RCV_MSG,
+               2, # RCV_MSG,
                0,
                msg.size,
                port,
-               MACH_MSG_TIMEOUT_NONE,
-               MACH_PORT_NULL)
+               MSG_TIMEOUT_NONE,
+               PORT_NULL)
 
       self.class.new :port => msg[:port][:name]
     end

data/lib/mach/types.rb

@@ -0,0 +1,54 @@
+require 'ffi'
+
+module Mach
+  module Types
+    extend FFI::Library
+
+    typedef :__darwin_mach_port_t, :mach_port_t
+    typedef :__darwin_natural_t, :natural_t
+
+    typedef :int, :integer_t
+    typedef :int, :kern_return_t # true for 64 bit??
+    typedef :int, :mach_error_t
+    typedef :int, :sync_policy_t # SyncPolicy
+    typedef :int, :clock_id_t
+    typedef :int, :clock_res_t
+
+    typedef :string, :name_t
+
+    typedef :mach_port_t, :host_t
+    typedef :mach_port_t, :task_t
+    typedef :mach_port_t, :ipc_space_t
+    typedef :mach_port_t, :semaphore_t
+    typedef :pointer, :mach_port_pointer_t
+
+    typedef :natural_t, :mach_port_name_t
+    typedef :natural_t, :mach_port_right_t # MachPortRight
+    typedef :pointer, :mach_port_name_array_t
+    typedef :pointer, :mach_port_name_pointer_t
+
+    typedef :uint, :mach_msg_type_name_t
+    typedef :uint, :mach_msg_bits_t
+    typedef :uint, :mach_msg_trailer_type_t
+    typedef :uint, :mach_msg_trailer_size_t
+    typedef :uint, :mach_msg_descriptor_type_t
+    typedef :natural_t, :mach_msg_timeout_t
+
+    typedef :natural_t, :mach_msg_size_t
+    typedef :integer_t, :mach_msg_id_t
+    typedef :integer_t, :mach_msg_options_t
+    typedef :integer_t, :mach_msg_option_t
+
+    def self.typedefs
+      @ffi_typedefs
+    end
+
+    def find_type(t)
+      Mach::Types.find_type(t) || super
+    end
+
+    def enum(*args)
+      Mach::Types.enum(*args)
+    end
+  end
+end

data/lib/process_shared.rb

@@ -3,39 +3,29 @@ require 'ffi'
 if RUBY_VERSION =~ /^1.8/
   require 'process_shared/define_singleton_method'
   
-  module ProcessShared
-    module PSem
-      extend DefineSingletonMethod
-    end
-
-    module RT
-      extend DefineSingletonMethod
-    end
-
-    module LibC
-      extend DefineSingletonMethod
-    end
+  class Module
+    include ProcessShared::DefineSingletonMethod
   end
 end
 
-require 'process_shared/semaphore'
-require 'process_shared/binary_semaphore'
-require 'process_shared/mutex'
-require 'process_shared/shared_memory'
-
 module ProcessShared
   case FFI::Platform::OS
   when 'linux'
     require 'process_shared/posix/shared_memory'
     require 'process_shared/posix/semaphore'
 
-    SharedMemory.impl = Posix::SharedMemory
-    Semaphore.impl = Posix::Semaphore
+    SharedMemory = Posix::SharedMemory
+    Semaphore = Posix::Semaphore
   when 'darwin'
     require 'process_shared/posix/shared_memory'
     require 'process_shared/mach/semaphore'
 
-    SharedMemory.impl = Posix::SharedMemory
-    Semaphore.impl = Mach::Semaphore
+    SharedMemory = Posix::SharedMemory
+    Semaphore = Mach::Semaphore
   end
 end
+
+require 'process_shared/binary_semaphore'
+require 'process_shared/mutex'
+require 'process_shared/condition_variable'
+

data/lib/process_shared/binary_semaphore.rb

@@ -1,8 +1,7 @@
 require 'forwardable'
 
 require 'process_shared'
-require 'process_shared/with_self'
-require 'process_shared/semaphore'
+require 'process_shared/open_with_self'
 require 'process_shared/process_error'
 
 module ProcessShared
@@ -14,14 +13,10 @@ module ProcessShared
   # This is identical to a Semaphore but with extra error checking.
   class BinarySemaphore
     extend Forwardable
-    include ProcessShared::WithSelf
+    extend ProcessShared::OpenWithSelf
 
     def_delegators :@sem, :wait, :try_wait, :synchronize, :value, :close
 
-    def self.open(value = 1, &block)
-      new(value).with_self(&block)
-    end
-
     # 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

data/lib/process_shared/condition_variable.rb

@@ -1,4 +1,4 @@
-require 'process_shared/semaphore'
+require 'process_shared'
 
 module ProcessShared
   class ConditionVariable

data/lib/process_shared/mach.rb

@@ -46,6 +46,10 @@ end
 
 module Kernel
   # Override to call Process::fork.
+  def self.fork(*args, &block)
+    Process.fork(*args, &block)
+  end
+
   def fork(*args, &block)
     Process.fork(*args, &block)
   end

data/lib/process_shared/mach/semaphore.rb

@@ -2,12 +2,15 @@ require 'mach'
 require 'mach/error'
 
 require 'process_shared/mach'
+require 'process_shared/open_with_self'
+require 'process_shared/synchronizable_semaphore'
 
 module ProcessShared
   module Mach
     # Extends ::Mach::Semaphore to be compatible with ProcessShared::Semaphore
     class Semaphore < ::Mach::Semaphore
-      include ProcessShared::Semaphore
+      extend ProcessShared::OpenWithSelf
+      include ProcessShared::SynchronizableSemaphore
 
       def initialize(value = 1)
         super(:value => value)

data/lib/process_shared/mutex.rb

@@ -1,6 +1,5 @@
-require 'process_shared/semaphore'
-require 'process_shared/with_self'
-require 'process_shared/shared_memory'
+require 'process_shared'
+require 'process_shared/open_with_self'
 require 'process_shared/process_error'
 
 module ProcessShared
@@ -20,11 +19,7 @@ module ProcessShared
   # release its {Semaphore} and {SharedMemory} resources.  For now,
   # rely on the object finalizers of those objects...
   class Mutex
-    # include WithSelf
-
-    # def self.open(&block)
-    #   new.with_self(&block)
-    # end
+    extend OpenWithSelf
 
     def initialize
       @internal_sem = Semaphore.new

data/lib/process_shared/{shared_memory.rb → object_buffer.rb}

@@ -1,23 +1,9 @@
-require 'process_shared/with_self'
 require 'process_shared/shared_memory_io'
 
 module ProcessShared
-  # Memory block shared across processes.
-  module SharedMemory
-    include ProcessShared::WithSelf
-
-    class << self
-      attr_accessor :impl
-
-      def new(*args)
-        impl.new(*args)
-      end
-
-      def open(size, &block)
-        new(size).with_self(&block)
-      end
-    end
-
+  # Provides reading and writing of serialized objects from a memory
+  # buffer.
+  module ObjectBuffer
     # Write the serialization of +obj+ (using Marshal.dump) to this
     # shared memory object at +offset+ (in bytes).
     #

data/lib/process_shared/open_with_self.rb

@@ -0,0 +1,20 @@
+module ProcessShared
+  module OpenWithSelf
+    # Like #new but if the optional code block is given, it will be
+    # passed the new object as an argument, and the object will
+    # automatically be closed (by invoking +close+) when the block
+    # terminates. In this instance, value of the block is returned.
+    def open(*args, &block)
+      obj = new(*args)
+      if block_given?
+        begin
+          yield obj
+        ensure
+          obj.close
+        end
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/process_shared/posix/semaphore.rb

@@ -1,4 +1,5 @@
-require 'process_shared/semaphore'
+require 'process_shared/synchronizable_semaphore'
+require 'process_shared/open_with_self'
 
 require 'process_shared/posix/errno'
 require 'process_shared/posix/libc'
@@ -34,8 +35,9 @@ module ProcessShared
                     :sem_timedwait)
       end
 
+      extend ProcessShared::OpenWithSelf
       include Foreign
-      include ProcessShared::Semaphore
+      include ProcessShared::SynchronizableSemaphore
 
       # Make a Proc suitable for use as a finalizer that will call
       # +shm_unlink+ on +sem+.

data/lib/process_shared/posix/shared_memory.rb

@@ -2,7 +2,8 @@ require 'ffi'
 
 require 'process_shared/posix/errno'
 require 'process_shared/posix/libc'
-require 'process_shared/shared_memory'
+require 'process_shared/object_buffer'
+require 'process_shared/open_with_self'
 
 module ProcessShared
   module Posix
@@ -25,10 +26,10 @@ module ProcessShared
         error_check :shm_open, :shm_unlink
       end
 
+      extend ProcessShared::OpenWithSelf
       include SharedMemory::Foreign
       include LibC
-      
-      include ProcessShared::SharedMemory
+      include ProcessShared::ObjectBuffer
 
       attr_reader :size, :type, :type_size, :count, :fd
 

data/lib/process_shared/shared_array.rb

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

data/lib/process_shared/synchronizable_semaphore.rb

@@ -0,0 +1,16 @@
+module ProcessShared
+  module SynchronizableSemaphore
+    # Yield the block after decrementing the semaphore, ensuring that
+    # the semaphore is incremented.
+    #
+    # @return [Object] the value of the block
+    def synchronize
+      wait
+      begin
+        yield
+      ensure
+        post
+      end
+    end
+  end
+end

data/spec/mach/semaphore_spec.rb

@@ -30,31 +30,41 @@ module Mach
     end
 
     it 'coordinates access to shared resource between two tasks' do
-      sem = Semaphore.new(:value => 0)
+      begin
+        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
+        port = Port.new
+        port.insert_right(:make_send)
+        Task.self.set_bootstrap_port(port)
 
-      child_task_port = port.receive_right
+        method = if Process.respond_to?(:__mach_original_fork__)
+                   :__mach_original_fork__
+                 else
+                   :fork
+                 end
 
-      start = Time.now.to_f
-      sem.insert_right(:copy_send, :ipc_space => child_task_port)
-      sem.wait
-      elapsed = Time.now.to_f - start
+        child = Process.send(method) 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
 
-      Process.wait child
+        child_task_port = port.receive_right
 
-      elapsed.must be_gt(0.4)
+        start = Time.now.to_f
+        sem.insert_right(:copy_send, :ipc_space => child_task_port)
+        sem.timedwait(1)
+        elapsed = Time.now.to_f - start
+
+        Process.wait child
+
+        elapsed.must be_gt(0.4)
+      ensure
+        Task.self.set_bootstrap_port(Mach::Functions.bootstrap_port)
+      end
     end
   end
 end

data/spec/process_shared/mutex_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
-require 'process_shared/mutex'
-require 'process_shared/shared_memory'
+require 'process_shared'
 
 module ProcessShared
   describe Mutex do

data/spec/process_shared/semaphore_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 require 'ffi'
-require 'process_shared/semaphore'
-require 'process_shared/shared_memory'
+require 'process_shared'
 
 module ProcessShared
   describe Semaphore do
@@ -16,7 +15,7 @@ module ProcessShared
           begin
             val = mem.get_int(0)
             # ensure other procs have a chance to interfere
-            sleep 0.001 if rand(100) == 0
+            sleep 0.002 if rand(50) == 0
             mem.put_int(0, val + 1)
           rescue => e
             "#{Process.pid} die'ing because #{e}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: process_shared
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-02 00:00:00.000000000Z
+date: 2012-02-09 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &13298820 !ruby/object:Gem::Requirement
+  requirement: &14966860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *13298820
+  version_requirements: *14966860
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &13297880 !ruby/object:Gem::Requirement
+  requirement: &14906760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13297880
+  version_requirements: *14906760
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &13297020 !ruby/object:Gem::Requirement
+  requirement: &14905460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13297020
+  version_requirements: *14905460
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &13296040 !ruby/object:Gem::Requirement
+  requirement: &14903860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13296040
+  version_requirements: *14903860
 - !ruby/object:Gem::Dependency
   name: minitest-matchers
-  requirement: &13295120 !ruby/object:Gem::Requirement
+  requirement: &14897460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13295120
+  version_requirements: *14897460
+- !ruby/object:Gem::Dependency
+  name: version
+  requirement: &14854820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *14854820
 description: FFI wrapper around portable semaphore library with mutex and condition
   vars built on top.
 email: pat@polycrystal.org
@@ -88,12 +99,16 @@ files:
 - lib/mach/time_spec.rb
 - lib/mach/error.rb
 - lib/mach/port.rb
+- lib/mach/types.rb
 - lib/mach/task.rb
+- lib/process_shared/synchronizable_semaphore.rb
 - lib/process_shared/abstract_semaphore.rb
 - lib/process_shared/posix_call.rb
 - lib/process_shared/mach.rb
+- lib/process_shared/object_buffer.rb
 - lib/process_shared/process_error.rb
 - lib/process_shared/thread.rb
+- lib/process_shared/open_with_self.rb
 - lib/process_shared/posix/errno.rb
 - lib/process_shared/posix/semaphore.rb
 - lib/process_shared/posix/time_spec.rb
@@ -103,16 +118,13 @@ files:
 - lib/process_shared/posix/shared_memory.rb
 - lib/process_shared/mutex.rb
 - lib/process_shared/shared_memory_io.rb
-- lib/process_shared/semaphore.rb
 - lib/process_shared/time_spec.rb
 - lib/process_shared/rt.rb
 - lib/process_shared/mach/semaphore.rb
 - lib/process_shared/shared_array.rb
 - lib/process_shared/binary_semaphore.rb
-- lib/process_shared/with_self.rb
 - lib/process_shared/define_singleton_method.rb
 - lib/process_shared/condition_variable.rb
-- lib/process_shared/shared_memory.rb
 - ext/pthread_sync_helper/pthread_sync_helper.c
 - ext/semaphore.c
 - ext/helper/helper.c
@@ -128,7 +140,6 @@ files:
 - spec/process_shared/condition_variable_spec.rb
 - spec/process_shared/mutex_spec.rb
 - spec/process_shared/shared_array_spec.rb
-- spec/process_shared/scratch.rb
 - spec/process_shared/semaphore_spec.rb
 - spec/spec_helper.rb
 - README.rdoc
@@ -148,7 +159,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4219144460365832731
+      hash: 282066855112542022
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -157,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4219144460365832731
+      hash: 282066855112542022
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10

data/lib/process_shared/semaphore.rb

@@ -1,37 +0,0 @@
-require 'process_shared/with_self'
-
-module ProcessShared
-  module Semaphore
-    include ProcessShared::WithSelf
-
-    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
-
-      # 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
-
-    def synchronize
-      wait
-      begin
-        yield
-      ensure
-        post
-      end
-    end
-  end
-end

data/lib/process_shared/with_self.rb

@@ -1,20 +0,0 @@
-module ProcessShared
-  module WithSelf
-    # With no associated block, return self.  If the optional code
-    # block is given, it will be passed `self` as an argument, and the
-    # self object will automatically be closed (by invoking +close+ on
-    # +self+) when the block terminates. In this instance, value of
-    # the block is returned.
-    def with_self
-      if block_given?
-        begin
-          yield self
-        ensure
-          self.close
-        end
-      else
-        self
-      end
-    end
-  end
-end

data/spec/process_shared/scratch.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'process_shared'
-
-module ProcessShared
-  describe Semaphore2 do
-    it 'does stuff' do
-      sem = Semaphore2.new(0)
-      puts ProcessShared::Mach.shared_ports.inspect
-      fork do
-        puts "child: #{Process.pid}"
-        sleep 2
-        puts "child signaling sem"
-        sem.post
-      end
-
-      puts "parent waiting..."
-      sem.wait
-      puts "parent woke up"
-    end
-  end
-end