multiprocessing 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in multiprocessing.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 clicube
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,130 @@
+MultiProcessing
+====================
+
+MultiProcessingはRubyにおいてプロセス間同期とプロセス間通信の機能を提供します（することを目指しています）．
+各クラスはRubyの標準添付ライブラリthreadで提供されているクラスのような動作をすることを目指しています．
+
+MultiProcessing includes classes for inter-process synchronization and communication. 
+The classes can be used like ones in ruby standard library for thread.
+
+現状で使用できるクラスは以下です．
+各クラスはMultiProcessingモジュールの下に作成されています．
+
+* Mutex
+* ConditionVariable
+* Semaphore
+* Queue
+* Process
+* ExternalObject
+
+また，IO.named\_pipe が追加されます
+
+いずれのクラスもプロセス間通信にパイプ（IO.pipe）を使用しています．
+また，複数のプロセスで1つの同期オブジェクトを共有するためにforkを使用する事を想定しているため，
+Unix系OSのみでのみ使用する事ができます．
+
+（Windowsするためには，名前付き共有セマフォなどの同期機能を使用する必要がありそうですね・・・）
+
+Mutex
+----------------
+
+標準添付ライブラリthreadのMutexと同様の使い方をします．
+
+    m = MultiProcessing::Mutex.new
+    fork do
+      m.synchronize do
+        # some critical work
+      end
+    end
+    m.synchronize do
+      # come critical work
+    end
+    Process.waitall
+
+lockした後unlockする前にforkすると（synchronize中でforkした場合も）そのクリティカルセクションは並列に動作してしまうので注意してください．
+（forkしたときに子プロセスでは子スレッドが全て殺されるため，別のスレッドでforkすれば問題ないと思います．）
+
+ConditionVariable
+----------------
+
+標準添付ライブラリthreadのConditionVariableと同じ使い方をします．
+
+      m = MultiProcessing::Mutex.new
+      cond = MultiProcessing::ConditionVariable.new
+      fork do
+        m.synchronize do
+          cond.wait(m)
+          # something to do
+        end
+      end
+      sleep 1
+      # on condition changed
+      cond.signal
+      Process.waitall
+
+Semaphore
+----------------
+
+Semaphoreは標準添付ライブラリに含まれていませんが作りました．
+
+    s = MultiProcessing::Semaphore.new 2
+
+コンストラクタにリソース量の初期値を与えてください．
+Pでリソースのロック，Vで解放をします．
+
+Pはlock，Vはunlockという名前のエイリアスが用意してあります．
+
+Queue
+----------------
+
+Queueも標準threadライブラリのQueueと同様の使い方をします．
+
+    q = MultiProcessing::Quque.new
+    fork do
+      q.push :nyan
+      q.close.join_thread
+    end
+    p q.pop
+
+プロセス間の通信にはパイプを使っています．Queue#pushをすると，パイプにデータを書き込むバックグラウンドスレッドが起動します（pythonのmultiprocessingを参考にしました）．
+プロセスが終了する際，バックグラウンドスレッドがパイプにデータを書き込み終わるまで待たないと，Queueが書き込みMutexをロックしたままになる場合があります．
+終了時は
+
+    q.close.join_thread
+
+として，書き込みスレッドの終了を待ってください．close後にキューにデータをpushすると例外が発生します．
+
+オブジェクトのシリアライズにMarshal.dumpを使用しているので，Marshal.dumpできないオブジェクトをpushできません．
+
+Process
+----------------
+
+標準のProcessモジュールは
+
+>Process がプロセスを表現するクラスではなく、プロセスに対する操作 をまとめたモジュールであることに注意してください。
+
+とのことなので，プロセスを表現するっぽいクラスを作ってみました．
+
+    p = MultiProcessing::Process.new { # something to do }
+    p.join
+
+とかできます．
+
+その他
+----------------
+
+### 関係ありそうなライブラリ
+
+* https://github.com/pmahoney/process_shared
+
+### TODO
+
+* ConditionVariable, ExternalObject, IO.named\_pipe のSpecを書く
+
+ライセンス
+----------------
+
+Author: clicube
+
+MIT License
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/multiprocessing.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/mutex')
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/conditionvariable')
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/semaphore')
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/queue')
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/process')
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/namedpipe')
+require File.expand_path(File.dirname(__FILE__) + '/multiprocessing/externalobject')
+

data/lib/multiprocessing/conditionvariable.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/processerror')
+require File.expand_path(File.dirname(__FILE__) + '/mutex')
+
+module MultiProcessing
+  class ConditionVariable
+
+    def initialize
+      @waiting_pout,@waiting_pin = IO.pipe
+      @signal_pout,@signal_pin = IO.pipe
+    end
+
+    def broadcast
+      while(signal); end
+    end
+
+    def signal
+      begin
+        @waiting_pout.read_nonblock 1
+        @signal_pin.syswrite 1
+        #@signal_pin.write 1
+        #@signal_pin.flush
+        return true
+      rescue Errno::EAGAIN
+        return nil
+      end
+    end
+
+    def wait(mutex)
+      raise MultiProcessing::ProcessError.new("mutex must be instance of MultiProcessing::Mutex") if mutex.class != MultiProcessing::Mutex
+      @waiting_pin.syswrite 1
+      #@waiting_pin.write 1
+      #@waiting_pin.flush
+      mutex.unlock
+      @signal_pout.readpartial 1
+      mutex.lock
+      self
+    end
+
+  end
+end
+
+if __FILE__ == $0
+
+  m = MultiProcessing::Mutex.new
+  cond = MultiProcessing::ConditionVariable.new
+  fork do
+    m.synchronize do
+      sleep 1
+      puts "waiting p1"
+      cond.wait(m)
+      puts "restarted p1"
+      sleep 1
+      puts "end p1"
+    end
+  end
+  fork do
+    m.synchronize do
+      sleep 1
+      puts "waiting p2"
+      cond.wait(m)
+      puts "restarted p2"
+      sleep 1
+      puts "end p2"
+    end
+  end
+  fork do
+    m.synchronize do
+      sleep 1
+      puts "waiting p3"
+      cond.wait(m)
+      puts "restarted p3"
+      sleep 1
+      puts "end p3"
+    end
+  end
+  sleep 5
+  puts "cond signaling"
+  cond.signal
+  sleep 3
+  puts "cond broadcasting"
+  cond.broadcast
+  Process.waitall
+end
+

data/lib/multiprocessing/externalobject.rb

@@ -0,0 +1,67 @@
+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
+
+    def initialize obj
+      @call_queue = Queue.new
+      @result_queue = Queue.new
+      @mutex = Mutex.new
+      @closed = false
+      @process = Process.new(obj){|obj| process_loop obj }
+    end
+
+    def process_loop obj
+      while true
+        *args = @call_queue.deq
+        result = nil
+        begin
+          result = obj.__send__ *args
+        rescue => e
+          result = e
+        end
+        @result_queue.enq result
+      end
+    end
+    private :process_loop
+
+    def send name, *args
+      @mutex.synchronize do
+        raise ProcessError.new("already closed") if @closed
+        @call_queue.enq [name, *args]
+        return @result_queue.deq
+      end
+    end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+        @process.kill :TERM
+      end
+    end
+
+    def method_missing *args
+      self.send *args
+    end
+
+  end
+end
+
+
+
+if $0 == __FILE__
+  obj = MultiProcessing::ExternalObject.new({})
+  obj[:cat] = :nyan
+  obj[:dog] = :wan
+  p obj
+
+  obj_proxy = MultiProcessing::ExternalObject.new(obj)
+  obj_proxy[:human] = :nyan
+  p obj_proxy
+
+  obj_proxy.close
+  obj.close
+end
+

data/lib/multiprocessing/mutex.rb

@@ -0,0 +1,138 @@
+require 'thread'
+require File.expand_path(File.dirname(__FILE__) + '/processerror')
+
+module MultiProcessing
+
+  class Mutex
+
+    def initialize
+      @pout,@pin = IO.pipe
+      @pin.syswrite 1
+      #@pin.write 1
+      #@pin.flush
+    end
+
+    def lock
+      unless @locking_pid == ::Process.pid && @locking_thread == Thread.current
+        @pout.readpartial 1
+        @locking_pid = ::Process.pid
+        @locking_thread = Thread.current
+      else
+        raise ProcessError.new "mutex was tried locking twice"
+      end
+      self
+    end
+
+    def locked?
+      begin
+        @pout.read_nonblock 1
+        @pin.syswrite 1
+        #@pin.write 1
+        #@pin.flush
+        return false
+      rescue Errno::EAGAIN => e
+        return true
+      end
+    end
+
+    def try_lock
+      begin
+        @pout.read_nonblock 1
+        @locking_thread = Thread.current
+        @locking_pid = ::Process.pid
+        return true
+      rescue Errno::EAGAIN
+        return false
+      end
+    end
+
+    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
+        @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}")
+      end
+    end
+
+    def synchronize
+      lock
+      begin
+        ret = yield
+      ensure
+        unlock if locked?
+      end
+      return ret
+    end
+
+    def sleep timeout=nil
+      unlock
+      timeout ? Kernel.sleep(timeout) : Kernel.sleep
+      lock
+    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/namedpipe.rb

@@ -0,0 +1,25 @@
+class IO
+
+  def self.named_pipe(path, create=true)
+    if !File.exist?(path)&& create
+      system "mkfifo #{path}"
+    end
+    raise IOError.new("it is not named pipe") if File.ftype(path) != "fifo"
+    pout = File.open(path, "r+")
+    pin = File.open(path, "w+")
+    return pout, pin
+  end
+
+end
+
+if __FILE__ == $0
+  pout, pin = IO.named_pipe("nyan")
+  3.times do
+    pin.puts :nyan
+  end
+  pin.flush
+  3.times do
+    puts pout.gets
+  end
+  File.delete "nyan"
+end

data/lib/multiprocessing/process.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/processerror')
+
+module MultiProcessing
+  class Process
+
+    attr_reader :pid
+
+    def initialize *args
+      raise ProcessError.new "mulst be called with a block" unless block_given?
+      @pid = fork do
+        yield *args
+        exit
+      end
+    end
+
+    def value
+      th = ::Process.detach(@pid)
+      th.value
+    end
+
+    def join timeout=nil
+      th = ::Process.detach(@pid)
+      th.join timeout
+    end
+
+    def kill signal
+      ::Process.kill signal, @pid
+    end
+
+  end
+end
+
+if $0 == __FILE__
+  include MultiProcessing
+
+  p = MultiProcessing::Process.new("nyan") do |str|
+    puts str
+    sleep 1
+  end
+  p p
+  p.join
+end
+

data/lib/multiprocessing/processerror.rb

@@ -0,0 +1,4 @@
+module MultiProcessing
+  class ProcessError < StandardError; end
+end
+

data/lib/multiprocessing/queue.rb

@@ -0,0 +1,134 @@
+require 'thread'
+require File.expand_path(File.dirname(__FILE__) + '/mutex')
+require File.expand_path(File.dirname(__FILE__) + '/semaphore')
+
+module MultiProcessing
+
+  class QueueError < StandardError; end
+
+  class Queue
+
+    def initialize
+      @count = Semaphore.new 0
+      @write_mutex = Mutex.new
+      @read_mutex = Mutex.new
+      @len_pout, @len_pin = IO.pipe
+      @data_pout, @data_pin = IO.pipe
+      @enq_queue = ::Queue.new
+      @queue_zero_cond = ::ConditionVariable.new
+      @closed = false
+    end
+
+    def clear
+      begin
+        loop do
+          @read_mutex.synchronize do
+            self.deq(true)
+          end
+        end
+      rescue Errno::EAGAIN
+      end
+    end
+
+    def empty?
+      length == 0
+    end
+
+    def length
+      return @count.value
+    end
+    alias :size :length
+    alias :count :length
+
+    def deq non_block=false
+      data = ""
+      @read_mutex.synchronize do
+        unless non_block
+          @count.wait
+        else
+          @count.trywait
+        end
+
+        buf = ""
+        len = nil
+        begin
+          c = @len_pout.readpartial 1
+          if c == "\n"
+            len = buf.to_i
+          else
+            buf << c
+          end
+        end while !len
+
+        begin
+          buf = @data_pout.readpartial len
+          len -= buf.bytesize
+          data << buf
+        end while len > 0
+      end
+      return Marshal.load(data)
+
+    end
+    alias :pop :deq
+    alias :shift :deq
+
+    def enq obj
+      raise QueueError.new("already closed") if @closed
+      unless(@enq_thread && @enq_thread.alive?)
+        @enq_queue.clear
+        @enq_thread = Thread.new &method(:enq_loop)
+      end
+      @enq_queue.enq(Marshal.dump(obj))
+      Thread.pass
+    end
+    alias :push :enq
+    alias :unshift :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
+          @data_pin.flush
+        end
+        Thread.exit if @closed && @enq_queue.length == 0
+      end
+    end
+    private :enq_loop
+
+    def close
+      @closed = true
+      self
+    end
+
+    def join_thread
+      raise QueueError.new("must be closed before join_thread") unless @closed
+      if @enq_thread && @enq_thread.alive?
+        @enq_thread.join
+      end
+    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

data/lib/multiprocessing/semaphore.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/mutex')
+require File.expand_path(File.dirname(__FILE__) + '/conditionvariable')
+
+module MultiProcessing
+  class Semaphore
+
+    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
+        end
+      rescue Errno::EAGAIN
+        @count_pin.syswrite "1"*n
+        #@count_pin.write "1"*n
+        #@count_pin.flush
+      end
+      return n
+    end
+    private :count_nonsynchronize
+
+    def count
+      @mutex.synchronize do
+        count_nonsynchronize
+      end
+    end
+    alias :value :count
+
+    def P
+      @mutex.synchronize do
+        while count_nonsynchronize == 0
+          @cond.wait(@mutex)
+        end
+        @count_pout.readpartial 1
+      end
+      return self
+    end
+    alias :lock :P
+    alias :wait :P
+
+    def try_P
+      begin
+        @mutex.synchronize do
+          @count_pout.read_nonblock 1
+        end
+        return true
+      rescue Errno::EAGAIN
+        return false
+      end
+    end
+    alias :try_lock :try_P
+    alias :try_wait :try_P
+
+    def V
+      @mutex.synchronize do
+        @count_pin.syswrite 1
+        #@count_pin.write 1
+        #@count_pin.flush
+        @cond.signal
+      end
+      return self
+    end
+    alias :signal :V
+    alias :unlock :V
+    alias :post :V
+
+    def synchronize
+      self.P
+      begin
+        yield
+      ensure
+        self.V
+      end
+    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

@@ -0,0 +1,3 @@
+module MultiProcessing
+  VERSION = "0.0.1"
+end

data/multiprocessing.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multiprocessing/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "multiprocessing"
+  gem.version       = MultiProcessing::VERSION
+  gem.authors       = ["clicube"]
+  gem.email         = ["clicube@gmail.com"]
+  gem.description   = %q{Classes for inter-process synchronization/communication like thread library in ruby standard library}
+  gem.summary       = %q{Inter-process synchronization/communication}
+  gem.homepage      = "https://github.com/clicube/multiprocessing"
+
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/multiprocessing/mutex_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+require 'timeout'
+
+describe MultiProcessing::Mutex do
+
+  before do
+    @mutex = MultiProcessing::Mutex.new
+  end
+
+  it "#lock returns itself" do
+    @mutex.lock.should === @mutex
+  end
+
+  it "#unlock returns itself if locked" do
+    @mutex.lock
+    @mutex.unlock.should === @mutex
+  end
+
+  it "#unlock raises ProcessError if not locked" do
+    proc{ @mutex.unlock }.should raise_error MultiProcessing::ProcessError
+  end
+
+  it "#locked? returns false if not locked" do
+    @mutex.locked?.should be_false
+  end
+
+  it "#locked? returns true if locked" do
+    @mutex.lock
+    @mutex.locked?.should be_true
+  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
+
+  it "#synchronize can synchronize with other process" do
+    process = MultiProcessing::Process.new do
+      sleep 0.1
+      @mutex.synchronize do
+        :nop
+      end
+    end
+    @mutex.synchronize do
+      sleep 0.2
+      process.join(0).should be_nil
+    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
+  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
+    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
+  end
+
+  it "#try_lock returns false if failed" do
+    process = MultiProcessing::Process.new do
+      @mutex.lock
+      sleep 0.2
+    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
+  end
+
+
+end
+

data/spec/multiprocessing/process_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+describe MultiProcessing::Process do
+
+  it "can be created with block" do
+    MultiProcessing::Process.new{:nop}.should be_instance_of MultiProcessing::Process
+  end
+
+  it "cannot be created without block" do
+    proc{ MultiProcessing::Process.new }.should raise_error MultiProcessing::ProcessError
+  end
+
+  it "returns pid" do
+    MultiProcessing::Process.new{ :nop }.pid.should be_instance_of Fixnum
+  end
+
+  it "joins process" do
+    p = MultiProcessing::Process.new { :nop }
+    p.join.should_not be_nil
+  end
+
+  it "joins process with timeout" do
+    p = MultiProcessing::Process.new { :nop }
+    p.join(1).should_not be_nil
+    p = MultiProcessing::Process.new { sleep 1 }
+    p.join(0).should be_nil
+  end
+
+  it "returns value" do
+    p = MultiProcessing::Process.new { :nop }
+    p.value.should be_instance_of ::Process::Status
+    p = MultiProcessing::Process.new { :nop }
+    p.value.success?.should be_true
+    p = MultiProcessing::Process.new { exit 1 }
+    p.value.success?.should be_false
+  end
+
+  it "returns nil when process does not exist" do
+    p = MultiProcessing::Process.new { :nop }
+    p.join
+    p.value.should be_nil
+  end
+
+  it "can be kill" do
+    p = MultiProcessing::Process.new { sleep 1 }
+    p.kill :TERM
+    p.join(0).should be_nil
+  end
+
+end
+

data/spec/multiprocessing/queue_spec.rb

@@ -0,0 +1,140 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+require 'timeout'
+
+describe MultiProcessing::Queue do
+
+  it "can be created" do
+    MultiProcessing::Queue.new.should be_instance_of MultiProcessing::Queue
+  end
+
+  it "#length returns its length" do
+    queue = MultiProcessing::Queue.new
+    queue.length.should == 0
+    queue.push :a
+    sleep 0.1 # wait for enqueue
+    queue.length.should == 1
+    queue.push :b
+    sleep 0.1 # wait for enqueue
+    queue.length.should == 2
+    queue.pop
+    queue.length.should == 1
+    queue.pop
+    queue.length.should == 0
+  end
+
+  it "can pass object across processes" do
+    queue = MultiProcessing::Queue.new
+    data_list = [:nyan, [:cat, :dog]]
+    fork do
+      data_list.each do |data|
+        queue.push data
+      end  
+      sleep 0.1
+    end
+    result = []
+    timeout(1) do
+      data_list.length.times do
+        result << queue.pop
+      end
+    end
+    result.should == data_list
+  end
+
+  it "can pass large objects across processes" do
+    queue1 = MultiProcessing::Queue.new
+    queue2 = MultiProcessing::Queue.new
+    data = "a" * 1024 * 1024 * 16 # 16MB
+    timeout_sec = 10
+    # process to echo queue1 -> queue 2
+    process = MultiProcessing::Process.new do
+      echo_queue = ::Queue.new
+      Thread.new do
+        loop do
+          echo_queue.push  queue1.pop
+        end
+      end
+      Thread.new do
+        loop do
+          queue2.push echo_queue.pop
+        end
+      end
+      sleep timeout_sec + 1
+    end
+    result = nil
+    timeout(timeout_sec) do
+      queue1.push data
+      result = queue2.pop
+    end
+    process.kill :TERM
+    result.should == data
+  end
+
+  it "can pass as many as objects across processes" do
+    queue1 = MultiProcessing::Queue.new
+    queue2 = MultiProcessing::Queue.new
+    data_list = Array.new(1000){|i| "a"*1000 }
+    timeout_sec = 10
+    # process to echo queue1 -> queue 2
+    process = MultiProcessing::Process.new do
+      echo_queue = ::Queue.new
+      Thread.new do
+        loop do
+          echo_queue.push  queue1.pop
+        end
+      end
+      Thread.new do
+        loop do
+          queue2.push echo_queue.pop
+        end
+      end
+      sleep timeout_sec + 1
+    end
+    result = []
+    timeout(timeout_sec) do
+      Thread.new do
+        data_list.each do |data|
+          queue1.push data
+        end
+      end
+      data_list.length.times do
+        result << queue2.pop
+      end
+    end
+    process.kill :TERM
+    result.should == data_list
+  end
+
+  it "can be closed and joined enqueue thread before enqueue" do
+    queue = MultiProcessing::Queue.new
+    thread = Thread.new { queue.close.join_thread }
+    thread.join.should_not be_nil
+  end
+
+  it "can be closed and joined enqueue thread after enqueue" do
+    queue = MultiProcessing::Queue.new
+    data_list = Array.new(1000){|i| "a"*1000 }
+    timeout_sec = 10
+    process = MultiProcessing::Process.new do
+      data_list.length.times do
+        queue.pop
+      end
+      sleep timeout_sec + 1
+    end
+    th = Thread.new do
+      data_list.each do |data|
+        queue.push data
+      end
+      queue.close.join_thread
+    end
+    th.join(timeout_sec).should_not be_nil
+    process.kill(:TERM)
+  end
+
+  it "cannot be joined before being closed" do
+    queue = MultiProcessing::Queue.new
+    proc{ queue.join_thread }.should raise_error MultiProcessing::QueueError
+  end
+
+end
+
+

data/spec/multiprocessing/semaphore_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+require 'timeout'
+
+describe MultiProcessing::Semaphore, "initialized with 1" do
+
+  before do
+    @semaphore = MultiProcessing::Semaphore.new 1
+  end
+
+  it "#P return itself" do
+    @semaphore.lock.should === @semaphore
+  end
+
+  it "#V returns itself" do
+    @semaphore.lock
+    @semaphore.unlock.should === @semaphore
+  end
+
+
+  it "#count returns number of remaining resource" do
+    @semaphore.count.should == 1
+    @semaphore.P
+    @semaphore.count.should == 0
+    @semaphore.V
+    @semaphore.V
+    @semaphore.count.should == 2
+  end
+
+  it "#try_P returns true if succeed, and P correctly" do
+    @semaphore.try_P.should be_true
+    @semaphore.count.should == 0
+  end
+
+  it "#try_P returns false if failed" do
+    process = MultiProcessing::Process.new do
+      @semaphore.P
+      sleep 0.2
+    end
+    sleep 0.1
+    @semaphore.try_P.should be_false
+  end
+
+  it "#synchronize can lock resource and yield and free" do
+    tmp = nil
+    @semaphore.synchronize do
+      @semaphore.count.should == 0
+      tmp = true
+    end
+    tmp.should be_true
+    @semaphore.count.should == 1
+  end
+  
+
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'multiprocessing'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: multiprocessing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- clicube
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-13 00:00:00.000000000 Z
+dependencies: []
+description: Classes for inter-process synchronization/communication like thread library
+  in ruby standard library
+email:
+- clicube@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/multiprocessing.rb
+- lib/multiprocessing/conditionvariable.rb
+- lib/multiprocessing/externalobject.rb
+- lib/multiprocessing/mutex.rb
+- lib/multiprocessing/namedpipe.rb
+- lib/multiprocessing/process.rb
+- lib/multiprocessing/processerror.rb
+- lib/multiprocessing/queue.rb
+- lib/multiprocessing/semaphore.rb
+- lib/multiprocessing/version.rb
+- multiprocessing.gemspec
+- spec/multiprocessing/mutex_spec.rb
+- spec/multiprocessing/process_spec.rb
+- spec/multiprocessing/queue_spec.rb
+- spec/multiprocessing/semaphore_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/clicube/multiprocessing
+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.24
+signing_key: 
+specification_version: 3
+summary: Inter-process synchronization/communication
+test_files:
+- spec/multiprocessing/mutex_spec.rb
+- spec/multiprocessing/process_spec.rb
+- spec/multiprocessing/queue_spec.rb
+- spec/multiprocessing/semaphore_spec.rb
+- spec/spec_helper.rb
+has_rdoc: