shoesgem 0.1424.0

data/shoes/ruby/lib/thread.rb

@@ -0,0 +1,367 @@
+#
+#		thread.rb - thread support classes
+#			by Yukihiro Matsumoto <matz@netlab.co.jp>
+#
+# Copyright (C) 2001  Yukihiro Matsumoto
+# Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright (C) 2000  Information-technology Promotion Agency, Japan
+#
+
+unless defined? Thread
+  raise "Thread not available for this ruby interpreter"
+end
+
+unless defined? ThreadError
+  class ThreadError < StandardError
+  end
+end
+
+if $DEBUG
+  Thread.abort_on_exception = true
+end
+
+# 
+# ConditionVariable objects augment class Mutex. Using condition variables,
+# it is possible to suspend while in the middle of a critical section until a
+# resource becomes available.
+#
+# Example:
+#
+#   require 'thread'
+#
+#   mutex = Mutex.new
+#   resource = ConditionVariable.new
+#   
+#   a = Thread.new {
+#     mutex.synchronize {
+#       # Thread 'a' now needs the resource
+#       resource.wait(mutex)
+#       # 'a' can now have the resource
+#     }
+#   }
+#   
+#   b = Thread.new {
+#     mutex.synchronize {
+#       # Thread 'b' has finished using the resource
+#       resource.signal
+#     }
+#   }
+#
+class ConditionVariable
+  #
+  # Creates a new ConditionVariable
+  #
+  def initialize
+    @waiters = []
+    @waiters_mutex = Mutex.new
+  end
+  
+  #
+  # Releases the lock held in +mutex+ and waits; reacquires the lock on wakeup.
+  #
+  def wait(mutex)
+    begin
+      # TODO: mutex should not be used
+      @waiters_mutex.synchronize do
+        @waiters.push(Thread.current)
+      end
+      mutex.sleep
+    end
+  end
+  
+  #
+  # Wakes up the first thread in line waiting for this lock.
+  #
+  def signal
+    begin
+      t = @waiters_mutex.synchronize { @waiters.shift }
+      t.run if t
+    rescue ThreadError
+      retry
+    end
+  end
+    
+  #
+  # Wakes up all threads waiting for this lock.
+  #
+  def broadcast
+    # TODO: imcomplete
+    waiters0 = nil
+    @waiters_mutex.synchronize do
+      waiters0 = @waiters.dup
+      @waiters.clear
+    end
+    for t in waiters0
+      begin
+	t.run
+      rescue ThreadError
+      end
+    end
+  end
+end
+
+#
+# This class provides a way to synchronize communication between threads.
+#
+# Example:
+#
+#   require 'thread'
+#   
+#   queue = Queue.new
+#   
+#   producer = Thread.new do
+#     5.times do |i|
+#       sleep rand(i) # simulate expense
+#       queue << i
+#       puts "#{i} produced"
+#     end
+#   end
+#   
+#   consumer = Thread.new do
+#     5.times do |i|
+#       value = queue.pop
+#       sleep rand(i/2) # simulate expense
+#       puts "consumed #{value}"
+#     end
+#   end
+#   
+#   consumer.join
+#
+class Queue
+  #
+  # Creates a new queue.
+  #
+  def initialize
+    @que = []
+    @waiting = []
+    @que.taint		# enable tainted comunication
+    @waiting.taint
+    self.taint
+    @mutex = Mutex.new
+  end
+
+  #
+  # Pushes +obj+ to the queue.
+  #
+  def push(obj)
+    t = nil
+    @mutex.synchronize{
+      @que.push obj
+      begin
+        t = @waiting.shift
+        t.wakeup if t
+      rescue ThreadError
+        retry
+      end
+    }
+    begin
+      t.run if t
+    rescue ThreadError
+    end
+  end
+
+  #
+  # Alias of push
+  #
+  alias << push
+
+  #
+  # Alias of push
+  #
+  alias enq push
+
+  #
+  # 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, the
+  # thread isn't suspended, and an exception is raised.
+  #
+  def pop(non_block=false)
+    while true
+      @mutex.synchronize{
+        if @que.empty?
+          raise ThreadError, "queue empty" if non_block
+          @waiting.push Thread.current
+          @mutex.sleep
+        else
+          return @que.shift
+        end
+      }
+    end
+  end
+
+  #
+  # Alias of pop
+  #
+  alias shift pop
+
+  #
+  # Alias of pop
+  #
+  alias deq pop
+
+  #
+  # Returns +true+ if the queue is empty.
+  #
+  def empty?
+    @que.empty?
+  end
+
+  #
+  # Removes all objects from the queue.
+  #
+  def clear
+    @que.clear
+  end
+
+  #
+  # Returns the length of the queue.
+  #
+  def length
+    @que.length
+  end
+
+  #
+  # Alias of length.
+  #
+  alias size length
+
+  #
+  # Returns the number of threads waiting on the queue.
+  #
+  def num_waiting
+    @waiting.size
+  end
+end
+
+#
+# This class represents queues of specified size capacity.  The push operation
+# may be blocked if the capacity is full.
+#
+# See Queue for an example of how a SizedQueue works.
+#
+class SizedQueue < Queue
+  #
+  # Creates a fixed-length queue with a maximum size of +max+.
+  #
+  def initialize(max)
+    raise ArgumentError, "queue size must be positive" unless max > 0
+    @max = max
+    @queue_wait = []
+    @queue_wait.taint		# enable tainted comunication
+    super()
+  end
+
+  #
+  # Returns the maximum size of the queue.
+  #
+  def max
+    @max
+  end
+
+  #
+  # Sets the maximum size of the queue.
+  #
+  def max=(max)
+    diff = nil
+    @mutex.synchronize {
+      if max <= @max
+        @max = max
+      else
+        diff = max - @max
+        @max = max
+      end
+    }
+    if diff
+      diff.times do
+	begin
+	  t = @queue_wait.shift
+	  t.run if t
+	rescue ThreadError
+	  retry
+	end
+      end
+    end
+    max
+  end
+
+  #
+  # Pushes +obj+ to the queue.  If there is no space left in the queue, waits
+  # until space becomes available.
+  #
+  def push(obj)
+    t = nil
+    @mutex.synchronize{
+      while true
+        break if @que.length < @max
+        @queue_wait.push Thread.current
+        @mutex.sleep
+      end
+    
+      @que.push obj
+      begin
+        t = @waiting.shift
+        t.wakeup if t
+      rescue ThreadError
+        retry
+      end
+    }
+    
+    begin
+      t.run if t
+    rescue ThreadError
+    end
+  end
+
+  #
+  # Alias of push
+  #
+  alias << push
+
+  #
+  # Alias of push
+  #
+  alias enq push
+
+  #
+  # Retrieves data from the queue and runs a waiting thread, if any.
+  #
+  def pop(*args)
+    retval = super
+    t = nil
+    @mutex.synchronize {
+      if @que.length < @max
+        begin
+          t = @queue_wait.shift
+          t.wakeup if t
+        rescue ThreadError
+          retry
+        end
+      end
+    }
+    begin
+      t.run if t
+    rescue ThreadError
+    end
+    retval
+  end
+
+  #
+  # Alias of pop
+  #
+  alias shift pop
+
+  #
+  # Alias of pop
+  #
+  alias deq pop
+
+  #
+  # Returns the number of threads waiting on the queue.
+  #
+  def num_waiting
+    @waiting.size + @queue_wait.size
+  end
+end
+
+# Documentation comments:
+#  - How do you make RDoc inherit documentation from superclass?

data/shoes/ruby/lib/thwait.rb

@@ -0,0 +1,168 @@
+#
+#   thwait.rb - thread synchronization class
+#   	$Release Version: 0.9 $
+#   	$Revision: 1.3 $
+#   	by Keiju ISHITSUKA(Nihpon Rational Software Co.,Ltd.)
+#
+# --
+#  feature:
+#  provides synchronization for multiple threads.
+#
+#  class methods:
+#  * ThreadsWait.all_waits(thread1,...)
+#    waits until all of specified threads are terminated.
+#    if a block is supplied for the method, evaluates it for
+#    each thread termination.
+#  * th = ThreadsWait.new(thread1,...)
+#    creates synchronization object, specifying thread(s) to wait.
+#  
+#  methods:
+#  * th.threads
+#    list threads to be synchronized
+#  * th.empty?
+#    is there any thread to be synchronized.
+#  * th.finished?
+#    is there already terminated thread.
+#  * th.join(thread1,...) 
+#    wait for specified thread(s).
+#  * th.join_nowait(threa1,...)
+#    specifies thread(s) to wait.  non-blocking.
+#  * th.next_wait
+#    waits until any of specified threads is terminated.
+#  * th.all_waits
+#    waits until all of specified threads are terminated.
+#    if a block is supplied for the method, evaluates it for
+#    each thread termination.
+#
+
+require "thread.rb"
+require "e2mmap.rb"
+
+#
+# This class watches for termination of multiple threads.  Basic functionality
+# (wait until specified threads have terminated) can be accessed through the
+# class method ThreadsWait::all_waits.  Finer control can be gained using
+# instance methods.
+#
+# Example:
+#
+#   ThreadsWait.all_wait(thr1, thr2, ...) do |t|
+#     STDERR.puts "Thread #{t} has terminated."
+#   end
+#
+class ThreadsWait
+  RCS_ID='-$Id: thwait.rb,v 1.3 1998/06/26 03:19:34 keiju Exp keiju $-'
+  
+  extend Exception2MessageMapper
+  def_exception("ErrNoWaitingThread", "No threads for waiting.")
+  def_exception("ErrNoFinishedThread", "No finished threads.")
+  
+  #
+  # Waits until all specified threads have terminated.  If a block is provided,
+  # it is executed for each thread termination.
+  #
+  def ThreadsWait.all_waits(*threads) # :yield: thread
+    tw = ThreadsWait.new(*threads)
+    if block_given?
+      tw.all_waits do |th|
+	yield th
+      end
+    else
+      tw.all_waits
+    end
+  end
+  
+  #
+  # Creates a ThreadsWait object, specifying the threads to wait on.
+  # Non-blocking.
+  #
+  def initialize(*threads)
+    @threads = []
+    @wait_queue = Queue.new
+    join_nowait(*threads) unless threads.empty?
+  end
+  
+  # Returns the array of threads in the wait queue.
+  attr :threads
+  
+  #
+  # Returns +true+ if there are no threads to be synchronized.
+  #
+  def empty?
+    @threads.empty?
+  end
+  
+  #
+  # Returns +true+ if any thread has terminated.
+  #
+  def finished?
+    !@wait_queue.empty?
+  end
+  
+  #
+  # Waits for specified threads to terminate.
+  #
+  def join(*threads)
+    join_nowait(*threads)
+    next_wait
+  end
+  
+  #
+  # Specifies the threads that this object will wait for, but does not actually
+  # wait.
+  #
+  def join_nowait(*threads)
+    threads.flatten!
+    @threads.concat threads
+    for th in threads
+      Thread.start(th) do |t|
+	begin
+	  t.join
+	ensure
+	  @wait_queue.push t
+	end
+      end
+    end
+  end
+  
+  #
+  # Waits until any of the specified threads has terminated, and returns the one
+  # that does.
+  #
+  # If there is no thread to wait, raises +ErrNoWaitingThread+.  If +nonblock+
+  # is true, and there is no terminated thread, raises +ErrNoFinishedThread+.
+  #
+  def next_wait(nonblock = nil)
+    ThreadsWait.fail ErrNoWaitingThread if @threads.empty?
+    begin
+      @threads.delete(th = @wait_queue.pop(nonblock))
+      th
+    rescue ThreadError
+      ThreadsWait.fail ErrNoFinishedThread
+    end
+  end
+  
+  #
+  # Waits until all of the specified threads are terminated.  If a block is
+  # supplied for the method, it is executed for each thread termination.
+  #
+  # Raises exceptions in the same manner as +next_wait+.
+  #
+  def all_waits
+    until @threads.empty?
+      th = next_wait
+      yield th if block_given?
+    end
+  end
+end
+
+ThWait = ThreadsWait
+
+
+# Documentation comments:
+#  - Source of documentation is evenly split between Nutshell, existing
+#    comments, and my own rephrasing.
+#  - I'm not particularly confident that the comments are all exactly correct.
+#  - The history, etc., up the top appears in the RDoc output.  Perhaps it would
+#    be better to direct that not to appear, and put something else there
+#    instead.