Steps toward a generalised big-bang

os.rkt

@@ -0,0 +1,100 @@
+#lang racket/base
+
+;; Virtualized operating system.
+
+(require racket/match)
+(require "functional-queue.rkt")
+
+(provide ...)
+
+;; Each VM hosts 0 or more *multiplexed* processes. Each process has
+;; its own state record. In between schedulings, a process consists of
+;; 1 or more event handlers. An event handler is a pair of an event
+;; recogniser and a procedure taking an event and a process state to a
+;; new process state.
+;;
+;; Each VM provides a *communication bus* for its processes to
+;; use. The communication bus is the only form of IPC the VM provides.
+;;
+;; Some processes *relay* messages out from the VM to other
+;; VMs. Because the "tree" of VMs so formed has to be a tree - See
+;; Shivers & Might 2006 for a discussion of this - we gather together
+;; all the interactions between the supervenient VM and its support VM
+;; into a single channel of communication. The relaying processes are,
+;; in effect, device-drivers, providing application-specific
+;; communication services to other processes in the VM.
+;;
+;; We split processes into "user" processes, permitted only to spawn
+;; other user processes and send messages on the VM's bus, and
+;; "kernel" processes, permitted also to spawn other kernel processes
+;; and send messages to the VM's container.
+;;
+;; Time plays an interesting role in a distributed system: if the
+;; medium messages are sent through isn't cooperative enough to let us
+;; know of a failed conversational participant, our only recourse is
+;; /timeout/. Therefore, we require every level of the machine to
+;; support timeouts, though we do not require such timeouts to be tied
+;; to real, wall-clock time: simulated time is just fine. This helps
+;; with testability.
+;;
+;; Racket's alarm-evt is almost the right design for timeouts: its
+;; synchronisation value should be the (or some) value of the clock
+;; after the asked-for time. That way it serves as timeout and
+;; clock-reader in one.
+
+;; VMs are parameterised over:
+;;  - the type of messages carried on the bus, Message
+;;  - the type of patterns over Messages, MessageEvent
+;;  - the type of messages to other VMs, MetaMessage
+;;  - the type of patterns over MetaMessages, MetaMessageEvent
+
+;; A VM is a (vm Map<Pid,Process>
+;;               QueueOf<Message>
+;;               QueueOf<InterruptK>).
+(struct vm (process-table pending-messages runnable) #:transparent)
+
+;; A Pid is some eq?-comparable object, guaranteed to be unique within
+;; the scope of a single VM. It IDentifies a Process.
+
+;; A Sid is some eq?-comparable object, guaranteed to be unique within
+;; the scope of a single VM's process. It IDentifies a Subscription.
+
+;; A Subscription is a (subscription Sid (Message -> Boolean) TrapK).
+(struct subscription (sid predicate handler) #:transparent)
+
+;; An Action is one of
+;; -- (send-message Message), a message to emit onto the bus
+;; -- (spawn-process InterruptK), a new sibling process to start
+;; -- (subscribe sid 
+
+;; A TrapK is a Message -> InterruptK, representing a suspended
+;; process waiting for some information from the VM before it can
+;; continue.
+
+;; An InterruptK is a
+;;                        ProcessState SetOf<Subscription>
+;;     -> ListOf<Message> ProcessState SetOf<Subscription> ListOf<InterruptK>
+;;
+;; representing a suspended process that can run instantly without
+;; waiting for more information from the VM. The inputs are the state
+;; of the process and its current set of subscriptions, and the
+;; outputs are a list of messages to emit into the VM's communication
+;; bus, as well as possibly-updated process state and subscription
+;; list, and a list of new processes to spawn.
+
+(define (make-vm boot)
+  (vm (hash)
+      (make-queue)
+      (enqueue (make-queue) boot)))
+
+;; VM SetOf<MetaSubscription> -> ListOf<MetaMessage> VM SetOf<MetaSubscription>
+;; (A kind of Meta-InterruptK)
+(define (run-vm state meta-subscriptions)
+  (define state-after-dispatch
+    (foldl dispatch-message
+	   (struct-copy vm state [pending-messages (make-queue)])
+	   (vm-pending-messages state)))
+  (define state-after-run
+    (foldl run-process
+	   (struct-copy vm state [runnable (make-queue)])
+	   (vm-runnable state)))