dramatis 0.0.1

data/lib/dramatis/runtime/task.rb

@@ -0,0 +1,390 @@
+module Dramatis; end
+class Dramatis::Runtime; end
+
+require 'dramatis/runtime/scheduler'
+require 'dramatis/future'
+require 'thread'
+
+class Dramatis::Runtime::Task #:nodoc: all
+
+  attr_reader :actor
+
+  def type
+    @dest
+  end
+
+  def method
+    @args[0]
+  end
+
+  def arguments
+    @args[1,@args.length]
+  end
+
+  attr_reader :call_thread
+
+  def initialize actor, dest, args, options
+    @actor = actor
+    @dest = dest
+    @args = args.dup
+
+    @call_thread = nil
+
+    name = Dramatis::Runtime::Scheduler.actor
+    actor = name.instance_eval { @actor }
+
+    object_id = actor.object.object_id
+
+    @args.each_with_index do |arg,i|
+      if arg.object_id == object_id
+        @args[i] = name
+      end
+    end
+
+    if actor.call_threading?
+      # warn "oct #{options[:call_thread]} act #{actor.call_thread}"
+      raise "hell" if options[:call_thread] and
+                       actor.call_thread and
+                       options[:call_thread] != actor.call_thread
+      @call_thread = actor.call_thread
+      if @call_thread == nil
+        @call_thread = self.to_s
+      end
+    end
+
+    # warn "task #{self} #{args[0]} call thread [ #{@call_thread} ] #{options.to_a.join(' ')}"
+
+    case options[:continuation]
+    when :none
+      @continuation = Continuation::None.new name, @call_thread
+    when :rpc
+      @continuation = Continuation::RPC.new name, @call_thread, options[:nonblocking]
+    when :future
+      @continuation = Continuation::Future.new name, @call_thread
+    when Proc
+      @continuation = Continuation::Proc.new name,  @call_thread, options[:continuation],
+                                                                    options[:exception]
+    else
+      raise Dramatis::Internal.new( "invalid contiunation type" )
+    end
+  end
+
+  def exception e
+    @continuation.exception e
+  end
+
+  def queued
+    @continuation.queued
+  end
+
+  def deliver
+    @actor.deliver @dest, @args, @continuation, @call_thread
+  end
+
+  private
+
+  module Continuation
+
+    class None
+
+      include Dramatis
+
+      def queued
+      end
+
+      def result result
+      end
+
+      def exception exception
+        # warn "except nil #{exception}"
+        # true and pp exception.backtrace
+        interface( release( @name ) ).exception exception
+      end
+
+      def initialize name, call_thread
+        @name = name
+      end
+    end
+
+    class RPC
+
+      include Dramatis
+
+      def actor
+        @actor.instance_eval { @actor }
+      end
+
+      def initialize name, call_thread, nonblocking
+        # all the synchronizaton here probably gets tossed
+        # proof:
+        # to create the continuation, you have to have the actor lock
+        # to deliver the continuation you have to have the actor lock
+        # QED
+        # when this wasn't a message send, you could try to execute before
+        # but now that's not possible; it'll get queued
+        # i think
+        # of course, it should be harmless
+        # fix ... might want to seperate the two parts of a continuation
+        # the value part and the thread state part
+        @blocking = !nonblocking
+        @state = :start
+        @mutex = Mutex.new
+        @wait = ConditionVariable.new
+        @call_thread = call_thread
+        # warn "contiunation to #{actor}"
+        @actor = interface( Dramatis::Runtime::Scheduler.actor ).send :continuation, self, :call_thread => call_thread
+      end
+
+      def queued
+
+        @mutex.synchronize do
+          raise "hell " + @state.to_s if @state != :start and @state != :signaled
+          if @state == :start
+            @state = :waiting
+            begin
+              tag = to_s
+              call_thread = @call_thread
+              blocking = @blocking
+              @actor.instance_eval do
+                @actor.instance_eval do
+                  # warn "#{self} ct [ #{call_thread} ]"
+                  @call_thread = call_thread
+                end
+                if blocking
+                  @actor.gate.only [ :continuation, tag ], :tag => tag
+                end
+                @actor.schedule self
+              end
+              begin
+                Dramatis::Runtime::Scheduler.current.suspend_notification self
+                @wait.wait @mutex
+                # this causes a deadlock if the waking thread, which may be
+                # retiring, does so before this thead has awakend and notified
+                # the scheduler
+                # sleep 1
+              ensure
+                # Dramatis::Runtime::Scheduler.current.wakeup_notification self
+              end
+            ensure
+              tag = to_s
+              @actor.instance_eval do
+                @actor.gate.default_by_tag tag
+              end
+            end
+            raise "hell" if @state != :done
+          end
+        end
+
+        raise "hell " + @type.inspect if ![ :return, :exception ].include? @type
+        case @type
+        when :return
+          return @value
+        when :exception
+          # if Dramatis::Deadlock === @value 
+          # @value = Dramatis::Deadlock.new nil, :next => @value
+          # end
+          # pp "reraise", caller
+          @value._dramatis_reraise
+          raise @value
+        end
+      end
+
+      def result result
+        @actor.result result
+      end
+
+      def exception exception
+        # warn "4 exception " + exception.to_s
+        # warn "4 exception " + exception.backtrace.join("\n")
+        @actor.exception exception
+        # warn "4 delivered ".to_s
+      end
+
+      def continuation_result result
+        @mutex.synchronize do
+          raise "hell" if @state != :start and @state != :waiting
+          @type = :return
+          @value = result
+          if @state == :start
+            @state = :signaled
+          else
+            @state = :done
+            Dramatis::Runtime::Scheduler.current.wakeup_notification self
+            @wait.signal
+          end
+        end
+      end
+
+      def continuation_exception exception
+        # warn "except rpc"
+        @mutex.synchronize do
+          raise "hell" if @state != :start and @state != :waiting
+          @type = :exception
+          @value = exception
+          if @state == :start
+            @state = :signaled
+          else
+            @state = :done
+            Dramatis::Runtime::Scheduler.current.wakeup_notification self
+            @wait.signal
+          end
+        end
+      end
+
+    end
+
+    class Proc
+
+      include Dramatis
+
+      def initialize name, call_thread, result, except
+        # p "p.n #{call_thread} #{result} #{except}"
+        @result_block = result
+        @exception_block = except
+        @name = name
+        @continuation = \
+          interface( Dramatis::Runtime::Scheduler.actor ) \
+             .send :continuation, self, :call_thread => call_thread
+      end
+
+      def queued; end
+
+      def result result
+        @continuation.result result
+      end
+
+      def exception exception
+        @continuation.exception exception
+      end
+
+      def continuation_result result
+        @result_block.call result
+      end
+
+      def continuation_exception exception
+        # warn "delivering #{exception} => #{@exception_block}"
+        # pp exception.backtrace
+        if @exception_block
+          @exception_block.call exception
+        else
+          release( @name ).dramatis_exception exception
+        end
+      end
+
+    end
+
+    class Future
+
+      include Dramatis
+
+      def initialize name, call_thread
+        @state = :start
+        @mutex = Mutex.new
+        @wait = ConditionVariable.new
+        @call_thread = call_thread
+        # warn "contiunation to #{actor}"
+        @actor = interface( Dramatis::Runtime::Scheduler.actor ) \
+          .send :continuation, self, :call_thread => call_thread
+      end
+
+      def ready?
+        @mutex.synchronize { @state == :done  or @state == :signaled }
+      end
+
+      def value
+        @mutex.synchronize do
+          if @state == :start
+            @state = :waiting
+            begin
+              tag = to_s
+              call_thread = @call_thread
+              @actor.instance_eval do
+                @actor.instance_eval do
+                  @call_thread = call_thread
+                end
+                @actor.gate.only [ :continuation, tag ], :tag => tag
+                @actor.schedule self
+              end
+              begin
+                Dramatis::Runtime::Scheduler.current.suspend_notification self
+                @wait.wait @mutex
+                # this causes a deadlock if the waking thread, which may be
+                # retiring, does so before this thead has awakend and notified
+                # the scheduler
+                # sleep 1
+              ensure
+                # Dramatis::Runtime::Scheduler.current.wakeup_notification self
+              end
+            ensure
+              tag = to_s
+              @actor.instance_eval do
+                @actor.gate.default_by_tag tag
+              end
+            end
+            raise "hell" if @state != :done
+          end
+        end
+
+        raise "hell " + @type.inspect if ![ :return, :exception ].include? @type
+        case @type
+        when :return
+          return @value
+        when :exception
+          begin
+            # raise "hell for #{@value}"
+          rescue Exception => e
+            pp "#{e}", e.backtrace
+          end
+          raise @value
+        end
+      end
+
+      def queued
+        Dramatis::Future.new( self )
+      end
+
+      def result result
+        @actor.result result
+      end
+
+      def exception exception
+        # warn "4 exception " + exception.to_s
+        # warn "4 exception " + exception.backtrace.join("\n")
+        @actor.exception exception
+        # warn "4 delivered ".to_s
+      end
+
+      def continuation_result result
+        @mutex.synchronize do
+          raise "hell" if @state != :start and @state != :waiting
+          @type = :return
+          @value = result
+          if @state == :start
+            @state = :signaled
+          else
+            @state = :done
+            Dramatis::Runtime::Scheduler.current.wakeup_notification self
+            @wait.signal
+          end
+        end
+      end
+
+      def continuation_exception exception
+        # warn "except rpc"
+        @mutex.synchronize do
+          raise "hell" if @state != :start and @state != :waiting
+          @type = :exception
+          @value = exception
+          if @state == :start
+            @state = :signaled
+          else
+            @state = :done
+            Dramatis::Runtime::Scheduler.current.wakeup_notification self
+            @wait.signal
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/dramatis/runtime/thread_pool.rb

@@ -0,0 +1,149 @@
+module Dramatis; end
+class Dramatis::Runtime; end
+
+class Dramatis::Runtime::ThreadPool; end
+class Dramatis::Runtime::ThreadPool::PoolThread < Thread; end
+
+class Dramatis::Runtime::ThreadPool #:nodoc: all
+
+  def reset
+    shutdown
+    @state = :running
+  end
+
+  def initialize
+    super
+    @mutex = Mutex.new
+    @threads = []
+    @state = :running
+  end
+
+  def new &block
+    checkout( &block )
+  end
+
+  def length
+    @mutex.synchronize do
+      @threads.length
+    end
+  end
+
+  private
+
+  def shutdown
+    @mutex.synchronize do
+      @state = :exiting
+      @threads.each do |thread|
+        thread.send :shutdown
+      end
+      @threads.each do |thread|
+        thread.true_join
+      end
+      @threads = []
+    end
+  end
+
+  def checkin thread
+    @mutex.synchronize do
+      if @state != :exiting
+        @threads << thread
+      else
+        warn("POST EXIT CHECKIN")
+      end
+    end
+  end
+
+  def checkout &block
+    raise "hell" if @state == :exiting
+    t = nil
+    @mutex.synchronize do
+      if @threads.length == 0
+        pt = PoolThread.new self
+        @threads << pt
+      end
+      t = @threads.pop
+    end
+    t.send :awaken, &block
+    t
+  end
+  
+end
+
+class Dramatis::Runtime::ThreadPool::PoolThread < Thread
+
+  def initialize pool
+    @pool = pool
+    @mutex = Mutex.new
+    @wait = ConditionVariable.new
+    @state = :running
+    super() do
+      self.abort_on_exception = true
+      target
+    end
+  end
+
+  alias true_join join
+
+  def join
+    # I've thought about this. It would be cool to implement join. It's not
+    # too hard to do it when threads aren't reused ... which is kinda dumb.
+    # It's possible to do it when threads are reused, by coding an allocation
+    # counter in the "thread" object (but not the native thread). It'd be
+    # cool, but I don't need it, so, oh well.
+    raise "not implemented"
+  end
+
+  private
+
+  def shutdown
+    @mutex.synchronize do
+      old_state, @state = @state, :exiting
+      # p "#{Thread.current} shutdown #{old_state} #{@state}"
+      if old_state == :waiting
+        @wait.signal
+      end
+    end
+  end
+
+  def awaken &block
+    @mutex.synchronize do
+      @block = block
+      old_state, @state = @state, :called
+      if old_state == :waiting
+        # p "#{Thread.current} signalling"
+        @wait.signal
+      elsif old_state == :exiting
+        warn("AWAKEN AFTER EXIT")
+        raise "AWAKEN AFTER EXIT"
+      elsif old_state != :running
+        warn("AWAKEN BAD STATE " + old_state)
+        raise "AWAKEN BAD STATE " + old_state
+      end
+    end
+  end
+
+  def target
+    while true do
+      @mutex.synchronize do
+        if @state == :exiting
+          return
+        elsif @state == :running
+          @state = :waiting
+          @wait.wait @mutex
+          raise "hell" if @state == :waiting
+        elsif @state == :called
+          begin
+            @block.call
+          ensure
+            @state = :running
+            @pool.send :checkin, self
+          end
+        else
+          warn( "!!FAIL!! " + @state)
+          raise "!!FAIL!! " + @state
+        end
+      end
+    end
+  end
+
+end

data/lib/dramatis/runtime/timer.rb

@@ -0,0 +1,5 @@
+module Dramatis; end
+class Dramatis::Runtime; end
+
+class Dramatis::Runtime::Timer #:nodoc: all
+end

data/lib/dramatis/runtime.rb

@@ -0,0 +1,129 @@
+module Dramatis; end
+
+require 'thread'
+
+# Dramatis::Runtime is the top level class managing the running of the
+# various pieces of the dramatis runtime. Typically programs don't
+# need to deal with the runtime directly, though some functions are
+# useful, particularly for debugging and testing.
+
+class Dramatis::Runtime
+
+  # Returns a reference to the current Dramatis::Runtime object.
+
+  def self.current
+    @@current ||= self.new
+  end
+
+  # Resets the current runtime instance. Note that this method hard
+  # resets counters and ignore exceptions which is generally a bad
+  # idea. It is typical only used in unit test after methods to keep
+  # failing tests from cascading.
+
+  def self.reset
+    # this swallows exceptions: it's assumed to be used to clean up
+    # a failed test so there's no connection between tests
+    begin
+      Dramatis::Runtime.current.quiesce
+    rescue Exception => e
+    end
+    Dramatis::Runtime::Scheduler.reset    
+    Dramatis::Runtime::Actor::Main.reset    
+    @@current = nil
+  end
+
+  # Causes the runtime to suspend the current thread until there are
+  # no more tasks that can be executed. If no tasks remain, returns
+  # normally. If tasks remain but are gated off,
+  # Dramtis::Error::Deadlock is raised.
+  #
+  # As a side effect, this method releases the current actor to
+  # process messages but does not change the task gate.
+  
+  def quiesce
+    Dramatis::Runtime::Scheduler.current.quiesce
+    maybe_raise_exceptions true
+  end
+
+  def maybe_raise_exceptions quiescing #:nodoc:
+    @mutex.synchronize do
+      if !@exceptions.empty?
+        # warn "no maybe about it"
+        if !quiescing and warnings?
+          warn "the following #{@exceptions.length} exception(s) were raised and not caught"
+          @exceptions.each do |exception|
+            # warn "#{exception}"
+            # pp exception.backtrace
+          end
+        end
+        raise Dramatis::Error::Uncaught.new( @exceptions )
+      end
+      @exceptions.clear
+    end
+  end
+
+  # Returns the list of uncaught exceptions.
+
+  def exceptions 
+    result = nil
+    @mutex.synchronize do
+      result = @exceptions.dup
+    end
+    result
+  end
+
+  # Clears the list of uncaught exceptions. Used in unit tests to
+  # clear expected exceptions.  If exceptions are raised and not
+  # clear, they will be raised at the end of the program via a
+  # Dramatis::Error::Uncaught.
+  
+  def clear_exceptions
+    @mutex.synchronize do
+      # warn "runtime clearing exceptions"
+      @exceptions.clear
+    end
+  end
+
+  def exception exception #:nodoc:
+    @mutex.synchronize do
+      @exceptions << exception
+      warn "runtime recording exception: #{exception} [#{@exceptions.length}]" if warnings?
+      # backtrace
+      # pp exception.backtrace
+    end
+  end
+
+  def backtrace #:nodoc:
+    begin
+      raise "backtrace"
+    rescue ::Exception => e
+      pp e.backtrace
+    end
+  end
+
+  # Enables or disables printing warnings, e.g., when uncaugh
+  # exceptions are detected.
+
+  def warnings= value
+    @warnings = value
+  end
+
+  # Returns true if warnings are enabled.
+
+  def warnings?
+    @warnings
+  end
+
+  def at_exit #:nodoc:
+    Dramatis::Runtime::Actor::Main.current.finalize
+  end
+
+  private
+
+  def initialize #:nodoc:
+    @warnings = true
+    @mutex = Mutex.new
+    @exceptions = []
+  end
+
+end

data/lib/dramatis/shoes/runtime.rb

@@ -0,0 +1,7 @@
+module Dramatis; end
+module Dramatis::Shoes; end
+
+class Dramatis::Shoes::Runtime  #:nodoc: all
+end
+
+

data/lib/dramatis/shoes.rb

@@ -0,0 +1,14 @@
+module Dramatis; end
+module Dramatis::Shoes; end
+
+require 'dramatis/shoes/runtime'
+
+module Dramatis::Shoes #:nodoc: all
+  
+  def self.runtime
+    @runtime ||= Dramatis::Shoes::Runtime.new
+  end
+  
+end
+
+

data/lib/dramatis/version.rb

@@ -0,0 +1,8 @@
+module Dramatis
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end