xthread 0.1.3

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (C) 2010 Keiju Ishitsuka. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/cond.c

@@ -0,0 +1,152 @@
+/************************************************
+
+  cond.c -
+
+  Copyright (C) 2011 Keiju Ishitsuka
+  Copyright (C) 2011 Penta Advanced Laboratories, Inc.
+
+************************************************/
+
+#include "ruby.h"
+
+#include "xthread.h"
+
+VALUE rb_cXThreadConditionVariable;
+
+typedef struct rb_xthread_cond_struct
+{
+  VALUE waiters;
+  /* VALUE waiters_mutex; */
+} xthread_cond_t;
+
+#define GetXThreadCondPtr(obj, tobj) \
+    TypedData_Get_Struct((obj), xthread_cond_t, &xthread_cond_data_type, (tobj))
+
+static void
+xthread_cond_mark(void *ptr)
+{
+  xthread_cond_t *cv = (xthread_cond_t*)ptr;
+  
+  rb_gc_mark(cv->waiters);
+  /* rb_gc_mark(cv->waiters_mutex); */
+}
+
+static void
+xthread_cond_free(void *ptr)
+{
+    ruby_xfree(ptr);
+}
+
+static size_t
+xthread_cond_memsize(const void *ptr)
+{
+    return ptr ? sizeof(xthread_cond_t) : 0;
+}
+
+static const rb_data_type_t xthread_cond_data_type = {
+    "xthread_cond",
+    {xthread_cond_mark, xthread_cond_free, xthread_cond_memsize,},
+};
+
+static VALUE
+xthread_cond_alloc(VALUE klass)
+{
+  VALUE volatile obj;
+  xthread_cond_t *cv;
+
+  obj = TypedData_Make_Struct(klass, xthread_cond_t,
+			      &xthread_cond_data_type, cv);
+  cv->waiters = rb_xthread_fifo_new();
+  /* cv->waiters_mutex = rb_mutex_new(); */
+  return obj;
+}
+
+/*
+ *  call-seq:
+ *     ConditionVariable.new   -> condition_variable
+ *
+ *  Creates a new ConditionVariable
+ */
+static VALUE
+xthread_cond_initialize(VALUE self)
+{
+    return self;
+}
+
+VALUE
+rb_xthread_cond_new(void)
+{
+  return xthread_cond_alloc(rb_cXThreadConditionVariable);
+}
+
+VALUE
+rb_xthread_cond_wait(VALUE self, VALUE mutex, VALUE timeout)
+{
+  xthread_cond_t *cv;
+  VALUE th = rb_thread_current();
+  
+  GetXThreadCondPtr(self, cv);
+
+  /* rb_mutex_lock(cv->waiters_mutex); */
+  rb_xthread_fifo_push(cv->waiters, th);
+  /* rb_mutex_unlock(cv->waiters_mutex); */
+  
+  rb_mutex_sleep(mutex, timeout);
+  
+  return self;
+}
+
+static VALUE
+xthread_cond_wait(int argc, VALUE *argv, VALUE self)
+{
+  VALUE mutex;
+  VALUE timeout;
+  
+  rb_scan_args(argc, argv, "11", &mutex, &timeout);
+  return rb_xthread_cond_wait(self, mutex, timeout);
+}
+
+VALUE
+rb_xthread_cond_signal(VALUE self)
+{
+  VALUE th;
+  xthread_cond_t *cv;
+  GetXThreadCondPtr(self, cv);
+
+  /*  rb_mutex_lock(cv->waiters_mutex); */
+  th = rb_xthread_fifo_pop(cv->waiters);
+  /* rb_mutex_unlock(cv->waiters_mutex); */
+  if (th != Qnil) {
+    rb_thread_wakeup(th);
+  }
+
+  return self;
+}
+
+VALUE
+rb_xthread_cond_broadcast(VALUE self)
+{
+  xthread_cond_t *cv;
+  VALUE waiters0;
+  VALUE th;
+  
+  GetXThreadCondPtr(self, cv);
+
+  while ((th = rb_xthread_fifo_pop(cv->waiters)) != Qnil) {
+    rb_thread_wakeup(th);
+  }
+  
+  return self;
+}
+
+void
+Init_XThreadCond(void)
+{
+  rb_cXThreadConditionVariable =
+    rb_define_class_under(rb_mXThread, "ConditionVariable", rb_cObject);
+  rb_define_alloc_func(rb_cXThreadConditionVariable, xthread_cond_alloc);
+  rb_define_method(rb_cXThreadConditionVariable, "initialize", xthread_cond_initialize, 0);
+  rb_define_method(rb_cXThreadConditionVariable, "wait", xthread_cond_wait, -1);
+  rb_define_method(rb_cXThreadConditionVariable, "signal", rb_xthread_cond_signal, 0);
+  rb_define_method(rb_cXThreadConditionVariable, "broadcast", rb_xthread_cond_broadcast, 0);
+}

data/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+create_makefile("xthread")
+

data/fifo.c

@@ -0,0 +1,269 @@
+/**********************************************************************
+
+  fifo.c -
+
+  Copyright (C) 2011 Keiju Ishitsuka
+  Copyright (C) 2011 Penta Advanced Laboratories, Inc.
+
+**********************************************************************/
+
+#include "ruby.h"
+
+#include "xthread.h"
+
+#define FIFO_DEFAULT_CAPA 16
+
+VALUE rb_mXThread;
+VALUE rb_cXThreadFifo;
+
+typedef struct rb_xthread_fifo_struct
+{
+  long push;
+  long pop;
+  long capa;
+  
+  VALUE *elements;
+} xthread_fifo_t;
+
+#define GetXThreadFifoPtr(obj, tobj) \
+    TypedData_Get_Struct((obj), xthread_fifo_t, &xthread_fifo_data_type, (tobj))
+
+static void
+xthread_fifo_mark(void *ptr)
+{
+  xthread_fifo_t *fifo = (xthread_fifo_t*)ptr;
+  
+  if (fifo->push < fifo->capa) {
+    long i;
+    for (i = fifo->pop; i < fifo->push; i++) {
+      rb_gc_mark(fifo->elements[i]);
+    }
+  }
+  else {
+    long i;
+    for (i = 0; i < fifo->push - fifo->capa; i++) {
+      rb_gc_mark(fifo->elements[i]);
+    }
+
+    for (i = fifo->pop; i < fifo->capa; i++) {
+      rb_gc_mark(fifo->elements[i]);
+    }
+  }
+}
+
+static void
+xthread_fifo_free(void *ptr)
+{
+  xthread_fifo_t *fifo = (xthread_fifo_t*)ptr;
+  
+  ruby_xfree(fifo->elements);
+  ruby_xfree(ptr);
+}
+
+static size_t
+xthread_fifo_memsize(const void *ptr)
+{
+  xthread_fifo_t *fifo = (xthread_fifo_t*)ptr;
+  
+  return ptr ? sizeof(xthread_fifo_t) + fifo->capa * sizeof(VALUE): 0;
+}
+
+static const rb_data_type_t xthread_fifo_data_type = {
+    "xthread_fifo",
+    {xthread_fifo_mark, xthread_fifo_free, xthread_fifo_memsize,},
+};
+
+static VALUE
+xthread_fifo_alloc(VALUE klass)
+{
+  VALUE volatile obj;
+  xthread_fifo_t *fifo;
+
+  obj = TypedData_Make_Struct(klass, xthread_fifo_t, &xthread_fifo_data_type, fifo);
+  
+  fifo->push = 0;
+  fifo->pop = 0;
+
+  fifo->capa = FIFO_DEFAULT_CAPA;
+  fifo->elements = NULL;
+
+  return obj;
+}
+
+static void
+xthread_fifo_resize_double_capa(xthread_fifo_t *fifo)
+{
+  long new_capa = fifo->capa * 2;
+
+  REALLOC_N(fifo->elements, VALUE, new_capa);
+
+  if (fifo->push > fifo->capa) {
+    if (fifo->capa - fifo->pop <= fifo->push - fifo->capa) {
+      MEMCPY(&fifo->elements[fifo->pop + fifo->capa],
+	     &fifo->elements[fifo->pop], VALUE, fifo->capa - fifo->pop);
+      fifo->pop += fifo->capa;
+      fifo->push += fifo->capa;
+    }
+    else {
+      MEMCPY(&fifo->elements[fifo->capa],
+	     fifo->elements, VALUE, fifo->push - fifo->capa);
+    }
+  }
+  fifo->capa = new_capa;
+}
+
+static VALUE
+xthread_fifo_initialize(VALUE self)
+{
+  xthread_fifo_t *fifo;
+  GetXThreadFifoPtr(self, fifo);
+  
+  fifo->elements = ALLOC_N(VALUE, fifo->capa);
+  return self;
+}
+
+VALUE
+rb_xthread_fifo_new(void)
+{
+  VALUE self;
+  self = xthread_fifo_alloc(rb_cXThreadFifo);
+  xthread_fifo_initialize(self);
+  return self;
+}
+
+VALUE
+rb_xthread_fifo_push(VALUE self, VALUE item)
+{
+  xthread_fifo_t *fifo;
+  int signal_p = 0;
+  
+  GetXThreadFifoPtr(self, fifo);
+
+  if (fifo->push < fifo->capa) {
+    fifo->elements[fifo->push++] = item;
+    return self;
+  }
+
+  if (fifo->push - fifo->capa < fifo->pop) {
+    fifo->elements[fifo->push - fifo->capa] = item;
+    fifo->push++;
+    return self;
+  }
+
+  xthread_fifo_resize_double_capa(fifo);
+  return rb_xthread_fifo_push(self, item);
+}
+
+VALUE
+rb_xthread_fifo_pop(VALUE self)
+{
+  xthread_fifo_t *fifo;
+  VALUE item;
+  
+  GetXThreadFifoPtr(self, fifo);
+
+  if (fifo->push == fifo->pop)
+    return Qnil;
+
+  item = fifo->elements[fifo->pop++];
+  if(fifo->pop >= fifo->capa) {
+    fifo->pop -= fifo->capa;
+    fifo->push -= fifo->capa;
+  }
+  return item;
+}
+
+VALUE
+rb_xthread_fifo_empty_p(VALUE self)
+{
+  xthread_fifo_t *fifo;
+  GetXThreadFifoPtr(self, fifo);
+  
+  if (fifo->push == fifo->pop)
+    return Qtrue;
+  return Qfalse;
+}
+
+VALUE
+rb_xthread_fifo_clear(VALUE self)
+{
+  xthread_fifo_t *fifo;
+  GetXThreadFifoPtr(self, fifo);
+
+  fifo->push = 0;
+  fifo->pop = 0;
+  return self;
+}
+
+VALUE
+rb_xthread_fifo_length(VALUE self)
+{
+  xthread_fifo_t *fifo;
+  GetXThreadFifoPtr(self, fifo);
+
+  return LONG2NUM(fifo->push - fifo->pop);
+}
+
+VALUE
+rb_xthread_fifo_to_a(VALUE self)
+{
+  VALUE ary;
+  xthread_fifo_t *fifo;
+  GetXThreadFifoPtr(self, fifo);
+
+  ary = rb_ary_new2(fifo->push - fifo->pop);
+
+  if (fifo->push < fifo->capa) {
+    long i;
+    for (i = fifo->pop; i < fifo->push; i++) {
+      rb_ary_push(ary, fifo->elements[i]);
+    }
+  }
+  else {
+    long i;
+    for (i = 0; i < fifo->push - fifo->capa; i++) {
+      rb_ary_push(ary, fifo->elements[i]);
+    }
+
+    for (i = fifo->pop; i < fifo->capa; i++) {
+      rb_ary_push(ary, fifo->elements[i]);
+    }
+  }
+  return ary;
+}
+
+VALUE
+rb_xthread_fifo_inspect(VALUE self)
+{
+  xthread_fifo_t *fifo;
+  VALUE str;
+  
+  GetXThreadFifoPtr(self, fifo);
+
+  str = rb_sprintf("<%s ", rb_obj_classname(self), (void*)self);
+  rb_str_append(str, rb_inspect(rb_xthread_fifo_to_a(self)));
+  rb_str_cat2(str, ">");
+  return str;
+}
+
+void
+Init_XThreadFifo()
+{
+  rb_cXThreadFifo  = rb_define_class_under(rb_mXThread, "Fifo", rb_cObject);
+
+  rb_define_alloc_func(rb_cXThreadFifo, xthread_fifo_alloc);
+  rb_define_method(rb_cXThreadFifo, "initialize", xthread_fifo_initialize, 0);
+  rb_define_method(rb_cXThreadFifo, "pop", rb_xthread_fifo_pop, 0);
+  rb_define_alias(rb_cXThreadFifo,  "shift", "pop");
+  rb_define_alias(rb_cXThreadFifo,  "deq", "pop");
+  rb_define_method(rb_cXThreadFifo, "push", rb_xthread_fifo_push, 1);
+  rb_define_alias(rb_cXThreadFifo,  "<<", "push");
+  rb_define_alias(rb_cXThreadFifo,  "enq", "push");
+  rb_define_method(rb_cXThreadFifo, "empty?", rb_xthread_fifo_empty_p, 0);
+  rb_define_method(rb_cXThreadFifo, "clear", rb_xthread_fifo_clear, 0);
+  rb_define_method(rb_cXThreadFifo, "length", rb_xthread_fifo_length, 0);
+  rb_define_alias(rb_cXThreadFifo,  "size", "length");
+  rb_define_method(rb_cXThreadFifo, "to_a", rb_xthread_fifo_to_a, 0);
+  rb_define_method(rb_cXThreadFifo, "inspect", rb_xthread_fifo_inspect, 0);
+  
+}

data/lib/xthread/monitor.rb

@@ -0,0 +1,282 @@
+=begin
+
+= xthread/monitor.rb
+
+This Monitor is using XThread::ConditionVariable.
+
+Original by monitor.rb
+Copyright (C) 2001  Shugo Maeda <shugo@ruby-lang.org>
+
+This library is distributed under the terms of the Ruby license.
+You can freely distribute/modify this library.
+
+== example
+
+This is a simple example.
+
+  require 'monitor.rb'
+
+  buf = []
+  buf.extend(MonitorMixin)
+  empty_cond = buf.new_cond
+
+  # consumer
+  Thread.start do
+    loop do
+      buf.synchronize do
+        empty_cond.wait_while { buf.empty? }
+        print buf.shift
+      end
+    end
+  end
+
+  # producer
+  while line = ARGF.gets
+    buf.synchronize do
+      buf.push(line)
+      empty_cond.signal
+    end
+  end
+
+The consumer thread waits for the producer thread to push a line
+to buf while buf.empty?, and the producer thread (main thread)
+reads a line from ARGF and push it to buf, then call
+empty_cond.signal.
+
+=end
+
+require 'xthread'
+
+#
+# Adds monitor functionality to an arbitrary object by mixing the module with
+# +include+.  For example:
+#
+#    require 'monitor'
+#
+#    buf = []
+#    buf.extend(MonitorMixin)
+#    empty_cond = buf.new_cond
+#
+#    # consumer
+#    Thread.start do
+#      loop do
+#        buf.synchronize do
+#          empty_cond.wait_while { buf.empty? }
+#          print buf.shift
+#        end
+#      end
+#    end
+#
+#    # producer
+#    while line = ARGF.gets
+#      buf.synchronize do
+#        buf.push(line)
+#        empty_cond.signal
+#      end
+#    end
+#
+# The consumer thread waits for the producer thread to push a line
+# to buf while buf.empty?, and the producer thread (main thread)
+# reads a line from ARGF and push it to buf, then call
+# empty_cond.signal.
+#
+module XThread 
+  module RBMonitorMixin
+    #
+    # FIXME: This isn't documented in Nutshell.
+    #
+    # Since MonitorMixin.new_cond returns a ConditionVariable, and the example
+    # above calls while_wait and signal, this class should be documented.
+    #
+    class RBConditionVariable
+      class Timeout < Exception; end
+
+      #
+      # Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.
+      #
+      # If +timeout+ is given, this method returns after +timeout+ seconds passed,
+      # even if no other thread doesn't signal.
+      #
+      def wait(timeout = nil)
+	@monitor.__send__(:mon_check_owner)
+	count = @monitor.__send__(:mon_exit_for_cond)
+	begin
+	  @cond.wait(@monitor.instance_variable_get("@mon_mutex"), timeout)
+	  return true
+	ensure
+	  @monitor.__send__(:mon_enter_for_cond, count)
+	end
+      end
+
+      #
+      # Calls wait repeatedly while the given block yields a truthy value.
+      #
+      def wait_while
+	while yield
+	  wait
+	end
+      end
+
+      #
+      # Calls wait repeatedly until the given block yields a truthy value.
+      #
+      def wait_until
+	until yield
+	  wait
+	end
+      end
+
+      #
+      # Wakes up the first thread in line waiting for this lock.
+      #
+      def signal
+	@monitor.__send__(:mon_check_owner)
+	@cond.signal
+      end
+
+      #
+      # Wakes up all threads waiting for this lock.
+      #
+      def broadcast
+	@monitor.__send__(:mon_check_owner)
+	@cond.broadcast
+      end
+
+      private
+
+      def initialize(monitor)
+	@monitor = monitor
+	@cond = ::XThread::ConditionVariable.new
+      end
+    end
+
+    def self.extend_object(obj)
+      super(obj)
+      obj.__send__(:mon_initialize)
+    end
+
+    #
+    # Attempts to enter exclusive section.  Returns +false+ if lock fails.
+    #
+    def mon_try_enter
+      if @mon_owner != Thread.current
+	unless @mon_mutex.try_lock
+	  return false
+	end
+	@mon_owner = Thread.current
+      end
+      @mon_count += 1
+      return true
+    end
+    # For backward compatibility
+    alias try_mon_enter mon_try_enter
+
+    #
+    # Enters exclusive section.
+    #
+    def mon_enter
+      if @mon_owner != Thread.current
+	@mon_mutex.lock
+	@mon_owner = Thread.current
+      end
+      @mon_count += 1
+    end
+
+    #
+    # Leaves exclusive section.
+    #
+    def mon_exit
+      mon_check_owner
+      @mon_count -=1
+      if @mon_count == 0
+	@mon_owner = nil
+	@mon_mutex.unlock
+      end
+    end
+
+    #
+    # Enters exclusive section and executes the block.  Leaves the exclusive
+    # section automatically when the block exits.  See example under
+    # +MonitorMixin+.
+    #
+    def mon_synchronize
+      mon_enter
+      begin
+	yield
+      ensure
+	mon_exit
+      end
+    end
+    alias synchronize mon_synchronize
+
+    #
+    # Creates a new MonitorMixin::ConditionVariable associated with the
+    # receiver.
+    #
+    def new_cond
+      return RBConditionVariable.new(self)
+    end
+
+    private
+
+    def initialize(*args)
+      super
+      mon_initialize
+    end
+
+    def mon_initialize
+      @mon_owner = nil
+      @mon_count = 0
+      @mon_mutex = Mutex.new
+    end
+
+    def mon_check_owner
+      if @mon_owner != Thread.current
+	raise ThreadError, "current thread not owner"
+      end
+    end
+
+    def mon_enter_for_cond(count)
+      @mon_owner = Thread.current
+      @mon_count = count
+    end
+
+    def mon_exit_for_cond
+      count = @mon_count
+      @mon_owner = nil
+      @mon_count = 0
+      return count
+    end
+  end
+
+  class RBMonitor
+    include RBMonitorMixin
+    alias try_enter try_mon_enter
+    alias enter mon_enter
+    alias exit mon_exit
+  end
+end
+
+
+# Documentation comments:
+#  - All documentation comes from Nutshell.
+#  - MonitorMixin.new_cond appears in the example, but is not documented in
+#    Nutshell.
+#  - All the internals (internal modules Accessible and Initializable, class
+#    ConditionVariable) appear in RDoc.  It might be good to hide them, by
+#    making them private, or marking them :nodoc:, etc.
+#  - The entire example from the RD section at the top is replicated in the RDoc
+#    comment for MonitorMixin.  Does the RD section need to remain?
+#  - RDoc doesn't recognise aliases, so we have mon_synchronize documented, but
+#    not synchronize.
+#  - mon_owner is in Nutshell, but appears as an accessor in a separate module
+#    here, so is hard/impossible to RDoc.  Some other useful accessors
+#    (mon_count and some queue stuff) are also in this module, and don't appear
+#    directly in the RDoc output.
+#  - in short, it may be worth changing the code layout in this file to make the
+#    documentation easier
+
+# Local variables:
+# mode: Ruby
+# tab-width: 8
+# End: