The petalisp Reference Manual

Source

Methods

Method: backend-compute ((testing-backend testing-backend) (data-structures list)) ¶

Source: testing-backend.lisp.

Method: backend-compute ((ir-backend ir-backend) (lazy-arrays list)) ¶

Source: ir-backend.lisp.

Method: backend-compute ((backend reference-backend) (lazy-arrays list)) ¶

Source: reference-backend.lisp.

Method: backend-compute ((backend backend) (lazy-arrays list)) ¶

Method: backend-compute ((backend backend) (lazy-arrays null)) ¶

Generic Function: backend-compute-asynchronously (backend lazy-arrays) ¶

Returns a request object that can be used to wait until all of the supplied lazy arrays have been computed.

Package

Source

Methods

Method: backend-compute-asynchronously ((backend backend) (lazy-arrays list)) ¶

Method: backend-compute-asynchronously ((backend backend) (lazy-arrays null)) ¶

Generic Reader: backend-debug-flag (backend) ¶

Returns whether the supplied backend runs in debug mode, where it trades performance for ease of debugging.

Package

Source

Methods

Reader Method: backend-debug-flag ((backend backend)) ¶

automatically generated reader method

Target Slot: %debug-flag.

Generic Writer: (setf backend-debug-flag) (backend) ¶

Set the backend’s debug flag to true or false.

Package

Source

Methods

Writer Method: (setf backend-debug-flag) ((backend backend)) ¶

automatically generated writer method

Target Slot: %debug-flag.

Generic Function: backend-evaluator (backend unknowns lazy-arrays) ¶

For a supplied backend, a list of unknowns of length N, and a list of
lazy arrays of length K, returns a function with K plus N arguments that returns, as multiple values, the K array values obtained by computing the supplied arrays after replacing the Ith unknown with the supplied argument in position K plus I.

The first K arguments of the resulting evaluator function specify which storage to use for the results, where a value of NIL indicates that the corresponding result is a freshly allocated array, and a value that is an array causes the result to be written to that array. The remaining N arguments specify the data that takes the place of the corresponding unknowns. Signals an error if any of the arguments of an evaluator has a different shape or element type from the corresponding result or unknown.

Package

Source

Methods

Method: backend-evaluator ((backend backend) (unknowns list) (lazy-arrays list)) ¶

Source: evaluator.lisp.

Method: backend-evaluator ((backend backend) (unknowns list) (lazy-arrays list)) ¶

Method: backend-evaluator ((backend backend) (unknowns list) (lazy-arrays null)) ¶

Method: backend-evaluator :before ((backend backend) (unknowns list) (lazy-arrays list)) ¶

Generic Function: backendp (object) ¶

Returns whether the supplied object is a backend.

Package

Source

Methods

Method: backendp ((backend backend)) ¶

Method: backendp (object) ¶

Generic Function: compile-blueprint (client blueprint) ¶

Returns a function that is a suitable return value for compiling a kernel that has the supplied blueprint.

Package

Source

Methods

Method: compile-blueprint ((client cuda-compiler-mixin) blueprint) ¶

Source: mixins.lisp.

Method: compile-blueprint ((client cpp-compiler-mixin) blueprint) ¶

Source: mixins.lisp.

Method: compile-blueprint ((client lisp-plus-cpp-compiler-mixin) blueprint) ¶

Source: mixins.lisp.

Method: compile-blueprint ((client lisp-compiler-mixin) blueprint) ¶

Source: mixins.lisp.

Method: compile-blueprint ((client lisp-interpreter-mixin) blueprint) ¶

Source: mixins.lisp.

Method: compile-blueprint :around ((client compile-cache-mixin) blueprint) ¶

Source: mixins.lisp.

Generic Function: compile-kernel (client kernel) ¶

Returns a function that returns zero values and that takes five arguments — the kernel, the iteration space, an opaque object representing all targets, an opaque object representing all sources, and an opaque object representing the evaluation environment.

Package

Source

Methods

Method: compile-kernel (client (kernel kernel)) ¶

Generic Reader: core-memory (device) ¶

Package

Source

Methods

Reader Method: core-memory ((core core)) ¶

automatically generated reader method

Target Slot: %memory.

Generic Reader: core-name (device) ¶

Package

Source

Methods

Reader Method: core-name ((core core)) ¶

automatically generated reader method

Target Slot: %name.

Generic Function: delayed-action-inputs (delayed-action) ¶

Package

Source

Methods

Method: delayed-action-inputs ((delayed-action delayed-action)) ¶

Method: delayed-action-inputs ((delayed-map delayed-map)) ¶

Method: delayed-action-inputs ((delayed-nth-value delayed-nth-value)) ¶

Method: delayed-action-inputs ((delayed-reshape delayed-reshape)) ¶

Method: delayed-action-inputs ((delayed-fuse delayed-fuse)) ¶

Generic Function: delete-backend (backend) ¶

Permanently disables the supplied backend and free any resources that are held by it. Once a backend has been deleted, further calls to an evaluation function on that backend will signal an error.

Package

Source

Methods

Method: delete-backend ((testing-backend testing-backend)) ¶

Source: testing-backend.lisp.

Method: delete-backend ((backend backend)) ¶

Source: backend.lisp.

Method: delete-backend ((backend backend)) ¶

Generic Reader: device-cores (device) ¶

Package

Source

Methods

Reader Method: device-cores ((device device)) ¶

automatically generated reader method

Target Slot: %cores.

Generic Reader: device-memory (device) ¶

Package

Source

Methods

Reader Method: device-memory ((device device)) ¶

automatically generated reader method

Target Slot: %memory.

Generic Reader: device-name (device) ¶

Package

Source

Methods

Reader Method: device-name ((device device)) ¶

automatically generated reader method

Target Slot: %name.

Generic Function: enlarge-transformation (transformation scale offset) ¶

Given a transformation mapping from (i1 ... iN) to (j1 ... jM), return a transformation mapping from (i0 i1 ... iN iN+1) to ((+(* i0 SCALE) OFFSET) j1 ... jM).

Package

Source

Methods

Method: enlarge-transformation ((transformation hairy-transformation) (scaling rational) (offset rational)) ¶

Method: enlarge-transformation ((transformation identity-transformation) (scale rational) (offset rational)) ¶

Method: enlarge-transformation ((transformation identity-transformation) (scale (eql 1)) (offset (eql 0))) ¶

Generic Function: inflate-transformation (transformation n) ¶

Package

Source

Methods

Method: inflate-transformation ((transformation hairy-transformation) (n integer)) ¶

Method: inflate-transformation ((transformation identity-transformation) (n integer)) ¶

Method: inflate-transformation :around ((transformation transformation) (n integer)) ¶

Generic Function: instruction-number-of-values (instruction) ¶

Package

Source

Methods

Method: instruction-number-of-values ((call-instruction call-instruction)) ¶

Method: instruction-number-of-values ((iref-instruction iref-instruction)) ¶

Method: instruction-number-of-values ((load-instruction load-instruction)) ¶

Method: instruction-number-of-values ((store-instruction store-instruction)) ¶

Generic Function: invert-transformation (transformation) ¶

Returns the inverse of the supplied transformation, or signals an error if the supplied transformation is not invertible.

Examples:

(invert-transformation (transform i to (+ 2 i)))
=> (transform a to (+ a -2))

(invert-transformation (transform a b to (+ (* 2 b) 5) (+ (* 3 a) 7)))
=> (transform a b to (+ (* 1/3 b) -7/3) (+ (* 1/2 a) -5/2))

(invert-transformation (transform a 0 to a))
=> (transform a to a 0)

(handler-case (invert-transformation (transform a b to a)) (error nil :error)) => :error

Package

Source

Methods

Method: invert-transformation ((transformation hairy-transformation)) ¶

Method: invert-transformation ((transformation identity-transformation)) ¶

Generic Function: load-function (client ntype) ¶

Returns the name of a function for loading an object of the supplied ntype from some base and index.

Package

Source

Methods

Method: load-function ((backend backend) (ntype ntype)) ¶

Source: compilation.lisp.

Method: load-function ((ir-backend ir-backend) (ntype ntype)) ¶

Source: ir-backend.lisp.

Generic Function: map-transformation-inputs (function transformation &key from-end) ¶

For each input of TRANSFORMATION, invoke FUNCTION with the input index and the corresponding input constraint, or null, if there is no input constraint for this input.

If FROM-END is false, the input indices are traversed in ascending order. Otherwise, they are traversed in descending order.

Package

Source

Methods

Method: map-transformation-inputs ((function function) (transformation hairy-transformation) &key from-end) ¶

Method: map-transformation-inputs ((function function) (transformation identity-transformation) &key from-end) ¶

Generic Function: map-transformation-outputs (function transformation &key from-end) ¶

For each output of TRANSFORMATION, invoke FUNCTION with the output index, input index, the scaling and the offset of that output.

An input index of NIL and a scaling of zero is used, if (and only if) the output is constant.

If FROM-END is false, the output indices are traversed in ascending order. Otherwise, they are traversed in descending order.

Package

Source

Methods

Method: map-transformation-outputs ((function function) (transformation hairy-transformation) &key from-end) ¶

Method: map-transformation-outputs ((function function) (transformation identity-transformation) &key from-end) ¶

Generic Reader: memory-bandwidth (memory) ¶

Package

Source

Methods

Reader Method: memory-bandwidth ((memory memory)) ¶

automatically generated reader method

Target Slot: %bandwidth.

Generic Reader: memory-children (memory) ¶

Package

Source

Methods

Reader Method: memory-children ((memory memory)) ¶

automatically generated reader method

Target Slot: %children.

Generic Reader: memory-cores (memory) ¶

Package

Source

Methods

Reader Method: memory-cores ((memory memory)) ¶

automatically generated reader method

Target Slot: %cores.

Generic Reader: memory-granularity (memory) ¶

Package

Source

Methods

Reader Method: memory-granularity ((memory memory)) ¶

automatically generated reader method

Target Slot: %granularity.

Generic Reader: memory-latency (memory) ¶

Package

Source

Methods

Reader Method: memory-latency ((memory memory)) ¶

automatically generated reader method

Target Slot: %latency.

Generic Reader: memory-name (memory) ¶

Package

Source

Methods

Reader Method: memory-name ((memory memory)) ¶

automatically generated reader method

Target Slot: %name.

Generic Reader: memory-parent (memory) ¶

Package

Source

Methods

Reader Method: memory-parent ((memory memory)) ¶

automatically generated reader method

Target Slot: %parent.

Generic Reader: memory-parent-bandwidth (memory) ¶

Package

Source

Methods

Reader Method: memory-parent-bandwidth ((memory memory)) ¶

automatically generated reader method

Target Slot: %parent-bandwidth.

Generic Reader: memory-size (memory) ¶

Package

Source

Methods

Reader Method: memory-size ((memory memory)) ¶

automatically generated reader method

Target Slot: %size.

Generic Function: request-completedp (request) ¶

Returns whether all lazy arrays that are part of the supplied request have already been computed.

Package

Source

Methods

Method: request-completedp ((request request)) ¶

Source: request.lisp.

Method: request-completedp ((completed-request completed-request)) ¶

Method: request-completedp ((request request)) ¶

Generic Function: request-wait (request) ¶

Blocks until all lazy arrays that are part of the supplied request have been computed.

Package

Source

Methods

Method: request-wait ((request request)) ¶

Source: request.lisp.

Method: request-wait ((completed-request completed-request)) ¶

Generic Function: requestp (object) ¶

Returns whether the supplied object is a request.

Package

Source

Methods

Method: requestp ((request request)) ¶

Source: request.lisp.

Method: requestp ((request request)) ¶

Method: requestp (object) ¶

Generic Function: shape-designator-shape (shape-designator) ¶

Returns the shape of the supplied shape designator. If the designator is already a shape, the result is that shape. If the designator is a regular array or lazy array, the result is the shape of that array. If the designator is any other object, the result is a shape with rank zero.

Package

Source

shape.lisp.

Methods

Method: shape-designator-shape ((lazy-array lazy-array)) ¶

Source: lazy-array.lisp.

Method: shape-designator-shape (object) ¶

Method: shape-designator-shape ((shape shape)) ¶

Method: shape-designator-shape ((array array)) ¶

Generic Function: source-function (client) ¶

Returns the name of a function that will be invoked with the
.sources. kernel parameter and an index, and that returns the source with that index.

As a second value, returns the values type specifier that describes the results of invoking that function.

Package

Source

Methods

Method: source-function ((backend backend)) ¶

Source: compilation.lisp.

Method: source-function ((ir-backend ir-backend)) ¶

Source: ir-backend.lisp.

Method: source-function :around (client) ¶

Generic Function: store-function (client ntype) ¶

Returns the name of a function for storing an object of the supplied ntype at some base and index.

Package

Source

Methods

Method: store-function ((backend backend) (ntype ntype)) ¶

Source: compilation.lisp.

Method: store-function ((ir-backend ir-backend) (ntype ntype)) ¶

Source: ir-backend.lisp.

Generic Function: substitute-delayed-action (delayed-action) ¶

Package

substitute-lazy-arrays.lisp.

Source

Methods

Method: substitute-delayed-action ((delayed-action delayed-action)) ¶

Method: substitute-delayed-action ((delayed-fuse delayed-fuse)) ¶

Method: substitute-delayed-action ((delayed-reshape delayed-reshape)) ¶

Method: substitute-delayed-action ((delayed-nth-value delayed-nth-value)) ¶

Method: substitute-delayed-action ((delayed-multiple-value-map delayed-multiple-value-map)) ¶

Method: substitute-delayed-action ((delayed-map delayed-map)) ¶

Generic Function: target-function (client) ¶

Returns the name of a function that will be invoked with the values of the .targets. kernel parameter and an index, and that returns the target with that index.

As a second value, returns the values type specifier that describes the results of invoking that function.

Package

Source

Methods

Method: target-function ((backend backend)) ¶

Source: compilation.lisp.

Method: target-function ((ir-backend ir-backend)) ¶

Source: ir-backend.lisp.

Method: target-function :around (client) ¶

Generic Function: transform-axis (axis transformation) ¶

Package

Source

Methods

Method: transform-axis ((axis integer) (hairy-transformation hairy-transformation)) ¶

Method: transform-axis ((axis integer) (transformation identity-transformation)) ¶

Method: transform-axis ((axis integer) (transformation transformation)) ¶

Generic Function: transform-index (index transformation) ¶

Returns the index that results from applying the supplied transformation to the supplied index.

Examples:

(transform-index ’(10) (transform i to (+ i 2)))
=> (12)

(transform-index ’(1 2 3) (transform i j k to j (* 3 i) (1+ k)))
=> (2 3 4)

Package

Source

Methods

Method: transform-index ((vector vector) (transformation hairy-transformation)) ¶

Method: transform-index ((list list) (transformation hairy-transformation)) ¶

Method: transform-index ((sequence sequence) (transformation identity-transformation)) ¶

Method: transform-index :before ((sequence sequence) (transformation hairy-transformation)) ¶

Method: transform-index :before ((sequence sequence) (transformation transformation)) ¶

Generic Function: transform-shape (shape transformation) ¶

Returns the shape that describes the set of all results of applying the supplied transformation to each index of the supplied shape.

Examples:

(transform-shape (~ 2 ~ 3) (transform i j to j i))
=> (~ 3 ~ 2)

(transform-shape (~ 10) (transform i to (1+ (* 2 i))))
=> (~ 1 20 2)

Package

Source

Methods

Method: transform-shape ((shape shape) (transformation hairy-transformation)) ¶

Method: transform-shape ((shape shape) (operator identity-transformation)) ¶

Method: transform-shape :before ((shape shape) (transformation hairy-transformation)) ¶

Method: transform-shape :before ((shape shape) (transformation transformation)) ¶

Generic Function: transformation-similar (transformation1 transformation2 delta) ¶

Returns whether two supplied transformations are similar. Two transformations are similar if they have the same permutation, the same inputs constraints, the same scalings, and offsets whose entries differ in at most DELTA.

Examples:

(petalisp.core:transformation-similar (transform a to a)
(transform a to (1+ a)) 0)
=> nil

(petalisp.core:transformation-similar (transform a to a)
(transform a to (1+ a)) 1)
=> t

(petalisp.core:transformation-similar (transform i j to (+ j 2) i) (transform i j to (- j 1) i) 2) => nil

(petalisp.core:transformation-similar (transform i j to (+ j 2) i) (transform i j to (- j 1) i) 3) => t

Package

Source

Methods

Method: transformation-similar ((t1 transformation) (t2 transformation) (delta integer)) ¶

Generic Function: transformation= (transformation1 transformation2) ¶

Returns whether two supplied transformations describe the same mapping.

Examples:

(transformation= (transform i to (* 2 (1+ i))) (transform i to (+ 2 (* 2 i)))) => t

(transformation= (transform i j to i j) (transform i j to j i))
=> nil

Package

Source

Methods

Method: transformation= ((t1 hairy-transformation) (t2 hairy-transformation)) ¶

Method: transformation= ((t1 identity-transformation) (t2 identity-transformation)) ¶

Method: transformation= ((t1 transformation) (t2 transformation)) ¶

Generic Function: unpack-function (client ntype rank) ¶

Returns the name of a function for unpacking a storage object and environment into a base, an offset, and as many strides as the supplied RANK.

As a second value, returns the values type specifier that describes the results of invoking that function.

Package

Source

Methods

Method: unpack-function ((backend backend) (ntype ntype) (rank integer)) ¶

Source: compilation.lisp.

Method: unpack-function ((ir-backend ir-backend) (ntype ntype) (rank integer)) ¶

Source: ir-backend.lisp.

Method: unpack-function :around (client ntype rank) ¶

Next: Structures, Previous: Generic functions, Up: Public Interface [Contents][Index]

5.1.7 Standalone methods

Method: generate-graph-from-roots :around ((graph partitioning-graph) roots &optional attributes) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: generate-graph-from-roots :around ((graph any-graph) objects &optional attributes) ¶

Package: cl-dot.
Source: protocol.lisp.

Method: generate-graph-from-roots :around ((graph ir-graph) roots &optional attributes) ¶

Package: cl-dot.
Source: ir.lisp.

Method: graph-object-cluster ((graph partitioning-graph) (kernel-shard kernel-shard)) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: graph-object-cluster ((graph ir-graph) (buffer buffer)) ¶

Package: cl-dot.
Source: ir.lisp.

Method: graph-object-cluster ((graph ir-graph) (kernel kernel)) ¶

Package: cl-dot.
Source: ir.lisp.

Method: graph-object-knows-of ((graph partitioning-graph) (node kernel-shard)) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: graph-object-knows-of ((graph any-graph) object) ¶

Package: cl-dot.
Source: protocol.lisp.

Method: graph-object-node ((graph partitioning-graph) (node kernel-shard)) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: graph-object-node ((graph partitioning-graph) (node buffer-shard)) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: graph-object-node ((graph any-graph) node) ¶

Package: cl-dot.
Source: protocol.lisp.

Method: graph-object-node ((graph class-diagram) (class class)) ¶

Package: cl-dot.
Source: class-diagram.lisp.

Method: graph-object-pointed-to-by ((graph partitioning-graph) (buffer-shard buffer-shard)) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: graph-object-pointed-to-by ((graph any-graph) node) ¶

Package: cl-dot.
Source: protocol.lisp.

Method: graph-object-points-to ((graph partitioning-graph) (buffer-shard buffer-shard)) ¶

Package: cl-dot.
Source: partitioning.lisp.

Method: graph-object-points-to ((graph any-graph) node) ¶

Package: cl-dot.
Source: protocol.lisp.

Method: initialize-instance :after ((backend backend) &key &allow-other-keys) ¶

Source: backend.lisp.

Method: print-object ((ad-record ad-record) stream) ¶

Source: differentiator.lisp.

Method: print-object ((node node) stream) ¶

Source: scheduling.lisp.

Method: print-object ((shape shape) stream) ¶

Source: shape-syntax.lisp.

Method: print-object ((lazy-array lazy-array) stream) ¶

Source: lazy-array.lisp.

Method: print-object ((transformation transformation) stream) ¶

Source: transform.lisp.

Method: print-object ((empty-range empty-range) stream) ¶

Source: range.lisp.

Method: print-object ((range non-empty-range) stream) ¶

Source: range.lisp.

Method: print-object ((kernel-shard kernel-shard) stream) ¶

Source: partitioning.lisp.

Method: print-object ((buffer buffer) stream) ¶

Source: ir.lisp.

Method: print-object ((store-instruction store-instruction) stream) ¶

Source: ir.lisp.

Method: print-object ((program program) stream) ¶

Source: ir.lisp.

Method: print-object ((buffer-shard buffer-shard) stream) ¶

Source: partitioning.lisp.

Method: print-object ((core core) stream) ¶

Source: device.lisp.

Method: print-object ((iref-instruction iref-instruction) stream) ¶

Source: ir.lisp.

Method: print-object ((memory memory) stream) ¶

Source: device.lisp.

Method: print-object ((split split) stream) ¶

Source: partitioning.lisp.

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

Source: ir.lisp.

Method: print-object ((load-instruction load-instruction) stream) ¶

Source: ir.lisp.

Method: print-object ((task task) stream) ¶

Source: ir.lisp.

Method: print-object ((device device) stream) ¶

Source: device.lisp.

Method: print-object ((call-instruction call-instruction) stream) ¶

Source: ir.lisp.

Method: print-object ((worker worker) stream) ¶

Source: worker-pool.lisp.

Method: shared-initialize :after ((core core) slot-names &key &allow-other-keys) ¶

Source: device.lisp.

Method: shared-initialize :after ((memory memory) slot-names &key &allow-other-keys) ¶

Source: device.lisp.

Next: Classes, Previous: Standalone methods, Up: Public Interface [Contents][Index]

5.1.8 Structures

Structure: buffer ¶

A buffer is a mapping from indices of a particular shape to memory locations of a particular type. It has the following slots:

- A shape that describes the size and virtual layout of the buffer.

- A conservative approximation of the type of each element of the buffer, represented as an ntype of the type inference library Typo.

- The depth of the lazy array corresponding to the buffer.

- The writers of the buffer, encoded as an association list where the key of each entry is a kernel and the value is the list of all the store instructions in that kernel that write to the buffer.

- The readers of the buffer, encoded as an association where the key of each entry is a kernel and the value is a list of all the load instructions in that kernel that load from the buffer.

- The task that contains all kernels that write into this buffer.

- The storage of the buffer, which is an opaque, backend-specific object.

- A number that is unique among all buffers in the program and less than the total number of buffers in the program.

Package

Source

Direct superclasses

structure-object.

Direct methods

check-ir-node.
graph-object-cluster.
graphviz-default-graph.
graphviz-incoming-edge-origins.
graphviz-node-attributes.
graphviz-node-properties.
graphviz-outgoing-edge-targets.
print-object.

Direct slots

Slot: shape ¶

Package: petalisp-1.0.
Type: petalisp-1.0:shape
Readers: buffer-shape.
Writers: (setf buffer-shape).

Slot: ntype ¶

Type: typo:ntype
Readers: buffer-ntype.
Writers: (setf buffer-ntype).

Slot: depth ¶

Type: (and unsigned-byte fixnum)
Readers: buffer-depth.
Writers: (setf buffer-depth).

Slot: writers ¶

Type: list
Initform: (quote nil)
Readers: buffer-writers.
Writers: (setf buffer-writers).

Slot: readers ¶

Type: list
Initform: (quote nil)
Readers: buffer-readers.
Writers: (setf buffer-readers).

Slot: task ¶

Type: (or null petalisp.ir:task)
Readers: buffer-task.
Writers: (setf buffer-task).

Slot: number ¶

Package: common-lisp.
Type: (and unsigned-byte fixnum)
Initform: 0
Readers: buffer-number.
Writers: (setf buffer-number).

Slot: storage ¶

Readers: buffer-storage.
Writers: (setf buffer-storage).

Structure: buffer-shard ¶

A buffer shard describes one portion of a buffer and how it relates to neighboring parts of that buffer. It also tracks the kernel shards reading from it and writing to it, and it may contain a split that describes how it is subdivided into smaller buffer shards. Each buffer shard has the following slots:

- The buffer being partitioned by this buffer shard.

- The domain, which is the part of the buffer’s shape that is exclusively managed by this buffer shard and its children.

- The shape, which is the union of the buffer shard’s domain and any auxiliary ghost layers.

- The parent, which is either the buffer shard that was split to create this one, or NIL if this buffer shard has no parent. We call any buffer shard whose parent is NIL a primogenitor, and its domain is equal to the shape of its buffer.

- The writers, which is a list of kernel shards that write to this buffer shard.

- The readers, which is a list of kernel shards that read from this buffer shard.

- The split priority cache, which is used to cache the user-supplied cost function for the buffer shard once it is computed for the first time.

- The split operation if this buffer shard has been split into two child buffer shards, or NIL if it hasn’t been split so far.

- The layout assigned to the buffer shard, or NIL if no layout has been assigned so far.

Package

Source

Direct superclasses

structure-object.

Direct methods

check-shard.
graph-object-node.
graph-object-pointed-to-by.
graph-object-points-to.
graphviz-default-graph.
graphviz-edge-attributes.
graphviz-edge-attributes.
print-object.

Direct slots

Slot: buffer ¶

Type: petalisp.ir:buffer
Readers: buffer-shard-buffer.
Writers: This slot is read-only.

Slot: parent ¶

Type: (or null petalisp.ir:buffer-shard)
Readers: buffer-shard-parent.
Writers: This slot is read-only.

Slot: domain ¶

Type: petalisp-1.0:shape
Readers: buffer-shard-domain.
Writers: This slot is read-only.

Slot: shape ¶

Package: petalisp-1.0.
Type: petalisp-1.0:shape
Readers: buffer-shard-shape.
Writers: This slot is read-only.

Slot: writers ¶

Type: list
Initform: (quote nil)
Readers: buffer-shard-writers.
Writers: (setf buffer-shard-writers).

Slot: readers ¶

Type: list
Initform: (quote nil)
Readers: buffer-shard-readers.
Writers: (setf buffer-shard-readers).

Slot: split-priority-cache ¶

Type: (or null unsigned-byte)
Readers: buffer-shard-split-priority-cache.
Writers: (setf buffer-shard-split-priority-cache).

Slot: split ¶

Type: (or null structure-object)
Readers: buffer-shard-split.
Writers: (setf buffer-shard-split).

Slot: layout ¶

Type: (or null petalisp.ir:layout)
Readers: buffer-shard-layout.
Writers: (setf buffer-shard-layout).

Structure: call-instruction ¶

A call instruction represents the application of a function to some arguments. It consists of an fnrecord from the type inference library Typo, an integer that specifies the number of values produced by the call instruction, and a list of inputs. The values of a call instruction are obtained by applying the fnrecord’s function to the values of each of the call instruction’s inputs. If the function application produces fewer values than specified, the missing values are set to NIL.

Package

Source

Direct superclasses

instruction.

Direct methods

clone-reference.
instruction-blueprint.
instruction-number-of-values.
print-object.

Direct slots

Slot: fnrecord ¶

Type: typo:fnrecord
Readers: call-instruction-fnrecord.
Writers: (setf call-instruction-fnrecord).

Slot: number-of-values ¶

Type: (integer 0 (1073741824))
Readers: call-instruction-number-of-values.
Writers: (setf call-instruction-number-of-values).

Structure: cqueue ¶

Package

petalisp.cqueue.

Source

cqueue.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: h-lock ¶

Type: bt2:lock
Initform: (bt2:make-lock :name "h-lock")
Readers: cqueue-h-lock.
Writers: (setf cqueue-h-lock).

Slot: t-lock ¶

Type: bt2:lock
Initform: (bt2:make-lock :name "t-lock")
Readers: cqueue-t-lock.
Writers: (setf cqueue-t-lock).

Slot: head ¶

Type: cons
Readers: cqueue-head.
Writers: (setf cqueue-head).

Slot: tail ¶

Type: cons
Readers: cqueue-tail.
Writers: (setf cqueue-tail).

Structure: delayed-action ¶

Package

Source

Direct superclasses

structure-object.

Direct subclasses

delayed-array.
delayed-failure.
delayed-fuse.
delayed-map.
delayed-nop.
delayed-nth-value.
delayed-range.
delayed-reshape.
delayed-unknown.
delayed-wait.

Direct methods

convert-nucleus.
convert-nucleus.
delayed-action-inputs.
grow-dendrite-aux.
substitute-delayed-action.
trivial-lazy-array-p.

Structure: delayed-array ¶

A delayed array describes the process of assigning each index the value of some existing Common Lisp array at that index. It has one slot that is the existing array being referenced.

Package

Source

Direct superclasses

Direct methods

approximately-equal.
delayed-action-value.
graphviz-node-attributes.
graphviz-node-properties.
grow-dendrite-aux.
trivial-lazy-array-p.
trivial-lazy-array-value.

Direct slots

Slot: storage ¶

Type: array
Initform: (alexandria:required-argument :storage)
Readers: delayed-array-storage.
Writers: (setf delayed-array-storage).

Structure: delayed-failure ¶

A delayed failure describes a lazy array that was involved in an asynchronous evaluation that signaled an error. It has one slot that is the condition that should be resignaled whenever this delayed action is part of a synchronous evaluation.

Package

Source

Direct superclasses

Direct methods

delayed-action-value.
grow-dendrite-aux.

Direct slots

Slot: condition ¶

Package: common-lisp.
Type: condition
Initform: (alexandria:required-argument :condition)
Readers: delayed-failure-condition.
Writers: This slot is read-only.

Structure: delayed-fuse ¶

A delayed fuse describes the process of assigning each index the corresponding value from the one input lazy array whose shape contains that index. It has a single slot
that is the list of lazy arrays being fused.

Package

Source

Direct superclasses

Direct methods

delayed-action-inputs.
delayed-action-value.
graphviz-node-attributes.
grow-dendrite-aux.
input-gradient.
substitute-delayed-action.

Direct slots

Slot: inputs ¶

Type: list
Initform: (alexandria:required-argument :inputs)
Readers: delayed-fuse-inputs.
Writers: (setf delayed-fuse-inputs).

Structure: delayed-map ¶

A delayed map describes the element-wise application of a function to some number of lazy arrays. A delayed map has two slots: The first slot is the fnrecord of the function being mapped, i.e., the entry of that function in the database of the type inference library Typo. The second slot is a list of lazy arrays that the function is being mapped over. All lazy arrays that appear as an input to a delayed map must have the same shape.

Package

Source

Direct superclasses

delayed-multiple-value-map.

Direct subclasses

Direct methods

delayed-action-inputs.
delayed-action-value.
graphviz-node-attributes.
graphviz-node-properties.
grow-dendrite-aux.
input-gradient.
substitute-delayed-action.

Direct slots

Slot: fnrecord ¶

Type: typo:fnrecord
Initform: (alexandria:required-argument :fnrecord)
Readers: delayed-map-fnrecord.
Writers: (setf delayed-map-fnrecord).

Slot: inputs ¶

Type: list
Initform: (alexandria:required-argument :inputs)
Readers: delayed-map-inputs.
Writers: (setf delayed-map-inputs).

Structure: delayed-multiple-value-map ¶

A delayed multiple value map describes the element-wise application of a multiple-valued function to some number of lazy arrays of the same shape. It has the same first two slots as a delayed map, a third slot that is Typo’s description of the type of the multiple values it returns, and a fourth slot that is a mutable bit vector that tracks which of the multiple values have been referenced so far. The bit vector is later used to eliminate unused values altogether.

Because of the nature of its return values, a lazy array whose delayed action is a delayed multiple value map must appear only as the input of a delayed nth value action and never be visible to the user.

Package

Source

Direct superclasses

delayed-map.

Direct methods

convert-nucleus.
delayed-action-value.
substitute-delayed-action.

Direct slots

Slot: values-ntype ¶

Type: typo:values-ntype
Initform: (alexandria:required-argument :values-ntype)
Readers: delayed-multiple-value-map-values-ntype.
Writers: This slot is read-only.

Slot: refbits ¶

Type: unsigned-byte
Initform: 0
Readers: delayed-multiple-value-map-refbits.
Writers: (setf delayed-multiple-value-map-refbits).

Slot: refbits-lock ¶

Type: bt2:lock
Initform: (bt2:make-lock :name "refbits lock")
Readers: delayed-multiple-value-map-refbits-lock.
Writers: (setf delayed-multiple-value-map-refbits-lock).

Structure: delayed-nop ¶

A delayed nop is the delayed action of any lazy array with zero elements. It cannot be computed.

Package: petalisp.core.
Source: lazy-array.lisp.
Direct superclasses: delayed-action.
Direct methods: delayed-action-value.

Structure: delayed-nth-value ¶

A delayed nth value describes the process of referencing the nth value of some lazy array whose delayed action is a delayed multiple value map. Its first slot is the position of the value being referenced, and its second slot is a lazy array defined by a delayed multiple value map.

Package

Source

Direct superclasses

Direct methods

delayed-action-inputs.
delayed-action-value.
graphviz-node-properties.
grow-dendrite-aux.
substitute-delayed-action.

Direct slots

Slot: number ¶

Package: common-lisp.
Type: typo:argument-index
Initform: (alexandria:required-argument :number)
Readers: delayed-nth-value-number.
Writers: (setf delayed-nth-value-number).

Slot: input ¶

Type: petalisp-1.0:lazy-array
Initform: (alexandria:required-argument :input)
Readers: delayed-nth-value-input.
Writers: (setf delayed-nth-value-input).

Structure: delayed-range ¶

A delayed range describes the process of assigning each index the sole integer contained in that index. This delayed action must appear only in the definition of lazy arrays of rank one.

Package

Source

Direct superclasses

Direct methods

delayed-action-value.
grow-dendrite-aux.

Structure: delayed-reshape ¶

A delayed reshape describes the process of assigning each index the value of the specified input lazy array at the position that is obtained by applying the specified transformation to that index. It has one slot that stores the transformation and one slot that stores that lazy array being referenced.

Package

Source

Direct superclasses

Direct methods

delayed-action-inputs.
delayed-action-value.
graphviz-node-attributes.
graphviz-node-properties.
grow-dendrite-aux.
input-gradient.
substitute-delayed-action.
trivial-lazy-array-p.
trivial-lazy-array-value.

Direct slots

Slot: transformation ¶

Package: petalisp-1.0.
Type: petalisp-1.0:transformation
Initform: (alexandria:required-argument :transformation)
Readers: delayed-reshape-transformation.
Writers: (setf delayed-reshape-transformation).

Slot: input ¶

Type: petalisp-1.0:lazy-array
Initform: (alexandria:required-argument :input)
Readers: delayed-reshape-input.
Writers: (setf delayed-reshape-input).

Structure: delayed-unknown ¶

A delayed unknown is used as the delayed action of any lazy array created by the function MAKE-UNKNOWN. It cannot be computed.

Package

Source

Direct superclasses

Direct methods

delayed-action-value.
grow-dendrite-aux.

Structure: delayed-wait ¶

Package

Source

Direct superclasses

Direct methods

grow-dendrite-aux.

Direct slots

Slot: request ¶

Initform: (alexandria:required-argument :request)
Readers: delayed-wait-request.
Writers: This slot is read-only.

Slot: delayed-action ¶

Type: petalisp.core:delayed-action
Initform: (alexandria:required-argument :delayed-action)
Readers: delayed-wait-delayed-action.
Writers: (setf delayed-wait-delayed-action).

Structure: empty-range ¶

An empty range is a range with zero elements.

Package: petalisp.core.
Source: range.lisp.
Direct superclasses: range.
Direct methods: print-object.

Structure: graph ¶

Package

petalisp.scheduling.

Source

Direct superclasses

structure-object.

Direct slots

Slot: object-nodes ¶

Type: hash-table
Initform: (make-hash-table)
Readers: graph-object-nodes.
Writers: (setf graph-object-nodes).

Structure: identity-transformation ¶

An identity transformation of rank N maps every list of length N to itself. An identity transformation is its own inverse.

Package

Source

Direct superclasses

transformation.

Direct methods

compose-two-transformations.
compose-two-transformations.
enlarge-transformation.
enlarge-transformation.
inflate-transformation.
invert-transformation.
map-transformation-inputs.
map-transformation-outputs.
transform-axis.
transform-index.
transform-shape.
transformation=.

Structure: instruction ¶

An instruction describes part of the semantics of the kernel that contains it. This abstract base class outlines behavior that is shared among all instructions. It prescribes two slots:

- The instruction number, which is an integer that is unique among all instructions of the containing kernel. Instruction numbers are handed out in depth-first order of instruction dependencies, such that the roots (store instructions) have the highest numbers and the leaf nodes (load and iref instructions) have the lowest numbers.

- A list of inputs, whose elements are cons cells whose CDR is another instruction in the same kernel and whose CAR is an integer denoting which of the multiple values returned by the instruction in the CDR is being referenced. An instruction with zero inputs is called a leaf instruction.

Package

Source

Direct superclasses

structure-object.

Direct subclasses

call-instruction.
iterating-instruction.

Direct methods

check-ir-node.
transform-instruction-input.
transform-instruction-output.

Direct slots

Slot: inputs ¶

Type: list
Initform: (quote nil)
Readers: instruction-inputs.
Writers: (setf instruction-inputs).

Slot: number ¶

Package: common-lisp.
Type: (and unsigned-byte fixnum)
Initform: 0
Readers: instruction-number.
Writers: (setf instruction-number).

Structure: iref-instruction ¶

An iref instruction represents an access to elements of the iteration space itself. It contains a transformation that maps each index of the iteration space to an index of rank one. Its value is the single index component of that rank one index. An iref instruction has zero inputs.

Package

Source

Direct superclasses

iterating-instruction.

Direct methods

clone-reference.
instruction-blueprint.
instruction-number-of-values.
print-object.

Structure: iterating-instruction ¶

The class of all instructions whose behavior directly depends on the current position in the surrounding iteration space.

Package

Source

Direct superclasses

instruction.

Direct subclasses

iref-instruction.
load-or-store-instruction.

Direct methods

transform-instruction-input.
transform-instruction-output.

Direct slots

Slot: transformation ¶

Package: petalisp-1.0.
Type: petalisp-1.0:transformation
Readers: instruction-transformation.
Writers: (setf instruction-transformation).

Structure: kernel ¶

A kernel represents a computation that executes some instructions once for each element in its iteration space. It has the following slots:

- The iteration space, encoded as a shape.

- The instruction vector that contains the instructions of that kernel sorted by their instruction numbers.

- The sources of that kernel, encoded as an association list where the key of each entry is a buffer and where the value is a list of stencils of load instructions reading from that buffer.

- The targets of that kernel, encoded as an association list where the key of each entry is a buffer and where the value is a list of stencils of store instructions writing into that buffer.

- The task that contains this kernel.

- A number that is unique among all kernels in the program and less than the total number of kernels in the program.

Package

Source

Direct superclasses

structure-object.

Direct methods

check-ir-node.
clone-reference.
clone-reference.
clone-reference.
compile-kernel.
graph-object-cluster.
graphviz-default-graph.
graphviz-incoming-edge-origins.
graphviz-node-attributes.
graphviz-node-properties.
graphviz-outgoing-edge-targets.
instruction-blueprint.
instruction-blueprint.
instruction-blueprint.
instruction-blueprint.
print-object.

Direct slots

Slot: iteration-space ¶

Type: petalisp-1.0:shape
Readers: kernel-iteration-space.
Writers: (setf kernel-iteration-space).

Slot: sources ¶

Type: list
Initform: (quote nil)
Readers: kernel-sources.
Writers: (setf kernel-sources).

Slot: targets ¶

Type: list
Initform: (quote nil)
Readers: kernel-targets.
Writers: (setf kernel-targets).

Slot: instruction-vector ¶

Type: simple-vector
Initform: #()
Readers: kernel-instruction-vector.
Writers: (setf kernel-instruction-vector).

Slot: task ¶

Type: (or null petalisp.ir:task)
Readers: kernel-task.
Writers: (setf kernel-task).

Slot: number ¶

Package: common-lisp.
Type: (and unsigned-byte fixnum)
Initform: 0
Readers: kernel-number.
Writers: (setf kernel-number).

Slot: data ¶

Readers: kernel-data.
Writers: (setf kernel-data).

Structure: kernel-shard ¶

A kernel shard describes one portion of a kernel to be executed and the buffer shards it reads from and writes to. A kernel shard has the following slots:

- The kernel being partitioned by this kernel shard.

- The iteration space, which is a shape that describes the subset of the kernel iteration space that is uniquely assigned to this kernel shard.

- The targets of the kernel shard, which is a list of buffer shards, one per target buffer of the kernel being partitioned.

- The sources of the kernel shard, which is a list of buffer shards, one per source buffer of the kernel being partitioned.

Package

Source

Direct superclasses

structure-object.

Direct methods

check-shard.
graph-object-cluster.
graph-object-knows-of.
graph-object-node.
graphviz-default-graph.
graphviz-edge-attributes.
graphviz-edge-attributes.
print-object.

Direct slots

Slot: kernel ¶

Type: petalisp.ir:kernel
Readers: kernel-shard-kernel.
Writers: This slot is read-only.

Slot: iteration-space ¶

Type: petalisp-1.0:shape
Readers: kernel-shard-iteration-space.
Writers: This slot is read-only.

Slot: targets ¶

Type: list
Initform: (quote nil)
Readers: kernel-shard-targets.
Writers: (setf kernel-shard-targets).

Slot: sources ¶

Type: list
Initform: (quote nil)
Readers: kernel-shard-sources.
Writers: (setf kernel-shard-sources).

Structure: layout ¶

A layout describes how the indices of a shape relate to a particular region of memory with linear addressing. After the partitioning, each buffer shard that is referenced at least once is assigned a layout. If a buffer shard has a layout, its children must have the same layout. A layout has the following slots:

- The strides, which is a vector of unsigned integers that describes the mapping from indices that are tuples of integers to a single integer that is the address of an element of this layout. Its Ith entry denotes the address increment when bumping the Ith component of an index by one.

- The offset, which is an integer that is the linear address corresponding to the index tuple of all zeros.

- The ntype of the elements of the layout.

- The size, i.e., the number of elements contained in the layout.

- The ghost layer alist, which is an association list whose keys are shapes and whose values are layouts. Its entries describe from where the ghost layers of this layout can be loaded.

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: offset ¶

Type: fixnum
Initform: 0
Readers: layout-offset.
Writers: This slot is read-only.

Slot: strides ¶

Type: (simple-array unsigned-byte (*))
Readers: layout-strides.
Writers: This slot is read-only.

Slot: ntype ¶

Type: typo:ntype
Readers: layout-ntype.
Writers: This slot is read-only.

Slot: size ¶

Type: unsigned-byte
Readers: layout-size.
Writers: This slot is read-only.

Slot: ghost-layer-alist ¶

Type: list
Readers: layout-ghost-layer-alist.
Writers: (setf layout-ghost-layer-alist).

Slot: allocation ¶

Readers: layout-allocation.
Writers: (setf layout-allocation).

Structure: lazy-array ¶

A lazy array encapsulates some information that can be used to compute actual Common Lisp arrays.

Package

Source

Direct superclasses

structure-object.

Direct methods

Direct slots

Slot: shape ¶

Type: petalisp-1.0:shape
Initform: (alexandria:required-argument :shape)
Readers: lazy-array-shape.
Writers: This slot is read-only.

Slot: ntype ¶

Package: petalisp.core.
Type: typo:ntype
Initform: (alexandria:required-argument :ntype)
Readers: lazy-array-ntype.
Writers: This slot is read-only.

Slot: depth ¶

Package: petalisp.core.
Type: (and unsigned-byte fixnum)
Initform: 0
Readers: lazy-array-depth.
Writers: This slot is read-only.

Slot: refcount ¶

Package: petalisp.core.
Type: (and unsigned-byte fixnum)
Initform: 0
Readers: lazy-array-refcount.
Writers: (setf lazy-array-refcount).

Slot: delayed-action ¶

Package: petalisp.core.
Type: petalisp.core:delayed-action
Initform: (alexandria:required-argument :delayed-action)
Readers: lazy-array-delayed-action.
Writers: (setf lazy-array-delayed-action).

Structure: load-instruction ¶

A load instruction represents a read from main memory. It consists of a buffer that is being read from and a transformation that maps each index of the iteration space to a position in that buffer. A load instruction has zero inputs and produces a single output that is the value that has been loaded.

Package

Source

load-or-store-instruction.

Direct superclasses

Direct methods

clone-reference.
instruction-blueprint.
instruction-number-of-values.
print-object.

Structure: load-or-store-instruction ¶

Package

Source

Direct superclasses

iterating-instruction.

Direct subclasses

load-instruction.
store-instruction.

Direct slots

Slot: buffer ¶

Type: petalisp.ir:buffer
Readers: instruction-buffer.
Writers: (setf instruction-buffer).

Structure: node ¶

Package

petalisp.scheduling.

Source

Direct superclasses

structure-object.

Direct methods

graphviz-default-graph.
graphviz-edge-attributes.
graphviz-known-nodes.
graphviz-node-properties.
graphviz-outgoing-edge-targets.
print-object.

Direct slots

Slot: predecessor-alist ¶

Type: list
Initform: (quote nil)
Readers: node-predecessor-alist.
Writers: (setf node-predecessor-alist).

Slot: successor-alist ¶

Type: list
Initform: (quote nil)
Readers: node-successor-alist.
Writers: (setf node-successor-alist).

Slot: object ¶

Readers: node-object.
Writers: (setf node-object).

Slot: depth ¶

Type: unsigned-byte
Initform: 0
Readers: node-depth.
Writers: (setf node-depth).

Slot: height ¶

Type: unsigned-byte
Initform: 0
Readers: node-height.
Writers: (setf node-height).

Slot: eagerness ¶

Type: unsigned-byte
Initform: 0
Readers: node-eagerness.
Writers: (setf node-eagerness).

Slot: affinity ¶

Type: (or unsigned-byte null)
Readers: node-affinity.
Writers: (setf node-affinity).

Slot: counter ¶

Type: unsigned-byte
Initform: 0
Readers: node-counter.
Writers: (setf node-counter).

Slot: position ¶

Package: common-lisp.
Readers: node-position.
Writers: (setf node-position).

Structure: non-empty-range ¶

A non-empty range denotes a set of integers, starting from a lower bound START, by a fixed stride STEP, to an exclusive upper bound END.

Package

Source

range.lisp.

Direct superclasses

range.

Direct methods

Direct slots

Slot: step ¶

Package: common-lisp.
Type: (integer 1 *)
Readers: range-step.
Writers: This slot is read-only.

Slot: start ¶

Type: integer
Readers: range-start.
Writers: This slot is read-only.

Structure: program ¶

A program is the largest organizational unit in Petalisp’s IR and fully describes the semantics of a particular graph of lazy arrays. It has the following slots:

- The initial task, which is the unique task in the program with zero predecessors.

- The final task, which is the unique task in the program with zero successors.

- An association list where each entry has a key that is a leaf buffer and a value that is the corresponding lazy array.

- A list of all root buffers of the program in the order that they were submitted for evaluation.

- A simple vector that contains all the tasks in the program sorted by their task number.

- The number of buffers in the program.

- The number of kernels in the program.

Package

Source

Direct superclasses

structure-object.

Direct methods

check-ir-node.
print-object.

Direct slots

Slot: initial-task ¶

Readers: program-initial-task.
Writers: (setf program-initial-task).

Slot: final-task ¶

Readers: program-final-task.
Writers: (setf program-final-task).

Slot: leaf-alist ¶

Type: list
Initform: (quote nil)
Readers: program-leaf-alist.
Writers: (setf program-leaf-alist).

Slot: root-buffers ¶

Type: list
Initform: (quote nil)
Readers: program-root-buffers.
Writers: (setf program-root-buffers).

Slot: task-vector ¶

Type: simple-vector
Initform: #()
Readers: program-task-vector.
Writers: (setf program-task-vector).

Slot: number-of-buffers ¶

Type: (and unsigned-byte fixnum)
Initform: 0
Readers: program-number-of-buffers.
Writers: (setf program-number-of-buffers).

Slot: number-of-kernels ¶

Type: (and unsigned-byte fixnum)
Initform: 0
Readers: program-number-of-kernels.
Writers: (setf program-number-of-kernels).

Structure: range ¶

A range denotes a possibly empty set of integers.

Package

Source

range.lisp.

Direct superclasses

structure-object.

Direct subclasses

empty-range.
non-empty-range.

Direct slots

Slot: size ¶

Package: petalisp.core.
Type: (integer 0 *)
Readers: range-size.
Writers: This slot is read-only.

Structure: shape ¶

A shape is the cartesian product of zero or more ranges. Shapes can be constructed by calling ~ or MAKE-SHAPE. The elements of a shape are lists of integers. The rank of a shape is the length of these lists. For example, the shape (~ 0 1 ~ 1 3 ~ 3 8 4) has rank three and consists of the integer tuples (0 1 3), (0 1 7), (0 2 3), (0 2 7).

Package

Source

shape.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.
shape-designator-shape.
transform-shape.
transform-shape.
transform-shape.
transform-shape.

Direct slots

Slot: ranges ¶

Package: petalisp.core.
Type: list
Readers: shape-ranges.
Writers: This slot is read-only.

Slot: rank ¶

Package: petalisp.core.
Type: petalisp.core:rank
Readers: shape-rank.
Writers: This slot is read-only.

Slot: size ¶

Package: petalisp.core.
Type: unsigned-byte
Readers: shape-size.
Writers: This slot is read-only.

Structure: shape-table ¶

Package

Source

shape.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: ht ¶

Type: hash-table
Initform: (make-hash-table :test (function equalp))
Readers: shape-table-ht.
Writers: This slot is read-only.

Structure: split ¶

A split describes how an axis of an existing buffer shard is split into two smaller child buffer shards. Each split has the following slots:

- The axis at which the buffer-shard is split.

- The position of the smallest element of the right child’s range in the axis being split.

- The buffer shard that is the left child of the split.

- The buffer shard that is the right child of the split.

Package

Source

Direct superclasses

structure-object.

Direct methods

Direct slots

Slot: axis ¶

Package: petalisp.core.
Type: petalisp.core:axis
Readers: split-axis.
Writers: This slot is read-only.

Slot: position ¶

Package: common-lisp.
Type: integer
Readers: split-position.
Writers: This slot is read-only.

Slot: left-child ¶

Type: petalisp.ir:buffer-shard
Readers: split-left-child.
Writers: This slot is read-only.

Slot: right-child ¶

Type: petalisp.ir:buffer-shard
Readers: split-right-child.
Writers: This slot is read-only.

Structure: stencil ¶

A stencil is a set of either load or store instructions that all have the same buffer, kernel, output mask, and scalings, and whose offsets are off by at most *STENCIL-MAX-RADIUS* from the center of the stencil (measured in steps of the corresponding range of the buffer being loaded from). The center of a stencil is a vector containing the averages of the offsets of its instructions rounded to the nearest integer.

Stencils are crucial for reasoning about memory locality. During buffer partitioning, memory that is accessed by exactly one stencil per kernel can be split by introducing ghost layers. The maximum distance of any offset from the stencil’s center determines the number of ghost layers that have to be introduced.

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: center ¶

Type: simple-vector
Readers: stencil-center.
Writers: (setf stencil-center).

Slot: instructions ¶

Type: (cons petalisp.ir:load-or-store-instruction list)
Readers: stencil-instructions.
Writers: (setf stencil-instructions).

Structure: store-instruction ¶

A store instruction represents a write to memory. It consists of a buffer that is being written to, a transformation that maps each index in the iteration space to a location in that buffer, and a single input that is the value to be written. A store instruction returns zero values.

Package

Source

load-or-store-instruction.

Direct superclasses

Direct methods

check-ir-node.
instruction-blueprint.
instruction-number-of-values.
print-object.

Structure: task ¶

A task is a collection of kernels that fully define a set of buffers. The rules for task membership are:

1. All kernels writing to a buffer B with task T have task T.

2. All buffers written to by a kernel K with task T have task T.

3. A buffer that is used by a kernel in T and that depends on a buffer in T is also in T.

Package

Source

Direct superclasses

structure-object.

Direct methods

check-ir-node.
print-object.

Direct slots

Slot: program ¶

Type: petalisp.ir:program
Initform: (quote nil)
Readers: task-program.
Writers: (setf task-program).

Slot: predecessors ¶

Type: list
Initform: (quote nil)
Readers: task-predecessors.
Writers: (setf task-predecessors).

Slot: successors ¶

Type: list
Initform: (quote nil)
Readers: task-successors.
Writers: (setf task-successors).

Slot: kernels ¶

Type: list
Initform: (quote nil)
Readers: task-kernels.
Writers: (setf task-kernels).

Slot: defined-buffers ¶

Type: list
Initform: (quote nil)
Readers: task-defined-buffers.
Writers: (setf task-defined-buffers).

Slot: number ¶

Package: common-lisp.
Type: (and unsigned-byte fixnum)
Initform: 0
Readers: task-number.
Writers: (setf task-number).

Structure: transformation ¶

A transformation with input rank N and output rank M is a mapping from lists of length N to lists of rank M.

Package

Source

Direct superclasses

structure-object.

Direct subclasses

hairy-transformation.
identity-transformation.

Direct methods

clone-reference.
clone-reference.
clone-reference.
compose-two-transformations.
compose-two-transformations.
compose-two-transformations.
inflate-transformation.
print-object.
transform-axis.
transform-index.
transform-instruction-input.
transform-instruction-input.
transform-instruction-output.
transform-instruction-output.
transform-shape.
transformation-similar.
transformation=.

Direct slots

Slot: input-rank ¶

Package: petalisp.core.
Type: petalisp.core:rank
Readers: transformation-input-rank.
Writers: This slot is read-only.

Slot: output-rank ¶

Package: petalisp.core.
Type: petalisp.core:rank
Readers: transformation-output-rank.
Writers: This slot is read-only.

Slot: input-mask ¶

Package: petalisp.core.
Type: simple-vector
Readers: transformation-input-mask.
Writers: This slot is read-only.

Slot: output-mask ¶

Package: petalisp.core.
Type: simple-vector
Readers: transformation-output-mask.
Writers: This slot is read-only.

Slot: scalings ¶

Package: petalisp.core.
Type: simple-vector
Readers: transformation-scalings.
Writers: This slot is read-only.

Slot: offsets ¶

Package: petalisp.core.
Type: simple-vector
Readers: transformation-offsets.
Writers: This slot is read-only.

Slot: inverse ¶

Package: petalisp.core.
Type: (or boolean petalisp-1.0:transformation)
Readers: transformation-inverse.
Writers: (setf transformation-inverse).

Structure: vicinity ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: left-neighbors-vec ¶

Type: simple-vector
Readers: vicinity-left-neighbors-vec.
Writers: This slot is read-only.

Slot: right-neighbors-vec ¶

Type: simple-vector
Readers: vicinity-right-neighbors-vec.
Writers: This slot is read-only.

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

5.1.9 Classes

Class: backend ¶

Package

Source

Direct subclasses

backend.
ir-backend.
reference-backend.
testing-backend.

Direct methods

backend-compute.
backend-compute.
backend-compute-asynchronously.
backend-compute-asynchronously.
(setf backend-debug-flag).
backend-debug-flag.
backend-evaluator.
backend-evaluator.
backend-evaluator.
backendp.
delete-backend.

Direct slots

Slot: %debug-flag ¶

Package: petalisp.core.
Type: boolean
Initargs: :debug
Readers: backend-debug-flag.
Writers: (setf backend-debug-flag).

Class: compile-cache-mixin ¶

Package

Source

mixins.lisp.

Direct subclasses

backend.

Direct methods

compile-blueprint.
compile-cache.

Direct slots

Slot: %compile-cache ¶

Type: petalisp.codegen::compile-cache
Initform: (petalisp.codegen::make-compile-cache)
Readers: compile-cache.
Writers: This slot is read-only.

Class: core ¶

Package

Source

Direct methods

core-memory.
core-name.
print-object.
shared-initialize.

Direct slots

Slot: %name ¶

Type: string
Initform: (alexandria:required-argument :name)
Initargs: :name
Readers: core-name.
Writers: This slot is read-only.

Slot: %memory ¶

Type: petalisp.ir:memory
Initform: (alexandria:required-argument :memory)
Initargs: :memory
Readers: core-memory.
Writers: This slot is read-only.

Class: cpp-compiler-mixin ¶

Package: petalisp.codegen.
Source: mixins.lisp.
Direct methods: compile-blueprint.

Class: cuda-compiler-mixin ¶

Package: petalisp.codegen.
Source: mixins.lisp.
Direct methods: compile-blueprint.

Class: device ¶

Package

Source

Direct methods

device-cores.
device-memory.
device-name.
print-object.

Direct slots

Slot: %name ¶

Type: string
Initform: (alexandria:required-argument :name)
Initargs: :name
Readers: device-name.
Writers: This slot is read-only.

Slot: %memory ¶

Type: petalisp.ir:memory
Initform: (alexandria:required-argument :memory)
Initargs: :memory
Readers: device-memory.
Writers: This slot is read-only.

Slot: %cores ¶

Type: (vector petalisp.ir:core)
Initargs: :cores
Readers: device-cores.
Writers: This slot is read-only.

Class: lisp-compiler-mixin ¶

Package: petalisp.codegen.
Source: mixins.lisp.
Direct subclasses: backend.
Direct methods: compile-blueprint.

Class: lisp-interpreter-mixin ¶

Package: petalisp.codegen.
Source: mixins.lisp.
Direct methods: compile-blueprint.

Class: lisp-plus-cpp-compiler-mixin ¶

Package: petalisp.codegen.
Source: mixins.lisp.
Direct methods: compile-blueprint.

Class: memory ¶

Package

Source

(setf memory-children-slot).

Direct methods

memory-bandwidth.
memory-children.
(setf memory-children-slot).
memory-children-slot.
memory-cores.
(setf memory-cores-slot).
memory-cores-slot.
memory-granularity.
memory-latency.
memory-name.
memory-parent.
memory-parent-bandwidth.
memory-size.
print-object.
shared-initialize.

Direct slots

Slot: %name ¶

Type: string
Initform: (alexandria:required-argument :name)
Initargs: :name
Readers: memory-name.
Writers: This slot is read-only.

Slot: %parent ¶

Type: (or null petalisp.ir:memory)
Initargs: :parent
Readers: memory-parent.
Writers: This slot is read-only.

Slot: %children ¶

Type

list

Initform

(quote nil)

Initargs

:children

Readers

memory-children.
memory-children-slot.

Writers

Slot: %cores ¶

Type

list

Initform

(quote nil)

Initargs

:cores

Readers

memory-cores.
memory-cores-slot.

Writers

(setf memory-cores-slot).

Slot: %size ¶

Type: unsigned-byte
Initform: (alexandria:required-argument :size)
Initargs: :size
Readers: memory-size.
Writers: This slot is read-only.

Slot: %granularity ¶

Type: unsigned-byte
Initform: (alexandria:required-argument :granularity)
Initargs: :granularity
Readers: memory-granularity.
Writers: This slot is read-only.

Slot: %latency ¶

Type: unsigned-byte
Initform: (alexandria:required-argument :latency)
Initargs: :latency
Readers: memory-latency.
Writers: This slot is read-only.

Slot: %bandwidth ¶

Type: unsigned-byte
Initform: (alexandria:required-argument :bandwidth)
Initargs: :bandwidth
Readers: memory-bandwidth.
Writers: This slot is read-only.

Slot: %parent-bandwidth ¶

Type: (or null unsigned-byte)
Initargs: :parent-bandwidth
Readers: memory-parent-bandwidth.
Writers: This slot is read-only.

Class: request ¶

Package

Source

Direct subclasses

completed-request.

Direct methods

request-completedp.
requestp.

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

5.1.10 Types

Type: axis () ¶

Package: petalisp.core.
Source: shape.lisp.

Type: index () ¶

Package: petalisp.codegen.
Source: indexing.lisp.

Type: rank () ¶

Package: petalisp.core.
Source: shape.lisp.

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

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

5.2.1 Constants

Constant: +argument-allocation-category+ ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Constant: +constant-allocation-category+ ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Constant: +empty-colorset+ ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Constant: +n-fixnum-tag-bits+ ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Constant: +result-allocation-category+ ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Constant: +table-of-primes+ ¶

Package: petalisp.utilities.
Source: prime-factors.lisp.

Constant: +worker-allocation-category-offset+ ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

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

5.2.2 Special variables

Special Variable: *alphabet* ¶

Package: petalisp.api.
Source: transform.lisp.

Special Variable: *backend-compute-recursion* ¶

Package: petalisp.core.
Source: backend.lisp.

Special Variable: *bpinfo-indices* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-instructions* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-ranges* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-reversed-functions* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-reversed-ioffsets* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-reversed-iscalings* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-reversed-levels* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-sources* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpinfo-targets* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpnames* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *bpvar-counter* ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Special Variable: *buffer-ghostspec-vector* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *buffer-shard-queue* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *buffer-shard-split-max-imbalance* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *buffer-shard-split-max-redundancy* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *buffer-shard-split-min-priority* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *buffer-shard-split-priority* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *check-count* ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Special Variable: *check-shards-buffer-shards* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *check-shards-kernel-shards* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *check-shards-table* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *check-shards-worklist* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *chunks* ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Special Variable: *failed-random-state* ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Special Variable: *free-variables* ¶

Package: petalisp.api.
Source: transform.lisp.

Special Variable: *function-cpp-info-table* ¶

Package: petalisp.codegen.
Source: cpp-from-lisp.lisp.

Special Variable: *index-ntype* ¶

Package: petalisp.codegen.
Source: indexing.lisp.

Special Variable: *instruction-table* ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Special Variable: *instruction-tables* ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Special Variable: *ir-checker-table* ¶

Package: petalisp.ir.
Source: ir-checker.lisp.

Special Variable: *ir-checker-worklist* ¶

Package: petalisp.ir.
Source: ir-checker.lisp.

Special Variable: *ir-converter* ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Special Variable: *k* ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Special Variable: *kernel-cluster-table* ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Special Variable: *layout-action-table* ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Special Variable: *nodes* ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Special Variable: *pass-count* ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Special Variable: *petalisp-view-directory* ¶

Package: petalisp.graphviz.
Source: view.lisp.

Special Variable: *pin-current-thread-code* ¶

Package: petalisp.native-backend.
Source: pin-current-thread.lisp.

Special Variable: *pin-current-thread-library* ¶

Package: petalisp.native-backend.
Source: pin-current-thread.lisp.

Special Variable: *primogenitor-buffer-shard-vector* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *prune* ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Special Variable: *simulator-step* ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Special Variable: *small-kernel-p* ¶

Whether a kernel is so small that there is no need including every detail in its blueprint.

Package: petalisp.codegen.
Source: blueprint.lisp.

Special Variable: *split-queue* ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Special Variable: *substitutions* ¶

Package: petalisp.core.
Source: substitute-lazy-arrays.lisp.

Special Variable: *suffix-factors* ¶

Package: petalisp.ir.
Source: device.lisp.

Special Variable: *table* ¶

Package: petalisp.core.
Source: reference-backend.lisp.

Special Variable: *task-cluster-table* ¶

Package: petalisp.graphviz.
Source: ir.lisp.

Special Variable: *test-count* ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Special Variable: *tests* ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Special Variable: *weight* ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Special Variable: *worker* ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Special Variable: *worklist* ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Next: Ordinary functions, Previous: Special variables, Up: Internals [Contents][Index]

5.2.3 Macros

Macro: ad-record-input-gradient-cache (ad-record index) ¶

Package: petalisp.api.
Source: differentiator.lisp.

Macro: bind (&body bindings) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Macro: buffer-dendrites (buffer) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Macro: defgenerator (name lambda-list &body body) ¶

Package: petalisp.test-suite.
Source: defgenerator.lisp.

Macro: define-float-generator (type) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Macro: defwrapper (name lambda-list &body body) ¶

Package: petalisp.test-suite.
Source: defgenerator.lisp.

Macro: do-kernel-stencils ((stencil kernel &optional result) &body body) ¶

Package: petalisp.ir.
Source: ir.lisp.

Macro: document-type (name &body body) ¶

Package: petalisp.utilities.
Source: documentation.lisp.

Macro: document-types (names &body body) ¶

Package: petalisp.utilities.
Source: documentation.lisp.

Macro: ensure-instruction-clone (instruction clone-form) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Macro: expand-documentation (form &rest examples) ¶

Package: petalisp.utilities.
Source: documentation.lisp.

Macro: maxf (place &rest numbers) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Macro: with-collector ((result-fn gather-fn) &body body) ¶

Package: petalisp.utilities.
Source: with-collectors.lisp.

Macro: with-random-state (&body body) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Macro: with-test-harness (&body body) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Macro: with-testing-backend (&body body) ¶

Package: petalisp.test-suite.
Source: testing-backend.lisp.

Next: Generic functions, Previous: Macros, Up: Internals [Contents][Index]

5.2.4 Ordinary functions

Function: %make-cenv (&key backend schedule result-shapes result-ntypes argument-shapes argument-ntypes constant-arrays constant-storage-vectors allocations) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: %make-delayed-array (storage) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: %make-delayed-fuse (&key inputs) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: %make-delayed-map (&key fnrecord inputs) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: %make-delayed-multiple-value-map (&key fnrecord inputs values-ntype refbits refbits-lock) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: %make-delayed-nth-value (&key number input) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: %make-delayed-reshape (&key transformation input) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: %make-dendrite (&key stem shape transformation depth cons) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: %make-denv (&key cenv result-arrays pointers serious-conditions serious-condition-lock request) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: %make-empty-range () ¶

Package: petalisp.core.
Source: range.lisp.

Function: %make-hairy-transformation (input-rank output-rank input-mask output-mask scalings offsets inverse) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: %make-identity-transformation (input-rank output-rank input-mask output-mask scalings offsets inverse) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: %make-kernel-shard (&key kernel iteration-space targets sources) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: %make-load-instruction (buffer transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: %make-shape (ranges rank size) ¶

Package: petalisp.core.
Source: shape.lisp.

Function: %make-stencil (&key center instructions) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: %make-store-instruction (inputs buffer transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: %make-worker (id worker-pool) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: %make-worker-pool (size) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: %requestp (object) ¶

Package: petalisp.native-backend.
Source: request.lisp.

Reader: action-copy-invocations (instance) ¶

Writer: (setf action-copy-invocations) (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: copy-invocations.

Reader: action-work-invocations (instance) ¶

Writer: (setf action-work-invocations) (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: work-invocations.

Function: actionp (object) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Reader: ad-record-alist (instance) ¶

Writer: (setf ad-record-alist) (instance) ¶

Package: petalisp.api.
Source: differentiator.lisp.
Target Slot: alist.

Function: ad-record-input-gradient (ad-record index) ¶

Package: petalisp.api.
Source: differentiator.lisp.

Reader: ad-record-input-gradient-caches (instance) ¶

Writer: (setf ad-record-input-gradient-caches) (instance) ¶

Package: petalisp.api.
Source: differentiator.lisp.
Target Slot: input-gradient-caches.

Reader: ad-record-lazy-array (instance) ¶

Package: petalisp.api.
Source: differentiator.lisp.
Target Slot: lazy-array.

Function: ad-record-output-gradient (ad-record) ¶

Package: petalisp.api.
Source: differentiator.lisp.

Reader: ad-record-output-gradient-cache (instance) ¶

Writer: (setf ad-record-output-gradient-cache) (instance) ¶

Package: petalisp.api.
Source: differentiator.lisp.
Target Slot: output-gradient-cache.

Function: add-child-kernel-shard (kernel-shard new-iteration-space) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: add-transformation-constraints (shape transformation) ¶

Package: petalisp.core.
Source: lazy-reshape.lisp.

Function: allocate-memory (allocation) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Reader: allocation-category (instance) ¶

Writer: (setf allocation-category) (instance) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.
Target Slot: category.

Reader: allocation-color (instance) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.
Target Slot: color.

Reader: allocation-size-in-bytes (instance) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.
Target Slot: size-in-bytes.

Reader: allocation-unboxed (instance) ¶

Writer: (setf allocation-unboxed) (instance) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.
Target Slot: unboxed.

Function: allocationp (object) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: argument-variables (n) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: array-element-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: array-size-in-bytes (array) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: array-storage-pointer (array) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: array-storage-vector (array) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: assign-layout (primogenitor-buffer-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: assign-layout-ghost-layer-alist (buffer-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: attempt-split (buffer-shard axis position) ¶

Attempt to split buffer shard at the supplied axis and position. If the split could be introduced successfully, or if an equivalent split already existed, return that split. Otherwise, return NIL.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: barrier () ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: base-char-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf base-char-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: batcher-odd-even-shapes (n p k) ¶

Package: petalisp.api.
Source: lazy-sort.lisp.

Function: bind-argument (denv argument index) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: bind-result (denv result index) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: blueprint-bpinfo (blueprint) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: blueprint-cpp-translatable-p (blueprint) ¶

Returns whether the supplied blueprint can be translated to C++. This is the case when each array element type has a C++ equivalent, and when all function calls therein have a C++ equivalent.

Package: petalisp.codegen.
Source: cpp-from-lisp.lisp.

Function: bpcall (number-of-values fn &rest args) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpcall-argument (bpcall &optional position) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpcall-arguments (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: arguments.

Reader: bpcall-function (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: function.

Function: bpcall-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpcall-value (bpcall &optional value-n) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpcall-values (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpcallp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpconstant-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpconstant-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpconstant-value (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: value.

Function: bpconstantp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpeval (instruction instruction-number) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpfunction-instruction-number (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpfunction-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpfunction-name (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpfunction-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpfunctionp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpindex* (&rest bpvalues) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpindex+ (&rest bpvalues) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpinfo-cpp-arguments (bpinfo) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Reader: bpinfo-functions (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: functions.

Reader: bpinfo-indices (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: indices.

Reader: bpinfo-instructions (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: instructions.

Reader: bpinfo-ioffsets (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: ioffsets.

Reader: bpinfo-iscalings (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: iscalings.

Reader: bpinfo-levels (instance) ¶

Writer: (setf bpinfo-levels) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: levels.

Reader: bpinfo-ranges (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: ranges.

Function: bpinfo-rank (bpinfo) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpinfo-sources (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: sources.

Reader: bpinfo-targets (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: targets.

Function: bpinfop (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpinstinfo (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpinstinfo-instruction-number (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: instruction-number.

Function: bpinstinfo-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpinstinfo-name (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpinstinfo-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpinstruction-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: level.

Function: bpinstruction-value (bpinstruction &optional value-n) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpinstruction-values (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: values.

Function: bpinstruction-values-ntype (bpinstruction) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpinstructionp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpioffset-instruction-number (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpioffset-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpioffset-name (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpioffset-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpioffsetp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpiref-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpiref-offset (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: offset.

Reader: bpiref-scaling (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: scaling.

Function: bpiref-values (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpirefp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpiscaling-instruction-number (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpiscaling-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpiscaling-name (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpiscaling-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpiscalingp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpload-index (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: index.

Function: bpload-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpload-source (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: source.

Function: bpload-values (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bploadp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpmemref-base (instance) ¶

Writer: (setf bpmemref-base) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: base.

Reader: bpmemref-ntype (instance) ¶

Writer: (setf bpmemref-ntype) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: ntype.

Reader: bpmemref-rank (instance) ¶

Writer: (setf bpmemref-rank) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: rank.

Reader: bpmemref-start (instance) ¶

Writer: (setf bpmemref-start) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: start.

Function: bpmemref-stencil (bpmemref index) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpmemref-stencils (instance) ¶

Writer: (setf bpmemref-stencils) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: stencils.

Function: bpmemref-stride (bpmemref axis) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpmemref-strides (instance) ¶

Writer: (setf bpmemref-strides) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: strides.

Function: bpmemrefp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpname (fmt &rest args) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bprange-end (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: end.

Reader: bprange-start (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: start.

Reader: bprange-step (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: step.

Function: bprangep (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpref (spec) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpstencil-center (instance) ¶

Writer: (setf bpstencil-center) (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: center.

Reader: bpstencil-offsets (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: offsets.

Reader: bpstencil-scalings (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: scalings.

Function: bpstencilp (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpstore-index (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: index.

Function: bpstore-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpstore-target (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: target.

Reader: bpstore-value (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: value.

Function: bpstore-values (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpstorep (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpvalue-cffi-type (bpvalue) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: bpvalue-cpp-string (bpvalue) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: bpvalue-cpp-type (bpvalue) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Reader: bpvalue-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: level.

Reader: bpvalue-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: ntype.

Function: bpvaluep (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpvariable-level (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: bpvariable-name (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Target Slot: name.

Function: bpvariable-ntype (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: bpvariablep (object) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: broadcast-ranges (range-1 range-2) ¶

Package: petalisp.api.
Source: broadcast.lisp.

Function: buffer-ghostspec (buffer) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Reader: buffer-readers (instance) ¶

Writer: (setf buffer-readers) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: readers.

Function: buffer-shard-add-reader (buffer-shard kernel-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-add-writer (buffer-shard kernel-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-bind (buffer-shard allocation) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: buffer-shard-chains (buffer-shard) ¶

A list of all chains of buffer shards writing to buffer shard and its children. Useful for debugging.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-guardian (buffer-shard) ¶

Returns the buffer shard’s oldest ancestor that has the same layout as this one. A buffer shard can be its own guardian.

Signals an error if the layout of the supplied buffer is NIL.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-infants (buffer-shard) ¶

An infant is a buffer-shard without a split. This function returns the list of infants whose line of ancestry contains the supplied buffer shard.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-label (buffer-shard) ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Function: buffer-shard-more-important-p (buffer-shard-1 buffer-shard-2) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-port (buffer-shard) ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Function: buffer-shard-queue-cleanup () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-queue-emptyp () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-queue-maybe-push (buffer-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-queue-pop () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: buffer-shard-split-priority (buffer-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Reader: buffer-shard-split-priority-cache (instance) ¶

Writer: (setf buffer-shard-split-priority-cache) (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: split-priority-cache.

Function: buffer-size-in-bytes (buffer) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: buffer-stencils-alist-blueprint (alist) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Reader: buffer-writers (instance) ¶

Writer: (setf buffer-writers) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: writers.

Function: build-documentation (docstring example-forms example-thunks) ¶

Package: petalisp.utilities.
Source: documentation.lisp.

Function: bytes-from-bits (bits) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: c128-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf c128-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: c64-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf c64-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: call-instruction-number (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf call-instruction-number) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: call-with-pinned-objects (objects thunk) ¶

Package: petalisp.utilities.
Source: with-pinned-objects.lisp.

Function: call-with-random-state (thunk) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: call-with-test-harness (thunk) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: call-with-testing-backend (thunk) ¶

Package: petalisp.test-suite.
Source: testing-backend.lisp.

Function: canonicalize-inputs (input-mask supplied-p input-rank) ¶

Package: petalisp.core.
Source: transformation-constructors.lisp.

Function: canonicalize-outputs (input-rank output-rank input-mask output-mask output-mask-supplied-p scalings scalings-supplied-p offsets offsets-supplied-p) ¶

Package: petalisp.core.
Source: transformation-constructors.lisp.

Function: canonicalize-transform-input (input) ¶

Package: petalisp.api.
Source: transform.lisp.

Reader: cenv-allocations (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: allocations.

Reader: cenv-argument-ntypes (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: argument-ntypes.

Reader: cenv-argument-shapes (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: argument-shapes.

Reader: cenv-backend (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: backend.

Reader: cenv-constant-arrays (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: constant-arrays.

Reader: cenv-constant-storage-vectors (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: constant-storage-vectors.

Reader: cenv-result-ntypes (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: result-ntypes.

Reader: cenv-result-shapes (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: result-shapes.

Reader: cenv-schedule (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: schedule.

Function: cenvp (object) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: cgraph-p (object) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Reader: cgraph-table (instance) ¶

Writer: (setf cgraph-table) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: table.

Function: character-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf character-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: check-cenv (cenv) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: check-ir-node-eventually (node) ¶

Package: petalisp.ir.
Source: ir-checker.lisp.

Function: check-program (program) ¶

Package: petalisp.ir.
Source: ir-checker.lisp.

Function: check-reverse-link (node map-object map-fn) ¶

Package: petalisp.ir.
Source: ir-checker.lisp.

Function: check-shard-eventually (shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: check-shards () ¶

Raise an error if any shards are malformed. Useful for debugging.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: class-name-p (symbol) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Reader: cnode-color (instance) ¶

Writer: (setf cnode-color) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: color.

Reader: cnode-colorset (instance) ¶

Writer: (setf cnode-colorset) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: colorset.

Reader: cnode-degree (instance) ¶

Writer: (setf cnode-degree) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: degree.

Reader: cnode-neighbors (instance) ¶

Writer: (setf cnode-neighbors) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: neighbors.

Reader: cnode-object (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: object.

Function: cnode-p (object) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Reader: cnode-queue-node (instance) ¶

Writer: (setf cnode-queue-node) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: queue-node.

Reader: cnode-saturation (instance) ¶

Writer: (setf cnode-saturation) (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.
Target Slot: saturation.

Function: cnode> (cnode1 cnode2) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: coerce-to-ntype (lazy-array ntype) ¶

Package: petalisp.api.
Source: differentiator.lisp.

Function: collect-prune-buffer-dendrites-alist (buffer) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: colorset-add (colorset color) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: colorset-contains (colorset color) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: colorset-next-free-color (colorset) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: colorset-union (colorset1 colorset2) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: combine-subsets (subset1 subset2) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: combine-tuples (tuple1 tuple2) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: compare-solutions (solutions1 solutions2) ¶

Package: petalisp.test-suite.
Source: testing-backend.lisp.

Function: compile-cache-p (object) ¶

Package: petalisp.codegen.
Source: compile-cache.lisp.

Reader: compile-cache-table (instance) ¶

Package: petalisp.codegen.
Source: compile-cache.lisp.
Target Slot: table.

Function: compute-allocations (schedule primogenitor-buffer-shard-vector unknowns backend) ¶

Returns a vector of vectors of allocations, and ensures that each layout being referenced by the supplied schedule has its allocation slot set to one of these allocations. Returns a second value that is a vector of all constant arrays that were referenced in the schedule.

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: compute-bpinfo-index (bprange level) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-bpinfo-indices () ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-bpinfo-ranges (iteration-space) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-bpmemref (spec prefix number) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-bpmemrefs (specs prefix) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-bprange (range-spec axis) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-bpstencil (irefs start strides prefix number index) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: compute-buffer-ghostspec (buffer) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: compute-buffer-shard-shape (domain buffer) ¶

Extend the domain of a buffer shard with suitable ghost layers.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: compute-delayed-array (lazy-array) ¶

Package: petalisp.core.
Source: reference-backend.lisp.

Function: compute-program-primogenitor-buffer-shard-vector (program) ¶

Returns a vector whose Nth entry is the primogenitor buffer shard corresponding to the buffer with number N.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: compute-schedule (primogenitor-buffer-shard-vector backend) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: compute-transform-input-mask (input-constraints) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: compute-transform-output-functions (output-variables output-forms) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: copy-action (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: copy-allocation (instance) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: copy-bpcall (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpconstant (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpfunction (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpinfo (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpinstinfo (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpinstruction (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpioffset (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpiref (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpiscaling (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpload (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpmemref (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bprange (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpstencil (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpstore (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpvalue (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-bpvariable (instance) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: copy-buffer (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: copy-buffer-shard (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: copy-cenv (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: copy-cgraph (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: copy-cnode (instance) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: copy-compile-cache (instance) ¶

Package: petalisp.codegen.
Source: compile-cache.lisp.

Function: copy-delayed-array (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-failure (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-fuse (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-map (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-multiple-value-map (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-nop (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-nth-value (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-range (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-reshape (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-unknown (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-delayed-wait (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: copy-dendrite (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: copy-denv (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: copy-ghostspec (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: copy-graph (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: copy-invocation (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: copy-ir-converter (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: copy-kernel (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: copy-kernel-shard (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: copy-layout (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: copy-node (instance) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Function: copy-node (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: copy-node-into (node other-node) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: copy-nucleus (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: copy-pdfs-queue (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: copy-program (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: copy-prune (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: copy-simulated-memory (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: copy-split (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: copy-stem (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: copy-subset (instance) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: copy-task (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: copy-tuple (instance) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: copy-vicinity (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: count-mapped-elements (map-fn what) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: cpp-compile-blueprint (client blueprint) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: cpp-translate-argument (argument) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: cpp-translate-blueprint (client blueprint) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: cpp-write-defun (bpinfo name arguments stream) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: cpp-write-instructions (bpinfo level stream) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Function: cpp-write-loop (bpinfo level stream) ¶

Package: petalisp.codegen.
Source: cpp-compiler.lisp.

Reader: cqueue-h-lock (instance) ¶

Writer: (setf cqueue-h-lock) (instance) ¶

Package: petalisp.cqueue.
Source: cqueue.lisp.
Target Slot: h-lock.

Reader: cqueue-head (instance) ¶

Writer: (setf cqueue-head) (instance) ¶

Package: petalisp.cqueue.
Source: cqueue.lisp.
Target Slot: head.

Reader: cqueue-t-lock (instance) ¶

Writer: (setf cqueue-t-lock) (instance) ¶

Package: petalisp.cqueue.
Source: cqueue.lisp.
Target Slot: t-lock.

Reader: cqueue-tail (instance) ¶

Writer: (setf cqueue-tail) (instance) ¶

Package: petalisp.cqueue.
Source: cqueue.lisp.
Target Slot: tail.

Function: defgeneric-name-p (symbol) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: defined-by-graphviz (&rest args) ¶

Package: petalisp.core.
Source: inspect.lisp.

Function: defun-name-p (symbol) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Reader: delayed-multiple-value-map-refbits-lock (instance) ¶

Writer: (setf delayed-multiple-value-map-refbits-lock) (instance) ¶

Package: petalisp.core.
Source: lazy-array.lisp.
Target Slot: refbits-lock.

Function: delete-kernel (kernel) ¶

Package: petalisp.ir.
Source: ir.lisp.

Reader: dendrite-cons (instance) ¶

Writer: (setf dendrite-cons) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: cons.

Reader: dendrite-depth (instance) ¶

Writer: (setf dendrite-depth) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: depth.

Function: dendrite-kernel (dendrite) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: dendrite-nucleus (dendrite) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: dendrite-p (object) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Reader: dendrite-shape (instance) ¶

Writer: (setf dendrite-shape) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: shape.

Reader: dendrite-stem (instance) ¶

Writer: (setf dendrite-stem) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: stem.

Reader: dendrite-transformation (instance) ¶

Writer: (setf dendrite-transformation) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: transformation.

Function: dendrite-validp (dendrite) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: dendrite-value-n (dendrite) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Reader: denv-cenv (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: cenv.

Reader: denv-pointers (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: pointers.

Reader: denv-request (instance) ¶

Writer: (setf denv-request) (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: request.

Reader: denv-result-arrays (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: result-arrays.

Reader: denv-serious-condition-lock (instance) ¶

Writer: (setf denv-serious-condition-lock) (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: serious-condition-lock.

Reader: denv-serious-conditions (instance) ¶

Writer: (setf denv-serious-conditions) (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: serious-conditions.

Function: denvp (object) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: destructure-transformoid (transformoid) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: differs-exactly-at (index) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: duplicates (list) ¶

Package: petalisp.ir.
Source: ir-checker.lisp.

Function: empty-range-size (instance) ¶

Package: petalisp.core.
Source: range.lisp.

Function: ensure-actions (buffer-shard backend) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: ensure-buffer-task (buffer program) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: ensure-documentation (name new-value kind) ¶

Package: petalisp.utilities.
Source: documentation.lisp.

Function: ensure-instruction-table (kernel transformation) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: ensure-kernel-shard-invocation (kernel-shard backend) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: ensure-node (kernel ir-backend) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Function: ensure-nucleus (lazy-array) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: ensure-result (cenv index result) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: ensure-tasks (root-buffers) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: enter-test (test-name) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: evaluate (denv) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: evaluator-template (number-of-results number-of-arguments) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: event-horizon (buffers depth) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: execute-node (node) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Function: expand-transform (forms) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: expect-condition (expected thunk) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: f32-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf f32-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: f64-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf f64-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: factorize-shape (shape start end) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: fallback-host-device () ¶

Package: petalisp.ir.
Source: device.lisp.

Function: file-open-p (file) ¶

Package: petalisp.graphviz.
Source: view.lisp.

Function: finalize-buffer (buffer) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: finalize-ir (root-buffers) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: finalize-kernel (kernel) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: find-optimal-buffer-shard-split-axis (buffer-shard) ¶

Returns the axis where buffer shard can be split while introducing the minimum number of ghost points, or NIL, if the buffer-shard cannot be split further. If there are multiple axes with the same number of ghost points, pick the lowest axis.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: find-optimal-buffer-shard-split-position (buffer-shard axis) ¶

Returns the position where buffer should be split such that both halves have similar size, but also such that recursive splitting results in shards that all have approximately the same split priority. The result of this function is a split position that is at most 1/6 away from the middle of the of the buffer shard’s range in the supplied axis.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: find-prune (buffer) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: fixnum-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf fixnum-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: flatten (thing) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: fnrecord-blueprint (fnrecord) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Function: fragment-difference-list (fragment1 fragment2) ¶

Package: petalisp.core.
Source: shape.lisp.

Function: fragment-intersections (fragment1 fragment2) ¶

Package: petalisp.core.
Source: shape.lisp.

Function: free-memory (allocation memory) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: free-variables (expression candidates) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: from-storage-transformation (shape) ¶

Package: petalisp.core.
Source: transformation-constructors.lisp.

Function: function-cpp-info (function-name) ¶

Returns the C++ type, function name, and kind (:infix or :prefix) of the supplied Lisp function name. Signals an error if no equivalent C++ function exists.

Package: petalisp.codegen.
Source: cpp-from-lisp.lisp.

Function: function-cpp-translatable-p (function-name) ¶

Package: petalisp.codegen.
Source: cpp-from-lisp.lisp.

Function: fusion-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: generate-double-float (&rest rest77 &key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-integer (&rest rest29 &key min max) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-lazy-array (&rest rest49 &key element-type element-generator shape-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-long-float (&rest rest77 &key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-matrix (&rest rest69 &key element-type element-generator size-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-range (&rest rest34 &key start-generator step-generator size-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-shape (&rest rest35 &key rank-generator range-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-short-float (&rest rest65 &key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: generate-single-float (&rest rest65 &key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: get-result (denv index) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Reader: ghostspec-buffer (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: buffer.

Function: ghostspec-left-padding (ghostspec axis) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Reader: ghostspec-left-padding-vec (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: left-padding-vec.

Reader: ghostspec-pattern (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: pattern.

Function: ghostspec-right-padding (ghostspec axis) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Reader: ghostspec-right-padding-vec (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: right-padding-vec.

Function: ghostspecp (object) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: graph-compute-distances (graph get-distance set-distance input-alist output-alist) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: graph-compute-node-depth (graph) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: graph-compute-node-height (graph) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: grow-dendrite (dendrite lazy-array) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: hairy-transformation-input-mask (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-input-rank (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-inverse (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: (setf hairy-transformation-inverse) (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-offsets (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-output-mask (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-output-rank (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-p (object) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hairy-transformation-scalings (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: hide-buffers (references) ¶

Package: petalisp.graphviz.
Source: ir.lisp.

Function: identity-transformation-input-mask (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: identity-transformation-input-rank (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: identity-transformation-inverse (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: (setf identity-transformation-inverse) (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: identity-transformation-offsets (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: identity-transformation-output-mask (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: identity-transformation-output-rank (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: identity-transformation-scalings (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.

Function: indices-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: insert-axis-after (lazy-array axis k) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: insert-axis-before (lazy-array axis k) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: insert-copy-kernel (iteration-space target-buffer source-buffer) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: instruction-blueprints (kernel) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Reader: instruction-buffer (instance) ¶

Writer: (setf instruction-buffer) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: buffer.

Function: interpret-kernel (kernel iteration-space targets sources environment) ¶

Package: petalisp.codegen.
Source: lisp-interpreter.lisp.

Reader: invocation-iteration-space (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: iteration-space.

Reader: invocation-kernel (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: kernel.

Reader: invocation-kfn (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: kfn.

Reader: invocation-sources (instance) ¶

Writer: (setf invocation-sources) (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: sources.

Reader: invocation-targets (instance) ¶

Writer: (setf invocation-targets) (instance) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.
Target Slot: targets.

Function: invocationp (object) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: ir-backend-array (alist index) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Reader: ir-converter-array-table (instance) ¶

Writer: (setf ir-converter-array-table) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: array-table.

Reader: ir-converter-buffer-dendrites-table (instance) ¶

Writer: (setf ir-converter-buffer-dendrites-table) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: buffer-dendrites-table.

Reader: ir-converter-cons-updates (instance) ¶

Writer: (setf ir-converter-cons-updates) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: cons-updates.

Function: ir-converter-empty-p (ir-converter) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Reader: ir-converter-kernel-size-threshold (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: kernel-size-threshold.

Reader: ir-converter-leaf-alist (instance) ¶

Writer: (setf ir-converter-leaf-alist) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: leaf-alist.

Function: ir-converter-next-nucleus (ir-converter) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Reader: ir-converter-nucleus-table (instance) ¶

Writer: (setf ir-converter-nucleus-table) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: nucleus-table.

Function: ir-converter-p (object) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Reader: ir-converter-potentially-superfluous-buffers (instance) ¶

Writer: (setf ir-converter-potentially-superfluous-buffers) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: potentially-superfluous-buffers.

Reader: ir-converter-pqueue (instance) ¶

Writer: (setf ir-converter-pqueue) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: pqueue.

Reader: ir-converter-scalar-table (instance) ¶

Writer: (setf ir-converter-scalar-table) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: scalar-table.

Reader: ir-converter-unknown-table (instance) ¶

Writer: (setf ir-converter-unknown-table) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: unknown-table.

Function: iref-instruction-inputs (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf iref-instruction-inputs) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: iref-instruction-number (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf iref-instruction-number) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: jacobi-test () ¶

Package: petalisp.test-suite.
Source: petalisp.examples.lisp.

Function: kernel-cluster (kernel) ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Reader: kernel-data (instance) ¶

Writer: (setf kernel-data) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: data.

Function: kernel-highest-instruction-number (kernel) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: kernel-number-of-inputs (kernel) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: kernel-shard-label (kernel-shard) ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Function: layout-bind (layout allocation) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: layout-label (layout domain shape) ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Function: layout-size-in-bytes (layout) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: lazy-array-size-in-bytes (lazy-array) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: lazy-array-value (lazy-array index) ¶

Package: petalisp.core.
Source: reference-backend.lisp.

Function: lazy-keysort (x y predicate) ¶

Package: petalisp.api.
Source: lazy-sort.lisp.

Function: lazy-map-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: lazy-multireshape (lazy-arrays &rest modifiers) ¶

Package: petalisp.api.
Source: lazy-reduce.lisp.

Function: lazy-rearrange-test () ¶

Package: petalisp.test-suite.
Source: petalisp.api.lisp.

Function: lazy-rearrange/normalized (lazy-array output-shape) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: lazy-reduce-aux (function lazy-arrays) ¶

Package: petalisp.api.
Source: lazy-reduce.lisp.

Function: lazy-reshape-aux (lazy-array modifier) ¶

An auxiliary function for LAZY-RESHAPE that processes a single modifier.

Package: petalisp.core.
Source: lazy-reshape.lisp.

Function: lazy-reshape-using-function (lazy-array function) ¶

Package: petalisp.core.
Source: lazy-reshape.lisp.

Function: lazy-reshape-using-shape (lazy-array shape) ¶

Package: petalisp.core.
Source: lazy-reshape.lisp.

Function: lazy-reshape-using-transformation (lazy-array transformation) ¶

Package: petalisp.core.
Source: lazy-reshape.lisp.

Function: lazy-sort-test () ¶

Package: petalisp.test-suite.
Source: petalisp.api.lisp.

Function: lazy-valuesort (x predicate) ¶

Package: petalisp.api.
Source: lazy-sort.lisp.

Function: linear-algebra-test () ¶

Package: petalisp.test-suite.
Source: petalisp.examples.lisp.

Function: linux-host-device () ¶

Package: petalisp.ir.
Source: device.lisp.

Function: lisp-compile-blueprint (client blueprint) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: lisp-translate-blueprint (client blueprint) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: listify-range-for-printing (range) ¶

Package: petalisp.api.
Source: shape-syntax.lisp.

Function: listify-shape-for-printing (shape) ¶

Package: petalisp.api.
Source: shape-syntax.lisp.

Function: load-instruction-inputs (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf load-instruction-inputs) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: load-instruction-number (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf load-instruction-number) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: macro-name-p (symbol) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: make-action (&key copy-invocations work-invocations) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: make-ad-record (lazy-array) ¶

Package: petalisp.api.
Source: differentiator.lisp.

Function: make-allocation (&key size-in-bytes category unboxed color) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: make-bpcall (&key level values function arguments) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpconstant (value) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpfunction (instruction-number) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpinfo (&key ranges indices targets sources functions ioffsets iscalings instructions levels) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpinstruction (&key level values) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpioffset (instruction-number) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpiref (&key level values offset scaling) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpiscaling (instruction-number) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpload (&key level values source index) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpmemref (&key ntype rank base start strides stencils) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bprange (&key start end step) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpstencil (&key center offsets scalings) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpstore (&key level values target index value) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpvalue (&key level ntype) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-bpvariable (&key level ntype name) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Function: make-broadcasting-transformation (source-shape target-shape &optional position) ¶

Returns a transformation that maps every element of TARGET-SHAPE to an element of SOURCE-SHAPE. In case TARGET-SHAPE has a higher rank than SOURCE-SHAPE, insert additional axes at POSITION.

Package: petalisp.api.
Source: broadcast.lisp.

Function: make-buffer-shard (&key buffer parent domain shape writers readers split-priority-cache split layout) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-buffer-shard-queue () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-call-form (function &rest arguments) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: make-call-instruction (number-of-values fnrecord inputs) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: make-cenv (backend unknowns lazy-arrays) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: make-cnode (&key neighbors object color colorset saturation degree queue-node) ¶

Package: petalisp.utilities.
Source: graph-coloring.lisp.

Function: make-compile-cache (&key table) ¶

Package: petalisp.codegen.
Source: compile-cache.lisp.

Function: make-copy-invocation (iteration-space target source backend) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: make-delayed-failure (&key condition) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-fuse (&key inputs) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-map (&key fnrecord inputs) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-multiple-value-map (&key fnrecord inputs values-ntype refbits) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-nop (&key) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-nth-value (&key number input) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-range (&key) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-reshape (&key transformation input) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-unknown (&key) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-delayed-wait (&key request delayed-action) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-dendrite (nucleus shape buffers) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: make-denv (cenv) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: make-double-float-generator (&key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-ghostspec (&key buffer left-padding-vec right-padding-vec pattern) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-html-label (&key caption properties) ¶

Package: petalisp.graphviz.
Source: utilities.lisp.

Function: make-html-table-row (property) ¶

Package: petalisp.graphviz.
Source: utilities.lisp.

Function: make-identity-transformation (rank) ¶

Package: petalisp.core.
Source: transformation-constructors.lisp.

Function: make-integer-generator (&key min max) ¶

Generate an integer between MIN (inclusive) and MAX (exclusive).

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-invocation (&key kfn kernel iteration-space targets sources) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: make-ir-converter (&key pqueue nucleus-table array-table scalar-table unknown-table leaf-alist cons-updates kernel-size-threshold potentially-superfluous-buffers buffer-dendrites-table) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: make-iref-instruction (transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: make-kernel-shard (&key kernel iteration-space targets sources) ¶

Returns a new kernel shard from the supplied keyword arguments. Ensure that this kernel shard appears in the list of writers of all of its target buffer shards, and in the list of readers of all its source buffer shards.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-layout (&key offset strides ntype size ghost-layer-alist allocation) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-lazy-array (&key shape ntype depth refcount delayed-action) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: make-lazy-array-generator (&key element-type element-generator shape-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-load-instruction (kernel buffer transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: make-long-float-generator (&key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-matrix-generator (&key element-type element-generator size-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-node (&key kernel dependencies users fn) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Function: make-node (&key predecessor-alist successor-alist object depth height eagerness affinity counter position) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: make-non-empty-range (start step size) ¶

Package: petalisp.core.
Source: range.lisp.

Function: make-nucleus (lazy-array) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: make-pdfs-queue () ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: make-prune (&key bits buffers) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: make-range (start end step) ¶

Package: petalisp.core.
Source: range.lisp.

Function: make-range-generator (&key start-generator step-generator size-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-request (&key lock cvar done) ¶

Package: petalisp.native-backend.
Source: request.lisp.

Function: make-reshape-transformation (target-shape source-shape) ¶

Returns a transformation that maps every element of the supplied target shape to an element of the supplied source shape. Signals an error if the supplied shapes don’t have the same rank.

Package: petalisp.core.
Source: lazy-reshape.lisp.

Function: make-shape-generator (&key rank-generator range-generator) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-short-float-generator (&key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-simulated-memory (allocation) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: make-single-float-generator (&key mean standard-deviation) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: make-split (&key axis position left-child right-child) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-split-queue () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-stem (&key nucleus kernel buffers validp) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: make-store-instruction (kernel input buffer transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: make-subset (&key elements weight) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: make-substitute-kernel (kernel) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: make-table-of-primes (size) ¶

Package: petalisp.utilities.
Source: prime-factors.lisp.

Function: make-transform-transformation (input-mask output-mask functions variables forms) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: make-tuple (&key subsets weight) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: make-vicinity (&key left-neighbors-vec right-neighbors-vec) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: make-work-invocation (kernel-shard backend) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: make-worker-pool (size) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: maxdepth (lazy-arrays) ¶

Package: petalisp.core.
Source: lazy-array.lisp.

Function: maybe-add-to-stencil (instruction stencil) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: maybe-prune (prune) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: merge-actions (action1 action2) ¶

Package: petalisp.native-backend.
Source: scheduling.lisp.

Function: mergeable-dendrites-p (d1 d2) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: message (format-string &rest arguments) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: mksym (fmt &rest args) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: multiple-arguments () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: native-backend-unpack (layout denv) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: ndarray (rank) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: next-bpvar (&key level ntype) ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.

Reader: node-affinity (instance) ¶

Writer: (setf node-affinity) (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: affinity.

Reader: node-counter (instance) ¶

Writer: (setf node-counter) (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: counter.

Reader: node-dependencies (instance) ¶

Writer: (setf node-dependencies) (instance) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.
Target Slot: dependencies.

Reader: node-eagerness (instance) ¶

Writer: (setf node-eagerness) (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: eagerness.

Reader: node-fn (instance) ¶

Writer: (setf node-fn) (instance) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.
Target Slot: fn.

Reader: node-kernel (instance) ¶

Writer: (setf node-kernel) (instance) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.
Target Slot: kernel.

Function: node-more-important-p (node1 node2) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Reader: node-object (instance) ¶

Writer: (setf node-object) (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: object.

Function: node-p (object) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.

Reader: node-position (instance) ¶

Writer: (setf node-position) (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: position.

Reader: node-users (instance) ¶

Writer: (setf node-users) (instance) ¶

Package: petalisp.codegen.
Source: ir-backend.lisp.
Target Slot: users.

Function: nth-prime-max-bits (n) ¶

Package: petalisp.utilities.
Source: prime-factors.lisp.

Function: nth-prime-upper-bound (n) ¶

Package: petalisp.utilities.
Source: prime-factors.lisp.

Function: ntype-bits-per-element (ntype) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Function: ntype-cpp-info (ntype &optional errorp) ¶

Package: petalisp.codegen.
Source: cpp-from-lisp.lisp.

Function: ntype-cpp-translatable-p (ntype) ¶

Package: petalisp.codegen.
Source: cpp-from-lisp.lisp.

Function: ntype-unboxed-p (ntype) ¶

Package: petalisp.native-backend.
Source: allocation.lisp.

Reader: nucleus-dendrites (instance) ¶

Writer: (setf nucleus-dendrites) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: dendrites.

Reader: nucleus-lazy-array (instance) ¶

Writer: (setf nucleus-lazy-array) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: lazy-array.

Function: nucleus-ntype (nucleus) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: nucleus-p (object) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: nucleus-shape (nucleus) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: parse-cache-type (string) ¶

Package: petalisp.ir.
Source: device.lisp.

Function: parse-defwrapper-lambda-list (lambda-list) ¶

Package: petalisp.test-suite.
Source: defgenerator.lisp.

Function: parse-integer-set (string) ¶

Package: petalisp.ir.
Source: device.lisp.

Function: parse-shape (syntax) ¶

Package: petalisp.api.
Source: shape-syntax.lisp.

Function: parse-shape-pattern (syntax) ¶

Package: petalisp.api.
Source: shape-syntax.lisp.

Function: parse-size (string &key start end) ¶

Package: petalisp.ir.
Source: device.lisp.

Function: parse-transform-inputs (inputs) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: parse-transform-output (output input-variables) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: parse-transform-outputs (outputs input-variables) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: partition-dendrites (dendrites) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: pass () ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: pdfs-queue-increase-node-eagerness (pdfs-queue node increment) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: pdfs-queue-p (object) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: pdfs-queue-pop (pdfs-queue) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Reader: pdfs-queue-priority-queue (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: priority-queue.

Function: pdfs-queue-push (pdfs-queue node) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Function: pdfs-queue-size (pdfs-queue) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.

Reader: pdfs-queue-tmpnode (instance) ¶

Writer: (setf pdfs-queue-tmpnode) (instance) ¶

Package: petalisp.scheduling.
Source: scheduling.lisp.
Target Slot: tmpnode.

Function: pin-current-thread (cpu-number) ¶

Ensure that the current thread will only run on the specified CPU. Returns whether the pinning was successful.

Package: petalisp.native-backend.
Source: pin-current-thread.lisp.

Function: plist-union (&rest plists) ¶

Package: petalisp.graphviz.
Source: utilities.lisp.

Function: potentially-superfluous-buffer-p (buffer dendrites) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: primogenitor-buffer-shard (buffer) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: print-package-statistics (package &optional stream) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: print-platform-information (&optional stream) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: print-system-statistics (system &optional stream) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: propagate-split (split) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: propagate-split/bmap (function kernel-shard axis position) ¶

Map the supplied function over all split-worthy buffer shards neighboring the supplied kernel shard. At the same time, change the coordinate system from the supplied axis and position from to that of each buffer shard being mapped over and pass the resulting axis and position as additional arguments to the supplied function.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: propagate-split/kmap (function buffer-shard axis position) ¶

Map the supplied function over all kernel shards neighboring the supplied buffer shard. At the same time, change the coordinate system from the supplied axis and position from to that of each kernel shard being mapped over and pass the resulting axis and position as additional arguments to the supplied function.

Package: petalisp.ir.
Source: partitioning.lisp.

Reader: prune-bits (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: bits.

Reader: prune-buffers (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: buffers.

Function: prune-p (object) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: prune-superfluous-buffers (potentially-superfluous-buffers) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: purge-unused-files-in-directory (directory) ¶

Delete all files in the supplied directory that are not currently open.

Package: petalisp.graphviz.
Source: view.lisp.

Function: range-difference-list--contiguous (start1 last1 start2 last2 step2 make-range-fn) ¶

Package: petalisp.core.
Source: range.lisp.

Function: range-difference-list--single (range index) ¶

Package: petalisp.core.
Source: range.lisp.

Function: range-intersection-start-end-step (range1 range2) ¶

Package: petalisp.core.
Source: range.lisp.

Function: range-peeler (amount-specifier) ¶

Package: petalisp.api.
Source: reshapers.lisp.

Function: range-slicer (slice-specifier) ¶

Package: petalisp.api.
Source: reshapers.lisp.

Function: range-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: ranges-blueprint (ranges) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Function: rbgs-test () ¶

Package: petalisp.test-suite.
Source: petalisp.examples.lisp.

Function: recompute-kernel-instruction-vector (kernel) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: recompute-program-task-vector (program) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: reduction-of-fusions () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: reduction-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: reference-to-delayed-unknown () ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: refine-buffer-shard (iteration-space transformoid buffer-shard) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: refine-kernel-shard (kernel-shard) ¶

Replace any of the kernel shard’s sources or targets that have one or more splits with the most specific buffer shard in that tree of splits that still provides all the data referenced by the kernel shard. Update the writers and readers slot of all affected buffers accordingly.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: refine-source (kernel-or-kernel-shard iteration-space source) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: refine-target (kernel-or-kernel-shard iteration-space target) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: register-free-variable (free-variable) ¶

Package: petalisp.api.
Source: transform.lisp.

Function: relative-position (iteration-space transformoid axis position) ¶

Returns either :LEFT, :RIGHT, or :BOTH, depending how the iteration space relates to the supplied transformoid.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: remove-axis-after (lazy-array axis) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: remove-axis-before (lazy-array axis) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: report (test-count pass-count) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Reader: request-cvar (instance) ¶

Package: petalisp.native-backend.
Source: request.lisp.
Target Slot: cvar.

Reader: request-done (instance) ¶

Writer: (setf request-done) (instance) ¶

Package: petalisp.native-backend.
Source: request.lisp.
Target Slot: done.

Reader: request-lock (instance) ¶

Package: petalisp.native-backend.
Source: request.lisp.
Target Slot: lock.

Function: reshape-randomly (array) ¶

Package: petalisp.test-suite.
Source: generators.lisp.

Function: reshape-test () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: reshape/flatten (lazy-array start end) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: reshape/unflatten (lazy-array shape start end) ¶

Package: petalisp.api.
Source: lazy-rearrange.lisp.

Function: result-variables (n) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: reverse-transform-axis-and-position (transformoid axis position) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: s16-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf s16-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: s32-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf s32-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: s64-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf s64-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: s8-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf s8-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: select-masked-elements (list bitmask) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Function: shape-strides (shape) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Reader: shape-table-ht (instance) ¶

Package: petalisp.core.
Source: shape.lisp.
Target Slot: ht.

Function: simplify-array (array) ¶

Returns an array with the same shape and elements as ARRAY, but that is guaranteed to be simple.

Package: petalisp.core.
Source: lazy-array.lisp.

Function: simplify-input (input) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: simplify-input (input) ¶

Package: petalisp.graphviz.
Source: ir.lisp.

Function: simulate-cenv-evaluation (cenv) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: simulate-references (layout shape) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Reader: simulated-memory-allocation (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: allocation.

Reader: simulated-memory-generation (instance) ¶

Writer: (setf simulated-memory-generation) (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: generation.

Reader: simulated-memory-mode (instance) ¶

Writer: (setf simulated-memory-mode) (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: mode.

Function: simulated-memory-p (object) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: simulated-memory-read-index (simulated-memory index) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: simulated-memory-read-shape (simulated-memory shape) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Reader: simulated-memory-table (instance) ¶

Writer: (setf simulated-memory-table) (instance) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.
Target Slot: table.

Function: simulated-memory-write-index (simulated-memory index) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: simulated-memory-write-shape (simulated-memory shape) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Function: size-one-range-removing-transformation (shape) ¶

Package: petalisp.core.
Source: transformation-constructors.lisp.

Function: split-label (split) ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.

Function: split-more-important-p (split-1 split-2) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: split-queue-emptyp () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: split-queue-pop () ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: split-queue-push (split) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: start-worker (worker) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Reader: stem-buffers (instance) ¶

Writer: (setf stem-buffers) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: buffers.

Reader: stem-kernel (instance) ¶

Writer: (setf stem-kernel) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: kernel.

Reader: stem-nucleus (instance) ¶

Writer: (setf stem-nucleus) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: nucleus.

Function: stem-p (object) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.

Reader: stem-validp (instance) ¶

Writer: (setf stem-validp) (instance) ¶

Package: petalisp.ir.
Source: ir-conversion.lisp.
Target Slot: validp.

Function: stencil-instruction-offsets (stencil instruction) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Function: stencils-blueprint (stencils) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Function: store-instruction-inputs (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf store-instruction-inputs) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: store-instruction-number (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: (setf store-instruction-number) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: store-instruction-offsets (store-instruction) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: store-instruction-scalings (store-instruction) ¶

Package: petalisp.codegen.
Source: lisp-compiler.lisp.

Function: stringify (x) ¶

Package: petalisp.graphviz.
Source: utilities.lisp.

Function: subdivide-fragments (old-fragments new-fragment) ¶

Takes a list of fragments whose shapes are disjoint, and one new
fragment, and returns a list of disjoint fragments that partition the old fragments and the new fragment. The resulting list consists of three parts:

1. One fragment for each old fragment that has an intersection with the new fragment. Its shape is that intersection, and its mask is the LOGIOR of the mask of the old fragment and the mask of the new fragment.

2. All elements of the fragment difference list of any old fragment and the new fragment. Their masks are the same as those of the old fragment they were derived from.

3. Fragments that, together, cover every part of the new fragment that is not already covered by the intersections from the first step. Each one has the same mask as the new fragment.

Package: petalisp.core.
Source: shape.lisp.

Reader: subset-elements (instance) ¶

Writer: (setf subset-elements) (instance) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.
Target Slot: elements.

Function: subset-p (object) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Reader: subset-weight (instance) ¶

Writer: (setf subset-weight) (instance) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.
Target Slot: weight.

Function: subtract-fragment-lists (fragment-list1 fragment-list2) ¶

Package: petalisp.core.
Source: shape.lisp.

Function: suffix-factor (suffix) ¶

Package: petalisp.ir.
Source: device.lisp.

Function: sum-axis (array axis) ¶

Package: petalisp.api.
Source: differentiator.lisp.

Function: sum-of-pairs () ¶

Package: petalisp.test-suite.
Source: petalisp.core.lisp.

Function: symbol-defined-p (symbol) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: symbol-methods (symbol) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: system-git-revision (system) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: system-source-file-pathnames (system) ¶

Package: petalisp.test-suite.
Source: code-statistics.lisp.

Function: task-cluster (task) ¶

Package: petalisp.graphviz.
Source: ir.lisp.

Reader: task-defined-buffers (instance) ¶

Writer: (setf task-defined-buffers) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: defined-buffers.

Reader: task-kernels (instance) ¶

Writer: (setf task-kernels) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: kernels.

Reader: task-predecessors (instance) ¶

Writer: (setf task-predecessors) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: predecessors.

Reader: task-successors (instance) ¶

Writer: (setf task-successors) (instance) ¶

Package: petalisp.ir.
Source: ir.lisp.
Target Slot: successors.

Function: touch (object) ¶

Package: petalisp.utilities.
Source: with-pinned-objects.lisp.

Function: transform-axis-and-position (transformoid axis position) ¶

Package: petalisp.ir.
Source: partitioning.lisp.

Function: transform-buffer (buffer transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: transform-kernel (kernel transformation) ¶

Package: petalisp.ir.
Source: ir.lisp.

Function: transformation-input-symbol (position) ¶

Package: petalisp.api.
Source: transform.lisp.

Reader: transformation-inverse (instance) ¶

Writer: (setf transformation-inverse) (instance) ¶

Package: petalisp.core.
Source: transformation.lisp.
Target Slot: inverse.

Function: trivial-object-p (object) ¶

Returns whether the supplied OBJECT is an array, a lazy array that can be cheaply converted to an array, or a scalar.

Package: petalisp.core.
Source: lazy-array.lisp.

Function: trivial-object-value (object) ¶

Returns the value of an OBJECT that is trivial in the sense of TRIVIAL-OBJECT-P.

Package: petalisp.core.
Source: lazy-array.lisp.

Function: tuple-from-object (object) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: tuple-p (object) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: tuple-subset (tuple index) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Reader: tuple-subsets (instance) ¶

Writer: (setf tuple-subsets) (instance) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.
Target Slot: subsets.

Reader: tuple-weight (instance) ¶

Writer: (setf tuple-weight) (instance) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.
Target Slot: weight.

Function: tuple> (tuple1 tuple2) ¶

Package: petalisp.karmarkar-karp.
Source: karmarkar-karp.lisp.

Function: type-specifier-p (object) ¶

Package: petalisp.test-suite.
Source: test-suite.lisp.

Function: u1-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u1-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: u16-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u16-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: u2-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u2-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: u32-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u32-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: u4-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u4-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: u64-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u64-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: u8-memref (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: (setf u8-memref) (pointer offset) ¶

Package: petalisp.native-backend.
Source: compilation.lisp.

Function: unlink-kernel-shard (kernel-shard) ¶

Ensure that no buffer shards reference this kernel shard.

Package: petalisp.ir.
Source: partitioning.lisp.

Function: v-cycle-test () ¶

Package: petalisp.test-suite.
Source: petalisp.examples.lisp.

Function: value-blueprint (value) ¶

Package: petalisp.codegen.
Source: blueprint.lisp.

Reader: vicinity-left-neighbors-vec (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: left-neighbors-vec.

Reader: vicinity-right-neighbors-vec (instance) ¶

Package: petalisp.ir.
Source: partitioning.lisp.
Target Slot: right-neighbors-vec.

Reader: worker-barrier-sense (instance) ¶

Writer: (setf worker-barrier-sense) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: barrier-sense.

Function: worker-enqueue (worker thunk) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: worker-evaluate (denv) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Reader: worker-id (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: id.

Function: worker-loop () ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: worker-pool-active (worker-pool) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Reader: worker-pool-barrier-countdown (instance) ¶

Writer: (setf worker-pool-barrier-countdown) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: barrier-countdown.

Reader: worker-pool-barrier-sense (instance) ¶

Writer: (setf worker-pool-barrier-sense) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: barrier-sense.

Function: worker-pool-join (worker-pool) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Reader: worker-pool-liveness (instance) ¶

Writer: (setf worker-pool-liveness) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: liveness.

Function: worker-pool-p (object) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: worker-pool-size (worker-pool) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Function: worker-pool-worker (worker-pool worker-id) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Reader: worker-pool-workers (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: workers.

Reader: worker-queue (instance) ¶

Writer: (setf worker-queue) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: queue.

Reader: worker-serious-conditions (instance) ¶

Writer: (setf worker-serious-conditions) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: serious-conditions.

Function: worker-synchronize-and-invoke (denv invocations) ¶

Package: petalisp.native-backend.
Source: evaluator.lisp.

Reader: worker-thread (instance) ¶

Writer: (setf worker-thread) (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: thread.

Reader: worker-worker-pool (instance) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.
Target Slot: worker-pool.

Function: workerp (object) ¶

Package: petalisp.native-backend.
Source: worker-pool.lisp.

Next: Method combinations, Previous: Ordinary functions, Up: Internals [Contents][Index]

5.2.5 Generic functions

Generic Function: approximately-equal (a b) ¶

Package

Source

testing-backend.lisp.

Methods

Method: approximately-equal ((a double-float) (b double-float)) ¶

Method: approximately-equal ((a single-float) (b single-float)) ¶

Method: approximately-equal ((array-1 array) (array-2 array)) ¶

Method: approximately-equal (a b) ¶

Method: approximately-equal ((a delayed-array) (b delayed-array)) ¶

Generic Reader: backend-worker-pool (backend) ¶

Package

Source

Methods

Reader Method: backend-worker-pool ((backend backend)) ¶

automatically generated reader method

Target Slot: %worker-pool.

Generic Function: bpinstruction-form (client bpinstruction) ¶

Package

Source

lisp-compiler.lisp.

Methods

Method: bpinstruction-form (client (bpcall bpcall)) ¶

Method: bpinstruction-form (client (bpload bpload)) ¶

Method: bpinstruction-form (client (bpstore bpstore)) ¶

Method: bpinstruction-form (client (bpiref bpiref)) ¶

Generic Function: bpvalue-form (client bpvalue) ¶

Package

Source

lisp-compiler.lisp.

Methods

Method: bpvalue-form (client (bpconstant bpconstant)) ¶

Method: bpvalue-form (client (bpvariable bpvariable)) ¶

Generic Function: bpvalue= (v1 v2) ¶

Package

Source

Methods

Method: bpvalue= ((v1 bpvariable) (v2 bpvariable)) ¶

Method: bpvalue= ((v1 bpconstant) (v2 bpconstant)) ¶

Method: bpvalue= ((v1 bpvalue) (v2 bpvalue)) ¶

Generic Function: check-ir-node (node) ¶

Package

Source

ir-checker.lisp.

Methods

Method: check-ir-node ((task task)) ¶

Method: check-ir-node :after ((store-instruction store-instruction)) ¶

Method: check-ir-node ((instruction instruction)) ¶

Method: check-ir-node ((kernel kernel)) ¶

Method: check-ir-node ((buffer buffer)) ¶

Method: check-ir-node ((program program)) ¶

Method: check-ir-node :around (object) ¶

Generic Function: check-shard (shard) ¶

Package

Source

Methods

Method: check-shard ((kernel-shard kernel-shard)) ¶

Method: check-shard ((buffer-shard buffer-shard)) ¶

Generic Function: clone-reference (value-n instruction kernel transformation) ¶

Package

Source

Methods

Method: clone-reference ((value-n (eql 0)) (load-instruction load-instruction) (kernel kernel) (transformation transformation)) ¶

Method: clone-reference ((value-n (eql 0)) (iref-instruction iref-instruction) (kernel kernel) (transformation transformation)) ¶

Method: clone-reference ((value-n integer) (call-instruction call-instruction) (kernel kernel) (transformation transformation)) ¶

Generic Reader: compile-cache (object) ¶

Package

Methods

Reader Method: compile-cache ((compile-cache-mixin compile-cache-mixin)) ¶

automatically generated reader method

Source: mixins.lisp.
Target Slot: %compile-cache.

Generic Function: compose-two-transformations (g f) ¶

Package

Source

Methods

Method: compose-two-transformations ((g hairy-transformation) (f hairy-transformation)) ¶

Method: compose-two-transformations ((g transformation) (f identity-transformation)) ¶

Method: compose-two-transformations ((g identity-transformation) (f transformation)) ¶

Method: compose-two-transformations :before ((g transformation) (f transformation)) ¶

Generic Function: convert-nucleus (nucleus lazy-array delayed-action) ¶

Package

Source

Methods

Method: convert-nucleus ((nucleus nucleus) (lazy-array lazy-array) (delayed-multiple-value-map delayed-multiple-value-map)) ¶

Method: convert-nucleus ((nucleus nucleus) (lazy-array lazy-array) (delayed-action delayed-action)) ¶

Method: convert-nucleus :around ((nucleus nucleus) (lazy-array lazy-array) (delayed-action delayed-action)) ¶

Generic Function: delayed-action-value (delayed-action index) ¶

Package

reference-backend.lisp.

Source

Methods

Method: delayed-action-value ((delayed-failure delayed-failure) index) ¶

Method: delayed-action-value ((delayed-unknown delayed-unknown) index) ¶

Method: delayed-action-value ((delayed-nop delayed-nop) index) ¶

Method: delayed-action-value ((delayed-array delayed-array) index) ¶

Method: delayed-action-value ((delayed-range delayed-range) index) ¶

Method: delayed-action-value ((delayed-fuse delayed-fuse) index) ¶

Method: delayed-action-value ((delayed-reshape delayed-reshape) index) ¶

Method: delayed-action-value ((delayed-nth-value delayed-nth-value) index) ¶

Method: delayed-action-value ((delayed-multiple-value-map delayed-multiple-value-map) index) ¶

Method: delayed-action-value ((delayed-map delayed-map) index) ¶

Generic Function: graphviz-default-graph (node) ¶

Package

Source

Methods

Method: graphviz-default-graph ((node node)) ¶

Source: scheduling.lisp.

Method: graphviz-default-graph ((node buffer-shard)) ¶

Source: partitioning.lisp.

Method: graphviz-default-graph ((node kernel-shard)) ¶

Source: partitioning.lisp.

Method: graphviz-default-graph ((node buffer)) ¶

Source: ir.lisp.

Method: graphviz-default-graph ((node kernel)) ¶

Source: ir.lisp.

Method: graphviz-default-graph ((node lazy-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-default-graph ((list cons)) ¶

Method: graphviz-default-graph (node) ¶

Method: graphviz-default-graph :around (node) ¶

Generic Function: graphviz-edge-attributes (graph edge from to edge-number) ¶

Package

Source

Method Combination

graphviz-attributes.

Methods

Method: graphviz-edge-attributes ((graph scheduling-graph) (edge scheduling-edge) (from node) (to node) (n integer)) ¶

Source: scheduling.lisp.

Method: graphviz-edge-attributes ((graph class-diagram) (edge direct-subclass-edge) (from class) (to class) edge-number) ¶

Source: class-diagram.lisp.

Method: graphviz-edge-attributes ((graph partitioning-graph) (edge writer-edge) (from kernel-shard) (to buffer-shard) n) ¶

Source: partitioning.lisp.

Method: graphviz-edge-attributes ((graph partitioning-graph) (edge reader-edge) (to buffer-shard) (from kernel-shard) n) ¶

Source: partitioning.lisp.

Method: graphviz-edge-attributes ((graph petalisp-graph) (edge petalisp-edge) form to edge-number) ¶

Source: petalisp.lisp.

Method: graphviz-edge-attributes ((graph any-graph) (edge any-edge) from to edge-number) ¶

Generic Function: graphviz-graph-attributes (graph) ¶

Package

Source

Method Combination

graphviz-attributes.

Methods

Method: graphviz-graph-attributes ((graph class-diagram)) ¶

Source: class-diagram.lisp.

Method: graphviz-graph-attributes ((graph petalisp-graph)) ¶

Source: petalisp.lisp.

Method: graphviz-graph-attributes ((graph any-graph)) ¶

Generic Function: graphviz-incoming-edge-origins (graph edge node) ¶

Package

Source

Methods

Method: graphviz-incoming-edge-origins ((graph class-diagram) (edge direct-subclass-edge) (class class)) ¶

Source: class-diagram.lisp.

Method: graphviz-incoming-edge-origins ((graph ir-graph) (edge load-edge) (kernel kernel)) ¶

Source: ir.lisp.

Method: graphviz-incoming-edge-origins ((graph ir-graph) (edge input-edge) (buffer buffer)) ¶

Source: ir.lisp.

Method: graphviz-incoming-edge-origins ((graph data-flow-graph) (edge data-flow-edge) (lazy-array lazy-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-incoming-edge-origins ((graph any-graph) (edge any-edge) node) ¶

Generic Function: graphviz-known-nodes (graph node) ¶

Package

Source

Method Combination

append.

Options: :most-specific-first

Methods

Method: graphviz-known-nodes append ((graph scheduling-graph) (node node)) ¶

Source: scheduling.lisp.

Method: graphviz-known-nodes append ((graph any-graph) node) ¶

Generic Function: graphviz-node-attributes (graph node) ¶

Package

Source

Method Combination

graphviz-attributes.

Methods

Method: graphviz-node-attributes ((graph ir-graph) (node buffer)) ¶

Source: ir.lisp.

Method: graphviz-node-attributes ((graph ir-graph) (node kernel)) ¶

Source: ir.lisp.

Method: graphviz-node-attributes ((graph data-flow-graph) (node delayed-reshape)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-attributes ((graph data-flow-graph) (node delayed-fuse)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-attributes ((graph data-flow-graph) (node delayed-map)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-attributes ((graph data-flow-graph) (node delayed-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-attributes ((graph data-flow-graph) (node lazy-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-attributes ((graph petalisp-graph) node) ¶

Source: petalisp.lisp.

Method: graphviz-node-attributes ((graph any-graph) node) ¶

Generic Function: graphviz-node-caption (graph node) ¶

Package

Source

Methods

Method: graphviz-node-caption ((graph data-flow-graph) (node lazy-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-caption ((graph any-graph) node) ¶

Generic Function: graphviz-node-properties (graph node) ¶

Package

Source

Method Combination

append.

Options: :most-specific-first

Methods

Method: graphviz-node-properties append ((graph scheduling-graph) (node node)) ¶

Source: scheduling.lisp.

Method: graphviz-node-properties append ((graph ir-graph) (kernel kernel)) ¶

Source: ir.lisp.

Method: graphviz-node-properties append ((graph ir-graph) (buffer buffer)) ¶

Source: ir.lisp.

Method: graphviz-node-properties append ((graph data-flow-graph) (node delayed-reshape)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-properties append ((graph data-flow-graph) (node delayed-map)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-properties append ((graph data-flow-graph) (delayed-array delayed-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-properties append ((graph data-flow-graph) (delayed-nth-value delayed-nth-value)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-properties append ((graph data-flow-graph) (node lazy-array)) ¶

Source: data-flow-graph.lisp.

Method: graphviz-node-properties append ((graph any-graph) node) ¶

Generic Function: graphviz-outgoing-edge-targets (graph edge node) ¶

Package

Source

Methods

Method: graphviz-outgoing-edge-targets ((graph scheduling-graph) (edge scheduling-edge) (node node)) ¶

Source: scheduling.lisp.

Method: graphviz-outgoing-edge-targets ((graph ir-graph) (edge store-edge) (kernel kernel)) ¶

Source: ir.lisp.

Method: graphviz-outgoing-edge-targets ((graph ir-graph) (edge output-edge) (buffer buffer)) ¶

Source: ir.lisp.

Method: graphviz-outgoing-edge-targets ((graph any-graph) (edge any-edge) node) ¶

Generic Function: graphviz-potential-edges (graph node) ¶

Package

Source

Method Combination

append.

Options: :most-specific-first

Methods

Method: graphviz-potential-edges append ((graph scheduling-graph) node) ¶

Source: scheduling.lisp.

Method: graphviz-potential-edges append ((graph class-diagram) (class class)) ¶

Source: class-diagram.lisp.

Method: graphviz-potential-edges append ((graph ir-graph) node) ¶

Source: ir.lisp.

Method: graphviz-potential-edges append ((graph data-flow-graph) node) ¶

Source: data-flow-graph.lisp.

Method: graphviz-potential-edges append ((graph any-graph) node) ¶

Generic Function: grow-dendrite-aux (dendrite lazy-array delayed-action) ¶

Package

Source

Methods

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-failure delayed-failure)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-wait delayed-wait)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-unknown delayed-unknown)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-range delayed-range)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-array delayed-array)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-nth-value delayed-nth-value)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-map delayed-map)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-reshape delayed-reshape)) ¶

Method: grow-dendrite-aux ((dendrite dendrite) (lazy-array lazy-array) (delayed-fuse delayed-fuse)) ¶

Method: grow-dendrite-aux :around ((dendrite dendrite) (lazy-array lazy-array) (delayed-action delayed-action)) ¶

Generic Function: input-gradient (lazy-array delayed-action output-gradient index) ¶

Package

petalisp.api.

Source

differentiator.lisp.

Methods

Method: input-gradient ((lazy-array lazy-array) (delayed-reshape delayed-reshape) (output-gradient lazy-array) (index (eql 0))) ¶

Method: input-gradient ((lazy-array lazy-array) (delayed-fuse delayed-fuse) (output-gradient lazy-array) index) ¶

Method: input-gradient ((lazy-array lazy-array) (delayed-map delayed-map) (output-gradient lazy-array) index) ¶

Generic Function: instruction-blueprint (instruction kernel) ¶

Package

Source

blueprint.lisp.

Methods

Method: instruction-blueprint ((iref-instruction iref-instruction) (kernel kernel)) ¶

Method: instruction-blueprint ((store-instruction store-instruction) (kernel kernel)) ¶

Method: instruction-blueprint ((load-instruction load-instruction) (kernel kernel)) ¶

Method: instruction-blueprint ((call-instruction call-instruction) (kernel kernel)) ¶

Generic Reader: ir-backend-compile-cache (object) ¶

Package

Methods

Reader Method: ir-backend-compile-cache ((ir-backend ir-backend)) ¶

automatically generated reader method

Source: ir-backend.lisp.
Target Slot: %compile-cache.

Generic Reader: ir-backend-compiled (object) ¶

Package

Methods

Reader Method: ir-backend-compiled ((testing-backend testing-backend)) ¶

automatically generated reader method

Source: testing-backend.lisp.
Target Slot: %ir-backend-compiled.

Generic Reader: ir-backend-interpreted (object) ¶

Package

Methods

Reader Method: ir-backend-interpreted ((testing-backend testing-backend)) ¶

automatically generated reader method

Source: testing-backend.lisp.
Target Slot: %ir-backend-interpreted.

Generic Reader: ir-backend-mode (object) ¶

Package

Methods

Reader Method: ir-backend-mode ((ir-backend ir-backend)) ¶

automatically generated reader method

Source: ir-backend.lisp.
Target Slot: %mode.

Generic Reader: memory-children-slot (object) ¶

Package

Methods

Reader Method: memory-children-slot ((memory memory)) ¶

automatically generated reader method

Source: device.lisp.
Target Slot: %children.

Generic Writer: (setf memory-children-slot) (object) ¶

Package

Methods

Writer Method: (setf memory-children-slot) ((memory memory)) ¶

automatically generated writer method

Source: device.lisp.
Target Slot: %children.

Generic Reader: memory-cores-slot (object) ¶

Package

Methods

Reader Method: memory-cores-slot ((memory memory)) ¶

automatically generated reader method

Source: device.lisp.
Target Slot: %cores.

Generic Writer: (setf memory-cores-slot) (object) ¶

Package

Methods

Writer Method: (setf memory-cores-slot) ((memory memory)) ¶

automatically generated writer method

Source: device.lisp.
Target Slot: %cores.

Generic Reader: native-backend (object) ¶

Package

Methods

Reader Method: native-backend ((testing-backend testing-backend)) ¶

automatically generated reader method

Source: testing-backend.lisp.
Target Slot: %native-backend.

Generic Reader: reference-backend (object) ¶

Package

Methods

Reader Method: reference-backend ((testing-backend testing-backend)) ¶

automatically generated reader method

Source: testing-backend.lisp.
Target Slot: %reference-backend.

Generic Reader: serious-conditions (condition) ¶

Package

Methods

Reader Method: serious-conditions ((condition evaluation-failure)) ¶

Source: evaluator.lisp.
Target Slot: %serious-conditions.

Generic Function: transform-instruction-input (instruction transformation) ¶

Package

Source

Methods

Method: transform-instruction-input ((instruction instruction) (transformation transformation)) ¶

Method: transform-instruction-input ((instruction iterating-instruction) (transformation transformation)) ¶

Generic Function: transform-instruction-output (instruction transformation) ¶

Package

Source

Methods

Method: transform-instruction-output ((instruction instruction) (transformation transformation)) ¶

Method: transform-instruction-output ((instruction iterating-instruction) (transformation transformation)) ¶

Generic Function: trivial-lazy-array-p (lazy-array delayed-action) ¶

Returns whether the supplied LAZY-ARRAYS and its DELAYED-ACTION have a corresponding deflated array that can be obtained cheaply.

Package

Source

Methods

Method: trivial-lazy-array-p ((lazy-array lazy-array) (delayed-action delayed-action)) ¶

Method: trivial-lazy-array-p ((lazy-array lazy-array) (delayed-array delayed-array)) ¶

Method: trivial-lazy-array-p ((lazy-array lazy-array) (delayed-reshape delayed-reshape)) ¶

Generic Function: trivial-lazy-array-value (lazy-array delayed-action) ¶

Obtain the array corresponding to the supplied LAZY-ARRAY, which must be trivial in the sense of TRIVIAL-LAZY-ARRAY-P.

Package

Source

Methods

Method: trivial-lazy-array-value ((lazy-array lazy-array) (delayed-array delayed-array)) ¶

Method: trivial-lazy-array-value ((lazy-array lazy-array) (delayed-reshape delayed-reshape)) ¶

Next: Conditions, Previous: Generic functions, Up: Internals [Contents][Index]

5.2.6 Method combinations

Method Combination: graphviz-attributes () ¶

Package

Source

utilities.lisp.

Client Functions

graphviz-edge-attributes.
graphviz-graph-attributes.
graphviz-node-attributes.

Next: Structures, Previous: Method combinations, Up: Internals [Contents][Index]

5.2.7 Conditions

Condition: evaluation-failure ¶

Package

Source

Direct superclasses

error.

Direct methods

serious-conditions.

Direct slots

Slot: %serious-conditions ¶

Initform: (quote (alexandria:required-argument :serious-conditions))
Initargs: :serious-conditions
Readers: serious-conditions.
Writers: This slot is read-only.

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

5.2.8 Structures

Structure: action ¶

An action consists of two lists of invocations that are processed by a worker:

1. A list of copy invocations that transfer data from the ghost layers of adjacent workers.

2. A list of work invocations that initialize the interior of their targets.

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: copy-invocations ¶

Type: list
Initform: (quote nil)
Readers: action-copy-invocations.
Writers: (setf action-copy-invocations).

Slot: work-invocations ¶

Type: list
Initform: (quote nil)
Readers: action-work-invocations.
Writers: (setf action-work-invocations).

Structure: ad-record ¶

Package

petalisp.api.

Source

differentiator.lisp.

Direct superclasses

structure-object.

Direct methods

Direct slots

Slot: lazy-array ¶

Package: petalisp-1.0.
Type: petalisp-1.0:lazy-array
Readers: ad-record-lazy-array.
Writers: This slot is read-only.

Slot: alist ¶

Type: list
Readers: ad-record-alist.
Writers: (setf ad-record-alist).

Slot: output-gradient-cache ¶

Type: (or null petalisp-1.0:lazy-array)
Readers: ad-record-output-gradient-cache.
Writers: (setf ad-record-output-gradient-cache).

Slot: input-gradient-caches ¶

Type: vector
Readers: ad-record-input-gradient-caches.
Writers: (setf ad-record-input-gradient-caches).

Structure: allocation ¶

Package

Source

allocation.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: size-in-bytes ¶

Type: unsigned-byte
Readers: allocation-size-in-bytes.
Writers: This slot is read-only.

Slot: category ¶

Type: unsigned-byte
Readers: allocation-category.
Writers: (setf allocation-category).

Slot: unboxed ¶

Type: boolean
Readers: allocation-unboxed.
Writers: (setf allocation-unboxed).

Slot: color ¶

Type: unsigned-byte
Readers: allocation-color.
Writers: This slot is read-only.

Structure: bpcall ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: function ¶

Package: common-lisp.
Type: (or petalisp.codegen::bpfunction petalisp.codegen::bpconstant)
Readers: bpcall-function.
Writers: This slot is read-only.

Slot: arguments ¶

Type: (simple-array petalisp.codegen::bpvalue (*))
Initform: #()
Readers: bpcall-arguments.
Writers: This slot is read-only.

Structure: bpconstant ¶

Package

Source

Direct superclasses

bpvalue.

Direct methods

bpvalue-form.
bpvalue=.

Direct slots

Slot: value ¶

Readers: bpconstant-value.
Writers: This slot is read-only.

Structure: bpfunction ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Direct superclasses: bpinstinfo.

Structure: bpinfo ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: ranges ¶

Type: (simple-array petalisp.codegen::bprange (*))
Readers: bpinfo-ranges.
Writers: This slot is read-only.

Slot: indices ¶

Type: (simple-array petalisp.codegen::bpvalue (*))
Readers: bpinfo-indices.
Writers: This slot is read-only.

Slot: targets ¶

Type: (simple-array petalisp.codegen::bpmemref (*))
Readers: bpinfo-targets.
Writers: This slot is read-only.

Slot: sources ¶

Type: (simple-array petalisp.codegen::bpmemref (*))
Readers: bpinfo-sources.
Writers: This slot is read-only.

Slot: functions ¶

Type: list
Readers: bpinfo-functions.
Writers: This slot is read-only.

Slot: ioffsets ¶

Type: list
Readers: bpinfo-ioffsets.
Writers: This slot is read-only.

Slot: iscalings ¶

Type: list
Readers: bpinfo-iscalings.
Writers: This slot is read-only.

Slot: instructions ¶

Type: (simple-array petalisp.codegen::bpinstruction (*))
Readers: bpinfo-instructions.
Writers: This slot is read-only.

Slot: levels ¶

Type: (simple-array list (*))
Readers: bpinfo-levels.
Writers: (setf bpinfo-levels).

Structure: bpinstinfo ¶

Package

Source

Direct superclasses

bpvariable.

Direct subclasses

bpfunction.
bpioffset.
bpiscaling.

Direct slots

Slot: instruction-number ¶

Package: petalisp.ir.
Type: unsigned-byte
Readers: bpinstinfo-instruction-number.
Writers: This slot is read-only.

Structure: bpinstruction ¶

Package

Source

Direct superclasses

structure-object.

Direct subclasses

bpcall.
bpiref.
bpload.
bpstore.

Direct slots

Slot: level ¶

Type: unsigned-byte
Readers: bpinstruction-level.
Writers: This slot is read-only.

Slot: values ¶

Package: common-lisp.
Type: (simple-array petalisp.codegen::bpvariable (*))
Initform: #()
Readers: bpinstruction-values.
Writers: This slot is read-only.

Structure: bpioffset ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Direct superclasses: bpinstinfo.

Structure: bpiref ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: offset ¶

Type: petalisp.codegen::bpvariable
Readers: bpiref-offset.
Writers: This slot is read-only.

Slot: scaling ¶

Type: petalisp.codegen::bpvalue
Readers: bpiref-scaling.
Writers: This slot is read-only.

Structure: bpiscaling ¶

Package: petalisp.codegen.
Source: bpinfo.lisp.
Direct superclasses: bpinstinfo.

Structure: bpload ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: source ¶

Type: petalisp.codegen::bpmemref
Readers: bpload-source.
Writers: This slot is read-only.

Slot: index ¶

Type: petalisp.codegen::bpvalue
Readers: bpload-index.
Writers: This slot is read-only.

Structure: bpmemref ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: ntype ¶

Type: typo:ntype
Readers: bpmemref-ntype.
Writers: (setf bpmemref-ntype).

Slot: rank ¶

Package: petalisp.core.
Type: petalisp.core:rank
Readers: bpmemref-rank.
Writers: (setf bpmemref-rank).

Slot: base ¶

Type: petalisp.codegen::bpvariable
Readers: bpmemref-base.
Writers: (setf bpmemref-base).

Slot: start ¶

Type: petalisp.codegen::bpvariable
Readers: bpmemref-start.
Writers: (setf bpmemref-start).

Slot: strides ¶

Type: (simple-array petalisp.codegen::bpvalue (*))
Readers: bpmemref-strides.
Writers: (setf bpmemref-strides).

Slot: stencils ¶

Type: (simple-array petalisp.codegen::bpstencil (*))
Readers: bpmemref-stencils.
Writers: (setf bpmemref-stencils).

Structure: bprange ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: start ¶

Type: petalisp.codegen::bpvariable
Readers: bprange-start.
Writers: This slot is read-only.

Slot: end ¶

Type: petalisp.codegen::bpvariable
Readers: bprange-end.
Writers: This slot is read-only.

Slot: step ¶

Package: common-lisp.
Type: petalisp.codegen::bpvalue
Readers: bprange-step.
Writers: This slot is read-only.

Structure: bpstencil ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: center ¶

Type: petalisp.codegen::bpvalue
Readers: bpstencil-center.
Writers: (setf bpstencil-center).

Slot: offsets ¶

Type: (simple-array petalisp.codegen::bpvariable (*))
Readers: bpstencil-offsets.
Writers: This slot is read-only.

Slot: scalings ¶

Type: (simple-array petalisp.codegen::bpvalue (*))
Readers: bpstencil-scalings.
Writers: This slot is read-only.

Structure: bpstore ¶

Package

Source

Direct superclasses

Direct methods

Direct slots

Slot: target ¶

Type: petalisp.codegen::bpmemref
Readers: bpstore-target.
Writers: This slot is read-only.

Slot: index ¶

Type: petalisp.codegen::bpvalue
Readers: bpstore-index.
Writers: This slot is read-only.

Slot: value ¶

Type: petalisp.codegen::bpvalue
Readers: bpstore-value.
Writers: This slot is read-only.

Structure: bpvalue ¶

Package

Source

Direct superclasses

structure-object.

Direct subclasses

bpconstant.
bpvariable.

Direct methods

bpvalue=.

Direct slots

Slot: level ¶

Type: unsigned-byte
Initform: 0
Readers: bpvalue-level.
Writers: This slot is read-only.

Slot: ntype ¶

Type: typo:ntype
Initform: (typo:universal-ntype)
Readers: bpvalue-ntype.
Writers: This slot is read-only.

Structure: bpvariable ¶

Package

Source

Direct superclasses

bpvalue.

Direct subclasses

bpinstinfo.

Direct methods

bpvalue-form.
bpvalue=.

Direct slots

Slot: name ¶

Type: typo:variable-name
Readers: bpvariable-name.
Writers: This slot is read-only.

Structure: cenv ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: backend ¶

Type: petalisp.native-backend::backend
Readers: cenv-backend.
Writers: This slot is read-only.

Slot: schedule ¶

Type: list
Readers: cenv-schedule.
Writers: This slot is read-only.

Slot: result-shapes ¶

Type: (simple-array petalisp-1.0:shape (*))
Readers: cenv-result-shapes.
Writers: This slot is read-only.

Slot: result-ntypes ¶

Type: (simple-array typo:ntype (*))
Readers: cenv-result-ntypes.
Writers: This slot is read-only.

Slot: argument-shapes ¶

Type: (simple-array petalisp-1.0:shape (*))
Readers: cenv-argument-shapes.
Writers: This slot is read-only.

Slot: argument-ntypes ¶

Type: (simple-array typo:ntype (*))
Readers: cenv-argument-ntypes.
Writers: This slot is read-only.

Slot: constant-arrays ¶

Type: (simple-array array (*))
Readers: cenv-constant-arrays.
Writers: This slot is read-only.

Slot: constant-storage-vectors ¶

Type: (simple-array vector (*))
Readers: cenv-constant-storage-vectors.
Writers: This slot is read-only.

Slot: allocations ¶

Type: (simple-array simple-vector (*))
Readers: cenv-allocations.
Writers: This slot is read-only.

Structure: cgraph ¶

Package

petalisp.utilities.

Source

graph-coloring.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: table ¶

Initform: (make-hash-table)
Readers: cgraph-table.
Writers: (setf cgraph-table).

Structure: cnode ¶

Package

petalisp.utilities.

Source

graph-coloring.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: neighbors ¶

Type: list
Initform: (quote nil)
Readers: cnode-neighbors.
Writers: (setf cnode-neighbors).

Slot: object ¶

Initform: (alexandria:required-argument :object)
Readers: cnode-object.
Writers: This slot is read-only.

Slot: color ¶

Type: (or petalisp.utilities::color null)
Readers: cnode-color.
Writers: (setf cnode-color).

Slot: colorset ¶

Type: petalisp.utilities::colorset
Initform: petalisp.utilities::+empty-colorset+
Readers: cnode-colorset.
Writers: (setf cnode-colorset).

Slot: saturation ¶

Type: (and unsigned-byte fixnum)
Initform: 0
Readers: cnode-saturation.
Writers: (setf cnode-saturation).

Slot: degree ¶

Type: (and unsigned-byte fixnum)
Initform: 0
Readers: cnode-degree.
Writers: (setf cnode-degree).

Slot: queue-node ¶

Readers: cnode-queue-node.
Writers: (setf cnode-queue-node).

Structure: compile-cache ¶

Package

Source

compile-cache.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: table ¶

Type: hash-table
Initform: (make-hash-table :test (function eql) :synchronized t)
Readers: compile-cache-table.
Writers: This slot is read-only.

Structure: dendrite ¶

A dendrite describes a set of indices and their mapping to the
iteration space of the dendrite’s stem. The dendrite holds a reference to an input of a not-yet-fully-initialized instruction and its job is to suitably initialize this instruction input. It has the following slots:

- A reference to the stem from which the dendrite originates.

- A shape that describes the indices being referenced.

- A transformation from the dendrite’s shape to the iteration space of the dendrite’s stem’s kernel.

- The depth of the nucleus that was most recently visited by the dendrite.

- The cons cell whose CDR should be set to the next instruction being emitted, and whose CAR is an integer denoting which of the multiple values of that instruction is being referenced.

Package

Source

Direct superclasses

structure-object.

Direct methods

grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.
grow-dendrite-aux.

Direct slots

Slot: stem ¶

Type: petalisp.ir::stem
Readers: dendrite-stem.
Writers: (setf dendrite-stem).

Slot: shape ¶

Package: petalisp-1.0.
Type: petalisp-1.0:shape
Readers: dendrite-shape.
Writers: (setf dendrite-shape).

Slot: transformation ¶

Package: petalisp-1.0.
Type: petalisp-1.0:transformation
Readers: dendrite-transformation.
Writers: (setf dendrite-transformation).

Slot: depth ¶

Type: unsigned-byte
Readers: dendrite-depth.
Writers: (setf dendrite-depth).

Slot: cons ¶

Package: common-lisp.
Type: cons
Readers: dendrite-cons.
Writers: (setf dendrite-cons).

Structure: denv ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: cenv ¶

Type: petalisp.native-backend::cenv
Initform: (alexandria:required-argument :cenv)
Readers: denv-cenv.
Writers: This slot is read-only.

Slot: result-arrays ¶

Type: (simple-array array (*))
Initform: (alexandria:required-argument :result-arrays)
Readers: denv-result-arrays.
Writers: This slot is read-only.

Slot: pointers ¶

Type: (simple-array simple-vector (*))
Readers: denv-pointers.
Writers: This slot is read-only.

Slot: serious-conditions ¶

Type: list
Readers: denv-serious-conditions.
Writers: (setf denv-serious-conditions).

Slot: serious-condition-lock ¶

Type: bt2:lock
Initform: (bt2:make-lock :name "denv serious condition lock")
Readers: denv-serious-condition-lock.
Writers: (setf denv-serious-condition-lock).

Slot: request ¶

Type: petalisp.native-backend::request
Readers: denv-request.
Writers: (setf denv-request).

Structure: ghostspec ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: buffer ¶

Type: petalisp.ir:buffer
Readers: ghostspec-buffer.
Writers: This slot is read-only.

Slot: left-padding-vec ¶

Type: simple-vector
Readers: ghostspec-left-padding-vec.
Writers: This slot is read-only.

Slot: right-padding-vec ¶

Type: simple-vector
Readers: ghostspec-right-padding-vec.
Writers: This slot is read-only.

Slot: pattern ¶

Type: (simple-array bit)
Readers: ghostspec-pattern.
Writers: This slot is read-only.

Structure: hairy-transformation ¶

Package

Source

Direct superclasses

transformation.

Direct methods

compose-two-transformations.
enlarge-transformation.
inflate-transformation.
invert-transformation.
map-transformation-inputs.
map-transformation-outputs.
transform-axis.
transform-index.
transform-index.
transform-index.
transform-shape.
transform-shape.
transformation=.

Structure: invocation ¶

An invocation represents one run of a kernel on a particular iteration space for some given source and target layouts.

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: kfn ¶

Type: function
Readers: invocation-kfn.
Writers: This slot is read-only.

Slot: kernel ¶

Package: petalisp.ir.
Type: petalisp.ir:kernel
Readers: invocation-kernel.
Writers: This slot is read-only.

Slot: iteration-space ¶

Type: petalisp-1.0:shape
Readers: invocation-iteration-space.
Writers: This slot is read-only.

Slot: targets ¶

Package: petalisp.ir.
Type: (simple-array petalisp.ir:layout (*))
Readers: invocation-targets.
Writers: (setf invocation-targets).

Slot: sources ¶

Package: petalisp.ir.
Type: (simple-array petalisp.ir:layout (*))
Readers: invocation-sources.
Writers: (setf invocation-sources).

Structure: ir-converter ¶

The ir-converter is a structure that tracks all the global state of one IR conversion process. Each of its slots used to be just a special variable that was bound when entering the IR conversion, but that turned out to be unwieldy. Now there is just a single special variable that holds an instance of this structure. The individual slots of an IR converter are as follows:

- A priority queue of nuclei, sorted by the depth of the corresponding lazy arrays.

- A hash table, mapping from lazy arrays to their nuclei.

- A hash table, mapping from Common Lisp arrays to buffers.

- A hash table, mapping from Common Lisp scalars to buffers of rank zero containing those scalars.

- A hash table, mapping from unknowns to buffers.

- An association list whose entries are conses of leaf buffers and their corresponding lazy arrays.

- A list of lists of conses that need to be updated by writing the value of the cdr of the first cons to the cdr of each remaining cons.

- The maximum size we allow a kernel to grow during buffer pruning.

- An list of potentially superfluous buffers, i.e., buffer where all dendrites are disjoint and cover the entire buffer. Nucleus conversion also makes sure that the data slot of each potentially superfluous buffer contains the list of dendrites reaching it.

- A hash table, mapping from potentially superfluous buffers to dendrites.

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: pqueue ¶

Initform: (priority-queue:make-pqueue (function >))
Readers: ir-converter-pqueue.
Writers: (setf ir-converter-pqueue).

Slot: nucleus-table ¶

Type: hash-table
Initform: (make-hash-table :test (function eq))
Readers: ir-converter-nucleus-table.
Writers: (setf ir-converter-nucleus-table).

Slot: array-table ¶

Type: hash-table
Initform: (make-hash-table :test (function eq))
Readers: ir-converter-array-table.
Writers: (setf ir-converter-array-table).

Slot: scalar-table ¶

Type: hash-table
Initform: (make-hash-table :test (function eql))
Readers: ir-converter-scalar-table.
Writers: (setf ir-converter-scalar-table).

Slot: unknown-table ¶

Type: hash-table
Initform: (make-hash-table :test (function eq))
Readers: ir-converter-unknown-table.
Writers: (setf ir-converter-unknown-table).

Slot: leaf-alist ¶

Type: list
Initform: (quote nil)
Readers: ir-converter-leaf-alist.
Writers: (setf ir-converter-leaf-alist).

Slot: cons-updates ¶

Type: list
Initform: (quote nil)
Readers: ir-converter-cons-updates.
Writers: (setf ir-converter-cons-updates).

Slot: kernel-size-threshold ¶

Type: unsigned-byte
Readers: ir-converter-kernel-size-threshold.
Writers: This slot is read-only.

Slot: potentially-superfluous-buffers ¶

Type: list
Initform: (quote nil)
Readers: ir-converter-potentially-superfluous-buffers.
Writers: (setf ir-converter-potentially-superfluous-buffers).

Slot: buffer-dendrites-table ¶

Type: hash-table
Initform: (make-hash-table :test (function eq))
Readers: ir-converter-buffer-dendrites-table.
Writers: (setf ir-converter-buffer-dendrites-table).

Structure: node ¶

Package

Source

ir-backend.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: kernel ¶

Package: petalisp.ir.
Type: petalisp.ir:kernel
Readers: node-kernel.
Writers: (setf node-kernel).

Slot: dependencies ¶

Type: list
Initform: (quote nil)
Readers: node-dependencies.
Writers: (setf node-dependencies).

Slot: users ¶

Type: list
Initform: (quote nil)
Readers: node-users.
Writers: (setf node-users).

Slot: fn ¶

Type: (or function null)
Readers: node-fn.
Writers: (setf node-fn).

Structure: nucleus ¶

A nucleus describes a lazy array that is either the root of a data flow graph or a lazy array that has been reached by more than one dendrite in the conversion process. Each nucleus has the following slots:

- The lazy array at which the nucleation occurs. When talking about the shape, depth and type of a nucleus, we refer to the shape, depth and type of the lazy array of that nucleus.

- A list of the dendrites that have reached this nucleus. This list is empty when the nucleus is at a root of the data flow graph, otherwise it contains two or more dendrites.

Package

Source

Direct superclasses

structure-object.

Direct methods

convert-nucleus.
convert-nucleus.
convert-nucleus.

Direct slots

Slot: lazy-array ¶

Package: petalisp-1.0.
Type: petalisp-1.0:lazy-array
Readers: nucleus-lazy-array.
Writers: (setf nucleus-lazy-array).

Slot: dendrites ¶

Type: list
Initform: (quote nil)
Readers: nucleus-dendrites.
Writers: (setf nucleus-dendrites).

Structure: pdfs-queue ¶

Package

petalisp.scheduling.

Source

Direct superclasses

structure-object.

Direct slots

Slot: priority-queue ¶

Type: queues:priority-queue
Initform: (queues:make-queue :priority-queue :compare (function petalisp.scheduling::node-more-important-p))
Readers: pdfs-queue-priority-queue.
Writers: This slot is read-only.

Slot: tmpnode ¶

Type: petalisp.scheduling:node
Initform: (petalisp.scheduling::make-node)
Readers: pdfs-queue-tmpnode.
Writers: (setf pdfs-queue-tmpnode).

Structure: prune ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: bits ¶

Type: unsigned-byte
Readers: prune-bits.
Writers: This slot is read-only.

Slot: buffers ¶

Type: list
Initform: (quote nil)
Readers: prune-buffers.
Writers: This slot is read-only.

Structure: request ¶

Package

Source

request.lisp.

Direct superclasses

structure-object.

Direct methods

request-completedp.
request-wait.
requestp.

Direct slots

Slot: lock ¶

Initform: (bt2:make-lock)
Readers: request-lock.
Writers: This slot is read-only.

Slot: cvar ¶

Initform: (bt2:make-condition-variable)
Readers: request-cvar.
Writers: This slot is read-only.

Slot: done ¶

Type: boolean
Readers: request-done.
Writers: (setf request-done).

Structure: simulated-memory ¶

Package

Source

Direct superclasses

structure-object.

Direct slots

Slot: allocation ¶

Type: petalisp.native-backend::allocation
Readers: simulated-memory-allocation.
Writers: This slot is read-only.

Slot: table ¶

Type: hash-table
Initform: (make-hash-table :test (function equal))
Readers: simulated-memory-table.
Writers: (setf simulated-memory-table).

Slot: generation ¶

Type: unsigned-byte
Initform: 0
Readers: simulated-memory-generation.
Writers: (setf simulated-memory-generation).

Slot: mode ¶

Type: (member :r :w)
Initform: :w
Readers: simulated-memory-mode.
Writers: (setf simulated-memory-mode).

Structure: stem ¶

A stem describes the process of assembling one kernel. Stems and their kernels are always created at the same time, but only the iteration space and the store instructions of the stem’s kernel are defined right away. All other instructions of the kernel are produced later by growing dendrites from the stem. A stem has the following slots:

- A reference to the nucleus from which the stem emanates.

- A reference to the not-yet-fully-initialized kernel that is grown from the stem. When talking about the iteration space of a stem, we refer to the iteration space of this kernel.

- A list of buffers that are written to by the stem’s kernel. If the stem’s nucleus occurs at a lazy array with a delayed multiple-value map action, this list has as many buffers as there are multiple values being returned. Otherwise, this list has a single buffer that will later hold the values of the lazy array corresponding to the stem’s nucleus. An element of this list can be NIL instead of a buffer if that particular value is never referenced.

- A flag that indicates whether the stem is valid. It is true initially, but is set to false in case the stem is split into multiple stems with smaller iteration spaces. When the conversion algorithm encounters a stem that is no longer valid, it discards the corresponding kernel and all dendrites rooted therein.

Package

Source

petalisp.karmarkar-karp.

Direct superclasses

structure-object.

Direct slots

Slot: nucleus ¶

Type: petalisp.ir::nucleus
Readers: stem-nucleus.
Writers: (setf stem-nucleus).

Slot: kernel ¶

Type: petalisp.ir:kernel
Readers: stem-kernel.
Writers: (setf stem-kernel).

Slot: buffers ¶

Type: list
Readers: stem-buffers.
Writers: (setf stem-buffers).

Slot: validp ¶

Type: boolean
Initform: t
Readers: stem-validp.
Writers: (setf stem-validp).

Structure: subset ¶

Package

Source

karmarkar-karp.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: elements ¶

Type: list
Initform: (quote nil)
Readers: subset-elements.
Writers: (setf subset-elements).

Slot: weight ¶

Type: real
Initform: 0
Readers: subset-weight.
Writers: (setf subset-weight).

Structure: tuple ¶

Package

petalisp.karmarkar-karp.

Source

karmarkar-karp.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: subsets ¶

Type: simple-vector
Initform: #()
Readers: tuple-subsets.
Writers: (setf tuple-subsets).

Slot: weight ¶

Type: number
Initform: 0
Readers: tuple-weight.
Writers: (setf tuple-weight).

Structure: worker ¶

Package

Source

worker-pool.lisp.

Direct superclasses

structure-object.

Direct methods

Direct slots

Slot: worker-pool ¶

Type: petalisp.native-backend::worker-pool
Readers: worker-worker-pool.
Writers: This slot is read-only.

Slot: id ¶

Type: petalisp.native-backend::worker-id
Readers: worker-id.
Writers: This slot is read-only.

Slot: thread ¶

Type: (or bt2:thread null)
Readers: worker-thread.
Writers: (setf worker-thread).

Slot: queue ¶

Initform: (lparallel.queue:make-queue)
Readers: worker-queue.
Writers: (setf worker-queue).

Slot: barrier-sense ¶

Type: (member :a :b)
Initform: :b
Readers: worker-barrier-sense.
Writers: (setf worker-barrier-sense).

Slot: serious-conditions ¶

Type: list
Initform: (quote nil)
Readers: worker-serious-conditions.
Writers: (setf worker-serious-conditions).

Structure: worker-pool ¶

Package

Source

worker-pool.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: workers ¶

Type: simple-vector
Readers: worker-pool-workers.
Writers: This slot is read-only.

Slot: liveness ¶

Initform: (bt2:make-atomic-integer :value 1)
Readers: worker-pool-liveness.
Writers: (setf worker-pool-liveness).

Slot: barrier-sense ¶

Type: (member :a :b)
Initform: :a
Readers: worker-pool-barrier-sense.
Writers: (setf worker-pool-barrier-sense).

Slot: barrier-countdown ¶

Readers: worker-pool-barrier-countdown.
Writers: (setf worker-pool-barrier-countdown).

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

5.2.9 Classes

Class: any-edge ¶

Package

Source

Direct subclasses

direct-subclass-edge.
petalisp-edge.

Direct methods

graphviz-edge-attributes.
graphviz-incoming-edge-origins.
graphviz-outgoing-edge-targets.

Class: any-graph ¶

Package

Source

Direct subclasses

class-diagram.
petalisp-graph.

Direct methods

generate-graph-from-roots.
graph-object-knows-of.
graph-object-node.
graph-object-pointed-to-by.
graph-object-points-to.
graphviz-edge-attributes.
graphviz-graph-attributes.
graphviz-incoming-edge-origins.
graphviz-known-nodes.
graphviz-node-attributes.
graphviz-node-caption.
graphviz-node-properties.
graphviz-outgoing-edge-targets.
graphviz-potential-edges.

Class: backend ¶

Package

Source

Direct superclasses

backend.
compile-cache-mixin.
lisp-compiler-mixin.

Direct methods

backend-evaluator.
backend-worker-pool.
delete-backend.
initialize-instance.
load-function.
source-function.
store-function.
target-function.
unpack-function.

Direct slots

Slot: %worker-pool ¶

Type: petalisp.native-backend::worker-pool
Initform: (alexandria:required-argument :worker-pool)
Initargs: :worker-pool
Readers: backend-worker-pool.
Writers: This slot is read-only.

Class: backend-stats ¶

Package: petalisp.core.
Source: backend.lisp.

Class: class-diagram ¶

Package

Source

class-diagram.lisp.

Direct superclasses

any-graph.

Direct methods

graph-object-node.
graphviz-edge-attributes.
graphviz-graph-attributes.
graphviz-incoming-edge-origins.
graphviz-potential-edges.

Class: completed-request ¶

Package

Source

Direct superclasses

request.

Direct methods

request-completedp.
request-wait.

Class: data-flow-edge ¶

Package: petalisp.graphviz.
Source: data-flow-graph.lisp.
Direct superclasses: petalisp-edge.
Direct methods: graphviz-incoming-edge-origins.

Class: data-flow-graph ¶

Package

Source

data-flow-graph.lisp.

Direct superclasses

Direct methods

graphviz-incoming-edge-origins.
graphviz-node-attributes.
graphviz-node-attributes.
graphviz-node-attributes.
graphviz-node-attributes.
graphviz-node-attributes.
graphviz-node-caption.
graphviz-node-properties.
graphviz-node-properties.
graphviz-node-properties.
graphviz-node-properties.
graphviz-node-properties.
graphviz-potential-edges.

Class: deleted-backend ¶

Package: petalisp.core.
Source: backend.lisp.

Class: direct-subclass-edge ¶

Package

Source

class-diagram.lisp.

Direct superclasses

any-edge.

Direct methods

graphviz-edge-attributes.
graphviz-incoming-edge-origins.

Class: input-edge ¶

Package: petalisp.graphviz.
Source: ir.lisp.
Direct superclasses: ir-edge.
Direct methods: graphviz-incoming-edge-origins.

Class: ir-backend ¶

Package

Source

ir-backend.lisp.

Direct superclasses

backend.

Direct methods

backend-compute.
ir-backend-compile-cache.
ir-backend-mode.
load-function.
source-function.
store-function.
target-function.
unpack-function.

Direct slots

Slot: %mode ¶

Type: (member :interpreted :compiled)
Initform: :interpreted
Initargs: :mode
Readers: ir-backend-mode.
Writers: This slot is read-only.

Slot: %compile-cache ¶

Type: hash-table
Initform: (make-hash-table)
Readers: ir-backend-compile-cache.
Writers: This slot is read-only.

Class: ir-edge ¶

Package

Source

Direct superclasses

petalisp-edge.

Direct subclasses

input-edge.
load-edge.
output-edge.
store-edge.

Class: ir-graph ¶

Package

Source

Direct superclasses

Direct methods

generate-graph-from-roots.
graph-object-cluster.
graph-object-cluster.
graphviz-incoming-edge-origins.
graphviz-incoming-edge-origins.
graphviz-node-attributes.
graphviz-node-attributes.
graphviz-node-properties.
graphviz-node-properties.
graphviz-outgoing-edge-targets.
graphviz-outgoing-edge-targets.
graphviz-potential-edges.

Class: load-edge ¶

Package: petalisp.graphviz.
Source: ir.lisp.
Direct superclasses: ir-edge.
Direct methods: graphviz-incoming-edge-origins.

Class: output-edge ¶

Package: petalisp.graphviz.
Source: ir.lisp.
Direct superclasses: ir-edge.
Direct methods: graphviz-outgoing-edge-targets.

Class: partitioning-edge ¶

Package

Source

Direct superclasses

petalisp-edge.

Direct subclasses

reader-edge.
writer-edge.

Class: partitioning-graph ¶

Package

Source

Direct superclasses

Direct methods

generate-graph-from-roots.
graph-object-cluster.
graph-object-knows-of.
graph-object-node.
graph-object-node.
graph-object-pointed-to-by.
graph-object-points-to.
graphviz-edge-attributes.
graphviz-edge-attributes.

Class: petalisp-edge ¶

Package

graphviz-edge-attributes.

Source

petalisp.lisp.

Direct superclasses

any-edge.

Direct subclasses

data-flow-edge.
ir-edge.
partitioning-edge.
scheduling-edge.

Direct methods

Class: petalisp-graph ¶

Package

Source

petalisp.lisp.

Direct superclasses

any-graph.

Direct subclasses

data-flow-graph.
ir-graph.
partitioning-graph.
scheduling-graph.

Direct methods

graphviz-edge-attributes.
graphviz-graph-attributes.
graphviz-node-attributes.

Class: reader-edge ¶

Package: petalisp.graphviz.
Source: partitioning.lisp.
Direct superclasses: partitioning-edge.
Direct methods: graphviz-edge-attributes.

Class: reference-backend ¶

Package: petalisp.core.
Source: reference-backend.lisp.
Direct superclasses: backend.
Direct methods: backend-compute.

Class: scheduling-edge ¶

Package

Source

Direct superclasses

petalisp-edge.

Direct methods

graphviz-edge-attributes.
graphviz-outgoing-edge-targets.

Class: scheduling-graph ¶

Package

Source

Direct superclasses

Direct methods

graphviz-edge-attributes.
graphviz-known-nodes.
graphviz-node-properties.
graphviz-outgoing-edge-targets.
graphviz-potential-edges.

Class: store-edge ¶

Package: petalisp.graphviz.
Source: ir.lisp.
Direct superclasses: ir-edge.
Direct methods: graphviz-outgoing-edge-targets.

Class: testing-backend ¶

Package