Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the petalisp Reference Manual, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Fri May 24 09:32:56 2019 GMT+0.
| • Introduction | What petalisp is all about | |
| • Systems | The systems documentation | |
| • Modules | The modules documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
#+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/petalisp-for-python][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.
To illustrate why Lisp is particularly well suited for a project like
Petalisp, consider the following implementation of a JIT-compiler for
mapping a function over a vector of a certain element type:
#+BEGIN_SRC lisp
(defun vector-mapper (element-type)
(compile nil `(lambda (fn vec)
(declare (function fn)
(type (simple-array ,element-type (*)) vec)
(optimize (speed 3) (safety 0)))
(loop for index below (length vec) do
(symbol-macrolet ((elt (aref vec index)))
(setf elt (funcall fn elt)))))))
#+END_SRC
Not only is this JIT-compiler just 8 lines of code, it is also 20 times
faster than invoking GCC or Clang on a roughly equivalent piece of C code.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
Next: The petalisp<dot>api system, Previous: Systems, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
Elegant High Performance Computing
petalisp.api (system)
petalisp.asd (file)
Next: The petalisp<dot>reference-backend system, Previous: The petalisp system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
A Convenient API for Petalisp.
petalisp.api.asd (file)
Next: The petalisp<dot>ir-backend system, Previous: The petalisp<dot>api system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.core (system)
Next: The petalisp<dot>native-backend system, Previous: The petalisp<dot>reference-backend system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.ir-backend.asd (file)
Next: The petalisp<dot>ir system, Previous: The petalisp<dot>ir-backend system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.native-backend.asd (file)
Next: The petalisp<dot>core system, Previous: The petalisp<dot>native-backend system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.ir.asd (file)
Next: The petalisp<dot>utilities system, Previous: The petalisp<dot>ir system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.core.asd (file)
Next: The petalisp<dot>type-codes system, Previous: The petalisp<dot>core system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.utilities.asd (file)
Previous: The petalisp<dot>utilities system, Up: Systems [Contents][Index]
Marco Heisig <marco.heisig@fau.de>
AGPLv3
petalisp.type-codes.asd (file)
Modules are listed depth-first from the system components tree.
| • The petalisp.type-codes/type-inference-rules module |
type-inference.lisp (file)
petalisp.type-codes (system)
type-codes/type-inference-rules/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The petalisp<dot>api<dot>asd file, Previous: Lisp files, Up: Lisp files [Contents][Index]
petalisp.asd
petalisp (system)
Next: The petalisp<dot>reference-backend<dot>asd file, Previous: The petalisp<dot>asd file, Up: Lisp files [Contents][Index]
api/petalisp.api.asd
petalisp.api (system)
Next: The petalisp<dot>ir-backend<dot>asd file, Previous: The petalisp<dot>api<dot>asd file, Up: Lisp files [Contents][Index]
reference-backend/petalisp.reference-backend.asd
petalisp.reference-backend (system)
Next: The petalisp<dot>native-backend<dot>asd file, Previous: The petalisp<dot>reference-backend<dot>asd file, Up: Lisp files [Contents][Index]
ir-backend/petalisp.ir-backend.asd
petalisp.ir-backend (system)
Next: The petalisp<dot>ir<dot>asd file, Previous: The petalisp<dot>ir-backend<dot>asd file, Up: Lisp files [Contents][Index]
native-backend/petalisp.native-backend.asd
petalisp.native-backend (system)
Next: The petalisp<dot>core<dot>asd file, Previous: The petalisp<dot>native-backend<dot>asd file, Up: Lisp files [Contents][Index]
ir/petalisp.ir.asd
petalisp.ir (system)
Next: The petalisp<dot>utilities<dot>asd file, Previous: The petalisp<dot>ir<dot>asd file, Up: Lisp files [Contents][Index]
core/petalisp.core.asd
petalisp.core (system)
Next: The petalisp<dot>type-codes<dot>asd file, Previous: The petalisp<dot>core<dot>asd file, Up: Lisp files [Contents][Index]
utilities/petalisp.utilities.asd
petalisp.utilities (system)
Next: The petalisp<dot>api/packages<dot>lisp file, Previous: The petalisp<dot>utilities<dot>asd file, Up: Lisp files [Contents][Index]
type-codes/petalisp.type-codes.asd
petalisp.type-codes (system)
Next: The petalisp<dot>api/api<dot>lisp file, Previous: The petalisp<dot>type-codes<dot>asd file, Up: Lisp files [Contents][Index]
petalisp.api (system)
api/packages.lisp
Next: The petalisp<dot>reference-backend/packages<dot>lisp file, Previous: The petalisp<dot>api/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.api (system)
api/api.lisp
Next: The petalisp<dot>reference-backend/simple-immediate<dot>lisp file, Previous: The petalisp<dot>api/api<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.reference-backend (system)
reference-backend/packages.lisp
Next: The petalisp<dot>reference-backend/reference-backend<dot>lisp file, Previous: The petalisp<dot>reference-backend/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.reference-backend (system)
reference-backend/simple-immediate.lisp
Next: The petalisp<dot>ir-backend/packages<dot>lisp file, Previous: The petalisp<dot>reference-backend/simple-immediate<dot>lisp file, Up: Lisp files [Contents][Index]
simple-immediate.lisp (file)
petalisp.reference-backend (system)
reference-backend/reference-backend.lisp
Next: The petalisp<dot>ir-backend/ir-backend<dot>lisp file, Previous: The petalisp<dot>reference-backend/reference-backend<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.ir-backend (system)
ir-backend/packages.lisp
Next: The petalisp<dot>native-backend/packages<dot>lisp file, Previous: The petalisp<dot>ir-backend/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.ir-backend (system)
ir-backend/ir-backend.lisp
Next: The petalisp<dot>native-backend/utilities<dot>lisp file, Previous: The petalisp<dot>ir-backend/ir-backend<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.native-backend (system)
native-backend/packages.lisp
Next: The petalisp<dot>native-backend/basic-block<dot>lisp file, Previous: The petalisp<dot>native-backend/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.native-backend (system)
native-backend/utilities.lisp
Next: The petalisp<dot>native-backend/lambda-block<dot>lisp file, Previous: The petalisp<dot>native-backend/utilities<dot>lisp file, Up: Lisp files [Contents][Index]
utilities.lisp (file)
petalisp.native-backend (system)
native-backend/basic-block.lisp
Next: The petalisp<dot>native-backend/loop-block<dot>lisp file, Previous: The petalisp<dot>native-backend/basic-block<dot>lisp file, Up: Lisp files [Contents][Index]
basic-block.lisp (file)
petalisp.native-backend (system)
native-backend/lambda-block.lisp
Next: The petalisp<dot>native-backend/tail-block<dot>lisp file, Previous: The petalisp<dot>native-backend/lambda-block<dot>lisp file, Up: Lisp files [Contents][Index]
lambda-block.lisp (file)
petalisp.native-backend (system)
native-backend/loop-block.lisp
Next: The petalisp<dot>native-backend/translation-unit<dot>lisp file, Previous: The petalisp<dot>native-backend/loop-block<dot>lisp file, Up: Lisp files [Contents][Index]
loop-block.lisp (file)
petalisp.native-backend (system)
native-backend/tail-block.lisp
Next: The petalisp<dot>native-backend/blueprint-compiler<dot>lisp file, Previous: The petalisp<dot>native-backend/tail-block<dot>lisp file, Up: Lisp files [Contents][Index]
tail-block.lisp (file)
petalisp.native-backend (system)
native-backend/translation-unit.lisp
Next: The petalisp<dot>native-backend/memory-pool<dot>lisp file, Previous: The petalisp<dot>native-backend/translation-unit<dot>lisp file, Up: Lisp files [Contents][Index]
translation-unit.lisp (file)
petalisp.native-backend (system)
native-backend/blueprint-compiler.lisp
instruction (function)
Next: The petalisp<dot>native-backend/native-backend<dot>lisp file, Previous: The petalisp<dot>native-backend/blueprint-compiler<dot>lisp file, Up: Lisp files [Contents][Index]
blueprint-compiler.lisp (file)
petalisp.native-backend (system)
native-backend/memory-pool.lisp
Next: The petalisp<dot>native-backend/execution<dot>lisp file, Previous: The petalisp<dot>native-backend/memory-pool<dot>lisp file, Up: Lisp files [Contents][Index]
memory-pool.lisp (file)
petalisp.native-backend (system)
native-backend/native-backend.lisp
make-native-backend (function)
Next: The petalisp<dot>ir/packages<dot>lisp file, Previous: The petalisp<dot>native-backend/native-backend<dot>lisp file, Up: Lisp files [Contents][Index]
native-backend.lisp (file)
petalisp.native-backend (system)
native-backend/execution.lisp
Next: The petalisp<dot>ir/ir<dot>lisp file, Previous: The petalisp<dot>native-backend/execution<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.ir (system)
ir/packages.lisp
Next: The petalisp<dot>ir/compute-buffer-table<dot>lisp file, Previous: The petalisp<dot>ir/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.ir (system)
ir/ir.lisp
Next: The petalisp<dot>ir/compute-iteration-spaces<dot>lisp file, Previous: The petalisp<dot>ir/ir<dot>lisp file, Up: Lisp files [Contents][Index]
ir.lisp (file)
petalisp.ir (system)
ir/compute-buffer-table.lisp
Next: The petalisp<dot>ir/ir-conversion<dot>lisp file, Previous: The petalisp<dot>ir/compute-buffer-table<dot>lisp file, Up: Lisp files [Contents][Index]
compute-buffer-table.lisp (file)
petalisp.ir (system)
ir/compute-iteration-spaces.lisp
Next: The petalisp<dot>ir/blueprint<dot>lisp file, Previous: The petalisp<dot>ir/compute-iteration-spaces<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.ir (system)
ir/ir-conversion.lisp
ir-from-lazy-arrays (function)
Next: The petalisp<dot>ir/documentation<dot>lisp file, Previous: The petalisp<dot>ir/ir-conversion<dot>lisp file, Up: Lisp files [Contents][Index]
ir-conversion.lisp (file)
petalisp.ir (system)
ir/blueprint.lisp
Next: The petalisp<dot>core/packages<dot>lisp file, Previous: The petalisp<dot>ir/blueprint<dot>lisp file, Up: Lisp files [Contents][Index]
blueprint.lisp (file)
petalisp.ir (system)
ir/documentation.lisp
Next: The petalisp<dot>core/set<dot>lisp file, Previous: The petalisp<dot>ir/documentation<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.core (system)
core/packages.lisp
Next: The petalisp<dot>core/empty-set<dot>lisp file, Previous: The petalisp<dot>core/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.core (system)
core/set.lisp
Next: The petalisp<dot>core/explicit-set<dot>lisp file, Previous: The petalisp<dot>core/set<dot>lisp file, Up: Lisp files [Contents][Index]
set.lisp (file)
petalisp.core (system)
core/empty-set.lisp
Next: The petalisp<dot>core/range<dot>lisp file, Previous: The petalisp<dot>core/empty-set<dot>lisp file, Up: Lisp files [Contents][Index]
empty-set.lisp (file)
petalisp.core (system)
core/explicit-set.lisp
Next: The petalisp<dot>core/shape<dot>lisp file, Previous: The petalisp<dot>core/explicit-set<dot>lisp file, Up: Lisp files [Contents][Index]
explicit-set.lisp (file)
petalisp.core (system)
core/range.lisp
Next: The petalisp<dot>core/transformation<dot>lisp file, Previous: The petalisp<dot>core/range<dot>lisp file, Up: Lisp files [Contents][Index]
range.lisp (file)
petalisp.core (system)
core/shape.lisp
Next: The petalisp<dot>core/identity-transformation<dot>lisp file, Previous: The petalisp<dot>core/shape<dot>lisp file, Up: Lisp files [Contents][Index]
shape.lisp (file)
petalisp.core (system)
core/transformation.lisp
map-transformation-inputs (generic function)
Next: The petalisp<dot>core/invertible-transformation<dot>lisp file, Previous: The petalisp<dot>core/transformation<dot>lisp file, Up: Lisp files [Contents][Index]
transformation.lisp (file)
petalisp.core (system)
core/identity-transformation.lisp
map-transformation-inputs (method)
Next: The petalisp<dot>core/hairy-transformation<dot>lisp file, Previous: The petalisp<dot>core/identity-transformation<dot>lisp file, Up: Lisp files [Contents][Index]
identity-transformation.lisp (file)
petalisp.core (system)
core/invertible-transformation.lisp
Next: The petalisp<dot>core/transformation-constructors<dot>lisp file, Previous: The petalisp<dot>core/invertible-transformation<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.core (system)
core/hairy-transformation.lisp
Next: The petalisp<dot>core/shape-transformations<dot>lisp file, Previous: The petalisp<dot>core/hairy-transformation<dot>lisp file, Up: Lisp files [Contents][Index]
hairy-transformation.lisp (file)
petalisp.core (system)
core/transformation-constructors.lisp
Next: The petalisp<dot>core/lazy-array<dot>lisp file, Previous: The petalisp<dot>core/transformation-constructors<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.core (system)
core/shape-transformations.lisp
from-storage-transformation (function)
Next: The petalisp<dot>core/broadcasting<dot>lisp file, Previous: The petalisp<dot>core/shape-transformations<dot>lisp file, Up: Lisp files [Contents][Index]
shape-transformations.lisp (file)
petalisp.core (system)
core/lazy-array.lisp
Next: The petalisp<dot>core/lazy-array-constructors<dot>lisp file, Previous: The petalisp<dot>core/lazy-array<dot>lisp file, Up: Lisp files [Contents][Index]
lazy-array.lisp (file)
petalisp.core (system)
core/broadcasting.lisp
Next: The petalisp<dot>core/backend<dot>lisp file, Previous: The petalisp<dot>core/broadcasting<dot>lisp file, Up: Lisp files [Contents][Index]
broadcasting.lisp (file)
petalisp.core (system)
core/lazy-array-constructors.lisp
Next: The petalisp<dot>core/documentation<dot>lisp file, Previous: The petalisp<dot>core/lazy-array-constructors<dot>lisp file, Up: Lisp files [Contents][Index]
lazy-array-constructors.lisp (file)
petalisp.core (system)
core/backend.lisp
Next: The petalisp<dot>utilities/packages<dot>lisp file, Previous: The petalisp<dot>core/backend<dot>lisp file, Up: Lisp files [Contents][Index]
backend.lisp (file)
petalisp.core (system)
core/documentation.lisp
Next: The petalisp<dot>utilities/documentation<dot>lisp file, Previous: The petalisp<dot>core/documentation<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.utilities (system)
utilities/packages.lisp
Next: The petalisp<dot>utilities/identical<dot>lisp file, Previous: The petalisp<dot>utilities/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.utilities (system)
utilities/documentation.lisp
Next: The petalisp<dot>utilities/memoization<dot>lisp file, Previous: The petalisp<dot>utilities/documentation<dot>lisp file, Up: Lisp files [Contents][Index]
documentation.lisp (file)
petalisp.utilities (system)
utilities/identical.lisp
identical (function)
Next: The petalisp<dot>utilities/extended-euclid<dot>lisp file, Previous: The petalisp<dot>utilities/identical<dot>lisp file, Up: Lisp files [Contents][Index]
identical.lisp (file)
petalisp.utilities (system)
utilities/memoization.lisp
+empty+ (constant)
Next: The petalisp<dot>utilities/define-method-pair<dot>lisp file, Previous: The petalisp<dot>utilities/memoization<dot>lisp file, Up: Lisp files [Contents][Index]
memoization.lisp (file)
petalisp.utilities (system)
utilities/extended-euclid.lisp
extended-euclid (function)
Next: The petalisp<dot>utilities/define-class-predicate<dot>lisp file, Previous: The petalisp<dot>utilities/extended-euclid<dot>lisp file, Up: Lisp files [Contents][Index]
extended-euclid.lisp (file)
petalisp.utilities (system)
utilities/define-method-pair.lisp
define-method-pair (macro)
parse-defmethod (function)
Next: The petalisp<dot>utilities/defalias<dot>lisp file, Previous: The petalisp<dot>utilities/define-method-pair<dot>lisp file, Up: Lisp files [Contents][Index]
define-method-pair.lisp (file)
petalisp.utilities (system)
utilities/define-class-predicate.lisp
define-class-predicate (macro)
Next: The petalisp<dot>utilities/float-bits<dot>lisp file, Previous: The petalisp<dot>utilities/define-class-predicate<dot>lisp file, Up: Lisp files [Contents][Index]
define-class-predicate.lisp (file)
petalisp.utilities (system)
utilities/defalias.lisp
defalias (macro)
Next: The petalisp<dot>type-codes/packages<dot>lisp file, Previous: The petalisp<dot>utilities/defalias<dot>lisp file, Up: Lisp files [Contents][Index]
defalias.lisp (file)
petalisp.utilities (system)
utilities/float-bits.lisp
Next: The petalisp<dot>type-codes/type-codes<dot>lisp file, Previous: The petalisp<dot>utilities/float-bits<dot>lisp file, Up: Lisp files [Contents][Index]
petalisp.type-codes (system)
type-codes/packages.lisp
Next: The petalisp<dot>type-codes/type-code-utilities<dot>lisp file, Previous: The petalisp<dot>type-codes/packages<dot>lisp file, Up: Lisp files [Contents][Index]
packages.lisp (file)
petalisp.type-codes (system)
type-codes/type-codes.lisp
+types+ (constant)
Next: The petalisp<dot>type-codes/function-lambda-lists<dot>lisp file, Previous: The petalisp<dot>type-codes/type-codes<dot>lisp file, Up: Lisp files [Contents][Index]
type-codes.lisp (file)
petalisp.type-codes (system)
type-codes/type-code-utilities.lisp
Next: The petalisp<dot>type-codes/type-inference<dot>lisp file, Previous: The petalisp<dot>type-codes/type-code-utilities<dot>lisp file, Up: Lisp files [Contents][Index]
type-code-utilities.lisp (file)
petalisp.type-codes (system)
type-codes/function-lambda-lists.lisp
Next: The petalisp<dot>type-codes/type-inference-rules/characters<dot>lisp file, Previous: The petalisp<dot>type-codes/function-lambda-lists<dot>lisp file, Up: Lisp files [Contents][Index]
function-lambda-lists.lisp (file)
petalisp.type-codes (system)
type-codes/type-inference.lisp
Next: The petalisp<dot>type-codes/type-inference-rules/data-and-control-flow<dot>lisp file, Previous: The petalisp<dot>type-codes/type-inference<dot>lisp file, Up: Lisp files [Contents][Index]
type-inference-rules (module)
type-codes/type-inference-rules/characters.lisp
Next: The petalisp<dot>type-codes/type-inference-rules/numbers<dot>lisp file, Previous: The petalisp<dot>type-codes/type-inference-rules/characters<dot>lisp file, Up: Lisp files [Contents][Index]
type-inference-rules (module)
type-codes/type-inference-rules/data-and-control-flow.lisp
Next: The petalisp<dot>type-codes/type-inference-rules/objects<dot>lisp file, Previous: The petalisp<dot>type-codes/type-inference-rules/data-and-control-flow<dot>lisp file, Up: Lisp files [Contents][Index]
type-inference-rules (module)
type-codes/type-inference-rules/numbers.lisp
Next: The petalisp<dot>type-codes/type-inference-rules/symbols<dot>lisp file, Previous: The petalisp<dot>type-codes/type-inference-rules/numbers<dot>lisp file, Up: Lisp files [Contents][Index]
type-inference-rules (module)
type-codes/type-inference-rules/objects.lisp
Previous: The petalisp<dot>type-codes/type-inference-rules/objects<dot>lisp file, Up: Lisp files [Contents][Index]
type-inference-rules (module)
type-codes/type-inference-rules/symbols.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
Next: The petalisp<dot>reference-backend package, Previous: Packages, Up: Packages [Contents][Index]
packages.lisp (file)
petalisp
Next: The petalisp<dot>ir-backend package, Previous: The petalisp<dot>api package, Up: Packages [Contents][Index]
packages.lisp (file)
make-reference-backend (function)
Next: The petalisp<dot>native-backend package, Previous: The petalisp<dot>reference-backend package, Up: Packages [Contents][Index]
packages.lisp (file)
make-ir-backend (function)
Next: The petalisp<dot>ir package, Previous: The petalisp<dot>ir-backend package, Up: Packages [Contents][Index]
packages.lisp (file)
make-native-backend (function)
Next: The petalisp<dot>core package, Previous: The petalisp<dot>native-backend package, Up: Packages [Contents][Index]
packages.lisp (file)
Next: The petalisp<dot>utilities package, Previous: The petalisp<dot>ir package, Up: Packages [Contents][Index]
packages.lisp (file)
Next: The petalisp<dot>type-codes package, Previous: The petalisp<dot>core package, Up: Packages [Contents][Index]
packages.lisp (file)
Previous: The petalisp<dot>utilities package, Up: Packages [Contents][Index]
packages.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
Next: Exported special variables, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
type-codes.lisp (file)
shape.lisp (file)
Next: Exported macros, Previous: Exported constants, Up: Exported definitions [Contents][Index]
api.lisp (file)
Next: Exported compiler macros, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
defalias.lisp (file)
define-class-predicate.lisp (file)
define-method-pair.lisp (file)
api.lisp (file)
Define an inference rule for the function named NAME that is a predicate that returns - as a generalized boolean - whether its argument is of TYPE.
Examples:
(define-predicate-type-inference-rule numberp number)
(define-predicate-type-inference-rule random-state-p random-state)
type-inference.lisp (file)
Define a type inference rule for the function with the supplied NAME.
The supplied LAMBDA-LIST must accept as many arguments as the corresponding
function, while consisting only of mandatory, optional and rest arguments.
During type inference, each statement in BODY will be evaluated in an
environment where each lambda list argument is bound to a type code. It
should return zero or more type codes, describing what values the function
will return if called with arguments of the prescribed types.
If a type inference function can determine that the call can never be
successful, it should call ABORT-TYPE-INFERENCE. If a type inference
function can determine that it won’t be able to derive any useful type
information, it should call GIVE-UP-TYPE-INFERENCE. Each type inference
rule will automatically abort when the number of supplied argument type
codes does not match LAMBDA-LIST.
Examples:
(define-type-inference-rule cl:identity (type-code)
type-code)
(define-type-inference-rule cl:values (&rest type-codes)
(values-list type-codes))
(define-type-inference-rule cl:values-list (type-code)
(give-up-type-inference))
(define-type-inference-rule cl:constantly (type-code)
(type-code-from-type-specifier ’function))
(define-type-inference-rule float-sign (type-code-1 &optional (type-code-2 type-code-1))
(check-type-code type-code-1 float)
(check-type-code type-code-2 float)
type-code-2)
type-inference.lisp (file)
type-code-utilities.lisp (file)
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.
memoization.lisp (file)
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.
memoization.lisp (file)
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.
memoization.lisp (file)
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.
memoization.lisp (file)
Memoize the values of BODY for VAR being a relatively small integer.
memoization.lisp (file)
type-code-utilities.lisp (file)
type-inference.lisp (file)
Memoize the value of BODY for KEY being a relatively small integer.
memoization.lisp (file)
Next: Exported functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
range.lisp (file)
type-codes.lisp (file)
type-codes.lisp (file)
shape.lisp (file)
Next: Exported generic functions, Previous: Exported compiler macros, Up: Exported definitions [Contents][Index]
Returns one or more lazy arrays whose contents are the values returned
by the supplied function, when applied element-wise to the contents of the
supplied arrays. If the supplied arrays don’t agree in shape, they are
first broadcast with the function BROADCAST-ARRAYS.
Examples:
(compute (α #’+ 2 3))
=> 5
(compute (α #’+ 2 #(1 2 3 4 5)))
=> #(3 4 5 6 7)
(compute (α #’* #(2 3) #2a((1 2) (3 4))))
=> #2A((2 4) (9 12))
(compute (α #’floor 7.5))
=> 1
(compute (α #’floor 7.5 #(1 2 3 4 5)))
=> #(7 3 2 1 1)
(multiple-value-bind (quot rem)
(α #’floor 7.5 #(1 2 3 4 5))
(compute quot rem))
=> #(7 3 2 1 1)
=> #(0.5 1.5 1.5 3.5 2.5)
lazy-array-constructors.lisp (file)
type-inference.lisp (file)
type-code-utilities.lisp (file)
ir.lisp (file)
Returns one or more lazy arrays whose contents are the multiple value
reduction with the supplied function, when applied pairwise to the elements
of the first axis of each of the supplied arrays. If the supplied arrays
don’t agree in shape, they are first broadcast with the function
BROADCAST-ARRAYS.
The supplied function F must accept 2k arguments and return k values, where
k is the number of supplied arrays. All supplied arrays must have the same
shape S, which is the cartesian product of some ranges, i.e., S = r_1 x
... r_n, where each range r_k is a set of integers, e.g., {0, 1, ..., m}.
Then β returns k arrays of shape s = r_2 x ... x r_n, whose elements are a
combination of the elements along the first axis of each array according to
the following rules:
1. If the given arrays are empty, return k empty arrays.
2. If the first axis of each given array contains exactly one element, drop that axis and return arrays with the same content, but with shape s.
3. If the first axis of each given array contains more than one element,
partition the indices of this axis into a lower half l and an upper half
u. Then split each given array into a part with shape l x s and a part
with shape u x s. Recursively process the lower and the upper halves of
each array independently to obtain 2k new arrays of shape s. Finally,
combine these 2k arrays element-wise with f to obtain k new arrays with
all values returned by f. Return these arrays.
Examples:
(compute (β #’+ #(1 2 3 4)))
=> 10
(compute (β #’+ #2a((1 2) (3 4))))
=> #(4 6)
(let ((a #(5 2 7 1 9)))
(multiple-value-bind (max index)
(β (lambda (lv li rv ri)
(if (> lv rv)
(values lv li)
(values rv ri)))
a (indices a 0))
(compute max index)))
=> 9
=> 4
lazy-array-constructors.lisp (file)
Returns as many lazy arrays as there are supplied arrays, but broadcast such that all resulting arrays have the same shape. If there is no suitable broadcast shape for all supplied arrays, an error is signaled.
Examples:
(broadcast-arrays #(1 2 3) 5)
=> #<array-immediate #(1 2 3)>
=> #<reference (unsigned-byte 4) (~ 0 2)>
(broadcast-arrays #(2 3 4) #2a((1 2 3) (4 5 6)))
=> #<reference t (~ 0 1 ~ 0 2)>
=> #<array-immediate #2A((1 2 3) (4 5 6))>
broadcasting.lisp (file)
Returns a list of lazy arrays of the same length as the list of supplied
arrays, but where each element is broadcast such that all resulting arrays
have the same shape. If there is no suitable broadcast shape for all
supplied arrays, an error is signaled.
Examples:
(petalisp.core::broadcast-list-of-arrays (list #(1 2 3) 5))
=> (#<array-immediate #(1 2 3)> #<reference (unsigned-byte 4) (~ 0 2)>)
(broadcast-list-of-arrays (list #(2 3 4) #2a((1 2 3) (4 5 6))))
=> (#<reference t (~ 0 1 ~ 0 2)> #<array-immediate #2A((1 2 3) (4 5 6))>)
broadcasting.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
shape-transformations.lisp (file)
Return the computed values of all ARGUMENTS.
backend.lisp (file)
lazy-array-constructors.lisp (file)
type-code-utilities.lisp (file)
Given nonnegative integers u and v, return the values u1 and u3 such that u*u1 + v*u2 = u3 = gcd(u,v).
extended-euclid.lisp (file)
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.
Examples:
(compute (fuse (reshape 1 (~ 0 1))
(reshape 0 (~ 2 3))))
=> #*1100
(compute (fuse (reshape 1 (~ 0 2 6))
(reshape 0 (~ 1 2 6))))
=> #*1010101
lazy-array-constructors.lisp (file)
Combine ARRAYS into a single strided array. When some of the supplied arguments overlap partially, the value of the rightmost object is used.
Examples:
(compute (fuse* (reshape 1 (~ 0 3))
(reshape 0 (~ 2 3))))
=> #*1100
lazy-array-constructors.lisp (file)
type-inference.lisp (file)
ir.lisp (file)
Check whether the KEYs of SEQUENCE are identical with respect to TEST.
identical.lisp (file)
identity-transformation.lisp (file)
Returns a lazy array of integers of the shape indicated by the first
argument ARRAY-OR-SHAPE , where each array element at index (i_0 ... i_N)
has the value i_AXIS. If AXIS is not supplied, it defaults to zero.
Examples:
(compute (indices #2a((1 2) (3 4))))
=> #2a((0 0) (1 1))
(compute (indices #2a((1 2) (3 4)) 1))
=> #2a((0 1) (0 1))
(compute (indices (reshape #2a((1 2) (3 4)) (τ (i j) (i (1+ j)))) 1))
=> #2a((1 2) (1 2))
(compute (indices "abc"))
=> #(0 1 2)
lazy-array-constructors.lisp (file)
lazy-array.lisp (file)
blueprint-compiler.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
Returns a list of buffers that form the root of an IR data flow graph
that is equivalent to the data flow graph specified by the supplied
LAZY-ARRAYS.
An IR graph is consists of alternating buffers and kernels. Each kernel reads and writes from zero or more buffers and writes to zero and more buffers. The behavior or each kernel is described by a directed acyclic graph of instructions.
ir-conversion.lisp (file)
ir.lisp (file)
ir.lisp (file)
blueprint.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
lazy-array-constructors.lisp (file)
ir.lisp (file)
explicit-set.lisp (file)
ir-backend.lisp (file)
ir.lisp (file)
native-backend.lisp (file)
range.lisp (file)
lazy-array-constructors.lisp (file)
reference-backend.lisp (file)
shape.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
range.lisp (file)
Modify the IR data flow graph specified by the supplied ROOT-BUFFERS
such that it has fewer degrees of freedom. This is achieved by
transforming all buffers to a zero-based coordinate system with minimal
stride, and by arranging each buffer such that the kernels using it have
optimal spatial locality.
In any case, the IR normalization preserves semantics.
ir.lisp (file)
blueprint.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
Return a data structure of given SHAPE, either by selecting a subset of
the elements of DATA, or by broadcasting them.
Examples:
(compute (reshape 4 (~ 0 4)))
=> #(4 4 4 4 4)
(compute (reshape 0 (~ 0 1 ~ 0 1)))
=> #2A((0 0) (0 0))
(compute (reshape #(1 2 3 4) (~ 1 2)))
=> #(2 3)
lazy-array-constructors.lisp (file)
Instruct Petalisp to compute all given ARGUMENTS asynchronously.
backend.lisp (file)
range.lisp (file)
range.lisp (file)
ir.lisp (file)
ir.lisp (file)
type-codes.lisp (file)
type-codes.lisp (file)
type-code-utilities.lisp (file)
type-codes.lisp (file)
Returns one or more type codes that describe what values will be
returned by FUNCTION when called with arguments that match the supplied
ARGUMENT-TYPE-CODES.
Returns a single value that is the empty type code, if and only if it can be determined that FUNCTION will never return for the specified argument types.
type-inference.lisp (file)
shape.lisp (file)
Returns one or more lazy arrays whose contents are the values returned
by the supplied function, when applied element-wise to the contents of the
supplied arrays. If the supplied arrays don’t agree in shape, they are
first broadcast with the function BROADCAST-ARRAYS.
Examples:
(compute (α #’+ 2 3))
=> 5
(compute (α #’+ 2 #(1 2 3 4 5)))
=> #(3 4 5 6 7)
(compute (α #’* #(2 3) #2a((1 2) (3 4))))
=> #2A((2 4) (9 12))
(compute (α #’floor 7.5))
=> 1
(compute (α #’floor 7.5 #(1 2 3 4 5)))
=> #(7 3 2 1 1)
(multiple-value-bind (quot rem)
(α #’floor 7.5 #(1 2 3 4 5))
(compute quot rem))
=> #(7 3 2 1 1)
=> #(0.5 1.5 1.5 3.5 2.5)
lazy-array-constructors.lisp (file)
Returns one or more lazy arrays whose contents are the multiple value
reduction with the supplied function, when applied pairwise to the elements
of the first axis of each of the supplied arrays. If the supplied arrays
don’t agree in shape, they are first broadcast with the function
BROADCAST-ARRAYS.
The supplied function F must accept 2k arguments and return k values, where
k is the number of supplied arrays. All supplied arrays must have the same
shape S, which is the cartesian product of some ranges, i.e., S = r_1 x
... r_n, where each range r_k is a set of integers, e.g., {0, 1, ..., m}.
Then β returns k arrays of shape s = r_2 x ... x r_n, whose elements are a
combination of the elements along the first axis of each array according to
the following rules:
1. If the given arrays are empty, return k empty arrays.
2. If the first axis of each given array contains exactly one element, drop that axis and return arrays with the same content, but with shape s.
3. If the first axis of each given array contains more than one element,
partition the indices of this axis into a lower half l and an upper half
u. Then split each given array into a part with shape l x s and a part
with shape u x s. Recursively process the lower and the upper halves of
each array independently to obtain 2k new arrays of shape s. Finally,
combine these 2k arrays element-wise with f to obtain k new arrays with
all values returned by f. Return these arrays.
Examples:
(compute (β #’+ #(1 2 3 4)))
=> 10
(compute (β #’+ #2a((1 2) (3 4))))
=> #(4 6)
(let ((a #(5 2 7 1 9)))
(multiple-value-bind (max index)
(β (lambda (lv li rv ri)
(if (> lv rv)
(values lv li)
(values rv ri)))
a (indices a 0))
(compute max index)))
=> 9
=> 4
lazy-array-constructors.lisp (file)
Next: Exported structures, Previous: Exported functions, Up: Exported definitions [Contents][Index]
lazy-array.lisp (file)
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
identity-transformation.lisp (file)
backend.lisp (file)
execution.lisp (file)
execution.lisp (file)
ir-backend.lisp (file)
reference-backend.lisp (file)
reference-backend.lisp (file)
backend.lisp (file)
backend.lisp (file)
lazy-array.lisp (file)
lazy-array.lisp (file)
shape.lisp (file)
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
identity-transformation.lisp (file)
identity-transformation.lisp (file)
lazy-array.lisp (file)
transformation.lisp (file)
automatically generated reader method
hairy-transformation.lisp (file)
automatically generated reader method
identity-transformation.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
lazy-array.lisp (file)
backend.lisp (file)
simple-immediate.lisp (file)
lazy-array-constructors.lisp (file)
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
automatically generated reader method
transformation.lisp (file)
automatically generated reader method
hairy-transformation.lisp (file)
automatically generated reader method
identity-transformation.lisp (file)
backend.lisp (file)
simple-immediate.lisp (file)
shape.lisp (file)
automatically generated reader method
shape.lisp (file)
lazy-array.lisp (file)
lazy-array.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
lazy-array.lisp (file)
(setf refcount) (generic function)
automatically generated reader method
refcount (generic function)
automatically generated writer method
lazy-array.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
backend.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
set.lisp (file)
set.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
empty-set.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
shape.lisp (file)
shape.lisp (file)
shape.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
lazy-array.lisp (file)
transformation.lisp (file)
lazy-array.lisp (file)
shape-transformations.lisp (file)
shape-transformations.lisp (file)
shape-transformations.lisp (file)
shape-transformations.lisp (file)
hairy-transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
automatically generated reader method
lazy-array.lisp (file)
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
transformation.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
lazy-array.lisp (file)
automatically generated reader method
automatically generated reader method
Next: Exported classes, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
ir.lisp (file)
structure-object (structure)
petalisp.core:shape
buffer-shape (function)
(setf buffer-shape) (function)
petalisp.type-codes:type-code
buffer-type-code (function)
(setf buffer-type-code) (function)
list
(quote nil)
buffer-inputs (function)
(setf buffer-inputs) (function)
list
(quote nil)
buffer-outputs (function)
(setf buffer-outputs) (function)
boolean
buffer-executedp (function)
(setf buffer-executedp) (function)
boolean
buffer-reusablep (function)
(setf buffer-reusablep) (function)
buffer-storage (function)
(setf buffer-storage) (function)
ir.lisp (file)
instruction (structure)
(or function symbol)
call-instruction-operator (function)
(setf call-instruction-operator) (function)
ir.lisp (file)
structure-object (structure)
instruction-values (method)
fixnum
0
instruction-number (function)
(setf instruction-number) (function)
list
(quote nil)
instruction-inputs (function)
(setf instruction-inputs) (function)
ir.lisp (file)
iterating-instruction (structure)
ir.lisp (file)
instruction (structure)
petalisp.core:transformation
instruction-transformation (function)
(setf instruction-transformation) (function)
ir.lisp (file)
structure-object (structure)
petalisp.core:shape
kernel-iteration-space (function)
(setf kernel-iteration-space) (function)
(or petalisp.core:range null)
kernel-reduction-range (function)
(setf kernel-reduction-range) (function)
list
kernel-load-instructions (function)
(setf kernel-load-instructions) (function)
list
kernel-store-instructions (function)
(setf kernel-store-instructions) (function)
boolean
kernel-executedp (function)
(setf kernel-executedp) (function)
ir.lisp (file)
iterating-instruction (structure)
petalisp.ir:buffer
load-instruction-buffer (function)
(setf load-instruction-buffer) (function)
range.lisp (file)
structure-object (structure)
integer
0
range-start (function)
(setf range-start) (function)
(integer 1 *)
1
range-step (function)
(setf range-step) (function)
(integer 1 *)
1
range-size (function)
(setf range-size) (function)
ir.lisp (file)
instruction (structure)
function
reduce-instruction-operator (function)
(setf reduce-instruction-operator) (function)
ir.lisp (file)
iterating-instruction (structure)
petalisp.ir:buffer
store-instruction-buffer (function)
(setf store-instruction-buffer) (function)
Next: Exported types, Previous: Exported structures, Up: Exported definitions [Contents][Index]
lazy-array.lisp (file)
non-empty-non-immediate (class)
:operator
operator (generic function)
(integer 0 4611686018427387903)
:value-n
value-n (generic function)
lazy-array.lisp (file)
non-empty-immediate (class)
:reusablep
reusablep (generic function)
:storage
storage (generic function)
backend.lisp (file)
backend (class)
native-backend (class)
(lparallel.queue:make-queue)
scheduler-queue (generic function)
scheduler-thread (generic function)
(setf scheduler-thread) (generic function)
backend.lisp (file)
standard-object (class)
lazy-array.lisp (file)
immediate (class)
lazy-array.lisp (file)
non-empty-non-immediate (class)
identity-transformation.lisp (file)
invertible-transformation (class)
(integer 0 *)
:rank
lazy-array.lisp (file)
lazy-array (class)
lazy-array.lisp (file)
standard-object (class)
lazy-array.lisp (file)
lazy-array (class)
petalisp.type-codes:type-code
:type-code
type-code (generic function)
lazy-array.lisp (file)
lazy-array.lisp (file)
0
refcount (generic function)
(setf refcount) (generic function)
lazy-array.lisp (file)
lazy-array (class)
non-empty-non-immediate (class)
:inputs
inputs (generic function)
lazy-array.lisp (file)
non-empty-immediate (class)
lazy-array.lisp (file)
non-empty-non-immediate (class)
:operator
operator (generic function)
(integer 0 4611686018427387903)
:value-n
value-n (generic function)
lazy-array.lisp (file)
non-empty-non-immediate (class)
:transformation
transformation (generic function)
shape.lisp (file)
finite-set (class)
array-rank
:rank
rank (generic function)
list
:ranges
ranges (generic function)
transformation.lisp (file)
standard-object (class)
Previous: Exported classes, Up: Exported definitions [Contents][Index]
type-codes.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
Next: Internal special variables, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
float-bits.lisp (file)
memoization.lisp (file)
float-bits.lisp (file)
float-bits.lisp (file)
float-bits.lisp (file)
type-codes.lisp (file)
Next: Internal symbol macros, Previous: Internal constants, Up: Internal definitions [Contents][Index]
compute-buffer-table.lisp (file)
blueprint.lisp (file)
blueprint.lisp (file)
ir-backend.lisp (file)
ir-backend.lisp (file)
blueprint-compiler.lisp (file)
ir-backend.lisp (file)
ir-conversion.lisp (file)
ir-conversion.lisp (file)
reference-backend.lisp (file)
blueprint-compiler.lisp (file)
translation-unit.lisp (file)
type-inference.lisp (file)
Next: Internal macros, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
translation-unit.lisp (file)
(petalisp.native-backend::initial-basic-block petalisp.native-backend::*translation-unit*)
translation-unit.lisp (file)
(petalisp.native-backend::symbol-table petalisp.native-backend::*translation-unit*)
Next: Internal compiler macros, Previous: Internal symbol macros, Up: Internal definitions [Contents][Index]
basic-block.lisp (file)
basic-block.lisp (file)
broadcasting.lisp (file)
type-inference.lisp (file)
documentation.lisp (file)
documentation.lisp (file)
documentation.lisp (file)
documentation.lisp (file)
documentation.lisp (file)
documentation.lisp (file)
documentation.lisp (file)
Like FLET, but declare every function to have dynamic extent.
utilities.lisp (file)
Like LET, but declare every variable to have dynamic extent.
utilities.lisp (file)
Like LET*, but declare every variable to have dynamic extent.
utilities.lisp (file)
compute-buffer-table.lisp (file)
utilities.lisp (file)
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.
utilities.lisp (file)
Optimize the heck out of BODY. Use with caution!
utilities.lisp (file)
Suppress all compiler notes arising during the compilation of BODY.
utilities.lisp (file)
Next: Internal functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
utilities.lisp (file)
utilities.lisp (file)
Next: Internal generic functions, Previous: Internal compiler macros, Up: Internal definitions [Contents][Index]
ir.lisp (file)
range.lisp (file)
blueprint-compiler.lisp (file)
translation-unit.lisp (file)
compute-buffer-table.lisp (file)
broadcasting.lisp (file)
broadcasting.lisp (file)
blueprint.lisp (file)
blueprint.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir-backend.lisp (file)
execution.lisp (file)
numbers.lisp (file)
compute-buffer-table.lisp (file)
ir-conversion.lisp (file)
ir-conversion.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir-conversion.lisp (file)
translation-unit.lisp (file)
basic-block.lisp (file)
empty-set.lisp (file)
translation-unit.lisp (file)
documentation.lisp (file)
ir-backend.lisp (file)
compute-buffer-table.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
float-bits.lisp (file)
float-bits.lisp (file)
shape-transformations.lisp (file)
function-lambda-lists.lisp (file)
Return the lambda list of FUNCTION, or an approximation thereof.
function-lambda-lists.lisp (file)
translation-unit.lisp (file)
blueprint-compiler.lisp (file)
utilities.lisp (file)
utilities.lisp (file)
ir-backend.lisp (file)
translation-unit.lisp (file)
lazy-array-constructors.lisp (file)
ir-backend.lisp (file)
simple-immediate.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
blueprint-compiler.lisp (file)
Return two values:
1. the number of mandatory arguments
2. the maximal number of permissible arguments
function-lambda-lists.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
basic-block.lisp (file)
ir.lisp (file)
execution.lisp (file)
lazy-array-constructors.lisp (file)
ir-backend.lisp (file)
ir.lisp (file)
lambda-block.lisp (file)
ir.lisp (file)
loop-block.lisp (file)
memory-pool.lisp (file)
ir.lisp (file)
blueprint-compiler.lisp (file)
simple-immediate.lisp (file)
ir.lisp (file)
tail-block.lisp (file)
translation-unit.lisp (file)
type-code-utilities.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
broadcasting.lisp (file)
numbers.lisp (file)
blueprint.lisp (file)
ir.lisp (file)
ir.lisp (file)
define-method-pair.lisp (file)
translation-unit.lisp (file)
blueprint-compiler.lisp (file)
blueprint.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
range.lisp (file)
ir.lisp (file)
ir.lisp (file)
type-inference.lisp (file)
lazy-array-constructors.lisp (file)
shape.lisp (file)
ir.lisp (file)
ir-conversion.lisp (file)
numbers.lisp (file)
translation-unit.lisp (file)
translation-unit.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
shape.lisp (file)
type-code-utilities.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
ir.lisp (file)
blueprint.lisp (file)
blueprint-compiler.lisp (file)
blueprint-compiler.lisp (file)
blueprint-compiler.lisp (file)
compute-buffer-table.lisp (file)
blueprint.lisp (file)
lazy-array-constructors.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
automatically generated reader method
memory-pool.lisp (file)
automatically generated reader method
translation-unit.lisp (file)
automatically generated reader method
automatically generated writer method
automatically generated reader method
native-backend.lisp (file)
execution.lisp (file)
ir-conversion.lisp (file)
automatically generated reader method
lambda-block.lisp (file)
reference-backend.lisp (file)
ir-backend.lisp (file)
execution.lisp (file)
execution.lisp (file)
basic-block.lisp (file)
loop-block.lisp (file)
lambda-block.lisp (file)
execution.lisp (file)
automatically generated reader method
basic-block.lisp (file)
lazy-array.lisp (file)
automatically generated reader method
translation-unit.lisp (file)
automatically generated reader method
hairy-transformation.lisp (file)
blueprint.lisp (file)
basic-block.lisp (file)
ir-backend.lisp (file)
automatically generated reader method
basic-block.lisp (file)
automatically generated writer method
basic-block.lisp (file)
lazy-array-constructors.lisp (file)
lazy-array-constructors.lisp (file)
automatically generated reader method
lambda-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
automatically generated reader method
loop-block.lisp (file)
transformation.lisp (file)
hairy-transformation.lisp (file)
identity-transformation.lisp (file)
automatically generated reader method
native-backend.lisp (file)
memory-pool.lisp (file)
memory-pool.lisp (file)
memory-pool.lisp (file)
automatically generated reader method
hairy-transformation.lisp (file)
automatically generated reader method
hairy-transformation.lisp (file)
automatically generated reader method
hairy-transformation.lisp (file)
automatically generated reader method
backend.lisp (file)
automatically generated reader method
backend.lisp (file)
automatically generated writer method
backend.lisp (file)
automatically generated reader method
explicit-set.lisp (file)
set.lisp (file)
shape.lisp (file)
explicit-set.lisp (file)
empty-set.lisp (file)
empty-set.lisp (file)
empty-set.lisp (file)
shape.lisp (file)
automatically generated reader method
basic-block.lisp (file)
automatically generated writer method
basic-block.lisp (file)
automatically generated reader method
translation-unit.lisp (file)
automatically generated reader method
simple-immediate.lisp (file)
automatically generated reader method
tail-block.lisp (file)
automatically generated writer method
tail-block.lisp (file)
basic-block.lisp (file)
tail-block.lisp (file)
basic-block.lisp (file)
automatically generated reader method
basic-block.lisp (file)
compute-buffer-table.lisp (file)
automatically generated reader method
native-backend.lisp (file)
Next: Internal classes, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
lazy-array-constructors.lisp (file)
error (condition)
:function
invalid-call-function (generic function)
:argument-types
invalid-call-argument-types (generic function)
Next: Internal types, Previous: Internal conditions, Up: Internal definitions [Contents][Index]
set.lisp (file)
standard-object (class)