process_shared 0.0.1

data/spec/process_shared/mutex_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'process_shared/mutex'
+require 'process_shared/shared_memory'
+
+module ProcessShared
+  describe Mutex do
+    it 'protects access to a shared variable' do
+      mutex = Mutex.new
+      mem = SharedMemory.new(:char)
+      mem.put_char(0, 0)
+
+      pids = []
+      10.times do |i|
+        inc = (-1) ** i         # half the procs increment; half decrement
+        pids << fork do
+          10.times do
+            mutex.lock
+            begin
+              mem.put_char(0, mem.get_char(0) + inc)
+              sleep 0.001
+            ensure
+              mutex.unlock
+            end
+          end
+          Kernel.exit!
+        end
+      end
+
+      pids.each { |pid| ::Process.wait(pid) }
+
+      mem.get_char(0).must_equal(0)
+    end
+
+    it 'protects access to a shared variable with synchronize' do
+      mutex = Mutex.new
+      mem = SharedMemory.new(:char)
+      mem.put_char(0, 0)
+
+      pids = []
+      10.times do |i|
+        inc = (-1) ** i         # half the procs increment; half decrement
+        pids << fork do
+          10.times do
+            mutex.synchronize do
+              mem.put_char(0, mem.get_char(0) + inc)
+              sleep 0.001
+            end
+          end
+          Kernel.exit!
+        end
+      end
+
+      pids.each { |pid| ::Process.wait(pid) }
+
+      mem.get_char(0).must_equal(0)
+    end
+
+    it 'raises exception when unlocked by other process' do
+      mutex = Mutex.new
+
+      pid = Kernel.fork do
+        mutex.lock
+        sleep 0.2
+        mutex.unlock
+        Kernel.exit!
+      end
+
+      sleep 0.1
+      proc { mutex.unlock }.must_raise(ProcessError)
+
+      ::Process.wait(pid)
+    end
+  end
+end

data/spec/process_shared/psem_spec.rb

@@ -0,0 +1,136 @@
+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

data/spec/process_shared/semaphore_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+require 'ffi'
+require 'process_shared/semaphore'
+require 'process_shared/shared_memory'
+
+module ProcessShared
+  describe Semaphore do
+    it 'coordinates access to shared object' do
+      nprocs = 4               # number of processes
+      nincrs = 1000            # each process increments nincrs times
+
+      do_increments = lambda do |mem, sem|
+        nincrs.times do
+          sem.wait
+          begin
+            val = mem.get_int(0)
+            # ensure other procs have a chance to interfere
+            sleep 0.001 if rand(100) == 0
+            mem.put_int(0, val + 1)
+          rescue => e
+            "#{Process.pid} die'ing because #{e}"
+          ensure
+            sem.post
+          end
+        end
+      end
+
+      # Make sure it fails with no synchronization
+      no_sem = Object.new
+      class << no_sem
+        def wait; end
+        def post; end
+      end
+      SharedMemory.open(FFI.type_size(:int)) do |mem|
+        pids = []
+        nprocs.times do
+          pids << fork { do_increments.call(mem, no_sem); exit }
+        end
+        
+        pids.each { |p| Process.wait(p) }
+        # puts "mem is #{mem.get_int(0)}"
+        mem.get_int(0).must be_lt(nprocs * nincrs)
+      end
+
+      # Now try with synchronization
+      SharedMemory.open(FFI.type_size(:int)) do |mem|
+        pids = []
+        Semaphore.open do |sem|
+          nprocs.times do
+            pids << fork { do_increments.call(mem, sem); exit }
+          end
+        end
+        
+        pids.each { |p| Process.wait(p) }
+        mem.get_int(0).must_equal(nprocs * nincrs)
+      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/shared_memory_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'process_shared/shared_memory'
+
+module ProcessShared
+  describe SharedMemory do
+    it 'shares memory across processes' do
+      mem = SharedMemory.new(1)
+      mem.put_char(0, 0)
+      mem.get_char(0).must_equal(0)
+      
+      pid = fork do
+        mem.put_char(0, 123)
+        Kernel.exit!
+      end
+
+      ::Process.wait(pid)
+
+      mem.get_char(0).must_equal(123)
+    end
+
+    it 'initializes with type symbol' do
+      mem = SharedMemory.new(:int)
+      mem.put_int(0, 0)
+      mem.get_int(0).must_equal(0)
+      
+      pid = fork do
+        mem.put_int(0, 1234567)
+        Kernel.exit!
+      end
+
+      ::Process.wait(pid)
+
+      mem.get_int(0).must_equal(1234567)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/matchers'
+
+class RangeMatcher
+  def initialize(operator, limit)
+    @operator = operator.to_sym
+    @limit = limit
+  end
+
+  def description
+    "be #{operator} #{@limit}"
+  end
+
+  def matches?(subject)
+    subject.send(@operator, @limit)
+  end
+
+  def failure_message_for_should
+    "expected #{operator} #{@limit}"
+  end
+
+  def failure_message_for_should_not
+    "expected not #{operator} #{@limit}"
+  end
+end
+
+def be_lt(value)
+  RangeMatcher.new('<', value)
+end
+
+def be_lte(value)
+  RangeMatcher.new('<=', value)
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: process_shared
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Patrick Mahoney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &19463720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19463720
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &19462580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19462580
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &19461120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19461120
+- !ruby/object:Gem::Dependency
+  name: minitest-matchers
+  requirement: &19459840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19459840
+description: FFI wrapper around portable semaphore library with mutex and condition
+  vars built on top.
+email: pat@polycrystal.org
+executables: []
+extensions:
+- ext/pthread_sync_helper/extconf.rb
+- ext/libpsem/extconf.rb
+extra_rdoc_files:
+- README.rdoc
+- ChangeLog
+- COPYING
+files:
+- lib/scratch.rb
+- lib/process_shared.rb
+- lib/process_shared/abstract_semaphore.rb
+- lib/process_shared/posix_call.rb
+- lib/process_shared/process_error.rb
+- lib/process_shared/thread.rb
+- lib/process_shared/mutex.rb
+- lib/process_shared/semaphore.rb
+- lib/process_shared/rt.rb
+- lib/process_shared/psem.rb
+- lib/process_shared/with_self.rb
+- lib/process_shared/condition_variable.rb
+- lib/process_shared/bounded_semaphore.rb
+- lib/process_shared/libc.rb
+- lib/process_shared/shared_memory.rb
+- lib/process_shared/libpsem.bundle
+- lib/process_shared/libpsem.so
+- ext/pthread_sync_helper/pthread_sync_helper.c
+- ext/semaphore.c
+- ext/libpsem/mempcpy.c
+- ext/libpsem/psem_error.c
+- ext/libpsem/bsem.c
+- ext/libpsem/psem_posix.c
+- ext/libpsem/psem.c
+- ext/libpsem/mutex.c
+- ext/libpsem/constants.c
+- ext/libpsem/bsem.h
+- ext/libpsem/psem_error.h
+- ext/libpsem/mutex.h
+- ext/libpsem/constants.h
+- ext/libpsem/psem.h
+- ext/libpsem/psem_posix.h
+- ext/libpsem/mempcpy.h
+- ext/pthread_sync_helper/extconf.rb
+- ext/libpsem/extconf.rb
+- spec/process_shared/psem_spec.rb
+- spec/process_shared/shared_memory_spec.rb
+- spec/process_shared/mutex_spec.rb
+- spec/process_shared/bounded_semaphore_spec.rb
+- spec/process_shared/semaphore_spec.rb
+- spec/process_shared/libc_spec.rb
+- spec/spec_helper.rb
+- README.rdoc
+- ChangeLog
+- COPYING
+homepage: https://github.com/pmahoney/process_shared
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: process-shared synchronization primitives
+test_files: []