The lparallel Reference Manual

Table of Contents

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 2.3 "Robert April" on Wed Mar 14 04:16:09 2018 GMT+0.


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

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


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

2 Systems

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


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

2.1 lparallel

Author

James M. Lawrence <llmjjmll@gmail.com>

License

BSD

Description

Parallelism for Common Lisp

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
Source

lparallel.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 lparallel/src

Parent

lparallel (system)

Location

src/

Components

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

3.2 lparallel/src/util

Parent

src (module)

Location

src/util/

Components

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

3.3 lparallel/src/spin-queue

Dependency

counter.lisp (file)

Parent

src (module)

Location

src/spin-queue/

Components

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

3.4 lparallel/src/kernel

Dependency

spin-queue (module)

Parent

src (module)

Location

src/kernel/

Components

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

3.5 lparallel/src/cognate

Dependency

defpun.lisp (file)

Parent

src (module)

Location

src/cognate/

Components

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

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


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 lparallel.asd

Location

lparallel.asd

Systems

lparallel (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 lparallel/src/util/package.lisp

Parent

util (module)

Location

src/util/package.lisp

Packages

lparallel.util


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 lparallel/src/util/config.lisp

Dependency

package.lisp (file)

Parent

util (module)

Location

src/util/config.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 lparallel/src/util/misc.lisp

Dependency

config.lisp (file)

Parent

util (module)

Location

src/util/misc.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 lparallel/src/util/defmacro.lisp

Dependency

misc.lisp (file)

Parent

util (module)

Location

src/util/defmacro.lisp

Exported Definitions

defmacro/once (macro)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 lparallel/src/util/defun.lisp

Dependency

defmacro.lisp (file)

Parent

util (module)

Location

src/util/defun.lisp

Exported Definitions
Internal Definitions

constrain-return-type (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 lparallel/src/util/defslots.lisp

Dependency

defun.lisp (file)

Parent

util (module)

Location

src/util/defslots.lisp

Exported Definitions

defslots (macro)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 lparallel/src/util/defpair.lisp

Dependency

defslots.lisp (file)

Parent

util (module)

Location

src/util/defpair.lisp

Exported Definitions

defpair (macro)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 lparallel/src/thread-util.lisp

Dependency

util (module)

Parent

src (module)

Location

src/thread-util.lisp

Packages

lparallel.thread-util

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 lparallel/src/raw-queue.lisp

Dependency

thread-util.lisp (file)

Parent

src (module)

Location

src/raw-queue.lisp

Packages

lparallel.raw-queue

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 lparallel/src/cons-queue.lisp

Dependency

raw-queue.lisp (file)

Parent

src (module)

Location

src/cons-queue.lisp

Packages

lparallel.cons-queue

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 lparallel/src/vector-queue.lisp

Dependency

cons-queue.lisp (file)

Parent

src (module)

Location

src/vector-queue.lisp

Packages

lparallel.vector-queue

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 lparallel/src/queue.lisp

Dependency

vector-queue.lisp (file)

Parent

src (module)

Location

src/queue.lisp

Packages

lparallel.queue

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 lparallel/src/counter.lisp

Dependency

queue.lisp (file)

Parent

src (module)

Location

src/counter.lisp

Packages

lparallel.counter

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

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

Parent

spin-queue (module)

Location

src/spin-queue/package.lisp

Packages

lparallel.spin-queue


Next: , Previous: , Up: Lisp files   [Contents][Index]

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

Dependency

package.lisp (file)

Parent

spin-queue (module)

Location

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

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.17 lparallel/src/kernel/package.lisp

Parent

kernel (module)

Location

src/kernel/package.lisp

Packages

lparallel.kernel


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.18 lparallel/src/kernel/specials.lisp

Dependency

package.lisp (file)

Parent

kernel (module)

Location

src/kernel/specials.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.19 lparallel/src/kernel/handling.lisp

Dependency

specials.lisp (file)

Parent

kernel (module)

Location

src/kernel/handling.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.20 lparallel/src/kernel/classes.lisp

Dependency

handling.lisp (file)

Parent

kernel (module)

Location

src/kernel/classes.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

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

Dependency

classes.lisp (file)

Parent

kernel (module)

Location

src/kernel/stealing-scheduler.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.22 lparallel/src/kernel/kill.lisp

Dependency

stealing-scheduler.lisp (file)

Parent

kernel (module)

Location

src/kernel/kill.lisp

Exported Definitions

kill-tasks (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.23 lparallel/src/kernel/core.lisp

Dependency

kill.lisp (file)

Parent

kernel (module)

Location

src/kernel/core.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.24 lparallel/src/kernel/timeout.lisp

Dependency

core.lisp (file)

Parent

kernel (module)

Location

src/kernel/timeout.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.25 lparallel/src/kernel-util.lisp

Dependency

kernel (module)

Parent

src (module)

Location

src/kernel-util.lisp

Packages

lparallel.kernel-util

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.26 lparallel/src/promise.lisp

Dependency

kernel-util.lisp (file)

Parent

src (module)

Location

src/promise.lisp

Packages

lparallel.promise

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.27 lparallel/src/ptree.lisp

Dependency

promise.lisp (file)

Parent

src (module)

Location

src/ptree.lisp

Packages

lparallel.ptree

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.28 lparallel/src/slet.lisp

Dependency

ptree.lisp (file)

Parent

src (module)

Location

src/slet.lisp

Packages

lparallel.slet

Exported Definitions

slet (macro)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.29 lparallel/src/defpun.lisp

Dependency

slet.lisp (file)

Parent

src (module)

Location

src/defpun.lisp

Packages

lparallel.defpun

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.30 lparallel/src/cognate/package.lisp

Parent

cognate (module)

Location

src/cognate/package.lisp

Packages

lparallel.cognate


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.31 lparallel/src/cognate/util.lisp

Dependency

package.lisp (file)

Parent

cognate (module)

Location

src/cognate/util.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.32 lparallel/src/cognate/option.lisp

Dependency

util.lisp (file)

Parent

cognate (module)

Location

src/cognate/option.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.33 lparallel/src/cognate/subdivide.lisp

Dependency

option.lisp (file)

Parent

cognate (module)

Location

src/cognate/subdivide.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.34 lparallel/src/cognate/pandor.lisp

Dependency

subdivide.lisp (file)

Parent

cognate (module)

Location

src/cognate/pandor.lisp

Exported Definitions
Internal Definitions

with-forms-submitted (macro)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.35 lparallel/src/cognate/plet.lisp

Dependency

pandor.lisp (file)

Parent

cognate (module)

Location

src/cognate/plet.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.36 lparallel/src/cognate/pmap.lisp

Dependency

plet.lisp (file)

Parent

cognate (module)

Location

src/cognate/pmap.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

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

Dependency

pmap.lisp (file)

Parent

cognate (module)

Location

src/cognate/pmap-open-coded.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.38 lparallel/src/cognate/pdotimes.lisp

Dependency

pmap-open-coded.lisp (file)

Parent

cognate (module)

Location

src/cognate/pdotimes.lisp

Exported Definitions

pdotimes (macro)

Internal Definitions

%pdotimes (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.39 lparallel/src/cognate/pquantifier.lisp

Dependency

pdotimes.lisp (file)

Parent

cognate (module)

Location

src/cognate/pquantifier.lisp

Exported Definitions
Internal Definitions

pquantifier (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.40 lparallel/src/cognate/preduce.lisp

Dependency

pquantifier.lisp (file)

Parent

cognate (module)

Location

src/cognate/preduce.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.41 lparallel/src/cognate/premove.lisp

Dependency

preduce.lisp (file)

Parent

cognate (module)

Location

src/cognate/premove.lisp

Exported Definitions
Internal Definitions

premove-if-not/list (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.42 lparallel/src/cognate/pfind.lisp

Dependency

premove.lisp (file)

Parent

cognate (module)

Location

src/cognate/pfind.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.43 lparallel/src/cognate/pcount.lisp

Dependency

pfind.lisp (file)

Parent

cognate (module)

Location

src/cognate/pcount.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.44 lparallel/src/cognate/psort.lisp

Dependency

pcount.lisp (file)

Parent

cognate (module)

Location

src/cognate/psort.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.45 lparallel/src/package.lisp

Dependency

cognate (module)

Parent

src (module)

Location

src/package.lisp

Packages

lparallel


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

5 Packages

Packages are listed by definition order.


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

5.1 lparallel.util

(private) Miscellaneous utilities.

Source

package.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

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

5.2 lparallel.thread-util

(private) Thread utilities.

Source

thread-util.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.3 lparallel.raw-queue

(private) Raw queue data structure.

Source

raw-queue.lisp (file)

Use List
Used By List

lparallel.cons-queue

Exported Definitions
Internal Definitions

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

5.4 lparallel.cons-queue

(private) Blocking infinite-capacity queue.

Source

cons-queue.lisp (file)

Use List
Used By List

lparallel.queue

Exported Definitions
Internal Definitions

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

5.5 lparallel.vector-queue

(private) Blocking fixed-capacity queue.

Source

vector-queue.lisp (file)

Use List
Used By List

lparallel.queue

Exported Definitions
Internal Definitions

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

5.6 lparallel.queue

Blocking FIFO queue for communication between threads.

Source

queue.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.7 lparallel.counter

(private) Atomic counter.

Source

counter.lisp (file)

Use List
Used By List

lparallel.kernel

Exported Definitions
Internal Definitions

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

5.8 lparallel.spin-queue

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

Source

package.lisp (file)

Use List
Used By List

lparallel.kernel

Exported Definitions
Internal Definitions

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

5.9 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 (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.10 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 (file)

Use List
Used By List

lparallel.cognate

Exported Definitions
Internal Definitions

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

5.11 lparallel.promise

Promises and futures.

Source

promise.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.12 lparallel.ptree

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

Source

ptree.lisp (file)

Use List
Used By List

lparallel

Exported Definitions
Internal Definitions

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

5.13 lparallel.slet

(private) Serial let.

Source

slet.lisp (file)

Use List
Used By List
Exported Definitions

slet (macro)

Internal Definitions

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

5.14 lparallel.defpun

Fine-grained parallelism.

Source

defpun.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.15 lparallel.cognate

Parallelized versions of some Common Lisp functions.

Source

package.lisp (file)

Use List
Used By List

lparallel

Exported Definitions
Internal Definitions

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

5.16 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 (file)

Use List

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

6 Definitions

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


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

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)

Special Variable: *full-optimize*
Package

lparallel.util

Source

config.lisp (file)

Special Variable: *kernel*

The current kernel, or nil.

Package

lparallel.kernel

Source

specials.lisp (file)

Special Variable: *kernel-spin-count*

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

Package

lparallel.kernel

Source

specials.lisp (file)

Special Variable: *normal-optimize*
Package

lparallel.util

Source

config.lisp (file)

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 (file)

Special Variable: *task-category*

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

Package

lparallel.kernel

Source

specials.lisp (file)

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 (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: alias-function ALIAS ORIG
Package

lparallel.util

Source

misc.lisp (file)

Macro: alias-macro ALIAS ORIG
Package

lparallel.util

Source

misc.lisp (file)

Macro: cas PLACE OLD NEW
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: declaim-defpun &rest NAMES

See ‘defpun’.

Package

lparallel.defpun

Source

defpun.lisp (file)

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 (file)

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 (file)

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 (file)

Macro: defpun* &rest ARGS

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

Package

lparallel.defpun

Source

defpun.lisp (file)

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 (file)

Macro: defpun/type* &rest ARGS

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

Package

lparallel.defpun

Source

defpun.lisp (file)

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 (file)

Macro: defun/inline NAME LAMBDA-LIST &body BODY

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

Package

lparallel.util

Source

defun.lisp (file)

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 (file)

Macro: defun/type/inline NAME LAMBDA-LIST ARG-TYPES RETURN-TYPE &body BODY
Package

lparallel.util

Source

defun.lisp (file)

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 (file)

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 (file)

Macro: dosequence (VAR SEQUENCE &optional RETURN) &body BODY
Package

lparallel.util

Source

misc.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Macro: repeat N &body BODY
Package

lparallel.util

Source

misc.lisp (file)

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 (file)

Macro: speculate &body BODY

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

Package

lparallel.promise

Source

promise.lisp (file)

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 (file)

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 (file)

Macro: with-lock-predicate/no-wait LOCK PREDICATE &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: with-lock-predicate/wait LOCK PREDICATE &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: with-locked-cons-queue QUEUE &body BODY
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

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 (file)

Macro: with-locked-vector-queue QUEUE &body BODY
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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 (file)

Macro: with-spin-lock-held ((ACCESS CONTAINER)) &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: with-submit-cancelable &body BODY
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

Macro: with-submit-counted &body BODY
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

Macro: with-submit-indexed COUNT ARRAY &body BODY
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

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 (file)

Macro: with-thread (&key BINDINGS NAME) &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Compiler macros

Compiler Macro: cancel-timeout &rest ARGS
Package

lparallel.kernel

Source

timeout.lisp (file)

Compiler Macro: condition-notify &rest ARGS
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Compiler Macro: condition-wait &rest ARGS
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Compiler Macro: make-channel &rest ARGS
Package

lparallel.kernel

Source

core.lisp (file)

Compiler Macro: make-queue &rest ARGS
Package

lparallel.queue

Source

queue.lisp (file)

Compiler Macro: partial-apply &rest ARGS
Package

lparallel.util

Source

misc.lisp (file)

Compiler Macro: pmap RESULT-TYPE FUNCTION &rest ARGS

Open-coding for 1 vector mapped to vector.

Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

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 (file)

Compiler Macro: psort* &rest ARGS
Package

lparallel.cognate

Source

psort.lisp (file)

Compiler Macro: submit-timeout &rest ARGS
Package

lparallel.kernel

Source

timeout.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 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 (file)

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 (file)

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 (file)

Function: chain OBJECT

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

Package

lparallel.promise

Source

promise.lisp (file)

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 (file)

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 (file)

Function: clear-ptree PTREE

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

Package

lparallel.ptree

Source

ptree.lisp (file)

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 (file)

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

Source

/home/quickbuilder/quicklisp/dists/quicklisp/software/bordeaux-threads-v0.8.5/src/impl-sbcl.lisp

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

Source

/home/quickbuilder/quicklisp/dists/quicklisp/software/bordeaux-threads-v0.8.5/src/impl-sbcl.lisp

Function: cons-queue-count ()
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: counter-value INSTANCE
Function: (setf counter-value) VALUE INSTANCE
Package

lparallel.counter

Source

counter.lisp (file)

Function: dec-counter COUNTER
Package

lparallel.counter

Source

counter.lisp (file)

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 (file)

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 (file)

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 (file)

Function: inc-counter COUNTER
Package

lparallel.counter

Source

counter.lisp (file)

Function: interact &rest PROMPT

Read from user and eval.

Package

lparallel.util

Source

misc.lisp (file)

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 (file)

Function: kernel-bindings ()

Return the bindings passed to ‘make-kernel’.

Package

lparallel.kernel

Source

core.lisp (file)

Function: kernel-context ()

Return the context passed to ‘make-kernel’.

Package

lparallel.kernel

Source

core.lisp (file)

Function: kernel-name ()

Return the name passed to ‘make-kernel’.

Package

lparallel.kernel

Source

core.lisp (file)

Function: kernel-worker-count ()

Return the number of workers in the current kernel.

Package

lparallel.kernel

Source

core.lisp (file)

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 (file)

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 (file)

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 (file)

Function: make-cons-queue &key INITIAL-CONTENTS
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: make-counter &optional VALUE
Package

lparallel.counter

Source

counter.lisp (file)

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 (file)

Function: make-ptree ()

Create a ptree instance.

Package

lparallel.ptree

Source

ptree.lisp (file)

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 (file)

Function: make-raw-queue &optional INITIAL-CAPACITY
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: make-spin-lock ()
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Function: make-spin-queue ()
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: make-vector-queue CAPACITY &key INITIAL-CONTENTS
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: partial-apply FUNCTION &rest ARGUMENTS

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

Package

lparallel.util

Source

/home/quickbuilder/quicklisp/dists/quicklisp/software/alexandria-20170830-git/functions.lisp

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 (file)

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 (file)

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 (file)

Function: peek-cons-queue ()
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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 (file)

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 (file)

Function: peek-raw-queue QUEUE
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: peek-spin-queue QUEUE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: peek-vector-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: pop-cons-queue ()
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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 (file)

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 (file)

Function: pop-raw-queue ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: pop-spin-queue ()
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: pop-vector-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: psort* &rest ARGS

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

Package

lparallel.cognate

Source

psort.lisp (file)

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 (file)

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 (file)

Function: push-cons-queue ()
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: push-queue OBJECT QUEUE

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

Package

lparallel.queue

Source

queue.lisp (file)

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 (file)

Function: push-raw-queue ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: push-spin-queue ()
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: push-vector-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: queue-count QUEUE

Return the number of elements in ‘queue’.

Package

lparallel.queue

Source

queue.lisp (file)

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 (file)

Function: queue-empty-p QUEUE

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

Package

lparallel.queue

Source

queue.lisp (file)

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 (file)

Function: queue-full-p QUEUE

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

Package

lparallel.queue

Source

queue.lisp (file)

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 (file)

Function: raw-queue-count QUEUE
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: raw-queue-empty-p QUEUE
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

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 (file)

Function: spin-queue-count QUEUE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: spin-queue-empty-p QUEUE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: submit-task CHANNEL FUNCTION &rest ARGS

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

Package

lparallel.kernel

Source

core.lisp (file)

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 (file)

Function: task-categories-running ()

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

Package

lparallel.kernel

Source

core.lisp (file)

Function: to-boolean X
Package

lparallel.util

Source

misc.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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 (file)

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 (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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 (file)

Function: unsplice FORM
Package

lparallel.util

Source

misc.lisp (file)

Function: vector-queue-capacity ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: vector-queue-count ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Conditions

Condition: kernel-creation-error ()

Error signaled when ‘make-kernel’ fails.

Package

lparallel.kernel

Source

handling.lisp (file)

Direct superclasses

error (condition)

Condition: no-kernel-error ()

Error signaled when ‘*kernel*’ is nil.

Package

lparallel.kernel

Source

handling.lisp (file)

Direct superclasses

error (condition)

Condition: ptree-lambda-list-keyword-error ()

Lambda list keywords found in function definition.

Package

lparallel.ptree

Source

ptree.lisp (file)

Direct superclasses

ptree-error (condition)

Direct methods

ptree-error-llks (method)

Direct slots
Slot: llks
Initargs

:llks

Readers

ptree-error-llks (generic function)

Condition: ptree-redefinition-error ()

Attempted to redefine a node’s function.

Package

lparallel.ptree

Source

ptree.lisp (file)

Direct superclasses

ptree-error (condition)

Condition: ptree-undefined-function-error ()

Attempted to execute a node which had no function.

Package

lparallel.ptree

Source

ptree.lisp (file)

Direct superclasses

ptree-error (condition)

Direct methods

ptree-error-refs (method)

Direct slots
Slot: refs
Initargs

:refs

Initform

(quote nil)

Readers

ptree-error-refs (generic function)

Condition: task-killed-error ()

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

Package

lparallel.kernel

Source

handling.lisp (file)

Direct superclasses

error (condition)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 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 (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: queue
Type

lparallel.queue:queue

Initform

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

Readers

%%%%.channel.queue (function)

Writers

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

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 (function)

Writers

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

Structure: cons-queue ()
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Direct superclasses

structure-object (structure)

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 (function)

Writers

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

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

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

Writers

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

Slot: cvar
Readers

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

Writers

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

Structure: counter ()
Package

lparallel.counter

Source

counter.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: value
Type

lparallel.counter:counter-value

Initform

0

Readers

counter-value (function)

Writers

(setf counter-value) (function)

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 (file)

Direct superclasses

limiter (structure)

Direct methods

print-object (method)

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 (function)

Writers

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

Slot: workers
Type

simple-vector

Initform

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

Readers

%%%%.kernel.workers (function)

Writers

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

Slot: workers-lock
Initform

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

Readers

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

Writers

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

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 (function)

Writers

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

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 (function)

Writers

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

Slot: alivep
Type

boolean

Initform

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

Readers

%%%%.kernel.alivep (function)

Writers

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

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 (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: nodes
Type

hash-table

Initform

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

Readers

%%%%.ptree.nodes (function)

Writers

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

Slot: queue
Type

lparallel.queue:queue

Initform

(lparallel.queue:make-queue)

Readers

%%%%.ptree.queue (function)

Writers

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

Slot: pending
Type

integer

Initform

0

Readers

%%%%.ptree.pending (function)

Writers

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

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

%%%%.ptree.lock (function)

Writers

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

Structure: raw-queue ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: head
Type

list

Initform

(error "no head")

Readers

head (function)

Writers

(setf head) (function)

Slot: tail
Type

list

Initform

(error "no tail")

Readers

tail (function)

Writers

(setf tail) (function)

Structure: spin-queue ()
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: head
Type

lparallel.spin-queue::node

Initform

(error "no head")

Readers

spin-queue-head (function)

Writers

(setf spin-queue-head) (function)

Slot: tail
Type

lparallel.spin-queue::node

Initform

(error "no tail")

Readers

spin-queue-tail (function)

Writers

(setf spin-queue-tail) (function)

Structure: vector-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Direct superclasses

structure-object (structure)

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 (function)

Writers

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

Slot: lock
Initform

(bordeaux-threads:make-lock)

Readers

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

Writers

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

Slot: notify-push
Readers

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

Writers

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

Slot: notify-pop
Readers

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

Writers

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


Previous: , Up: Exported definitions   [Contents][Index]

6.1.7 Types

Type: counter-value ()
Package

lparallel.counter

Source

counter.lisp (file)

Type: index ()
Package

lparallel.util

Source

misc.lisp (file)

Type: queue ()
Package

lparallel.queue

Source

queue.lisp (file)

Type: raw-queue-count ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)


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

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Constants

Constant: +checked-key+
Package

lparallel.defpun

Source

defpun.lisp (file)

Constant: +current-task+
Package

lparallel.kernel

Source

handling.lisp (file)

Constant: +dead-end+
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Constant: +dummy+
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Constant: +no-result+
Package

lparallel.promise

Source

promise.lisp (file)

Constant: +no-result+
Package

lparallel.ptree

Source

ptree.lisp (file)

Constant: +no-result+
Package

lparallel.defpun

Source

defpun.lisp (file)

Constant: +unchecked-key+
Package

lparallel.defpun

Source

defpun.lisp (file)

Constant: +worker-suicide-tag+
Package

lparallel.kernel

Source

kill.lisp (file)


Next: , Previous: , Up: Internal definitions   [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 (file)

Special Variable: *debugger-error*

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

Package

lparallel.kernel

Source

specials.lisp (file)

Special Variable: *erroring-workers*

Track debugger popups in order to kill them.

Package

lparallel.kernel

Source

specials.lisp (file)

Special Variable: *erroring-workers-lock*

Lock for *erroring-workers*.

Package

lparallel.kernel

Source

specials.lisp (file)

Special Variable: *handler-active-p*

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

Package

lparallel.kernel

Source

specials.lisp (file)

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 (file)

Special Variable: *make-limiter-data*
Package

lparallel.kernel

Source

specials.lisp (file)

Special Variable: *registered-names*
Package

lparallel.defpun

Source

defpun.lisp (file)

Special Variable: *registration-lock*
Package

lparallel.defpun

Source

defpun.lisp (file)

Special Variable: *standard-declaration-identifiers*
Package

lparallel.cognate

Source

plet.lisp (file)

Special Variable: *worker*

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

Package

lparallel.kernel

Source

specials.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Macros

Macro: %%%%plet KERNEL BINDINGS BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: %%%plet KERNEL PREDICATE SPAWN-COUNT BINDINGS BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: %%plet KERNEL PREDICATE BINDINGS BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: %defslots NAME SUPERS SLOTS OPTIONS
Package

lparallel.util

Source

defslots.lisp (file)

Macro: %plet KERNEL BINDINGS &body BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: %plet BINDINGS BODY
Package

lparallel.cognate

Source

plet.lisp (file)

Macro: %plet-if KERNEL PREDICATE BINDINGS &body BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: %slet BINDING-DATA FULL-BINDING-DATA NULL-BINDINGS BODY
Package

lparallel.slet

Source

slet.lisp (file)

Macro: accept-task-p KERNEL
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: bind (VARS FORM) &body BODY
Package

lparallel.slet

Source

slet.lisp (file)

Macro: check-symbols &rest SYMS
Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

Macro: define-counter-fn NAME OP
Package

lparallel.counter

Source

counter.lisp (file)

Macro: define-defpun DEFPUN DOC DEFUN &rest TYPES
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: define-locking-fn NAME ARGS ARG-TYPES RETURN-TYPE LOCK &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

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 (file)

Macro: define-mod-inc-dec NAME OP OP-RESULT-TYPE
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: define-mod-incf-decf NAME OP
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: define-queue-fn NAME ARG-TYPES RAW RETURN-TYPE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Macro: define-queue-fn NAME ARG-TYPES RAW RETURN-TYPE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Macro: define-queue-fn NAME PARAMS CONS-NAME VECTOR-NAME
Package

lparallel.queue

Source

queue.lisp (file)

Macro: define-quicksort-fn NAME CALL-KEY KEY KEY-TYPE GRAN GRAN-TYPE
Package

lparallel.cognate

Source

psort.lisp (file)

Macro: define-quicksort-fns ()
Package

lparallel.cognate

Source

psort.lisp (file)

Macro: define-reader PUBLIC PRIVATE TYPE STRUCT
Package

lparallel.util

Source

defslots.lisp (file)

Macro: define-readers STRUCT CONC-NAME SLOTS
Package

lparallel.util

Source

defslots.lisp (file)

Macro: define-simple-locking-fn NAME ARGS ARG-TYPES RETURN-TYPE LOCK &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: define-slots-macrolet PACKAGE CONC-NAME ENTRIES INSTANCE &body BODY
Package

lparallel.util

Source

defslots.lisp (file)

Macro: define-struct NAME SUPERS SLOTS OPTIONS CONC-NAME CONSTRUCTOR
Package

lparallel.util

Source

defslots.lisp (file)

Macro: define-try-pop-queue NAME CONS-NAME VECTOR-NAME
Package

lparallel.queue

Source

queue.lisp (file)

Macro: define-with-slots-macro NAME PACKAGE CONC-NAME
Package

lparallel.util

Source

defslots.lisp (file)

Macro: define-worker-info-reader NAME SLOT &optional RESULT
Package

lparallel.kernel

Source

core.lisp (file)

Macro: defmacro/syms NAME PARAMS &body BODY

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

Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

Macro: defun/wrapper WRAPPER-NAME IMPL-NAME LAMBDA-LIST &body BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: do-indexes (INDEX-VAR SIZE HOME-INDEX FROM-HOME-INDEX-P) &body BODY
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: do-workers (WORKER-VAR WORKERS HOME-INDEX FROM-HOME-INDEX-P) &body BODY
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: exec-task HERE-BINDING-DATUM
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: map-into/vector/1-vector/range DST FN SRC START END
Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

Macro: mod-dec K N
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: mod-decf PLACE N
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: mod-inc K N
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: mod-incf PLACE N
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: msetq VARS FORM
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: node-car NODE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Macro: node-cdr NODE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Macro: pmap-into/vector/1-vector DST FN SRC SIZE PARTS
Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

Macro: pop-plist LIST
Package

lparallel.cognate

Source

option.lisp (file)

Macro: repeat/fixnum COUNT &body BODY
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: scan-for-errors BINDING-DATA
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: spawn KERNEL TEMP-VARS FORM
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: spawn-tasks KERNEL SPAWN-BINDING-DATA
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: sync KERNEL SPAWN-BINDING-DATA
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: task-lambda &body BODY
Package

lparallel.kernel

Source

core.lisp (file)

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

Source

plet.lisp (file)

Macro: with-%chain-slots SLOTS INSTANCE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-%delay-slots SLOTS INSTANCE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-%future-slots SLOTS INSTANCE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-%promise-slots SLOTS INSTANCE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-abort-restart &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: with-binding-datum-slots SLOTS INSTANCE &body BODY
Package

lparallel.cognate

Source

plet.lisp (file)

Macro: with-channel-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

classes.lisp (file)

Macro: with-client-bindings BINDING-DATA NULL-BINDINGS &body BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: with-cons-queue-slots SLOTS INSTANCE &body BODY
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Macro: with-countdown (TIME) &body BODY
Package

lparallel.thread-util

Source

thread-util.lisp (file)

Macro: with-fill-workers-handler WORKERS &body BODY
Package

lparallel.kernel

Source

core.lisp (file)

Macro: with-forms-submitted FORMS &body BODY
Package

lparallel.cognate

Source

pandor.lisp (file)

Macro: with-kernel-slots ()
Package

lparallel.kernel

Source

classes.lisp (file)

Macro: with-lock-operation OPERATION PROMISE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-lock-predicates &key LOCK PREDICATE1 PREDICATE2 SUCCEED/LOCK SUCCEED/NO-LOCK FAIL
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: with-node-slots SLOTS INSTANCE &body BODY
Package

lparallel.ptree

Source

ptree.lisp (file)

Macro: with-parsed-options (ARGS SIZE PARTS) &body BODY
Package

lparallel.cognate

Source

option.lisp (file)

Macro: with-parts SEQ-SIZE PARTS-HINT &body BODY
Package

lparallel.cognate

Source

subdivide.lisp (file)

Macro: with-pfind-context SEQUENCE START END PARTS &body BODY
Package

lparallel.cognate

Source

pfind.lisp (file)

Macro: with-plan-slots SLOTS INSTANCE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-pop-success VAR QUEUE &body BODY
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Macro: with-preduce-context SIZE PARTS &body BODY
Package

lparallel.cognate

Source

preduce.lisp (file)

Macro: with-promise-base-slots SLOTS INSTANCE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-ptree-slots SLOTS INSTANCE &body BODY
Package

lparallel.ptree

Source

ptree.lisp (file)

Macro: with-raw-queue-slots SLOTS INSTANCE &body BODY
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Macro: with-scheduler-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

classes.lisp (file)

Macro: with-task-context &body BODY
Package

lparallel.kernel

Source

handling.lisp (file)

Macro: with-temp-bindings HERE-BINDING-DATUM SPAWN-BINDING-DATA &body BODY
Package

lparallel.defpun

Source

defpun.lisp (file)

Macro: with-timeout-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

timeout.lisp (file)

Macro: with-tracked-error CONDITION &body BODY
Package

lparallel.kernel

Source

handling.lisp (file)

Macro: with-unfulfilled-future/no-wait FUTURE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-unfulfilled/no-wait PROMISE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-unfulfilled/wait PROMISE &body BODY
Package

lparallel.promise

Source

promise.lisp (file)

Macro: with-vector-queue-slots SLOTS INSTANCE &body BODY
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Macro: with-worker-info-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

classes.lisp (file)

Macro: with-worker-notifications-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

classes.lisp (file)

Macro: with-worker-restarts &body BODY
Package

lparallel.kernel

Source

kill.lisp (file)

Macro: with-worker-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

classes.lisp (file)

Macro: with-wrapped-error-slots SLOTS INSTANCE &body BODY
Package

lparallel.kernel

Source

handling.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Compiler macros

Compiler Macro: alivep ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: binding-datum-vars &rest ARGS
Package

lparallel.cognate

Source

plet.lisp (file)

Compiler Macro: chain-object &rest ARGS
Package

lparallel.promise

Source

promise.lisp (file)

Compiler Macro: channel-kernel &rest ARGS
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: channel-queue &rest ARGS
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: data &rest ARGS
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Compiler Macro: id &rest ARGS
Package

lparallel.ptree

Source

ptree.lisp (file)

Compiler Macro: impl &rest ARGS
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Compiler Macro: impl &rest ARGS
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Compiler Macro: lock &rest ARGS
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Compiler Macro: lock &rest ARGS
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Compiler Macro: lock &rest ARGS
Package

lparallel.ptree

Source

ptree.lisp (file)

Compiler Macro: lock-level &rest ARGS
Package

lparallel.ptree

Source

ptree.lisp (file)

Compiler Macro: make-node &rest ARGS
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Compiler Macro: make-task-instance ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: nodes &rest ARGS
Package

lparallel.ptree

Source

ptree.lisp (file)

Compiler Macro: plan-fn &rest ARGS
Package

lparallel.promise

Source

promise.lisp (file)

Compiler Macro: raw-queue-count &rest ARGS
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Compiler Macro: result &rest ARGS
Package

lparallel.promise

Source

promise.lisp (file)

Compiler Macro: result &rest ARGS
Package

lparallel.ptree

Source

ptree.lisp (file)

Compiler Macro: running-category &rest ARGS
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: scheduler ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: task-category ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: task-fn ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: tasks &rest ARGS
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: thread &rest ARGS
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: use-caller-p ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: worker-index &rest ARGS
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: workers ()
Package

lparallel.kernel

Source

classes.lisp (file)

Compiler Macro: wrapped-error-value &rest ARGS
Package

lparallel.kernel

Source

handling.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Functions

Function: %%%%.%chain.object INSTANCE
Function: (setf %%%%.%chain.object) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%delay.fn INSTANCE
Function: (setf %%%%.%delay.fn) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%delay.lock INSTANCE
Function: (setf %%%%.%delay.lock) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%delay.result INSTANCE
Function: (setf %%%%.%delay.result) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%future.canceledp INSTANCE
Function: (setf %%%%.%future.canceledp) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%future.fn INSTANCE
Function: (setf %%%%.%future.fn) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%future.lock INSTANCE
Function: (setf %%%%.%future.lock) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%future.result INSTANCE
Function: (setf %%%%.%future.result) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%promise.availablep INSTANCE
Function: (setf %%%%.%promise.availablep) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%promise.cvar INSTANCE
Function: (setf %%%%.%promise.cvar) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%promise.lock INSTANCE
Function: (setf %%%%.%promise.lock) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.%promise.result INSTANCE
Function: (setf %%%%.%promise.result) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.binding-datum.form INSTANCE
Function: (setf %%%%.binding-datum.form) VALUE INSTANCE
Package

lparallel.cognate

Source

plet.lisp (file)

Function: %%%%.binding-datum.future-result INSTANCE
Function: (setf %%%%.binding-datum.future-result) VALUE INSTANCE
Package

lparallel.cognate

Source

plet.lisp (file)

Function: %%%%.binding-datum.future-var INSTANCE
Function: (setf %%%%.binding-datum.future-var) VALUE INSTANCE
Package

lparallel.cognate

Source

plet.lisp (file)

Function: %%%%.binding-datum.vars INSTANCE
Function: (setf %%%%.binding-datum.vars) VALUE INSTANCE
Package

lparallel.cognate

Source

plet.lisp (file)

Function: %%%%.channel.kernel INSTANCE
Function: (setf %%%%.channel.kernel) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.channel.queue INSTANCE
Function: (setf %%%%.channel.queue) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.cons-queue.cvar INSTANCE
Function: (setf %%%%.cons-queue.cvar) VALUE INSTANCE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: %%%%.cons-queue.impl INSTANCE
Function: (setf %%%%.cons-queue.impl) VALUE INSTANCE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: %%%%.cons-queue.lock INSTANCE
Function: (setf %%%%.cons-queue.lock) VALUE INSTANCE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.cognate

Source

psort.lisp (file)

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

lparallel.cognate

Source

psort.lisp (file)

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

lparallel.cognate

Source

psort.lisp (file)

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

lparallel.cognate

Source

psort.lisp (file)

Function: %%%%.kernel.alivep ()
Function: (setf %%%%.kernel.alivep) ()
Package

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.kernel.scheduler ()
Function: (setf %%%%.kernel.scheduler) ()
Package

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.kernel.worker-info ()
Function: (setf %%%%.kernel.worker-info) ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.kernel.workers ()
Function: (setf %%%%.kernel.workers) ()
Package

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.node.children INSTANCE
Function: (setf %%%%.node.children) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.node.children-done-p INSTANCE
Function: (setf %%%%.node.children-done-p) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.node.function INSTANCE
Function: (setf %%%%.node.function) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.node.id INSTANCE
Function: (setf %%%%.node.id) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.node.lock-level INSTANCE
Function: (setf %%%%.node.lock-level) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.node.parents INSTANCE
Function: (setf %%%%.node.parents) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.node.result INSTANCE
Function: (setf %%%%.node.result) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.plan.fn INSTANCE
Function: (setf %%%%.plan.fn) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.plan.lock INSTANCE
Function: (setf %%%%.plan.lock) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.plan.result INSTANCE
Function: (setf %%%%.plan.result) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.promise-base.lock INSTANCE
Function: (setf %%%%.promise-base.lock) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.promise-base.result INSTANCE
Function: (setf %%%%.promise-base.result) VALUE INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: %%%%.ptree.lock INSTANCE
Function: (setf %%%%.ptree.lock) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.ptree.nodes INSTANCE
Function: (setf %%%%.ptree.nodes) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.ptree.pending INSTANCE
Function: (setf %%%%.ptree.pending) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.ptree.queue INSTANCE
Function: (setf %%%%.ptree.queue) VALUE INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: %%%%.raw-queue.count INSTANCE
Function: (setf %%%%.raw-queue.count) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.raw-queue.data INSTANCE
Function: (setf %%%%.raw-queue.data) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.raw-queue.start INSTANCE
Function: (setf %%%%.raw-queue.start) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.scheduler.low-priority-tasks INSTANCE
Function: (setf %%%%.scheduler.low-priority-tasks) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.notify-count INSTANCE
Function: (setf %%%%.scheduler.notify-count) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.random-index INSTANCE
Function: (setf %%%%.scheduler.random-index) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.spin-count INSTANCE
Function: (setf %%%%.scheduler.spin-count) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.wait-count INSTANCE
Function: (setf %%%%.scheduler.wait-count) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.wait-cvar INSTANCE
Function: (setf %%%%.scheduler.wait-cvar) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.wait-lock INSTANCE
Function: (setf %%%%.scheduler.wait-lock) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.scheduler.workers INSTANCE
Function: (setf %%%%.scheduler.workers) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.timeout.canceled-result INSTANCE
Function: (setf %%%%.timeout.canceled-result) VALUE INSTANCE
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: %%%%.timeout.lock INSTANCE
Function: (setf %%%%.timeout.lock) VALUE INSTANCE
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: %%%%.timeout.thread INSTANCE
Function: (setf %%%%.timeout.thread) VALUE INSTANCE
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: %%%%.vector-queue.impl INSTANCE
Function: (setf %%%%.vector-queue.impl) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.vector-queue.lock INSTANCE
Function: (setf %%%%.vector-queue.lock) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.vector-queue.notify-pop INSTANCE
Function: (setf %%%%.vector-queue.notify-pop) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.vector-queue.notify-push INSTANCE
Function: (setf %%%%.vector-queue.notify-push) VALUE INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %%%%.worker-info.bindings INSTANCE
Function: (setf %%%%.worker-info.bindings) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker-info.context INSTANCE
Function: (setf %%%%.worker-info.context) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker-info.name INSTANCE
Function: (setf %%%%.worker-info.name) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker-notifications.exit-notification INSTANCE
Function: (setf %%%%.worker-notifications.exit-notification) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker-notifications.handshake/from-worker INSTANCE
Function: (setf %%%%.worker-notifications.handshake/from-worker) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker-notifications.handshake/to-worker INSTANCE
Function: (setf %%%%.worker-notifications.handshake/to-worker) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

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

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker.index INSTANCE
Function: (setf %%%%.worker.index) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker.running-category INSTANCE
Function: (setf %%%%.worker.running-category) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker.tasks INSTANCE
Function: (setf %%%%.worker.tasks) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.worker.thread INSTANCE
Function: (setf %%%%.worker.thread) VALUE INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: %%%%.wrapped-error.value INSTANCE
Function: (setf %%%%.wrapped-error.value) VALUE INSTANCE
Package

lparallel.kernel

Source

handling.lisp (file)

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

lparallel.kernel

Source

handling.lisp (file)

Function: %chain-p OBJECT
Package

lparallel.promise

Source

promise.lisp (file)

Function: %delay-p OBJECT
Package

lparallel.promise

Source

promise.lisp (file)

Function: %fill-workers WORKERS KERNEL
Package

lparallel.kernel

Source

core.lisp (file)

Function: %future-p OBJECT
Package

lparallel.promise

Source

promise.lisp (file)

Function: %kernel-worker-count ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: %make-channel &key FIXED-CAPACITY
Package

lparallel.kernel

Source

core.lisp (file)

Function: %make-cons-queue ()
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: %make-queue &key FIXED-CAPACITY INITIAL-CONTENTS
Package

lparallel.queue

Source

queue.lisp (file)

Function: %make-raw-queue ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: %make-spin-queue HEAD TAIL
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: %make-vector-queue CAPACITY
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: %make-worker INDEX TASKS
Package

lparallel.kernel

Source

core.lisp (file)

Function: %mv-macrolet-bindings TYPED-VARS MV-BINDING-DATUM
Package

lparallel.cognate

Source

plet.lisp (file)

Function: %parse-options ARGS
Package

lparallel.cognate

Source

option.lisp (file)

Function: %pdotimes SIZE PARTS FN
Package

lparallel.cognate

Source

pdotimes.lisp (file)

Function: %preduce-partial FUNCTION SEQUENCE START SIZE PARTS &rest KEYWORD-ARGS
Package

lparallel.cognate

Source

preduce.lisp (file)

Function: %promise-p OBJECT
Package

lparallel.promise

Source

promise.lisp (file)

Function: %time-remaining START TIMEOUT
Package

lparallel.thread-util

Source

thread-util.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: alivep ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: all-binding-vars BINDING-DATA NULL-BINDINGS
Package

lparallel.cognate

Source

plet.lisp (file)

Function: binding-datum-p OBJECT
Package

lparallel.cognate

Source

plet.lisp (file)

Function: binding-datum-vars INSTANCE
Package

lparallel.cognate

Source

plet.lisp (file)

Function: binding-decl-spec TYPED-VARS VAR
Package

lparallel.cognate

Source

plet.lisp (file)

Function: binding-decl-specs TYPED-VARS VARS
Package

lparallel.cognate

Source

plet.lisp (file)

Function: call-impl-fn ()
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: call-inside-worker ()
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: call-quicksort VEC LO HI COMPARE GRANULARITY KEY
Package

lparallel.cognate

Source

psort.lisp (file)

Function: call-with-locked-cons-queue FN QUEUE
Package

lparallel.queue

Source

queue.lisp (file)

Function: call-with-locked-queue FN QUEUE
Package

lparallel.queue

Source

queue.lisp (file)

Function: call-with-locked-vector-queue FN QUEUE
Package

lparallel.queue

Source

queue.lisp (file)

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

lparallel.kernel

Source

handling.lisp (file)

Function: call-with-temp-kernel FN &rest ARGS
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

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

lparallel.defpun

Source

defpun.lisp (file)

Function: call-with-tracked-error CONDITION BODY-FN
Package

lparallel.kernel

Source

handling.lisp (file)

Function: call-with-worker-context FN WORKER-CONTEXT KERNEL WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: chain-object INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: channel-kernel INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: channel-p OBJECT
Package

lparallel.kernel

Source

classes.lisp (file)

Function: channel-queue INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: check-node NODE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: children-done-p ()
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: clear-node NODE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: clear-node-error NODE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: client-vars BINDING-DATA
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: compute-node NODE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: compute-ptree ROOT PTREE KERNEL
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: computedp ()
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: condition-handler CONDITION

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

Package

lparallel.kernel

Source

handling.lisp (file)

Function: cons-queue-full-p QUEUE
Package

lparallel.queue

Source

queue.lisp (file)

Function: cons-queue-full-p/no-lock QUEUE
Package

lparallel.queue

Source

queue.lisp (file)

Function: cons-queue-p OBJECT
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: constrain-return-type RETURN-TYPE
Package

lparallel.util

Source

defun.lisp (file)

Function: copy-%chain INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: copy-%delay INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: copy-%future INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: copy-%promise INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: copy-binding-datum INSTANCE
Package

lparallel.cognate

Source

plet.lisp (file)

Function: copy-channel INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-cons-queue INSTANCE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: copy-counter INSTANCE
Package

lparallel.counter

Source

counter.lisp (file)

Function: copy-kernel ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-limiter ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-node INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: copy-plan INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: copy-promise-base INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: copy-ptree INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: copy-raw-queue ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: copy-raw-queue INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: copy-scheduler INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-spin-queue INSTANCE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: copy-timeout INSTANCE
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: copy-vector-queue INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: copy-worker INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-worker-info INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-worker-notifications INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: copy-wrapped-error INSTANCE
Package

lparallel.kernel

Source

handling.lisp (file)

Function: counter-p OBJECT
Package

lparallel.counter

Source

counter.lisp (file)

Function: custom-declaration-p SYMBOL ENV
Package

lparallel.cognate

Source

plet.lisp (file)

Function: data INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: decl-spec->typed-vars DECL-SPEC ENV
Package

lparallel.cognate

Source

plet.lisp (file)

Function: decl-specs->typed-vars DECL-SPECS ENV
Package

lparallel.cognate

Source

plet.lisp (file)

Function: declaration-information DECL ENV
Package

lparallel.cognate

Source

plet.lisp (file)

Function: declarationp SYMBOL ENV
Package

lparallel.cognate

Source

plet.lisp (file)

Function: declares->decl-specs DECLARES
Package

lparallel.cognate

Source

plet.lisp (file)

Function: declares->typed-vars DECLARES ENV
Package

lparallel.cognate

Source

plet.lisp (file)

Function: defslots-names NAME
Package

lparallel.util

Source

defslots.lisp (file)

Function: delete-registered-names NAMES
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: delete-stale-registrations ()
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: deprecated-timeout ()
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: each-node PTREE FN
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: enter-worker-loop KERNEL WORKER
Package

lparallel.kernel

Source

core.lisp (file)

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

lparallel.kernel

Source

core.lisp (file)

Function: exec-task/worker ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: fill-workers WORKERS KERNEL
Package

lparallel.kernel

Source

core.lisp (file)

Function: find-min-length SEQS
Package

lparallel.cognate

Source

util.lisp (file)

Function: find-node ()
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: find-num-parts SIZE PARTS-HINT
Package

lparallel.cognate

Source

subdivide.lisp (file)

Function: force-delay DELAY
Package

lparallel.promise

Source

promise.lisp (file)

Function: force-future FUTURE
Package

lparallel.promise

Source

promise.lisp (file)

Function: force-promise PROMISE
Package

lparallel.promise

Source

promise.lisp (file)

Function: freep ()
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: fulfill-delay DELAY CLIENT-FN
Package

lparallel.promise

Source

promise.lisp (file)

Function: fulfill-future FUTURE CLIENT-FN
Package

lparallel.promise

Source

promise.lisp (file)

Function: fulfill-object OBJECT CLIENT-FN
Package

lparallel.promise

Source

promise.lisp (file)

Function: fulfill-plan/call PLAN
Package

lparallel.promise

Source

promise.lisp (file)

Function: fulfill-plan/error PLAN ERR
Package

lparallel.promise

Source

promise.lisp (file)

Function: fulfill-plan/values PLAN VALUES
Package

lparallel.promise

Source

promise.lisp (file)

Function: fulfill-promise PROMISE CLIENT-FN
Package

lparallel.promise

Source

promise.lisp (file)

Function: future-let-binding BINDING-DATUM
Package

lparallel.cognate

Source

plet.lisp (file)

Function: future-let-bindings BINDING-DATA
Package

lparallel.cognate

Source

plet.lisp (file)

Function: future-macrolet-binding TYPED-VARS BINDING-DATUM
Package

lparallel.cognate

Source

plet.lisp (file)

Function: future-macrolet-bindings TYPED-VARS BINDING-DATA
Package

lparallel.cognate

Source

plet.lisp (file)

Function: get-parts-hint PARTS-HINT
Package

lparallel.cognate

Source

option.lisp (file)

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

lparallel.thread-util

Source

thread-util.lisp (file)

Function: handshake/from-worker/finish WORKER STATUS
Package

lparallel.kernel

Source

core.lisp (file)

Function: handshake/from-worker/start WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: handshake/to-worker/finish WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: handshake/to-worker/start WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: head ()
Function: (setf head) ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: id INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: impl INSTANCE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: impl INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: indexing-wrapper ARRAY INDEX FUNCTION ARGS
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

Function: initial-limiter-count THREAD-COUNT
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: item-predicate ITEM TEST TEST-NOT
Package

lparallel.cognate

Source

util.lisp (file)

Function: kernel-info KERNEL
Package

lparallel.kernel

Source

core.lisp (file)

Function: kernel-p ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: kill KERNEL CATEGORY
Package

lparallel.kernel

Source

kill.lisp (file)

Function: kill-errors ()
Package

lparallel.kernel

Source

kill.lisp (file)

Function: kill-errors-report STREAM
Package

lparallel.kernel

Source

kill.lisp (file)

Function: limiter-accept-task-p ()
Function: (setf limiter-accept-task-p) ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: limiter-count ()
Function: (setf limiter-count) ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: limiter-lock ()
Function: (setf limiter-lock) ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: limiter-p ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: lock INSTANCE
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: lock INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: lock INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: lock-level INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: lock-node ()
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: lookup-all ITEM ALIST &key TEST
Package

lparallel.cognate

Source

plet.lisp (file)

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

lparallel.promise

Source

promise.lisp (file)

Function: make-%delay-instance &key (RESULT RESULT) (LOCK LOCK) (FN FN)
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-%future-instance &key (RESULT RESULT) (LOCK LOCK) (FN FN) (CANCELEDP CANCELEDP)
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-%promise-instance &key (RESULT RESULT) (LOCK LOCK) (CVAR CVAR) (AVAILABLEP AVAILABLEP)
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-all-bindings KERNEL BINDINGS
Package

lparallel.kernel

Source

core.lisp (file)

Function: make-binding-data BINDINGS
Package

lparallel.slet

Source

slet.lisp (file)

Function: make-binding-data BINDINGS
Package

lparallel.cognate

Source

plet.lisp (file)

Function: make-binding-datum MV-BINDING
Package

lparallel.slet

Source

slet.lisp (file)

Function: make-binding-datum-instance &key (FUTURE-RESULT FUTURE-RESULT) (FUTURE-VAR FUTURE-VAR) (FORM FORM) (VARS VARS)
Package

lparallel.cognate

Source

plet.lisp (file)

Function: make-channel-instance &key (QUEUE QUEUE) (KERNEL KERNEL)
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-channeled-task ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: make-cons-queue-instance &key (IMPL IMPL) (LOCK LOCK) (CVAR CVAR)
Package

lparallel.cons-queue

Source

cons-queue.lisp (file)

Function: make-debugger-hook ()

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

Package

lparallel.kernel

Source

handling.lisp (file)

Function: make-future FN
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-future-task ()
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-input-parts SEQUENCES SIZE PARTS-HINT

Subdivide and interleave sequences for parallel mapping.

Package

lparallel.cognate

Source

subdivide.lisp (file)

Function: make-kernel-instance ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-limiter ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-limiter-data THREAD-COUNT
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: make-mv-binding-datum MV-BINDING
Package

lparallel.cognate

Source

plet.lisp (file)

Function: make-node SE1 SE2

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

Package

lparallel.spin-queue

Source

SYS:SRC;CODE;LIST.LISP (not found)

Function: make-node-instance &key (ID ID) (FUNCTION FUNCTION) (CHILDREN CHILDREN) (PARENTS PARENTS) (LOCK-LEVEL LOCK-LEVEL) (CHILDREN-DONE-P CHILDREN-DONE-P) (RESULT RESULT)
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: make-node-task QUEUE NODE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: make-parts RESULT SIZE PARTS-HINT &key SLICEP
Package

lparallel.cognate

Source

subdivide.lisp (file)

Function: make-plan-instance &key (RESULT RESULT) (LOCK LOCK) (FN FN)
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-promise-base-instance &key (RESULT RESULT) (LOCK LOCK)
Package

lparallel.promise

Source

promise.lisp (file)

Function: make-ptree-instance &key (NODES NODES) (QUEUE QUEUE) (PENDING PENDING) (LOCK LOCK)
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: make-raw-queue CAPACITY
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: make-raw-queue-instance &key (DATA DATA) (START START) (COUNT COUNT)
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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 (file)

Function: make-scheduler WORKERS SPIN-COUNT
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Function: make-scheduler-instance &key (WORKERS WORKERS) (WAIT-CVAR WAIT-CVAR) (WAIT-LOCK WAIT-LOCK) (WAIT-COUNT WAIT-COUNT) (NOTIFY-COUNT NOTIFY-COUNT) (SPIN-COUNT SPIN-COUNT) (RANDOM-INDEX RANDOM-INDEX) (LOW-PRIORITY-TASKS LOW-PRIORITY-TASKS)
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-sv-binding-datum SV-BINDING
Package

lparallel.cognate

Source

plet.lisp (file)

Function: make-task ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: make-task-instance SE1 SE2

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

Package

lparallel.kernel

Source

SYS:SRC;CODE;LIST.LISP (not found)

Function: make-temp-var VAR
Package

lparallel.slet

Source

slet.lisp (file)

Function: make-timeout-instance &key (CANCELED-RESULT CANCELED-RESULT) (THREAD THREAD) (LOCK LOCK)
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: make-vector-queue-instance &key (IMPL IMPL) (LOCK LOCK) (NOTIFY-PUSH NOTIFY-PUSH) (NOTIFY-POP NOTIFY-POP)
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: make-worker KERNEL INDEX TASKS
Package

lparallel.kernel

Source

core.lisp (file)

Function: make-worker-info-instance &key (BINDINGS BINDINGS) (CONTEXT CONTEXT) (NAME NAME)
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-worker-instance &key (HANDSHAKE/FROM-WORKER HANDSHAKE/FROM-WORKER) (HANDSHAKE/TO-WORKER HANDSHAKE/TO-WORKER) (EXIT-NOTIFICATION EXIT-NOTIFICATION) (THREAD THREAD) (RUNNING-CATEGORY RUNNING-CATEGORY) (INDEX INDEX) (TASKS TASKS)
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-worker-notifications-instance &key (HANDSHAKE/FROM-WORKER HANDSHAKE/FROM-WORKER) (HANDSHAKE/TO-WORKER HANDSHAKE/TO-WORKER) (EXIT-NOTIFICATION EXIT-NOTIFICATION)
Package

lparallel.kernel

Source

classes.lisp (file)

Function: make-worker-thread KERNEL WORKER NAME BINDINGS
Package

lparallel.kernel

Source

core.lisp (file)

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

lparallel.kernel

Source

handling.lisp (file)

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 (file)

Function: map-nil &rest ARGS
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: maplist-into RESULT-LIST FN &rest LISTS

A variation of map-into.

Package

lparallel.cognate

Source

pmap.lisp (file)

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

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Function: midpoint ()
Package

lparallel.cognate

Source

psort.lisp (file)

Function: mv-macrolet-bindings TYPED-VARS MV-BINDING-DATA
Package

lparallel.cognate

Source

plet.lisp (file)

Function: next-task ()
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Function: node-p OBJECT
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: nodes INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: notify-exit WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: parse-bindings BINDINGS
Package

lparallel.slet

Source

slet.lisp (file)

Function: parse-defslots SUPERS SLOTS OPTIONS
Package

lparallel.util

Source

defslots.lisp (file)

Function: parse-options ARGS
Package

lparallel.cognate

Source

option.lisp (file)

Function: partition PREDICATE LIST
Package

lparallel.cognate

Source

plet.lisp (file)

Function: peek-raw-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: pfind-if/list PREDICATE SEQUENCE &key FROM-END START END KEY PARTS
Package

lparallel.cognate

Source

pfind.lisp (file)

Function: pfind-if/vector PREDICATE SEQUENCE &key FROM-END START END KEY PARTS
Package

lparallel.cognate

Source

pfind.lisp (file)

Function: plan-fn INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: plan-p OBJECT
Package

lparallel.promise

Source

promise.lisp (file)

Function: plist-keys PLIST
Package

lparallel.util

Source

defslots.lisp (file)

Function: plist-values-for-key PLIST TARGET-KEY
Package

lparallel.util

Source

defslots.lisp (file)

Function: pmap-into/parsed MAP-INTO RESULT-SEQ FN SEQS SIZE PARTS-HINT
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap-into/parts MAP-INTO RESULT-SEQ FN SEQS SIZE PARTS-HINT
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap-into/powder MAP-INTO RESULT-SEQ FN SEQS SIZE
Package

lparallel.cognate

Source

pmap.lisp (file)

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 (file)

Function: pmap-into/powder/list MAP RESULT-SEQ FN SEQS SIZE
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap-into/unparsed MAP-INTO RESULT-SEQ FN SEQS
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap-iterate MAP FN SEQS SIZE PARTS-HINT
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap-iterate/parts MAP FN SEQS SIZE PARTS-HINT
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap-iterate/powder MAP FN SEQS SIZE
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap/parsed RESULT-TYPE FUNCTION SEQUENCES SIZE PARTS-HINT
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pmap/unparsed RESULT-TYPE FUNCTION SEQUENCES
Package

lparallel.cognate

Source

pmap.lisp (file)

Function: pop-raw-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: pquantifier QUANTIFIER PREDICATE SEQUENCES BAIL
Package

lparallel.cognate

Source

pquantifier.lisp (file)

Function: preduce-partial/list FUNCTION SEQUENCE START SIZE PARTS &rest KEYWORD-ARGS
Package

lparallel.cognate

Source

preduce.lisp (file)

Function: preduce-partial/vector FUNCTION SEQUENCE START SIZE PARTS &rest KEYWORD-ARGS
Package

lparallel.cognate

Source

preduce.lisp (file)

Function: preduce/common FUNCTION SEQUENCE SUBSIZE &key KEY FROM-END START END INITIAL-VALUE PARTS RECURSE PARTIAL
Package

lparallel.cognate

Source

preduce.lisp (file)

Function: premove-if-not/list TEST LIST FROM-END START END KEY PARTS
Package

lparallel.cognate

Source

premove.lisp (file)

Function: primary-temp-vars BINDING-DATA
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: promise-base-p OBJECT
Package

lparallel.promise

Source

promise.lisp (file)

Function: propagate-error ()
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: ptree-p OBJECT
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: push-raw-queue ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Function: quicksort/key/gran VEC LO HI COMPARE GRAN3 KEY2
Package

lparallel.cognate

Source

psort.lisp (file)

Function: quicksort/key/no-gran VEC LO HI COMPARE KEY2
Package

lparallel.cognate

Source

psort.lisp (file)

Function: quicksort/no-key/gran VEC LO HI COMPARE GRAN3
Package

lparallel.cognate

Source

psort.lisp (file)

Function: quicksort/no-key/no-gran VEC LO HI COMPARE
Package

lparallel.cognate

Source

psort.lisp (file)

Function: quoted-vector-type-p FORM
Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

Function: quotedp FORM
Package

lparallel.cognate

Source

pmap-open-coded.lisp (file)

Function: raw-queue-capacity ()
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: raw-queue-count INSTANCE
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: raw-queue-p ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: raw-queue-p OBJECT
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: receive-results CHANNEL COUNT FN
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

Function: register-fn NAME
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: register-name NAME
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: registered-fn-p NAME
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: registered-macrolets KERNEL
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: replace-error PROMISE
Package

lparallel.promise

Source

promise.lisp (file)

Function: replace-worker KERNEL WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: result INSTANCE
Package

lparallel.promise

Source

promise.lisp (file)

Function: result INSTANCE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: running-category INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: schedule-task ()
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Function: scheduler ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: scheduler-p OBJECT
Package

lparallel.kernel

Source

classes.lisp (file)

Function: shutdown CHANNEL KERNEL
Package

lparallel.kernel

Source

core.lisp (file)

Function: spin-queue-head INSTANCE
Function: (setf spin-queue-head) VALUE INSTANCE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: spin-queue-p OBJECT
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: spin-queue-tail INSTANCE
Function: (setf spin-queue-tail) VALUE INSTANCE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

Function: steal-task ()
Package

lparallel.kernel

Source

stealing-scheduler.lisp (file)

Function: steal-until-receive-result CHANNEL WORKER FN
Package

lparallel.kernel-util

Source

kernel-util.lisp (file)

Function: steal-work ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: subdivide-array ARRAY SIZE PARTS-HINT
Package

lparallel.cognate

Source

subdivide.lisp (file)

Function: subdivide-list LIST SIZE PARTS-HINT
Package

lparallel.cognate

Source

subdivide.lisp (file)

Function: subdivide-list/slice LIST SIZE PARTS-HINT
Package

lparallel.cognate

Source

subdivide.lisp (file)

Function: submit-node NODE QUEUE KERNEL
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: submit-raw-task TASK KERNEL
Package

lparallel.kernel

Source

core.lisp (file)

Function: subsize SEQ SIZE START END
Package

lparallel.cognate

Source

util.lisp (file)

Function: symbolicate/no-intern &rest STRING-DESIGNATORS

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

Package

lparallel.util

Source

misc.lisp (file)

Function: symbolicate/package PACKAGE &rest STRING-DESIGNATORS

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

Package

lparallel.util

Source

misc.lisp (file)

Function: tail ()
Function: (setf tail) ()
Package

lparallel.raw-queue

Source

raw-queue.lisp (file)

Function: task-category LIST

Return all but the first object in a list.

Package

lparallel.kernel

Source

SYS:SRC;CODE;LIST.LISP (not found)

Function: task-fn LIST

Return the 1st object in a list.

Package

lparallel.kernel

Source

SYS:SRC;CODE;LIST.LISP (not found)

Function: tasks INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: temp-vars BINDING-DATA
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: thread INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: timeout-p OBJECT
Package

lparallel.kernel

Source

timeout.lisp (file)

Function: track-exit ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: transfer-error-report STREAM
Package

lparallel.kernel

Source

handling.lisp (file)

Function: transfer-error-restart &optional ERR
Package

lparallel.kernel

Source

handling.lisp (file)

Function: try-each-elem FUN QUEUE
Package

lparallel.spin-queue

Source

cas-spin-queue.lisp (file)

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

lparallel.cons-queue

Source

cons-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: unchecked-name NAME
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: unknown-typed-vars TYPED-VARS BINDING-DATA NULL-BINDINGS
Package

lparallel.cognate

Source

plet.lisp (file)

Function: unlock-node ()
Package

lparallel.ptree

Source

ptree.lisp (file)

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 (file)

Function: update-limiter-count ()
Package

lparallel.defpun

Source

defpun.lisp (file)

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

lparallel.defpun

Source

defpun.lisp (file)

Function: use-caller-p ()
Package

lparallel.kernel

Source

classes.lisp (file)

Function: valid-registered-fn-p NAME
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: valid-registered-name-p NAME
Package

lparallel.defpun

Source

defpun.lisp (file)

Function: var-type VAR TYPED-VARS
Package

lparallel.cognate

Source

plet.lisp (file)

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

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: vector-queue-p OBJECT
Package

lparallel.vector-queue

Source

vector-queue.lisp (file)

Function: wait-for-compute PTREE
Package

lparallel.ptree

Source

ptree.lisp (file)

Function: wait-for-worker WORKER
Package

lparallel.kernel

Source

core.lisp (file)

Function: worker-index INSTANCE
Package

lparallel.kernel

Source

classes.lisp (file)

Function: worker-info-p OBJECT
Package

lparallel.kernel

Source

classes.lisp (file)

Function: worker-loop ()
Package

lparallel.kernel

Source

core.lisp (file)

Function: worker-notifications-p OBJECT
Package

lparallel.kernel

Source

classes.lisp (file)

Function: worker-p OBJECT
Package

lparallel.kernel

Source

classes.lisp (file)

Function: workers ()
Package

lparallel.kernel

Source

classes.lisp (file)

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 (file)

Function: wrapped-error-p OBJECT
Package

lparallel.kernel

Source

handling.lisp (file)

Function: wrapped-error-value INSTANCE
Package

lparallel.kernel

Source

handling.lisp (file)

Function: zip-repeat FN LIST OBJECT
Package

lparallel.cognate

Source

plet.lisp (file)

Function: zip/vector SEQS
Package

lparallel.cognate

Source

util.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.6 Generic functions

Generic Function: ptree-error-id CONDITION
Package

lparallel.ptree

Methods
Method: ptree-error-id (CONDITION ptree-error)
Source

ptree.lisp (file)