multiprocessing 0.0.1 → 0.0.2

data/lib/multiprocessing/externalobject.rb

@@ -1,6 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/mutex')
 require File.expand_path(File.dirname(__FILE__) + '/queue')
-require File.expand_path(File.dirname(__FILE__) + '/process')
 
 module MultiProcessing
   class ExternalObject < BasicObject
@@ -10,7 +9,7 @@ module MultiProcessing
       @result_queue = Queue.new
       @mutex = Mutex.new
       @closed = false
-      @process = Process.new(obj){|obj| process_loop obj }
+      @pid = fork{|obj| process_loop obj }
     end
 
     def process_loop obj
@@ -38,7 +37,10 @@ module MultiProcessing
     def close
       @mutex.synchronize do
         @closed = true
-        @process.kill :TERM
+        begin
+          Process.kill :TERM, @pid
+        rescue
+        end
       end
     end
 

data/lib/multiprocessing/mutex.rb

@@ -3,136 +3,166 @@ require File.expand_path(File.dirname(__FILE__) + '/processerror')
 
 module MultiProcessing
 
+  ##
+  #
+  # Process version of Mutex.
+  # This can be used like ::Mutex in Ruby standard library.
+  #
+  # Do not fork in #synchronize block or before #unlock.
+  # Forking and forked process run in parallel.
+  #
+  # Note that Mutex uses 1 pipe.
+  #
+  # @example
+  #   require 'multiprocessing'
+  #   
+  #   mutex = MultiProcessing::Mutex.new
+  #   3.times do
+  #     fork do
+  #       mutex.synchronize do
+  #         # critical section
+  #         puts Process.pid
+  #         sleep 1
+  #       end
+  #     end
+  #   end
+  #   Process.waitall
+  #   # => prints 3 pids of forked process in 1 sec interval
+  # 
   class Mutex
 
     def initialize
       @pout,@pin = IO.pipe
       @pin.syswrite 1
-      #@pin.write 1
-      #@pin.flush
     end
 
+    ##
+    #
+    # Attempts to grab the lock and waits if it isn't available.
+    # Raises ProcessError if mutex was locked by the current thread.
+    #
+    # @return [Mutex] self
+    # @raise [ProcessError]
+    #
     def lock
-      unless @locking_pid == ::Process.pid && @locking_thread == Thread.current
+      MultiProcessing.try_handle_interrupt(RuntimeError => :on_blocking) do
+        raise ProcessError.new "mutex was tried locking twice" if owned?
         @pout.readpartial 1
-        @locking_pid = ::Process.pid
+        @locking_pid = Process.pid
         @locking_thread = Thread.current
-      else
-        raise ProcessError.new "mutex was tried locking twice"
+        self
       end
-      self
     end
 
+    ##
+    #
+    # Returns true if this lock is currently held by some thread.
+    #
+    # @return [Boolean]
+    #
     def locked?
-      begin
-        @pout.read_nonblock 1
-        @pin.syswrite 1
-        #@pin.write 1
-        #@pin.flush
-        return false
-      rescue Errno::EAGAIN => e
-        return true
+      MultiProcessing.try_handle_interrupt(RuntimeError => :never) do
+        begin
+          @pout.read_nonblock 1
+          @pin.syswrite 1
+          false
+        rescue Errno::EAGAIN => e
+          true
+        end
       end
     end
 
+    ##
+    #
+    # Attempts to obtain the lock and returns immediately.
+    # Returns true if the lock was granted.
+    #
+    # @return [Boolean]
+    #
     def try_lock
-      begin
-        @pout.read_nonblock 1
-        @locking_thread = Thread.current
-        @locking_pid = ::Process.pid
-        return true
-      rescue Errno::EAGAIN
-        return false
+      MultiProcessing.try_handle_interrupt(RuntimeError => :never) do
+        begin
+          @pout.read_nonblock 1
+          @locking_thread = Thread.current
+          @locking_pid = Process.pid
+          return true
+        rescue Errno::EAGAIN
+          return false
+        end
       end
     end
 
+    ##
+    #
+    # Returns true if the lock is locked by current thread on current process
+    #
+    # @return [Boolean]
+    #
+    def owned?
+      @locking_pid == Process.pid && @locking_thread == Thread.current
+    end
+
+    ##
+    #
+    # Releases the lock.
+    # Raises ProcessError if mutex wasn't locked by the current thread.
+    #
+    # @note An order of restarting thread is indefinite.
+    #
+    # @return [Mutex] self
+    # @raise [ProcessError]
+    #
     def unlock
-      raise ProcessError.new("Attempt to unlock a mutex which is not locked") if !locked?
-      if @locking_pid == ::Process.pid && @locking_thread == Thread.current
-        @pin.syswrite 1
-        #@pin.write 1
-        #@pin.flush
+      MultiProcessing.try_handle_interrupt(RuntimeError => :never) do
+        raise ProcessError.new("Attempt to unlock a mutex which is not locked") unless locked?
+        raise ProcessError.new("Mutex was tried being unlocked in process/thread which didn't lock this mutex: locking[pid:#{(@locking_pid||'nil')}, thread:#{@locking_thread.inspect}] current[pid:#{Process.pid}, thread:#{Thread.current.inspect}]") unless owned?
         @locking_pid = nil
         @locking_thread = nil
-        return self
-      else
-        #return nil
-        raise ProcessError.new("mutex was tried unlocking in process/thread which didn't lock this mutex #{@locking_pid} #{::Process.pid}")
+        @pin.syswrite 1
+        self
       end
     end
 
+    ##
+    #
+    # Obtains a lock, runs the block, and releases the lock when the block completes.
+    #
+    # @return [Object] returned value of block
+    #
     def synchronize
-      lock
-      begin
-        ret = yield
-      ensure
-        unlock if locked?
+      MultiProcessing.try_handle_interrupt(RuntimeError => :on_blocking) do
+        lock
+        ret = nil
+        begin
+          MultiProcessing.try_handle_interrupt(RuntimeError => :immediate) do
+            ret = yield
+          end
+        ensure
+          unlock
+        end
+        ret
       end
-      return ret
     end
 
+    ##
+    #
+    # Releases the lock and sleeps timeout seconds if it is given and non-nil or forever.
+    # Raises ProcessError if mutex wasn't locked by the current thread.
+    #
+    # @param [Numeric,nil] timeout
+    # @raise [ProcessError]
+    #
     def sleep timeout=nil
-      unlock
-      timeout ? Kernel.sleep(timeout) : Kernel.sleep
-      lock
+      MultiProcessing.try_handle_interrupt(RuntimeError => :on_blocking) do
+        unlock
+        begin
+          timeout ? Kernel.sleep(timeout) : Kernel.sleep
+        ensure
+          lock
+        end
+      end
     end
-  end
-end
 
-if __FILE__ == $0
-
-  puts "use lock and unlock"
-  m = MultiProcessing::Mutex.new
-  puts "locking mutex in main process(pid:#{Process.pid})"
-  m.lock
-  puts "locked mutex in main process(pid:#{Process.pid})"
-  pid1 = fork do
-    puts "locking mutex in child process(pid:#{Process.pid})"
-    m.lock
-    puts "locked mutex in child process(pid:#{Process.pid})"
-    sleep 1
-    puts "unlocking mutex in child process(pid:#{Process.pid})"
-    m.unlock
-    puts "unlocked mutex in child process(pid:#{Process.pid})"
-    exit
-  end
-  pid2 = fork do
-    puts "locking mutex in child process(pid:#{Process.pid})"
-    m.lock
-    puts "locked mutex in child process(pid:#{Process.pid})"
-    sleep 1
-    puts "unlocking mutex in child process(pid:#{Process.pid})"
-    m.unlock
-    puts "unlocked mutex in child process(pid:#{Process.pid})"
-    exit
-  end
-
-  sleep 1
-  puts "unlocking mutex in main process(pid:#{Process.pid})"
-  m.unlock
-  puts "unlocked mutex in main process(pid:#{Process.pid})"
-  Process.waitall
-
-
-  puts ""
-  puts "use synchrnize"
-  m = MultiProcessing::Mutex.new
-  if pid = fork
-    puts "synchronizing in main process(pid:#{Process.pid})"
-    m.synchronize do
-      puts "something to do in main process(pid:#{Process.pid})"
-      sleep 2
-      puts "end something in main process(pid:#{Process.pid})"
-    end
-    Process.waitpid pid
-  else
-    sleep 1
-    puts "synchronizing in child process(pid:#{Process.pid})"
-    m.synchronize do
-      puts "something to do in child process(pid:#{Process.pid})"
-      sleep 1
-      puts "end something in child process(pid:#{Process.pid})"
-    end
   end
 end
 

data/lib/multiprocessing/processerror.rb

@@ -1,4 +1,9 @@
 module MultiProcessing
+
+  ##
+  #
+  # Raised when an invalid operation is attempted on process.
+  #
   class ProcessError < StandardError; end
 end
 

data/lib/multiprocessing/queue.rb

@@ -4,8 +4,38 @@ require File.expand_path(File.dirname(__FILE__) + '/semaphore')
 
 module MultiProcessing
 
+  ##
+  #
+  # Raised when an invalid operation is attempted on a queue.
+  #
   class QueueError < StandardError; end
 
+  ##
+  #
+  # This class provides a way to synchronize communication between process.
+  #
+  # Queue uses pipes to communicate with other processes.
+  # {Queue#push} starts background thread to write data to the pipe.
+  # Avoiding to exit process before writing to the pipe, use {#close} and {#join_thread}.
+  #
+  #   q.close.join_thread
+  #
+  # {#join_thread} waits until all data is written to the pipe.
+  #
+  # Note that Queue uses 8 pipes ( 2 pipes, 2 Mutex, 1 Semaphore).
+  #
+  # @example
+  #   require 'multiprocessing'
+  #
+  #   q = MultiProcessing::Queue.new
+  #   fork do
+  #     q.push :nyan
+  #     q.push :wan
+  #     q.close.join_thread
+  #   end
+  #   q.pop # => :nyan
+  #   q.pop # => :wan
+  #
   class Queue
 
     def initialize
@@ -19,34 +49,62 @@ module MultiProcessing
       @closed = false
     end
 
+    ##
+    #
+    # Removes all objects from the queue
+    #
+    # @return [Queue] self
+    #
     def clear
       begin
         loop do
-          @read_mutex.synchronize do
-            self.deq(true)
-          end
+          self.deq(true)
         end
-      rescue Errno::EAGAIN
+      rescue QueueError
       end
+      self
     end
 
+    ##
+    #
+    # Returns true if the queue is empty.
+    #
+    # @return [Boolean]
+    #
     def empty?
       length == 0
     end
 
+    ##
+    #
+    # Returns number of items in the queue.
+    #
+    # @return [Fixnum]
+    #
     def length
-      return @count.value
+      @count.value
     end
     alias :size :length
     alias :count :length
 
+    ##
+    #
+    # Retrieves data from the queue.
+    # If the queue is empty, the calling thread is suspended until data is pushed onto the queue.
+    # If non_block is true, thread isn't suspended, and exception is raised.
+    #
+    # @param [Boolean] non_block
+    # @return [Object]
+    #
     def deq non_block=false
       data = ""
       @read_mutex.synchronize do
         unless non_block
           @count.wait
         else
-          @count.trywait
+          unless @count.try_wait
+            raise QueueError.new("Queue is empty")
+          end
         end
 
         buf = ""
@@ -72,6 +130,17 @@ module MultiProcessing
     alias :pop :deq
     alias :shift :deq
 
+    ##
+    #
+    # Pushes object to the queue.
+    # Raise QueueError if the queue is already closed.
+    # Raise TypeError if the object passed cannot be dumped with Marshal.
+    #
+    # @param [Object] obj
+    # @return [Queue] self
+    # @raise [QueueError] the queue is already closed.
+    # @raise [TypeError] object cannot be dumped with Marshal.
+    # 
     def enq obj
       raise QueueError.new("already closed") if @closed
       unless(@enq_thread && @enq_thread.alive?)
@@ -79,16 +148,16 @@ module MultiProcessing
         @enq_thread = Thread.new &method(:enq_loop)
       end
       @enq_queue.enq(Marshal.dump(obj))
-      Thread.pass
+      @count.post
+      self
     end
     alias :push :enq
-    alias :unshift :enq
+    alias :<< :enq
 
     def enq_loop
       loop do
         data = @enq_queue.deq
         @write_mutex.synchronize do
-          @count.post
           @len_pin.write data.length.to_s + "\n"
           @len_pin.flush
           @data_pin.write data
@@ -99,36 +168,35 @@ module MultiProcessing
     end
     private :enq_loop
 
+    ##
+    #
+    # Close the queue.
+    # After closing, the queue cannot be pushed any object.
+    # {#join_thread} can call only after closing the queue.
+    #
+    # @return [Queue] self
+    #
     def close
       @closed = true
       self
     end
 
+    ##
+    #
+    # Waits until all data is written to the communication pipe.
+    # This can call only after closing({#close}) queue.
+    #
+    # @return [Queue] self
+    # @raise [QueueError] the queue is not closed.
+    # 
     def join_thread
       raise QueueError.new("must be closed before join_thread") unless @closed
       if @enq_thread && @enq_thread.alive?
         @enq_thread.join
       end
+      self
     end
 
   end
 end
 
-if __FILE__ == $0
-
-  q = MultiProcessing::Queue.new
-
-  q.push(0)
-  sleep 1
-  pid = fork
-  if !pid
-    q.push("111")
-    q.push({:a=>"a",:b=>123})
-    p q.pop
-    exit(0)
-  end
-  p q.pop
-  p q.pop
-  Process.waitall
-
-end