chickadee » termite

termite

Erlang style concurrency for Chicken Scheme

Documentation

Fundamental Operations

spawn

(spawn THUNK) procedure

Create a process running thunk and returns its pid.

!

(! PID MSG) procedure

Send msg to process pid.

?

(? [TIMEOUT [DEFAULT]]) procedure

Fetch a message from the mailbox. timeout is in seconds.

??

(?? PRED) procedure

Fetches next message that matches pred.

!?

(!? PID MSG [TIMEOUT [DEFAULT]]) procedure

Send msg to process pid and wait for a reply.

recv

(recv ((PAT VAR ACTION) [...]) [(after TIMEOUT TMO-ACTION)]) procedure

Receive a message, when it matches pat put it in var and take action (there can be many of these). Optionally, do tmo-action after timeout.

(This was documented from the termite.pdf, but it's not exported in chicken's termite.)

Create a process running thunk and returns its pid and link to it. When either process dies, and exception is raised in the other process.

spawn-linked-to

(spawn-linked-to THUNK TO) procedure

Create a process running thunk and returns its pid and have it link to to (a pid). When either process dies, and exception is raised in the other process.

Distributed Operations

make-node

(make-node HOST PORT) procedure

Creates a node object for host:port and returns the node object.

node-init

(node-init NODE) procedure

Primary setup for creating a node to accept processes.

remote-spawn

(remote-spawn NODE THUNK) procedure

Run thunk on node, returns pid. Node needs to have done a node-init.

Run thunk on node and link to it, returns pid.

on

(on NODE THUNK) procedure

Run thunk on node, returns result of thunk.

Error Handling

with-exception-catcher

(with-exception-catcher HANDLER BODY) procedure

Installs a dynamically scoped exception handler handler for the duration of body. Resumes execution a the point where the handler was installed.

with-exception-handler

(with-exception-handler HANDLER BODY) procedure

Installs a dynamically scoped exception handler handler for the duration of body. Resumes execution a the point where the exception was raised.

raise

(raise EXCEPTION) procedure

Raises exception.

catch

(catch HANDLER BODY) procedure

Catches an exception with handler during execution of body.

Stopping

shutdown!

(shutdown!) procedure

Stops gracefully. Linked processes receive a "normal" exit message.

halt!

(halt!) procedure

Stops ungracefully. Linked processes are clueless as to what happened.

terminate!

(terminate! VICTIM) procedure

Forcefully terminate a local(!) process. Processed linked to victim get a terminated message.

Examples

Making a "server" process

(define pong-server
  (spawn
    (lambda ()
      (let loop ()
        (let ((msg (?)))
          (if (and (list? msg)
                   (= (length msg) 2)
                   (pid? (car msg))
                   (eq? (cadr msg) 'ping))
            (let ((from (car msg)))
              (! from 'pong)
              (loop))
            (loop)))))))

(! pong-server (list (self) 'ping))

(?)                 --> pong

Selective message retrieval

(! (self) 1)
(! (self) 2)
(! (self) 3)

(?)                 --> 1
(?? odd?)           --> 3
(?)                 --> 2

Distributed processing

On node a:

(node-init (make-node "a.example.org" 12345))

On node b:

(define node-a (make-node "a.example.org" 12345))
(on node-a host-name)    --> "a.example.org"
(define p (remote-spawn node-a
                        (lambda ()
                         (let loop ()
                          (let ((x (?)))
                            (! (car x) ((cdr x)))
                            (loop))))))
(! p (cons (self) host-name))
(?)                      --> "a.example.org"

Notes

There's a paper about Termite.

Requirements

s11n mailbox mailbox-threads defstruct

Bugs and Limitations

Author

Gulliaume Germain, ported to Chicken by Christian Kellermann

Version History

License

Copyright (c) 2005-2008, Guillaume Germain<br> Termite is licensed under the same terms as Gambit-C (LGPL and Apache v.2)<br> It comes with absolutely no warranty of any kind.<br> LGPL 2.1

Contents »