dramatis 0.0.1

data/lib/dramatis/runtime/actor.rb

@@ -0,0 +1,294 @@
+module Dramatis; end
+class Dramatis::Runtime; end
+
+require 'dramatis/runtime/task'
+require 'dramatis/runtime/gate'
+require 'dramatis/runtime/timer'
+require 'dramatis/actor/interface'
+require 'dramatis/actor/name'
+require 'thread'
+
+begin require 'pp'; rescue Exception; end
+
+class Dramatis::Runtime::Actor #:nodoc: all
+
+  def name
+    @name ||= Dramatis::Actor::Name.new self
+  end
+
+  attr_reader :object_interface
+  attr_reader :object
+  attr_reader :gate
+  attr_reader :call_thread
+
+  def initialize object = nil
+    @call_threading = false
+    @call_thread = nil
+    @object = object
+    @gate = Dramatis::Runtime::Gate.new
+    if !object
+      @gate.refuse :object
+    end
+    @gate.always( ( [ :object, :dramatis_exception ] ), true )
+    blocked!
+    @queue = []
+    @mutex = Mutex.new
+    @continuations = {}
+    @object_interface = Dramatis::Actor::Interface.new self
+    Dramatis::Runtime::Scheduler.current << self
+  end
+  
+  def call_threading?
+    @call_threading
+  end
+
+  def enable_call_threading
+    @call_threading = true
+  end
+
+  def current_call_thread? that
+    # warn "current_call_thread? #{@call_thread} #{(@call_thread and (@call_thread == that)).inspect} #{that}"
+    @call_thread and @call_thread == that
+  end
+
+  def object_initialize *args
+    @gate.accept :object
+    @object.send :initialize, *args
+  end
+
+  def yield; end
+
+  def bind object
+    raise Dramatis::Error::Bind if @object
+    @object = object
+    @gate.accept :object
+    name
+  end
+
+  def exception exception
+    if @object.respond_to? :dramatis_exception
+      @object.dramatis_exception exception
+    else
+      Dramatis::Runtime.current.exception exception
+    end
+    self
+  end
+
+  def deadlock e
+    tasks = nil
+    @mutex.synchronize do
+      tasks = @queue.dup
+      @queue.clear
+    end
+    tasks.each { |task| task.exception e }
+  end
+
+  def register_continuation c
+    # p "selfish", self, @continuations
+    # pp "csr", c.to_s
+    @continuations[c.to_s] = c
+  end
+
+  def actor_send args, opts
+    common_send :actor, args, opts
+  end
+
+  def object_send args, opts
+    t = nil
+    if opts[:continuation_send]
+      t = :continuation 
+      args.unshift opts[:continuation_send]
+    else
+      t = :object
+    end
+    common_send t, args, opts
+  end
+
+  def common_send dest, args, opts
+
+    # warn "common send #{self} #{dest} #{args[0]}"
+    # warn "common send #{self} #{dest} #{args.join(' ')} #{opts.to_a.join(' ' )}"
+
+    task = Dramatis::Runtime::Task.new( self, dest, args, opts  )
+    
+    # warn "#{task.type} #{task.method}"
+    # warn "#{self} #{Thread.current} common send r? #{runnable?} g? #{@gate.accepts?( *( [ task.type, task.method ] + task.arguments )  ) } q #{@queue.length}"
+    @mutex.synchronize do
+      # FIX arguments to gate
+      if !runnable? and ( @gate.accepts?(  *( [ task.type, task.method ] + task.arguments ) ) or current_call_thread?( task.call_thread ) )
+        runnable!
+        Dramatis::Runtime::Scheduler.current.schedule task
+      else
+        # warn "+>schd #{self} #{@queue.join(' ')}"
+        @queue << task
+        # warn "+<schd #{self} #{@queue.join(' ')}"
+      end
+    end
+
+    task.queued
+
+  end
+
+  def deliver dest, args, continuation, call_thread
+    old_call_thread = @call_thread
+    begin
+      @call_thread = call_thread
+      method = args.shift
+      # warn "switch " + dest.to_s + " " + method.to_s
+      result = 
+        case dest
+        when :actor
+          # FIX: do name folding; needs test
+          self.send method, *args
+          # p "sent actor #{method}"
+        when :object
+          # p "send object #{@object} #{method} #{args.length}"
+          v = @object.send method, *args
+          if v.object_id == @object.object_id
+            v = name
+          end
+          # p "sent object #{method}"
+          v
+        when :continuation
+          # FIX: name folding?
+          # p "send continuation #{method}"
+          continuation_name = method
+          # warn "c is #{continuation_name}"
+          c = @continuations[continuation_name]
+          # pp "cs", @continuations.keys
+          raise "hell 0 #{Thread.current}" if !c
+          method = args.shift
+          method = case method
+                     when :result; :continuation_result
+                     when :exception; :continuation_exception
+                     else; raise "hell *"
+                   end
+          # pp c.to_s, "send", method, args
+          c.send method, *args
+          @continuations.delete continuation_name
+          # pp "csd", continuation_name, @continuations.keys
+        else
+          raise "hell 1: " + @dest.to_s
+        end
+      # p "call c '#{result}'"
+      # p continuation.to_s
+      continuation.result result
+      # p "called c #{result}"
+    rescue Exception => exception
+      # pp "0 exception ", exception
+      # pp exception.backtrace
+      begin
+        continuation.exception exception
+      rescue Exception => e
+        warn "double exception fault: #{e}"
+        pp e
+        raise e
+      end
+    ensure
+      @call_thread = old_call_thread
+      schedule
+    end
+  end
+
+  # note called from task.rb, too
+  def schedule continuation = nil
+    @mutex.synchronize do
+      # warn ">schd #{self} #{@state} #{@queue.join(' ')}"
+      task = nil
+      index = 0
+      while task == nil and index < @queue.length do
+        candidate = @queue[index]
+        # FIX arugments?
+        if @gate.accepts?( *( [ candidate.type, candidate.method ] + candidate.arguments ) ) or
+           current_call_thread? candidate.call_thread
+          task = candidate
+          @queue[index,1] = []
+        end
+        index += 1
+      end
+      if task 
+        Dramatis::Runtime::Scheduler.current.schedule task
+      else
+        blocked!
+      end
+      # warn "<schd #{self} #{@queue.join(' ')} #{@state} #{Thread.current}"
+    end
+  end
+
+  def blocked!
+    # warn "blocked! #{self} #{@state}"
+    @state = :blocked
+  end
+
+  def runnable!
+    # warn "runnable! #{self} #{@state}"
+    @state = :runnable
+  end
+
+  def runnable?
+    # warn "runnable? #{self} #{@state}"
+    @state == :runnable
+  end
+
+  def timeout value, *args
+    @timer ||= Dramatis::Runtime::Timer.new
+  end
+
+end
+
+# Might be nice if this was broken out into another file ... YAGNI?
+# This needs to be reworked. External threads and the main thread are
+# related but different (there can only be one main thread). Mutliple
+# at_exit calls are suspect. Of course, if the main actor tracks multilple
+# runtimes, it might be okay.
+
+class Dramatis::Runtime::Actor::Main < Dramatis::Runtime::Actor  #:nodoc: all
+
+  class DefaultBehavior
+
+    class Exception < ::Exception; end
+
+    def method_missing *args
+      raise Exception.new( "must use Actor#become to enable main actor" )
+    end
+
+    def dramatis_exception e
+      if Dramatis::Runtime.current.warnings?
+        warn "exception on main thread: #{e}"
+        # pp caller
+      end
+      Dramatis::Runtime.current.exception e
+    end
+
+  end
+
+  @@current = nil
+
+  def self.current
+    @@current ||= self.new
+  end
+
+  def self.reset
+    @@current = nil
+  end
+
+  def quiesce
+    schedule
+  end
+
+  def finalize
+    if !@at_exit_run
+      @at_exit_run = true
+      schedule
+      Dramatis::Runtime::Scheduler.current.main_at_exit
+    end
+  end
+
+  def initialize
+    super DefaultBehavior.new
+    @at_exit_run = false
+    at_exit { finalize }
+    runnable!
+  end
+
+end

data/lib/dramatis/runtime/gate.rb

@@ -0,0 +1,244 @@
+module Dramatis; end
+class Dramatis::Runtime; end
+
+begin require 'pp'; rescue Exception; end
+
+class Dramatis::Runtime::Gate  #:nodoc: all
+
+  def self.new
+    gate = Case.new
+    gate.accept Object
+    gate.accept :actor
+    gate.accept :continuation
+    gate.accept :object
+    gate
+  end
+
+  class Case
+    def always args, value, options = {}
+      _change @always, Array( args ), value, options
+    end
+    def only args, options = {}
+      _change @list, [ :object ], false, options
+      _change @list, [ :continuation ], false, options
+      _change @list, [ :continuation, Object, :exception ], true, options
+      _change @list, Array( args ), true, options
+    end
+    def default args, options = {}
+      _change @list, args, nil, options
+    end
+    def default_by_tag tag
+      _change @list, nil, nil, { :tag => tag }
+    end
+    def _change list, args, value, options = {}
+      inplace = options[ :inplace ]
+      tag = options[ :tag ]
+      # pp ">> #{args and args.join(' ')} #{value} #{inplace} #{tag}", list
+      prepend = true
+      tbd = []
+      list.each_with_index do |entry, list_index|
+        vector, result, entry_tag = entry
+        matches = true
+        if tag and entry_tag != tag
+          # p "#{tag} tag and #{entry_tag} dont' match"
+          next
+        end
+        if args
+          args.each_with_index do |arg, arg_index|
+            # p "compare #{vector[arg_index]} #{arg}"
+            if vector[arg_index] != arg
+              # p "matches"
+              matches = false
+              break
+            end
+          end
+        end
+        if matches
+          # p "matched"
+          if inplace and value != nil
+            # p "inplace"
+            list[list_index][1] = value
+            # FIX: tag?
+            prepend = false
+          else
+            # p "schedule remove #{list[list_index].join(' ')} at #{list_index}"
+            tbd << list_index
+            # list[list_index,1] = []
+          end
+          # break
+        end
+      end
+      tbd.reverse.each do |index|
+        # p "remove #{index} #{list[index].join(' ')} at #{index}"
+        list[index,1] = []
+      end
+      if prepend and value != nil
+        list.unshift [ args, value, tag ]
+      end
+      # pp "<< #{args and args.join(' ')} #{value} #{inplace} #{tag}", list
+    end
+    def change args, value, inplace
+      # pp "> #{args.join(' ')} #{value} #{inplace}", @list
+      prepend = true
+      @list.each_with_index do |entry, list_index|
+        vector, result = entry
+        matches = true
+        args.each_with_index do |arg, arg_index|
+          # p "compare #{vector[arg_index]} #{arg}"
+          if vector[arg_index] != arg
+            # p "matches"
+            matches = false
+            break
+          end
+        end
+        if matches
+          # p "matched"
+          if inplace
+            # p "inplace"
+            @list[list_index][1] = value
+            # FIX: tag?
+            prepend = false
+          else
+            @list[list_index,1] = []
+          end
+          break
+        end
+      end
+      if prepend
+        @list.unshift [ args, value ]
+      end
+      # pp "<", @list
+    end
+    def accept *args
+      change args, true, false
+    end
+    def refuse *args
+      change args, false, false
+    end
+    def update value, *args
+    end
+    def accepts? *args
+      # p "accepts? #{args.join(" ")}"
+      accepted = nil
+      ( @always + @list ).each do |entry|
+        vector, result = entry
+        matches = true
+        vector.each_with_index do |v, i|
+          # warn "#{v} #{args[i]} => #{v === args[i]} so #{result}"
+          if not( v === args[i] )
+            matches = false
+            break
+          end
+        end
+        if matches
+          accepted = result
+          break
+        end
+      end
+      # warn "last '#{accepted}'"
+      # p "accepts? #{args.join(" ")} => '#{accepted}'"
+      accepted == true
+    end
+    def initialize
+      @always = []
+      @list = []
+    end
+    def list
+      @list
+    end
+  end
+
+  class Constant
+    def initialize constant
+      @constant = constant
+    end
+    def accepts? *args
+      @constant
+    end
+    def refuse *args
+      warn "HELLL"
+      raise "hell"
+    end
+    def accept *args
+      warn "HELLL"
+      raise "hell"
+    end
+    def default *args
+      warn "HELLL"
+      raise "hell"
+    end
+    def set_default *args
+      warn "HELLL"
+      raise "hell"
+    end
+  end
+
+  ACCEPT = Constant.new true
+  REJECT = Constant.new false
+
+  class Hash
+
+    def initialize default, hash = {}
+      @default = default
+      @hash = hash.clone
+      @queued = {}
+      track and warn "create default = #{@default} hash = [#{@hash.keys.join(' ')}]"
+      @always = []
+      @call_thread = nil
+    end
+
+    def track; false; end
+
+    def always *args
+      track and warn "always [#{args.join(' ')}]"
+      @always << args
+    end
+
+    def refuse *args
+      track and warn "refuse [#{args.join(' ')}]"
+      if args.length == 1
+        @hash[args[0]] = REJECT
+      else
+        @hash[args[0]].refuse( *args[1,args.length] )
+      end
+    end
+
+    def accept *args
+      track and warn "accept [#{args.join(' ')}]"
+      if args.length == 1
+        @hash[args[0]] = ACCEPT
+      else
+        @hash[args[0]].accept( *args[1,args.length] )
+      end
+    end
+
+    def default *args
+      track and warn "default [#{args.join(' ')}]"
+      if args.length == 1
+        @hash.delete args[0]
+      else
+        @hash[args[0]].default( *args[1,args.length] )
+      end
+    end
+
+    def set_default value, *args
+      track and warn "default = #{value} [#{args.join(' ')}] #{args.length}"
+      if args.length == 0
+        @default = value
+      else
+        @hash[args[0]].set_default value, *args[1,args.length]
+      end
+    end
+
+    def accepts? *args
+      v = nil
+      if v == nil 
+        v = @hash.has_key?( args[0] ) ? @hash[args[0]].accepts?( *args[1,args.length] ) : @default
+      end
+      track and warn "accepts? [#{args.join(' ')}] => #{v}"
+      v
+    end
+
+  end
+
+end