The lparallel Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The lparallel Reference Manual

This is the lparallel Reference Manual, version 2.8.4, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 05:15:12 2022 GMT+0.

Table of Contents


1 Introduction

lparallel

lparallel is a library for parallel programming in Common Lisp, featuring

See http://lparallel.org for documentation and examples.

Running

lparallel should run on any Common Lisp implementation supported by bordeaux-threads. The following implementations successfully pass the test suite:

To run tests, load lparallel-test.asd and call (lparallel-test:execute).

To run benchmarks, load lparallel-bench.asd and call (lparallel-bench:execute N) where N is the number of worker threads.

Author

James M. Lawrence llmjjmll@gmail.com


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 lparallel

Parallelism for Common Lisp

Author

James M. Lawrence <llmjjmll@gmail.com>

License

BSD

Long Description

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.

Version

2.8.4

Dependencies
  • alexandria (system).
  • bordeaux-threads (system).
Source

lparallel.asd.

Child Component

src (module).


3 Modules

Modules are listed depth-first from the system components tree.


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 lparallel/src

Source

lparallel.asd.

Parent Component

lparallel (system).

Child Components

3.2 lparallel/src/util

Source

lparallel.asd.

Parent Component

src (module).

Child Components

3.3 lparallel/src/spin-queue

Dependency

counter.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Child Components

3.4 lparallel/src/kernel

Dependency

spin-queue (module).

Source

lparallel.asd.

Parent Component

src (module).

Child Components

3.5 lparallel/src/cognate

Dependency

defpun.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Child Components

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


4.1.1 lparallel/lparallel.asd

Source

lparallel.asd.

Parent Component

lparallel (system).

ASDF Systems

lparallel.


4.1.2 lparallel/src/util/package.lisp

Source

lparallel.asd.

Parent Component

util (module).

Packages

lparallel.util.


4.1.3 lparallel/src/util/config.lisp

Dependency

package.lisp (file).

Source

lparallel.asd.

Parent Component

util (module).

Public Interface

4.1.4 lparallel/src/util/misc.lisp

Dependency

config.lisp (file).

Source

lparallel.asd.

Parent Component

util (module).

Public Interface
Internals

4.1.5 lparallel/src/util/defmacro.lisp

Dependency

misc.lisp (file).

Source

lparallel.asd.

Parent Component

util (module).

Public Interface

defmacro/once (macro).


4.1.6 lparallel/src/util/defun.lisp

Dependency

defmacro.lisp (file).

Source

lparallel.asd.

Parent Component

util (module).

Public Interface
Internals

constrain-return-type (function).


4.1.7 lparallel/src/util/defslots.lisp

Dependency

defun.lisp (file).

Source

lparallel.asd.

Parent Component

util (module).

Public Interface

defslots (macro).

Internals

4.1.8 lparallel/src/util/defpair.lisp

Dependency

defslots.lisp (file).

Source

lparallel.asd.

Parent Component

util (module).

Public Interface

defpair (macro).


4.1.9 lparallel/src/thread-util.lisp

Dependency

util (module).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.thread-util.

Public Interface
Internals

4.1.10 lparallel/src/raw-queue.lisp

Dependency

thread-util.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.raw-queue.

Public Interface
Internals

4.1.11 lparallel/src/cons-queue.lisp

Dependency

raw-queue.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.cons-queue.

Public Interface
Internals

4.1.12 lparallel/src/vector-queue.lisp

Dependency

cons-queue.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.vector-queue.

Public Interface
Internals

4.1.13 lparallel/src/queue.lisp

Dependency

vector-queue.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.queue.

Public Interface
Internals

4.1.14 lparallel/src/counter.lisp

Dependency

queue.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.counter.

Public Interface
Internals

4.1.15 lparallel/src/spin-queue/package.lisp

Source

lparallel.asd.

Parent Component

spin-queue (module).

Packages

lparallel.spin-queue.


4.1.16 lparallel/src/spin-queue/cas-spin-queue.lisp

Dependency

package.lisp (file).

Source

lparallel.asd.

Parent Component

spin-queue (module).

Public Interface
Internals

4.1.17 lparallel/src/kernel/package.lisp

Source

lparallel.asd.

Parent Component

kernel (module).

Packages

lparallel.kernel.


4.1.18 lparallel/src/kernel/specials.lisp

Dependency

package.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Public Interface
Internals

4.1.19 lparallel/src/kernel/handling.lisp

Dependency

specials.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Public Interface
Internals

4.1.20 lparallel/src/kernel/classes.lisp

Dependency

handling.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Public Interface
Internals

4.1.21 lparallel/src/kernel/stealing-scheduler.lisp

Dependency

classes.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Internals

4.1.22 lparallel/src/kernel/kill.lisp

Dependency

stealing-scheduler.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Public Interface

kill-tasks (function).

Internals

4.1.23 lparallel/src/kernel/core.lisp

Dependency

kill.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Public Interface
Internals

4.1.24 lparallel/src/kernel/timeout.lisp

Dependency

core.lisp (file).

Source

lparallel.asd.

Parent Component

kernel (module).

Public Interface
Internals

4.1.25 lparallel/src/kernel-util.lisp

Dependency

kernel (module).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.kernel-util.

Public Interface
Internals

4.1.26 lparallel/src/promise.lisp

Dependency

kernel-util.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.promise.

Public Interface
Internals

4.1.27 lparallel/src/ptree.lisp

Dependency

promise.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.ptree.

Public Interface
Internals

4.1.28 lparallel/src/slet.lisp

Dependency

ptree.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.slet.

Public Interface

slet (macro).

Internals

4.1.29 lparallel/src/defpun.lisp

Dependency

slet.lisp (file).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.defpun.

Public Interface
Internals

4.1.30 lparallel/src/cognate/package.lisp

Source

lparallel.asd.

Parent Component

cognate (module).

Packages

lparallel.cognate.


4.1.31 lparallel/src/cognate/util.lisp

Dependency

package.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Internals

4.1.32 lparallel/src/cognate/option.lisp

Dependency

util.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Internals

4.1.33 lparallel/src/cognate/subdivide.lisp

Dependency

option.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Internals

4.1.34 lparallel/src/cognate/pandor.lisp

Dependency

subdivide.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

with-forms-submitted (macro).


4.1.35 lparallel/src/cognate/plet.lisp

Dependency

pandor.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

4.1.36 lparallel/src/cognate/pmap.lisp

Dependency

plet.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

4.1.37 lparallel/src/cognate/pmap-open-coded.lisp

Dependency

pmap.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

4.1.38 lparallel/src/cognate/pdotimes.lisp

Dependency

pmap-open-coded.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface

pdotimes (macro).

Internals

%pdotimes (function).


4.1.39 lparallel/src/cognate/pquantifier.lisp

Dependency

pdotimes.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

pquantifier (function).


4.1.40 lparallel/src/cognate/preduce.lisp

Dependency

pquantifier.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

4.1.41 lparallel/src/cognate/premove.lisp

Dependency

preduce.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

premove-if-not/list (function).


4.1.42 lparallel/src/cognate/pfind.lisp

Dependency

premove.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

4.1.43 lparallel/src/cognate/pcount.lisp

Dependency

pfind.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface

4.1.44 lparallel/src/cognate/psort.lisp

Dependency

pcount.lisp (file).

Source

lparallel.asd.

Parent Component

cognate (module).

Public Interface
Internals

4.1.45 lparallel/src/package.lisp

Dependency

cognate (module).

Source

lparallel.asd.

Parent Component

src (module).

Packages

lparallel.


5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 lparallel.vector-queue

(private) Blocking fixed-capacity queue.

Source

vector-queue.lisp.

Use List
Used By List

lparallel.queue.

Public Interface
Internals

5.2 lparallel.thread-util

(private) Thread utilities.

Source

thread-util.lisp.

Use List
Used By List
Public Interface
Internals

5.3 lparallel.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.

Source

package.lisp.

Use List
Used By List
Public Interface
Internals

5.4 lparallel.counter

(private) Atomic counter.

Source

counter.lisp.

Use List
Used By List

lparallel.kernel.

Public Interface
Internals

5.5 lparallel.cons-queue

(private) Blocking infinite-capacity queue.

Source

cons-queue.lisp.

Use List
Used By List

lparallel.queue.

Public Interface
Internals

5.6 lparallel.kernel-util

(semi-private) Abstracts some common patterns for submitting and receiving tasks. This probably won’t change, but no guarantees.

Source

kernel-util.lisp.

Use List
Used By List

lparallel.cognate.

Public Interface
Internals

5.7 lparallel.spin-queue

(private) Thread-safe FIFO queue which spins instead of locks.

Source

package.lisp.

Use List
Used By List

lparallel.kernel.

Public Interface
Internals

5.8 lparallel.slet

(private) Serial let.

Source

slet.lisp.

Use List
Used By List
Public Interface

slet (macro).

Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.9 lparallel.cognate

Parallelized versions of some Common Lisp functions.

Source

package.lisp.

Use List
Used By List

lparallel.

Public Interface
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.10 lparallel.defpun

Fine-grained parallelism.

Source

defpun.lisp.

Use List
Used By List
Public Interface
Internals

5.11 lparallel

This is a convenience package which exports the external symbols of: lparallel.kernel
lparallel.promise
lparallel.defpun
lparallel.cognate
lparallel.ptree

Source

package.lisp.

Use List

Next: , Previous: , Up: Packages   [Contents][Index]

5.12 lparallel.raw-queue

(private) Raw queue data structure.

Source

raw-queue.lisp.

Use List
Used By List

lparallel.cons-queue.

Public Interface
Internals

5.13 lparallel.queue

Blocking FIFO queue for communication between threads.

Source

queue.lisp.

Use List
Used By List
Public Interface
Internals

Next: , Previous: , Up: Packages   [Contents][Index]

5.14 lparallel.promise

Promises and futures.

Source

promise.lisp.

Use List
Used By List
Public Interface
Internals

5.15 lparallel.ptree

A ptree is a computation represented by a tree together with functionality to execute the tree in parallel.

Source

ptree.lisp.

Use List
Used By List

lparallel.

Public Interface
Internals

Previous: , Up: Packages   [Contents][Index]

5.16 lparallel.util

(private) Miscellaneous utilities.

Source

package.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.1 Special variables

Special Variable: *debug-tasks-p*

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)) ...)

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *full-optimize*
Package

lparallel.util.

Source

config.lisp.

Special Variable: *kernel*

The current kernel, or nil.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *kernel-spin-count*

Default value of the ‘spin-count’ argument to ‘make-kernel’.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *normal-optimize*
Package

lparallel.util.

Source

config.lisp.

Special Variable: *ptree-node-kernel*

When non-nil, ‘*kernel*’ is bound to this value during the call of a node function.

Package

lparallel.ptree.

Source

ptree.lisp.

Special Variable: *task-category*

See ‘kill-tasks’. Default value is ‘:default’.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *task-priority*

When bound to ‘:low’, the kernel schedules submitted tasks at low priority. Default value is ‘:default’.

Package

lparallel.kernel.

Source

specials.lisp.


6.1.2 Macros

Macro: alias-function (alias orig)
Package

lparallel.util.

Source

misc.lisp.

Macro: alias-macro (alias orig)
Package

lparallel.util.

Source

misc.lisp.

Macro: cas (place old new)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: declaim-defpun (&rest names)

See ‘defpun’.

Package

lparallel.defpun.

Source

defpun.lisp.

Macro: defmacro/once (name params &body body)

Like ‘defmacro’ except that params which are immediately preceded by ‘&once’ are passed to a ‘once-only’ call which surrounds ‘body’.

Package

lparallel.util.

Source

defmacro.lisp.

Macro: defpair (name supers (a b) &optional doc)

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.

Package

lparallel.util.

Source

defpair.lisp.

Macro: defpun (name lambda-list &body body)

‘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)

Package

lparallel.defpun.

Source

defpun.lisp.

Macro: defpun* (&rest args)

Deprecated. Instead use ‘defpun’ and pass ‘:use-caller t’ to ‘make-kernel’.

Package

lparallel.defpun.

Source

defpun.lisp.

Macro: defpun/type (name lambda-list arg-types return-type &body body)

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.)

Package

lparallel.defpun.

Source

defpun.lisp.

Macro: defpun/type* (&rest args)

Deprecated. Instead use ‘defpun/type’ and pass ‘:use-caller t’ to ‘make-kernel’.

Package

lparallel.defpun.

Source

defpun.lisp.

Macro: defslots (name supers slots &rest options)

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.

Package

lparallel.util.

Source

defslots.lisp.

Macro: defun/inline (name lambda-list &body body)

Shortcut for
(declaim (inline foo)) (defun foo ...).

Package

lparallel.util.

Source

defun.lisp.

Macro: defun/type (name lambda-list arg-types return-type &body body)

Shortcut for
(declaim (ftype (function arg-types return-type) foo)
(defun foo ...).
Additionally constrains return-type to the number of values provided.

Package

lparallel.util.

Source

defun.lisp.

Macro: defun/type/inline (name lambda-list arg-types return-type &body body)
Package

lparallel.util.

Source

defun.lisp.

Macro: delay (&body body)

Create a delay. A delay is a promise which is fulfilled when ‘force’ is called upon it.

Package

lparallel.promise.

Source

promise.lisp.

Macro: do-fast-receives ((result channel count) &body body)

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.

Package

lparallel.kernel.

Source

core.lisp.

Macro: dosequence ((var sequence &optional return) &body body)
Package

lparallel.util.

Source

misc.lisp.

Macro: fulfill (object &body body)

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.

Package

lparallel.promise.

Source

promise.lisp.

Macro: future (&body body)

Create a future. A future is a promise which is fulfilled in parallel by the implicit progn ‘body’.

Package

lparallel.promise.

Source

promise.lisp.

Macro: pand (&rest forms)

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.

Package

lparallel.cognate.

Source

pandor.lisp.

Macro: pdotimes ((var count &optional result parts) &body body)

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.

Package

lparallel.cognate.

Source

pdotimes.lisp.

Macro: pfuncall (function &rest args)

Parallel version of ‘funcall’. Arguments in ‘args’ may be executed in parallel, though not necessarily at the same time.

Package

lparallel.cognate.

Source

plet.lisp.

Macro: plet (bindings &body body)

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’.

Package

lparallel.defpun.

Source

plet.lisp.

Macro: plet-if (predicate bindings &body body)

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’.

Package

lparallel.defpun.

Source

plet.lisp.

Macro: por (&rest forms)

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.

Package

lparallel.cognate.

Source

pandor.lisp.

Macro: ptree (defs &body body)

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.

Package

lparallel.ptree.

Source

ptree.lisp.

Macro: repeat (n &body body)
Package

lparallel.util.

Source

misc.lisp.

Macro: slet (bindings &body body)

‘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.

Package

lparallel.slet.

Source

slet.lisp.

Macro: speculate (&body body)

Create a speculation. A speculation is a low-priority future.

Package

lparallel.promise.

Source

promise.lisp.

Macro: task-handler-bind (clauses &body body)

Like ‘handler-bind’ but handles conditions signaled inside tasks that were created in ‘body’.

Package

lparallel.kernel.

Source

handling.lisp.

Macro: unwind-protect/ext (&key prepare main cleanup abort)

Extended ‘unwind-protect’.

‘prepare’ : executed first, outside of ‘unwind-protect’ ‘main’ : protected form
‘cleanup’ : cleanup form
‘abort’ : executed if ‘main’ does not finish

Package

lparallel.util.

Source

misc.lisp.

Macro: with-lock-predicate/no-wait (lock predicate &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: with-lock-predicate/wait (lock predicate &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: with-locked-cons-queue (queue &body body)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Macro: with-locked-queue (queue &body body)

Execute ‘body’ with the queue lock held. Use the ‘/no-lock’ functions inside ‘body’.

Package

lparallel.queue.

Source

queue.lisp.

Macro: with-locked-vector-queue (queue &body body)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Macro: with-parsed-body ((body declares &optional docstring) &body own-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.

Package

lparallel.util.

Source

misc.lisp.

Macro: with-spin-lock-held (((access container)) &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: with-submit-cancelable (&body body)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Macro: with-submit-counted (&body body)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Macro: with-submit-indexed (count array &body body)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Macro: with-temp-kernel ((&rest make-kernel-args) &body body)

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.

Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Macro: with-thread ((&key bindings name) &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.


6.1.3 Compiler macros

Compiler Macro: cancel-timeout (&rest args)
Package

lparallel.kernel.

Source

timeout.lisp.

Compiler Macro: condition-notify (&rest args)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Compiler Macro: condition-wait (&rest args)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Compiler Macro: make-channel (&rest args)
Package

lparallel.kernel.

Source

core.lisp.

Compiler Macro: make-queue (&rest args)
Package

lparallel.queue.

Source

queue.lisp.

Compiler Macro: partial-apply (&rest args)
Package

lparallel.util.

Source

misc.lisp.

Compiler Macro: pmap (result-type function &rest args)

Open-coding for 1 vector mapped to vector.

Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Compiler Macro: pmap-into (result-sequence function &rest args)

Open-coding for 1 vector mapped to vector.

Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Compiler Macro: psort* (&rest args)
Package

lparallel.cognate.

Source

psort.lisp.

Compiler Macro: submit-timeout (&rest args)
Package

lparallel.kernel.

Source

timeout.lisp.


6.1.4 Ordinary functions

Function: broadcast-task (function &rest args)

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.

Package

lparallel.kernel.

Source

core.lisp.

Function: call-ptree (id ptree)

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.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: cancel-timeout (timeout timeout-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’.

Package

lparallel.kernel.

Source

timeout.lisp.

Function: chain (object)

Create a chain. A chain links objects together by relaying ‘force’ and ‘fulfilledp’ calls.

Package

lparallel.promise.

Source

promise.lisp.

Function: check-kernel ()

Ensures the value of ‘*kernel*’ is a kernel instance. Provides the MAKE-KERNEL and STORE-VALUE restarts. Returns ‘*kernel*’.

Package

lparallel.kernel.

Source

core.lisp.

Function: check-ptree (ptree)

Verify that all nodes have been defined with an associated function. If not, ‘ptree-undefined-function-error’ is signaled.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: clear-ptree (ptree)

Clear all node results in ‘ptree’, restoring the tree to its uncomputed state.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: clear-ptree-errors (ptree)

Clear all error results in ‘ptree’, allowing the computation to resume from its latest pre-error state.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: condition-notify (condition-variable)

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.

Package

lparallel.thread-util.

Alias for

condition-notify.

Function: condition-wait (condition-variable lock &key timeout)

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 system always reacquires LOCK before returning to the caller. In this case T is returned.

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 lock is no longer held and that the timeout has expired. A return of T indicates that the lock is held, in which case the timeout may or may not have expired.

**NOTE**: The behavior of CONDITION-WAIT with TIMEOUT diverges from the POSIX function pthread_cond_timedwait. The former may return without the lock being held while the latter always returns with the lock held.

In an implementation that does not support multiple threads, this function signals an error.

Package

lparallel.thread-util.

Alias for

condition-wait.

Function: cons-queue-count ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: cons-queue-count/no-lock ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: cons-queue-empty-p ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: cons-queue-empty-p/no-lock ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Reader: counter-value (instance)
Writer: (setf counter-value) (instance)
Package

lparallel.counter.

Source

counter.lisp.

Target Slot

value.

Function: dec-counter (counter)
Package

lparallel.counter.

Source

counter.lisp.

Function: end-kernel (&key 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.

Package

lparallel.kernel.

Source

core.lisp.

Function: force (object)

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’.

Package

lparallel.promise.

Source

promise.lisp.

Function: fulfilledp (object)

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.

Package

lparallel.promise.

Source

promise.lisp.

Function: inc-counter (counter)
Package

lparallel.counter.

Source

counter.lisp.

Function: interact (&rest prompt)

Read from user and eval.

Package

lparallel.util.

Source

misc.lisp.

Function: invoke-transfer-error (error)

Equivalent to (invoke-restart ’transfer-error error).

This is a convenience function for use in ‘task-handler-bind’.

Package

lparallel.kernel.

Source

handling.lisp.

Function: kernel-bindings ()

Return the bindings passed to ‘make-kernel’.

Package

lparallel.kernel.

Source

core.lisp.

Function: kernel-context ()

Return the context passed to ‘make-kernel’.

Package

lparallel.kernel.

Source

core.lisp.

Function: kernel-name ()

Return the name passed to ‘make-kernel’.

Package

lparallel.kernel.

Source

core.lisp.

Function: kernel-worker-count ()

Return the number of workers in the current kernel.

Package

lparallel.kernel.

Source

core.lisp.

Function: kernel-worker-index ()

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.

Package

lparallel.kernel.

Source

core.lisp.

Function: kill-tasks (task-category &key dry-run)

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.

Package

lparallel.kernel.

Source

kill.lisp.

Function: make-channel (&rest args)

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.

Package

lparallel.kernel.

Source

core.lisp.

Function: make-cons-queue (&key initial-contents)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: make-counter (&optional value)
Package

lparallel.counter.

Source

counter.lisp.

Function: make-kernel (worker-count &key name bindings context spin-count use-caller)

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.

Package

lparallel.kernel.

Source

core.lisp.

Function: make-ptree ()

Create a ptree instance.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: make-queue (&rest args)

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.

Package

lparallel.queue.

Source

queue.lisp.

Function: make-raw-queue (&optional initial-capacity)
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: make-spin-lock ()
Package

lparallel.thread-util.

Source

thread-util.lisp.

Function: make-spin-queue ()
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: make-vector-queue (capacity &key initial-contents)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: partial-apply (function &rest arguments)

Returns a function that applies ARGUMENTS and the arguments it is called with to FUNCTION.

Package

lparallel.util.

Alias for

curry.

Function: pcount (item sequence &key from-end start end key test test-not parts)

Parallel version of ‘count’.

The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).

Package

lparallel.cognate.

Source

pcount.lisp.

Function: pcount-if (predicate sequence &key from-end start end key parts)

Parallel version of ‘count-if’.

The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).

Package

lparallel.cognate.

Source

pcount.lisp.

Function: pcount-if-not (predicate sequence &rest args &key from-end start end key parts)

Parallel version of ‘count-if-not’.

The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).

Package

lparallel.cognate.

Source

pcount.lisp.

Function: peek-cons-queue ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: peek-cons-queue/no-lock ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: peek-queue (queue)

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).

Package

lparallel.queue.

Source

queue.lisp.

Function: peek-queue/no-lock (queue)

Like ‘peek-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: peek-raw-queue (queue)
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: peek-spin-queue (queue)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: peek-vector-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: peek-vector-queue/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: pevery (predicate &rest sequences)

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’).

Package

lparallel.cognate.

Source

pquantifier.lisp.

Function: pfind (item sequence &rest args &key from-end test test-not start end key parts)

Parallel version of ‘pfind’.

The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).

Package

lparallel.cognate.

Source

pfind.lisp.

Function: pfind-if (predicate sequence &rest args &key from-end start end key parts)

Parallel version of ‘pfind-if’.

The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).

Package

lparallel.cognate.

Source

pfind.lisp.

Function: pfind-if-not (predicate sequence &rest args &key from-end start end key parts)

Parallel version of ‘pfind-if-not’.

The ‘parts’ option divides ‘sequence’ into ‘parts’ number of parts. Default is (kernel-worker-count).

Package

lparallel.cognate.

Source

pfind.lisp.

Function: pmap (result-type function &rest sequences)

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.

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-into (result-sequence function &rest sequences)

Parallel version of ‘map-into’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-reduce (map-function reduce-function sequence &rest args &key start end initial-value parts recurse)

Equivalent to (preduce reduce-function sequence :key map-function ...).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmapc (function &rest lists)

Parallel version of ‘mapc’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmapcan (function &rest lists)

Parallel version of ‘mapcan’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmapcar (function &rest sequences)

Parallel version of ‘mapcar’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Unlike ‘mapcar’, ‘pmapcar’ also accepts vectors.

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmapcon (function &rest lists)

Parallel version of ‘mapcon’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmapl (function &rest lists)

Parallel version of ‘mapl’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmaplist (function &rest lists)

Parallel version of ‘maplist’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmaplist-into (result-list function &rest lists)

Like ‘pmaplist’ but results are stored in ‘result-list’. Keyword arguments ‘parts’ and ‘size’ are also accepted (see ‘pmap’).

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pnotany (predicate &rest sequences)

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’).

Package

lparallel.cognate.

Source

pquantifier.lisp.

Function: pnotevery (predicate &rest sequences)

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’).

Package

lparallel.cognate.

Source

pquantifier.lisp.

Function: pop-cons-queue ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: pop-cons-queue/no-lock ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: pop-queue (queue)

Remove the frontmost element from ‘queue’ and return it.

If ‘queue’ is empty, block until an element is available.

Package

lparallel.queue.

Source

queue.lisp.

Function: pop-queue/no-lock (queue)

Like ‘pop-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: pop-raw-queue ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: pop-spin-queue ()
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: pop-vector-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: pop-vector-queue/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: preduce (function sequence &rest args &key key from-end start end initial-value parts recurse)

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".

Package

lparallel.cognate.

Source

preduce.lisp.

Function: preduce-partial (function sequence &rest args &key key from-end start end initial-value parts)

Like ‘preduce’ but only does a single reducing pass.

The length of ‘sequence’ must not be zero.

Returns the partial results as a vector.

Package

lparallel.cognate.

Source

preduce.lisp.

Function: premove (item sequence &rest args &key test test-not from-end start end key parts)

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).

Package

lparallel.cognate.

Source

premove.lisp.

Function: premove-if (test sequence &rest args &key from-end start end key parts)

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).

Package

lparallel.cognate.

Source

premove.lisp.

Function: premove-if-not (test sequence &rest args &key from-end start end key parts)

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).

Package

lparallel.cognate.

Source

premove.lisp.

Function: promise ()

Create a promise. A promise is a receptacle for a result which is unknown at the time it is created.

Package

lparallel.promise.

Source

promise.lisp.

Function: psome (predicate &rest sequences)

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’).

Package

lparallel.cognate.

Source

pquantifier.lisp.

Function: psort (sequence predicate &key key granularity &allow-other-keys)

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’.

Package

lparallel.cognate.

Source

psort.lisp.

Function: psort* (&rest args)

Deprecated. Instead use ‘psort’ and pass ‘:use-caller t’ to ‘make-kernel’.

Package

lparallel.cognate.

Source

psort.lisp.

Function: ptree-computed-p (id ptree)

Return true if the node with identifier ‘id’ in ‘ptree’ has finished computing, otherwise return false.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: ptree-fn (id args function ptree)

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.

Package

lparallel.ptree.

Source

ptree.lisp.

Function: push-cons-queue ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: push-cons-queue/no-lock ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: push-queue (object queue)

Push ‘object’ onto the back of ‘queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: push-queue/no-lock (object queue)

Like ‘push-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: push-raw-queue ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: push-spin-queue ()
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: push-vector-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: push-vector-queue/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: queue-count (queue)

Return the number of elements in ‘queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: queue-count/no-lock (queue)

Like ‘queue-count’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: queue-empty-p (queue)

Return true if ‘queue’ is empty, otherwise return false.

Package

lparallel.queue.

Source

queue.lisp.

Function: queue-empty-p/no-lock (queue)

Like ‘queue-empty-p’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: queue-full-p (queue)

Return true if ‘queue’ is full, otherwise return false.

Package

lparallel.queue.

Source

queue.lisp.

Function: queue-full-p/no-lock (queue)

Like ‘queue-full-p’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: raw-queue-count (queue)
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: raw-queue-empty-p (queue)
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: receive-result (channel)

Remove a result from ‘channel’. If nothing is available the call will block until a result is received.

Package

lparallel.kernel.

Source

core.lisp.

Function: spin-queue-count (queue)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: spin-queue-empty-p (queue)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: submit-task (channel function &rest args)

Submit a task through ‘channel’ to the kernel stored in ‘channel’.

Package

lparallel.kernel.

Source

core.lisp.

Function: submit-timeout (channel timeout-seconds timeout-result)

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’.

Package

lparallel.kernel.

Source

timeout.lisp.

Function: task-categories-running ()

Return a vector containing the task category currently running for each worker.

Package

lparallel.kernel.

Source

core.lisp.

Function: to-boolean (x)
Package

lparallel.util.

Source

misc.lisp.

Function: try-pop-cons-queue ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: try-pop-cons-queue/no-lock ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: try-pop-queue (queue &key timeout)

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.

Package

lparallel.queue.

Source

queue.lisp.

Function: try-pop-queue/no-lock (queue &key timeout)

Like ‘try-pop-queue’ but does not acquire the lock. Use inside ‘with-locked-queue’.

Package

lparallel.queue.

Source

queue.lisp.

Function: try-pop-vector-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: try-pop-vector-queue/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: try-receive-result (channel &key timeout)

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.

Package

lparallel.kernel.

Source

core.lisp.

Function: unsplice (form)
Package

lparallel.util.

Source

misc.lisp.

Function: vector-queue-capacity ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-count ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-count/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-empty-p ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-empty-p/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-full-p ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-full-p/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.


6.1.5 Standalone methods

Method: print-object ((kernel kernel) stream)
Source

core.lisp.


6.1.6 Conditions

Condition: kernel-creation-error

Error signaled when ‘make-kernel’ fails.

Package

lparallel.kernel.

Source

handling.lisp.

Direct superclasses

error.

Condition: no-kernel-error

Error signaled when ‘*kernel*’ is nil.

Package

lparallel.kernel.

Source

handling.lisp.

Direct superclasses

error.

Condition: ptree-lambda-list-keyword-error

Lambda list keywords found in function definition.

Package

lparallel.ptree.

Source

ptree.lisp.

Direct superclasses

ptree-error.

Direct methods

ptree-error-llks.

Direct slots
Slot: llks
Initargs

:llks

Readers

ptree-error-llks.

Writers

This slot is read-only.

Condition: ptree-redefinition-error

Attempted to redefine a node’s function.

Package

lparallel.ptree.

Source

ptree.lisp.

Direct superclasses

ptree-error.

Condition: ptree-undefined-function-error

Attempted to execute a node which had no function.

Package

lparallel.ptree.

Source

ptree.lisp.

Direct superclasses

ptree-error.

Direct methods

ptree-error-refs.

Direct slots
Slot: refs
Initform

(quote nil)

Initargs

:refs

Readers

ptree-error-refs.

Writers

This slot is read-only.

Condition: task-killed-error

Error signaled when attempting to obtain the result of a killed task.

Package

lparallel.kernel.

Source

handling.lisp.

Direct superclasses

error.


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.7 Structures

Structure: channel

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.

Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: queue
Package

lparallel.queue.

Type

lparallel.queue:queue

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.queue:queue) (quote lparallel.kernel:channel))

Readers

%%%%.channel.queue.

Writers

(setf %%%%.channel.queue).

Slot: kernel
Type

lparallel.kernel:kernel

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel:kernel) (quote lparallel.kernel:channel))

Readers

%%%%.channel.kernel.

Writers

(setf %%%%.channel.kernel).

Structure: cons-queue
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: impl
Type

lparallel.raw-queue:raw-queue

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.cons-queue::impl) (quote lparallel.cons-queue:cons-queue))

Readers

%%%%.cons-queue.impl.

Writers

(setf %%%%.cons-queue.impl).

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.cons-queue.lock.

Writers

(setf %%%%.cons-queue.lock).

Slot: cvar
Readers

%%%%.cons-queue.cvar.

Writers

(setf %%%%.cons-queue.cvar).

Structure: counter
Package

lparallel.counter.

Source

counter.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: value
Type

lparallel.counter:counter-value

Initform

0

Readers

counter-value.

Writers

(setf counter-value).

Structure: kernel

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.

Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

limiter.

Direct methods

print-object.

Direct slots
Slot: scheduler
Type

lparallel.kernel::scheduler

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::scheduler) (quote lparallel.kernel:kernel))

Readers

%%%%.kernel.scheduler.

Writers

(setf %%%%.kernel.scheduler).

Slot: workers
Type

simple-vector

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::workers) (quote lparallel.kernel:kernel))

Readers

%%%%.kernel.workers.

Writers

(setf %%%%.kernel.workers).

Slot: workers-lock
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::workers-lock) (quote lparallel.kernel:kernel))

Readers

%%%%.kernel.workers-lock.

Writers

(setf %%%%.kernel.workers-lock).

Slot: worker-info
Type

lparallel.kernel::worker-info

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::worker-info) (quote lparallel.kernel:kernel))

Readers

%%%%.kernel.worker-info.

Writers

(setf %%%%.kernel.worker-info).

Slot: use-caller-p
Type

boolean

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::use-caller-p) (quote lparallel.kernel:kernel))

Readers

%%%%.kernel.use-caller-p.

Writers

(setf %%%%.kernel.use-caller-p).

Slot: alivep
Type

boolean

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::alivep) (quote lparallel.kernel:kernel))

Readers

%%%%.kernel.alivep.

Writers

(setf %%%%.kernel.alivep).

Structure: ptree

A ptree is a computation represented by a tree together with functionality to execute the tree in parallel.

Package

lparallel.ptree.

Source

ptree.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: nodes
Type

hash-table

Initform

(make-hash-table :test (function eql))

Readers

%%%%.ptree.nodes.

Writers

(setf %%%%.ptree.nodes).

Slot: queue
Package

lparallel.queue.

Type

lparallel.queue:queue

Initform

(lparallel.queue:make-queue)

Readers

%%%%.ptree.queue.

Writers

(setf %%%%.ptree.queue).

Slot: pending
Type

integer

Initform

0

Readers

%%%%.ptree.pending.

Writers

(setf %%%%.ptree.pending).

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.ptree.lock.

Writers

(setf %%%%.ptree.lock).

Structure: raw-queue
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: head
Type

list

Initform

(error "no head")

Readers

head.

Writers

(setf head).

Slot: tail
Type

list

Initform

(error "no tail")

Readers

tail.

Writers

(setf tail).

Structure: spin-queue
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: head
Type

lparallel.spin-queue::node

Initform

(error "no head")

Readers

spin-queue-head.

Writers

(setf spin-queue-head).

Slot: tail
Type

lparallel.spin-queue::node

Initform

(error "no tail")

Readers

spin-queue-tail.

Writers

(setf spin-queue-tail).

Structure: vector-queue
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: impl
Type

lparallel.vector-queue::raw-queue

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.vector-queue::impl) (quote lparallel.vector-queue:vector-queue))

Readers

%%%%.vector-queue.impl.

Writers

(setf %%%%.vector-queue.impl).

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.vector-queue.lock.

Writers

(setf %%%%.vector-queue.lock).

Slot: notify-push
Readers

%%%%.vector-queue.notify-push.

Writers

(setf %%%%.vector-queue.notify-push).

Slot: notify-pop
Readers

%%%%.vector-queue.notify-pop.

Writers

(setf %%%%.vector-queue.notify-pop).


Previous: , Up: Public Interface   [Contents][Index]

6.1.8 Types

Type: counter-value ()
Package

lparallel.counter.

Source

counter.lisp.

Type: index ()
Package

lparallel.util.

Source

misc.lisp.

Type: queue ()
Package

lparallel.queue.

Source

queue.lisp.

Type: raw-queue-count ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.


6.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.1 Constants

Constant: +checked-key+
Package

lparallel.defpun.

Source

defpun.lisp.

Constant: +current-task+
Package

lparallel.kernel.

Source

handling.lisp.

Constant: +dead-end+
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Constant: +dummy+
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Constant: +no-result+
Package

lparallel.defpun.

Source

defpun.lisp.

Constant: +no-result+
Package

lparallel.promise.

Source

promise.lisp.

Constant: +no-result+
Package

lparallel.ptree.

Source

ptree.lisp.

Constant: +unchecked-key+
Package

lparallel.defpun.

Source

defpun.lisp.

Constant: +worker-suicide-tag+
Package

lparallel.kernel.

Source

kill.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.2 Special variables

Special Variable: *client-handlers*

Records handlers established with ‘task-handler-bind’ in the calling thread.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *debugger-error*

Track the error inside the debugger for the ‘transfer-error’ restart.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *erroring-workers*

Track debugger popups in order to kill them.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *erroring-workers-lock*

Lock for *erroring-workers*.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *handler-active-p*

Non-nil when handlers have been established via ‘call-with-task-handler’.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *lisp-exiting-p*

True if the Lisp process is exiting; for skipping auto-replacement of killed workers during exit.

Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *make-limiter-data*
Package

lparallel.kernel.

Source

specials.lisp.

Special Variable: *registered-names*
Package

lparallel.defpun.

Source

defpun.lisp.

Special Variable: *registration-lock*
Package

lparallel.defpun.

Source

defpun.lisp.

Special Variable: *standard-declaration-identifiers*
Package

lparallel.cognate.

Source

plet.lisp.

Special Variable: *worker*

The worker instance if inside a worker thread, otherwise nil.

Package

lparallel.kernel.

Source

specials.lisp.


6.2.3 Macros

Macro: %%%%plet (kernel bindings body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: %%%plet (kernel predicate spawn-count bindings body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: %%plet (kernel predicate bindings body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: %defslots (name supers slots options)
Package

lparallel.util.

Source

defslots.lisp.

Macro: %plet (bindings body)
Package

lparallel.cognate.

Source

plet.lisp.

Macro: %plet (kernel bindings &body body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: %plet-if (kernel predicate bindings &body body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: %slet (binding-data full-binding-data null-bindings body)
Package

lparallel.slet.

Source

slet.lisp.

Macro: accept-task-p (kernel)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: bind ((vars form) &body body)
Package

lparallel.slet.

Source

slet.lisp.

Macro: check-symbols (&rest syms)
Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Macro: define-counter-fn (name op)
Package

lparallel.counter.

Source

counter.lisp.

Macro: define-defpun (defpun doc defun &rest types)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: define-locking-fn (name args arg-types return-type lock &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: define-locking-fn/base (name args arg-types return-type lock-reader defun/no-lock arg-types/no-lock return-type/no-lock &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: define-mod-inc-dec (name op op-result-type)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: define-mod-incf-decf (name op)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: define-queue-fn (name arg-types raw return-type)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Macro: define-queue-fn (name arg-types raw return-type)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Macro: define-queue-fn (name params cons-name vector-name)
Package

lparallel.queue.

Source

queue.lisp.

Macro: define-quicksort-fn (name call-key key key-type gran gran-type)
Package

lparallel.cognate.

Source

psort.lisp.

Macro: define-quicksort-fns ()
Package

lparallel.cognate.

Source

psort.lisp.

Macro: define-reader (public private type struct)
Package

lparallel.util.

Source

defslots.lisp.

Macro: define-readers (struct conc-name slots)
Package

lparallel.util.

Source

defslots.lisp.

Macro: define-simple-locking-fn (name args arg-types return-type lock &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: define-slots-macrolet (package conc-name entries instance &body body)
Package

lparallel.util.

Source

defslots.lisp.

Macro: define-struct (name supers slots options conc-name constructor)
Package

lparallel.util.

Source

defslots.lisp.

Macro: define-try-pop-queue (name cons-name vector-name)
Package

lparallel.queue.

Source

queue.lisp.

Macro: define-with-slots-macro (name package conc-name)
Package

lparallel.util.

Source

defslots.lisp.

Macro: define-worker-info-reader (name slot &optional result)
Package

lparallel.kernel.

Source

core.lisp.

Macro: defmacro/syms (name params &body body)

Like ‘defmacro’ but requires all parameters to be symbols.

Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Macro: defun/wrapper (wrapper-name impl-name lambda-list &body body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: do-indexes ((index-var size home-index from-home-index-p) &body body)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: do-workers ((worker-var workers home-index from-home-index-p) &body body)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: exec-task (here-binding-datum)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: map-into/vector/1-vector/range (dst fn src start end)
Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Macro: mod-dec (k n)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: mod-decf (place n)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: mod-inc (k n)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: mod-incf (place n)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: msetq (vars form)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: node-car (node)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Macro: node-cdr (node)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Macro: pmap-into/vector/1-vector (dst fn src size parts)
Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Macro: pop-plist (list)
Package

lparallel.cognate.

Source

option.lisp.

Macro: repeat/fixnum (count &body body)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: scan-for-errors (binding-data)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: spawn (kernel temp-vars form)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: spawn-tasks (kernel spawn-binding-data)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: sync (kernel spawn-binding-data)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: task-lambda (&body body)
Package

lparallel.kernel.

Source

core.lisp.

Macro: toplevel-plet (bindings &body body)

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’.

Package

lparallel.cognate.

Alias for

plet.

Macro: with-%chain-slots (slots instance &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-%delay-slots (slots instance &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-%future-slots (slots instance &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-%promise-slots (slots instance &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-abort-restart (&body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: with-binding-datum-slots (slots instance &body body)
Package

lparallel.cognate.

Source

plet.lisp.

Macro: with-channel-slots (slots instance &body body)
Package

lparallel.kernel.

Source

classes.lisp.

Macro: with-client-bindings (binding-data null-bindings &body body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: with-cons-queue-slots (slots instance &body body)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Macro: with-countdown ((time) &body body)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Macro: with-fill-workers-handler (workers &body body)
Package

lparallel.kernel.

Source

core.lisp.

Macro: with-forms-submitted (forms &body body)
Package

lparallel.cognate.

Source

pandor.lisp.

Macro: with-kernel-slots ()
Package

lparallel.kernel.

Source

classes.lisp.

Macro: with-lock-operation (operation promise &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-lock-predicates (&key lock predicate1 predicate2 succeed/lock succeed/no-lock fail)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: with-node-slots (slots instance &body body)
Package

lparallel.ptree.

Source

ptree.lisp.

Macro: with-parsed-options ((args size parts) &body body)
Package

lparallel.cognate.

Source

option.lisp.

Macro: with-parts (seq-size parts-hint &body body)
Package

lparallel.cognate.

Source

subdivide.lisp.

Macro: with-pfind-context (sequence start end parts &body body)
Package

lparallel.cognate.

Source

pfind.lisp.

Macro: with-plan-slots (slots instance &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-pop-success (var queue &body body)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Macro: with-preduce-context (size parts &body body)
Package

lparallel.cognate.

Source

preduce.lisp.

Macro: with-promise-base-slots (slots instance &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-ptree-slots (slots instance &body body)
Package

lparallel.ptree.

Source

ptree.lisp.

Macro: with-raw-queue-slots (slots instance &body body)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Macro: with-scheduler-slots (slots instance &body body)
Package

lparallel.kernel.

Source

classes.lisp.

Macro: with-task-context (&body body)
Package

lparallel.kernel.

Source

handling.lisp.

Macro: with-temp-bindings (here-binding-datum spawn-binding-data &body body)
Package

lparallel.defpun.

Source

defpun.lisp.

Macro: with-timeout-slots (slots instance &body body)
Package

lparallel.kernel.

Source

timeout.lisp.

Macro: with-tracked-error (condition &body body)
Package

lparallel.kernel.

Source

handling.lisp.

Macro: with-unfulfilled-future/no-wait (future &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-unfulfilled/no-wait (promise &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-unfulfilled/wait (promise &body body)
Package

lparallel.promise.

Source

promise.lisp.

Macro: with-vector-queue-slots (slots instance &body body)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Macro: with-worker-info-slots (slots instance &body body)
Package

lparallel.kernel.

Source

classes.lisp.

Macro: with-worker-notifications-slots (slots instance &body body)
Package

lparallel.kernel.

Source

classes.lisp.

Macro: with-worker-restarts (&body body)
Package

lparallel.kernel.

Source

kill.lisp.

Macro: with-worker-slots (slots instance &body body)
Package

lparallel.kernel.

Source

classes.lisp.

Macro: with-wrapped-error-slots (slots instance &body body)
Package

lparallel.kernel.

Source

handling.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.4 Compiler macros

Compiler Macro: alivep ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: binding-datum-vars (&rest args)
Package

lparallel.cognate.

Source

plet.lisp.

Compiler Macro: chain-object (&rest args)
Package

lparallel.promise.

Source

promise.lisp.

Compiler Macro: channel-kernel (&rest args)
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: channel-queue (&rest args)
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: data (&rest args)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Compiler Macro: id (&rest args)
Package

lparallel.ptree.

Source

ptree.lisp.

Compiler Macro: impl (&rest args)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Compiler Macro: impl (&rest args)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Compiler Macro: lock (&rest args)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Compiler Macro: lock (&rest args)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Compiler Macro: lock (&rest args)
Package

lparallel.ptree.

Source

ptree.lisp.

Compiler Macro: lock-level (&rest args)
Package

lparallel.ptree.

Source

ptree.lisp.

Compiler Macro: make-node (&rest args)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Compiler Macro: make-task-instance ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: nodes (&rest args)
Package

lparallel.ptree.

Source

ptree.lisp.

Compiler Macro: plan-fn (&rest args)
Package

lparallel.promise.

Source

promise.lisp.

Compiler Macro: raw-queue-count (&rest args)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Compiler Macro: result (&rest args)
Package

lparallel.promise.

Source

promise.lisp.

Compiler Macro: result (&rest args)
Package

lparallel.ptree.

Source

ptree.lisp.

Compiler Macro: running-category (&rest args)
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: scheduler ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: task-category ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: task-fn ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: tasks (&rest args)
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: thread (&rest args)
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: use-caller-p ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: worker-index (&rest args)
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: workers ()
Package

lparallel.kernel.

Source

classes.lisp.

Compiler Macro: wrapped-error-value (&rest args)
Package

lparallel.kernel.

Source

handling.lisp.


6.2.5 Ordinary functions

Reader: %%%%.%chain.object (instance)
Writer: (setf %%%%.%chain.object) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

object.

Function: %%%%.%delay.fn (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%delay.fn) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: %%%%.%delay.lock (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%delay.lock) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: %%%%.%delay.result (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%delay.result) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Reader: %%%%.%future.canceledp (instance)
Writer: (setf %%%%.%future.canceledp) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

canceledp.

Function: %%%%.%future.fn (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%future.fn) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: %%%%.%future.lock (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%future.lock) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: %%%%.%future.result (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%future.result) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Reader: %%%%.%promise.availablep (instance)
Writer: (setf %%%%.%promise.availablep) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

availablep.

Reader: %%%%.%promise.cvar (instance)
Writer: (setf %%%%.%promise.cvar) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

cvar.

Function: %%%%.%promise.lock (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%promise.lock) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: %%%%.%promise.result (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.%promise.result) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Reader: %%%%.binding-datum.form (instance)
Writer: (setf %%%%.binding-datum.form) (instance)
Package

lparallel.cognate.

Source

plet.lisp.

Target Slot

form.

Reader: %%%%.binding-datum.future-result (instance)
Writer: (setf %%%%.binding-datum.future-result) (instance)
Package

lparallel.cognate.

Source

plet.lisp.

Target Slot

future-result.

Reader: %%%%.binding-datum.future-var (instance)
Writer: (setf %%%%.binding-datum.future-var) (instance)
Package

lparallel.cognate.

Source

plet.lisp.

Target Slot

future-var.

Reader: %%%%.binding-datum.vars (instance)
Writer: (setf %%%%.binding-datum.vars) (instance)
Package

lparallel.cognate.

Source

plet.lisp.

Target Slot

vars.

Reader: %%%%.channel.kernel (instance)
Writer: (setf %%%%.channel.kernel) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

kernel.

Reader: %%%%.channel.queue (instance)
Writer: (setf %%%%.channel.queue) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

queue.

Reader: %%%%.cons-queue.cvar (instance)
Writer: (setf %%%%.cons-queue.cvar) (instance)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Target Slot

cvar.

Reader: %%%%.cons-queue.impl (instance)
Writer: (setf %%%%.cons-queue.impl) (instance)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Target Slot

impl.

Reader: %%%%.cons-queue.lock (instance)
Writer: (setf %%%%.cons-queue.lock) (instance)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Target Slot

lock.

Function: %%%%.defpun.quicksort/key/gran ()
Package

lparallel.cognate.

Source

psort.lisp.

Function: %%%%.defpun.quicksort/key/no-gran ()
Package

lparallel.cognate.

Source

psort.lisp.

Function: %%%%.defpun.quicksort/no-key/gran ()
Package

lparallel.cognate.

Source

psort.lisp.

Function: %%%%.defpun.quicksort/no-key/no-gran ()
Package

lparallel.cognate.

Source

psort.lisp.

Reader: %%%%.kernel.alivep ()
Writer: (setf %%%%.kernel.alivep) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

alivep.

Function: %%%%.kernel.limiter-accept-task-p ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: (setf %%%%.kernel.limiter-accept-task-p) ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: %%%%.kernel.limiter-count ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: (setf %%%%.kernel.limiter-count) ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: %%%%.kernel.limiter-lock ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: (setf %%%%.kernel.limiter-lock) ()
Package

lparallel.kernel.

Source

classes.lisp.

Reader: %%%%.kernel.scheduler ()
Writer: (setf %%%%.kernel.scheduler) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

scheduler.

Reader: %%%%.kernel.use-caller-p ()
Writer: (setf %%%%.kernel.use-caller-p) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

use-caller-p.

Reader: %%%%.kernel.worker-info ()
Writer: (setf %%%%.kernel.worker-info) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

worker-info.

Reader: %%%%.kernel.workers ()
Writer: (setf %%%%.kernel.workers) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

workers.

Reader: %%%%.kernel.workers-lock ()
Writer: (setf %%%%.kernel.workers-lock) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

workers-lock.

Reader: %%%%.node.children (instance)
Writer: (setf %%%%.node.children) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

children.

Reader: %%%%.node.children-done-p (instance)
Writer: (setf %%%%.node.children-done-p) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

children-done-p.

Reader: %%%%.node.function (instance)
Writer: (setf %%%%.node.function) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

function.

Reader: %%%%.node.id (instance)
Writer: (setf %%%%.node.id) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

id.

Reader: %%%%.node.lock-level (instance)
Writer: (setf %%%%.node.lock-level) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

lock-level.

Reader: %%%%.node.parents (instance)
Writer: (setf %%%%.node.parents) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

parents.

Reader: %%%%.node.result (instance)
Writer: (setf %%%%.node.result) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

result.

Reader: %%%%.plan.fn (instance)
Writer: (setf %%%%.plan.fn) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

fn.

Function: %%%%.plan.lock (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.plan.lock) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: %%%%.plan.result (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: (setf %%%%.plan.result) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Reader: %%%%.promise-base.lock (instance)
Writer: (setf %%%%.promise-base.lock) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

lock.

Reader: %%%%.promise-base.result (instance)
Writer: (setf %%%%.promise-base.result) (instance)
Package

lparallel.promise.

Source

promise.lisp.

Target Slot

result.

Reader: %%%%.ptree.lock (instance)
Writer: (setf %%%%.ptree.lock) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

lock.

Reader: %%%%.ptree.nodes (instance)
Writer: (setf %%%%.ptree.nodes) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

nodes.

Reader: %%%%.ptree.pending (instance)
Writer: (setf %%%%.ptree.pending) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

pending.

Reader: %%%%.ptree.queue (instance)
Writer: (setf %%%%.ptree.queue) (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Target Slot

queue.

Reader: %%%%.raw-queue.count (instance)
Writer: (setf %%%%.raw-queue.count) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

count.

Reader: %%%%.raw-queue.data (instance)
Writer: (setf %%%%.raw-queue.data) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

data.

Reader: %%%%.raw-queue.start (instance)
Writer: (setf %%%%.raw-queue.start) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

start.

Reader: %%%%.scheduler.low-priority-tasks (instance)
Writer: (setf %%%%.scheduler.low-priority-tasks) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

low-priority-tasks.

Reader: %%%%.scheduler.notify-count (instance)
Writer: (setf %%%%.scheduler.notify-count) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

notify-count.

Reader: %%%%.scheduler.random-index (instance)
Writer: (setf %%%%.scheduler.random-index) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

random-index.

Reader: %%%%.scheduler.spin-count (instance)
Writer: (setf %%%%.scheduler.spin-count) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

spin-count.

Reader: %%%%.scheduler.wait-count (instance)
Writer: (setf %%%%.scheduler.wait-count) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

wait-count.

Reader: %%%%.scheduler.wait-cvar (instance)
Writer: (setf %%%%.scheduler.wait-cvar) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

wait-cvar.

Reader: %%%%.scheduler.wait-lock (instance)
Writer: (setf %%%%.scheduler.wait-lock) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

wait-lock.

Reader: %%%%.scheduler.workers (instance)
Writer: (setf %%%%.scheduler.workers) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

workers.

Reader: %%%%.timeout.canceled-result (instance)
Writer: (setf %%%%.timeout.canceled-result) (instance)
Package

lparallel.kernel.

Source

timeout.lisp.

Target Slot

canceled-result.

Reader: %%%%.timeout.lock (instance)
Writer: (setf %%%%.timeout.lock) (instance)
Package

lparallel.kernel.

Source

timeout.lisp.

Target Slot

lock.

Reader: %%%%.timeout.thread (instance)
Writer: (setf %%%%.timeout.thread) (instance)
Package

lparallel.kernel.

Source

timeout.lisp.

Target Slot

thread.

Reader: %%%%.vector-queue.impl (instance)
Writer: (setf %%%%.vector-queue.impl) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

impl.

Reader: %%%%.vector-queue.lock (instance)
Writer: (setf %%%%.vector-queue.lock) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

lock.

Reader: %%%%.vector-queue.notify-pop (instance)
Writer: (setf %%%%.vector-queue.notify-pop) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

notify-pop.

Reader: %%%%.vector-queue.notify-push (instance)
Writer: (setf %%%%.vector-queue.notify-push) (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Target Slot

notify-push.

Reader: %%%%.worker-info.bindings (instance)
Writer: (setf %%%%.worker-info.bindings) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

bindings.

Reader: %%%%.worker-info.context (instance)
Writer: (setf %%%%.worker-info.context) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

context.

Reader: %%%%.worker-info.name (instance)
Writer: (setf %%%%.worker-info.name) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

name.

Reader: %%%%.worker-notifications.exit-notification (instance)
Writer: (setf %%%%.worker-notifications.exit-notification) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

exit-notification.

Reader: %%%%.worker-notifications.handshake/from-worker (instance)
Writer: (setf %%%%.worker-notifications.handshake/from-worker) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

handshake/from-worker.

Reader: %%%%.worker-notifications.handshake/to-worker (instance)
Writer: (setf %%%%.worker-notifications.handshake/to-worker) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

handshake/to-worker.

Function: %%%%.worker.exit-notification (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: (setf %%%%.worker.exit-notification) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: %%%%.worker.handshake/from-worker (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: (setf %%%%.worker.handshake/from-worker) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: %%%%.worker.handshake/to-worker (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: (setf %%%%.worker.handshake/to-worker) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Reader: %%%%.worker.index (instance)
Writer: (setf %%%%.worker.index) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

index.

Reader: %%%%.worker.running-category (instance)
Writer: (setf %%%%.worker.running-category) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

running-category.

Reader: %%%%.worker.tasks (instance)
Writer: (setf %%%%.worker.tasks) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

tasks.

Reader: %%%%.worker.thread (instance)
Writer: (setf %%%%.worker.thread) (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

thread.

Reader: %%%%.wrapped-error.value (instance)
Writer: (setf %%%%.wrapped-error.value) (instance)
Package

lparallel.kernel.

Source

handling.lisp.

Target Slot

value.

Function: %call-with-task-handler ()
Package

lparallel.kernel.

Source

handling.lisp.

Function: %chain-p (object)
Package

lparallel.promise.

Source

promise.lisp.

Function: %delay-p (object)
Package

lparallel.promise.

Source

promise.lisp.

Function: %fill-workers (workers kernel)
Package

lparallel.kernel.

Source

core.lisp.

Function: %future-p (object)
Package

lparallel.promise.

Source

promise.lisp.

Function: %kernel-worker-count ()
Package

lparallel.kernel.

Source

core.lisp.

Function: %make-channel (&key fixed-capacity)
Package

lparallel.kernel.

Source

core.lisp.

Function: %make-cons-queue ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: %make-queue (&key fixed-capacity initial-contents)
Package

lparallel.queue.

Source

queue.lisp.

Function: %make-raw-queue ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: %make-spin-queue (head tail)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: %make-vector-queue (capacity)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: %make-worker (index tasks)
Package

lparallel.kernel.

Source

core.lisp.

Function: %mv-macrolet-bindings (typed-vars mv-binding-datum)
Package

lparallel.cognate.

Source

plet.lisp.

Function: %parse-options (args)
Package

lparallel.cognate.

Source

option.lisp.

Function: %pdotimes (size parts fn)
Package

lparallel.cognate.

Source

pdotimes.lisp.

Function: %preduce-partial (function sequence start size parts &rest keyword-args)
Package

lparallel.cognate.

Source

preduce.lisp.

Function: %promise-p (object)
Package

lparallel.promise.

Source

promise.lisp.

Function: %time-remaining (start timeout)
Package

lparallel.thread-util.

Source

thread-util.lisp.

Function: %try-pop-cons-queue/no-lock/timeout ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: %try-pop-vector-queue/no-lock/timeout ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Reader: alivep ()
Package

lparallel.kernel.

Alias for

%%%%.kernel.alivep.

Function: all-binding-vars (binding-data null-bindings)
Package

lparallel.cognate.

Source

plet.lisp.

Function: binding-datum-p (object)
Package

lparallel.cognate.

Source

plet.lisp.

Reader: binding-datum-vars (instance)
Package

lparallel.cognate.

Alias for

%%%%.binding-datum.vars.

Function: binding-decl-spec (typed-vars var)
Package

lparallel.cognate.

Source

plet.lisp.

Function: binding-decl-specs (typed-vars vars)
Package

lparallel.cognate.

Source

plet.lisp.

Function: call-impl-fn ()
Package

lparallel.defpun.

Source

defpun.lisp.

Function: call-inside-worker ()
Package

lparallel.defpun.

Source

defpun.lisp.

Function: call-quicksort (vec lo hi compare granularity key)
Package

lparallel.cognate.

Source

psort.lisp.

Function: call-with-locked-cons-queue (fn queue)
Package

lparallel.queue.

Source

queue.lisp.

Function: call-with-locked-queue (fn queue)
Package

lparallel.queue.

Source

queue.lisp.

Function: call-with-locked-vector-queue (fn queue)
Package

lparallel.queue.

Source

queue.lisp.

Function: call-with-task-handler ()
Package

lparallel.kernel.

Source

handling.lisp.

Function: call-with-temp-kernel (fn &rest args)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Function: call-with-toplevel-handler ()
Package

lparallel.defpun.

Source

defpun.lisp.

Function: call-with-tracked-error (condition body-fn)
Package

lparallel.kernel.

Source

handling.lisp.

Function: call-with-worker-context (fn worker-context kernel worker)
Package

lparallel.kernel.

Source

core.lisp.

Reader: chain-object (instance)
Package

lparallel.promise.

Alias for

%%%%.%chain.object.

Reader: channel-kernel (instance)
Package

lparallel.kernel.

Alias for

%%%%.channel.kernel.

Function: channel-p (object)
Package

lparallel.kernel.

Source

classes.lisp.

Reader: channel-queue (instance)
Package

lparallel.kernel.

Alias for

%%%%.channel.queue.

Function: check-node (node)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: children-done-p ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: clear-node (node)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: clear-node-error (node)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: client-vars (binding-data)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: compute-node (node)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: compute-ptree (root ptree kernel)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: computedp ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: condition-handler (condition)

Mimic the CL handling mechanism, calling handlers until one assumes control (or not).

Package

lparallel.kernel.

Source

handling.lisp.

Function: cons-queue-full-p (queue)
Package

lparallel.queue.

Source

queue.lisp.

Function: cons-queue-full-p/no-lock (queue)
Package

lparallel.queue.

Source

queue.lisp.

Function: cons-queue-p (object)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: constrain-return-type (return-type)
Package

lparallel.util.

Source

defun.lisp.

Function: copy-%chain (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: copy-%delay (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: copy-%future (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: copy-%promise (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: copy-binding-datum (instance)
Package

lparallel.cognate.

Source

plet.lisp.

Function: copy-channel (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-cons-queue (instance)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: copy-counter (instance)
Package

lparallel.counter.

Source

counter.lisp.

Function: copy-kernel ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-limiter ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-node (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: copy-plan (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: copy-promise-base (instance)
Package

lparallel.promise.

Source

promise.lisp.

Function: copy-ptree (instance)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: copy-raw-queue (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: copy-raw-queue ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: copy-scheduler (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-spin-queue (instance)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: copy-timeout (instance)
Package

lparallel.kernel.

Source

timeout.lisp.

Function: copy-vector-queue (instance)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: copy-worker (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-worker-info (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-worker-notifications (instance)
Package

lparallel.kernel.

Source

classes.lisp.

Function: copy-wrapped-error (instance)
Package

lparallel.kernel.

Source

handling.lisp.

Function: counter-p (object)
Package

lparallel.counter.

Source

counter.lisp.

Function: custom-declaration-p (symbol env)
Package

lparallel.cognate.

Source

plet.lisp.

Reader: data (instance)
Package

lparallel.vector-queue.

Alias for

%%%%.raw-queue.data.

Function: decl-spec->typed-vars (decl-spec env)
Package

lparallel.cognate.

Source

plet.lisp.

Function: decl-specs->typed-vars (decl-specs env)
Package

lparallel.cognate.

Source

plet.lisp.

Function: declaration-information (decl env)
Package

lparallel.cognate.

Source

plet.lisp.

Function: declarationp (symbol env)
Package

lparallel.cognate.

Source

plet.lisp.

Function: declares->decl-specs (declares)
Package

lparallel.cognate.

Source

plet.lisp.

Function: declares->typed-vars (declares env)
Package

lparallel.cognate.

Source

plet.lisp.

Function: defslots-names (name)
Package

lparallel.util.

Source

defslots.lisp.

Function: delete-registered-names (names)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: delete-stale-registrations ()
Package

lparallel.defpun.

Source

defpun.lisp.

Function: deprecated-timeout ()
Package

lparallel.kernel.

Source

timeout.lisp.

Function: each-node (ptree fn)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: enter-worker-loop (kernel worker)
Package

lparallel.kernel.

Source

core.lisp.

Function: exec-task/non-worker ()
Package

lparallel.kernel.

Source

core.lisp.

Function: exec-task/worker ()
Package

lparallel.kernel.

Source

core.lisp.

Function: fill-workers (workers kernel)
Package

lparallel.kernel.

Source

core.lisp.

Function: find-min-length (seqs)
Package

lparallel.cognate.

Source

util.lisp.

Function: find-node ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: find-num-parts (size parts-hint)
Package

lparallel.cognate.

Source

subdivide.lisp.

Function: force-delay (delay)
Package

lparallel.promise.

Source

promise.lisp.

Function: force-future (future)
Package

lparallel.promise.

Source

promise.lisp.

Function: force-promise (promise)
Package

lparallel.promise.

Source

promise.lisp.

Function: freep ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: fulfill-delay (delay client-fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: fulfill-future (future client-fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: fulfill-object (object client-fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: fulfill-plan/call (plan)
Package

lparallel.promise.

Source

promise.lisp.

Function: fulfill-plan/error (plan err)
Package

lparallel.promise.

Source

promise.lisp.

Function: fulfill-plan/values (plan values)
Package

lparallel.promise.

Source

promise.lisp.

Function: fulfill-promise (promise client-fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: future-let-binding (binding-datum)
Package

lparallel.cognate.

Source

plet.lisp.

Function: future-let-bindings (binding-data)
Package

lparallel.cognate.

Source

plet.lisp.

Function: future-macrolet-binding (typed-vars binding-datum)
Package

lparallel.cognate.

Source

plet.lisp.

Function: future-macrolet-bindings (typed-vars binding-data)
Package

lparallel.cognate.

Source

plet.lisp.

Function: get-parts-hint (parts-hint)
Package

lparallel.cognate.

Source

option.lisp.

Function: get-real-time-in-seconds ()
Package

lparallel.thread-util.

Source

thread-util.lisp.

Function: handshake/from-worker/finish (worker status)
Package

lparallel.kernel.

Source

core.lisp.

Function: handshake/from-worker/start (worker)
Package

lparallel.kernel.

Source

core.lisp.

Function: handshake/to-worker/finish (worker)
Package

lparallel.kernel.

Source

core.lisp.

Function: handshake/to-worker/start (worker)
Package

lparallel.kernel.

Source

core.lisp.

Reader: head ()
Writer: (setf head) ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Target Slot

head.

Reader: id (instance)
Package

lparallel.ptree.

Alias for

%%%%.node.id.

Reader: impl (instance)
Package

lparallel.vector-queue.

Alias for

%%%%.vector-queue.impl.

Reader: impl (instance)
Package

lparallel.cons-queue.

Alias for

%%%%.cons-queue.impl.

Function: indexing-wrapper (array index function args)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Function: initial-limiter-count (thread-count)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: item-predicate (item test test-not)
Package

lparallel.cognate.

Source

util.lisp.

Function: kernel-info (kernel)
Package

lparallel.kernel.

Source

core.lisp.

Function: kernel-p ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: kill (kernel category)
Package

lparallel.kernel.

Source

kill.lisp.

Function: kill-errors ()
Package

lparallel.kernel.

Source

kill.lisp.

Function: kill-errors-report (stream)
Package

lparallel.kernel.

Source

kill.lisp.

Reader: limiter-accept-task-p ()
Writer: (setf limiter-accept-task-p) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

limiter-accept-task-p.

Reader: limiter-count ()
Writer: (setf limiter-count) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

limiter-count.

Reader: limiter-lock ()
Writer: (setf limiter-lock) ()
Package

lparallel.kernel.

Source

classes.lisp.

Target Slot

limiter-lock.

Function: limiter-p ()
Package

lparallel.kernel.

Source

classes.lisp.

Reader: lock (instance)
Package

lparallel.vector-queue.

Alias for

%%%%.vector-queue.lock.

Reader: lock (instance)
Package

lparallel.cons-queue.

Alias for

%%%%.cons-queue.lock.

Reader: lock (instance)
Package

lparallel.ptree.

Alias for

%%%%.ptree.lock.

Reader: lock-level (instance)
Package

lparallel.ptree.

Alias for

%%%%.node.lock-level.

Function: lock-node ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: lookup-all (item alist &key test)
Package

lparallel.cognate.

Source

plet.lisp.

Function: make-%chain-instance (&key object)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-%delay-instance (&key result lock fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-%future-instance (&key result lock fn canceledp)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-%promise-instance (&key result lock cvar availablep)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-all-bindings (kernel bindings)
Package

lparallel.kernel.

Source

core.lisp.

Function: make-binding-data (bindings)
Package

lparallel.slet.

Source

slet.lisp.

Function: make-binding-data (bindings)
Package

lparallel.cognate.

Source

plet.lisp.

Function: make-binding-datum (mv-binding)
Package

lparallel.slet.

Source

slet.lisp.

Function: make-binding-datum-instance (&key future-result future-var form vars)
Package

lparallel.cognate.

Source

plet.lisp.

Function: make-channel-instance (&key queue kernel)
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-channeled-task ()
Package

lparallel.kernel.

Source

core.lisp.

Function: make-cons-queue-instance (&key impl lock cvar)
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: make-debugger-hook ()

Record ‘*debugger-error*’ for the ‘transfer-error’ restart.

Package

lparallel.kernel.

Source

handling.lisp.

Function: make-future (fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-future-task ()
Package

lparallel.promise.

Source

promise.lisp.

Function: make-input-parts (sequences size parts-hint)

Subdivide and interleave sequences for parallel mapping.

Package

lparallel.cognate.

Source

subdivide.lisp.

Function: make-kernel-instance ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-limiter ()
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-limiter-data (thread-count)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: make-mv-binding-datum (mv-binding)
Package

lparallel.cognate.

Source

plet.lisp.

Function: make-node (se1 se2)

Return a list with SE1 as the CAR and SE2 as the CDR.

Package

lparallel.spin-queue.

Alias for

cons.

Function: make-node-instance (&key id function children parents lock-level children-done-p result)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: make-node-task (queue node)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: make-parts (result size parts-hint &key slicep)
Package

lparallel.cognate.

Source

subdivide.lisp.

Function: make-plan-instance (&key result lock fn)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-promise-base-instance (&key result lock)
Package

lparallel.promise.

Source

promise.lisp.

Function: make-ptree-instance (&key nodes queue pending lock)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: make-raw-queue (capacity)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: make-raw-queue-instance (&key data start count)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: make-result-parts (result size parts-hint)

Subdivide the result sequence. For a list, delineate boundaries by slicing.

Package

lparallel.cognate.

Source

subdivide.lisp.

Function: make-scheduler (workers spin-count)
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Function: make-scheduler-instance (&key workers wait-cvar wait-lock wait-count notify-count spin-count random-index low-priority-tasks)
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-sv-binding-datum (sv-binding)
Package

lparallel.cognate.

Source

plet.lisp.

Function: make-task ()
Package

lparallel.kernel.

Source

core.lisp.

Function: make-task-instance (se1 se2)

Return a list with SE1 as the CAR and SE2 as the CDR.

Package

lparallel.kernel.

Alias for

cons.

Function: make-temp-var (var)
Package

lparallel.slet.

Source

slet.lisp.

Function: make-timeout-instance (&key canceled-result thread lock)
Package

lparallel.kernel.

Source

timeout.lisp.

Function: make-vector-queue-instance (&key impl lock notify-push notify-pop)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: make-worker (kernel index tasks)
Package

lparallel.kernel.

Source

core.lisp.

Function: make-worker-info-instance (&key bindings context name)
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-worker-instance (&key handshake/from-worker handshake/to-worker exit-notification thread running-category index tasks)
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-worker-notifications-instance (&key handshake/from-worker handshake/to-worker exit-notification)
Package

lparallel.kernel.

Source

classes.lisp.

Function: make-worker-thread (kernel worker name bindings)
Package

lparallel.kernel.

Source

core.lisp.

Function: make-wrapped-error-instance (&key value)
Package

lparallel.kernel.

Source

handling.lisp.

Function: map-iterate (map size fn seqs)

A variation of (map nil ...)/mapc/mapl with size constrained. Without a result to delineate sublist boundaries, we must enforce them manually.

Package

lparallel.cognate.

Source

pmap.lisp.

Function: map-nil (&rest args)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: maplist-into (result-list fn &rest lists)

A variation of map-into.

Package

lparallel.cognate.

Source

pmap.lisp.

Function: maybe-wake-a-worker ()
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Function: midpoint ()
Package

lparallel.cognate.

Source

psort.lisp.

Function: mv-macrolet-bindings (typed-vars mv-binding-data)
Package

lparallel.cognate.

Source

plet.lisp.

Function: next-task ()
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Function: node-p (object)
Package

lparallel.ptree.

Source

ptree.lisp.

Reader: nodes (instance)
Package

lparallel.ptree.

Alias for

%%%%.ptree.nodes.

Function: notify-exit (worker)
Package

lparallel.kernel.

Source

core.lisp.

Function: parse-bindings (bindings)
Package

lparallel.slet.

Source

slet.lisp.

Function: parse-defslots (supers slots options)
Package

lparallel.util.

Source

defslots.lisp.

Function: parse-options (args)
Package

lparallel.cognate.

Source

option.lisp.

Function: partition (predicate list)
Package

lparallel.cognate.

Source

plet.lisp.

Function: peek-raw-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: pfind-if/list (predicate sequence &key from-end start end key parts)
Package

lparallel.cognate.

Source

pfind.lisp.

Function: pfind-if/vector (predicate sequence &key from-end start end key parts)
Package

lparallel.cognate.

Source

pfind.lisp.

Reader: plan-fn (instance)
Package

lparallel.promise.

Alias for

%%%%.plan.fn.

Function: plan-p (object)
Package

lparallel.promise.

Source

promise.lisp.

Function: plist-keys (plist)
Package

lparallel.util.

Source

defslots.lisp.

Function: plist-values-for-key (plist target-key)
Package

lparallel.util.

Source

defslots.lisp.

Function: pmap-into/parsed (map-into result-seq fn seqs size parts-hint)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-into/parts (map-into result-seq fn seqs size parts-hint)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-into/powder (map-into result-seq fn seqs size)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-into/powder/array (result-seq fn seqs size)

When a sequence of size N is divided into N parts, it becomes powder.

Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-into/powder/list (map result-seq fn seqs size)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-into/unparsed (map-into result-seq fn seqs)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-iterate (map fn seqs size parts-hint)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-iterate/parts (map fn seqs size parts-hint)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap-iterate/powder (map fn seqs size)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap/parsed (result-type function sequences size parts-hint)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pmap/unparsed (result-type function sequences)
Package

lparallel.cognate.

Source

pmap.lisp.

Function: pop-raw-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: pquantifier (quantifier predicate sequences bail)
Package

lparallel.cognate.

Source

pquantifier.lisp.

Function: preduce-partial/list (function sequence start size parts &rest keyword-args)
Package

lparallel.cognate.

Source

preduce.lisp.

Function: preduce-partial/vector (function sequence start size parts &rest keyword-args)
Package

lparallel.cognate.

Source

preduce.lisp.

Function: preduce/common (function sequence subsize &key key from-end start end initial-value parts recurse partial)
Package

lparallel.cognate.

Source

preduce.lisp.

Function: premove-if-not/list (test list from-end start end key parts)
Package

lparallel.cognate.

Source

premove.lisp.

Function: primary-temp-vars (binding-data)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: promise-base-p (object)
Package

lparallel.promise.

Source

promise.lisp.

Function: propagate-error ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: ptree-p (object)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: push-raw-queue ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: push-to-random-worker ()
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Function: quicksort/key/gran (vec lo hi compare gran3 key2)
Package

lparallel.cognate.

Source

psort.lisp.

Function: quicksort/key/no-gran (vec lo hi compare key2)
Package

lparallel.cognate.

Source

psort.lisp.

Function: quicksort/no-key/gran (vec lo hi compare gran3)
Package

lparallel.cognate.

Source

psort.lisp.

Function: quicksort/no-key/no-gran (vec lo hi compare)
Package

lparallel.cognate.

Source

psort.lisp.

Function: quoted-vector-type-p (form)
Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Function: quotedp (form)
Package

lparallel.cognate.

Source

pmap-open-coded.lisp.

Function: raw-queue-capacity ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Reader: raw-queue-count (instance)
Package

lparallel.vector-queue.

Alias for

%%%%.raw-queue.count.

Function: raw-queue-empty-p ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: raw-queue-full-p ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: raw-queue-p (object)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: raw-queue-p ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Function: receive-results (channel count fn)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Function: register-fn (name)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: register-name (name)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: registered-fn-p (name)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: registered-macrolets (kernel)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: replace-error (promise)
Package

lparallel.promise.

Source

promise.lisp.

Function: replace-worker (kernel worker)
Package

lparallel.kernel.

Source

core.lisp.

Reader: result (instance)
Package

lparallel.promise.

Alias for

%%%%.promise-base.result.

Reader: result (instance)
Package

lparallel.ptree.

Alias for

%%%%.node.result.

Reader: running-category (instance)
Package

lparallel.kernel.

Alias for

%%%%.worker.running-category.

Function: schedule-task ()
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Reader: scheduler ()
Package

lparallel.kernel.

Alias for

%%%%.kernel.scheduler.

Function: scheduler-p (object)
Package

lparallel.kernel.

Source

classes.lisp.

Function: shutdown (channel kernel)
Package

lparallel.kernel.

Source

core.lisp.

Reader: spin-queue-head (instance)
Writer: (setf spin-queue-head) (instance)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Target Slot

head.

Function: spin-queue-p (object)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Reader: spin-queue-tail (instance)
Writer: (setf spin-queue-tail) (instance)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Target Slot

tail.

Function: steal-task ()
Package

lparallel.kernel.

Source

stealing-scheduler.lisp.

Function: steal-until-receive-result (channel worker fn)
Package

lparallel.kernel-util.

Source

kernel-util.lisp.

Function: steal-work ()
Package

lparallel.kernel.

Source

core.lisp.

Function: subdivide-array (array size parts-hint)
Package

lparallel.cognate.

Source

subdivide.lisp.

Function: subdivide-list (list size parts-hint)
Package

lparallel.cognate.

Source

subdivide.lisp.

Function: subdivide-list/slice (list size parts-hint)
Package

lparallel.cognate.

Source

subdivide.lisp.

Function: submit-node (node queue kernel)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: submit-raw-task (task kernel)
Package

lparallel.kernel.

Source

core.lisp.

Function: subsize (seq size start end)
Package

lparallel.cognate.

Source

util.lisp.

Function: symbolicate/no-intern (&rest string-designators)

Concatenate ‘string-designators’ then make-symbol the result.

Package

lparallel.util.

Source

misc.lisp.

Function: symbolicate/package (package &rest string-designators)

Concatenate ‘string-designators’ then intern the result into ‘package’.

Package

lparallel.util.

Source

misc.lisp.

Reader: tail ()
Writer: (setf tail) ()
Package

lparallel.raw-queue.

Source

raw-queue.lisp.

Target Slot

tail.

Function: task-category (list)

Return all but the first object in a list.

Package

lparallel.kernel.

Alias for

cdr.

Function: task-fn (list)

Return the 1st object in a list.

Package

lparallel.kernel.

Alias for

car.

Reader: tasks (instance)
Package

lparallel.kernel.

Alias for

%%%%.worker.tasks.

Function: temp-vars (binding-data)
Package

lparallel.defpun.

Source

defpun.lisp.

Reader: thread (instance)
Package

lparallel.kernel.

Alias for

%%%%.worker.thread.

Function: timeout-p (object)
Package

lparallel.kernel.

Source

timeout.lisp.

Function: track-exit ()
Package

lparallel.kernel.

Source

core.lisp.

Function: transfer-error-report (stream)
Package

lparallel.kernel.

Source

handling.lisp.

Function: transfer-error-restart (&optional err)
Package

lparallel.kernel.

Source

handling.lisp.

Function: try-each-elem (fun queue)
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Function: try-pop-cons-queue/no-lock/timeout ()
Package

lparallel.cons-queue.

Source

cons-queue.lisp.

Function: try-pop-vector-queue/no-lock/no-timeout ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: try-pop-vector-queue/no-lock/timeout ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: unchecked-name (name)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: unknown-typed-vars (typed-vars binding-data null-bindings)
Package

lparallel.cognate.

Source

plet.lisp.

Function: unlock-node ()
Package

lparallel.ptree.

Source

ptree.lisp.

Function: unwrap-result ()

In ‘receive-result’, this is called on the stored task result. The user receives the return value of this function.

Package

lparallel.kernel.

Source

handling.lisp.

Function: update-limiter-count ()
Package

lparallel.defpun.

Source

defpun.lisp.

Function: update-limiter-count/no-lock ()
Package

lparallel.defpun.

Source

defpun.lisp.

Reader: use-caller-p ()
Package

lparallel.kernel.

Alias for

%%%%.kernel.use-caller-p.

Function: valid-registered-fn-p (name)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: valid-registered-name-p (name)
Package

lparallel.defpun.

Source

defpun.lisp.

Function: var-type (var typed-vars)
Package

lparallel.cognate.

Source

plet.lisp.

Function: vector-queue-capacity/no-lock ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: vector-queue-p (object)
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Function: wait-for-compute (ptree)
Package

lparallel.ptree.

Source

ptree.lisp.

Function: wait-for-worker (worker)
Package

lparallel.kernel.

Source

core.lisp.

Reader: worker-index (instance)
Package

lparallel.kernel.

Alias for

%%%%.worker.index.

Function: worker-info-p (object)
Package

lparallel.kernel.

Source

classes.lisp.

Function: worker-loop ()
Package

lparallel.kernel.

Source

core.lisp.

Function: worker-notifications-p (object)
Package

lparallel.kernel.

Source

classes.lisp.

Function: worker-p (object)
Package

lparallel.kernel.

Source

classes.lisp.

Reader: workers ()
Package

lparallel.kernel.

Alias for

%%%%.kernel.workers.

Function: wrap-error (condition)

Wrap an error. A non-error condition may also be wrapped, though it will still be signaled with ‘error’.

Package

lparallel.kernel.

Source

handling.lisp.

Function: wrapped-error-p (object)
Package

lparallel.kernel.

Source

handling.lisp.

Reader: wrapped-error-value (instance)
Package

lparallel.kernel.

Alias for

%%%%.wrapped-error.value.

Function: zip-repeat (fn list object)
Package

lparallel.cognate.

Source

plet.lisp.

Function: zip/vector (seqs)
Package

lparallel.cognate.

Source

util.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.6 Generic functions

Generic Reader: ptree-error-id (condition)
Package

lparallel.ptree.

Methods
Reader Method: ptree-error-id ((condition ptree-error))
Source

ptree.lisp.

Target Slot

id.

Generic Reader: ptree-error-llks (condition)
Package

lparallel.ptree.

Methods
Reader Method: ptree-error-llks ((condition ptree-lambda-list-keyword-error))
Source

ptree.lisp.

Target Slot

llks.

Generic Reader: ptree-error-refs (condition)
Package

lparallel.ptree.

Methods
Reader Method: ptree-error-refs ((condition ptree-undefined-function-error))
Source

ptree.lisp.

Target Slot

refs.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.7 Conditions

Condition: ptree-error
Package

lparallel.ptree.

Source

ptree.lisp.

Direct superclasses

error.

Direct subclasses
Direct methods

ptree-error-id.

Direct slots
Slot: id
Initargs

:id

Readers

ptree-error-id.

Writers

This slot is read-only.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.8 Structures

Structure: %chain
Package

lparallel.promise.

Source

promise.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: object
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.promise::object) (quote lparallel.promise::%chain))

Readers

%%%%.%chain.object.

Writers

(setf %%%%.%chain.object).

Structure: %delay
Package

lparallel.promise.

Source

promise.lisp.

Direct superclasses

plan.

Structure: %future
Package

lparallel.promise.

Source

promise.lisp.

Direct superclasses

plan.

Direct slots
Slot: canceledp
Type

boolean

Readers

%%%%.%future.canceledp.

Writers

(setf %%%%.%future.canceledp).

Structure: %promise
Package

lparallel.promise.

Source

promise.lisp.

Direct superclasses

promise-base.

Direct slots
Slot: cvar
Readers

%%%%.%promise.cvar.

Writers

(setf %%%%.%promise.cvar).

Slot: availablep
Type

boolean

Initform

t

Readers

%%%%.%promise.availablep.

Writers

(setf %%%%.%promise.availablep).

Structure: binding-datum
Package

lparallel.cognate.

Source

plet.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: future-result
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.cognate::future-result) (quote lparallel.cognate::binding-datum))

Readers

%%%%.binding-datum.future-result.

Writers

(setf %%%%.binding-datum.future-result).

Slot: future-var
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.cognate::future-var) (quote lparallel.cognate::binding-datum))

Readers

%%%%.binding-datum.future-var.

Writers

(setf %%%%.binding-datum.future-var).

Slot: form
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.cognate::form) (quote lparallel.cognate::binding-datum))

Readers

%%%%.binding-datum.form.

Writers

(setf %%%%.binding-datum.form).

Slot: vars
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.cognate::vars) (quote lparallel.cognate::binding-datum))

Readers

%%%%.binding-datum.vars.

Writers

(setf %%%%.binding-datum.vars).

Structure: limiter
Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

structure-object.

Direct subclasses

kernel.

Direct slots
Slot: limiter-accept-task-p
Type

boolean

Initform

(error "no init")

Readers

limiter-accept-task-p.

Writers

(setf limiter-accept-task-p).

Slot: limiter-lock
Initform

(error "no init")

Readers

limiter-lock.

Writers

(setf limiter-lock).

Slot: limiter-count
Type

fixnum

Initform

(error "no init")

Readers

limiter-count.

Writers

(setf limiter-count).

Structure: node
Package

lparallel.ptree.

Source

ptree.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: id
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.ptree::id) (quote lparallel.ptree::node))

Readers

%%%%.node.id.

Writers

(setf %%%%.node.id).

Slot: function
Package

common-lisp.

Type

(or function null)

Readers

%%%%.node.function.

Writers

(setf %%%%.node.function).

Slot: children
Type

list

Readers

%%%%.node.children.

Writers

(setf %%%%.node.children).

Slot: parents
Type

list

Readers

%%%%.node.parents.

Writers

(setf %%%%.node.parents).

Slot: lock-level
Type

fixnum

Initform

0

Readers

%%%%.node.lock-level.

Writers

(setf %%%%.node.lock-level).

Slot: children-done-p
Type

boolean

Readers

%%%%.node.children-done-p.

Writers

(setf %%%%.node.children-done-p).

Slot: result
Initform

lparallel.ptree::+no-result+

Readers

%%%%.node.result.

Writers

(setf %%%%.node.result).

Structure: plan
Package

lparallel.promise.

Source

promise.lisp.

Direct superclasses

promise-base.

Direct subclasses
Direct slots
Slot: fn
Type

(or null function)

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.promise::fn) (quote lparallel.promise::plan))

Readers

%%%%.plan.fn.

Writers

(setf %%%%.plan.fn).

Structure: promise-base
Package

lparallel.promise.

Source

promise.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct slots
Slot: result
Initform

lparallel.promise::+no-result+

Readers

%%%%.promise-base.result.

Writers

(setf %%%%.promise-base.result).

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.promise-base.lock.

Writers

(setf %%%%.promise-base.lock).

Structure: raw-queue
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: data
Type

simple-array

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.vector-queue::data) (quote lparallel.vector-queue::raw-queue))

Readers

%%%%.raw-queue.data.

Writers

(setf %%%%.raw-queue.data).

Slot: start
Type

lparallel.util:index

Initform

0

Readers

%%%%.raw-queue.start.

Writers

(setf %%%%.raw-queue.start).

Slot: count
Package

common-lisp.

Type

lparallel.vector-queue::raw-queue-count

Initform

0

Readers

%%%%.raw-queue.count.

Writers

(setf %%%%.raw-queue.count).

Structure: scheduler

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’.

Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: workers
Type

simple-vector

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::workers) (quote lparallel.kernel::scheduler))

Readers

%%%%.scheduler.workers.

Writers

(setf %%%%.scheduler.workers).

Slot: wait-cvar
Initform

(bordeaux-threads:make-condition-variable)

Readers

%%%%.scheduler.wait-cvar.

Writers

(setf %%%%.scheduler.wait-cvar).

Slot: wait-lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.scheduler.wait-lock.

Writers

(setf %%%%.scheduler.wait-lock).

Slot: wait-count
Type

lparallel.counter:counter

Initform

(lparallel.counter:make-counter)

Readers

%%%%.scheduler.wait-count.

Writers

(setf %%%%.scheduler.wait-count).

Slot: notify-count
Type

(integer 0)

Initform

0

Readers

%%%%.scheduler.notify-count.

Writers

(setf %%%%.scheduler.notify-count).

Slot: spin-count
Type

lparallel.util:index

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::spin-count) (quote lparallel.kernel::scheduler))

Readers

%%%%.scheduler.spin-count.

Writers

(setf %%%%.scheduler.spin-count).

Slot: random-index
Type

lparallel.util:index

Initform

0

Readers

%%%%.scheduler.random-index.

Writers

(setf %%%%.scheduler.random-index).

Slot: low-priority-tasks
Type

lparallel.spin-queue:spin-queue

Initform

(lparallel.spin-queue:make-spin-queue)

Readers

%%%%.scheduler.low-priority-tasks.

Writers

(setf %%%%.scheduler.low-priority-tasks).

Structure: timeout
Package

lparallel.kernel.

Source

timeout.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: canceled-result
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::canceled-result) (quote lparallel.kernel::timeout))

Readers

%%%%.timeout.canceled-result.

Writers

(setf %%%%.timeout.canceled-result).

Slot: thread
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::thread) (quote lparallel.kernel::timeout))

Readers

%%%%.timeout.thread.

Writers

(setf %%%%.timeout.thread).

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.timeout.lock.

Writers

(setf %%%%.timeout.lock).

Structure: worker

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.

Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

worker-notifications.

Direct slots
Slot: thread
Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::thread) (quote lparallel.kernel::worker))

Readers

%%%%.worker.thread.

Writers

(setf %%%%.worker.thread).

Slot: running-category
Readers

%%%%.worker.running-category.

Writers

(setf %%%%.worker.running-category).

Slot: index
Package

lparallel.util.

Type

lparallel.util:index

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.util:index) (quote lparallel.kernel::worker))

Readers

%%%%.worker.index.

Writers

(setf %%%%.worker.index).

Slot: tasks
Type

lparallel.spin-queue:spin-queue

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::tasks) (quote lparallel.kernel::worker))

Readers

%%%%.worker.tasks.

Writers

(setf %%%%.worker.tasks).

Structure: worker-info

Information common to all workers. See ‘make-kernel’.

Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: bindings
Type

list

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::bindings) (quote lparallel.kernel::worker-info))

Readers

%%%%.worker-info.bindings.

Writers

(setf %%%%.worker-info.bindings).

Slot: context
Type

function

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::context) (quote lparallel.kernel::worker-info))

Readers

%%%%.worker-info.context.

Writers

(setf %%%%.worker-info.context).

Slot: name
Type

string

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::name) (quote lparallel.kernel::worker-info))

Readers

%%%%.worker-info.name.

Writers

(setf %%%%.worker-info.name).

Structure: worker-notifications

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.

Package

lparallel.kernel.

Source

classes.lisp.

Direct superclasses

structure-object.

Direct subclasses

worker.

Direct slots
Slot: handshake/from-worker
Initform

(lparallel.queue:make-queue)

Readers

%%%%.worker-notifications.handshake/from-worker.

Writers

(setf %%%%.worker-notifications.handshake/from-worker).

Slot: handshake/to-worker
Initform

(lparallel.queue:make-queue)

Readers

%%%%.worker-notifications.handshake/to-worker.

Writers

(setf %%%%.worker-notifications.handshake/to-worker).

Slot: exit-notification
Initform

(lparallel.queue:make-queue)

Readers

%%%%.worker-notifications.exit-notification.

Writers

(setf %%%%.worker-notifications.exit-notification).

Structure: wrapped-error

This is a container for transferring an error that occurs inside ‘call-with-task-handler’ to the calling thread.

Package

lparallel.kernel.

Source

handling.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: value
Type

condition

Initform

(error "slot ~a in ~a not initialized" (quote lparallel.kernel::value) (quote lparallel.kernel::wrapped-error))

Readers

%%%%.wrapped-error.value.

Writers

(setf %%%%.wrapped-error.value).


Previous: , Up: Internals   [Contents][Index]

6.2.9 Types

Type: node ()
Package

lparallel.spin-queue.

Source

cas-spin-queue.lisp.

Type: raw-queue-count ()
Package

lparallel.vector-queue.

Source

vector-queue.lisp.

Type: task ()
Package

lparallel.kernel.

Source

classes.lisp.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   K   L   M   N   P   Q   R   S   T   U   V   W   Z  
Index Entry  Section

%
%%%%.%chain.object: Private ordinary functions
%%%%.%delay.fn: Private ordinary functions
%%%%.%delay.lock: Private ordinary functions
%%%%.%delay.result: Private ordinary functions
%%%%.%future.canceledp: Private ordinary functions
%%%%.%future.fn: Private ordinary functions
%%%%.%future.lock: Private ordinary functions
%%%%.%future.result: Private ordinary functions
%%%%.%promise.availablep: Private ordinary functions
%%%%.%promise.cvar: Private ordinary functions
%%%%.%promise.lock: Private ordinary functions
%%%%.%promise.result: Private ordinary functions
%%%%.binding-datum.form: Private ordinary functions
%%%%.binding-datum.future-result: Private ordinary functions
%%%%.binding-datum.future-var: Private ordinary functions
%%%%.binding-datum.vars: Private ordinary functions
%%%%.channel.kernel: Private ordinary functions
%%%%.channel.queue: Private ordinary functions
%%%%.cons-queue.cvar: Private ordinary functions
%%%%.cons-queue.impl: Private ordinary functions
%%%%.cons-queue.lock: Private ordinary functions
%%%%.defpun.quicksort/key/gran: Private ordinary functions
%%%%.defpun.quicksort/key/no-gran: Private ordinary functions
%%%%.defpun.quicksort/no-key/gran: Private ordinary functions
%%%%.defpun.quicksort/no-key/no-gran: Private ordinary functions
%%%%.kernel.alivep: Private ordinary functions
%%%%.kernel.limiter-accept-task-p: Private ordinary functions
%%%%.kernel.limiter-count: Private ordinary functions
%%%%.kernel.limiter-lock: Private ordinary functions
%%%%.kernel.scheduler: Private ordinary functions
%%%%.kernel.use-caller-p: Private ordinary functions
%%%%.kernel.worker-info: Private ordinary functions
%%%%.kernel.workers: Private ordinary functions
%%%%.kernel.workers-lock: Private ordinary functions
%%%%.node.children: Private ordinary functions
%%%%.node.children-done-p: Private ordinary functions
%%%%.node.function: Private ordinary functions
%%%%.node.id: Private ordinary functions
%%%%.node.lock-level: Private ordinary functions
%%%%.node.parents: Private ordinary functions
%%%%.node.result: Private ordinary functions
%%%%.plan.fn: Private ordinary functions
%%%%.plan.lock: Private ordinary functions
%%%%.plan.result: Private ordinary functions
%%%%.promise-base.lock: Private ordinary functions
%%%%.promise-base.result: Private ordinary functions
%%%%.ptree.lock: Private ordinary functions
%%%%.ptree.nodes: Private ordinary functions
%%%%.ptree.pending: Private ordinary functions
%%%%.ptree.queue: Private ordinary functions
%%%%.raw-queue.count: Private ordinary functions
%%%%.raw-queue.data: Private ordinary functions
%%%%.raw-queue.start: Private ordinary functions
%%%%.scheduler.low-priority-tasks: Private ordinary functions
%%%%.scheduler.notify-count: Private ordinary functions
%%%%.scheduler.random-index: Private ordinary functions
%%%%.scheduler.spin-count: Private ordinary functions
%%%%.scheduler.wait-count: Private ordinary functions
%%%%.scheduler.wait-cvar: Private ordinary functions
%%%%.scheduler.wait-lock: Private ordinary functions
%%%%.scheduler.workers: Private ordinary functions
%%%%.timeout.canceled-result: Private ordinary functions
%%%%.timeout.lock: Private ordinary functions
%%%%.timeout.thread: Private ordinary functions
%%%%.vector-queue.impl: Private ordinary functions
%%%%.vector-queue.lock: Private ordinary functions
%%%%.vector-queue.notify-pop: Private ordinary functions
%%%%.vector-queue.notify-push: Private ordinary functions
%%%%.worker-info.bindings: Private ordinary functions
%%%%.worker-info.context: Private ordinary functions
%%%%.worker-info.name: Private ordinary functions
%%%%.worker-notifications.exit-notification: Private ordinary functions
%%%%.worker-notifications.handshake/from-worker: Private ordinary functions
%%%%.worker-notifications.handshake/to-worker: Private ordinary functions
%%%%.worker.exit-notification: Private ordinary functions
%%%%.worker.handshake/from-worker: Private ordinary functions
%%%%.worker.handshake/to-worker: Private ordinary functions
%%%%.worker.index: Private ordinary functions
%%%%.worker.running-category: Private ordinary functions
%%%%.worker.tasks: Private ordinary functions
%%%%.worker.thread: Private ordinary functions
%%%%.wrapped-error.value: Private ordinary functions
%%%%plet: Private macros
%%%plet: Private macros
%%plet: Private macros
%call-with-task-handler: Private ordinary functions
%chain-p: Private ordinary functions
%defslots: Private macros
%delay-p: Private ordinary functions
%fill-workers: Private ordinary functions
%future-p: Private ordinary functions
%kernel-worker-count: Private ordinary functions
%make-channel: Private ordinary functions
%make-cons-queue: Private ordinary functions
%make-queue: Private ordinary functions
%make-raw-queue: Private ordinary functions
%make-spin-queue: Private ordinary functions
%make-vector-queue: Private ordinary functions
%make-worker: Private ordinary functions
%mv-macrolet-bindings: Private ordinary functions
%parse-options: Private ordinary functions
%pdotimes: Private ordinary functions
%plet: Private macros
%plet: Private macros
%plet-if: Private macros
%preduce-partial: Private ordinary functions
%promise-p: Private ordinary functions
%slet: Private macros
%time-remaining: Private ordinary functions
%try-pop-cons-queue/no-lock/timeout: Private ordinary functions
%try-pop-vector-queue/no-lock/timeout: Private ordinary functions

(
(setf %%%%.%chain.object): Private ordinary functions
(setf %%%%.%delay.fn): Private ordinary functions
(setf %%%%.%delay.lock): Private ordinary functions
(setf %%%%.%delay.result): Private ordinary functions
(setf %%%%.%future.canceledp): Private ordinary functions
(setf %%%%.%future.fn): Private ordinary functions
(setf %%%%.%future.lock): Private ordinary functions
(setf %%%%.%future.result): Private ordinary functions
(setf %%%%.%promise.availablep): Private ordinary functions
(setf %%%%.%promise.cvar): Private ordinary functions
(setf %%%%.%promise.lock): Private ordinary functions
(setf %%%%.%promise.result): Private ordinary functions
(setf %%%%.binding-datum.form): Private ordinary functions
(setf %%%%.binding-datum.future-result): Private ordinary functions
(setf %%%%.binding-datum.future-var): Private ordinary functions
(setf %%%%.binding-datum.vars): Private ordinary functions
(setf %%%%.channel.kernel): Private ordinary functions
(setf %%%%.channel.queue): Private ordinary functions
(setf %%%%.cons-queue.cvar): Private ordinary functions
(setf %%%%.cons-queue.impl): Private ordinary functions
(setf %%%%.cons-queue.lock): Private ordinary functions
(setf %%%%.kernel.alivep): Private ordinary functions
(setf %%%%.kernel.limiter-accept-task-p): Private ordinary functions
(setf %%%%.kernel.limiter-count): Private ordinary functions
(setf %%%%.kernel.limiter-lock): Private ordinary functions
(setf %%%%.kernel.scheduler): Private ordinary functions
(setf %%%%.kernel.use-caller-p): Private ordinary functions
(setf %%%%.kernel.worker-info): Private ordinary functions
(setf %%%%.kernel.workers): Private ordinary functions
(setf %%%%.kernel.workers-lock): Private ordinary functions
(setf %%%%.node.children): Private ordinary functions
(setf %%%%.node.children-done-p): Private ordinary functions
(setf %%%%.node.function): Private ordinary functions
(setf %%%%.node.id): Private ordinary functions
(setf %%%%.node.lock-level): Private ordinary functions
(setf %%%%.node.parents): Private ordinary functions
(setf %%%%.node.result): Private ordinary functions
(setf %%%%.plan.fn): Private ordinary functions
(setf %%%%.plan.lock): Private ordinary functions
(setf %%%%.plan.result): Private ordinary functions
(setf %%%%.promise-base.lock): Private ordinary functions
(setf %%%%.promise-base.result): Private ordinary functions
(setf %%%%.ptree.lock): Private ordinary functions
(setf %%%%.ptree.nodes): Private ordinary functions
(setf %%%%.ptree.pending): Private ordinary functions
(setf %%%%.ptree.queue): Private ordinary functions
(setf %%%%.raw-queue.count): Private ordinary functions
(setf %%%%.raw-queue.data): Private ordinary functions
(setf %%%%.raw-queue.start): Private ordinary functions
(setf %%%%.scheduler.low-priority-tasks): Private ordinary functions
(setf %%%%.scheduler.notify-count): Private ordinary functions
(setf %%%%.scheduler.random-index): Private ordinary functions
(setf %%%%.scheduler.spin-count): Private ordinary functions
(setf %%%%.scheduler.wait-count): Private ordinary functions
(setf %%%%.scheduler.wait-cvar): Private ordinary functions
(setf %%%%.scheduler.wait-lock): Private ordinary functions
(setf %%%%.scheduler.workers): Private ordinary functions
(setf %%%%.timeout.canceled-result): Private ordinary functions
(setf %%%%.timeout.lock): Private ordinary functions
(setf %%%%.timeout.thread): Private ordinary functions
(setf %%%%.vector-queue.impl): Private ordinary functions
(setf %%%%.vector-queue.lock): Private ordinary functions
(setf %%%%.vector-queue.notify-pop): Private ordinary functions
(setf %%%%.vector-queue.notify-push): Private ordinary functions
(setf %%%%.worker-info.bindings): Private ordinary functions
(setf %%%%.worker-info.context): Private ordinary functions
(setf %%%%.worker-info.name): Private ordinary functions
(setf %%%%.worker-notifications.exit-notification): Private ordinary functions
(setf %%%%.worker-notifications.handshake/from-worker): Private ordinary functions
(setf %%%%.worker-notifications.handshake/to-worker): Private ordinary functions
(setf %%%%.worker.exit-notification): Private ordinary functions
(setf %%%%.worker.handshake/from-worker): Private ordinary functions
(setf %%%%.worker.handshake/to-worker): Private ordinary functions
(setf %%%%.worker.index): Private ordinary functions
(setf %%%%.worker.running-category): Private ordinary functions
(setf %%%%.worker.tasks): Private ordinary functions
(setf %%%%.worker.thread): Private ordinary functions
(setf %%%%.wrapped-error.value): Private ordinary functions
(setf counter-value): Public ordinary functions
(setf head): Private ordinary functions
(setf limiter-accept-task-p): Private ordinary functions
(setf limiter-count): Private ordinary functions
(setf limiter-lock): Private ordinary functions
(setf spin-queue-head): Private ordinary functions
(setf spin-queue-tail): Private ordinary functions
(setf tail): Private ordinary functions

A
accept-task-p: Private macros
alias-function: Public macros
alias-macro: Public macros
alivep: Private compiler macros
alivep: Private ordinary functions
all-binding-vars: Private ordinary functions

B
bind: Private macros
binding-datum-p: Private ordinary functions
binding-datum-vars: Private compiler macros
binding-datum-vars: Private ordinary functions
binding-decl-spec: Private ordinary functions
binding-decl-specs: Private ordinary functions
broadcast-task: Public ordinary functions

C
call-impl-fn: Private ordinary functions
call-inside-worker: Private ordinary functions
call-ptree: Public ordinary functions
call-quicksort: Private ordinary functions
call-with-locked-cons-queue: Private ordinary functions
call-with-locked-queue: Private ordinary functions
call-with-locked-vector-queue: Private ordinary functions
call-with-task-handler: Private ordinary functions
call-with-temp-kernel: Private ordinary functions
call-with-toplevel-handler: Private ordinary functions
call-with-tracked-error: Private ordinary functions
call-with-worker-context: Private ordinary functions
cancel-timeout: Public compiler macros
cancel-timeout: Public ordinary functions
cas: Public macros
chain: Public ordinary functions
chain-object: Private compiler macros
chain-object: Private ordinary functions
channel-kernel: Private compiler macros
channel-kernel: Private ordinary functions
channel-p: Private ordinary functions
channel-queue: Private compiler macros
channel-queue: Private ordinary functions
check-kernel: Public ordinary functions
check-node: Private ordinary functions
check-ptree: Public ordinary functions
check-symbols: Private macros
children-done-p: Private ordinary functions
clear-node: Private ordinary functions
clear-node-error: Private ordinary functions
clear-ptree: Public ordinary functions
clear-ptree-errors: Public ordinary functions
client-vars: Private ordinary functions
Compiler Macro, alivep: Private compiler macros
Compiler Macro, binding-datum-vars: Private compiler macros
Compiler Macro, cancel-timeout: Public compiler macros
Compiler Macro, chain-object: Private compiler macros
Compiler Macro, channel-kernel: Private compiler macros
Compiler Macro, channel-queue: Private compiler macros
Compiler Macro, condition-notify: Public compiler macros
Compiler Macro, condition-wait: Public compiler macros
Compiler Macro, data: Private compiler macros
Compiler Macro, id: Private compiler macros
Compiler Macro, impl: Private compiler macros
Compiler Macro, impl: Private compiler macros
Compiler Macro, lock: Private compiler macros
Compiler Macro, lock: Private compiler macros
Compiler Macro, lock: Private compiler macros
Compiler Macro, lock-level: Private compiler macros
Compiler Macro, make-channel: Public compiler macros
Compiler Macro, make-node: Private compiler macros
Compiler Macro, make-queue: Public compiler macros
Compiler Macro, make-task-instance: Private compiler macros
Compiler Macro, nodes: Private compiler macros
Compiler Macro, partial-apply: Public compiler macros
Compiler Macro, plan-fn: Private compiler macros
Compiler Macro, pmap: Public compiler macros
Compiler Macro, pmap-into: Public compiler macros
Compiler Macro, psort*: Public compiler macros
Compiler Macro, raw-queue-count: Private compiler macros
Compiler Macro, result: Private compiler macros
Compiler Macro, result: Private compiler macros
Compiler Macro, running-category: Private compiler macros
Compiler Macro, scheduler: Private compiler macros
Compiler Macro, submit-timeout: Public compiler macros
Compiler Macro, task-category: Private compiler macros
Compiler Macro, task-fn: Private compiler macros
Compiler Macro, tasks: Private compiler macros
Compiler Macro, thread: Private compiler macros
Compiler Macro, use-caller-p: Private compiler macros
Compiler Macro, worker-index: Private compiler macros
Compiler Macro, workers: Private compiler macros
Compiler Macro, wrapped-error-value: Private compiler macros
compute-node: Private ordinary functions
compute-ptree: Private ordinary functions
computedp: Private ordinary functions
condition-handler: Private ordinary functions
condition-notify: Public compiler macros
condition-notify: Public ordinary functions
condition-wait: Public compiler macros
condition-wait: Public ordinary functions
cons-queue-count: Public ordinary functions
cons-queue-count/no-lock: Public ordinary functions
cons-queue-empty-p: Public ordinary functions
cons-queue-empty-p/no-lock: Public ordinary functions
cons-queue-full-p: Private ordinary functions
cons-queue-full-p/no-lock: Private ordinary functions
cons-queue-p: Private ordinary functions
constrain-return-type: Private ordinary functions
copy-%chain: Private ordinary functions
copy-%delay: Private ordinary functions
copy-%future: Private ordinary functions
copy-%promise: Private ordinary functions
copy-binding-datum: Private ordinary functions
copy-channel: Private ordinary functions
copy-cons-queue: Private ordinary functions
copy-counter: Private ordinary functions
copy-kernel: Private ordinary functions
copy-limiter: Private ordinary functions
copy-node: Private ordinary functions
copy-plan: Private ordinary functions
copy-promise-base: Private ordinary functions
copy-ptree: Private ordinary functions
copy-raw-queue: Private ordinary functions
copy-raw-queue: Private ordinary functions
copy-scheduler: Private ordinary functions
copy-spin-queue: Private ordinary functions
copy-timeout: Private ordinary functions
copy-vector-queue: Private ordinary functions
copy-worker: Private ordinary functions
copy-worker-info: Private ordinary functions
copy-worker-notifications: Private ordinary functions
copy-wrapped-error: Private ordinary functions
counter-p: Private ordinary functions
counter-value: Public ordinary functions
custom-declaration-p: Private ordinary functions

D
data: Private compiler macros
data: Private ordinary functions
dec-counter: Public ordinary functions
decl-spec->typed-vars: Private ordinary functions
decl-specs->typed-vars: Private ordinary functions
declaim-defpun: Public macros
declaration-information: Private ordinary functions
declarationp: Private ordinary functions
declares->decl-specs: Private ordinary functions
declares->typed-vars: Private ordinary functions
define-counter-fn: Private macros
define-defpun: Private macros
define-locking-fn: Private macros
define-locking-fn/base: Private macros
define-mod-inc-dec: Private macros
define-mod-incf-decf: Private macros
define-queue-fn: Private macros
define-queue-fn: Private macros
define-queue-fn: Private macros
define-quicksort-fn: Private macros
define-quicksort-fns: Private macros
define-reader: Private macros
define-readers: Private macros
define-simple-locking-fn: Private macros
define-slots-macrolet: Private macros
define-struct: Private macros
define-try-pop-queue: Private macros
define-with-slots-macro: Private macros
define-worker-info-reader: Private macros
defmacro/once: Public macros
defmacro/syms: Private macros
defpair: Public macros
defpun: Public macros
defpun*: Public macros
defpun/type: Public macros
defpun/type*: Public macros
defslots: Public macros
defslots-names: Private ordinary functions
defun/inline: Public macros
defun/type: Public macros
defun/type/inline: Public macros
defun/wrapper: Private macros
delay: Public macros
delete-registered-names: Private ordinary functions
delete-stale-registrations: Private ordinary functions
deprecated-timeout: Private ordinary functions
do-fast-receives: Public macros
do-indexes: Private macros
do-workers: Private macros
dosequence: Public macros

E
each-node: Private ordinary functions
end-kernel: Public ordinary functions
enter-worker-loop: Private ordinary functions
exec-task: Private macros
exec-task/non-worker: Private ordinary functions
exec-task/worker: Private ordinary functions

F
fill-workers: Private ordinary functions
find-min-length: Private ordinary functions
find-node: Private ordinary functions
find-num-parts: Private ordinary functions
force: Public ordinary functions
force-delay: Private ordinary functions
force-future: Private ordinary functions
force-promise: Private ordinary functions
freep: Private ordinary functions
fulfill: Public macros
fulfill-delay: Private ordinary functions
fulfill-future: Private ordinary functions
fulfill-object: Private ordinary functions
fulfill-plan/call: Private ordinary functions
fulfill-plan/error: Private ordinary functions
fulfill-plan/values: Private ordinary functions
fulfill-promise: Private ordinary functions
fulfilledp: Public ordinary functions
Function, %%%%.%chain.object: Private ordinary functions
Function, %%%%.%delay.fn: Private ordinary functions
Function, %%%%.%delay.lock: Private ordinary functions
Function, %%%%.%delay.result: Private ordinary functions
Function, %%%%.%future.canceledp: Private ordinary functions
Function, %%%%.%future.fn: Private ordinary functions
Function, %%%%.%future.lock: Private ordinary functions
Function, %%%%.%future.result: Private ordinary functions
Function, %%%%.%promise.availablep: Private ordinary functions
Function, %%%%.%promise.cvar: Private ordinary functions
Function, %%%%.%promise.lock: Private ordinary functions
Function, %%%%.%promise.result: Private ordinary functions
Function, %%%%.binding-datum.form: Private ordinary functions
Function, %%%%.binding-datum.future-result: Private ordinary functions
Function, %%%%.binding-datum.future-var: Private ordinary functions
Function, %%%%.binding-datum.vars: Private ordinary functions
Function, %%%%.channel.kernel: Private ordinary functions
Function, %%%%.channel.queue: Private ordinary functions
Function, %%%%.cons-queue.cvar: Private ordinary functions
Function, %%%%.cons-queue.impl: Private ordinary functions
Function, %%%%.cons-queue.lock: Private ordinary functions
Function, %%%%.defpun.quicksort/key/gran: Private ordinary functions
Function, %%%%.defpun.quicksort/key/no-gran: Private ordinary functions
Function, %%%%.defpun.quicksort/no-key/gran: Private ordinary functions
Function, %%%%.defpun.quicksort/no-key/no-gran: Private ordinary functions
Function, %%%%.kernel.alivep: Private ordinary functions
Function, %%%%.kernel.limiter-accept-task-p: Private ordinary functions
Function, %%%%.kernel.limiter-count: Private ordinary functions
Function, %%%%.kernel.limiter-lock: Private ordinary functions
Function, %%%%.kernel.scheduler: Private ordinary functions
Function, %%%%.kernel.use-caller-p: Private ordinary functions
Function, %%%%.kernel.worker-info: Private ordinary functions
Function, %%%%.kernel.workers: Private ordinary functions
Function, %%%%.kernel.workers-lock: Private ordinary functions
Function, %%%%.node.children: Private ordinary functions
Function, %%%%.node.children-done-p: Private ordinary functions
Function, %%%%.node.function: Private ordinary functions
Function, %%%%.node.id: Private ordinary functions
Function, %%%%.node.lock-level: Private ordinary functions
Function, %%%%.node.parents: Private ordinary functions
Function, %%%%.node.result: Private ordinary functions
Function, %%%%.plan.fn: Private ordinary functions
Function, %%%%.plan.lock: Private ordinary functions
Function, %%%%.plan.result: Private ordinary functions
Function, %%%%.promise-base.lock: Private ordinary functions
Function, %%%%.promise-base.result: Private ordinary functions
Function, %%%%.ptree.lock: Private ordinary functions
Function, %%%%.ptree.nodes: Private ordinary functions
Function, %%%%.ptree.pending: Private ordinary functions
Function, %%%%.ptree.queue: Private ordinary functions
Function, %%%%.raw-queue.count: Private ordinary functions
Function, %%%%.raw-queue.data: Private ordinary functions
Function, %%%%.raw-queue.start: Private ordinary functions
Function, %%%%.scheduler.low-priority-tasks: Private ordinary functions
Function, %%%%.scheduler.notify-count: Private ordinary functions
Function, %%%%.scheduler.random-index: Private ordinary functions
Function, %%%%.scheduler.spin-count: Private ordinary functions
Function, %%%%.scheduler.wait-count: Private ordinary functions
Function, %%%%.scheduler.wait-cvar: Private ordinary functions
Function, %%%%.scheduler.wait-lock: Private ordinary functions
Function, %%%%.scheduler.workers: Private ordinary functions
Function, %%%%.timeout.canceled-result: Private ordinary functions
Function, %%%%.timeout.lock: Private ordinary functions
Function, %%%%.timeout.thread: Private ordinary functions
Function, %%%%.vector-queue.impl: Private ordinary functions
Function, %%%%.vector-queue.lock: Private ordinary functions
Function, %%%%.vector-queue.notify-pop: Private ordinary functions
Function, %%%%.vector-queue.notify-push: Private ordinary functions
Function, %%%%.worker-info.bindings: Private ordinary functions
Function, %%%%.worker-info.context: Private ordinary functions
Function, %%%%.worker-info.name: Private ordinary functions
Function, %%%%.worker-notifications.exit-notification: Private ordinary functions
Function, %%%%.worker-notifications.handshake/from-worker: Private ordinary functions
Function, %%%%.worker-notifications.handshake/to-worker: Private ordinary functions
Function, %%%%.worker.exit-notification: Private ordinary functions
Function, %%%%.worker.handshake/from-worker: Private ordinary functions
Function, %%%%.worker.handshake/to-worker: Private ordinary functions
Function, %%%%.worker.index: Private ordinary functions
Function, %%%%.worker.running-category: Private ordinary functions
Function, %%%%.worker.tasks: Private ordinary functions
Function, %%%%.worker.thread: Private ordinary functions
Function, %%%%.wrapped-error.value: Private ordinary functions
Function, %call-with-task-handler: Private ordinary functions
Function, %chain-p: Private ordinary functions
Function, %delay-p: Private ordinary functions
Function, %fill-workers: Private ordinary functions
Function, %future-p: Private ordinary functions
Function, %kernel-worker-count: Private ordinary functions
Function, %make-channel: Private ordinary functions
Function, %make-cons-queue: Private ordinary functions
Function, %make-queue: Private ordinary functions
Function, %make-raw-queue: Private ordinary functions
Function, %make-spin-queue: Private ordinary functions
Function, %make-vector-queue: Private ordinary functions
Function, %make-worker: Private ordinary functions
Function, %mv-macrolet-bindings: Private ordinary functions
Function, %parse-options: Private ordinary functions
Function, %pdotimes: Private ordinary functions
Function, %preduce-partial: Private ordinary functions
Function, %promise-p: Private ordinary functions
Function, %time-remaining: Private ordinary functions
Function, %try-pop-cons-queue/no-lock/timeout: Private ordinary functions
Function, %try-pop-vector-queue/no-lock/timeout: Private ordinary functions
Function, (setf %%%%.%chain.object): Private ordinary functions
Function, (setf %%%%.%delay.fn): Private ordinary functions
Function, (setf %%%%.%delay.lock): Private ordinary functions
Function, (setf %%%%.%delay.result): Private ordinary functions
Function, (setf %%%%.%future.canceledp): Private ordinary functions
Function, (setf %%%%.%future.fn): Private ordinary functions
Function, (setf %%%%.%future.lock): Private ordinary functions
Function, (setf %%%%.%future.result): Private ordinary functions
Function, (setf %%%%.%promise.availablep):