process_shared 0.0.4 → 0.1.0

data/ext/libpsem/psem_posix.h

@@ -1,10 +0,0 @@
-#ifndef __PSEM_POSIX_H__
-#define __PSEM_POSIX_H__
-
-#include <semaphore.h>
-
-struct psem {
-  sem_t *sem;
-};
-
-#endif  /* __PSEM_POSIX_H__ */

data/lib/process_shared/bounded_semaphore.rb

@@ -1,46 +0,0 @@
-require 'process_shared/psem'
-require 'process_shared/semaphore'
-
-module ProcessShared
-  # BoundedSemaphore is identical to Semaphore except that its value
-  # is not permitted to rise above a maximum.  When the value is at
-  # the maximum, calls to #post will have no effect.
-  class BoundedSemaphore < Semaphore
-    # 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, BoundedSemaphore.open returns the value of the block.
-    #
-    # @param [Integer] value the initial semaphore value
-    # @param [String] name not currently supported
-    def self.open(maxvalue, value = 1, name = nil, &block)
-      new(maxvalue, value, name).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
-    # 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(maxvalue, value = 1, name = nil)
-      init(PSem.sizeof_bsem_t, 'bsem', name) do |sem_name|
-        bsem_open(sem, sem_name, maxvalue, value, err)
-      end
-    end
-
-    protected
-
-    alias_method :psem_unlink, :bsem_unlink
-    alias_method :psem_close, :bsem_close
-    alias_method :psem_wait, :bsem_wait
-    alias_method :psem_post, :bsem_post
-    alias_method :psem_getvalue, :bsem_getvalue
-  end
-end

data/lib/process_shared/libc.rb

@@ -1,36 +0,0 @@
-require 'ffi'
-
-require 'process_shared/posix_call'
-require 'process_shared/psem'
-
-module ProcessShared
-  module LibC
-    extend FFI::Library
-    extend PosixCall
-
-    ffi_lib FFI::Library::LIBC
-
-    MAP_FAILED = FFI::Pointer.new(-1)
-    MAP_SHARED = PSem.map_shared
-    MAP_PRIVATE = PSem.map_private
-
-    PROT_READ = PSem.prot_read
-    PROT_WRITE = PSem.prot_write
-    PROT_EXEC = PSem.prot_exec
-    PROT_NONE = PSem.prot_none
-
-    O_RDWR = PSem.o_rdwr
-    O_CREAT = PSem.o_creat
-    O_EXCL = PSem.o_excl
-
-    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
-    attach_function :close, [:int], :int
-
-    error_check(:mmap) { |v| v == MAP_FAILED }
-    error_check(:munmap, :ftruncate, :close)
-  end
-end

data/lib/process_shared/psem.rb

@@ -1,113 +0,0 @@
-require 'ffi'
-
-module ProcessShared
-  module PSem
-    class Error < FFI::Struct
-      layout(:source, :int,
-             :errno, :int)
-    end
-
-    extend FFI::Library
-
-    # Workaround FFI dylib/bundle issue.  See https://github.com/ffi/ffi/issues/42
-    suffix = if FFI::Platform.mac?
-               'bundle'
-             else
-               FFI::Platform::LIBSUFFIX
-             end
-
-    ffi_lib File.join(File.expand_path(File.dirname(__FILE__)),
-                      'libpsem.' + suffix)
-
-    class << self
-      # Replace methods in `syms` with error checking wrappers that
-      # invoke the original psem method and raise an appropriate
-      # error.
-      #
-      # The last argument is assumed to be a pointer to a pointer
-      # where either a psem error or NULL will be stored.
-      def psem_error_check(*syms)
-        syms.each do |sym|
-          method = self.method(sym)
-
-          block = lambda do |*args|
-            if method.call(*args) < 0
-              errp = args[-1]
-              unless errp.nil?
-                begin
-                  err = Error.new(errp.read_pointer)
-                  errp.write_pointer(nil)
-                  if err[:source] == PSem.e_source_system
-                    raise SystemCallError.new("error in #{sym}", err[:errno])
-                  else
-                    raise "error in #{sym}: #{err.get_integer(1)}"
-                  end
-                ensure
-                  psem_error_free(err)
-                end
-              end
-            end
-          end
-
-          define_method(sym, &block)
-          define_singleton_method(sym, &block)
-        end
-      end
-    end
-
-    # Generic constants
-
-    int_consts = [:o_rdwr,
-                  :o_creat,
-                  :o_excl,
-                  
-                  :prot_read,
-                  :prot_write,
-                  :prot_exec,
-                  :prot_none,
-                  
-                  :map_shared,
-                  :map_private]
-    int_consts.each { |sym| attach_variable sym, :int }
-
-    # Other constants, functions
-
-    attach_function :psem_error_free, :error_free, [:pointer], :void
-
-    attach_variable :e_source_system, :E_SOURCE_SYSTEM, :int
-    attach_variable :e_source_psem, :E_SOURCE_PSEM, :int
-
-    attach_variable :e_name_too_long, :E_NAME_TOO_LONG, :int
-
-    attach_variable :sizeof_psem_t, :size_t
-    attach_variable :sizeof_bsem_t, :size_t
-
-    # PSem functions
-
-    attach_function :psem_open, [:pointer, :string, :uint, :pointer], :int
-    attach_function :psem_close, [:pointer, :pointer], :int
-    attach_function :psem_unlink, [:string, :pointer], :int
-    attach_function :psem_post, [:pointer, :pointer], :int
-    attach_function :psem_wait, [:pointer, :pointer], :int
-    attach_function :psem_trywait, [:pointer, :pointer], :int
-    attach_function :psem_timedwait, [:pointer, :float, :pointer], :int
-    attach_function :psem_getvalue, [:pointer, :pointer, :pointer], :int
-
-    psem_error_check(:psem_open, :psem_close, :psem_unlink, :psem_post,
-                     :psem_wait, :psem_trywait, :psem_timedwait, :psem_getvalue)
-
-    # BSem functions
-    
-    attach_function :bsem_open, [:pointer, :string, :uint, :uint, :pointer], :int
-    attach_function :bsem_close, [:pointer, :pointer], :int
-    attach_function :bsem_unlink, [:string, :pointer], :int
-    attach_function :bsem_post, [:pointer, :pointer], :int
-    attach_function :bsem_wait, [:pointer, :pointer], :int
-    attach_function :bsem_trywait, [:pointer, :pointer], :int
-    attach_function :bsem_timedwait, [:pointer, :float, :pointer], :int
-    attach_function :bsem_getvalue, [:pointer, :pointer, :pointer], :int
-
-    psem_error_check(:bsem_open, :bsem_close, :bsem_unlink, :bsem_post,
-                     :bsem_wait, :bsem_trywait, :bsem_timedwait, :bsem_getvalue)
-  end
-end

data/spec/process_shared/bounded_semaphore_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'process_shared/bounded_semaphore'
-
-module ProcessShared
-  describe BoundedSemaphore do
-    it 'never rises above its max value' do
-      max = 10
-      BoundedSemaphore.open(max) do |sem|
-        pids = []
-        10.times do |i|
-          pids << fork do
-            100.times do
-              if rand(3) == 0
-                sem.wait
-              else
-                sem.post
-              end
-            end
-
-            exit i
-          end
-        end
-
-        100.times do
-          sem.value.must be_lte(max)
-        end
-
-        pids.each { |pid| Process.wait(pid) }
-      end
-    end
-
-    describe '#post and #wait' do
-      it 'increments and decrements the value' do
-        Semaphore.open(0) do |sem|
-          10.times do |i|
-            sem.post
-            sem.value.must_equal(i + 1)
-          end
-
-          10.times do |i|
-            sem.wait
-            sem.value.must_equal(10 - i - 1)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/process_shared/libc_spec.rb

@@ -1,9 +0,0 @@
-require 'process_shared/libc'
-
-module ProcessShared
-  describe LibC do
-    it 'throws exceptions with invalid args' do
-      proc { LibC.mmap nil,2,0,0,1,0 }.must_raise(Errno::EINVAL)
-    end
-  end
-end

data/spec/process_shared/psem_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-require 'process_shared/psem'
-
-module ProcessShared
-  describe PSem do
-    before do
-      extend PSem
-    end
-
-    before(:each) do
-      @err = FFI::MemoryPointer.new(:pointer)
-    end
-
-    describe '.psem_open' do
-      it 'opens a psem' do
-        psem = FFI::MemoryPointer.new(PSem.sizeof_psem_t)
-        psem_open(psem, "psem-test", 1, @err)
-        psem_unlink("psem-test", @err)
-      end
-
-      it 'raises excpetion if name alredy exists' do
-        psem1 = FFI::MemoryPointer.new(PSem.sizeof_psem_t)
-        psem2 = FFI::MemoryPointer.new(PSem.sizeof_psem_t)
-        psem_open(psem1, "psem-test", 1, @err)
-        proc { psem_open(psem2, "psem-test", 1, @err) }.must_raise(Errno::EEXIST)
-
-        psem_unlink("psem-test", @err)
-        psem_open(psem2, "psem-test", 1, @err)
-        psem_unlink("psem-test", @err)
-      end
-    end
-
-    describe '.psem_wait' do
-      before(:each) do
-        @psem = FFI::MemoryPointer.new(PSem.sizeof_psem_t)
-        psem_open(@psem, 'psem-test', 1, @err)
-        psem_unlink('psem-test', @err)
-
-        @int = FFI::MemoryPointer.new(:int)
-      end
-
-      after(:each) do
-        #psem_close(@psem, @err)
-      end
-
-      def value
-        psem_getvalue(@psem, @int, @err)
-        @int.get_int(0)
-      end
-
-      it 'decrements psem value' do
-        value.must_equal 1
-        psem_wait(@psem, @err)
-        value.must_equal(0)
-      end
-
-      it 'waits until another process posts' do
-        psem_wait(@psem, @err)
-
-        # child exits with ~ time spent waiting
-        child = fork do
-          start = Time.now
-          psem_wait(@psem, @err)
-          exit (Time.now - start).ceil
-        end
-
-        t = 1.5
-        sleep t
-        psem_post(@psem, @err)
-        _pid, status = Process.wait2(child)
-        status.exitstatus.must_equal 2
-      end
-    end
-
-    describe '.bsem_open' do
-      it 'opens a bsem' do
-        bsem = FFI::MemoryPointer.new(PSem.sizeof_bsem_t)
-        bsem_open(bsem, "bsem-test", 1, 1, @err)
-        bsem_unlink("bsem-test", @err)
-      end
-
-      it 'raises excpetion if name alredy exists' do
-        bsem1 = FFI::MemoryPointer.new(PSem.sizeof_bsem_t)
-        bsem2 = FFI::MemoryPointer.new(PSem.sizeof_bsem_t)
-        bsem_open(bsem1, "bsem-test", 1, 1, @err)
-        proc { bsem_open(bsem2, "bsem-test", 1, 1, @err) }.must_raise(Errno::EEXIST)
-
-        bsem_unlink("bsem-test", @err)
-        bsem_open(bsem2, "bsem-test", 1, 1, @err)
-        bsem_unlink("bsem-test", @err)
-      end
-    end
-
-    describe '.bsem_wait' do
-      before(:each) do
-        @bsem = FFI::MemoryPointer.new(PSem.sizeof_bsem_t)
-        bsem_open(@bsem, 'bsem-test', 1, 1, @err)
-        bsem_unlink('bsem-test', @err)
-
-        @int = FFI::MemoryPointer.new(:int)
-      end
-
-      after do
-        #bsem_close(@bsem, @err)
-      end
-
-      def value
-        bsem_getvalue(@bsem, @int, @err)
-        @int.get_int(0)
-      end
-
-      it 'decrements bsem value' do
-        value.must_equal 1
-        bsem_wait(@bsem, @err)
-        value.must_equal 0
-      end
-
-      it 'waits until another process posts' do
-        bsem_wait(@bsem, @err)
-
-        # child exits with ~ time spent waiting
-        child = fork do
-          start = Time.now
-          bsem_wait(@bsem, @err)
-          exit (Time.now - start).ceil
-        end
-
-        t = 1.5
-        sleep t
-        bsem_post(@bsem, @err)
-        _pid, status = Process.wait2(child)
-        status.exitstatus.must_equal 2
-      end
-    end
-  end
-end