The petalisp Reference Manual

Table of Contents

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

The petalisp Reference Manual

This is the petalisp Reference Manual, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Apr 08 14:45:02 2019 GMT+0.


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

1 Introduction

#+TITLE: Petalisp

Petalisp is an attempt to generate high performance code for parallel
computers by JIT-compiling array definitions. It is not a full blown
programming language, but rather a carefully crafted extension of Common
Lisp that allows for extreme optimization and parallelization.

** Getting Started
1. Install Lisp and a suitable IDE.  If unsure, pick [[https://portacle.github.io/][Portacle]].
2. Download Petalisp via [[https://www.quicklisp.org/][Quicklisp]].
3. Check out some of the [[file:examples][examples]].

** Showcases
Petalisp is still under development, so the following examples may still
change slightly. Nevertheless they give a good glimpse on what programming
with Petalisp will be like.

Example 1: transposing a matrix
#+BEGIN_SRC lisp
(defun transpose (A)
  (reshape A (τ (m n) (n m))))
#+END_SRC

Example 2: matrix-matrix multiplication
#+BEGIN_SRC lisp
(defun matrix-multiplication (A B)
  (β #'+
     (α #'*
        (reshape A (τ (m n) (n m 1)))
        (reshape B (τ (n k) (n 1 k))))))
#+END_SRC

Example 3: the numerical Jacobi scheme in two dimensions
#+BEGIN_SRC lisp
(defun jacobi-2d (grid iterations)
  (let ((interior (interior grid)))
    (if (zerop iterations) grid
        (jacobi-2d
         (fuse x
               (α #'* 0.25
                  (α #'+
                     (reshape x (τ (i0 i1) ((+ i0 1) i1)) interior)
                     (reshape x (τ (i0 i1) ((- i0 1) i1)) interior)
                     (reshape x (τ (i0 i1) (i0 (+ i1 1))) interior)
                     (reshape x (τ (i0 i1) (i0 (- i1 1))) interior))))
         (- iterations 1)))))
#+END_SRC

** Performance

Coming soon!

** Frequently Asked Questions
*** Is Petalisp similar to NumPy?
NumPy is a widely used Python library for scientific computing on arrays.
It provides powerful N-dimensional arrays and a variety of functions for
working with these arrays.

Petalisp works on a more fundamental level.  It provides even more powerful
N-dimensional arrays, but just a few building blocks for working on them -
element-wise function application, reduction, reshaping and array fusion.

So Petalisp is not a substitute for NumPy.  However, it could be used to
write a library that behaves like NumPy, but that is much faster and fully
parallelized.  In fact, writing such a library is one of my future goals.
*** Do I have to program Lisp to use Petalisp?
Not necessarily.  Not everyone has the time to learn Common Lisp.  That is
why I am also working on some [[https://github.com/marcoheisig/cl4py][convenient Python bindings]] for Petalisp.

But: If you ever have time to learn Lisp, do it!  It is an enlightening
experience.
*** Why the Greek letters?
There are several reasons:
1. It underlines the beautiful, mathematical nature of this programming model.
2. The α and β functions are a tribute to Connection Machine Lisp.
3. Compared to programming a computer with billions of transistors and
   terabytes of memory, typing Greek letters is easy. Right?

Note: Following community feedback, it is now also possible to write =a=
instead of =α= and =b= instead of =β=.  But as a convention, please use the
ASCII aliases only as a shortcut for scripting.  If I ever see =a= and =b=
being called in a Quicklisp project, I will remove them from the API :)

*** Why is Petalisp licensed under AGPL?
I am aware that this license prevents some people from using or
contributing to this piece of software, which is a shame. But unfortunately
the majority of software developers have not yet understood that

1. In a digital world, free software is a necessary prerequisite for a free
   society.
2. When developing software, open collaboration is way more efficient than
   competition.

So as long as distribution of non-free software is socially accepted,
copyleft licenses like the AGPL seem to be the lesser evil.

That being said, I am willing to discuss relicensing on an individual
basis.

*** Why is Petalisp written in Common Lisp?
I couldn't wish for a better tool for the job. Common Lisp is extremely
rich in features, standardized, fast, safe and mature. The Lisp community
is amazing and there are excellent libraries for almost every imaginable
task.


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

2 Systems

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


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

2.1 petalisp

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Description

Elegant High Performance Computing

Dependency

petalisp.api (system)

Source

petalisp.asd (file)


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

2.2 petalisp.api

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Description

A Convenient API for Petalisp.

Dependencies
Source

petalisp.api.asd (file)

Components

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

2.3 petalisp.reference-backend

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Dependency

petalisp.core (system)

Source

petalisp.reference-backend.asd (file)

Components

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

2.4 petalisp.ir-backend

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Dependencies
Source

petalisp.ir-backend.asd (file)

Components

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

2.5 petalisp.native-backend

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Dependencies
Source

petalisp.native-backend.asd (file)

Components

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

2.6 petalisp.ir

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Dependency

petalisp.core (system)

Source

petalisp.ir.asd (file)

Components

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

2.7 petalisp.core

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Dependencies
Source

petalisp.core.asd (file)

Components

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

2.8 petalisp.utilities

Author

Marco Heisig <marco.heisig@fau.de>

License

AGPLv3

Dependencies
Source

petalisp.utilities.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 petalisp.asd

Location

petalisp.asd

Systems

petalisp (system)


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

3.1.2 petalisp.api.asd

Location

api/petalisp.api.asd

Systems

petalisp.api (system)


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

3.1.3 petalisp.reference-backend.asd

Location

reference-backend/petalisp.reference-backend.asd

Systems

petalisp.reference-backend (system)


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

3.1.4 petalisp.ir-backend.asd

Location

ir-backend/petalisp.ir-backend.asd

Systems

petalisp.ir-backend (system)


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

3.1.5 petalisp.native-backend.asd

Location

native-backend/petalisp.native-backend.asd

Systems

petalisp.native-backend (system)


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

3.1.6 petalisp.ir.asd

Location

ir/petalisp.ir.asd

Systems

petalisp.ir (system)


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

3.1.7 petalisp.core.asd

Location

core/petalisp.core.asd

Systems

petalisp.core (system)


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

3.1.8 petalisp.utilities.asd

Location

utilities/petalisp.utilities.asd

Systems

petalisp.utilities (system)


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

3.1.9 petalisp.api/packages.lisp

Parent

petalisp.api (system)

Location

api/packages.lisp

Packages

petalisp.api


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

3.1.10 petalisp.api/api.lisp

Dependency

packages.lisp (file)

Parent

petalisp.api (system)

Location

api/api.lisp

Exported Definitions

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

3.1.11 petalisp.reference-backend/packages.lisp

Parent

petalisp.reference-backend (system)

Location

reference-backend/packages.lisp

Packages

petalisp.reference-backend


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

3.1.12 petalisp.reference-backend/simple-immediate.lisp

Dependency

packages.lisp (file)

Parent

petalisp.reference-backend (system)

Location

reference-backend/simple-immediate.lisp

Exported Definitions
Internal Definitions

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

3.1.13 petalisp.reference-backend/reference-backend.lisp

Dependency

simple-immediate.lisp (file)

Parent

petalisp.reference-backend (system)

Location

reference-backend/reference-backend.lisp

Exported Definitions
Internal Definitions

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

3.1.14 petalisp.ir-backend/packages.lisp

Parent

petalisp.ir-backend (system)

Location

ir-backend/packages.lisp

Packages

petalisp.ir-backend


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

3.1.15 petalisp.ir-backend/ir-backend.lisp

Dependency

packages.lisp (file)

Parent

petalisp.ir-backend (system)

Location

ir-backend/ir-backend.lisp

Exported Definitions

make-ir-backend (function)

Internal Definitions

ir-backend (class)


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

3.1.16 petalisp.ir-backend/ir-conversion.lisp

Dependency

ir-backend.lisp (file)

Parent

petalisp.ir-backend (system)

Location

ir-backend/ir-conversion.lisp

Exported Definitions
Internal Definitions

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

3.1.17 petalisp.ir-backend/execution.lisp

Dependency

ir-conversion.lisp (file)

Parent

petalisp.ir-backend (system)

Location

ir-backend/execution.lisp

Exported Definitions

compute-immediates (method)

Internal Definitions

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

3.1.18 petalisp.native-backend/packages.lisp

Parent

petalisp.native-backend (system)

Location

native-backend/packages.lisp

Packages

petalisp.native-backend


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

3.1.19 petalisp.native-backend/utilities.lisp

Dependency

packages.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/utilities.lisp

Internal Definitions

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

3.1.20 petalisp.native-backend/basic-block.lisp

Dependency

utilities.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/basic-block.lisp

Internal Definitions

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

3.1.21 petalisp.native-backend/lambda-block.lisp

Dependency

basic-block.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/lambda-block.lisp

Internal Definitions

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

3.1.22 petalisp.native-backend/loop-block.lisp

Dependency

lambda-block.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/loop-block.lisp

Internal Definitions

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

3.1.23 petalisp.native-backend/tail-block.lisp

Dependency

loop-block.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/tail-block.lisp

Internal Definitions

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

3.1.24 petalisp.native-backend/translation-unit.lisp

Dependency

tail-block.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/translation-unit.lisp

Internal Definitions

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

3.1.25 petalisp.native-backend/blueprint-compiler.lisp

Dependency

translation-unit.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/blueprint-compiler.lisp

Internal Definitions

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

3.1.26 petalisp.native-backend/memory-pool.lisp

Dependency

blueprint-compiler.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/memory-pool.lisp

Internal Definitions

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

3.1.27 petalisp.native-backend/native-backend.lisp

Dependency

memory-pool.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/native-backend.lisp

Exported Definitions

make-native-backend (function)

Internal Definitions

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

3.1.28 petalisp.native-backend/ir-conversion.lisp

Dependency

native-backend.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/ir-conversion.lisp

Exported Definitions
Internal Definitions

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

3.1.29 petalisp.native-backend/execution.lisp

Dependency

ir-conversion.lisp (file)

Parent

petalisp.native-backend (system)

Location

native-backend/execution.lisp

Exported Definitions

compute-immediates (method)

Internal Definitions

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

3.1.30 petalisp.ir/packages.lisp

Parent

petalisp.ir (system)

Location

ir/packages.lisp

Packages

petalisp.ir


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

3.1.31 petalisp.ir/ir.lisp

Dependency

packages.lisp (file)

Parent

petalisp.ir (system)

Location

ir/ir.lisp

Exported Definitions
Internal Definitions

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

3.1.32 petalisp.ir/compute-buffer-table.lisp

Dependency

ir.lisp (file)

Parent

petalisp.ir (system)

Location

ir/compute-buffer-table.lisp

Exported Definitions
Internal Definitions

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

3.1.33 petalisp.ir/compute-iteration-spaces.lisp

Dependency

compute-buffer-table.lisp (file)

Parent

petalisp.ir (system)

Location

ir/compute-iteration-spaces.lisp

Internal Definitions

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

3.1.34 petalisp.ir/ir-conversion.lisp

Dependency

compute-iteration-spaces.lisp (file)

Parent

petalisp.ir (system)

Location

ir/ir-conversion.lisp

Exported Definitions
Internal Definitions

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

3.1.35 petalisp.ir/blueprint.lisp

Dependency

ir-conversion.lisp (file)

Parent

petalisp.ir (system)

Location

ir/blueprint.lisp

Exported Definitions
Internal Definitions

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

3.1.36 petalisp.core/packages.lisp

Parent

petalisp.core (system)

Location

core/packages.lisp

Packages

petalisp.core


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

3.1.37 petalisp.core/set.lisp

Dependency

packages.lisp (file)

Parent

petalisp.core (system)

Location

core/set.lisp

Exported Definitions
Internal Definitions

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

3.1.38 petalisp.core/empty-set.lisp

Dependency

set.lisp (file)

Parent

petalisp.core (system)

Location

core/empty-set.lisp

Exported Definitions
Internal Definitions

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

3.1.39 petalisp.core/explicit-set.lisp

Dependency

empty-set.lisp (file)

Parent

petalisp.core (system)

Location

core/explicit-set.lisp

Exported Definitions
Internal Definitions

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

3.1.40 petalisp.core/range.lisp

Dependency

explicit-set.lisp (file)

Parent

petalisp.core (system)

Location

core/range.lisp

Exported Definitions
Internal Definitions

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

3.1.41 petalisp.core/shape.lisp

Dependency

range.lisp (file)

Parent

petalisp.core (system)

Location

core/shape.lisp

Exported Definitions
Internal Definitions

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

3.1.42 petalisp.core/transformation.lisp

Dependency

shape.lisp (file)

Parent

petalisp.core (system)

Location

core/transformation.lisp

Exported Definitions
Internal Definitions

map-transformation-inputs (generic function)


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

3.1.43 petalisp.core/identity-transformation.lisp

Dependency

transformation.lisp (file)

Parent

petalisp.core (system)

Location

core/identity-transformation.lisp

Exported Definitions
Internal Definitions

map-transformation-inputs (method)


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

3.1.44 petalisp.core/invertible-transformation.lisp

Dependency

identity-transformation.lisp (file)

Parent

petalisp.core (system)

Location

core/invertible-transformation.lisp

Exported Definitions
Internal Definitions

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

3.1.45 petalisp.core/hairy-transformation.lisp

Dependency

invertible-transformation.lisp (file)

Parent

petalisp.core (system)

Location

core/hairy-transformation.lisp

Exported Definitions
Internal Definitions

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

3.1.46 petalisp.core/transformation-constructors.lisp

Dependency

hairy-transformation.lisp (file)

Parent

petalisp.core (system)

Location

core/transformation-constructors.lisp

Exported Definitions
Internal Definitions

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

3.1.47 petalisp.core/shape-transformations.lisp

Dependency

transformation-constructors.lisp (file)

Parent

petalisp.core (system)

Location

core/shape-transformations.lisp

Exported Definitions
Internal Definitions

from-storage-transformation (function)


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

3.1.48 petalisp.core/lazy-array.lisp

Dependency

shape-transformations.lisp (file)

Parent

petalisp.core (system)

Location

core/lazy-array.lisp

Exported Definitions
Internal Definitions

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

3.1.49 petalisp.core/broadcasting.lisp

Dependency

lazy-array.lisp (file)

Parent

petalisp.core (system)

Location

core/broadcasting.lisp

Exported Definitions

broadcast-arrays (function)

Internal Definitions

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

3.1.50 petalisp.core/lazy-array-constructors.lisp

Dependency

broadcasting.lisp (file)

Parent

petalisp.core (system)

Location

core/lazy-array-constructors.lisp

Exported Definitions
Internal Definitions

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

3.1.51 petalisp.core/backend.lisp

Dependency

lazy-array-constructors.lisp (file)

Parent

petalisp.core (system)

Location

core/backend.lisp

Exported Definitions
Internal Definitions

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

3.1.52 petalisp.core/documentation.lisp

Dependency

backend.lisp (file)

Parent

petalisp.core (system)

Location

core/documentation.lisp

Internal Definitions

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

3.1.53 petalisp.utilities/packages.lisp

Parent

petalisp.utilities (system)

Location

utilities/packages.lisp

Packages

petalisp.utilities


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

3.1.54 petalisp.utilities/identical.lisp

Dependency

packages.lisp (file)

Parent

petalisp.utilities (system)

Location

utilities/identical.lisp

Exported Definitions

identical (function)


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

3.1.55 petalisp.utilities/memoization.lisp

Dependency

identical.lisp (file)

Parent

petalisp.utilities (system)

Location

utilities/memoization.lisp

Exported Definitions
Internal Definitions

+empty+ (constant)


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

3.1.56 petalisp.utilities/extended-euclid.lisp

Dependency

memoization.lisp (file)

Parent

petalisp.utilities (system)

Location

utilities/extended-euclid.lisp

Exported Definitions

extended-euclid (function)


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

3.1.57 petalisp.utilities/define-method-pair.lisp

Dependency

extended-euclid.lisp (file)

Parent

petalisp.utilities (system)

Location

utilities/define-method-pair.lisp

Exported Definitions

define-method-pair (macro)

Internal Definitions

parse-defmethod (function)


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

3.1.58 petalisp.utilities/define-class-predicate.lisp

Dependency

define-method-pair.lisp (file)

Parent

petalisp.utilities (system)

Location

utilities/define-class-predicate.lisp

Exported Definitions

define-class-predicate (macro)


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

3.1.59 petalisp.utilities/defalias.lisp

Dependency

define-class-predicate.lisp (file)

Parent

petalisp.utilities (system)

Location

utilities/defalias.lisp

Exported Definitions

defalias (macro)


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

4 Packages

Packages are listed by definition order.


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

4.1 petalisp.api

Source

packages.lisp (file)

Nickname

petalisp

Use List
Exported Definitions

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

4.2 petalisp.reference-backend

Source

packages.lisp (file)

Use List
Exported Definitions

make-reference-backend (function)

Internal Definitions

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

4.3 petalisp.ir-backend

Source

packages.lisp (file)

Use List
Exported Definitions

make-ir-backend (function)

Internal Definitions

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

4.4 petalisp.native-backend

Source

packages.lisp (file)

Use List
Exported Definitions

make-native-backend (function)

Internal Definitions

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

4.5 petalisp.ir

Source

packages.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.6 petalisp.core

Source

packages.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

4.7 petalisp.utilities

Source

packages.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Constants

Constant: ~
Package

petalisp.core

Source

shape.lisp (file)


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

5.1.2 Special variables

Special Variable: *backend*
Package

petalisp.core

Source

api.lisp (file)


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

5.1.3 Macros

Macro: defalias ALIAS FUNCTION
Package

petalisp.utilities

Source

defalias.lisp (file)

Macro: define-class-predicate CLASS-NAME &key HYPHENATE
Package

petalisp.utilities

Source

define-class-predicate.lisp (file)

Macro: define-method-pair NAME &rest ARGS
Package

petalisp.utilities

Source

define-method-pair.lisp (file)

Macro: define-parallel-aliases NAME
Package

petalisp.api

Source

api.lisp (file)

Macro: with-hash-table-memoization (KEY &key STORE-KEY) HASH-TABLE &body BODY

Memoize the value of BODY. If KEY is found in HASH-TABLE, BODY is not evaluated and the corresponding value is returned. Otherwise, BODY is evaluated and its values are first stored as the HASH-TABLE entry of KEY and then returned.

If the optional form STORE-KEY is supplied, it is evaluated after any evaluation of BODY and its value is used instead of KEY for storing the results. This way, KEY can be an object with dynamic extent (to avoid consing) and STORE-KEY can create a copy with indefinite extent when necessary.

Package

petalisp.utilities

Source

memoization.lisp (file)

Macro: with-memoization (KEY &key TEST STORE-KEY) &body BODY

Memoize the value of BODY. If KEY has the same value (with respect to TEST) as some previously computed key, then BODY is not evaluated and the values of the previous computation are returned.

Note: TEST is evaluated at load time in a null lexical environment and must be a valid hash table test designator.

If the optional form STORE-KEY is supplied, it is evaluated after any evaluation of BODY and its value is used instead of KEY for storing the results. This way, KEY can be an object with dynamic extent (to avoid consing) and STORE-KEY can create a copy with indefinite extent when necessary.

Package

petalisp.utilities

Source

memoization.lisp (file)

Macro: with-multiple-value-hash-table-memoization (KEY &key STORE-KEY) HASH-TABLE &body BODY

Memoize the multiple values of BODY. If KEY is found in HASH-TABLE, BODY is not evaluated and the values of the previous computation are returned. Otherwise, BODY is evaluated and its values are first stored at KEY in HASH-TABLE and then returned.

If the optional form STORE-KEY is supplied, it is evaluated after any evaluation of BODY and its value is used instead of KEY for storing the results. This way, KEY can be an object with dynamic extent (to avoid consing) and STORE-KEY can create a copy with indefinite extent when necessary.

Package

petalisp.utilities

Source

memoization.lisp (file)

Macro: with-multiple-value-memoization (KEY &key TEST STORE-KEY) &body BODY

Memoize the multiple values of BODY. If KEY has the same value (with respect to TEST) as some previously computed key, then BODY is not evaluated and the values of the previous computation are returned.

Note: TEST is evaluated at load time in a null lexical environment and must be a suitable hash table test.

If the optional form STORE-KEY is supplied, it is evaluated after any evaluation of BODY and its value is used instead of KEY for storing the results. This way, KEY can be an object with dynamic extent (to avoid consing) and STORE-KEY can create a copy with indefinite extent when necessary.

Package

petalisp.utilities

Source

memoization.lisp (file)

Macro: with-multiple-value-vector-memoization (KEY &key SIZE GROWTH) &body BODY

Memoize the values of BODY for VAR being a relatively small integer.

Package

petalisp.utilities

Source

memoization.lisp (file)

Macro: with-vector-memoization (KEY &key SIZE GROWTH) &body BODY

Memoize the value of BODY for KEY being a relatively small integer.

Package

petalisp.utilities

Source

memoization.lisp (file)

Macro: τ INPUT-FORMS OUTPUT-FORMS
Package

petalisp.core

Source

transformation-constructors.lisp (file)


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

5.1.4 Compiler macros

Compiler Macro: range &rest ARGS
Package

petalisp.core

Source

range.lisp (file)

Compiler Macro: ~ &rest TILDE-SEPARATED-RANGE-DESIGNATORS
Package

petalisp.core

Source

shape.lisp (file)


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

5.1.5 Functions

Function: a ARG-1 ARG-2 &rest MORE-ARGS
Package

petalisp.api

Source

lazy-array-constructors.lisp (file)

Function: b FUNCTION ARRAY &rest MORE-ARRAYS
Package

petalisp.api

Source

lazy-array-constructors.lisp (file)

Function: broadcast-arrays &rest ARRAYS
Package

petalisp.core

Source

broadcasting.lisp (file)

Function: collapsing-transformation SHAPE
Package

petalisp.core

Source

shape-transformations.lisp (file)

Function: compute &rest ARGUMENTS

Return the computed values of all ARGUMENTS.

Package

petalisp.core

Source

backend.lisp (file)

Function: compute-kernels ROOT BACKEND
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Function: empty-array ()
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: extended-euclid U V

Given nonnegative integers u and v, return the values u1 and u3 such that u*u1 + v*u2 = u3 = gcd(u,v).

Package

petalisp.utilities

Source

extended-euclid.lisp (file)

Function: fuse &rest INPUTS

Combine ARRAYS into a single strided array. It is an error if some of the supplied arrays overlap, or if there exists no suitable strided array to represent the fusion.

Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: fuse* &rest INPUTS

Combine ARRAYS into a single strided array. When some of the supplied arguments overlap partially, the value of the rightmost object is used.

Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: highest-instruction-number KERNEL
Package

petalisp.ir

Source

ir.lisp (file)

Function: identical SEQUENCE &key TEST KEY

Check whether the KEYs of SEQUENCE are identical with respect to TEST.

Package

petalisp.utilities

Source

identical.lisp (file)

Function: identity-transformation RANK
Package

petalisp.core

Source

identity-transformation.lisp (file)

Function: indices ARRAY-OR-SHAPE &optional AXIS

Return an array of integers, where the value of each entry (i_0 ... i_N) is i_AXIS. If axis is not supplied, it defaults to zero.

Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: input OBJECT
Package

petalisp.core

Source

lazy-array.lisp (file)

Function: ir-from-lazy-arrays LAZY-ARRAYS BACKEND
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Function: kernel-buffers KERNEL
Package

petalisp.ir

Source

ir.lisp (file)

Function: make-array-immediate ARRAY
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: make-explicit-set SEQUENCE
Package

petalisp.core

Source

explicit-set.lisp (file)

Function: make-ir-backend ()
Package

petalisp.ir-backend

Source

ir-backend.lisp (file)

Function: make-native-backend &key THREADS
Package

petalisp.native-backend

Source

native-backend.lisp (file)

Function: make-range START STEP END
Package

petalisp.core

Source

range.lisp (file)

Function: make-range-immediate RANGE
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: make-reference-backend ()
Package

petalisp.reference-backend

Source

reference-backend.lisp (file)

Function: make-shape RANGES
Package

petalisp.core

Source

shape.lisp (file)

Function: make-transformation &key INPUT-MASK OUTPUT-MASK OFFSETS SCALINGS INPUT-RANK OUTPUT-RANK
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: map-buffers FUNCTION ROOT-BUFFERS
Package

petalisp.ir

Source

ir.lisp (file)

Function: map-instructions FUNCTION KERNEL
Package

petalisp.ir

Source

ir.lisp (file)

Function: normalize-ir ROOT-BUFFERS
Package

petalisp.ir

Source

ir.lisp (file)

Function: parse-blueprint BLUEPRINT
Package

petalisp.ir

Source

blueprint.lisp (file)

Function: range START &optional STEP-OR-END END
Package

petalisp.core

Source

range.lisp (file)

Function: reshape ARRAY &rest SHAPES-AND-TRANSFORMATIONS

Return a data structure of given SHAPE, either by selecting a subset of the elements of DATA, or by broadcasting them.

Examples:
(reshape 0 (~ 10 ~ 10)) ; Create a 10x10 array of zeros (reshape #(1 2 3 4) (~ 1 2)) ; Select the two interior entries

Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: schedule &rest ARGUMENTS

Instruct Petalisp to compute all given ARGUMENTS asynchronously.

Package

petalisp.core

Source

backend.lisp (file)

Function: update-instruction-numbers KERNEL
Package

petalisp.ir

Source

ir.lisp (file)

Function: ~ &rest TILDE-SEPARATED-RANGE-DESIGNATORS
Package

petalisp.core

Source

shape.lisp (file)

Function: α ARG-1 ARG-2 &rest MORE-ARGS
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: β FUNCTION ARRAY &rest MORE-ARRAYS
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)


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

5.1.6 Generic functions

Generic Function: arguments OBJECT
Package

petalisp.ir

Methods
Method: arguments (REDUCE-INSTRUCTION reduce-instruction)

automatically generated reader method

Source

ir.lisp (file)

Method: arguments (CALL-INSTRUCTION call-instruction)

automatically generated reader method

Source

ir.lisp (file)

Generic Function: blueprint KERNEL
Package

petalisp.ir

Source

blueprint.lisp (file)

Methods
Method: blueprint (TRANSFORMATION transformation)
Method: blueprint (REDUCE-INSTRUCTION reduce-instruction)
Method: blueprint (IREF-INSTRUCTION iref-instruction)
Method: blueprint (STORE-INSTRUCTION store-instruction)
Method: blueprint (LOAD-INSTRUCTION load-instruction)
Method: blueprint (CALL-INSTRUCTION call-instruction)
Method: blueprint (RANGE range)
Method: blueprint (BUFFER buffer)
Method: blueprint (KERNEL kernel)
Method: blueprint (NULL null)
Method: blueprint (KERNEL kernel) around
Generic Function: buffer OBJECT
Package

petalisp.ir

Methods
Method: buffer (STORE-INSTRUCTION store-instruction)

automatically generated reader method

Source

ir.lisp (file)

Method: buffer (LOAD-INSTRUCTION load-instruction)

automatically generated reader method

Source

ir.lisp (file)

Generic Function: buffer-shape OBJECT
Generic Function: (setf buffer-shape) NEW-VALUE OBJECT
Package

petalisp.ir

Methods
Method: buffer-shape (BUFFER buffer)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf buffer-shape) NEW-VALUE (BUFFER buffer)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: coerce-to-lazy-array ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: coerce-to-lazy-array OBJECT
Method: coerce-to-lazy-array (ARRAY array)
Method: coerce-to-lazy-array (LAZY-ARRAY lazy-array)
Generic Function: compose-transformations G F
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: compose-transformations (G hairy-transformation) (F hairy-transformation)
Source

hairy-transformation.lisp (file)

Method: compose-transformations (G transformation) (F identity-transformation)
Source

identity-transformation.lisp (file)

Method: compose-transformations (G identity-transformation) (F transformation)
Source

identity-transformation.lisp (file)

Method: compose-transformations (G transformation) (F transformation) before
Generic Function: compute-buffer-table LAZY-ARRAYS BACKEND
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Methods
Method: compute-buffer-table (GRAPH-ROOTS list) (BACKEND backend)
Generic Function: compute-immediates LAZY-ARRAYS BACKEND
Package

petalisp.core

Source

backend.lisp (file)

Methods
Method: compute-immediates (LAZY-ARRAYS list) (NATIVE-BACKEND native-backend)
Source

execution.lisp (file)

Method: compute-immediates (LAZY-ARRAYS list) (IR-BACKEND ir-backend)
Source

execution.lisp (file)

Method: compute-immediates (LAZY-ARRAYS list) (BACKEND reference-backend) around
Source

reference-backend.lisp (file)

Method: compute-immediates (LAZY-ARRAYS list) (BACKEND reference-backend)
Source

reference-backend.lisp (file)

Generic Function: compute-on-backend LAZY-ARRAYS BACKEND
Package

petalisp.core

Source

backend.lisp (file)

Methods
Method: compute-on-backend (LAZY-ARRAYS list) (BACKEND backend)
Generic Function: delete-backend BACKEND
Package

petalisp.core

Source

backend.lisp (file)

Methods
Method: delete-backend (ASYNCHRONOUS-BACKEND asynchronous-backend)
Method: delete-backend (BACKEND backend)
Generic Function: element-type ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: element-type (BUFFER buffer)

automatically generated reader method

Source

ir.lisp (file)

Method: element-type (REFERENCE reference)
Method: element-type (REDUCTION reduction)
Method: element-type (APPLICATION application)
Method: element-type EMPTY-ARRAY
Method: element-type (ARRAY array)
Method: element-type (FUSION fusion)

automatically generated reader method

Method: element-type (RANGE-IMMEDIATE range-immediate)

automatically generated reader method

Method: element-type (ARRAY-IMMEDIATE array-immediate)

automatically generated reader method

Generic Function: empty-array-p OBJECT
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: empty-array-p (EMPTY-ARRAY empty-array)
Method: empty-array-p (ARRAY array)
Method: empty-array-p OBJECT
Generic Function: enlarge-shape SHAPE RANGE
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: enlarge-shape (SHAPE shape) (RANGE range)
Generic Function: enlarge-transformation TRANSFORMATION SCALE OFFSET
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: enlarge-transformation (TRANSFORMATION hairy-transformation) SCALING OFFSET
Source

hairy-transformation.lisp (file)

Method: enlarge-transformation (TRANSFORMATION identity-transformation) (SCALE rational) (OFFSET rational)
Source

identity-transformation.lisp (file)

Method: enlarge-transformation (TRANSFORMATION identity-transformation) (SCALE (eql 1)) (OFFSET (eql 0))
Source

identity-transformation.lisp (file)

Generic Function: identity-transformation-p OBJECT
Package

petalisp.core

Source

identity-transformation.lisp (file)

Methods
Method: identity-transformation-p OBJECT
Method: identity-transformation-p (IDENTITY-TRANSFORMATION identity-transformation)
Generic Function: immediatep OBJECT
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: immediatep (IMMEDIATE immediate)
Method: immediatep OBJECT
Generic Function: input-rank TRANSFORMATION
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: input-rank (HAIRY-TRANSFORMATION hairy-transformation)

automatically generated reader method

Source

hairy-transformation.lisp (file)

Method: input-rank (IDENTITY-TRANSFORMATION identity-transformation)

automatically generated reader method

Source

identity-transformation.lisp (file)

Generic Function: inputs ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Writer

(setf inputs) (generic function)

Methods
Method: inputs (BUFFER buffer)

automatically generated reader method

Source

ir.lisp (file)

Method: inputs OBJECT
Method: inputs (NON-IMMEDIATE non-immediate)

automatically generated reader method

Generic Function: (setf inputs) NEW-VALUE OBJECT
Package

petalisp.core

Reader

inputs (generic function)

Methods
Method: (setf inputs) NEW-VALUE (BUFFER buffer)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: instruction-number OBJECT
Generic Function: (setf instruction-number) NEW-VALUE OBJECT
Package

petalisp.ir

Methods
Method: instruction-number (INSTRUCTION instruction)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf instruction-number) NEW-VALUE (INSTRUCTION instruction)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: invert-transformation TRANSFORMATION
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: invert-transformation (TRANSFORMATION hairy-invertible-transformation)
Source

hairy-transformation.lisp (file)

Method: invert-transformation (TRANSFORMATION transformation)
Source

invertible-transformation.lisp (file)

Method: invert-transformation (TRANSFORMATION cached-inverse-transformation-mixin) around
Source

invertible-transformation.lisp (file)

Method: invert-transformation (TRANSFORMATION identity-transformation)
Source

identity-transformation.lisp (file)

Generic Function: invertible-transformation-p OBJECT
Package

petalisp.core

Source

invertible-transformation.lisp (file)

Methods
Method: invertible-transformation-p (TRANSFORMATION invertible-transformation)
Method: invertible-transformation-p OBJECT
Generic Function: iteration-space OBJECT
Generic Function: (setf iteration-space) NEW-VALUE OBJECT
Package

petalisp.ir

Methods
Method: iteration-space (KERNEL kernel)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf iteration-space) NEW-VALUE (KERNEL kernel)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: lazy-array-p OBJECT
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: lazy-array-p (LAZY-ARRAY lazy-array)
Method: lazy-array-p OBJECT
Generic Function: lisp-datum-from-immediate LAZY-ARRAY
Package

petalisp.core

Source

backend.lisp (file)

Methods
Method: lisp-datum-from-immediate (SIMPLE-IMMEDIATE simple-immediate)
Source

simple-immediate.lisp (file)

Method: lisp-datum-from-immediate (RANGE-IMMEDIATE range-immediate)
Method: lisp-datum-from-immediate (ARRAY-IMMEDIATE array-immediate)
Generic Function: loads OBJECT
Generic Function: (setf loads) NEW-VALUE OBJECT
Package

petalisp.ir

Methods
Method: loads (KERNEL kernel)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf loads) NEW-VALUE (KERNEL kernel)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: make-buffer LAZY-ARRAY BACKEND
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: make-buffer (LAZY-ARRAY lazy-array) (NATIVE-BACKEND native-backend)
Source

ir-conversion.lisp (file)

Method: make-buffer (ARRAY-IMMEDIATE array-immediate) (NATIVE-BACKEND native-backend)
Source

ir-conversion.lisp (file)

Method: make-buffer (RANGE-IMMEDIATE range-immediate) (IR-BACKEND ir-backend)
Source

ir-conversion.lisp (file)

Method: make-buffer (ARRAY-IMMEDIATE array-immediate) (IR-BACKEND ir-backend)
Source

ir-conversion.lisp (file)

Method: make-buffer (LAZY-ARRAY lazy-array) (IR-BACKEND ir-backend)
Source

ir-conversion.lisp (file)

Method: make-buffer (LAZY-ARRAY lazy-array) (BACKEND backend)
Generic Function: make-kernel BACKEND &key ITERATION-SPACE LOADS STORES REDUCTION-RANGE
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: make-kernel (BACKEND native-backend) &rest ARGS
Source

ir-conversion.lisp (file)

Method: make-kernel (IR-BACKEND ir-backend) &rest ARGS
Source

ir-conversion.lisp (file)

Method: make-kernel (BACKEND backend) &rest ARGS
Generic Function: make-reference INPUT SHAPE TRANSFORMATION
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Methods
Method: make-reference (LAZY-ARRAY lazy-array) (SHAPE shape) (TRANSFORMATION transformation) before
Method: make-reference (LAZY-ARRAY lazy-array) (SHAPE shape) (TRANSFORMATION transformation)
Method: make-reference (LAZY-ARRAY lazy-array) (EMPTY-SET empty-set) (TRANSFORMATION transformation)
Method: make-reference (LAZY-ARRAY lazy-array) (SHAPE shape) (IDENTITY-TRANSFORMATION identity-transformation)
Method: make-reference (REFERENCE reference) (SHAPE shape) (TRANSFORMATION transformation)
Generic Function: map-instruction-inputs FUNCTION INSTRUCTION
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: map-instruction-inputs (FUNCTION function) (IREF-INSTRUCTION iref-instruction)
Method: map-instruction-inputs (FUNCTION function) (LOAD-INSTRUCTION load-instruction)
Method: map-instruction-inputs (FUNCTION function) (STORE-INSTRUCTION store-instruction)
Method: map-instruction-inputs (FUNCTION function) (REDUCE-INSTRUCTION reduce-instruction)
Method: map-instruction-inputs (FUNCTION function) (CALL-INSTRUCTION call-instruction)
Generic Function: map-transformation-outputs FUNCTION TRANSFORMATION &key FROM-END
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: map-transformation-outputs (FUNCTION function) (TRANSFORMATION hairy-transformation) &key FROM-END
Source

hairy-transformation.lisp (file)

Method: map-transformation-outputs (FUNCTION function) (TRANSFORMATION identity-transformation) &key FROM-END
Source

identity-transformation.lisp (file)

Generic Function: operator ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: operator (REDUCE-INSTRUCTION reduce-instruction)

automatically generated reader method

Source

ir.lisp (file)

Method: operator (CALL-INSTRUCTION call-instruction)

automatically generated reader method

Source

ir.lisp (file)

Method: operator (REDUCTION reduction)

automatically generated reader method

Method: operator (APPLICATION application)

automatically generated reader method

Generic Function: output-rank TRANSFORMATION
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: output-rank (HAIRY-TRANSFORMATION hairy-transformation)

automatically generated reader method

Source

hairy-transformation.lisp (file)

Method: output-rank (IDENTITY-TRANSFORMATION identity-transformation)

automatically generated reader method

Source

identity-transformation.lisp (file)

Generic Function: outputs OBJECT
Generic Function: (setf outputs) NEW-VALUE OBJECT
Package

petalisp.ir

Methods
Method: outputs (BUFFER buffer)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf outputs) NEW-VALUE (BUFFER buffer)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: overwrite-instance INSTANCE REPLACEMENT
Package

petalisp.core

Source

backend.lisp (file)

Methods
Method: overwrite-instance (INSTANCE lazy-array) (REPLACEMENT simple-immediate)
Source

simple-immediate.lisp (file)

Method: overwrite-instance (INSTANCE lazy-array) (REPLACEMENT range-immediate)
Method: overwrite-instance (INSTANCE lazy-array) (REPLACEMENT array-immediate)
Method: overwrite-instance (INSTANCE lazy-array) (REPLACEMENT reference)
Method: overwrite-instance (INSTANCE reference) (REPLACEMENT reference)
Generic Function: range-end RANGE
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: range-end (NON-SIZE-ONE-CONTIGUOUS-RANGE non-size-one-contiguous-range)

automatically generated reader method

Method: range-end (SIZE-ONE-RANGE size-one-range)

automatically generated reader method

Method: range-end (NON-CONTIGUOUS-RANGE non-contiguous-range)

automatically generated reader method

Generic Function: range-start RANGE
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: range-start (NON-SIZE-ONE-CONTIGUOUS-RANGE non-size-one-contiguous-range)

automatically generated reader method

Method: range-start (SIZE-ONE-RANGE size-one-range)

automatically generated reader method

Method: range-start (NON-CONTIGUOUS-RANGE non-contiguous-range)

automatically generated reader method

Generic Function: range-start-step-end RANGE
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: range-start-step-end (RANGE size-one-range)
Method: range-start-step-end (RANGE contiguous-range)
Method: range-start-step-end (RANGE range)
Generic Function: range-step RANGE
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: range-step (RANGE contiguous-range)
Method: range-step (NON-CONTIGUOUS-RANGE non-contiguous-range)

automatically generated reader method

Generic Function: rangep OBJECT
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: rangep OBJECT
Method: rangep (RANGE range)
Generic Function: ranges SHAPE
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: ranges (SHAPE shape)

automatically generated reader method

Generic Function: rank SHAPE
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: rank (LAZY-ARRAY lazy-array)
Source

lazy-array.lisp (file)

Method: rank (ARRAY array)
Source

lazy-array.lisp (file)

Method: rank OBJECT
Source

lazy-array.lisp (file)

Method: rank (SHAPE shape)

automatically generated reader method

Generic Function: reduction-kernel-p OBJECT
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: reduction-kernel-p OBJECT
Method: reduction-kernel-p (KERNEL kernel)
Generic Function: reduction-range REDUCTION
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: reduction-range (REDUCTION reduction)
Method: reduction-range (KERNEL kernel)

automatically generated reader method

Generic Function: refcount ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Writer

(setf refcount) (generic function)

Methods
Method: refcount OBJECT
Method: refcount (NON-EMPTY-NON-IMMEDIATE non-empty-non-immediate)

automatically generated reader method

Generic Function: (setf refcount) NEW-VALUE OBJECT
Package

petalisp.core

Reader

refcount (generic function)

Methods
Method: (setf refcount) NEW-VALUE (NON-EMPTY-NON-IMMEDIATE non-empty-non-immediate)

automatically generated writer method

Source

lazy-array.lisp (file)

Generic Function: rotate-buffer BUFFER TRANSFORMATION
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: rotate-buffer (BUFFER buffer) (TRANSFORMATION transformation) after
Method: rotate-buffer (BUFFER buffer) (TRANSFORMATION transformation)
Generic Function: rotate-kernel KERNEL TRANSFORMATION
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: rotate-kernel (KERNEL kernel) (TRANSFORMATION transformation)
Method: rotate-kernel (KERNEL kernel) (TRANSFORMATION identity-transformation)
Generic Function: schedule-on-backend LAZY-ARRAYS BACKEND
Package

petalisp.core

Source

backend.lisp (file)

Methods
Method: schedule-on-backend (DATA-STRUCTURES list) (ASYNCHRONOUS-BACKEND asynchronous-backend)
Method: schedule-on-backend (LAZY-ARRAYS list) (BACKEND backend)
Generic Function: set-contains SET OBJECT
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-contains (SHAPE shape) (TUPLE list)
Source

shape.lisp (file)

Method: set-contains (RANGE size-one-range) (INTEGER integer)
Source

range.lisp (file)

Method: set-contains (RANGE contiguous-range) (INTEGER integer)
Source

range.lisp (file)

Method: set-contains (RANGE range) (INTEGER integer)
Source

range.lisp (file)

Method: set-contains (SET explicit-set) OBJECT
Source

explicit-set.lisp (file)

Method: set-contains (SET empty-set) OBJECT
Source

empty-set.lisp (file)

Method: set-contains (SET finite-set) OBJECT
Generic Function: set-difference SET-1 SET-2
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-difference (SHAPE-1 shape) (SHAPE-2 shape)
Source

shape.lisp (file)

Method: set-difference (SET-1 finite-set) (SET-2 finite-set)
Source

explicit-set.lisp (file)

Method: set-difference (SET-1 explicit-set) (SET-2 explicit-set)
Source

explicit-set.lisp (file)

Method: set-difference (ANY-SET any-set) (EMPTY-SET empty-set)
Source

empty-set.lisp (file)

Generic Function: set-elements SET
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-elements (SET empty-set)
Source

empty-set.lisp (file)

Method: set-elements (SET finite-set)
Generic Function: set-emptyp SET
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-emptyp (SET empty-set)
Source

empty-set.lisp (file)

Method: set-emptyp (SET any-set)
Generic Function: set-equal SET-1 SET-2
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-equal (SHAPE-1 shape) (SHAPE-2 shape)
Source

shape.lisp (file)

Method: set-equal (EXPLICIT-SET explicit-set) (RANGE range)
Source

range.lisp (file)

Method: set-equal (RANGE range) (EXPLICIT-SET explicit-set)
Source

range.lisp (file)

Method: set-equal (RANGE-2 range) (RANGE-1 size-one-range)
Source

range.lisp (file)

Method: set-equal (RANGE-1 size-one-range) (RANGE-2 range)
Source

range.lisp (file)

Method: set-equal (RANGE-1 size-one-range) (RANGE-2 size-one-range)
Source

range.lisp (file)

Method: set-equal (RANGE-1 range) (RANGE-2 range)
Source

range.lisp (file)

Method: set-equal (SET-1 explicit-set) (SET-2 explicit-set)
Source

explicit-set.lisp (file)

Method: set-equal (ANY-SET any-set) (EMPTY-SET empty-set)
Source

empty-set.lisp (file)

Method: set-equal (EMPTY-SET empty-set) (ANY-SET any-set)
Source

empty-set.lisp (file)

Method: set-equal (SET-1 empty-set) (SET-2 empty-set)
Source

empty-set.lisp (file)

Method: set-equal (SET-2 infinite-set) (SET-1 finite-set)
Method: set-equal (SET-1 finite-set) (SET-2 infinite-set)
Generic Function: set-for-each FUNCTION SET
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-for-each (FUNCTION function) (SHAPE shape)
Source

shape.lisp (file)

Method: set-for-each (FUNCTION function) (RANGE range)
Source

range.lisp (file)

Method: set-for-each (FUNCTION function) (SET explicit-set)
Source

explicit-set.lisp (file)

Method: set-for-each (FUNCTION function) (SET empty-set)
Source

empty-set.lisp (file)

Generic Function: set-intersection SET-1 SET-2
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-intersection (SHAPE-1 shape) (SHAPE-2 shape)
Source

shape.lisp (file)

Method: set-intersection (RANGE-1 contiguous-range) (RANGE-2 contiguous-range)
Source

range.lisp (file)

Method: set-intersection (RANGE-1 range) (RANGE-2 range)
Source

range.lisp (file)

Method: set-intersection (SET-1 finite-set) (SET-2 finite-set)
Source

explicit-set.lisp (file)

Method: set-intersection (SET-1 explicit-set) (SET-2 explicit-set)
Source

explicit-set.lisp (file)

Method: set-intersection (ANY-SET any-set) (EMPTY-SET empty-set)
Source

empty-set.lisp (file)

Method: set-intersection (EMPTY-SET empty-set) (ANY-SET any-set)
Source

empty-set.lisp (file)

Generic Function: set-intersectionp SET-1 SET-2
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-intersectionp (SHAPE-1 shape) (SHAPE-2 shape)
Source

shape.lisp (file)

Method: set-intersectionp (RANGE-1 range) (RANGE-2 range)
Source

range.lisp (file)

Method: set-intersectionp (SET-1 explicit-set) (SET-2 explicit-set)
Source

explicit-set.lisp (file)

Method: set-intersectionp (ANY-SET any-set) (EMPTY-SET empty-set)
Source

empty-set.lisp (file)

Method: set-intersectionp (EMPTY-SET empty-set) (ANY-SET any-set)
Source

empty-set.lisp (file)

Method: set-intersectionp (SET-1 any-set) (SET-2 any-set)
Generic Function: set-size SET
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-size (SHAPE shape)
Source

shape.lisp (file)

Method: set-size (RANGE size-one-range)
Source

range.lisp (file)

Method: set-size (RANGE contiguous-range)
Source

range.lisp (file)

Method: set-size (RANGE range)
Source

range.lisp (file)

Method: set-size (SET explicit-set)
Source

explicit-set.lisp (file)

Method: set-size (SET empty-set)
Source

empty-set.lisp (file)

Method: set-size (SET finite-set)
Generic Function: set-subsetp SET-1 SET-2
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-subsetp (SET-1 any-set) (SET-2 any-set)
Method: set-subsetp (SET-1 infinite-set) (SET-2 finite-set)
Generic Function: set-union SET-1 SET-2
Package

petalisp.core

Source

set.lisp (file)

Methods
Method: set-union (SET-1 explicit-set) (SET-2 explicit-set)
Source

explicit-set.lisp (file)

Method: set-union (ANY-SET any-set) (EMPTY-SET empty-set)
Source

empty-set.lisp (file)

Method: set-union (EMPTY-SET empty-set) (ANY-SET any-set)
Source

empty-set.lisp (file)

Generic Function: shape ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: shape (EMPTY-ARRAY empty-array)
Method: shape (ANY-SET any-set)
Method: shape (ARRAY array)
Method: shape OBJECT
Method: shape (NON-EMPTY-ARRAY non-empty-array)

automatically generated reader method

Generic Function: shape-difference-list SHAPE-1 SHAPE-2
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: shape-difference-list (SHAPE-1 shape) (SHAPE-2 shape)
Generic Function: shapep OBJECT
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: shapep OBJECT
Method: shapep (SHAPE shape)
Generic Function: shrink-shape SHAPE
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: shrink-shape (SHAPE shape)
Generic Function: size-one-range-p OBJECT
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: size-one-range-p OBJECT
Method: size-one-range-p (SIZE-ONE-RANGE size-one-range)
Generic Function: split-range RANGE
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: split-range (RANGE range)
Generic Function: storage ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Writer

(setf storage) (generic function)

Methods
Method: storage (ARRAY-BUFFER array-buffer)

automatically generated reader method

Source

ir-conversion.lisp (file)

Method: storage (NON-IMMEDIATE-BUFFER non-immediate-buffer)

automatically generated reader method

Source

ir-conversion.lisp (file)

Method: storage (BUFFER buffer)

automatically generated reader method

Source

ir-conversion.lisp (file)

Method: storage (ARRAY-IMMEDIATE array-immediate)

automatically generated reader method

Generic Function: (setf storage) NEW-VALUE OBJECT
Package

petalisp.core

Reader

storage (generic function)

Methods
Method: (setf storage) NEW-VALUE (NON-IMMEDIATE-BUFFER non-immediate-buffer)

automatically generated writer method

Source

ir-conversion.lisp (file)

Generic Function: stores OBJECT
Generic Function: (setf stores) NEW-VALUE OBJECT
Package

petalisp.ir

Methods
Method: stores (KERNEL kernel)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf stores) NEW-VALUE (KERNEL kernel)

automatically generated writer method

Source

ir.lisp (file)

Generic Function: total-size ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: total-size (FINITE-SET finite-set)
Method: total-size (NON-EMPTY-ARRAY non-empty-array)
Method: total-size (EMPTY-ARRAY empty-array)
Method: total-size (ARRAY array)
Method: total-size OBJECT
Generic Function: transform OBJECT TRANSFORMATION
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: transform (LAZY-ARRAY lazy-array) (TRANSFORMATION transformation)
Source

lazy-array.lisp (file)

Method: transform (SHAPE shape) (TRANSFORMATION hairy-transformation)
Source

shape-transformations.lisp (file)

Method: transform (SHAPE shape) (OPERATOR identity-transformation)
Source

shape-transformations.lisp (file)

Method: transform (SHAPE shape) (TRANSFORMATION hairy-transformation) before
Source

shape-transformations.lisp (file)

Method: transform (SHAPE shape) (TRANSFORMATION transformation) before
Source

shape-transformations.lisp (file)

Method: transform (LIST list) (TRANSFORMATION hairy-transformation)
Source

hairy-transformation.lisp (file)

Method: transform (SEQUENCE sequence) (TRANSFORMATION hairy-transformation) before
Source

hairy-transformation.lisp (file)

Method: transform (SEQUENCE sequence) (OPERATOR identity-transformation)
Source

identity-transformation.lisp (file)

Method: transform (SEQUENCE sequence) (TRANSFORMATION transformation)
Generic Function: transform-axis AXIS TRANSFORMATION
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: transform-axis (AXIS integer) (HAIRY-TRANSFORMATION hairy-transformation)
Source

hairy-transformation.lisp (file)

Method: transform-axis (AXIS integer) (TRANSFORMATION identity-transformation)
Source

identity-transformation.lisp (file)

Method: transform-axis (AXIS integer) (TRANSFORMATION transformation)
Generic Function: transformation OBJECT
Generic Function: (setf transformation) NEW-VALUE OBJECT
Package

petalisp.core

Methods
Method: transformation (ITERATING-INSTRUCTION iterating-instruction)

automatically generated reader method

Source

ir.lisp (file)

Method: (setf transformation) NEW-VALUE (ITERATING-INSTRUCTION iterating-instruction)

automatically generated writer method

Source

ir.lisp (file)

Method: transformation (REFERENCE reference)

automatically generated reader method

Source

lazy-array.lisp (file)

Generic Function: transformation-equal TRANSFORMATION-1 TRANSFORMATION-2
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: transformation-equal (T1 hairy-transformation) (T2 hairy-transformation)
Source

hairy-transformation.lisp (file)

Method: transformation-equal (TRANSFORMATION-1 identity-transformation) (TRANSFORMATION-2 identity-transformation)
Source

identity-transformation.lisp (file)

Method: transformation-equal (T1 transformation) (T2 transformation)
Generic Function: transformationp OBJECT
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: transformationp OBJECT
Method: transformationp (TRANSFORMATION transformation)
Generic Function: value OBJECT
Package

petalisp.ir

Methods
Method: value (STORE-INSTRUCTION store-instruction)

automatically generated reader method

Source

ir.lisp (file)

Generic Function: value-n ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: value-n (REDUCTION reduction)

automatically generated reader method

Method: value-n (APPLICATION application)

automatically generated reader method


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

5.1.7 Classes

Class: application ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

non-empty-non-immediate (class)

Direct methods
Direct slots
Slot: %operator
Initargs

:operator

Readers

operator (generic function)

Slot: %value-n
Type

(integer 0 4611686018427387903)

Initargs

:value-n

Readers

value-n (generic function)

Class: array-immediate ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

non-empty-immediate (class)

Direct methods
Direct slots
Slot: %element-type
Initargs

:element-type

Readers

element-type (generic function)

Slot: %storage
Initargs

:storage

Readers

storage (generic function)

Class: asynchronous-backend ()
Package

petalisp.core

Source

backend.lisp (file)

Direct superclasses

backend (class)

Direct subclasses

native-backend (class)

Direct methods
Direct slots
Slot: %scheduler-queue
Initform

(lparallel.queue:make-queue)

Readers

scheduler-queue (generic function)

Slot: %scheduler-thread
Readers

scheduler-thread (generic function)

Writers

(setf scheduler-thread) (generic function)

Class: backend ()
Package

petalisp.core

Source

backend.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: buffer ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: %shape
Initargs

:shape

Readers

buffer-shape (generic function)

Writers

(setf buffer-shape) (generic function)

Slot: %element-type
Initargs

:element-type

Readers

element-type (generic function)

Slot: %inputs
Initargs

:inputs

Readers

inputs (generic function)

Writers

(setf inputs) (generic function)

Slot: %outputs
Initargs

:outputs

Readers

outputs (generic function)

Writers

(setf outputs) (generic function)

Class: call-instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

instruction (class)

Direct methods
Direct slots
Slot: %operator
Initargs

:operator

Readers

operator (generic function)

Slot: %arguments
Initargs

:arguments

Readers

arguments (generic function)

Class: empty-array ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

immediate (class)

Direct methods
Class: fusion ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

non-empty-non-immediate (class)

Direct methods
Direct slots
Slot: %element-type
Initargs

:element-type

Readers

element-type (generic function)

Class: identity-transformation ()
Package

petalisp.core

Source

identity-transformation.lisp (file)

Direct superclasses

invertible-transformation (class)

Direct methods
Direct slots
Slot: %rank
Type

(integer 0 *)

Initargs

:rank

Readers
Class: immediate ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

lazy-array (class)

Direct subclasses
Direct methods
Class: instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: %number
Initform

(petalisp.ir::next-instruction-number)

Readers

instruction-number (generic function)

Writers

(setf instruction-number) (generic function)

Class: iref-instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

iterating-instruction (class)

Direct methods
Class: iterating-instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

instruction (class)

Direct subclasses
Direct methods
Direct slots
Slot: %transformation
Initargs

:transformation

Readers

transformation (generic function)

Writers

(setf transformation) (generic function)

Class: kernel ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: %iteration-space
Initargs

:iteration-space

Readers

iteration-space (generic function)

Writers

(setf iteration-space) (generic function)

Slot: %reduction-range
Initargs

:reduction-range

Readers

reduction-range (generic function)

Slot: %loads
Initargs

:loads

Readers

loads (generic function)

Writers

(setf loads) (generic function)

Slot: %stores
Initargs

:stores

Readers

stores (generic function)

Writers

(setf stores) (generic function)

Class: lazy-array ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: load-instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

iterating-instruction (class)

Direct methods
Direct slots
Slot: %buffer
Initargs

:buffer

Readers

buffer (generic function)

Class: non-empty-array ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

lazy-array (class)

Direct subclasses
Direct methods
Direct slots
Slot: %shape
Initargs

:shape

Readers
  • shape (generic function)
  • shape (generic function)
Class: non-empty-immediate ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses
Direct subclasses
Class: non-empty-non-immediate ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses
Direct subclasses
Direct methods
Direct slots
Slot: %refcount
Initform

0

Readers

refcount (generic function)

Writers

(setf refcount) (generic function)

Class: non-immediate ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

lazy-array (class)

Direct subclasses

non-empty-non-immediate (class)

Direct methods
  • initialize-instance (method)
  • inputs (method)
Direct slots
Slot: %inputs
Initargs

:inputs

Readers

inputs (generic function)

Class: range ()
Package

petalisp.core

Source

range.lisp (file)

Direct superclasses

finite-set (class)

Direct subclasses
Direct methods
Class: range-immediate ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

non-empty-immediate (class)

Direct methods
Direct slots
Slot: %element-type
Initargs

:element-type

Readers

element-type (generic function)

Class: reduce-instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

iterating-instruction (class)

Direct methods
Direct slots
Slot: %operator
Initargs

:operator

Readers

operator (generic function)

Slot: %arguments
Initargs

:arguments

Readers

arguments (generic function)

Class: reduction ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

non-empty-non-immediate (class)

Direct methods
Direct slots
Slot: %operator
Initargs

:operator

Readers

operator (generic function)

Slot: %value-n
Type

(integer 0 4611686018427387903)

Initargs

:value-n

Readers

value-n (generic function)

Class: reference ()
Package

petalisp.core

Source

lazy-array.lisp (file)

Direct superclasses

non-empty-non-immediate (class)

Direct methods
Direct slots
Slot: %transformation
Initargs

:transformation

Readers

transformation (generic function)

Class: shape ()
Package

petalisp.core

Source

shape.lisp (file)

Direct superclasses

finite-set (class)

Direct methods
Direct slots
Slot: %rank
Type

array-rank

Initargs

:rank

Readers

rank (generic function)

Slot: %ranges
Type

list

Initargs

:ranges

Readers

ranges (generic function)

Class: store-instruction ()
Package

petalisp.ir

Source

ir.lisp (file)

Direct superclasses

iterating-instruction (class)

Direct methods
Direct slots
Slot: %value
Initargs

:value

Readers

value (generic function)

Slot: %buffer
Initargs

:buffer

Readers

buffer (generic function)

Class: transformation ()
Package

petalisp.core

Source

transformation.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

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

5.2 Internal definitions


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

5.2.1 Constants

Constant: +empty+
Package

petalisp.utilities

Source

memoization.lisp (file)


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

5.2.2 Special variables

Special Variable: *buffer-table*
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Special Variable: *buffers*
Package

petalisp.ir

Source

blueprint.lisp (file)

Special Variable: *function-counter*
Package

petalisp.ir

Source

blueprint.lisp (file)

Special Variable: *index*
Package

petalisp.ir-backend

Source

execution.lisp (file)

Special Variable: *instruction-counter*
Package

petalisp.ir

Source

ir.lisp (file)

Special Variable: *instruction-values-cache*
Package

petalisp.ir-backend

Source

execution.lisp (file)

Special Variable: *instructions*
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Special Variable: *kernel*
Package

petalisp.ir-backend

Source

execution.lisp (file)

Special Variable: *kernel-root*
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Special Variable: *loads*
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Special Variable: *lock*
Package

petalisp.core

Source

invertible-transformation.lisp (file)

Special Variable: *memoization-table*
Package

petalisp.reference-backend

Source

reference-backend.lisp (file)

Special Variable: *reductionp*
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Special Variable: *register-iteration-space*
Package

petalisp.ir

Source

compute-iteration-spaces.lisp (file)

Special Variable: *root*
Package

petalisp.ir

Source

compute-iteration-spaces.lisp (file)

Special Variable: *translation-unit*
Package

petalisp.native-backend

Source

translation-unit.lisp (file)


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

5.2.3 Symbol macros

Symbol Macro: *initial-basic-block*
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Expansion

(petalisp.native-backend::initial-basic-block petalisp.native-backend::*translation-unit*)

Symbol Macro: *symbol-table*
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Expansion

(petalisp.native-backend::symbol-table petalisp.native-backend::*translation-unit*)


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

5.2.4 Macros

Macro: basic-block &body BODY
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Macro: bind VARIABLES INSTRUCTION BODY
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Macro: broadcast-ranges-f PLACE RANGE-2
Package

petalisp.core

Source

broadcasting.lisp (file)

Macro: document-function NAME &body BODY
Package

petalisp.core

Source

documentation.lisp (file)

Macro: document-variable NAME &body BODY
Package

petalisp.core

Source

documentation.lisp (file)

Macro: dx-flet FUNCTIONS &body BODY

Like FLET, but declare every function to have dynamic extent.

Package

petalisp.native-backend

Source

utilities.lisp (file)

Macro: dx-let BINDINGS &body BODY

Like LET, but declare every variable to have dynamic extent.

Package

petalisp.native-backend

Source

utilities.lisp (file)

Macro: dx-let* BINDINGS &body BODY

Like LET*, but declare every variable to have dynamic extent.

Package

petalisp.native-backend

Source

utilities.lisp (file)

Macro: node-value NODE
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Macro: store VALUE ARRAY ROW-MAJOR-INDEX
Package

petalisp.native-backend

Source

utilities.lisp (file)

Macro: with-instruction-numbering &body BODY
Package

petalisp.ir

Source

ir.lisp (file)

Macro: with-unsafe-optimizations &body BODY

Optimize the heck out of BODY. Use with caution!

To preserve sanity, compiler efficiency hints are disabled by default. Use WITH-UNSAFE-OPTIMIZATIONS* to see these hints.

Package

petalisp.native-backend

Source

utilities.lisp (file)

Macro: with-unsafe-optimizations* &body BODY

Optimize the heck out of BODY. Use with caution!

Package

petalisp.native-backend

Source

utilities.lisp (file)

Macro: without-compiler-notes &body BODY

Suppress all compiler notes arising during the compilation of BODY.

Package

petalisp.native-backend

Source

utilities.lisp (file)


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

5.2.5 Compiler macros

Compiler Macro: fixnum-* &rest FORMS
Package

petalisp.native-backend

Source

utilities.lisp (file)

Compiler Macro: fixnum-+ &rest FORMS
Package

petalisp.native-backend

Source

utilities.lisp (file)

Compiler Macro: make-transformation-from-function FUNCTION &optional INPUT-MASK
Package

petalisp.core

Source

transformation-constructors.lisp (file)


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

5.2.6 Functions

Function: add-loop-block RANGE INDEX IMMEDIATE-DOMINATOR
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: array-symbol N
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: blueprint-from-operator OPERATOR
Package

petalisp.ir

Source

blueprint.lisp (file)

Function: blueprint-from-value VALUE
Package

petalisp.ir

Source

blueprint.lisp (file)

Function: breaking-fusion-p FUSION REDUCTION-AXIS
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Function: broadcast-list-of-arrays LIST-OF-ARRAYS
Package

petalisp.core

Source

broadcasting.lisp (file)

Function: broadcast-ranges RANGE-1 RANGE-2
Package

petalisp.core

Source

broadcasting.lisp (file)

Function: broadcasting-transformation INPUT-SHAPE OUTPUT-SHAPE
Package

petalisp.core

Source

broadcasting.lisp (file)

Function: buffer-number BUFFER
Package

petalisp.ir

Source

blueprint.lisp (file)

Function: canonicalize-input-mask VALUE SUPPLIED-P INPUT-RANK
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: canonicalize-offsets VALUE SUPPLIED-P OUTPUT-RANK
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: canonicalize-output-mask VALUE SUPPLIED-P OUTPUT-RANK INPUT-RANK
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: canonicalize-scalings VALUE SUPPLIED-P OUTPUT-RANK
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: clear-instruction-values-cache ()
Package

petalisp.ir-backend

Source

execution.lisp (file)

Function: compile-and-execute-kernel KERNEL BACKEND
Package

petalisp.native-backend

Source

execution.lisp (file)

Function: compute-kernel ROOT ITERATION-SPACE REDUCTION-RANGE BACKEND
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Function: compute-kernel-body ROOT ITERATION-SPACE TRANSFORMATION
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Function: defining-basic-block SYMBOL
Function: (setf defining-basic-block) BASIC-BLOCK SYMBOL
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: dominates A B
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Function: empty-set ()
Package

petalisp.core

Source

empty-set.lisp (file)

Function: end-symbol N
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: finalize-buffer-table BACKEND
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Function: fixnum-* &rest FIXNUMS
Package

petalisp.native-backend

Source

utilities.lisp (file)

Function: fixnum-+ &rest FIXNUMS
Package

petalisp.native-backend

Source

utilities.lisp (file)

Function: free-variables FORM &optional ENVIRONMENT
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: from-storage-transformation SHAPE
Package

petalisp.core

Source

shape-transformations.lisp (file)

Function: function-symbol N
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: handle-reductions RANGE IMMEDIATE-DOMINATOR
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: i* &rest EXPRESSIONS
Package

petalisp.native-backend

Source

utilities.lisp (file)

Function: i+ &rest EXPRESSIONS
Package

petalisp.native-backend

Source

utilities.lisp (file)

Function: index-symbol N
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: instruction INSTRUCTION-NUMBER
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: instruction-values-cache INSTRUCTION
Function: (setf instruction-values-cache) VALUE INSTRUCTION
Package

petalisp.ir-backend

Source

execution.lisp (file)

Function: iref SIMPLE-IMMEDIATE INDEX
Package

petalisp.reference-backend

Source

simple-immediate.lisp (file)

Function: lambda-expression-from-blueprint BLUEPRINT
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: make-basic-block &key IMMEDIATE-DOMINATOR
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Function: make-fusion INPUTS
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: make-lambda-block &key LAMBDA-LIST IMMEDIATE-DOMINATOR
Package

petalisp.native-backend

Source

lambda-block.lisp (file)

Function: make-loop-block &rest ARGS
Package

petalisp.native-backend

Source

loop-block.lisp (file)

Function: make-memory-pool ()
Package

petalisp.native-backend

Source

memory-pool.lisp (file)

Function: make-range--step=0 START END
Package

petalisp.core

Source

range.lisp (file)

Function: make-range--step=1 START END
Package

petalisp.core

Source

range.lisp (file)

Function: make-range--step=n START STEP END
Package

petalisp.core

Source

range.lisp (file)

Function: make-reduction-lambda REDUCTION-SPEC
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: make-simple-immediate SHAPE ELEMENT-TYPE VALUE-FN
Package

petalisp.reference-backend

Source

simple-immediate.lisp (file)

Function: make-tail-block &key TAIL IMMEDIATE-DOMINATOR
Package

petalisp.native-backend

Source

tail-block.lisp (file)

Function: make-transformation-from-function FUNCTION &optional INPUT-MASK
Package

petalisp.core

Source

transformation-constructors.lisp (file)

Function: make-translation-unit ARRAY-TYPES
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: map-buffers-and-kernels BUFFER-FN KERNEL-FN ROOT-BUFFERS
Package

petalisp.ir

Source

ir.lisp (file)

Function: map-instruction-tree FUNCTION ROOT-INSTRUCTION
Package

petalisp.ir

Source

ir.lisp (file)

Function: map-kernels FUNCTION ROOT-BUFFERS
Package

petalisp.ir

Source

ir.lisp (file)

Function: next-instruction-number ()
Package

petalisp.ir

Source

ir.lisp (file)

Function: normalize-buffer BUFFER
Package

petalisp.ir

Source

ir.lisp (file)

Function: nth-broadcast-range SHAPE BROADCAST-RANK AXIS
Package

petalisp.core

Source

broadcasting.lisp (file)

Function: optimize-kernel-locality KERNEL
Package

petalisp.ir

Source

ir.lisp (file)

Function: optimize-locality ROOT-BUFFERS
Package

petalisp.ir

Source

ir.lisp (file)

Function: parse-defmethod ARGS
Package

petalisp.utilities

Source

define-method-pair.lisp (file)

Function: pseudo-eval VALUE-N FORM &optional TYPE
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: pseudo-eval-argument ARGUMENT
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: range-difference-list--contiguous START-1 END-1 START-2 STEP-2 END-2 MAKE-RANGE-FN
Package

petalisp.core

Source

range.lisp (file)

Function: range-difference-list--single START-1 STEP-1 END-1 INDEX
Package

petalisp.core

Source

range.lisp (file)

Function: range-fusion RANGES
Package

petalisp.core

Source

range.lisp (file)

Function: range-intersection-start-step-end RANGE-1 RANGE-2
Package

petalisp.core

Source

range.lisp (file)

Function: register-iteration-space ITERATION-SPACE
Package

petalisp.ir

Source

compute-iteration-spaces.lisp (file)

Function: sanitize-fusion-inputs INPUTS
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)

Function: shape-union-range-oracle &rest RANGES
Package

petalisp.core

Source

shape.lisp (file)

Function: simplify-argument ARGUMENT
Package

petalisp.ir

Source

ir.lisp (file)

Function: start-symbol N
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: step-symbol N
Package

petalisp.native-backend

Source

translation-unit.lisp (file)

Function: subdivision SHAPES
Package

petalisp.core

Source

shape.lisp (file)

Function: translate-instruction INSTRUCTION
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: translate-row-major-index ARRAY-NUMBER IREFS &optional REDUCTIONP
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: translate-stride ARRAY-NUMBER ARRAY-RANK AXIS
Package

petalisp.native-backend

Source

blueprint-compiler.lisp (file)

Function: traverse-node NODE SPECIAL-P REDUCTION-AXIS
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Function: α-aux N-OUTPUTS FUNCTION &rest ARGUMENTS
Package

petalisp.core

Source

lazy-array-constructors.lisp (file)


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

5.2.7 Generic functions

Generic Function: array-table OBJECT
Package

petalisp.native-backend

Methods
Method: array-table (MEMORY-POOL memory-pool)

automatically generated reader method

Source

memory-pool.lisp (file)

Generic Function: array-types OBJECT
Package

petalisp.native-backend

Methods
Method: array-types (TRANSLATION-UNIT translation-unit)

automatically generated reader method

Source

translation-unit.lisp (file)

Generic Function: bref BUFFER INDEX
Generic Function: (setf bref) VALUE BUFFER INDEX
Package

petalisp.ir-backend

Source

ir-conversion.lisp (file)

Methods
Method: bref (BUFFER buffer) (INDEX list)
Method: (setf bref) VALUE (BUFFER buffer) INDEX
Generic Function: cached-inverse OBJECT
Generic Function: (setf cached-inverse) NEW-VALUE OBJECT
Package

petalisp.core

Methods
Method: cached-inverse (CACHED-INVERSE-TRANSFORMATION-MIXIN cached-inverse-transformation-mixin)

automatically generated reader method

Source

invertible-transformation.lisp (file)

Method: (setf cached-inverse) NEW-VALUE (CACHED-INVERSE-TRANSFORMATION-MIXIN cached-inverse-transformation-mixin)

automatically generated writer method

Source

invertible-transformation.lisp (file)

Generic Function: compile-cache OBJECT
Package

petalisp.native-backend

Methods
Method: compile-cache (NATIVE-BACKEND native-backend)

automatically generated reader method

Source

native-backend.lisp (file)

Generic Function: compute-buffer BUFFER NATIVE-BACKEND
Package

petalisp.native-backend

Methods
Method: compute-buffer (BUFFER non-immediate-buffer) (NATIVE-BACKEND native-backend)
Source

execution.lisp (file)

Method: compute-buffer (BUFFER immediate-buffer) (NATIVE-BACKEND native-backend)
Source

execution.lisp (file)

Generic Function: compute-iteration-spaces ROOT-NODE
Package

petalisp.ir

Source

compute-iteration-spaces.lisp (file)

Methods
Method: compute-iteration-spaces (ROOT reduction)
Method: compute-iteration-spaces (ROOT lazy-array)
Generic Function: compute-iteration-spaces-aux NODE ITERATION-SPACE TRANSFORMATION
Package

petalisp.ir

Source

compute-iteration-spaces.lisp (file)

Methods
Method: compute-iteration-spaces-aux (IMMEDIATE immediate) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-iteration-spaces-aux (APPLICATION application) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-iteration-spaces-aux (REDUCTION reduction) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-iteration-spaces-aux (REFERENCE reference) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-iteration-spaces-aux (FUSION fusion) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-iteration-spaces-aux (NODE lazy-array) (ITERATION-SPACE shape) (TRANSFORMATION transformation) around
Generic Function: compute-value NODE ITERATION-SPACE TRANSFORMATION
Package

petalisp.ir

Source

ir-conversion.lisp (file)

Methods
Method: compute-value (LAZY-ARRAY lazy-array) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-value (FUSION fusion) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-value (REFERENCE reference) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-value (REDUCTION reduction) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-value (APPLICATION application) (ITERATION-SPACE shape) (TRANSFORMATION transformation)
Method: compute-value (NODE lazy-array) (ITERATION-SPACE shape) (TRANSFORMATION transformation) around
Generic Function: evaluate LAZY-ARRAY
Package

petalisp.reference-backend

Source

reference-backend.lisp (file)

Methods
Method: evaluate (REFERENCE reference)
Method: evaluate (FUSION fusion)
Method: evaluate (REDUCTION reduction)
Method: evaluate (APPLICATION application)
Method: evaluate (RANGE-IMMEDIATE range-immediate)
Method: evaluate (ARRAY-IMMEDIATE array-immediate)
Method: evaluate (SIMPLE-IMMEDIATE simple-immediate)
Method: evaluate (LAZY-ARRAY lazy-array) before
Method: evaluate (LAZY-ARRAY lazy-array) around
Generic Function: execute IR-NODE
Package

petalisp.ir-backend

Source

execution.lisp (file)

Methods
Method: execute (KERNEL kernel)
Method: execute (BUFFER buffer) before
Method: execute (KERNEL kernel) before
Method: execute (IR-NODE ir-node) around
Method: execute (IR-NODE ir-node)
Generic Function: execute-kernel KERNEL NATIVE-BACKEND
Package

petalisp.native-backend

Methods
Method: execute-kernel (KERNEL kernel) (NATIVE-BACKEND native-backend)
Source

execution.lisp (file)

Method: execute-kernel (KERNEL kernel) (NATIVE-BACKEND native-backend) before
Source

execution.lisp (file)

Generic Function: executedp OBJECT
Generic Function: (setf executedp) NEW-VALUE OBJECT
Package

petalisp.ir-backend

Methods
Method: executedp (IR-NODE ir-node)

automatically generated reader method

Source

ir-conversion.lisp (file)

Method: (setf executedp) NEW-VALUE (IR-NODE ir-node)

automatically generated writer method

Source

ir-conversion.lisp (file)

Generic Function: executedp OBJECT
Generic Function: (setf executedp) NEW-VALUE OBJECT
Package

petalisp.native-backend

Methods
Method: executedp (KERNEL kernel)

automatically generated reader method

Source

ir-conversion.lisp (file)

Method: (setf executedp) NEW-VALUE (KERNEL kernel)

automatically generated writer method

Source

ir-conversion.lisp (file)

Generic Function: form BASIC-BLOCK
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Methods
Method: form (LOOP-BLOCK loop-block) around
Source

loop-block.lisp (file)

Method: form (LAMBDA-BLOCK lambda-block) around
Source

lambda-block.lisp (file)

Method: form (BASIC-BLOCK basic-block)
Generic Function: free-storage BUFFER BACKEND
Package

petalisp.native-backend

Source

execution.lisp (file)

Methods
Method: free-storage (BUFFER non-immediate-buffer) (BACKEND native-backend)
Method: free-storage (BUFFER buffer) (BACKEND native-backend)
Generic Function: immediate-dominator OBJECT
Package

petalisp.native-backend

Methods
Method: immediate-dominator (BASIC-BLOCK basic-block)

automatically generated reader method

Source

basic-block.lisp (file)

Generic Function: immediate-from-buffer BUFFER
Package

petalisp.ir-backend

Source

ir-conversion.lisp (file)

Methods
Method: immediate-from-buffer (BUFFER buffer)
Generic Function: increment-refcount ARRAY
Package

petalisp.core

Source

lazy-array.lisp (file)

Methods
Method: increment-refcount (NON-EMPTY-NON-IMMEDIATE non-empty-non-immediate)
Method: increment-refcount OBJECT
Generic Function: initial-basic-block OBJECT
Package

petalisp.native-backend

Methods
Method: initial-basic-block (TRANSLATION-UNIT translation-unit)

automatically generated reader method

Source

translation-unit.lisp (file)

Generic Function: input-mask OBJECT
Package

petalisp.core

Methods
Method: input-mask (HAIRY-TRANSFORMATION hairy-transformation)

automatically generated reader method

Source

hairy-transformation.lisp (file)

Generic Function: instruction-symbols FORM BASIC-BLOCK
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Methods
Method: instruction-symbols INSTRUCTION (BASIC-BLOCK basic-block)
Generic Function: instruction-values INSTRUCTION
Package

petalisp.ir-backend

Source

execution.lisp (file)

Methods
Method: instruction-values (INSTRUCTION instruction) around
Method: instruction-values (IREF-INSTRUCTION iref-instruction)
Method: instruction-values (REDUCE-INSTRUCTION reduce-instruction)
Method: instruction-values (STORE-INSTRUCTION store-instruction)
Method: instruction-values (LOAD-INSTRUCTION load-instruction)
Method: instruction-values (CALL-INSTRUCTION call-instruction)
Generic Function: instructions OBJECT
Generic Function: (setf instructions) NEW-VALUE OBJECT
Package

petalisp.native-backend

Methods
Method: instructions (BASIC-BLOCK basic-block)

automatically generated reader method

Source

basic-block.lisp (file)

Method: (setf instructions) NEW-VALUE (BASIC-BLOCK basic-block)

automatically generated writer method

Source

basic-block.lisp (file)

Generic Function: lambda-list OBJECT
Package

petalisp.native-backend

Methods
Method: lambda-list (LAMBDA-BLOCK lambda-block)

automatically generated reader method

Source

lambda-block.lisp (file)

Generic Function: loop-end OBJECT
Package

petalisp.native-backend

Methods
Method: loop-end (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: loop-size-bits OBJECT
Package

petalisp.native-backend

Methods
Method: loop-size-bits (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: loop-start OBJECT
Package

petalisp.native-backend

Methods
Method: loop-start (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: loop-step OBJECT
Package

petalisp.native-backend

Methods
Method: loop-step (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: loop-step-bits OBJECT
Package

petalisp.native-backend

Methods
Method: loop-step-bits (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: loop-var OBJECT
Package

petalisp.native-backend

Methods
Method: loop-var (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: loop-var-type OBJECT
Package

petalisp.native-backend

Methods
Method: loop-var-type (LOOP-BLOCK loop-block)

automatically generated reader method

Source

loop-block.lisp (file)

Generic Function: map-transformation-inputs FUNCTION TRANSFORMATION &key FROM-END
Package

petalisp.core

Source

transformation.lisp (file)

Methods
Method: map-transformation-inputs (FUNCTION function) (TRANSFORMATION transformation) &key FROM-END
Source

hairy-transformation.lisp (file)

Method: map-transformation-inputs (FUNCTION function) (TRANSFORMATION identity-transformation) &key FROM-END
Source

identity-transformation.lisp (file)

Generic Function: memory-pool OBJECT
Package

petalisp.native-backend

Methods
Method: memory-pool (NATIVE-BACKEND native-backend)

automatically generated reader method

Source

native-backend.lisp (file)

Generic Function: memory-pool-allocate MEMORY-POOL ARRAY-ELEMENT-TYPE ARRAY-DIMENSIONS
Package

petalisp.native-backend

Source

memory-pool.lisp (file)

Methods
Method: memory-pool-allocate (MEMORY-POOL memory-pool) ARRAY-ELEMENT-TYPE (ARRAY-DIMENSIONS list)
Generic Function: memory-pool-free MEMORY-POOL ARRAY
Package

petalisp.native-backend

Source

memory-pool.lisp (file)

Methods
Method: memory-pool-free (MEMORY-POOL memory-pool) (ARRAY array)
Generic Function: memory-pool-reset MEMORY-POOL
Package

petalisp.native-backend

Source

memory-pool.lisp (file)

Methods
Method: memory-pool-reset (MEMORY-POOL memory-pool)
Generic Function: offsets OBJECT
Package

petalisp.core

Methods
Method: offsets (HAIRY-TRANSFORMATION hairy-transformation)

automatically generated reader method

Source

hairy-transformation.lisp (file)

Generic Function: output-mask OBJECT
Package

petalisp.core

Methods
Method: output-mask (HAIRY-TRANSFORMATION hairy-transformation)

automatically generated reader method

Source

hairy-transformation.lisp (file)

Generic Function: range-difference-list RANGE-1 RANGE-2
Package

petalisp.core

Source

range.lisp (file)

Methods
Method: range-difference-list (RANGE-1 contiguous-range) (RANGE-2 range)
Method: range-difference-list (RANGE-1 range) (RANGE-2 size-one-range)
Method: range-difference-list (RANGE-1 size-one-range) (RANGE-2 size-one-range)
Method: range-difference-list (RANGE-1 range) (RANGE-2 range)
Generic Function: rotate-instruction-input INSTRUCTION TRANSFORMATION
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: rotate-instruction-input (ITERATING-INSTRUCTION iterating-instruction) (TRANSFORMATION transformation)
Method: rotate-instruction-input (INSTRUCTION instruction) (TRANSFORMATION transformation)
Generic Function: rotate-instruction-output INSTRUCTION TRANSFORMATION
Package

petalisp.ir

Source

ir.lisp (file)

Methods
Method: rotate-instruction-output (ITERATING-INSTRUCTION iterating-instruction) (TRANSFORMATION transformation)
Method: rotate-instruction-output (INSTRUCTION instruction) (TRANSFORMATION transformation)
Generic Function: scalings OBJECT
Package

petalisp.core

Methods
Method: scalings (HAIRY-TRANSFORMATION hairy-transformation)

automatically generated reader method

Source

hairy-transformation.lisp (file)

Generic Function: scheduler-queue OBJECT
Package

petalisp.core

Methods
Method: scheduler-queue (ASYNCHRONOUS-BACKEND asynchronous-backend)

automatically generated reader method

Source

backend.lisp (file)

Generic Function: scheduler-thread OBJECT
Generic Function: (setf scheduler-thread) NEW-VALUE OBJECT
Package

petalisp.core

Methods
Method: scheduler-thread (ASYNCHRONOUS-BACKEND asynchronous-backend)

automatically generated reader method

Source

backend.lisp (file)

Method: (setf scheduler-thread) NEW-VALUE (ASYNCHRONOUS-BACKEND asynchronous-backend)

automatically generated writer method

Source

backend.lisp (file)

Generic Function: set-element-table OBJECT
Package

petalisp.core

Methods
Method: set-element-table (EXPLICIT-SET explicit-set)

automatically generated reader method

Source

explicit-set.lisp (file)

Generic Function: shape-union SHAPES
Package

petalisp.core

Source

shape.lisp (file)

Methods
Method: shape-union (SHAPES cons) around
Method: shape-union (SHAPES cons)
Method: shape-union (SHAPES cons) before
Method: shape-union (NULL null)
Generic Function: successors OBJECT
Generic Function: (setf successors) NEW-VALUE OBJECT
Package

petalisp.native-backend

Methods
Method: successors (BASIC-BLOCK basic-block)

automatically generated reader method

Source

basic-block.lisp (file)

Method: (setf successors) NEW-VALUE (BASIC-BLOCK basic-block)

automatically generated writer method

Source

basic-block.lisp (file)

Generic Function: symbol-table OBJECT
Package

petalisp.native-backend

Methods
Method: symbol-table (TRANSLATION-UNIT translation-unit)

automatically generated reader method

Source

translation-unit.lisp (file)

Generic Function: table OBJECT
Package

petalisp.reference-backend

Methods
Method: table (SIMPLE-IMMEDIATE simple-immediate)

automatically generated reader method

Source

simple-immediate.lisp (file)

Generic Function: tail OBJECT
Generic Function: (setf tail) NEW-VALUE OBJECT
Package

petalisp.native-backend

Methods
Method: tail (TAIL-BLOCK tail-block)

automatically generated reader method

Source

tail-block.lisp (file)

Method: (setf tail) NEW-VALUE (TAIL-BLOCK tail-block)

automatically generated writer method

Source

tail-block.lisp (file)

Generic Function: tail-form BASIC-BLOCK
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Methods
Method: tail-form (TAIL-BLOCK tail-block)
Source

tail-block.lisp (file)

Method: tail-form (BASIC-BLOCK basic-block)
Generic Function: value-symbol VALUE-N FORM BASIC-BLOCK
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Methods
Method: value-symbol VALUE-N FORM (BASIC-BLOCK basic-block)
Generic Function: value-symbol-table OBJECT
Package

petalisp.native-backend

Methods
Method: value-symbol-table (BASIC-BLOCK basic-block)

automatically generated reader method

Source

basic-block.lisp (file)

Generic Function: visit-node NODE REDUCTION-AXIS
Package

petalisp.ir

Source

compute-buffer-table.lisp (file)

Methods
Method: visit-node (FUSION fusion) REDUCTION-AXIS
Method: visit-node (REFERENCE reference) REDUCTION-AXIS
Method: visit-node (IMMEDIATE immediate) REDUCTION-AXIS
Method: visit-node (REDUCTION reduction) REDUCTION-AXIS
Method: visit-node (NODE lazy-array) REDUCTION-AXIS
Generic Function: worker-pool OBJECT
Package

petalisp.native-backend

Methods
Method: worker-pool (NATIVE-BACKEND native-backend)

automatically generated reader method

Source

native-backend.lisp (file)


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

5.2.8 Classes

Class: any-set ()
Package

petalisp.core

Source

set.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Class: array-buffer ()
Package

petalisp.native-backend

Source

ir-conversion.lisp (file)

Direct superclasses

immediate-buffer (class)

Direct methods

storage (method)

Direct slots
Slot: %storage
Initargs

:storage

Readers

storage (generic function)

Class: basic-block ()
Package

petalisp.native-backend

Source

basic-block.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: %immediate-dominator
Initargs

:immediate-dominator

Readers

immediate-dominator (generic function)

Slot: %successors
Initargs

:successors

Readers

successors (generic function)

Writers

(setf successors) (generic function)

Slot: %instructions
Initargs

:instructions

Readers

instructions (generic function)

Writers

(setf instructions) (generic function)

Slot: %value-symbol-table
Initargs

:value-symbol-table

Readers

value-symbol-table (generic function)

Direct Default Initargs
InitargValue
:immediate-dominatornil
:successors(quote nil)
:instructions(quote nil)
:value-symbol-table(make-hash-table :test (function equal))
Class: buffer ()
Package

petalisp.ir-backend

Source

ir-conversion.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: %storage
Initargs

:storage

Readers

storage (generic function)

Class: buffer ()
Package

petalisp.native-backend

Source

ir-conversion.lisp (file)

Direct superclasses

buffer (class)

Direct subclasses
Direct methods

free-storage (method)

Class: cached-inverse-transformation-mixin ()
Package

petalisp.core

Source

invertible-transformation.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

hairy-invertible-transformation (class)

Direct methods
Direct slots
Slot: %cached-inverse
Readers

cached-inverse (generic function)

Writers

(setf cached-inverse) (generic function)

Class: contiguous-range ()
Package

petalisp.core

Source

range.lisp (file)

Direct superclasses

range (class)

Direct subclasses
Direct methods
Class: empty-set ()
Package

petalisp.core

Source

empty-set.lisp (file)

Direct superclasses

finite-set (class)

Direct methods
Class: explicit-set ()
Package

petalisp.core

Source

explicit-set.lisp (file)

Direct superclasses

finite-set (class)

Direct methods
Direct slots
Slot: %table
Initargs

:table

Readers

set-element-table (generic function)

Class: finite-set ()
Package

petalisp.core

Source

set.lisp (file)

Direct superclasses

any-set (class)

Direct subclasses
Direct methods
Class: hairy-invertible-transformation ()
Package

petalisp.core

Source

hairy-transformation.lisp (file)

Direct superclasses
Direct methods

invert-transformation (method)

Class: hairy-transformation ()
Package

petalisp.core

Source

hairy-transformation.lisp (file)

Direct superclasses

transformation (class)

Direct subclasses

hairy-invertible-transformation (class)

Direct methods
Direct slots
Slot: %input-rank
Initargs

:input-rank

Readers

input-rank (generic function)

Slot: %output-rank
Initargs

:output-rank

Readers

output-rank (generic function)

Slot: %input-mask
Type

simple-vector

Initargs

:input-mask

Readers

input-mask (generic function)

Slot: %output-mask
Type

simple-vector

Initargs

:output-mask

Readers

output-mask (generic function)

Slot: %offsets
Type

simple-vector

Initargs

:offsets

Readers

offsets (generic function)

Slot: %scalings
Type

simple-vector

Initargs

:scalings

Readers

scalings (generic function)

Class: immediate-buffer ()
Package

petalisp.native-backend

Source

ir-conversion.lisp (file)

Direct superclasses

buffer (class)

Direct subclasses

array-buffer (class)

Direct methods

compute-buffer (method)

Class: infinite-set ()
Package

petalisp.core

Source

set.lisp (file)

Direct superclasses

any-set (class)

Direct methods
Class: invertible-transformation ()
Package

petalisp.core

Source

invertible-transformation.lisp (file)

Direct superclasses

transformation (class)

Direct subclasses
Direct methods

invertible-transformation-p (method)

Class: ir-backend ()
Package

petalisp.ir-backend

Source

ir-backend.lisp (file)

Direct superclasses

backend (class)

Direct methods
Class: ir-node ()
Package

petalisp.ir-backend

Source

ir-conversion.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses