Parallel programming library providing the futures/promises synchronization mechanism

eager-future2

Eager Future2 is a Common Lisp library that provides composable
concurrency primitives that unify parallel and lazy evaluation, are
integrated with the Common Lisp condition system, and have automatic
resource management.

The basic unit of concurrency in Eager Future2 is the future, which is
a data type that acts as a proxy for the values of a no-argument
function (thunk) that is computed concurrently.

Eager Future2 provides several strategies for computing futures
(specified as keywords): :lazy (only computed when the future is asked
to yield its values), :speculative (may be computed when there is
processing capacity available), and :eager (computation begins as
soon as the future is created).

A future is created by the pcall function, which takes a thunk to
compute, and optionally the computing strategy. The default computing
strategy is specified by *default-future-type*, which is :speculative
by default.

A future can be asked for its values with the yield function. The
function ready-to-yield? is a non-blocking way to check whether the
future is done computing. The function select takes a set of futures
and blocks until at least one future is ready to yield, returning that
future.

Ongoing computation of a future can be aborted with the force
function, which takes the future and desired yield values and attempts
to install them in that future. If a future has already finished
computing, calling force on it will have no effect.

Error handling is done transparently (the same way as if the program
wasn't written to use futures) by proxying unhandled conditions and
available restarts across thread boundaries. An additional restart
called force-values is also offered, which simply calls force on the
future whose computation raised the error.

If a future is no longer referenced and gets garbage collected, any
ongoing computation associated with that future is aborted to release
underlying thread resources. This permits speculative computation to
be done without having to worry about manual resource management.

API documentation:

function pcall (thunk &optional (future-type *default-future-type*)) => future

  Given a function of no arguments, returns an object (called a
  future) that can later be used to retrieve the values computed by the
  function.

  future-type (by default the value of *default-future-type*) can either
  be :eager, :speculative, or :lazy. See the documentation of
  *default-future-type* for an explanation of the different future
  types.

  The function is called in an unspecified dynamic environment.

special variable *default-future-type*

  One of :eager, :speculative (default) or :lazy. If eager, any newly
  created futures start their computation immediately. If speculative,
  newly created futures are computed when thread pool threads are
  available, in FIFO future creation order. If lazy, newly created
  futures are not computed until asked to yield their values.

function ready-to-yield? (future) => nil or non-nil

  Returns non-nil if the future values have been computed, nil otherwise.

function yield (future) => value*

  Returns the computed values of the future.

  In case of a delayed future, computes the value of the future in the
  current thread.

  In case of a speculative future, if no other thread is computing the
  value of the future, computes the value in the current thread. If
  another thread is currently computing the value of the future, blocks
  until the value is available.

  In case of an eager future, blocks until the value is available.

function select (&rest futures) => future

  Returns the first future that is ready to yield.

function force (future &rest values) => nil

  If the future has not yet yielded a value, installs the given
  values as the yield-values of the future (stopping any ongoing
  computation of the future).

macro pexec (&body body) => future

  Shorthand for (pcall (lambda () ...))

macro plet ((&rest bindings) &body body)

  Like LET, but all bindings are evaluated asynchronously.

function iterate-futures (proc futures) => nil

  Calls proc on each future in select order. Proc is a procedure that
  takes the currently yieldable future as its first argument, and the
  list of futures not yet processed as its second. Futures need to be
  yielded by proc - this is done so that proc can have control of error
  handling. The second argument is useful to for example be able to
  terminate remaining computations before a non-local control transfer.

function force-all (futures &rest values) => nil

  Calls force on all given future with values. Useful to stop
  remaining computations in for example iterate-futures.

macro pand (&rest exprs) => t or nil

  Evaluates expressions in parallel. If any expression yields nil,
  terminates all outstanding computations and returns nil. If all
  expressions yield a non-nil value, returns t.

macro por (&rest exprs) => nil or non-nil

  Evaluates expressions in parallel. Returns the value of the first
  expression that yields a non-nil value. If all expressions evaluate
  to nil, returns nil.

function select-timeout (timeout &rest futures) => future or nil

  Given a timeout (in seconds) and a set of futures, returns either
  nil if no futures are ready to yield when timeout seconds have
  elapsed, or the first yieldable future otherwise.

macro pfuncall (function &rest args) => result

  Evaluates args in parallel before funcalling the given function on them.

function touch (x) => value

  If x is a future, yields its value, otherwise returns x.


eager-future2

Upstream URL

Author

License

eager-future2

License:

Authors:

Dependencies:

test.eager-future2

Dependencies:

Dependencies (3)

Dependents (2)