This is the lparallel Reference Manual, version 2.8.4, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 15 06:54:32 2024 GMT+0.
lparallel/lparallel.asdlparallel/src/util/package.lisplparallel/src/util/config.lisplparallel/src/util/misc.lisplparallel/src/util/defmacro.lisplparallel/src/util/defun.lisplparallel/src/util/defslots.lisplparallel/src/util/defpair.lisplparallel/src/thread-util.lisplparallel/src/raw-queue.lisplparallel/src/cons-queue.lisplparallel/src/vector-queue.lisplparallel/src/queue.lisplparallel/src/counter.lisplparallel/src/spin-queue/package.lisplparallel/src/spin-queue/cas-spin-queue.lisplparallel/src/kernel/package.lisplparallel/src/kernel/specials.lisplparallel/src/kernel/handling.lisplparallel/src/kernel/classes.lisplparallel/src/kernel/stealing-scheduler.lisplparallel/src/kernel/kill.lisplparallel/src/kernel/core.lisplparallel/src/kernel/timeout.lisplparallel/src/kernel-util.lisplparallel/src/promise.lisplparallel/src/ptree.lisplparallel/src/slet.lisplparallel/src/defpun.lisplparallel/src/cognate/package.lisplparallel/src/cognate/util.lisplparallel/src/cognate/option.lisplparallel/src/cognate/subdivide.lisplparallel/src/cognate/pandor.lisplparallel/src/cognate/plet.lisplparallel/src/cognate/pmap.lisplparallel/src/cognate/pmap-open-coded.lisplparallel/src/cognate/pdotimes.lisplparallel/src/cognate/pquantifier.lisplparallel/src/cognate/preduce.lisplparallel/src/cognate/premove.lisplparallel/src/cognate/pfind.lisplparallel/src/cognate/pcount.lisplparallel/src/cognate/psort.lisplparallel/src/package.lisplparallellparallel.thread-utillparallel.cognatelparallel.queuelparallel.kernel-utillparallel.spin-queuelparallel.sletlparallel.ptreelparallel.kernellparallel.promiselparallel.raw-queuelparallel.cons-queuelparallel.defpunlparallel.counterlparallel.vector-queuelparallel.utilThe main system appears first, followed by any subsystem dependency.
lparallelParallelism for Common Lisp
James M. Lawrence <llmjjmll@gmail.com>
BSD
lparallel is a library for parallel programming in Common Lisp, featuring
* a simple model of task submission with receiving queue
* constructs for expressing fine-grained parallelism
* asynchronous condition handling across thread boundaries
* parallel versions of map, reduce, sort, remove, and many others
* promises, futures, and delayed evaluation constructs
* computation trees for parallelizing interconnected tasks
* bounded and unbounded FIFO queues
* high and low priority tasks
* task killing by category
* integrated timeouts
See http://lparallel.org for documentation and examples.
2.8.4
alexandria (system).
bordeaux-threads (system).
src (module).
Modules are listed depth-first from the system components tree.
lparallel/srclparallel/src/utillparallel/src/spin-queuelparallel/src/kernellparallel/src/cognatelparallel/srclparallel (system).
util (module).
thread-util.lisp (file).
raw-queue.lisp (file).
cons-queue.lisp (file).
vector-queue.lisp (file).
queue.lisp (file).
counter.lisp (file).
spin-queue (module).
kernel (module).
kernel-util.lisp (file).
promise.lisp (file).
ptree.lisp (file).
slet.lisp (file).
defpun.lisp (file).
cognate (module).
package.lisp (file).
lparallel/src/utilsrc (module).
package.lisp (file).
config.lisp (file).
misc.lisp (file).
defmacro.lisp (file).
defun.lisp (file).
defslots.lisp (file).
defpair.lisp (file).
lparallel/src/spin-queuecounter.lisp (file).
src (module).
package.lisp (file).
cas-spin-queue.lisp (file).
lparallel/src/kernelspin-queue (module).
src (module).
package.lisp (file).
specials.lisp (file).
handling.lisp (file).
classes.lisp (file).
stealing-scheduler.lisp (file).
kill.lisp (file).
core.lisp (file).
timeout.lisp (file).
lparallel/src/cognatedefpun.lisp (file).
src (module).
package.lisp (file).
util.lisp (file).
option.lisp (file).
subdivide.lisp (file).
pandor.lisp (file).
plet.lisp (file).
pmap.lisp (file).
pmap-open-coded.lisp (file).
pdotimes.lisp (file).
pquantifier.lisp (file).
preduce.lisp (file).
premove.lisp (file).
pfind.lisp (file).
pcount.lisp (file).
psort.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
lparallel/lparallel.asdlparallel/src/util/package.lisplparallel/src/util/config.lisplparallel/src/util/misc.lisplparallel/src/util/defmacro.lisplparallel/src/util/defun.lisplparallel/src/util/defslots.lisplparallel/src/util/defpair.lisplparallel/src/thread-util.lisplparallel/src/raw-queue.lisplparallel/src/cons-queue.lisplparallel/src/vector-queue.lisplparallel/src/queue.lisplparallel/src/counter.lisplparallel/src/spin-queue/package.lisplparallel/src/spin-queue/cas-spin-queue.lisplparallel/src/kernel/package.lisplparallel/src/kernel/specials.lisplparallel/src/kernel/handling.lisplparallel/src/kernel/classes.lisplparallel/src/kernel/stealing-scheduler.lisplparallel/src/kernel/kill.lisplparallel/src/kernel/core.lisplparallel/src/kernel/timeout.lisplparallel/src/kernel-util.lisplparallel/src/promise.lisplparallel/src/ptree.lisplparallel/src/slet.lisplparallel/src/defpun.lisplparallel/src/cognate/package.lisplparallel/src/cognate/util.lisplparallel/src/cognate/option.lisplparallel/src/cognate/subdivide.lisplparallel/src/cognate/pandor.lisplparallel/src/cognate/plet.lisplparallel/src/cognate/pmap.lisplparallel/src/cognate/pmap-open-coded.lisplparallel/src/cognate/pdotimes.lisplparallel/src/cognate/pquantifier.lisplparallel/src/cognate/preduce.lisplparallel/src/cognate/premove.lisplparallel/src/cognate/pfind.lisplparallel/src/cognate/pcount.lisplparallel/src/cognate/psort.lisplparallel/src/package.lisplparallel/src/util/config.lisppackage.lisp (file).
util (module).
*full-optimize* (special variable).
*normal-optimize* (special variable).
lparallel/src/util/misc.lispconfig.lisp (file).
util (module).
alias-function (macro).
alias-macro (macro).
dosequence (macro).
index (type).
interact (function).
partial-apply (compiler macro).
repeat (macro).
to-boolean (function).
unsplice (function).
unwind-protect/ext (macro).
with-parsed-body (macro).
symbolicate/no-intern (function).
symbolicate/package (function).
lparallel/src/util/defmacro.lispmisc.lisp (file).
util (module).
defmacro/once (macro).
lparallel/src/util/defun.lispdefmacro.lisp (file).
util (module).
defun/inline (macro).
defun/type (macro).
defun/type/inline (macro).
constrain-return-type (function).
lparallel/src/util/defslots.lispdefun.lisp (file).
util (module).
defslots (macro).
%defslots (macro).
define-reader (macro).
define-readers (macro).
define-slots-macrolet (macro).
define-struct (macro).
define-with-slots-macro (macro).
defslots-names (function).
parse-defslots (function).
plist-keys (function).
plist-values-for-key (function).
lparallel/src/util/defpair.lispdefslots.lisp (file).
util (module).
defpair (macro).
lparallel/src/thread-util.lisputil (module).
src (module).
cas (macro).
condition-notify (compiler macro).
condition-wait (compiler macro).
make-spin-lock (function).
with-lock-predicate/no-wait (macro).
with-lock-predicate/wait (macro).
with-spin-lock-held (macro).
with-thread (macro).
%time-remaining (function).
define-locking-fn (macro).
define-locking-fn/base (macro).
define-simple-locking-fn (macro).
get-real-time-in-seconds (function).
with-abort-restart (macro).
with-countdown (macro).
lparallel/src/raw-queue.lispthread-util.lisp (file).
src (module).
make-raw-queue (function).
peek-raw-queue (function).
pop-raw-queue (function).
push-raw-queue (function).
raw-queue (structure).
raw-queue-count (function).
raw-queue-count (type).
raw-queue-empty-p (function).
%make-raw-queue (function).
copy-raw-queue (function).
head (reader).
(setf head) (writer).
raw-queue-p (function).
tail (reader).
(setf tail) (writer).
lparallel/src/cons-queue.lispraw-queue.lisp (file).
src (module).
cons-queue (structure).
cons-queue-count (function).
cons-queue-count/no-lock (function).
cons-queue-empty-p (function).
cons-queue-empty-p/no-lock (function).
make-cons-queue (function).
peek-cons-queue (function).
peek-cons-queue/no-lock (function).
pop-cons-queue (function).
pop-cons-queue/no-lock (function).
push-cons-queue (function).
push-cons-queue/no-lock (function).
try-pop-cons-queue (function).
try-pop-cons-queue/no-lock (function).
with-locked-cons-queue (macro).
%%%%.cons-queue.cvar (reader).
(setf %%%%.cons-queue.cvar) (writer).
%%%%.cons-queue.impl (reader).
(setf %%%%.cons-queue.impl) (writer).
%%%%.cons-queue.lock (reader).
(setf %%%%.cons-queue.lock) (writer).
%make-cons-queue (function).
%try-pop-cons-queue/no-lock/timeout (function).
cons-queue-p (function).
copy-cons-queue (function).
define-queue-fn (macro).
impl (compiler macro).
lock (compiler macro).
make-cons-queue-instance (function).
try-pop-cons-queue/no-lock/timeout (function).
with-cons-queue-slots (macro).
lparallel/src/vector-queue.lispcons-queue.lisp (file).
src (module).
make-vector-queue (function).
peek-vector-queue (function).
peek-vector-queue/no-lock (function).
pop-vector-queue (function).
pop-vector-queue/no-lock (function).
push-vector-queue (function).
push-vector-queue/no-lock (function).
try-pop-vector-queue (function).
try-pop-vector-queue/no-lock (function).
vector-queue (structure).
vector-queue-capacity (function).
vector-queue-count (function).
vector-queue-count/no-lock (function).
vector-queue-empty-p (function).
vector-queue-empty-p/no-lock (function).
vector-queue-full-p (function).
vector-queue-full-p/no-lock (function).
with-locked-vector-queue (macro).
%%%%.raw-queue.count (reader).
(setf %%%%.raw-queue.count) (writer).
%%%%.raw-queue.data (reader).
(setf %%%%.raw-queue.data) (writer).
%%%%.raw-queue.start (reader).
(setf %%%%.raw-queue.start) (writer).
%%%%.vector-queue.impl (reader).
(setf %%%%.vector-queue.impl) (writer).
%%%%.vector-queue.lock (reader).
(setf %%%%.vector-queue.lock) (writer).
%%%%.vector-queue.notify-pop (reader).
(setf %%%%.vector-queue.notify-pop) (writer).
%%%%.vector-queue.notify-push (reader).
(setf %%%%.vector-queue.notify-push) (writer).
%make-vector-queue (function).
%try-pop-vector-queue/no-lock/timeout (function).
copy-raw-queue (function).
copy-vector-queue (function).
data (compiler macro).
define-queue-fn (macro).
impl (compiler macro).
lock (compiler macro).
make-raw-queue (function).
make-raw-queue-instance (function).
make-vector-queue-instance (function).
peek-raw-queue (function).
pop-raw-queue (function).
push-raw-queue (function).
raw-queue (structure).
raw-queue-capacity (function).
raw-queue-count (compiler macro).
raw-queue-count (type).
raw-queue-empty-p (function).
raw-queue-full-p (function).
raw-queue-p (function).
try-pop-vector-queue/no-lock/no-timeout (function).
try-pop-vector-queue/no-lock/timeout (function).
vector-queue-capacity/no-lock (function).
vector-queue-p (function).
with-raw-queue-slots (macro).
with-vector-queue-slots (macro).
lparallel/src/queue.lispvector-queue.lisp (file).
src (module).
make-queue (compiler macro).
make-queue (function).
peek-queue (function).
peek-queue/no-lock (function).
pop-queue (function).
pop-queue/no-lock (function).
push-queue (function).
push-queue/no-lock (function).
queue (type).
queue-count (function).
queue-count/no-lock (function).
queue-empty-p (function).
queue-empty-p/no-lock (function).
queue-full-p (function).
queue-full-p/no-lock (function).
try-pop-queue (function).
try-pop-queue/no-lock (function).
with-locked-queue (macro).
%make-queue (function).
call-with-locked-cons-queue (function).
call-with-locked-queue (function).
call-with-locked-vector-queue (function).
cons-queue-full-p (function).
cons-queue-full-p/no-lock (function).
define-queue-fn (macro).
define-try-pop-queue (macro).
lparallel/src/counter.lispqueue.lisp (file).
src (module).
counter (structure).
counter-value (reader).
(setf counter-value) (writer).
counter-value (type).
dec-counter (function).
inc-counter (function).
make-counter (function).
copy-counter (function).
counter-p (function).
define-counter-fn (macro).
lparallel/src/spin-queue/cas-spin-queue.lisppackage.lisp (file).
spin-queue (module).
make-spin-queue (function).
peek-spin-queue (function).
pop-spin-queue (function).
push-spin-queue (function).
spin-queue (structure).
spin-queue-count (function).
spin-queue-empty-p (function).
%make-spin-queue (function).
+dead-end+ (constant).
+dummy+ (constant).
copy-spin-queue (function).
make-node (compiler macro).
node (type).
node-car (macro).
node-cdr (macro).
spin-queue-head (reader).
(setf spin-queue-head) (writer).
spin-queue-p (function).
spin-queue-tail (reader).
(setf spin-queue-tail) (writer).
try-each-elem (function).
lparallel/src/kernel/specials.lisppackage.lisp (file).
kernel (module).
*debug-tasks-p* (special variable).
*kernel* (special variable).
*kernel-spin-count* (special variable).
*task-category* (special variable).
*task-priority* (special variable).
*client-handlers* (special variable).
*debugger-error* (special variable).
*erroring-workers* (special variable).
*erroring-workers-lock* (special variable).
*handler-active-p* (special variable).
*lisp-exiting-p* (special variable).
*make-limiter-data* (special variable).
*worker* (special variable).
lparallel/src/kernel/handling.lispspecials.lisp (file).
kernel (module).
invoke-transfer-error (function).
kernel-creation-error (condition).
no-kernel-error (condition).
task-handler-bind (macro).
task-killed-error (condition).
%%%%.wrapped-error.value (reader).
(setf %%%%.wrapped-error.value) (writer).
%call-with-task-handler (function).
+current-task+ (constant).
call-with-task-handler (function).
call-with-tracked-error (function).
condition-handler (function).
copy-wrapped-error (function).
make-debugger-hook (function).
make-wrapped-error-instance (function).
transfer-error-report (function).
transfer-error-restart (function).
unwrap-result (function).
with-task-context (macro).
with-tracked-error (macro).
with-wrapped-error-slots (macro).
wrap-error (function).
wrapped-error (structure).
wrapped-error-p (function).
wrapped-error-value (compiler macro).
lparallel/src/kernel/classes.lisphandling.lisp (file).
kernel (module).
%%%%.channel.kernel (reader).
(setf %%%%.channel.kernel) (writer).
%%%%.channel.queue (reader).
(setf %%%%.channel.queue) (writer).
%%%%.kernel.alivep (reader).
(setf %%%%.kernel.alivep) (writer).
%%%%.kernel.limiter-accept-task-p (function).
(setf %%%%.kernel.limiter-accept-task-p) (function).
%%%%.kernel.limiter-count (function).
(setf %%%%.kernel.limiter-count) (function).
%%%%.kernel.limiter-lock (function).
(setf %%%%.kernel.limiter-lock) (function).
%%%%.kernel.scheduler (reader).
(setf %%%%.kernel.scheduler) (writer).
%%%%.kernel.use-caller-p (reader).
(setf %%%%.kernel.use-caller-p) (writer).
%%%%.kernel.worker-info (reader).
(setf %%%%.kernel.worker-info) (writer).
%%%%.kernel.workers (reader).
(setf %%%%.kernel.workers) (writer).
%%%%.kernel.workers-lock (reader).
(setf %%%%.kernel.workers-lock) (writer).
%%%%.scheduler.low-priority-tasks (reader).
(setf %%%%.scheduler.low-priority-tasks) (writer).
%%%%.scheduler.notify-count (reader).
(setf %%%%.scheduler.notify-count) (writer).
%%%%.scheduler.random-index (reader).
(setf %%%%.scheduler.random-index) (writer).
%%%%.scheduler.spin-count (reader).
(setf %%%%.scheduler.spin-count) (writer).
%%%%.scheduler.wait-count (reader).
(setf %%%%.scheduler.wait-count) (writer).
%%%%.scheduler.wait-cvar (reader).
(setf %%%%.scheduler.wait-cvar) (writer).
%%%%.scheduler.wait-lock (reader).
(setf %%%%.scheduler.wait-lock) (writer).
%%%%.scheduler.workers (reader).
(setf %%%%.scheduler.workers) (writer).
%%%%.worker-info.bindings (reader).
(setf %%%%.worker-info.bindings) (writer).
%%%%.worker-info.context (reader).
(setf %%%%.worker-info.context) (writer).
%%%%.worker-info.name (reader).
(setf %%%%.worker-info.name) (writer).
%%%%.worker-notifications.exit-notification (reader).
(setf %%%%.worker-notifications.exit-notification) (writer).
%%%%.worker-notifications.handshake/from-worker (reader).
(setf %%%%.worker-notifications.handshake/from-worker) (writer).
%%%%.worker-notifications.handshake/to-worker (reader).
(setf %%%%.worker-notifications.handshake/to-worker) (writer).
%%%%.worker.exit-notification (function).
(setf %%%%.worker.exit-notification) (function).
%%%%.worker.handshake/from-worker (function).
(setf %%%%.worker.handshake/from-worker) (function).
%%%%.worker.handshake/to-worker (function).
(setf %%%%.worker.handshake/to-worker) (function).
%%%%.worker.index (reader).
(setf %%%%.worker.index) (writer).
%%%%.worker.running-category (reader).
(setf %%%%.worker.running-category) (writer).
%%%%.worker.tasks (reader).
(setf %%%%.worker.tasks) (writer).
%%%%.worker.thread (reader).
(setf %%%%.worker.thread) (writer).
alivep (compiler macro).
channel-kernel (compiler macro).
channel-p (function).
channel-queue (compiler macro).
copy-channel (function).
copy-kernel (function).
copy-limiter (function).
copy-scheduler (function).
copy-worker (function).
copy-worker-info (function).
copy-worker-notifications (function).
kernel-p (function).
limiter (structure).
limiter-accept-task-p (reader).
(setf limiter-accept-task-p) (writer).
limiter-count (reader).
(setf limiter-count) (writer).
limiter-lock (reader).
(setf limiter-lock) (writer).
limiter-p (function).
make-channel-instance (function).
make-kernel-instance (function).
make-limiter (function).
make-scheduler-instance (function).
make-task-instance (compiler macro).
make-worker-info-instance (function).
make-worker-instance (function).
make-worker-notifications-instance (function).
running-category (compiler macro).
scheduler (compiler macro).
scheduler (structure).
scheduler-p (function).
task (type).
task-category (compiler macro).
task-fn (compiler macro).
tasks (compiler macro).
thread (compiler macro).
use-caller-p (compiler macro).
with-channel-slots (macro).
with-kernel-slots (macro).
with-scheduler-slots (macro).
with-worker-info-slots (macro).
with-worker-notifications-slots (macro).
with-worker-slots (macro).
worker (structure).
worker-index (compiler macro).
worker-info (structure).
worker-info-p (function).
worker-notifications (structure).
worker-notifications-p (function).
worker-p (function).
workers (compiler macro).
lparallel/src/kernel/stealing-scheduler.lispclasses.lisp (file).
kernel (module).
define-mod-inc-dec (macro).
define-mod-incf-decf (macro).
do-indexes (macro).
do-workers (macro).
make-scheduler (function).
maybe-wake-a-worker (function).
mod-dec (macro).
mod-decf (macro).
mod-inc (macro).
mod-incf (macro).
next-task (function).
push-to-random-worker (function).
repeat/fixnum (macro).
schedule-task (function).
steal-task (function).
with-pop-success (macro).
lparallel/src/kernel/kill.lispstealing-scheduler.lisp (file).
kernel (module).
kill-tasks (function).
+worker-suicide-tag+ (constant).
kill (function).
kill-errors (function).
kill-errors-report (function).
with-worker-restarts (macro).
lparallel/src/kernel/core.lispkill.lisp (file).
kernel (module).
broadcast-task (function).
check-kernel (function).
do-fast-receives (macro).
end-kernel (function).
kernel-bindings (function).
kernel-context (function).
kernel-name (function).
kernel-worker-count (function).
kernel-worker-index (function).
make-channel (compiler macro).
make-channel (function).
make-kernel (function).
print-object (method).
receive-result (function).
submit-task (function).
task-categories-running (function).
try-receive-result (function).
%fill-workers (function).
%kernel-worker-count (function).
%make-channel (function).
%make-worker (function).
call-with-worker-context (function).
define-worker-info-reader (macro).
enter-worker-loop (function).
exec-task/non-worker (function).
exec-task/worker (function).
fill-workers (function).
handshake/from-worker/finish (function).
handshake/from-worker/start (function).
handshake/to-worker/finish (function).
handshake/to-worker/start (function).
kernel-info (function).
make-all-bindings (function).
make-channeled-task (function).
make-task (function).
make-worker (function).
make-worker-thread (function).
notify-exit (function).
replace-worker (function).
shutdown (function).
steal-work (function).
submit-raw-task (function).
task-lambda (macro).
track-exit (function).
wait-for-worker (function).
with-fill-workers-handler (macro).
worker-loop (function).
lparallel/src/kernel/timeout.lispcore.lisp (file).
kernel (module).
cancel-timeout (compiler macro).
cancel-timeout (function).
submit-timeout (compiler macro).
submit-timeout (function).
%%%%.timeout.canceled-result (reader).
(setf %%%%.timeout.canceled-result) (writer).
%%%%.timeout.lock (reader).
(setf %%%%.timeout.lock) (writer).
%%%%.timeout.thread (reader).
(setf %%%%.timeout.thread) (writer).
copy-timeout (function).
deprecated-timeout (function).
make-timeout-instance (function).
timeout (structure).
timeout-p (function).
with-timeout-slots (macro).
lparallel/src/kernel-util.lispkernel (module).
src (module).
with-submit-cancelable (macro).
with-submit-counted (macro).
with-submit-indexed (macro).
with-temp-kernel (macro).
call-with-temp-kernel (function).
indexing-wrapper (function).
receive-results (function).
steal-until-receive-result (function).
lparallel/src/promise.lispkernel-util.lisp (file).
src (module).
%%%%.%chain.object (reader).
(setf %%%%.%chain.object) (writer).
%%%%.%delay.fn (function).
(setf %%%%.%delay.fn) (function).
%%%%.%delay.lock (function).
(setf %%%%.%delay.lock) (function).
%%%%.%delay.result (function).
(setf %%%%.%delay.result) (function).
%%%%.%future.canceledp (reader).
(setf %%%%.%future.canceledp) (writer).
%%%%.%future.fn (function).
(setf %%%%.%future.fn) (function).
%%%%.%future.lock (function).
(setf %%%%.%future.lock) (function).
%%%%.%future.result (function).
(setf %%%%.%future.result) (function).
%%%%.%promise.availablep (reader).
(setf %%%%.%promise.availablep) (writer).
%%%%.%promise.cvar (reader).
(setf %%%%.%promise.cvar) (writer).
%%%%.%promise.lock (function).
(setf %%%%.%promise.lock) (function).
%%%%.%promise.result (function).
(setf %%%%.%promise.result) (function).
%%%%.plan.fn (reader).
(setf %%%%.plan.fn) (writer).
%%%%.plan.lock (function).
(setf %%%%.plan.lock) (function).
%%%%.plan.result (function).
(setf %%%%.plan.result) (function).
%%%%.promise-base.lock (reader).
(setf %%%%.promise-base.lock) (writer).
%%%%.promise-base.result (reader).
(setf %%%%.promise-base.result) (writer).
%chain (structure).
%chain-p (function).
%delay (structure).
%delay-p (function).
%future (structure).
%future-p (function).
%promise (structure).
%promise-p (function).
+no-result+ (constant).
chain-object (compiler macro).
copy-%chain (function).
copy-%delay (function).
copy-%future (function).
copy-%promise (function).
copy-plan (function).
copy-promise-base (function).
force-delay (function).
force-future (function).
force-promise (function).
fulfill-delay (function).
fulfill-future (function).
fulfill-object (function).
fulfill-plan/call (function).
fulfill-plan/error (function).
fulfill-plan/values (function).
fulfill-promise (function).
make-%chain-instance (function).
make-%delay-instance (function).
make-%future-instance (function).
make-%promise-instance (function).
make-future (function).
make-future-task (function).
make-plan-instance (function).
make-promise-base-instance (function).
plan (structure).
plan-fn (compiler macro).
plan-p (function).
promise-base (structure).
promise-base-p (function).
replace-error (function).
result (compiler macro).
with-%chain-slots (macro).
with-%delay-slots (macro).
with-%future-slots (macro).
with-%promise-slots (macro).
with-lock-operation (macro).
with-plan-slots (macro).
with-promise-base-slots (macro).
with-unfulfilled-future/no-wait (macro).
with-unfulfilled/no-wait (macro).
with-unfulfilled/wait (macro).
lparallel/src/ptree.lisppromise.lisp (file).
src (module).
*ptree-node-kernel* (special variable).
call-ptree (function).
check-ptree (function).
clear-ptree (function).
clear-ptree-errors (function).
make-ptree (function).
ptree (macro).
ptree (structure).
ptree-computed-p (function).
ptree-fn (function).
ptree-lambda-list-keyword-error (condition).
ptree-redefinition-error (condition).
ptree-undefined-function-error (condition).
%%%%.node.children (reader).
(setf %%%%.node.children) (writer).
%%%%.node.children-done-p (reader).
(setf %%%%.node.children-done-p) (writer).
%%%%.node.function (reader).
(setf %%%%.node.function) (writer).
%%%%.node.id (reader).
(setf %%%%.node.id) (writer).
%%%%.node.lock-level (reader).
(setf %%%%.node.lock-level) (writer).
%%%%.node.parents (reader).
(setf %%%%.node.parents) (writer).
%%%%.node.result (reader).
(setf %%%%.node.result) (writer).
%%%%.ptree.lock (reader).
(setf %%%%.ptree.lock) (writer).
%%%%.ptree.nodes (reader).
(setf %%%%.ptree.nodes) (writer).
%%%%.ptree.pending (reader).
(setf %%%%.ptree.pending) (writer).
%%%%.ptree.queue (reader).
(setf %%%%.ptree.queue) (writer).
+no-result+ (constant).
check-node (function).
children-done-p (function).
clear-node (function).
clear-node-error (function).
compute-node (function).
compute-ptree (function).
computedp (function).
copy-node (function).
copy-ptree (function).
each-node (function).
find-node (function).
freep (function).
id (compiler macro).
lock (compiler macro).
lock-level (compiler macro).
lock-node (function).
make-node-instance (function).
make-node-task (function).
make-ptree-instance (function).
node (structure).
node-p (function).
nodes (compiler macro).
propagate-error (function).
ptree-error (condition).
ptree-error-id (reader method).
ptree-error-llks (reader method).
ptree-error-refs (reader method).
ptree-p (function).
result (compiler macro).
submit-node (function).
unlock-node (function).
wait-for-compute (function).
with-node-slots (macro).
with-ptree-slots (macro).
lparallel/src/slet.lispptree.lisp (file).
src (module).
slet (macro).
%slet (macro).
bind (macro).
make-binding-data (function).
make-binding-datum (function).
make-temp-var (function).
parse-bindings (function).
lparallel/src/defpun.lispslet.lisp (file).
src (module).
declaim-defpun (macro).
defpun (macro).
defpun* (macro).
defpun/type (macro).
defpun/type* (macro).
%%%%plet (macro).
%%%plet (macro).
%%plet (macro).
%plet (macro).
%plet-if (macro).
*registered-names* (special variable).
*registration-lock* (special variable).
+checked-key+ (constant).
+no-result+ (constant).
+unchecked-key+ (constant).
accept-task-p (macro).
call-impl-fn (function).
call-inside-worker (function).
call-with-toplevel-handler (function).
client-vars (function).
define-defpun (macro).
defun/wrapper (macro).
delete-registered-names (function).
delete-stale-registrations (function).
exec-task (macro).
initial-limiter-count (function).
make-limiter-data (function).
msetq (macro).
primary-temp-vars (function).
register-fn (function).
register-name (function).
registered-fn-p (function).
registered-macrolets (function).
scan-for-errors (macro).
spawn (macro).
spawn-tasks (macro).
sync (macro).
temp-vars (function).
unchecked-name (function).
update-limiter-count (function).
update-limiter-count/no-lock (function).
valid-registered-fn-p (function).
valid-registered-name-p (function).
with-client-bindings (macro).
with-lock-predicates (macro).
with-temp-bindings (macro).
lparallel/src/cognate/util.lisppackage.lisp (file).
cognate (module).
find-min-length (function).
item-predicate (function).
subsize (function).
zip/vector (function).
lparallel/src/cognate/option.lisputil.lisp (file).
cognate (module).
%parse-options (function).
get-parts-hint (function).
parse-options (function).
pop-plist (macro).
with-parsed-options (macro).
lparallel/src/cognate/subdivide.lispoption.lisp (file).
cognate (module).
find-num-parts (function).
make-input-parts (function).
make-parts (function).
make-result-parts (function).
subdivide-array (function).
subdivide-list (function).
subdivide-list/slice (function).
with-parts (macro).
lparallel/src/cognate/pandor.lispsubdivide.lisp (file).
cognate (module).
with-forms-submitted (macro).
lparallel/src/cognate/plet.lisppandor.lisp (file).
cognate (module).
%%%%.binding-datum.form (reader).
(setf %%%%.binding-datum.form) (writer).
%%%%.binding-datum.future-result (reader).
(setf %%%%.binding-datum.future-result) (writer).
%%%%.binding-datum.future-var (reader).
(setf %%%%.binding-datum.future-var) (writer).
%%%%.binding-datum.vars (reader).
(setf %%%%.binding-datum.vars) (writer).
%mv-macrolet-bindings (function).
%plet (macro).
*standard-declaration-identifiers* (special variable).
all-binding-vars (function).
binding-datum (structure).
binding-datum-p (function).
binding-datum-vars (compiler macro).
binding-decl-spec (function).
binding-decl-specs (function).
copy-binding-datum (function).
custom-declaration-p (function).
decl-spec->typed-vars (function).
decl-specs->typed-vars (function).
declaration-information (function).
declarationp (function).
declares->decl-specs (function).
declares->typed-vars (function).
future-let-binding (function).
future-let-bindings (function).
future-macrolet-binding (function).
future-macrolet-bindings (function).
lookup-all (function).
make-binding-data (function).
make-binding-datum-instance (function).
make-mv-binding-datum (function).
make-sv-binding-datum (function).
mv-macrolet-bindings (function).
partition (function).
unknown-typed-vars (function).
var-type (function).
with-binding-datum-slots (macro).
zip-repeat (function).
lparallel/src/cognate/pmap.lispplet.lisp (file).
cognate (module).
pmap (function).
pmap-into (function).
pmap-reduce (function).
pmapc (function).
pmapcan (function).
pmapcar (function).
pmapcon (function).
pmapl (function).
pmaplist (function).
pmaplist-into (function).
map-iterate (function).
map-nil (function).
maplist-into (function).
pmap-into/parsed (function).
pmap-into/parts (function).
pmap-into/powder (function).
pmap-into/powder/array (function).
pmap-into/powder/list (function).
pmap-into/unparsed (function).
pmap-iterate (function).
pmap-iterate/parts (function).
pmap-iterate/powder (function).
pmap/parsed (function).
pmap/unparsed (function).
lparallel/src/cognate/pmap-open-coded.lisppmap.lisp (file).
cognate (module).
check-symbols (macro).
defmacro/syms (macro).
map-into/vector/1-vector/range (macro).
pmap-into/vector/1-vector (macro).
quoted-vector-type-p (function).
quotedp (function).
lparallel/src/cognate/pdotimes.lisppmap-open-coded.lisp (file).
cognate (module).
pdotimes (macro).
%pdotimes (function).
lparallel/src/cognate/pquantifier.lisppdotimes.lisp (file).
cognate (module).
pquantifier (function).
lparallel/src/cognate/preduce.lisppquantifier.lisp (file).
cognate (module).
preduce (function).
preduce-partial (function).
%preduce-partial (function).
preduce-partial/list (function).
preduce-partial/vector (function).
preduce/common (function).
with-preduce-context (macro).
lparallel/src/cognate/premove.lisppreduce.lisp (file).
cognate (module).
premove (function).
premove-if (function).
premove-if-not (function).
premove-if-not/list (function).
lparallel/src/cognate/pfind.lisppremove.lisp (file).
cognate (module).
pfind (function).
pfind-if (function).
pfind-if-not (function).
pfind-if/list (function).
pfind-if/vector (function).
with-pfind-context (macro).
lparallel/src/cognate/pcount.lisppfind.lisp (file).
cognate (module).
pcount (function).
pcount-if (function).
pcount-if-not (function).
lparallel/src/cognate/psort.lisppcount.lisp (file).
cognate (module).
%%%%.defpun.quicksort/key/gran (function).
%%%%.defpun.quicksort/key/no-gran (function).
%%%%.defpun.quicksort/no-key/gran (function).
%%%%.defpun.quicksort/no-key/no-gran (function).
call-quicksort (function).
define-quicksort-fn (macro).
define-quicksort-fns (macro).
midpoint (function).
quicksort/key/gran (function).
quicksort/key/no-gran (function).
quicksort/no-key/gran (function).
quicksort/no-key/no-gran (function).
Packages are listed by definition order.
lparallellparallel.thread-utillparallel.cognatelparallel.queuelparallel.kernel-utillparallel.spin-queuelparallel.sletlparallel.ptreelparallel.kernellparallel.promiselparallel.raw-queuelparallel.cons-queuelparallel.defpunlparallel.counterlparallel.vector-queuelparallel.utillparallelThis is a convenience package which exports the external symbols of:
lparallel.kernel
lparallel.promise
lparallel.defpun
lparallel.cognate
lparallel.ptree
common-lisp.
lparallel.cognate.
lparallel.defpun.
lparallel.kernel.
lparallel.promise.
lparallel.ptree.
lparallel.thread-util(private) Thread utilities.
common-lisp.
lparallel.util.
cas (macro).
condition-notify (compiler macro).
condition-notify (function).
condition-wait (compiler macro).
condition-wait (function).
make-spin-lock (function).
with-lock-predicate/no-wait (macro).
with-lock-predicate/wait (macro).
with-spin-lock-held (macro).
with-thread (macro).
%time-remaining (function).
define-locking-fn (macro).
define-locking-fn/base (macro).
define-simple-locking-fn (macro).
get-real-time-in-seconds (function).
with-abort-restart (macro).
with-countdown (macro).
lparallel.cognateParallelized versions of some Common Lisp functions.
pand (macro).
pcount (function).
pcount-if (function).
pcount-if-not (function).
pdotimes (macro).
pevery (function).
pfind (function).
pfind-if (function).
pfind-if-not (function).
pfuncall (macro).
pmap (compiler macro).
pmap (function).
pmap-into (compiler macro).
pmap-into (function).
pmap-reduce (function).
pmapc (function).
pmapcan (function).
pmapcar (function).
pmapcon (function).
pmapl (function).
pmaplist (function).
pmaplist-into (function).
pnotany (function).
pnotevery (function).
por (macro).
preduce (function).
preduce-partial (function).
premove (function).
premove-if (function).
premove-if-not (function).
psome (function).
psort (function).
psort* (compiler macro).
psort* (function).
%%%%.binding-datum.form (reader).
(setf %%%%.binding-datum.form) (writer).
%%%%.binding-datum.future-result (reader).
(setf %%%%.binding-datum.future-result) (writer).
%%%%.binding-datum.future-var (reader).
(setf %%%%.binding-datum.future-var) (writer).
%%%%.binding-datum.vars (reader).
(setf %%%%.binding-datum.vars) (writer).
%%%%.defpun.quicksort/key/gran (function).
%%%%.defpun.quicksort/key/no-gran (function).
%%%%.defpun.quicksort/no-key/gran (function).
%%%%.defpun.quicksort/no-key/no-gran (function).
%mv-macrolet-bindings (function).
%parse-options (function).
%pdotimes (function).
%plet (macro).
%preduce-partial (function).
*standard-declaration-identifiers* (special variable).
all-binding-vars (function).
binding-datum (structure).
binding-datum-p (function).
binding-datum-vars (compiler macro).
binding-datum-vars (reader).
binding-decl-spec (function).
binding-decl-specs (function).
call-quicksort (function).
check-symbols (macro).
copy-binding-datum (function).
custom-declaration-p (function).
decl-spec->typed-vars (function).
decl-specs->typed-vars (function).
declaration-information (function).
declarationp (function).
declares->decl-specs (function).
declares->typed-vars (function).
define-quicksort-fn (macro).
define-quicksort-fns (macro).
defmacro/syms (macro).
find-min-length (function).
find-num-parts (function).
future-let-binding (function).
future-let-bindings (function).
future-macrolet-binding (function).
future-macrolet-bindings (function).
get-parts-hint (function).
item-predicate (function).
lookup-all (function).
make-binding-data (function).
make-binding-datum-instance (function).
make-input-parts (function).
make-mv-binding-datum (function).
make-parts (function).
make-result-parts (function).
make-sv-binding-datum (function).
map-into/vector/1-vector/range (macro).
map-iterate (function).
map-nil (function).
maplist-into (function).
midpoint (function).
mv-macrolet-bindings (function).
parse-options (function).
partition (function).
pfind-if/list (function).
pfind-if/vector (function).
pmap-into/parsed (function).
pmap-into/parts (function).
pmap-into/powder (function).
pmap-into/powder/array (function).
pmap-into/powder/list (function).
pmap-into/unparsed (function).
pmap-into/vector/1-vector (macro).
pmap-iterate (function).
pmap-iterate/parts (function).
pmap-iterate/powder (function).
pmap/parsed (function).
pmap/unparsed (function).
pop-plist (macro).
pquantifier (function).
preduce-partial/list (function).
preduce-partial/vector (function).
preduce/common (function).
premove-if-not/list (function).
quicksort/key/gran (function).
quicksort/key/no-gran (function).
quicksort/no-key/gran (function).
quicksort/no-key/no-gran (function).
quoted-vector-type-p (function).
quotedp (function).
subdivide-array (function).
subdivide-list (function).
subdivide-list/slice (function).
subsize (function).
toplevel-plet (macro).
unknown-typed-vars (function).
var-type (function).
with-binding-datum-slots (macro).
with-forms-submitted (macro).
with-parsed-options (macro).
with-parts (macro).
with-pfind-context (macro).
with-preduce-context (macro).
zip-repeat (function).
zip/vector (function).
lparallel.queueBlocking FIFO queue for communication between threads.
common-lisp.
lparallel.cons-queue.
lparallel.thread-util.
lparallel.util.
lparallel.vector-queue.
make-queue (compiler macro).
make-queue (function).
peek-queue (function).
peek-queue/no-lock (function).
pop-queue (function).
pop-queue/no-lock (function).
push-queue (function).
push-queue/no-lock (function).
queue (type).
queue (slot).
queue (slot).
queue-count (function).
queue-count/no-lock (function).
queue-empty-p (function).
queue-empty-p/no-lock (function).
queue-full-p (function).
queue-full-p/no-lock (function).
try-pop-queue (function).
try-pop-queue/no-lock (function).
with-locked-queue (macro).
%make-queue (function).
call-with-locked-cons-queue (function).
call-with-locked-queue (function).
call-with-locked-vector-queue (function).
cons-queue-full-p (function).
cons-queue-full-p/no-lock (function).
define-queue-fn (macro).
define-try-pop-queue (macro).
lparallel.kernel-util(semi-private) Abstracts some common patterns for submitting and receiving tasks. This probably won’t change, but no guarantees.
common-lisp.
lparallel.kernel.
lparallel.queue.
lparallel.util.
with-submit-cancelable (macro).
with-submit-counted (macro).
with-submit-indexed (macro).
with-temp-kernel (macro).
call-with-temp-kernel (function).
indexing-wrapper (function).
receive-results (function).
steal-until-receive-result (function).
lparallel.spin-queue(private) Thread-safe FIFO queue which spins instead of locks.
common-lisp.
lparallel.thread-util.
lparallel.util.
make-spin-queue (function).
peek-spin-queue (function).
pop-spin-queue (function).
push-spin-queue (function).
spin-queue (structure).
spin-queue-count (function).
spin-queue-empty-p (function).
%make-spin-queue (function).
+dead-end+ (constant).
+dummy+ (constant).
copy-spin-queue (function).
make-node (compiler macro).
make-node (function).
node (type).
node-car (macro).
node-cdr (macro).
spin-queue-head (reader).
(setf spin-queue-head) (writer).
spin-queue-p (function).
spin-queue-tail (reader).
(setf spin-queue-tail) (writer).
try-each-elem (function).
lparallel.slet(private) Serial let.
common-lisp.
lparallel.util.
slet (macro).
%slet (macro).
bind (macro).
make-binding-data (function).
make-binding-datum (function).
make-temp-var (function).
parse-bindings (function).
lparallel.ptreeA ptree is a computation represented by a tree together with functionality to execute the tree in parallel.
common-lisp.
lparallel.kernel.
lparallel.queue.
lparallel.thread-util.
lparallel.util.
*ptree-node-kernel* (special variable).
call-ptree (function).
check-ptree (function).
clear-ptree (function).
clear-ptree-errors (function).
make-ptree (function).
ptree (macro).
ptree (structure).
ptree-computed-p (function).
ptree-fn (function).
ptree-lambda-list-keyword-error (condition).
ptree-redefinition-error (condition).
ptree-undefined-function-error (condition).
%%%%.node.children (reader).
(setf %%%%.node.children) (writer).
%%%%.node.children-done-p (reader).
(setf %%%%.node.children-done-p) (writer).
%%%%.node.function (reader).
(setf %%%%.node.function) (writer).
%%%%.node.id (reader).
(setf %%%%.node.id) (writer).
%%%%.node.lock-level (reader).
(setf %%%%.node.lock-level) (writer).
%%%%.node.parents (reader).
(setf %%%%.node.parents) (writer).
%%%%.node.result (reader).
(setf %%%%.node.result) (writer).
%%%%.ptree.lock (reader).
(setf %%%%.ptree.lock) (writer).
%%%%.ptree.nodes (reader).
(setf %%%%.ptree.nodes) (writer).
%%%%.ptree.pending (reader).
(setf %%%%.ptree.pending) (writer).
%%%%.ptree.queue (reader).
(setf %%%%.ptree.queue) (writer).
+no-result+ (constant).
check-node (function).
children-done-p (function).
clear-node (function).
clear-node-error (function).
compute-node (function).
compute-ptree (function).
computedp (function).
copy-node (function).
copy-ptree (function).
each-node (function).
find-node (function).
freep (function).
id (compiler macro).
id (reader).
lock (compiler macro).
lock (reader).
lock-level (compiler macro).
lock-level (reader).
lock-node (function).
make-node-instance (function).
make-node-task (function).
make-ptree-instance (function).
node (structure).
node-p (function).
nodes (compiler macro).
nodes (reader).
propagate-error (function).
ptree-error (condition).
ptree-error-id (generic reader).
ptree-error-llks (generic reader).
ptree-error-refs (generic reader).
ptree-p (function).
result (compiler macro).
result (reader).
submit-node (function).
unlock-node (function).
wait-for-compute (function).
with-node-slots (macro).
with-ptree-slots (macro).
lparallel.kernelEncompasses the scheduling and execution of parallel tasks using a pool of worker threads. All parallelism in lparallel is done on top of the kernel.
common-lisp.
lparallel.counter.
lparallel.queue.
lparallel.spin-queue.
lparallel.thread-util.
lparallel.util.
*debug-tasks-p* (special variable).
*kernel* (special variable).
*kernel-spin-count* (special variable).
*task-category* (special variable).
*task-priority* (special variable).
broadcast-task (function).
cancel-timeout (compiler macro).
cancel-timeout (function).
channel (structure).
check-kernel (function).
do-fast-receives (macro).
end-kernel (function).
invoke-transfer-error (function).
kernel (structure).
kernel-bindings (function).
kernel-context (function).
kernel-creation-error (condition).
kernel-name (function).
kernel-worker-count (function).
kernel-worker-index (function).
kill-tasks (function).
make-channel (compiler macro).
make-channel (function).
make-kernel (function).
no-kernel-error (condition).
receive-result (function).
submit-task (function).
submit-timeout (compiler macro).
submit-timeout (function).
task-categories-running (function).
task-handler-bind (macro).
task-killed-error (condition).
try-receive-result (function).
%%%%.channel.kernel (reader).
(setf %%%%.channel.kernel) (writer).
%%%%.channel.queue (reader).
(setf %%%%.channel.queue) (writer).
%%%%.kernel.alivep (reader).
(setf %%%%.kernel.alivep) (writer).
%%%%.kernel.limiter-accept-task-p (function).
(setf %%%%.kernel.limiter-accept-task-p) (function).
%%%%.kernel.limiter-count (function).
(setf %%%%.kernel.limiter-count) (function).
%%%%.kernel.limiter-lock (function).
(setf %%%%.kernel.limiter-lock) (function).
%%%%.kernel.scheduler (reader).
(setf %%%%.kernel.scheduler) (writer).
%%%%.kernel.use-caller-p (reader).
(setf %%%%.kernel.use-caller-p) (writer).
%%%%.kernel.worker-info (reader).
(setf %%%%.kernel.worker-info) (writer).
%%%%.kernel.workers (reader).
(setf %%%%.kernel.workers) (writer).
%%%%.kernel.workers-lock (reader).
(setf %%%%.kernel.workers-lock) (writer).
%%%%.scheduler.low-priority-tasks (reader).
(setf %%%%.scheduler.low-priority-tasks) (writer).
%%%%.scheduler.notify-count (reader).
(setf %%%%.scheduler.notify-count) (writer).
%%%%.scheduler.random-index (reader).
(setf %%%%.scheduler.random-index) (writer).
%%%%.scheduler.spin-count (reader).
(setf %%%%.scheduler.spin-count) (writer).
%%%%.scheduler.wait-count (reader).
(setf %%%%.scheduler.wait-count) (writer).
%%%%.scheduler.wait-cvar (reader).
(setf %%%%.scheduler.wait-cvar) (writer).
%%%%.scheduler.wait-lock (reader).
(setf %%%%.scheduler.wait-lock) (writer).
%%%%.scheduler.workers (reader).
(setf %%%%.scheduler.workers) (writer).
%%%%.timeout.canceled-result (reader).
(setf %%%%.timeout.canceled-result) (writer).
%%%%.timeout.lock (reader).
(setf %%%%.timeout.lock) (writer).
%%%%.timeout.thread (reader).
(setf %%%%.timeout.thread) (writer).
%%%%.worker-info.bindings (reader).
(setf %%%%.worker-info.bindings) (writer).
%%%%.worker-info.context (reader).
(setf %%%%.worker-info.context) (writer).
%%%%.worker-info.name (reader).
(setf %%%%.worker-info.name) (writer).
%%%%.worker-notifications.exit-notification (reader).
(setf %%%%.worker-notifications.exit-notification) (writer).
%%%%.worker-notifications.handshake/from-worker (reader).
(setf %%%%.worker-notifications.handshake/from-worker) (writer).
%%%%.worker-notifications.handshake/to-worker (reader).
(setf %%%%.worker-notifications.handshake/to-worker) (writer).
%%%%.worker.exit-notification (function).
(setf %%%%.worker.exit-notification) (function).
%%%%.worker.handshake/from-worker (function).
(setf %%%%.worker.handshake/from-worker) (function).
%%%%.worker.handshake/to-worker (function).
(setf %%%%.worker.handshake/to-worker) (function).
%%%%.worker.index (reader).
(setf %%%%.worker.index) (writer).
%%%%.worker.running-category (reader).
(setf %%%%.worker.running-category) (writer).
%%%%.worker.tasks (reader).
(setf %%%%.worker.tasks) (writer).
%%%%.worker.thread (reader).
(setf %%%%.worker.thread) (writer).
%%%%.wrapped-error.value (reader).
(setf %%%%.wrapped-error.value) (writer).
%call-with-task-handler (function).
%fill-workers (function).
%kernel-worker-count (function).
%make-channel (function).
%make-worker (function).
*client-handlers* (special variable).
*debugger-error* (special variable).
*erroring-workers* (special variable).
*erroring-workers-lock* (special variable).
*handler-active-p* (special variable).
*lisp-exiting-p* (special variable).
*make-limiter-data* (special variable).
*worker* (special variable).
+current-task+ (constant).
+worker-suicide-tag+ (constant).
alivep (compiler macro).
alivep (reader).
call-with-task-handler (function).
call-with-tracked-error (function).
call-with-worker-context (function).
channel-kernel (compiler macro).
channel-kernel (reader).
channel-p (function).
channel-queue (compiler macro).
channel-queue (reader).
condition-handler (function).
copy-channel (function).
copy-kernel (function).
copy-limiter (function).
copy-scheduler (function).
copy-timeout (function).
copy-worker (function).
copy-worker-info (function).
copy-worker-notifications (function).
copy-wrapped-error (function).
define-mod-inc-dec (macro).
define-mod-incf-decf (macro).
define-worker-info-reader (macro).
deprecated-timeout (function).
do-indexes (macro).
do-workers (macro).
enter-worker-loop (function).
exec-task/non-worker (function).
exec-task/worker (function).
fill-workers (function).
handshake/from-worker/finish (function).
handshake/from-worker/start (function).
handshake/to-worker/finish (function).
handshake/to-worker/start (function).
kernel-info (function).
kernel-p (function).
kill (function).
kill-errors (function).
kill-errors-report (function).
limiter (structure).
limiter-accept-task-p (reader).
(setf limiter-accept-task-p) (writer).
limiter-count (reader).
(setf limiter-count) (writer).
limiter-lock (reader).
(setf limiter-lock) (writer).
limiter-p (function).
make-all-bindings (function).
make-channel-instance (function).
make-channeled-task (function).
make-debugger-hook (function).
make-kernel-instance (function).
make-limiter (function).
make-scheduler (function).
make-scheduler-instance (function).
make-task (function).
make-task-instance (compiler macro).
make-task-instance (function).
make-timeout-instance (function).
make-worker (function).
make-worker-info-instance (function).
make-worker-instance (function).
make-worker-notifications-instance (function).
make-worker-thread (function).
make-wrapped-error-instance (function).
maybe-wake-a-worker (function).
mod-dec (macro).
mod-decf (macro).
mod-inc (macro).
mod-incf (macro).
next-task (function).
notify-exit (function).
push-to-random-worker (function).
repeat/fixnum (macro).
replace-worker (function).
running-category (compiler macro).
running-category (reader).
schedule-task (function).
scheduler (compiler macro).
scheduler (reader).
scheduler (structure).
scheduler-p (function).
shutdown (function).
steal-task (function).
steal-work (function).
submit-raw-task (function).
task (type).
task-category (compiler macro).
task-category (function).
task-fn (compiler macro).
task-fn (function).
task-lambda (macro).
tasks (compiler macro).
tasks (reader).
thread (compiler macro).
thread (reader).
timeout (structure).
timeout-p (function).
track-exit (function).
transfer-error-report (function).
transfer-error-restart (function).
unwrap-result (function).
use-caller-p (compiler macro).
use-caller-p (reader).
wait-for-worker (function).
with-channel-slots (macro).
with-fill-workers-handler (macro).
with-kernel-slots (macro).
with-pop-success (macro).
with-scheduler-slots (macro).
with-task-context (macro).
with-timeout-slots (macro).
with-tracked-error (macro).
with-worker-info-slots (macro).
with-worker-notifications-slots (macro).
with-worker-restarts (macro).
with-worker-slots (macro).
with-wrapped-error-slots (macro).
worker (structure).
worker-index (compiler macro).
worker-index (reader).
worker-info (structure).
worker-info-p (function).
worker-loop (function).
worker-notifications (structure).
worker-notifications-p (function).
worker-p (function).
workers (compiler macro).
workers (reader).
wrap-error (function).
wrapped-error (structure).
wrapped-error-p (function).
wrapped-error-value (compiler macro).
wrapped-error-value (reader).
lparallel.promisePromises and futures.
common-lisp.
lparallel.kernel.
lparallel.thread-util.
lparallel.util.
%%%%.%chain.object (reader).
(setf %%%%.%chain.object) (writer).
%%%%.%delay.fn (function).
(setf %%%%.%delay.fn) (function).
%%%%.%delay.lock (function).
(setf %%%%.%delay.lock) (function).
%%%%.%delay.result (function).
(setf %%%%.%delay.result) (function).
%%%%.%future.canceledp (reader).
(setf %%%%.%future.canceledp) (writer).
%%%%.%future.fn (function).
(setf %%%%.%future.fn) (function).
%%%%.%future.lock (function).
(setf %%%%.%future.lock) (function).
%%%%.%future.result (function).
(setf %%%%.%future.result) (function).
%%%%.%promise.availablep (reader).
(setf %%%%.%promise.availablep) (writer).
%%%%.%promise.cvar (reader).
(setf %%%%.%promise.cvar) (writer).
%%%%.%promise.lock (function).
(setf %%%%.%promise.lock) (function).
%%%%.%promise.result (function).
(setf %%%%.%promise.result) (function).
%%%%.plan.fn (reader).
(setf %%%%.plan.fn) (writer).
%%%%.plan.lock (function).
(setf %%%%.plan.lock) (function).
%%%%.plan.result (function).
(setf %%%%.plan.result) (function).
%%%%.promise-base.lock (reader).
(setf %%%%.promise-base.lock) (writer).
%%%%.promise-base.result (reader).
(setf %%%%.promise-base.result) (writer).
%chain (structure).
%chain-p (function).
%delay (structure).
%delay-p (function).
%future (structure).
%future-p (function).
%promise (structure).
%promise-p (function).
+no-result+ (constant).
chain-object (compiler macro).
chain-object (reader).
copy-%chain (function).
copy-%delay (function).
copy-%future (function).
copy-%promise (function).
copy-plan (function).
copy-promise-base (function).
force-delay (function).
force-future (function).
force-promise (function).
fulfill-delay (function).
fulfill-future (function).
fulfill-object (function).
fulfill-plan/call (function).
fulfill-plan/error (function).
fulfill-plan/values (function).
fulfill-promise (function).
make-%chain-instance (function).
make-%delay-instance (function).
make-%future-instance (function).
make-%promise-instance (function).
make-future (function).
make-future-task (function).
make-plan-instance (function).
make-promise-base-instance (function).
plan (structure).
plan-fn (compiler macro).
plan-fn (reader).
plan-p (function).
promise-base (structure).
promise-base-p (function).
replace-error (function).
result (compiler macro).
result (reader).
with-%chain-slots (macro).
with-%delay-slots (macro).
with-%future-slots (macro).
with-%promise-slots (macro).
with-lock-operation (macro).
with-plan-slots (macro).
with-promise-base-slots (macro).
with-unfulfilled-future/no-wait (macro).
with-unfulfilled/no-wait (macro).
with-unfulfilled/wait (macro).
lparallel.raw-queue(private) Raw queue data structure.
common-lisp.
lparallel.util.
make-raw-queue (function).
peek-raw-queue (function).
pop-raw-queue (function).
push-raw-queue (function).
raw-queue (structure).
raw-queue-count (function).
raw-queue-count (type).
raw-queue-empty-p (function).
%make-raw-queue (function).
copy-raw-queue (function).
head (reader).
(setf head) (writer).
raw-queue-p (function).
tail (reader).
(setf tail) (writer).
lparallel.cons-queue(private) Blocking infinite-capacity queue.
common-lisp.
lparallel.raw-queue.
lparallel.thread-util.
lparallel.util.
cons-queue (structure).
cons-queue-count (function).
cons-queue-count/no-lock (function).
cons-queue-empty-p (function).
cons-queue-empty-p/no-lock (function).
make-cons-queue (function).
peek-cons-queue (function).
peek-cons-queue/no-lock (function).
pop-cons-queue (function).
pop-cons-queue/no-lock (function).
push-cons-queue (function).
push-cons-queue/no-lock (function).
try-pop-cons-queue (function).
try-pop-cons-queue/no-lock (function).
with-locked-cons-queue (macro).
%%%%.cons-queue.cvar (reader).
(setf %%%%.cons-queue.cvar) (writer).
%%%%.cons-queue.impl (reader).
(setf %%%%.cons-queue.impl) (writer).
%%%%.cons-queue.lock (reader).
(setf %%%%.cons-queue.lock) (writer).
%make-cons-queue (function).
%try-pop-cons-queue/no-lock/timeout (function).
cons-queue-p (function).
copy-cons-queue (function).
define-queue-fn (macro).
impl (compiler macro).
impl (reader).
lock (compiler macro).
lock (reader).
make-cons-queue-instance (function).
try-pop-cons-queue/no-lock/timeout (function).
with-cons-queue-slots (macro).
lparallel.defpunFine-grained parallelism.
common-lisp.
lparallel.kernel.
lparallel.slet.
lparallel.thread-util.
lparallel.util.
declaim-defpun (macro).
defpun (macro).
defpun* (macro).
defpun/type (macro).
defpun/type* (macro).
plet (macro).
plet-if (macro).
%%%%plet (macro).
%%%plet (macro).
%%plet (macro).
%plet (macro).
%plet-if (macro).
*registered-names* (special variable).
*registration-lock* (special variable).
+checked-key+ (constant).
+no-result+ (constant).
+unchecked-key+ (constant).
accept-task-p (macro).
call-impl-fn (function).
call-inside-worker (function).
call-with-toplevel-handler (function).
client-vars (function).
define-defpun (macro).
defun/wrapper (macro).
delete-registered-names (function).
delete-stale-registrations (function).
exec-task (macro).
initial-limiter-count (function).
make-limiter-data (function).
msetq (macro).
primary-temp-vars (function).
register-fn (function).
register-name (function).
registered-fn-p (function).
registered-macrolets (function).
scan-for-errors (macro).
spawn (macro).
spawn-tasks (macro).
sync (macro).
temp-vars (function).
unchecked-name (function).
update-limiter-count (function).
update-limiter-count/no-lock (function).
valid-registered-fn-p (function).
valid-registered-name-p (function).
with-client-bindings (macro).
with-lock-predicates (macro).
with-temp-bindings (macro).
lparallel.counter(private) Atomic counter.
common-lisp.
lparallel.thread-util.
lparallel.util.
counter (structure).
counter-value (reader).
(setf counter-value) (writer).
counter-value (type).
dec-counter (function).
inc-counter (function).
make-counter (function).
copy-counter (function).
counter-p (function).
define-counter-fn (macro).
lparallel.vector-queue(private) Blocking fixed-capacity queue.
common-lisp.
lparallel.thread-util.
lparallel.util.
make-vector-queue (function).
peek-vector-queue (function).
peek-vector-queue/no-lock (function).
pop-vector-queue (function).
pop-vector-queue/no-lock (function).
push-vector-queue (function).
push-vector-queue/no-lock (function).
try-pop-vector-queue (function).
try-pop-vector-queue/no-lock (function).
vector-queue (structure).
vector-queue-capacity (function).
vector-queue-count (function).
vector-queue-count/no-lock (function).
vector-queue-empty-p (function).
vector-queue-empty-p/no-lock (function).
vector-queue-full-p (function).
vector-queue-full-p/no-lock (function).
with-locked-vector-queue (macro).
%%%%.raw-queue.count (reader).
(setf %%%%.raw-queue.count) (writer).
%%%%.raw-queue.data (reader).
(setf %%%%.raw-queue.data) (writer).
%%%%.raw-queue.start (reader).
(setf %%%%.raw-queue.start) (writer).
%%%%.vector-queue.impl (reader).
(setf %%%%.vector-queue.impl) (writer).
%%%%.vector-queue.lock (reader).
(setf %%%%.vector-queue.lock) (writer).
%%%%.vector-queue.notify-pop (reader).
(setf %%%%.vector-queue.notify-pop) (writer).
%%%%.vector-queue.notify-push (reader).
(setf %%%%.vector-queue.notify-push) (writer).
%make-vector-queue (function).
%try-pop-vector-queue/no-lock/timeout (function).
copy-raw-queue (function).
copy-vector-queue (function).
data (compiler macro).
data (reader).
define-queue-fn (macro).
impl (compiler macro).
impl (reader).
lock (compiler macro).
lock (reader).
make-raw-queue (function).
make-raw-queue-instance (function).
make-vector-queue-instance (function).
peek-raw-queue (function).
pop-raw-queue (function).
push-raw-queue (function).
raw-queue (structure).
raw-queue-capacity (function).
raw-queue-count (compiler macro).
raw-queue-count (reader).
raw-queue-count (type).
raw-queue-empty-p (function).
raw-queue-full-p (function).
raw-queue-p (function).
try-pop-vector-queue/no-lock/no-timeout (function).
try-pop-vector-queue/no-lock/timeout (function).
vector-queue-capacity/no-lock (function).
vector-queue-p (function).
with-raw-queue-slots (macro).
with-vector-queue-slots (macro).
lparallel.util(private) Miscellaneous utilities.
common-lisp.
*full-optimize* (special variable).
*normal-optimize* (special variable).
alias-function (macro).
alias-macro (macro).
defmacro/once (macro).
defpair (macro).
defslots (macro).
defun/inline (macro).
defun/type (macro).
defun/type/inline (macro).
dosequence (macro).
index (slot).
index (type).
interact (function).
partial-apply (compiler macro).
partial-apply (function).
repeat (macro).
to-boolean (function).
unsplice (function).
unwind-protect/ext (macro).
with-parsed-body (macro).
%defslots (macro).
constrain-return-type (function).
define-reader (macro).
define-readers (macro).
define-slots-macrolet (macro).
define-struct (macro).
define-with-slots-macro (macro).
defslots-names (function).
parse-defslots (function).
plist-keys (function).
plist-values-for-key (function).
symbolicate/no-intern (function).
symbolicate/package (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
If true (the default), the debugger is invoked when an error goes
unhandled inside a task, i.e. when the handlers established by
‘task-handler-bind’ (if any) do not handle it.
If false, unhandled errors from tasks are automatically transferred
to their parent thread (and/or any dependent threads) via the
‘transfer-error’ restart. This is for convenience – sometimes you
wish to avoid N debugger popups arising from N errors in N worker
threads.
For local control over debugger invocation, bind a task handler:
(task-handler-bind ((error #’invoke-debugger)) ...)
(task-handler-bind ((error #’invoke-transfer-error)) ...)
The current kernel, or nil.
Default value of the ‘spin-count’ argument to ‘make-kernel’.
When non-nil, ‘*kernel*’ is bound to this value during the call of a node function.
See ‘kill-tasks’. Default value is ‘:default’.
When bound to ‘:low’, the kernel schedules submitted tasks at low priority. Default value is ‘:default’.
See ‘defpun’.
Like ‘defmacro’ except that params which are immediately preceded by ‘&once’ are passed to a ‘once-only’ call which surrounds ‘body’.
Define a cons type using defclass syntax.
Exactly two slots and zero superclasses must be given.
Available slot options are: ‘:initform’, ‘:type’, ‘:reader’.
A deftype for ‘name’ is defined.
‘(defpair foo ...)’ defines the function ‘make-foo-instance’ which takes keyword arguments corresponding to slots of the same name.
All slots must be initialized when an instance is created, else an error will be signaled.
‘defpun’ defines a function which is specially geared for
fine-grained parallelism. If you have many small tasks which bog down
the system, ‘defpun’ may help.
The syntax of ‘defpun’ matches that of ‘defun’. The difference is that
‘plet’ and ‘plet-if’ take on new meaning inside ‘defpun’. The symbols
in the binding positions of ‘plet’ and ‘plet-if’ should be viewed as
lazily evaluated immutable references.
Inside a ‘defpun’ form the name of the function being defined is a
macrolet, as are the names of other functions which were defined by
‘defpun’. Thus using #’ on them is an error. Calls to functions
defined by ‘defpun’ entail more overhead when the caller lies outside
a ‘defpun’ form.
A ‘defpun’ function must exist before it is referenced inside another
‘defpun’ function. If this is not possible–for example if func1 and
func2 reference each other–then use ‘declaim-defpun’ to specify
intent:
(declaim-defpun func1 func2)
Deprecated. Instead use ‘defpun’ and pass ‘:use-caller t’ to ‘make-kernel’.
Typed version of ‘defpun’.
‘arg-types’ is an unevaluated list of argument types.
‘return-type’ is an unevaluated form of the return type, possibly
indicating multiple values as in (values fixnum float).
(As a technical point, if ‘return-type’ contains no lambda list keywords then the return type given to ftype will be additionally constrained to match the number of return values specified.)
Deprecated. Instead use ‘defpun/type’ and pass ‘:use-caller t’ to ‘make-kernel’.
Define a thing with slots.
A ‘defslots’ form may expand to either a ‘defclass’ form or a
‘defstruct’ form. Thou art foolish to depend upon either.
The syntax of ‘defslots’ matches that of ‘defclass’ with the following
restrictions: at most one superclass is permitted; ‘:initform’,
‘:type’, and ‘:reader’, are the only slot options allowed;
‘:documentation’ is the only class option allowed.
‘(defslots foo ...)’ defines the functions ‘make-foo-instance’ and
‘with-foo-slots’ which are like ‘make-instance’ and ‘with-slots’
respectively. ‘make-foo-instance’ takes keyword arguments
corresponding to slots of the same name.
All slots must be initialized when an instance is created, else an error will be signaled.
Shortcut for
(declaim (inline foo))
(defun foo ...).
Shortcut for
(declaim (ftype (function arg-types return-type) foo)
(defun foo ...).
Additionally constrains return-type to the number of values provided.
Create a delay. A delay is a promise which is fulfilled when ‘force’ is called upon it.
Receive ‘count’ number of results from ‘channel’, executing ‘body’
each time with the result bound to ‘result’.
‘body’ should be a trivial operation such as an aref call.
Attempt to give ‘object’ a value.
If ‘object’ is a promise which is not fulfilled and not currently
being fulfilled, then the implicit progn ‘body’ will be executed and
the promise will store the result. In this case ‘fulfill’ returns
true.
If ‘object’ is a promise that is either already fulfilled or actively
being fulfilled, then ‘body’ will not be executed and ‘fulfill’
returns false.
If ‘object’ is a chain, call ‘fulfill’ on the chained object.
If ‘object’ is not a promise and not a chain then false is returned immediately, with ‘body’ being ignored.
Create a future. A future is a promise which is fulfilled in parallel by the implicit progn ‘body’.
Parallel version of ‘and’. Forms in ‘forms’ may be executed in parallel, though not necessarily at the same time. If all forms evaluate to true, then the result of any form may be returned.
Parallel version of ‘dotimes’.
The ‘parts’ option divides the integer range into ‘parts’ number of
parts. Default is (kernel-worker-count).
Unlike ‘dotimes’, ‘pdotimes’ does not define an implicit block named nil.
Parallel version of ‘funcall’. Arguments in ‘args’ may be executed in parallel, though not necessarily at the same time.
The syntax of ‘plet’ matches that of ‘let’.
plet ({var-no-init | (var [init-form]) | ((var1 var2 ...) [init-form])}*)
declaration* form*
For each (var init-form) pair, a future is created which executes
‘init-form’. Inside ‘body’, ‘var’ is a symbol macro which expands to a
‘force’ form for the corresponding future.
Likewise, each ((var1 var2 ...) init-form) pair creates a future where
‘var1’, ‘var2’,... are bound to the respective multiple return values
of ‘init-form’.
Each ‘var-no-init’ is bound to nil and each variable without a
corresponding ‘init-form’ is bound to nil (no future is created).
Type declarations for vars are recognized by ‘plet’ and incorporated
into the final expansion. The semantics of these declarations are the
same as those of a regular ‘let’ form.
‘plet’ is subject to optimization inside ‘defpun’.
The syntax of ‘plet-if’ matches that of ‘plet’ except for the
addition of the ‘predicate’ form.
If ‘predicate’ evaluates to true, the behavior is the same as ‘plet’.
If ‘predicate’ evaluates to false, the behavior is the same as ‘slet’.
‘plet-if’ is subject to optimization inside ‘defpun’.
Parallel version of ‘or’. Forms in ‘forms’ may be executed in parallel, though not necessarily at the same time. Any form which evaluates to non-nil may be returned.
Create a ptree using ‘flet’ syntax.
ptree ((node-name child-names function-body)*) form*
Each ‘node-name’ form corresponds to the definition of a ptree node.
‘node-name’ is the name of the node being defined (a symbol).
‘child-names’ is a list of the names of child nodes (symbols).
The function associated with the node being defined is
‘(lambda ,child-names ,@function-body)
‘child-names’ cannot contain lambda list keywords.
For each ‘node-name’, a symbol macro is defined which expands to a ‘call-ptree’ form for that node.
‘slet’ (serial let) is the non-parallel counterpart to ‘plet’.
The syntax of ‘slet’ matches that of ‘plet’, which includes the ability to bind multiple values.
Create a speculation. A speculation is a low-priority future.
Like ‘handler-bind’ but handles conditions signaled inside tasks that were created in ‘body’.
Extended ‘unwind-protect’.
‘prepare’ : executed first, outside of ‘unwind-protect’
‘main’ : protected form
‘cleanup’ : cleanup form
‘abort’ : executed if ‘main’ does not finish
Execute ‘body’ with the queue lock held. Use the ‘/no-lock’ functions inside ‘body’.
Pop docstring and declarations off ‘body’ and assign them to the variables ‘docstring’ and ‘declares’ respectively. If ‘docstring’ is not present then no docstring is parsed.
Create a temporary kernel for the duration of ‘body’, ensuring that
‘end-kernel’ is eventually called. ‘make-kernel’ is given the
arguments ‘make-kernel-args’.
**NOTE**: Use this only if you understand its implications. Since
‘*kernel*’ is unaffected outside ‘body’, the REPL will be useless with
respect to the temporary kernel. For instance calling ‘kill-tasks’
from the REPL will not affect tasks that are running in the temporary
kernel.
Multiple uses of ‘with-temp-kernel’ within the same application are
prone to defeat the purpose and benefits of having a thread pool. This
is an especial risk if ‘with-temp-kernel’ appears inside a library,
which is likely to be a suboptimal situation.
While using ‘with-temp-kernel’ is generally a bad idea, there are a few valid uses, such as for testing, where the code is non-critical or where convenience trumps other concerns.
Open-coding for 1 vector mapped to vector.
Open-coding for 1 vector mapped to vector.
Wait for current and pending tasks to complete, if any, then
simultaneously execute the given task inside each worker. Wait until
these tasks finish, then return the results in a vector.
Calling ‘broadcast-task’ from inside a worker is an error.
Return the computation result of the node with identifier ‘id’ in
‘ptree’.
If the node is uncomputed, compute the result.
If the node is already computed, return the computed result.
Attempt to cancel a timeout. If successful, the channel passed to
‘submit-timeout’ will receive ‘timeout-result’.
At most one call to ‘cancel-timeout’ will succeed; others will be
ignored. If the timeout has expired on its own then ‘cancel-timeout’
will have no effect.
‘cancel-timeout’ is not available in ABCL.
‘submit-timeout’ and ‘cancel-timeout’ are deprecated; use the new ‘:timeout’ option in ‘try-receive-result’.
Create a chain. A chain links objects together by relaying ‘force’ and ‘fulfilledp’ calls.
Ensures the value of ‘*kernel*’ is a kernel instance. Provides the MAKE-KERNEL and STORE-VALUE restarts. Returns ‘*kernel*’.
Verify that all nodes have been defined with an associated function. If not, ‘ptree-undefined-function-error’ is signaled.
Clear all node results in ‘ptree’, restoring the tree to its uncomputed state.
Clear all error results in ‘ptree’, allowing the computation to resume from its latest pre-error state.
Notify at least one of the threads waiting for
CONDITION-VARIABLE. It is implementation-dependent whether one or
more than one (and possibly all) threads are woken, but if the
implementation is capable of waking only a single thread (not all
are) this is probably preferable for efficiency reasons. The order
of wakeup is unspecified and does not necessarily relate to the
order that the threads went to sleep in.
CONDITION-NOTIFY has no useful return value. In an implementation that does not support multiple threads, it has no effect.
condition-notify.
Atomically release LOCK and enqueue the calling
thread waiting for CONDITION-VARIABLE. The thread will resume when
another thread has notified it using CONDITION-NOTIFY; it may also
resume if interrupted by some external event or in other
implementation-dependent circumstances: the caller must always test
on waking that there is threading to be done, instead of assuming
that it can go ahead.
It is an error to call function this unless from the thread that
holds LOCK.
If TIMEOUT is nil or not provided, the call blocks until a
notification is received.
If TIMEOUT is non-nil, the call will return after at most TIMEOUT seconds (approximately), whether or not a notification has occurred.
Either NIL or T will be returned. A return of NIL indicates that the
timeout has expired without receiving a notification. A return of T
indicates that a notification was received.
In an implementation that does not support multiple threads, this function signals an error.
condition-wait.
Sets ‘*kernel*’ to nil and ends all workers gracefully.
‘end-kernel’ should not be used as a substitute for properly waiting
on tasks with ‘receive-result’ or otherwise.
If ‘wait’ is nil (the default) then ‘end-kernel’ returns immediately.
Workers are waited upon by a separate shutdown manager thread.
If ‘wait’ is non-nil then ‘end-kernel’ blocks until all workers are
finished. No shutdown manager thread is created.
A list of the implementation-defined worker thread objects is
returned. If ‘wait’ is nil then the shutdown manager thread is also
returned as the first element in the list.
Note that creating and destroying kernels is relatively expensive. A kernel typically exists for lifetime of the Lisp process. Having more than one kernel is fine – simply use ‘let’ to bind a kernel instance to ‘*kernel*’ when you need it. Use ‘kill-tasks’ to terminate deadlocked or infinite looping tasks.
If ‘object’ is a promise and the promise is fulfilled, return the
fulfilled value (possibly multiple values). If the promise is
unfulfilled then the call blocks until the promise is fulfilled.
If ‘object’ is a chain, call ‘force’ on the chained object.
If ‘object’ is not a promise and not a chain, return the identical
object passed.
Note if ‘force’ is called on an unfulfilled future then the future is fulfilled by the caller of ‘force’.
If ‘object’ is a promise, return a boolean indicating whether the
promise is fulfilled.
If ‘object’ is a chain, call ‘fulfilledp’ on the chained object.
If ‘object’ is not a promise and not a chain, return true.
Read from user and eval.
Equivalent to (invoke-restart ’transfer-error error).
This is a convenience function for use in ‘task-handler-bind’.
Return the bindings passed to ‘make-kernel’.
Return the context passed to ‘make-kernel’.
Return the name passed to ‘make-kernel’.
Return the number of workers in the current kernel.
If called from inside a worker, return the worker’s assigned index,
ranging from 0 to one less than (kernel-worker-count).
If not called from inside a worker, return nil.
This is an expensive function which should only be used in
exceptional circumstances.
Every task has an associated task category. When a task is submitted,
it is assigned the category of ‘*task-category*’ which has a default
value of ‘:default’.
‘kill-tasks’ interrupts running tasks whose category is ‘eql’ to
‘task-category’. The corresponding worker threads are killed and
replaced. Pending tasks are not affected.
If you don’t know what to pass for ‘task-category’ then you should
probably pass ‘:default’, though this may kill more tasks than you
wish. Binding ‘*task-category*’ around ‘submit-task’ enables targeted
task killing.
If ‘dry-run’ is nil, the function returns the number of tasks killed.
If ‘dry-run’ is non-nil then no tasks are killed. In this case the
return value is the number of tasks that would have been killed if
‘dry-run’ were nil.
‘kill-tasks’ is not available in ABCL.
Create a channel for submitting and receiving tasks. The current
value of ‘*kernel*’ is stored for use in ‘submit-task’.
By default there is no limit on the channel capacity. Passing a
‘fixed-capacity’ keyword argument limits the capacity to the value
passed.
Note that a fixed capacity channel may cause a deadlocked kernel if ‘receive-result’ is not called a sufficient number of times.
Create a kernel with ‘worker-count’ number of worker threads.
‘name’ is a string identifier for this kernel which is reported by
‘print-object’. Worker threads will also be given this name, shown in
‘bordeaux-threads:all-threads’.
‘bindings’ is an alist for establishing thread-local variables inside
worker threads. By default workers will have *standard-output* and
*error-output* bindings.
Dynamic context for each worker may be established with the function ‘context’. The argument passed to ‘context’ is a function which must be funcalled. It begins the worker loop and will not return until the worker exits. The default value of ‘context’ is #’funcall. The special variables in ‘bindings’ are available inside the ‘context’ function.
When a worker discovers that no tasks are available, ‘spin-count’ is
the number of task-searching iterations done by the worker before
sleeping.
If ‘use-caller’ is true (default is false) then in certain situations
the calling thread may be enlisted to steal work from worker threads.
This is an optimization strategy that currently applies only during
the execution of functions defined by ‘defpun’ and ‘defpun/type’.
Typically in this case the number of workers will be one less than the
number of cores/CPUs.
A kernel will not be garbage collected until ‘end-kernel’ is called.
Create a ptree instance.
Create a queue.
The queue contents may be initialized with the keyword argument
‘initial-contents’.
By default there is no limit on the queue capacity. Passing a ‘fixed-capacity’ keyword argument limits the capacity to the value passed. ‘push-queue’ will block for a full fixed-capacity queue.
Returns a function that applies ARGUMENTS and the arguments it is called with to FUNCTION.
curry.
Parallel version of ‘count’.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘count-if’.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘count-if-not’.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
If ‘queue’ is non-empty, return (values element t) where ‘element’ is
the frontmost element of ‘queue’.
If ‘queue’ is empty, return (values nil nil).
Like ‘peek-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.
Parallel version of ‘every’. Calls to ‘predicate’ are done in
parallel, though not necessarily at the same time. Behavior is
otherwise indistinguishable from ‘every’.
Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘pfind’.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘pfind-if’.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘pfind-if-not’.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘map’. Keyword arguments ‘parts’ and ‘size’ are
also accepted.
The ‘parts’ option divides each sequence into ‘parts’ number of parts.
Default is (kernel-worker-count).
The ‘size’ option limits the number of elements mapped to ‘size’. When
given, no ‘length’ calls are made on the sequence(s) passed.
Warning: ‘size’ must be less than or equal to the length of the smallest sequence passed. It is unspecified what happens when that condition is not met.
Parallel version of ‘map-into’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Equivalent to (preduce reduce-function sequence :key map-function ...).
Parallel version of ‘mapc’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘mapcan’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘mapcar’. Keyword arguments ‘parts’ and ‘size’
are also accepted (see ‘pmap’).
Unlike ‘mapcar’, ‘pmapcar’ also accepts vectors.
Parallel version of ‘mapcon’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘mapl’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘maplist’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Like ‘pmaplist’ but results are stored in ‘result-list’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘notany’. Calls to ‘predicate’ are done in
parallel, though not necessarily at the same time. Behavior is
otherwise indistinguishable from ‘notany’.
Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘notevery’. Calls to ‘predicate’ are done in
parallel, though not necessarily at the same time. Behavior is
otherwise indistinguishable from ‘notevery’.
Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Remove the frontmost element from ‘queue’ and return it.
If ‘queue’ is empty, block until an element is available.
Like ‘pop-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.
Parallel version of ‘reduce’.
‘preduce’ subdivides the input sequence into ‘parts’ number of parts
and, in parallel, calls ‘reduce’ on each part. The partial results are
then reduced again, either by ‘reduce’ (the default) or, if ‘recurse’
is non-nil, by ‘preduce’.
‘parts’ defaults to (kernel-worker-count).
‘key’ is thrown out while reducing the partial results. It applies to
the first pass only.
‘start’ and ‘end’ have the same meaning as in ‘reduce’.
‘from-end’ means "from the end of each part".
‘initial-value’ means "initial value of each part".
Like ‘preduce’ but only does a single reducing pass.
The length of ‘sequence’ must not be zero.
Returns the partial results as a vector.
Parallel version of ‘remove’. Note the ‘count’ option is not
supported.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘remove-if’. Note the ‘count’ option is not
supported.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Parallel version of ‘remove-if-not’. Note the ‘count’ option is not
supported.
The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).
Create a promise. A promise is a receptacle for a result which is unknown at the time it is created.
Parallel version of ‘some’. Calls to ‘predicate’ are done in
parallel, though not necessarily at the same time. Behavior is
otherwise indistinguishable from ‘some’ except that any non-nil
predicate comparison result may be returned.
Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).
Parallel version of ‘sort’.
If ‘granularity’ is provided then parallel tasks are created only for
segments larger than ‘granularity’. This may or may not result in
better performance.
At present ‘psort’ is only parallelized for vectors; other types are given to ‘cl:sort’.
Deprecated. Instead use ‘psort’ and pass ‘:use-caller t’ to ‘make-kernel’.
Return true if the node with identifier ‘id’ in ‘ptree’ has finished computing, otherwise return false.
Define a ptree node with identifier ‘id’, which is some unique
object suitable for ‘eql’ comparison such as symbol.
The ids of its child nodes are elements of the list ‘args’.
‘function’ is the function associated with this node. The arguments
passed to ‘function’ are the respective results of the child node
computations.
‘ptree’ is the ptree instance in which the node is being defined.
Push ‘object’ onto the back of ‘queue’.
Like ‘push-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.
Return the number of elements in ‘queue’.
Like ‘queue-count’ but does not acquire the lock. Use inside ‘with-locked-queue’.
Return true if ‘queue’ is empty, otherwise return false.
Like ‘queue-empty-p’ but does not acquire the lock. Use inside ‘with-locked-queue’.
Return true if ‘queue’ is full, otherwise return false.
Like ‘queue-full-p’ but does not acquire the lock. Use inside ‘with-locked-queue’.
Remove a result from ‘channel’. If nothing is available the call will block until a result is received.
Submit a task through ‘channel’ to the kernel stored in ‘channel’.
Effectively equivalent to
(submit-task channel (lambda () (sleep timeout-seconds) timeout-result))
The difference is that ‘submit-timeout’ does not occupy a worker
thread.
A timeout object is returned, which may be passed to ‘cancel-timeout’.
‘submit-timeout’ and ‘cancel-timeout’ are deprecated; use the new ‘:timeout’ option in ‘try-receive-result’.
Return a vector containing the task category currently running for each worker.
If ‘queue’ is non-empty, remove the frontmost element from ‘queue’ and return (values element t) where ‘element’ is the element removed.
If ‘queue’ is empty and ‘timeout’ is given, then wait up to ‘timeout’
seconds for the queue to become non-empty.
If ‘queue’ is empty and the timeout has expired, or if ‘queue’ is
empty and no ‘timeout’ was given, return (values nil nil).
Providing a nil or non-positive value of ‘timeout’ is equivalent to providing no timeout.
Like ‘try-pop-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.
If ‘channel’ has a result then remove it and return (values result t).
If no result is available and ‘timeout’ is given, then wait up to
‘timeout’ seconds for a result.
If the channel is empty and the timeout has expired, or if the channel
is empty and no timeout was given, return (values nil nil).
Providing a nil or non-positive value of ‘timeout’ is equivalent to providing no timeout.
Error signaled when ‘make-kernel’ fails.
error.
Error signaled when ‘*kernel*’ is nil.
error.
Lambda list keywords found in function definition.
:llks
This slot is read-only.
Attempted to redefine a node’s function.
Attempted to execute a node which had no function.
(quote nil)
:refs
This slot is read-only.
Error signaled when attempting to obtain the result of a killed task.
error.
A task is submitted to the kernel using a channel. A channel always points to the same kernel, which is the value of ‘*kernel*’ when the channel is created.
structure-object.
lparallel.queue:queue
(error "slot ~a in ~a not initialized" (quote lparallel.queue:queue) (quote lparallel.kernel:channel))
lparallel.kernel:kernel
(error "slot ~a in ~a not initialized" (quote lparallel.kernel:kernel) (quote lparallel.kernel:channel))
structure-object.
lparallel.raw-queue:raw-queue
(error "slot ~a in ~a not initialized" (quote lparallel.cons-queue::impl) (quote lparallel.cons-queue:cons-queue))
(bordeaux-threads:make-lock)
structure-object.
lparallel.counter:counter-value
0
The kernel encompasses the scheduling and execution of parallel tasks using a pool of worker threads. All parallelism in lparallel is done on top of the kernel.
lparallel.kernel::scheduler
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::scheduler) (quote lparallel.kernel:kernel))
simple-vector
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::workers) (quote lparallel.kernel:kernel))
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::workers-lock) (quote lparallel.kernel:kernel))
lparallel.kernel::worker-info
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::worker-info) (quote lparallel.kernel:kernel))
boolean
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::use-caller-p) (quote lparallel.kernel:kernel))
boolean
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::alivep) (quote lparallel.kernel:kernel))
A ptree is a computation represented by a tree together with functionality to execute the tree in parallel.
structure-object.
hash-table
(make-hash-table :test (function eql))
lparallel.queue:queue
(lparallel.queue:make-queue)
integer
0
(bordeaux-threads:make-lock)
structure-object.
lparallel.vector-queue::raw-queue
(error "slot ~a in ~a not initialized" (quote lparallel.vector-queue::impl) (quote lparallel.vector-queue:vector-queue))
(bordeaux-threads:make-lock)
Records handlers established with ‘task-handler-bind’ in the calling thread.
Track the error inside the debugger for the ‘transfer-error’ restart.
Track debugger popups in order to kill them.
Lock for *erroring-workers*.
Non-nil when handlers have been established via ‘call-with-task-handler’.
True if the Lisp process is exiting; for skipping auto-replacement of killed workers during exit.
The worker instance if inside a worker thread, otherwise nil.
Like ‘defmacro’ but requires all parameters to be symbols.
The syntax of ‘plet’ matches that of ‘let’.
plet ({var-no-init | (var [init-form]) | ((var1 var2 ...) [init-form])}*)
declaration* form*
For each (var init-form) pair, a future is created which executes
‘init-form’. Inside ‘body’, ‘var’ is a symbol macro which expands to a
‘force’ form for the corresponding future.
Likewise, each ((var1 var2 ...) init-form) pair creates a future where
‘var1’, ‘var2’,... are bound to the respective multiple return values
of ‘init-form’.
Each ‘var-no-init’ is bound to nil and each variable without a
corresponding ‘init-form’ is bound to nil (no future is created).
Type declarations for vars are recognized by ‘plet’ and incorporated
into the final expansion. The semantics of these declarations are the
same as those of a regular ‘let’ form.
‘plet’ is subject to optimization inside ‘defpun’.
plet.
cvar.
form.
vars.
cvar.
impl.
lock.
id.
fn.
lock.
lock.
data.
lock.
impl.
lock.
name.
Mimic the CL handling mechanism, calling handlers until one assumes control (or not).
Record ‘*debugger-error*’ for the ‘transfer-error’ restart.
Subdivide and interleave sequences for parallel mapping.
Return a list with SE1 as the CAR and SE2 as the CDR.
cons.
Subdivide the result sequence. For a list, delineate boundaries by slicing.
Return a list with SE1 as the CAR and SE2 as the CDR.
cons.
A variation of (map nil ...)/mapc/mapl with size constrained. Without a result to delineate sublist boundaries, we must enforce them manually.
A variation of map-into.
When a sequence of size N is divided into N parts, it becomes powder.
head.
tail.
Concatenate ‘string-designators’ then make-symbol the result.
Concatenate ‘string-designators’ then intern the result into ‘package’.
Return all but the first object in a list.
cdr.
Return the 1st object in a list.
car.
In ‘receive-result’, this is called on the stored task result. The user receives the return value of this function.
Wrap an error. A non-error condition may also be wrapped, though it will still be signaled with ‘error’.
ptree-error)) ¶id.
ptree-lambda-list-keyword-error)) ¶llks.
ptree-undefined-function-error)) ¶refs.
error.
:id
This slot is read-only.
structure-object.
(error "slot ~a in ~a not initialized" (quote lparallel.promise::object) (quote lparallel.promise::%chain))
structure-object.
(error "slot ~a in ~a not initialized" (quote lparallel.cognate::future-result) (quote lparallel.cognate::binding-datum))
(error "slot ~a in ~a not initialized" (quote lparallel.cognate::future-var) (quote lparallel.cognate::binding-datum))
(error "slot ~a in ~a not initialized" (quote lparallel.cognate::form) (quote lparallel.cognate::binding-datum))
(error "slot ~a in ~a not initialized" (quote lparallel.cognate::vars) (quote lparallel.cognate::binding-datum))
structure-object.
boolean
(error "no init")
(error "no init")
fixnum
(error "no init")
structure-object.
(error "slot ~a in ~a not initialized" (quote lparallel.ptree::id) (quote lparallel.ptree::node))
common-lisp.
(or function null)
list
list
fixnum
0
boolean
lparallel.ptree::+no-result+
(or null function)
(error "slot ~a in ~a not initialized" (quote lparallel.promise::fn) (quote lparallel.promise::plan))
structure-object.
simple-array
(error "slot ~a in ~a not initialized" (quote lparallel.vector-queue::data) (quote lparallel.vector-queue::raw-queue))
lparallel.util:index
0
common-lisp.
lparallel.vector-queue::raw-queue-count
0
A scheduler is responsible for storing tasks and finding the next
task to execute. A task may also be stolen from the scheduler.
‘workers’ – vector of workers; kernel has the same reference.
‘wait-cvar’, ‘wait-lock’, ‘wait-count’, ‘notify-count’ – these
coordinate waking/sleeping of workers.
‘spin-count’ – see ‘make-kernel’.
‘random-index’ – some random index to the vector of workers.
‘low-priority-tasks’ – tasks submitted when ‘*task-priority*’ is ‘:low’.
structure-object.
simple-vector
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::workers) (quote lparallel.kernel::scheduler))
(bordeaux-threads:make-condition-variable)
(bordeaux-threads:make-lock)
lparallel.counter:counter
(lparallel.counter:make-counter)
(integer 0)
0
lparallel.util:index
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::spin-count) (quote lparallel.kernel::scheduler))
lparallel.util:index
0
lparallel.spin-queue:spin-queue
(lparallel.spin-queue:make-spin-queue)
structure-object.
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::canceled-result) (quote lparallel.kernel::timeout))
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::thread) (quote lparallel.kernel::timeout))
(bordeaux-threads:make-lock)
A worker represents a thread dedicated to executing tasks. See ‘kill-tasks’ for an explanation of ‘running-category’. ‘index’ is the location of the worker in the kernel’s vector of workers. When the stealing scheduler is enabled, each worker has its own lockless task queue.
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::thread) (quote lparallel.kernel::worker))
lparallel.util:index
(error "slot ~a in ~a not initialized" (quote lparallel.util:index) (quote lparallel.kernel::worker))
lparallel.spin-queue:spin-queue
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::tasks) (quote lparallel.kernel::worker))
Information common to all workers. See ‘make-kernel’.
structure-object.
list
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::bindings) (quote lparallel.kernel::worker-info))
function
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::context) (quote lparallel.kernel::worker-info))
string
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::name) (quote lparallel.kernel::worker-info))
Communication with workers. A handshake takes place when a worker is created in order to verify its existence and to ensure all data is initialized. A worker sends a notification just before it exits.
structure-object.
(lparallel.queue:make-queue)
(lparallel.queue:make-queue)
(lparallel.queue:make-queue)
This is a container for transferring an error that occurs inside ‘call-with-task-handler’ to the calling thread.
structure-object.
condition
(error "slot ~a in ~a not initialized" (quote lparallel.kernel::value) (quote lparallel.kernel::wrapped-error))
| Jump to: | %
(
A B C D E F G H I K L M N P Q R S T U V W Z |
|---|
| Jump to: | %
(
A B C D E F G H I K L M N P Q R S T U V W Z |
|---|
| Jump to: | *
+
A B C D E F H I K L N O P Q R S T U V W |
|---|
| Jump to: | *
+
A B C D E F H I K L N O P Q R S T U V W |
|---|
| Jump to: | %
B C D F H I K L M N O P Q R S T U V W |
|---|
| Jump to: | %
B C D F H I K L M N O P Q R S T U V W |
|---|