3.2 Cooporative multitasking within vats

An individual vat is not parallel, i.e. only one object within a vat can be working at any given time, however vats can work with one another cooperatively to multitask. This is done by asynchronously messages to objects on other vats, possibly waiting for their reply and then continuing work.

In this way it’s important to not block a vat (e.g. by calling sleep or reading/writing to a port, etc.) as that will block the event loop and prevent the vat doing work. Instead we should be using Goblins’ promise system in places where we’d block.

Lets take the following example which has two actors ^sleeper, which sleeps for 10 seconds then returns 'awake, and ^hello which just returns the symbol 'hello. Both actors are spawned within the same vat, we then use another vat to invoke both of them at the same time ascynhronously:

(use-modules (goblins)
             (fibers))

(define-actor (^sleeper _bcom)
  (lambda ()
    (sleep 10)
    'awake))

(define-actor (^hello _bcom)
  (lambda ()
    'hello))

(define a-vat (spawn-vat))
(define sleeper
  (with-vat a-vat
    (spawn ^sleeper)))
(define hello
  (with-vat a-vat
    (spawn ^hello)))

(define b-vat (spawn-vat))
(with-vat b-vat
  (on (<- sleeper)
      (lambda (response)
        (pk 'sleeper-said response)))
  (on (<- hello)
      (lambda (response)
        (pk 'hello-said response))))

When we run this, the first thing we might notice is nothing happens for 10 seconds, then this is printed:

;;; (sleeper-said awake)

;;; (hello-said hello)

During those initial 10 seconds, the entire a-vat is blocked because of the (sleep 10) call, this stops other objects like our ^hello object from doing anything. Instead, we should rely on promises. The following code fixes the blocking issue:

(use-modules (goblins)
             (goblins vat)
             (fibers))

(define-actor (^sleeper _bcom)
  (lambda ()
    (define sleep-vow
      (spawn-fibrous-vow (lambda () (sleep 10) #t)))
    (on sleep-vow
        (lambda _
          'awake)
        #:promise? #t)))

(define-actor (^hello _bcom)
  (lambda ()
    'hello))

(define a-vat (spawn-vat))
(define sleeper
  (with-vat a-vat
    (spawn ^sleeper)))
(define hello
  (with-vat a-vat
    (spawn ^hello)))

(define b-vat (spawn-vat))
(with-vat b-vat
  (on (<- sleeper)
      (lambda (response)
        (pk 'sleeper-said response)))
  (on (<- hello)
      (lambda (response)
        (pk 'hello-said response))))

This time we get:

;;; (hello-said hello)

;;; (sleeper-said awake)

The initial response from ^hello occurs immediately when we run the code, then 10 seconds later we see ^sleeper’s response. This is because the vat is not blocked, we’re instead using spawn-fibrous-vow. Vats are built on top of the Fibers concurrency library. This procedure calls a thunk (a procedure of zero arguments) in a new fiber. By spawning a new fiber, the vat’s event loop fiber is not suspended when sleep is called. spawn-fibrous-vow returns a promise that will eventually resolve with the value returned by the thunk.

This sleep example could be made even easier by using Goblins’ built in timeout procedure provided by Timers module. Other tasks likely to block (e.g. reading or writing from ports or working with other blocking resources) could be written with IO module, which wraps the resource in a Goblins actor that ensures the vat is never blocked.