process_shared 0.0.3 → 0.0.4

data/lib/process_shared/shared_memory_io.rb

@@ -0,0 +1,321 @@
+module ProcessShared
+  # Does some bounds checking for EOF, but assumes underlying memory
+  # object (FFI::Pointer) will do bounds checking, in particular the
+  # {#_putbytes} method relies on this.
+  #
+  # Note: an unbounded FFI::Pointer may be converted into a bounded
+  # pointer using +ptr.slice(0, size)+.
+  class SharedMemoryIO
+
+    attr_accessor :pos
+    attr_reader :mem
+
+    def initialize(mem)
+      @mem = mem
+      @pos = 0
+      @closed = false           # TODO: actually pay attention to this
+    end
+    
+    def <<(*args)
+      raise NotImplementedError
+    end
+
+    def advise(*args)
+      # no-op
+    end
+    
+    def autoclose=(*args)
+      raise NotImplementedError
+    end
+
+    def autoclose?
+      raise NotImplementedError
+    end
+
+    def binmode
+      # no-op; always in binmode
+    end
+
+    def binmode?
+      true
+    end
+
+    def bytes
+      if block_given?
+        until eof?
+          yield _getbyte
+        end
+      else
+        raise NotImplementedError
+      end
+    end
+    alias_method :each_byte, :bytes
+
+    def chars
+      raise NotImplementedError
+    end
+    alias_method :each_char, :chars
+
+    def close
+      @closed = true
+    end
+
+    def close_on_exec=(bool)
+      raise NotImplementedError
+    end
+
+    def close_on_exec?
+      raise NotImplementedError
+    end
+
+    def close_read
+      raise NotImplementedError
+    end
+
+    def close_write
+      raise NotImplementedError
+    end
+
+    def closed?
+      @closed
+    end
+
+    def codepoints
+      raise NotImplementedError
+    end
+    alias_method :each_codepoint, :codepoints
+
+    def each
+      raise NotImplementedError
+    end
+    alias_method :each_line, :each
+    alias_method :lines, :each
+
+    def eof?
+      pos == mem.size
+    end
+    alias_method :eof, :eof?
+
+    def external_encoding
+      raise NotImplementedError
+    end
+
+    def fcntl
+      raise NotImplementedError
+    end
+
+    def fdatasync
+      raise NotImplementedError
+    end
+
+    def fileno
+      raise NotImplementedError
+    end
+    alias_method :to_i, :fileno
+
+    def flush
+      # no-op
+    end
+
+    def fsync
+      raise NotImplementedError
+    end
+
+    def getbyte
+      return nil if eof?
+      _getbyte
+    end
+
+    # {#getc} in Ruby 1.9 returns String or nil.  In 1.8, it returned
+    # Fixnum of nil (identical to getbyte).
+    #
+    # FIXME: should this be encoding/character aware?
+    def getc19
+      if b = getbyte
+        '' << b
+      end
+    end
+    # FIXME: ignores versions prior to 1.8.
+    if RUBY_VERSION =~ /^1.8/
+      alias_method :getc, :getbyte
+    else
+      alias_method :getc, :getc19
+    end
+
+    def gets
+      raise NotImplementedError
+    end
+
+    def internal_encoding
+      raise NotImplementedError
+    end
+
+    def ioctl
+      raise NotImplementedError
+    end
+
+    def tty?
+      false
+    end
+    alias_method :isatty, :tty?
+
+    def lineno
+      raise NotImplementedError
+    end
+
+    def lineno=
+      raise NotImplementedError
+    end
+
+    def lines
+      raise NotImplementedError
+    end
+
+    def pid
+      raise NotImplementedError
+    end
+
+    alias_method :tell, :pos
+
+    def print(*args)
+      raise NotImplementedError
+    end
+    def printf(*args)
+      raise NotImplementedError
+    end
+
+    def putc(arg)
+      raise NotImplementedError
+    end
+
+    def puts(*args)
+      raise NotImplementedError
+    end
+
+    # FIXME: this doesn't match IO#read exactly (corner cases about
+    # EOF and whether length was nil or not), but it's enough for
+    # {Marshal::load}.
+    def read(length = nil, buffer = nil)
+      length ||= (mem.size - pos)
+      buffer ||= ''
+      
+      actual_length = [(mem.size - pos), length].min
+      actual_length.times do
+        buffer << _getbyte
+      end
+      buffer
+    end
+
+    def read_nonblock(*args)
+      raise NotImplementedError
+    end
+
+    def readbyte
+      raise EOFError if eof?
+      _getbyte
+    end
+
+    def readchar
+      raise NotImplementedError
+    end
+
+    def readline
+      raise NotImplementedError
+    end
+
+    def readlines
+      raise NotImplementedError
+    end
+
+    def readpartial
+      raise NotImplementedError
+    end
+
+    def reopen
+      raise NotImplementedError
+    end
+
+    def rewind
+      pos = 0
+    end
+
+    def seek(amount, whence = IO::SEEK_SET)
+      case whence
+      when IO::SEEK_CUR
+        self.pos += amount
+      when IO::SEEK_END
+        self.pos = (mem.size + amount)
+      when IO::SEEK_SET
+        self.pos = amount
+      else
+        raise ArgumentError, "bad seek whence #{whence}"
+      end
+    end
+
+    def set_encoding
+      raise NotImplementedError
+    end
+
+    def stat
+      raise NotImplementedError
+    end
+
+    def sync
+      true
+    end
+
+    def sync=
+      raise NotImplementedError
+    end
+
+    def sysread(*args)
+      raise NotImplementedError
+    end
+
+    def sysseek(*args)
+      raise NotImplementedError
+    end
+
+    def syswrite(*args)
+      raise NotImplementedError
+    end
+
+    def to_io
+      raise NotImplementedError
+    end
+
+    def ungetbyte
+      raise IOError if pos == 0
+      pos -= 1
+    end
+
+    def ungetc
+      raise NotImplementedError
+    end
+
+    def write(str)
+      s = str.to_s
+      _putbytes(s)
+      s.size
+    end
+
+    def write_nonblock(str)
+      raise NotImplementedError
+    end
+
+    private
+
+    # Like {#getbyte} but does not perform eof check.
+    def _getbyte
+      b = mem.get_uchar(pos)
+      self.pos += 1
+      b
+    end
+
+    def _putbytes(str)
+      mem.put_bytes(pos, str, 0, str.size)
+      self.pos += str.size
+    end
+
+  end
+end

data/lib/process_shared/with_self.rb

@@ -2,8 +2,8 @@ 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
+    # 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?

data/spec/process_shared/binary_semaphore_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'process_shared/binary_semaphore'
+
+module ProcessShared
+  describe BinarySemaphore do
+    it 'raises exception with double post' do
+      BinarySemaphore.open(0) do |sem|
+        sem.post
+        proc { sem.post }.must_raise(ProcessError)
+      end
+    end
+  end
+end

data/spec/process_shared/condition_variable_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+require 'process_shared/condition_variable'
+
+module ProcessShared
+  describe ConditionVariable do
+    it 'runs the example of Ruby Stdlib ConditionVariable' do
+      mutex = Mutex.new
+      resource = ConditionVariable.new
+
+      a = fork {
+        mutex.synchronize {
+          resource.wait(mutex)
+        }
+        Kernel.exit!
+      }
+      
+      b = fork {
+        mutex.synchronize {
+          resource.signal
+        }
+        Kernel.exit!
+      }
+
+      ::Process.wait(a)
+      ::Process.wait(b)
+    end
+
+    it 'broadcasts to multiple processes' do
+      mutex = Mutex.new
+      cond = ConditionVariable.new
+      mem = SharedMemory.new(:int)
+      mem.write_int(0)
+
+      pids = []
+      10.times do
+        pids << fork do
+          mutex.synchronize {
+            cond.wait(mutex)
+            mem.write_int(mem.read_int + 1)
+          }
+          Kernel.exit!
+        end
+      end
+
+      sleep 0.2               # hopefully they are all waiting...
+      mutex.synchronize {
+        cond.broadcast
+      }
+
+      pids.each { |p| ::Process.wait(p) }
+
+      mem.read_int.must_equal(10)
+    end
+
+    it 'stops waiting after timeout' do
+      mutex = Mutex.new
+      cond = ConditionVariable.new
+
+      mutex.synchronize {
+        start = Time.now.to_f
+        cond.wait(mutex, 0.1)
+        (Time.now.to_f - start).must be_gte(0.1)
+      }
+    end
+  end
+end

data/spec/process_shared/semaphore_spec.rb

@@ -72,5 +72,46 @@ module ProcessShared
         end
       end
     end
+
+    describe '#try_wait' do
+      it 'returns immediately with non-zero semaphore' do
+        Semaphore.open(1) do |sem|
+          start = Time.now.to_f
+          sem.try_wait
+          (Time.now.to_f - start).must be_lt(0.01)
+        end
+      end
+
+      it 'raises EAGAIN with zero semaphore' do
+        Semaphore.open(0) do |sem|
+          proc { sem.try_wait }.must_raise(Errno::EAGAIN)
+        end
+      end
+
+      it 'raises ETIMEDOUT after timeout expires' do
+        Semaphore.open(0) do |sem|
+          start = Time.now.to_f
+          proc { sem.try_wait(0.1) }.must_raise(Errno::ETIMEDOUT)
+          (Time.now.to_f - start).must be_gte(0.1)
+        end
+      end
+
+      it 'returns after waiting if another processes posts' do
+        Semaphore.open(0) do |sem|
+          start = Time.now.to_f
+
+          pid = fork do
+            sleep 0.01
+            sem.post
+            Kernel.exit!
+          end
+
+          sem.try_wait(0.1)
+          (Time.now.to_f - start).must be_lt(0.1)
+
+          ::Process.wait(pid)
+        end
+      end
+    end
   end
 end

data/spec/process_shared/shared_array_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'process_shared/shared_array'
+
+module ProcessShared
+  describe SharedArray do
+    it 'initializes arrays' do
+      mem = SharedArray.new(:int, 10)
+      10.times do |i|
+        mem[i] = i
+      end
+      10.times do |i|
+        mem[i].must_equal i
+      end
+    end
+
+    it 'responds to Enumerable methods' do
+      mem = SharedArray.new(:int, 4)
+      4.times do |i|
+        mem[i] = i+1
+      end
+
+      mem.map { |i| i * 2 }.must_equal [2, 4, 6, 8]
+      mem.sort.must_equal [1, 2, 3, 4]
+    end
+  end
+end

data/spec/process_shared/shared_memory_spec.rb

@@ -32,5 +32,30 @@ module ProcessShared
 
       mem.get_int(0).must_equal(1234567)
     end
+
+    describe 'Object dump/load' do
+      it 'writes serialized objects' do
+        mem = SharedMemory.new(1024)
+        pid = fork do
+          mem.write_object(['a', 'b'])
+          Kernel.exit!
+        end
+        ::Process.wait(pid)
+        mem.read_object.must_equal ['a', 'b']
+      end
+      
+      it 'raises IndexError when insufficient space' do
+        mem = SharedMemory.new(2)
+        proc { mem.write_object(['a', 'b']) }.must_raise(IndexError)
+      end
+
+      it 'writes with an offset' do
+        mem = SharedMemory.new(1024)
+        mem.put_object(2, 'string')
+        proc { mem.read_object }.must_raise(TypeError)
+        proc { mem.get_object(0) }.must_raise(TypeError)
+        mem.get_object(2).must_equal 'string'
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -17,15 +17,16 @@ class RangeMatcher
   end
 
   def matches?(subject)
+    @subject = subject
     subject.send(@operator, @limit)
   end
 
   def failure_message_for_should
-    "expected #{operator} #{@limit}"
+    "expected #{@operator} #{@limit}, not #{@subject}"
   end
 
   def failure_message_for_should_not
-    "expected not #{operator} #{@limit}"
+    "expected not #{@operator} #{@limit}, not #{@subject}"
   end
 end
 
@@ -33,6 +34,14 @@ def be_lt(value)
   RangeMatcher.new('<', value)
 end
 
+def be_gt(value)
+  RangeMatcher.new('>', value)
+end
+
 def be_lte(value)
   RangeMatcher.new('<=', value)
 end
+
+def be_gte(value)
+  RangeMatcher.new('>=', value)
+end