async compute in SBCL

This library is a prototype implementation of an async interface and executor for multithreaded computation in Common Lisp on SBCL. It makes heavy use of SBCL's atomics interface in its lock-free executor, and as such is not portable to other Common Lisp implementations.

Unlike many async frameworks in the world, this library is not suited to async I/O, essentially because I haven't written a wrapper around kqueue / epoll / whatever Windows has. It is intended for CPU compute-intensive parallelism of the variety I encounter in my planning work.

Examples (taken straight from the tests)

Using asynchronously, sleep for a second, then do some addition

(asynchronously (2) ; creates an executor with two worker threads
   (let* ((one (async ()
                 (sleep 1) ; this blocks the thread, preventing other jobs from running
                 1))
          (two (async ()
                 (+ 1 (await one))))
          (twelve (async ()
                    (* 6 (await two))))
          (three (async ()
                    (sleep 1)
                    3))
          (fifteen (async ()
                     (* 5 (await three)))))
     (+ (await twelve) (await fifteen))))

Using job-seq, pipe the result of a job into the next

job-seq looks a lot like Haskell's do

(with-executor (1) ; creates an executor with one worker thread
  (wait-for (job-seq (async () 1)
                     (lambda (one) (+ one 1))
                     (lambda (two) (* two two))
                     (lambda (four) (- four 1)))))

Using with-executor, spawn an ungodly amount of jobs to do inefficient recursive exponentiation

(with-executor (4) ; four worker threads
  (labels ((make-job-sums-to-2^ (n)
             (if (= n 0)
                 (async () 1)
                 (let* ((left (make-job-sums-to-2^ (1- n)))
                        (right (make-job-sums-to-2^ (1- n))))
                   (async () (+ (await left) (await right)))))))
    (let* ((jobs (iter outer (for i from 0 to 8)
                   (collect (make-job-sums-to-2^ i)))))
      (iter (for job in jobs)
        (for i from 0 to 8)
        (is (= (expt 2 i) (wait-for job)))
        (finish-output *test-dribble*)))))