multiprocessing 0.0.1 → 0.0.2

data/lib/multiprocessing/semaphore.rb

@@ -2,33 +2,66 @@ require File.expand_path(File.dirname(__FILE__) + '/mutex')
 require File.expand_path(File.dirname(__FILE__) + '/conditionvariable')
 
 module MultiProcessing
+
+  ##
+  #
+  # Like Mutex but can manage multiple resources.
+  #
+  # Note that Semaphore uses 4 pipes( 1 pipe, 1 Mutex, 1 ConditionVariable).
+  #
+  # @example
+  #   require 'multiprocessing'
+  #   
+  #   s = MultiProcessing::Semaphore.new 2
+  #   3.times do
+  #     fork do
+  #       s.synchronize do
+  #         puts "pid: #{Process.pid}"
+  #         sleep 1
+  #       end
+  #     end
+  #   end
+  #   Process.waitall
+  #   # => 2 processes prints its pid immediately
+  #   #    but the other does late.
+  #
   class Semaphore
 
+    ##
+    #
+    # A new instance of Semaphore
+    #
+    # @param [Fixnum] count is initial number of resource
+    #
     def initialize count
       @count_pout, @count_pin = IO.pipe
       @count_pin.syswrite "1"*count
-      #@count_pin.write "1"*count
-      #@count_pin.flush
       @mutex = Mutex.new
       @cond = ConditionVariable.new
     end
 
     def count_nonsynchronize
-      n = 0
-      begin
-        loop do
-          @count_pout.read_nonblock 1
-          n += 1
+      MultiProcessing.try_handle_interrupt(RuntimeError => :never) do
+        n = 0
+        begin
+          loop do
+            @count_pout.read_nonblock 1
+            n += 1
+          end
+        rescue Errno::EAGAIN
+          @count_pin.syswrite "1"*n
         end
-      rescue Errno::EAGAIN
-        @count_pin.syswrite "1"*n
-        #@count_pin.write "1"*n
-        #@count_pin.flush
+        n
       end
-      return n
     end
     private :count_nonsynchronize
 
+    ##
+    #
+    # Returns current number of resources.
+    #
+    # @return [Fixnum]
+    #
     def count
       @mutex.synchronize do
         count_nonsynchronize
@@ -36,6 +69,12 @@ module MultiProcessing
     end
     alias :value :count
 
+    ##
+    #
+    # Attempts to get the resource and wait if it isn't available.
+    #
+    # @return [Semaphore] self
+    #
     def P
       @mutex.synchronize do
         while count_nonsynchronize == 0
@@ -48,6 +87,13 @@ module MultiProcessing
     alias :lock :P
     alias :wait :P
 
+    ##
+    #
+    # Attempts to get the resource and returns immediately
+    # Returns true if the resource granted.
+    #
+    # @return [Boolean]
+    #
     def try_P
       begin
         @mutex.synchronize do
@@ -61,36 +107,41 @@ module MultiProcessing
     alias :try_lock :try_P
     alias :try_wait :try_P
 
+    ##
+    #
+    # Releases the resource.
+    #
+    # @return [Semaphore] self
+    #
     def V
-      @mutex.synchronize do
-        @count_pin.syswrite 1
-        #@count_pin.write 1
-        #@count_pin.flush
-        @cond.signal
+      MultiProcessing.try_handle_interrupt(RuntimeError => :never) do
+        @mutex.synchronize do
+          @count_pin.syswrite 1
+          @cond.signal
+        end
+        self
       end
-      return self
     end
     alias :signal :V
     alias :unlock :V
     alias :post :V
 
+    ##
+    #
+    # Obtains a resource, runs the block, and releases the resource when the block completes.
+    #
+    # @return [Object] returned value of the block
+    #
     def synchronize
       self.P
       begin
-        yield
+        ret = yield
       ensure
         self.V
       end
+      ret
     end
 
   end
 end
 
-if $0 == __FILE__
-  s = MultiProcessing::Semaphore.new 1
-  fork
-  s.wait
-  puts Process.pid
-  sleep 1
-  s.post
-end

data/lib/multiprocessing/version.rb

@@ -1,3 +1,14 @@
 module MultiProcessing
-  VERSION = "0.0.1"
+
+  ##
+  #
+  # A version of MultiProcessing library
+  #
+  # 0.0.1 (2012-02-13)
+  # : Initial release
+  #
+  # 0.0.2 (2012-07-14)
+  # : fixed many bugs
+  #
+  VERSION = "0.0.2"
 end

data/spec/multiprocessing/conditionvariable_spec.rb

@@ -0,0 +1,206 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'timeout'
+require 'thwait'
+
+describe MultiProcessing::ConditionVariable do
+
+  before do
+    @cond = MultiProcessing::ConditionVariable.new
+  end
+
+  context "being waited by no process" do
+
+    describe "#signal" do
+      it "returns false" do
+        @cond.signal.should be_false
+      end
+    end
+
+    describe "#broadcast" do
+      it "returns 0" do
+        @cond.broadcast.should == 0
+      end
+    end
+
+  end
+
+  context "being waited by one process" do
+
+    before do
+      @pid = fork do
+        mutex = MultiProcessing::Mutex.new
+        mutex.synchronize do
+          @cond.wait(mutex)
+        end
+      end
+      @detached_thread = Process.detach(@pid)
+      sleep 0.01
+    end
+
+    describe "#signal" do
+
+      it "returns true" do
+        @cond.signal.should be_true
+      end
+
+      it "makes waiting process restart" do
+        @cond.signal
+        timeout(1){ @detached_thread.value }.success?.should be_true
+      end
+
+    end
+
+    describe "#broadcast" do
+
+      it "returns number of waited processes" do
+        @cond.broadcast.should == 1
+      end
+
+      it "makes waiting process restart" do
+        @cond.broadcast
+        timeout(1){ @detached_thread.value }.success?.should be_true
+      end
+
+    end
+
+    after do
+      begin
+        Process.kill(:TERM, @pid)
+      rescue Errno::ESRCH
+      end
+    end
+
+  end
+
+  context "being waited by multiple processes" do
+
+    before do
+      Process.waitall
+      @pid1 = fork do
+        mutex = MultiProcessing::Mutex.new
+        mutex.synchronize do
+          @cond.wait(mutex)
+        end
+      end
+      @pid2 = fork do
+        mutex = MultiProcessing::Mutex.new
+        mutex.synchronize do
+          @cond.wait(mutex)
+        end
+      end
+      @detached_thread1 = Process.detach(@pid1)
+      @detached_thread2 = Process.detach(@pid2)
+      sleep 0.01
+    end
+
+    describe "#signal" do
+
+      it "returns true" do
+        @cond.signal.should be_true
+      end
+
+      it "makes waiting process restart" do
+        @cond.signal
+        threads = [@detached_thread1, @detached_thread2]
+        thwait = ThreadsWait.new(threads)
+        timeout(1){ thwait.next_wait.value }.success?.should be_true
+        thwait.threads[0].should be_alive
+      end
+
+    end
+
+    describe "#broadcast" do
+
+      it "returns number of waited process" do
+        @cond.broadcast.should == 2
+      end
+
+      it "makes waiting process restart" do
+        @cond.broadcast
+        timeout(1){ @detached_thread1.value }.success?.should be_true
+        timeout(1){ @detached_thread2.value }.success?.should be_true
+      end
+
+    end
+
+    after do
+      begin
+        Process.kill(:TERM, @pid1)
+      rescue Errno::ESRCH
+      end
+      begin
+        Process.kill(:TERM,@pid2)
+      rescue Errno::ESRCH
+      end
+    end
+
+  end
+
+  describe "#wait" do
+
+    context "called with MultiProcessing::Mutex" do
+
+      before do
+        @mutex = MultiProcessing::Mutex.new
+        @pid = fork do
+          sleep 0.02
+          @cond.signal
+        end
+      end
+
+      context "until signal" do
+        it "blocks" do
+          @mutex.synchronize do
+            proc{timeout(0.01){@cond.wait(@mutex)}}.should raise_error Timeout::Error
+          end
+        end
+      end
+
+      context "after signal" do
+        it "restarts" do
+          @mutex.synchronize do
+            proc{timeout(0.03){@cond.wait(@mutex)}}.should_not raise_error Timeout::Error
+          end
+        end
+      end
+
+      after do
+        begin
+          Process.kill :KILL, @pid
+        rescue Errno::ESRCH
+        end
+      end
+
+    end
+
+    context "called with object except MultiProcessing::Mutex" do
+      it "raises MultiProcessing::ProcessError" do
+        proc{@cond.wait(Object.new)}.should raise_error TypeError
+      end
+    end
+
+    context "called with unlocked Mutex" do
+
+      it "raises MultiProcessing::ProcessError" do
+        mutex = MultiProcessing::Mutex.new
+        proc{@cond.wait(mutex)}.should raise_error ArgumentError
+      end
+
+      it "still works" do
+        mutex = MultiProcessing::Mutex.new
+        begin
+          @cond.wait(mutex)
+        rescue ArgumentError
+        end
+        @cond.signal.should be_false
+        # this means that inner variables are in the state that no process are waiting it
+      end
+
+    end
+
+  end
+
+end
+
+
+

data/spec/multiprocessing/mutex_spec.rb

@@ -7,103 +7,497 @@ describe MultiProcessing::Mutex do
     @mutex = MultiProcessing::Mutex.new
   end
 
-  it "#lock returns itself" do
-    @mutex.lock.should === @mutex
-  end
+  describe "#lock" do
 
-  it "#unlock returns itself if locked" do
-    @mutex.lock
-    @mutex.unlock.should === @mutex
-  end
+    it "returns itself" do
+      @mutex.lock.should === @mutex
+    end
 
-  it "#unlock raises ProcessError if not locked" do
-    proc{ @mutex.unlock }.should raise_error MultiProcessing::ProcessError
-  end
+    context "when locked in same thread" do
 
-  it "#locked? returns false if not locked" do
-    @mutex.locked?.should be_false
-  end
+      before do
+        @mutex.lock
+      end
 
-  it "#locked? returns true if locked" do
-    @mutex.lock
-    @mutex.locked?.should be_true
-  end
+      it "raises ProcessError" do
+        proc{ @mutex.lock }.should raise_error MultiProcessing::ProcessError
+      end
 
-  it "#lock, #unlock can locks/unlocks other process" do
-    process = MultiProcessing::Process.new do
-      sleep 0.1
-      @mutex.lock
-      @mutex.unlock
-    end
-    @mutex.lock
-    sleep 0.2
-    process.join(0).should be_nil
-    @mutex.unlock
-    proc{ timeout(1){ process.join } }.should_not raise_error Timeout::Error
-  end
+      after do
+        @mutex.unlock
+      end
 
-  it "#synchronize can synchronize with other process" do
-    process = MultiProcessing::Process.new do
-      sleep 0.1
-      @mutex.synchronize do
-        :nop
+    end
+
+    context "when locked in another thread but same process" do
+
+      before do
+        Thread.new do
+          @mutex.lock
+        end
+        sleep 0.01
+      end
+
+      it "blocks" do
+        proc{ timeout(0.01){ @mutex.lock } }.should raise_error Timeout::Error
       end
+
     end
-    @mutex.synchronize do
-      sleep 0.2
-      process.join(0).should be_nil
+
+    context "when locked in another process" do
+
+      before do
+        fork do
+          @mutex.lock
+          sleep 0.03
+          @mutex.unlock
+        end
+        sleep 0.01
+      end
+
+      it "blocks" do
+        proc{ timeout(0.01){ @mutex.lock } }.should raise_error Timeout::Error
+      end
+
     end
-    proc{ timeout(1){ process.join } }.should_not raise_error Timeout::Error
+
   end
 
-  it "#lock cannot lock twice" do
-    @mutex.lock
-    proc{
-      @mutex.lock
-    }.should raise_error MultiProcessing::ProcessError
+  describe "#owned?" do
+
+    context "initial state" do
+      it "returns false" do
+        @mutex.should_not be_owned
+      end
+    end
+
+    context "during locked by current thread" do
+      it "returns true" do
+        @mutex.lock
+        @mutex.should be_owned
+        @mutex.unlock
+        @mutex.synchronize do
+          @mutex.should be_owned
+        end
+      end
+    end
+    
+    context "during locked by another process" do
+
+      before do
+        fork do
+          @mutex.synchronize do
+            sleep 0.02
+          end
+        end
+        sleep 0.01
+      end
+
+      it "returns false" do
+        @mutex.should_not be_owned
+      end
+
+    end
+
+    context "after unlocked" do
+
+      before do
+        fork do
+          @mutex.synchronize do
+            sleep 0.01
+          end
+        end
+        sleep 0.02
+      end
+
+      it "returns false" do
+        @mutex.should_not be_owned
+      end
+
+    end
+
   end
 
-  it "#unlock raises ProcessError and does not unlock when unlocking by other processes" do
-    process = MultiProcessing::Process.new do
-      @mutex.lock
-      sleep 0.2
-      @mutex.unlock
+  describe "#unlock" do
+
+    context "when locked in same thread" do
+
+      before do
+        @mutex.lock
+      end
+
+      it "return itself" do
+        @mutex.unlock.should === @mutex
+      end
+
+      context "when another thread in same process is blocked" do
+
+        before do
+          @thread = Thread.new do
+            @mutex.lock
+            @mutex.unlock
+          end
+          sleep 0.01
+        end
+
+        it "makes the other blocked thread restart" do
+          @mutex.unlock
+          @thread.join(0.01).should_not be_nil
+        end
+
+      end
+
+      context "when another thread in another process is blocked" do
+
+        before do
+          @pid = fork do
+            @mutex.lock
+            @mutex.unlock
+          end
+          @detached_thread = Process.detach(@pid)
+          sleep 0.01
+        end
+
+        it "makes the other blocked thread restart" do
+          @mutex.unlock
+          timeout(1){ @detached_thread.value }.should be_success
+        end
+
+        after do
+          begin
+            Process.kill :TERM, @pid
+          rescue Errno::ESRCH
+          end
+        end
+
+      end
+
+    end
+
+
+    context "when locked in another thread but same process" do
+
+      before do
+        Thread.new do
+          @mutex.lock
+          sleep 0.02
+          @mutex.unlock
+        end
+        sleep 0.01
+      end
+
+      it "raise ProcessError" do
+        proc{ @mutex.unlock }.should raise_error MultiProcessing::ProcessError
+      end
+
+      it "is still locked" do
+        begin
+          @mutex.unlock
+        rescue MultiProcessing::ProcessError
+        end
+        @mutex.should be_locked
+      end
+
+    end
+
+    context "when locked in another process" do
+
+      before do
+        @pid = fork do
+          @mutex.lock
+          sleep 0.02
+          @mutex.unlock
+        end
+        sleep 0.01
+      end
+
+      it "raises ProcessError" do
+        proc{ @mutex.unlock }.should raise_error MultiProcessing::ProcessError
+      end
+
+      it "is still locked" do
+        begin
+          @mutex.unlock
+        rescue MultiProcessing::ProcessError
+        end
+        @mutex.should be_locked
+      end
+
+    end
+
+    context "when not locked" do
+      it "raises ProcessError" do
+        proc{ @mutex.unlock }.should raise_error MultiProcessing::ProcessError
+      end
+    end
+
+    context "forked on locking" do
+
+      context "forked process calls #unlock before forking process calls it" do
+        it "raises ProcessError at unlocking on forked process" do
+          @mutex.lock
+          pid = fork do
+            begin
+              @mutex.unlock
+            rescue MultiProcessing::ProcessError
+              exit! true # OK
+            end
+            exit! false # NG
+          end
+          sleep 0.01
+          @mutex.should be_locked
+          @mutex.unlock
+          timeout(1){ Process.detach(pid).value }.should be_success
+          @mutex.should_not be_locked
+        end
+      end
+
+      context "forking process calls #unlock before forked process calls it" do
+        it "raises ProcessError at unlocking on forked process" do
+          @mutex.lock
+          pid = fork do
+            begin
+              sleep 0.01
+              @mutex.unlock
+            rescue MultiProcessing::ProcessError
+              exit! true # OK
+            end
+            exit! false # NG
+          end
+          @mutex.unlock
+          timeout(1){ Process.detach(pid).value }.should be_success
+          @mutex.should_not be_locked
+        end
+      end
+
     end
-    sleep 0.1
-    proc{ @mutex.unlock }.should raise_error MultiProcessing::ProcessError
-    process.value.success?.should be_true
+
   end
 
-  it "#try_lock returns true if succeed, and lock correctly" do
-    @mutex.try_lock.should be_true
-    @mutex.locked?.should be_true
-    @mutex.unlock.should === @mutex
+
+  describe "#locked?" do
+
+    context "when not locked" do
+      it "returns false" do
+        @mutex.locked?.should be_false
+      end
+    end
+
+    context "when locked" do
+      it "returns true" do
+        fork{ @mutex.lock }
+        sleep 0.01
+        @mutex.locked?.should be_true
+      end
+    end
+
   end
 
-  it "#try_lock returns false if failed" do
-    process = MultiProcessing::Process.new do
-      @mutex.lock
-      sleep 0.2
+  describe "#try_lock" do
+
+    context "when not locked" do
+
+      it "returns true" do
+        @mutex.try_lock.should be_true
+      end
+
+      it "gets locked" do
+        fork{ @mutex.try_lock }
+        sleep 0.01
+        @mutex.should be_locked
+      end
+
+    end
+
+    context "when locked" do
+
+      before do
+        fork do
+          @mutex.lock
+          sleep 0.02
+        end
+        sleep 0.01
+      end
+
+      it "returns false" do
+        @mutex.try_lock.should be_false
+      end
+
+      it "is still locked" do
+        @mutex.try_lock
+        @mutex.should be_locked
+      end
+
     end
-    sleep 0.1
-    @mutex.try_lock.should be_false
   end
 
-  it "s sleep method unlocks and sleeps and re-locks itself" do
-    process = MultiProcessing::Process.new do
-      @mutex.lock
-      @mutex.sleep(0.2)
-      sleep 0.2
-      @mutex.unlock
-    end
-    sleep 0.1
-    @mutex.try_lock.should be_true
-    @mutex.unlock
-    sleep 0.2
-    @mutex.try_lock.should be_false
-    timeout(1){ process.value }.success?.should be_true
+  describe "#synchronize" do
+
+    context "synchronizing in current thread" do
+
+      it "returns a value returned by block" do
+        obj = Object.new
+        @mutex.synchronize {
+          obj
+        }.should === obj
+      end
+
+      context "processing block" do
+        it "is locked" do
+          @mutex.synchronize do
+            @mutex.should be_locked
+          end
+        end
+      end
+
+      context "after block" do
+        it "is unlocked" do
+          @mutex.synchronize{ :nop }
+          @mutex.should_not be_locked
+        end
+      end
+
+      context "raised in block" do
+        it "raised same error" do
+          proc{ @mutex.synchronize{ raise StandardError.new } }.should raise_error StandardError
+        end
+
+        it "is unlocked" do
+          begin
+            @mutex.synchronize{ raise StandardError.new }
+          rescue StandardError
+          end
+          @mutex.should_not be_locked
+        end
+      end 
+    end
+
+    context "synchronizing in other process" do
+
+      context "processing block" do
+        it "is locked" do
+          fork do
+            @mutex.synchronize do
+              sleep 0.02
+            end
+          end
+          sleep 0.01
+          @mutex.should be_locked
+        end
+      end
+
+      context "after block" do
+        it "is unlocked" do
+          fork do
+            @mutex.synchronize{ :nop }
+          end
+          sleep 0.01
+          @mutex.should_not be_locked
+        end
+      end
+
+    end
+
+    context "forked on locking" do
+
+      context "forked process exits synchronize block before forking process" do
+        it "raises ProcessError at unlocking on forked process" do
+          pid = nil
+          begin
+            @mutex.synchronize do
+              pid = fork
+              sleep 0.01 if pid # for forked process exiting sychronize block before forking process 
+            end
+          rescue MultiProcessing::ProcessError
+            if !pid
+              exit! true # OK
+            end
+          end
+          if !pid
+            exit! false # NG
+          end
+          @mutex.should_not be_locked
+          timeout(1){ Process.detach(pid).value }.should be_success
+          @mutex.should_not be_locked
+        end
+      end
+
+      context "forking process exits synchronize block before forked process" do
+        it "raises ProcessError at unlocking on forked process" do
+          pid = nil
+          begin
+            @mutex.synchronize do
+              pid = fork
+              sleep 0.01 if !pid # for forking process exiting sychronize block before forked process 
+            end
+          rescue MultiProcessing::ProcessError
+            if !pid
+              exit! true # OK
+            end
+          end
+          if !pid
+            exit! false # NG
+          end
+          @mutex.should_not be_locked
+          timeout(1){ Process.detach(pid).value }.should be_success
+          @mutex.should_not be_locked
+        end
+      end
+
+    end
+
   end
 
+  describe "#sleep" do
+
+    context "another thread waits the lock" do
+
+      before do
+        @pid = fork do
+          sleep 0.02
+          @mutex.lock
+          @mutex.unlock
+        end
+        @detached_thread = Process.detach(@pid)
+        sleep 0.01
+      end
+
+      it "unlocks before sleep" do
+        @mutex.synchronize do
+          @mutex.sleep 0.01
+        end
+        timeout(1){ @detached_thread.value }.should be_success
+      end
+
+      it "re-locks after sleep" do
+        @mutex.synchronize do
+          @mutex.sleep 0.01
+          @mutex.should be_locked
+        end
+      end
+
+      after do
+        begin
+          Process.kill :TERM, @pid
+        rescue Errno::ESRCH
+        end
+      end
+
+    end
+
+    context "error occurs in sleep" do
+      it "re-locks" do
+        @mutex.synchronize do
+          begin
+            timeout(0.01){ @mutex.sleep }
+          rescue Timeout::Error
+          end
+          @mutex.should be_locked
+        end
+      end
+    end
+
+  end
 
 end