chickadee » termite

termite

Erlang style concurrency for Chicken Scheme

Documentation

Fundamental Operations

spawn

spawn THUNKprocedure

Create a process running thunk and returns its pid.

!

! PID MSGprocedure

Send msg to process pid.

?

? #!optional TIMEOUT DEFAULTprocedure

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

??

?? PREDprocedure

Fetches next message that matches pred.

!?

!? PID MSG #!optional TIMEOUT DEFAULTprocedure

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 TOprocedure

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 PORTprocedure

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

node-init

node-init NODEprocedure

Primary setup for creating a node to accept processes.

remote-spawn

remote-spawn NODE THUNKprocedure

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 THUNKprocedure

Run thunk on node, returns result of thunk.

Error Handling

with-exception-catcher

with-exception-catcher HANDLER BODYprocedure

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 BODYprocedure

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

raise

raise EXCEPTIONprocedure

Raises exception.

catch

catch HANDLER BODYprocedure

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! VICTIMprocedure

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 »