gisele-vm 0.6.0

data/lib/gisele/vm/kernel/opcodes.rb

@@ -0,0 +1,212 @@
+module Gisele
+  class VM
+    class Kernel
+      module Opcodes
+
+      private
+
+        ### GENERIC OPCODES ################################################################
+
+        # Pops a method name on the stack unless `method` is specified. Pops an array of
+        # argument `args`. Pops an object `receiver`. Invoke `method` on `receiver`, passing
+        # arguments `args`. Push the result back on the stack.
+        def op_send(method = nil, push_result = true)
+          method ||= pop
+          args     = pop
+          receiver = pop
+          result   = receiver.send(method, *args)
+          push result if push_result
+        end
+
+        # Same as `op_send` but does not keep the result on the stack.
+        def op_invoke(method = nil)
+          op_send(method, false)
+        end
+
+        # Push the value of the attribute `attrname` of the top object. If `attrname` is not
+        # specified, pops it from the stack first.
+        def op_get(attrname = nil, remove=false)
+          attrname ||= pop
+          receiver = remove ? pop : peek
+          if receiver.respond_to?(:[])
+            push receiver[attrname]
+          elsif receiver.respond_to?(attrname)
+            push receiver.send(attrname)
+          else
+            raise Error, "Unable to get #{attrname} on #{receiver.inspect}"
+          end
+        end
+
+        # Same as +get+ but removes the original receiver from the stack.
+        def op_getr(attrname = nil)
+          op_get(attrname, true)
+        end
+
+        # If `attrname` is unspecified, pops it from the stack first. Pops a value `val`
+        # from the stack. Set attribute `attrname` to `val` on the top object.
+        def op_set(attrname = nil)
+          attrname ||= pop
+          attrvalue  = pop
+          receiver   = peek
+          if receiver.respond_to?(:[]=)
+            receiver[attrname] = attrvalue
+          elsif receiver.respond_to?(:"#{attrname}=")
+            receiver.send(:"#{attrname}=", attrvalue)
+          else
+            raise Error, "Unable to set #{attrname} on #{receiver.inspect}"
+          end
+        end
+
+        # If `attrname` is unspecified, pops it from the stack first. Expects an object
+        # responding to :delete on top of the stack. Pops it, call `delete(attrname)` on
+        # a duplicate and push the later back on the stack.
+        def op_del(attrname = nil)
+          attrname ||= pop
+          push pop.dup
+          peek.delete(attrname)
+        end
+
+        ### CONTROL ########################################################################
+
+        # Does nothing at all
+        def op_nop
+        end
+
+        # Pushes opcodes at label `at` on the code queue. If `at` is unspecified, it it
+        # poped from the stack first
+        def op_then(at = nil)
+          enlist_bytecode_at(at || pop)
+        end
+
+        # If the peek object is equal to `val`, flip top operations and skip the first one.
+        # Otherwise skip the top operation.
+        def op_ifeeq(val = nil)
+          if peek == val
+            t = opcodes.shift
+            opcodes.shift
+            opcodes.unshift t
+          else
+            opcodes.shift
+          end
+        end
+
+        # If the peek object is nil, flip top operations and skip the first one. Otherwise
+        # skip the top operation.
+        def op_ifenil
+          op_ifeeq(nil)
+        end
+
+        # If the peek object is zero, flip top operations and skip the first one. Otherwise
+        # skip the top operation.
+        def op_ifezero
+          op_ifeeq(0)
+        end
+
+        ### LIFECYCLE ######################################################################
+
+        # Puts the puid of the executing Prog on the stack
+        def op_puid
+          push puid
+        end
+
+        # Push the current Prog on the stack.
+        def op_self
+          push prog
+        end
+
+        # Pushes the parent Prog of the executing program.
+        def op_parent
+          push(prog.parent==prog.puid ? nil : vm.fetch(prog.parent))
+        end
+
+        # Fetches the Prog whose id is `puid` and pushes it on the stack. if `puid` is not
+        # specified, pops it from the stack first.
+        def op_fetch(puid = nil)
+          push vm.fetch(puid || pop)
+        end
+
+        def fork(at)
+          Prog.new({
+            :parent  => puid,
+            :pc      => at,
+            :waitfor => :enacter,
+            :root    => prog && prog.root
+          })
+        end
+        private :fork
+
+        # Fork the current Prog. Set its program counter to `at` (taken from the stack if
+        # not specified), and mark it as schedulable by default. The resulting Prog is
+        # pushed on the stack. It is not saved.
+        def op_fork(at = nil)
+          push fork(at || pop)
+        end
+
+        # Expects an array of labels on the stack. Same as +fork+ but in array version.
+        # A resulting array of unsaved Prog is put back on the stack.
+        def op_forka(at = nil)
+          at ||= pop
+          push at.map{|l| fork(l)}
+        end
+
+        # Pops `n` programs from the stack and save them. Pushes their puid back on
+        # the stack after saving, in the original order. `n` is considered 1 if unspecified.
+        def op_save(n = nil)
+          progs = pop(n || 1)
+          puids = vm.save(progs)
+          puids.reverse.each{|puid| push(puid)}
+        end
+
+        # Expects an array of Progs on the stack. Similar to +save+ but in array version.
+        # Push the resulting puids back on the stack in an array.
+        def op_savea
+          push vm.save(pop)
+        end
+
+        ### DATA STACK MANAGEMENT ##########################################################
+
+        # Pushes `arg` on the data stack.
+        def op_push(arg)
+          push arg
+        end
+
+        # Pops the top element from the stack.
+        def op_pop(n = nil)
+          pop(n)
+        end
+
+        # Flips the two elements on top of the stack
+        def op_flip
+          pop(2).each{|e| push(e)}
+        end
+
+        # Pops `n` elements from the stack, keep them in a new array and push the later
+        # back on the stack. If `n` is not provided, it is taken from the stack first.
+        def op_fold(nb = nil)
+          n, arr = (nb || pop), []
+          n.times{ arr << pop }
+          push arr.reverse
+        end
+
+        # Pops an array. Unfolds it on the stack.
+        def op_unfold
+          pop.each do |elm|
+            push elm
+          end
+        end
+
+        ### EVENT HANDLING #################################################################
+
+        # Pops event arguments from the stack (an array). Send an event of the specified
+        # kind on the event interface. If `type` is not provided, it is first poped from
+        # the stack
+        def op_event(type = nil)
+          type ||= pop
+          args = pop
+          vm.event(Event.new(prog, type, args))
+        end
+
+      end # module Opcodes
+    end # class Kernel
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/kernel/runner.rb

@@ -0,0 +1,63 @@
+module Gisele
+  class VM
+    class Kernel
+      class Runner
+        include Opcodes
+
+        attr_reader :vm
+        attr_reader :opcodes
+        attr_reader :prog
+
+        def initialize(vm = VM.new, prog = nil)
+          @vm       = vm
+          @prog     = prog
+          @stack    = []
+          @opcodes  = []
+        end
+
+        def run(at = nil, stack = [])
+          @stack = stack
+          enlist_bytecode_at(at) if at
+          until @opcodes.empty?
+            op = @opcodes.shift
+            send :"op_#{op.first}", *op[1..-1]
+          end
+          @stack
+        end
+
+      private
+
+        ### self
+
+        def puid
+          prog && prog.puid
+        end
+
+        ### stack
+
+        def push(x)
+          @stack << x
+        end
+
+        def pop(n = nil)
+          if n.nil?
+            @stack.pop
+          else
+            n.times.map{ @stack.pop }
+          end
+        end
+
+        def peek
+          @stack.last
+        end
+
+        ### code
+
+        def enlist_bytecode_at(label)
+          @opcodes += vm.bytecode[label]
+        end
+
+      end # class Runner
+    end # class Kernel
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/lifecycle.rb

@@ -0,0 +1,72 @@
+module Gisele
+  class VM
+    module Lifecycle
+
+      attr_reader :status
+      attr_reader :last_error
+
+      def stopped?
+        @status == :stopped
+      end
+
+      def running?
+        @status == :running
+      end
+
+      def warmup?
+        @status == :warmup
+      end
+
+      def shutdown?
+        @status == :shutdown
+      end
+
+      def run
+        raise InvalidStateError, "VM already running" unless stopped?
+        if EM.reactor_running?
+          starter
+          EM.reactor_thread.join
+        else
+          EM.error_handler do |ex|
+            fatal("EventMachine crashed: #{ex.message}\n" + ex.backtrace.join("\n"))
+            if warmup?
+              @status = :stopped
+              EM.stop_event_loop
+            end
+          end
+          EM::run &method(:starter)
+        end
+      end
+
+      def stop
+        raise InvalidStateError, "VM not running" unless running?
+        @status = :shutdown
+        info('VM stop request received, disconnecting.')
+        registry.disconnect
+        EM.stop_event_loop
+        @status = :stopped
+        info('VM stopped successfully.')
+      end
+
+    private
+
+      def init_lifecycle
+        @status = :stopped
+      end
+
+      def starter
+        @last_error = nil
+        @status     = :warmup
+        info('VM start request received, connecting.')
+        registry.connect
+        info('Gisele VM has taken stage!')
+        @status = :running
+      rescue Exception => ex
+        fatal("VM start failed.")
+        @last_error = ex
+        raise
+      end
+
+    end # module Lifecycle
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/logging.rb

@@ -0,0 +1,18 @@
+module Gisele
+  class VM
+    module Logging
+      extend Forwardable
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def logger
+        @logger ||= NullObject.new
+      end
+
+      def_delegators :logger, :debug,  :info,  :warn,  :error,  :fatal
+      def_delegators :logger, :debug?, :info?, :warn?, :error?, :fatal?
+    end # module Logging
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/null_object.rb

@@ -0,0 +1,19 @@
+module Gisele
+  class VM
+    class NullObject < BasicObject
+
+      def method_missing(*args)
+        self
+      end
+
+      [ :debug?, :info?, :warn?, :error?, :fatal? ].each do |meth|
+        define_method(meth){ false }
+      end
+
+      def to_s
+        ''
+      end
+
+    end # class NullObject
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/prog.rb

@@ -0,0 +1,63 @@
+module Gisele
+  class VM
+    class Prog
+      attr_accessor :puid
+      attr_accessor :parent
+      attr_accessor :root
+      attr_accessor :pc
+      attr_accessor :waitfor
+      attr_reader   :waitlist
+      attr_accessor :input
+
+      def initialize(attrs = {})
+        @puid     = attrs[:puid]     || nil
+        @parent   = attrs[:parent]   || @puid
+        @root     = attrs[:root]     || @puid
+        @pc       = attrs[:pc]       || :main
+        @waitfor  = attrs[:waitfor]  || :none
+        @waitlist = attrs[:waitlist] || {}
+        @input    = attrs[:input]    || []
+      end
+
+      def waitlist=(wlist)
+        wlist = Hash[wlist.map{|x| [x,true]}] unless Hash===wlist
+        @waitlist = wlist
+      end
+
+      def to_hash(keys = nil)
+        if keys
+          h = {}
+          keys.each do |k|
+            h[k] = instance_variable_get(:"@#{k}")
+          end
+          h
+        else
+          { :puid     => puid,
+            :parent   => parent,
+            :root     => root,
+            :pc       => pc,
+            :waitfor  => waitfor,
+            :waitlist => waitlist,
+            :input    => input }
+        end
+      end
+
+      def dup
+        super.tap do |c|
+          c.waitlist = waitlist.dup
+          c.input    = input.dup
+        end
+      end
+
+      def ==(other)
+        other.is_a?(Prog) and (other.to_hash == to_hash)
+      end
+      alias :eql? :==
+
+      def to_s
+        "Prog(#{puid.inspect})"
+      end
+
+    end # class Prog
+  end # class VM
+end # module Gisele