gisele-vm 0.6.0

data/lib/gisele/vm/console.rb

@@ -0,0 +1,58 @@
+module Gisele
+  class VM
+    class Console < Component
+
+      module Handler
+        attr_accessor :interactive
+        def notify_readable
+          case s = @io.readline.strip
+          when /^l(ist)?$/           then interactive.list_action
+          when /^n(ew)?\s+(.+)$/     then interactive.new_action($2)
+          when /^r(esume)?\s+(.+)$/  then interactive.resume_action($2)
+          when /^q(uit)?$/           then interactive.stop_action
+          else
+            puts "Unrecognized: #{s}" unless s.empty?
+          end
+        rescue Exception => ex
+          puts "ERROR: #{ex.message}"
+        ensure
+          interactive.prompt if interactive.connected?
+        end
+      end
+
+      def enter_heartbeat
+        EM.watch($stdin, Handler){|c|
+          c.interactive = self
+          c.notify_readable = true
+        }
+        prompt
+      end
+
+      def prompt
+        $stdout << "\n? Please choose an action:(list, new, resume or quit)\ngisele-vm> "
+      end
+
+      def list_action(lispy = Alf.lispy)
+        rel = vm.progs
+        rel = lispy.extend(rel, :waitlist => lambda{ waitlist.keys })
+        rel = lispy.group(rel, [:root], :progs, :allbut => true)
+        puts rel.to_relation
+      end
+
+      def new_action(args)
+        vm.start(:main, [ args.strip.to_sym ])
+      end
+
+      def resume_action(args)
+        puid, *input = args.split(/\s+/)
+        input = input.map{|x| Bytecode::Grammar.parse(x, :root => :arg).value}
+        vm.resume(puid, input)
+      end
+
+      def stop_action
+        vm.stop
+      end
+
+    end # class Console
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/enacter.rb

@@ -0,0 +1,29 @@
+module Gisele
+  class VM
+    class Enacter < Component
+
+      def enter_heartbeat
+        @timer = EM.add_periodic_timer(0.01, &method(:enact))
+      end
+
+      def leave_heartbeat
+        @timer.cancel
+      end
+
+    private
+
+      def enact
+        prog = vm.pick(:waitfor => :enacter)
+        enact_one(prog) if prog
+      end
+
+      def enact_one(prog)
+        debug("Enacting Prog #{prog.puid}@#{prog.pc}")
+        vm.progress(prog)
+      rescue Exception => ex
+        error error_message(ex, "Progress error (#{prog.puid}):")
+      end
+
+    end # class Enacter
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/errors.rb

@@ -0,0 +1,26 @@
+module Gisele
+  class VM
+
+    class Error < StandardError
+    end # class Error
+
+    class InvalidBytecodeError < Error
+    end # class InvalidBytecodeError
+
+    class InvalidLabelError < Error
+    end # class InvalidLabelError
+
+    class InvalidInputError < Error
+    end # class InvalidInputError
+
+    class InvalidStateError < Error
+    end # class InvalidStateError
+
+    class BadUsageError < Error
+    end # BadUsageError
+
+    class InvalidPUIDError < Error
+    end # class InvalidPUIDError
+
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/event.rb

@@ -0,0 +1,11 @@
+module Gisele
+  class VM
+    class Event < Struct.new(:prog, :type, :args)
+
+      def to_s
+        "#{type}[#{prog.puid}](#{args.join(', ')})"
+      end
+
+    end # class Event
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/event_manager.rb

@@ -0,0 +1,65 @@
+module Gisele
+  class VM
+    class EventManager < Component
+
+      def initialize
+        super()
+        @listeners = []
+      end
+
+      def connect
+        super
+        @channel, @names = EM::Channel.new, {}
+        @listeners.each do |l|
+          em_subscribe(l)
+        end
+      end
+
+      def disconnect
+        super
+        @listeners.each do |l|
+          em_unsubscribe(l)
+        end
+        @channel = @names = nil
+      end
+
+      def subscribe(a = nil, &b)
+        @listeners << (a || b)
+        em_subscribe(@listeners.last) if connected?
+      end
+
+      def unsubscribe(l)
+        if @listeners.delete(l) and connected?
+          em_unsubscribe(l)
+        end
+      end
+
+      def subscribed?(l)
+        @listeners.include?(l)
+      end
+
+      def event(event)
+        debug(event.to_s)
+        @channel.push(event) if connected?
+      rescue Exception => ex
+        error error_message(ex, "Error when processing `#{event.to_s}`")
+      end
+
+    private
+
+      def name_of(l)
+        @names[l]
+      end
+
+      def em_subscribe(l)
+        @names[l] = @channel.subscribe(l)
+      end
+
+      def em_unsubscribe(l)
+        @channel.unsubscribe(@names[l])
+        @names.delete(l)
+      end
+
+    end # class EventManager
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/kernel.rb

@@ -0,0 +1,58 @@
+module Gisele
+  class VM
+    class Kernel < Component
+      include Robustness
+
+      def self.bytecode
+        @kernelbc ||= Bytecode.parse(Path.dir/'kernel/macros.gvm')
+      end
+
+      def_delegators :vm, :pick,
+                          :fetch,
+                          :save,
+                          :event
+
+      def start(at, input)
+        at    = valid_label!(at)
+        input = valid_input!(input)
+
+        runner(nil) do |k|
+          stack = k.run(:start, [ input, at ])
+          stack.first
+        end
+      end
+
+      def resume(puid, input)
+        prog  = Prog===puid ? puid : fetch(puid)
+        prog  = valid_prog!(puid, :world)
+        input = valid_input!(input)
+
+        runner(prog) do |k|
+          k.run(:resume, [ input ])
+        end
+      end
+
+      def progress(puid)
+        prog = valid_prog!(puid, :enacter)
+
+        runner(prog) do |k|
+          k.run(:progress, [ ])
+        end
+      end
+
+    private
+
+      def runner(prog = nil)
+        if block_given?
+          yield Runner.new(vm, prog)
+        else
+          Runner.new(vm, prog)
+        end
+      end
+
+    end # class Kernel
+  end # class VM
+end # module Gisele
+require_relative 'kernel/opcodes'
+require_relative 'kernel/runner'
+

data/lib/gisele/vm/kernel/macros.gvm

@@ -0,0 +1,214 @@
+# Make the current Prog progress by running it on its input.
+#
+# INPUT:  [ ]
+# OUTPUT: [ ]
+# PRE:    - the current Prog must be scheduled (waitfor: enacter)
+#         - its input must be set as well as its program counter
+# POST:   - the Prog has been executed on its input
+#         - its input is now [ ]
+#
+progress: self                       # [ Prog ]
+          get :pc                    # [ Prog, pc ]
+          then                       # [ Prog ]       # enqueue instructions at pc
+          get :input                 # [ Prog, [input...] ]
+          flip                       # [ [ input... ], Prog ]
+          push []                    # [ [input...], Prog, [] ]
+          set :input                 # [ [input...], Prog ]
+          save                       # [ [input...], puid ]
+          pop                        # [ [input...] ]
+          unfold                     # [ input... ]
+
+# Forks a fresh new process and schedules it for running at a given label.
+#
+# INPUT:  [ [input...], `startat` ]
+# OUTPUT: [ puid ]
+# PRE:    - true
+# POST:   - a new process has been created
+#         - it is scheduled for running at `startat`
+#         - its input has been set to `input`
+#
+start:  fork                        # [ [input...], Prog ]
+        flip                        # [ Prog, [input...] ]
+        set :input                  # [ Prog ]
+        save                        # [ puid ]
+
+# Schedule the current prog and set its input.
+#
+# INPUT:  [ [input...] ]
+# OUTPUT: [ ]
+# PRE:    - the current Prog should not be scheduled
+# POST:   - the current Prog is scheduled
+#         - its input is set to `input`
+#
+resume:  self                       # [ input, Prog ]
+         push :enacter              # [ input, Prog, :enacter ]
+         set :waitfor               # [ input, Prog ]
+         flip                       # [ input, Prog ] -> [ Prog, input ]
+         set :input                 # [ Prog ]
+         then :save_it              # [ ]
+
+# Given a Prog on the stack, simply saves it.
+#
+# INPUT:  [ Prog ] (aka `peek`)
+# OUTPUT: [ ]
+# PRE:    - `peek` should have been modified
+# POST:   - `peek` is now saved
+#
+save_it: save
+         pop
+
+# Given a label on the stack, schedule the current Prog for execution there. The effective
+# execution will only take place when the Prog will be selected for running.
+#
+# INPUT:  [ `at` ]
+# OUTPUT: [ ]
+# PRE:    - `at` must be a valid label
+# POST:   - the current Prog is scheduled and its program counter set to `at` (and it is
+#           saved)
+#         - its waiting list is empty
+#
+schedule_at: self                       # [ pc, Prog ]
+             flip                       # [ Prog, pc ]
+             set :pc                    # [ Prog ]
+             push :enacter              # [ Prog, :enacter ]
+             set :waitfor               # [ Prog ]
+             push {}                    # [ Prog, {} ]
+             set :waitlist              # [ Prog ]
+             then :save_it              # [ ]
+
+# Given an event Hash on the stack. Registers it as waitlist. Unschedule the current prog
+# for continuation at :react.
+#
+# INPUT:  [ `events` ]
+# OUTPUT: [ ]
+# PRE:    - `events` should be a valid waitlist
+# POST:   - the current Prog sleeps at :react.
+#         - its waitlist has been set to `events`
+#
+listen:  self                       # [ events, Prog ]
+         flip                       # [ Prog, events ]
+         set  :waitlist             # [ Prog ]
+         push :world                # [ Prog, :world ]
+         set  :waitfor              # [ Prog ]
+         push :react                # [ Prog, :react ]
+         set  :pc                   # [ Prog ]
+         then :save_it              # [ ]
+
+# Given an event on the stack, get the current Prog, check if it waits for this particular
+# event. If yes, schedule the Prog as specified in its wait list. Otherwise, return to
+# sleep.
+#
+# INPUT:  [ `event` ]
+# OUTPUT: [ ]
+# PRE:    - the current Prog should be waiting for events (in its waitlist)
+# POST:   - if `event` is waited for, the current Prog is scheduled at the corresponding
+#           location.
+#         - otherwise, the current Prog falls alsleep (program counter unchanged)
+#
+react:       self                       # [ event, Prog ]
+             getr :waitlist             # [ event, waitlist ]
+             flip                       # [ waitlist, event ]
+             getr                       # [ pc/nil ]
+             ifenil                     #
+             then :react_sleep          #
+             then :schedule_at          #
+react_sleep: pop                        # [ ]
+             self                       # [ Prog ]
+             push :world                # [ Prog, :world ]
+             set  :waitfor              # [ Prog ]
+             then :save_it              #
+
+# Fork a list of children at specified locations. Wait for joining them at a label
+# `joinat` specified through the stack as well.
+#
+# INPUT:  [ joinat, [ forkat... ] ]
+# OUTPUT: [ Prog ]  (the current prog)
+# PRE:    - `joinat` is an existing label
+#         - `forkat` is an array of existing labels.
+# POST:   - a child Prog has been created for each label in `forkat`
+#         - those children are all scheduled
+#         - the current Prog waits for them all at `joinat` (not scheduled)
+#
+fork:    forka                      # [ joinat, [ Prog, ... ] ]
+         savea                      # [ joinat, [ puid, ... ] ]
+         self                       # [ joinat, [ puid, ... ], Prog ]
+         flip                       # [ joinat, Prog, [ puid, ... ] ]
+         set :waitlist              # [ joinat, Prog ]
+         flip                       # [ Prog, joinat ]
+         set :pc                    # [ Prog ]
+         push :children             # [ Prog, :children ]
+         set  :waitfor              # [ Prog ]
+         then :save_it              # [ ]
+
+# Given a Hash of events, if the waitlist of the current prog is empty, schedule execution
+# at the label associated to the `wake` event. Otherwise simply return asleep.
+#
+# INPUT:  [ {:wake => `wakeat`} ] (aka `events`)
+# OUTPUT: [ ]
+# PRE:    - `events` must include a :wake key
+#         - `wakeat` must be an existing label
+# POST:   - if the waitlist of the current prog is empty, it is scheduled at `wakeat`
+#         - if ... is not empty, it is unscheduled (program counter unchanged)
+#
+join:       self                       # [ {evt...}, Prog ]
+            getr :waitlist             # [ {evt...}, waitlist ]
+            push []
+            send :size                 # [ {evt...}, size ]
+            ifezero
+            push :wake
+            push :wait                 # [ {evt...}, size, wake/wait ]
+            flip                       # [ {evt...}, wake/wait, size ]
+            pop                        # [ {evt...}, wake/wait ]
+            get                        # [ {evt...}, label/nil ]
+            flip                       # [ label/nil, {evt...} ]
+            pop                        # [ label/nil ]
+            ifenil                     # ...
+            then :join_sleep           # [ ]
+            then :schedule_at          # [ ]
+join_sleep: pop
+            self
+            push :children
+            set  :waitfor
+            then :save_it
+
+# Expects a Prog on the stack (typically the parent). Remove the current puid from its
+# waitlist and schedule it.
+#
+# INPUT:  [ Prog ]  (aka peek)
+# OUTPUT: [ ]
+# PRE:    - the current `puid` should be a key in `peek`'s waitlist
+# POST:   - `peek`'s waitlist no longer contains an entry for `puid`
+#         - `peek` is scheduled
+#
+notify_it:  get :waitlist              # [ Prog, waitlist ]
+            puid                       # [ Prog, waitlist, puid ]
+            del                        # [ Prog, waitlist ]
+            set :waitlist              # [ Prog ]
+            push :enacter              # [ Prog, :enacter ]
+            set :waitfor               # [ Prog ]
+            then :save_it              # [ ]
+
+# End the current Prog then notify its parent through notify_it.
+#
+# INPUT:  [ ]
+# OUTPUT: [ ]
+# PRE:    - the current Prog should not be ended
+# POST:   - the program counter of the current Prog is -1
+# =>      - its waitfor attribute has been set to :none
+#         - its parent has been notified, if any (@see notify_it)
+#
+notify:     self                       # [ Prog ]
+            push -1                    # [ Prog, -1 ]
+            set :pc                    # [ Prog ]
+            push :none                 # [ Prog, :none ]
+            set :waitfor               # [ Prog ]
+            save                       # [ puid ]
+            pop                        # [ ]
+            parent                     # [ Prog/nil ]
+            ifenil
+            pop                        # [ ]
+            then :notify_it            # [ ]
+
+ping:       fold  1
+            event :pong
+            then :notify