The cl-cuda Reference Manual

2.1 cl-cuda

Cl-cuda is a library to use NVIDIA CUDA in Common Lisp programs.

Author

Masayuki Takagi

License

MIT

Long Description

# Cl-Cuda

Cl-cuda is a library to use NVIDIA CUDA in Common Lisp programs. It provides not only FFI binding to CUDA driver API but the kernel description language with which users can define CUDA kernel functions in S-expression. The kernel description language also provides facilities to define kernel macros and kernel symbol macros in addition to kernel functions. Cl-cuda’s kernel macro and kernel symbol macro offer powerful abstraction that CUDA C itself does not have and provide enormous advantage in resource-limited GPU programming.

Kernel functions defined with the kernel description language can be launched as almost same as ordinal Common Lisp functions except that they must be launched in a CUDA context and followed with grid and block sizes. Kernel functions are compiled and loaded automatically and lazily when they are to be launched for the first time. This process is as following. First, they are compiled into a CUDA C code (.cu file) by cl-cuda. The compiled CUDA C code, then, is compiled into a CUDA kernel module (.ptx file) by NVCC - NVIDIA CUDA Compiler Driver. The obtained kernel module is automatically loaded via CUDA driver API and finally the kernel functions are launched with properly constructed arguments to be passed to CUDA device. Since this process is autonomously managed by the kernel manager, users do not need to handle it for themselves. About the kernel manager, see [Kernel manager](https://github.com/takagi/cl-cuda/blob/master/README.markdown#kernel-manager) section.

Memory management is also one of the most important things in GPU programming. Cl-cuda provides memory block data structure which abstract host memory and device memory. With memory block, users do not need to manage host memory and device memory individually for themselves. It lightens their burden on memory management, prevents bugs and keeps code simple. Besides memory block that provides high level abstraction on host and device memory, cl-cuda also offers low level interfaces to handle CFFI pointers and CUDA device pointers directly. With these primitive interfaces, users can choose to gain more flexible memory control than using memory block if needed.

Cl-cuda is verified on several environments. For detail, see [Verification environments](https://github.com/takagi/cl-cuda/blob/master/README.markdown#verification-environments) section.

## Example

Following code is a part of vector addition example using cl-cuda based on CUDA SDK’s "vectorAdd" sample.

You can define ‘vec-add-kernel‘ kernel function using ‘defkernel‘ macro. In the definition, ‘aref‘ is to refer values stored in an array. ‘set‘ is to store values into an array. ‘block-dim-x‘, ‘block-idx-x‘ and ‘thread-idx-x‘ have their counterparts in CUDA C’s built-in variables and are used to specify the array index to be operated in each CUDA thread.

Once the kernel function is defined, you can launch it as if it is an ordinal Common Lisp function except that it requires to be in a CUDA context and followed by ‘:gird-dim‘ and ‘:block-dim‘ keyword parameters which specify the dimensions of grid and block. To keep a CUDA context, you can use ‘with-cuda‘ macro which has responsibility on initializing CUDA and managing a CUDA context. ‘with-memory-blocks‘ manages memory blocks which abstract host memory area and device memory area, then ‘sync-memory-block‘ copies data stored in a memory block between host and device.

For the whole code, please see [examples/vector-add.lisp](https://github.com/takagi/cl-cuda/tree/master/examples/vector-add.lisp).

(defkernel vec-add-kernel (void ((a float*) (b float*) (c float*) (n int)))
(let ((i (+ (* block-dim-x block-idx-x) thread-idx-x)))
(if (< i n)
(set (aref c i)
(+ (aref a i) (aref b i))))))

(defun main ()
(let* ((dev-id 0)
(n 1024)
(threads-per-block 256)
(blocks-per-grid (/ n threads-per-block)))
(with-cuda (dev-id)
(with-memory-blocks ((a ’float n)
(b ’float n)
(c ’float n))
(random-init a n)
(random-init b n)
(sync-memory-block a :host-to-device)
(sync-memory-block b :host-to-device)
(vec-add-kernel a b c n
:grid-dim (list blocks-per-grid 1 1)
:block-dim (list threads-per-block 1 1))
(sync-memory-block c :device-to-host)
(verify-result a b c n)))))

## Installation

You can install cl-cuda via quicklisp.

> (ql:quickload :cl-cuda)

You may encounter the following error, please install CFFI explicitly ‘(ql:quickload :cffi)‘ before loading cl-cuda. Just once is enough.

Component CFFI-GROVEL not found
[Condition of type ASDF/FIND-SYSTEM:MISSING-COMPONENT]

## Requirements

Cl-cuda requires following:

* NVIDIA CUDA-enabled GPU
* CUDA Toolkit, CUDA Drivers and CUDA SDK need to be installed

## Verification environments

Cl-cuda is verified to work in following environments:

#### Environment 1
* Mac OS X 10.6.8 (MacBookPro)
* GeForce 9400M
* CUDA 4
* SBCL 1.0.55 32-bit
* All tests pass, all examples work

#### Environment2
* Amazon Linux x86_64 (Amazon EC2)
* Tesla M2050
* CUDA 4
* SBCL 1.1.7 64-bit
* All tests pass, all examples which are verified work (others not tried yet)
* ‘(setf *nvcc-options* (list "-arch=sm_20" "-m32"))‘ needed

#### Environment3 (Thanks to Viktor Cerovski)
* Linux 3.5.0-32-generic Ubuntu SMP x86_64
* GeFroce 9800 GT
* CUDA 5
* SBCL 1.1.7 64-bit
* All tests pass, all examples work

#### Environment4 (Thanks to wvxvw)
* Fedra18 x86_64
* GeForce GTX 560M
* CUDA 5.5
* SBCL 1.1.2-1.fc18
* ‘vector-add‘ example works (didn’t try the rest yet)

Further information:
* ‘(setf *nvcc-options* (list "-arch=sm_20" "-m32"))‘ needed
* using video drivers from ‘rpmfusion‘ instead of the ones in ‘cuda‘ package
* see issue [#1](https://github.com/takagi/cl-cuda/issues/1#issuecomment-22813518)

#### Environment5 (Thanks to Atabey Kaygun)
* Linux 3.11-2-686-pae SMP Debian 3.11.8-1 (2013-11-13) i686 GNU/Linux
* NVIDIA Corporation GK106 GeForce GTX 660
* CUDA 5.5
* SBCL 1.1.12
* All tests pass, all examples work

#### Environment6 (Thanks to @gos-k)
* Ubuntu 16.04.1 LTS
* GeForce GTX 1080
* CUDA Version 8.0.27
* Driver Version 367.35
* CCL Version 1.11-r16635 (LinuxX8664)
* All tests pass, all examples work

## API

Here explain some APIs commonly used.

### [Macro] with-cuda

WITH-CUDA (dev-id) &body body

Initializes CUDA and keeps a CUDA context during ‘body‘. ‘dev-id‘ is passed to ‘get-cuda-device‘ function and the device handler returned is passed to ‘create-cuda-context‘ function to create a CUDA context in the expanded form. The results of ‘get-cuda-device‘ and ‘create-cuda-context‘ functions are bound to ‘*cuda-device*‘ and ‘*cuda-context*‘ special variables respectively. The kernel manager unloads before ‘with-cuda‘ exits.

### [Function] synchronize-context

SYNCHRONIZE-CONTEXT

Blocks until a CUDA context has completed all preceding requested tasks.

### [Function] alloc-memory-block

ALLOC-MEMORY-BLOCK type size

Allocates a memory block to hold ‘size‘ elements of type ‘type‘ and returns it. Actually, linear memory areas are allocated on both host and device memory and a memory block holds pointers to them.

### [Function] free-memory-block

FREE-MEMORY-BLOCK memory-block

Frees ‘memory-block‘ previously allocated by ‘alloc-memory-block‘. Freeing a memory block twice should cause an error.

### [Macro] with-memory-block, with-memory-blocks

WITH-MEMORY-BLOCK (var type size) &body body
WITH-MEMORY-BLOCKS ({(var type size)}*) &body body

Binds ‘var‘ to a memory block allocated using ‘alloc-memory-block‘ applied to the given ‘type‘ and ‘size‘ during ‘body‘. The memory block is freed using ‘free-memory-block‘ when ‘with-memory-block‘ exits. ‘with-memory-blocks‘ is a plural form of ‘with-memory-block‘.

### [Function] sync-memory-block

SYNC-MEMORY-BLOCK memory-block direction

Copies stored data between host memory and device memory for ‘memory-block‘. ‘direction‘ is either ‘:host-to-device‘ or ‘:device-to-host‘ which specifies the direction of copying.

### [Accessor] memory-block-aref

MEMORY-BLOCK-AREF memory-block index

Accesses ‘memory-block‘’s element specified by ‘index‘. Note that the accessed memory area is that on host memory. Use ‘sync-memory-block‘ to synchronize stored data between host memory and device memory.

### [Macro] defglobal

DEFGLOBAL name type &optional expression qualifiers

Defines a global variable. ‘name‘ is a symbol which is the name of the variable. ‘type‘ is the type of the variable. Optional ‘expression‘ is an expression which initializes the variable. Optional ‘qualifiers‘ is one of or a list of keywords: ‘:device‘, ‘:constant‘, ‘:shared‘, ‘:managed‘ and ‘:restrict‘, which are corresponding to CUDA C’s ‘__device__‘, ‘__constant__‘, ‘__shared__‘, ‘__managed__‘ and ‘__restrict__‘ variable qualifiers. If not given, ‘:device‘ is used.

(defglobal pi float 3.14159 :constant)

### [Accessor] global-ref

Accesses a global variable’s value on device from host with automatically copying its value from/to device.

(defglobal x :device int 0)
(global-ref x) ; => 0
(setf (global-ref x) 42)
(global-ref x) ; => 42

### [Special Variable] \*tmp-path\*

Specifies the temporary directory in which cl-cuda generates files such as ‘.cu‘ file and ‘.ptx‘ file. The default is ‘"/tmp/"‘.

(setf *tmp-path* "/path/to/tmp/")

### [Special Variable] \*nvcc-options\*

Specifies additional command line options passed to ‘nvcc‘ command that cl-cuda calls internally. The default is ‘nil‘. If ‘-arch=sm_XX‘ option is not specified here, it is automatically inserted with ‘cuDeviceComputeCapability‘ driver API.

(setf *nvcc-options* (list "-arch=sm_20" "-m32"))

### [Special Variable] \*nvcc-binary\*

Specifies the path to ‘nvcc‘ command so that cl-cuda can call internally. The default is just ‘nvcc‘.

(setf *nvcc-binary* "/path/to/nvcc")

### [Special Variable] \*show-messages\*

Specifies whether to let cl-cuda show operational messages or not. The default is ‘t‘.

(setf *show-messages* nil)

### [Special Variable] \*sdk-not-found\*

Readonly. The value is ‘t‘ if cl-cuda could not find CUDA SDK or at least it failed to load ‘libcuda‘ for some reason, otherwise ‘nil‘.

*sdk-not-found* ; => nil

## Kernel Description Language

### Types

not documented yet.

### IF statement

IF test-form then-form [else-form]

‘if‘ allows the execution of a form to be dependent on a single ‘test-form‘. First ‘test-form‘ is evaluated. If the result is ‘true‘, then ‘then-form‘ is selected; otherwise ‘else-form‘ is selected. Whichever form is selected is then evaluated. If ‘else-form‘ is not provided, does nothing when ‘else-form‘ is selected.

Example:

(if (= a 0)
(return 0)
(return 1))

Compiled:

if (a == 0) {
return 0;
} else {
return 1;
}

### LET statement

LET ({(var init-form)}*) statement*

‘let‘ declares new variable bindings and set corresponding ‘init-form‘s to them and execute a series of ‘statement‘s that use these bindings. ‘let‘ performs the bindings in parallel. For sequentially, use ‘let*‘ kernel macro instead.

Example:

(let ((i 0))
(return i))

Compiled:

{
int i = 0;
return i;
}

### SYMBOL-MACROLET statement

SYMBOL-MACROLET ({(symbol expansion)}*) statement*

‘symbol-macrolet‘ establishes symbol expansion rules in the variable environment and execute a series of ‘statement‘s that use these rules. In cl-cuda’s compilation process, the symbol macros found in a form are replaces by corresponding ‘expansion‘s.

Example:

(symbol-macrolet ((x 1.0))
(return x))

Compiled:

{
return 1.0;
}

### MACROLET statement

MACROLET ({(name lambda-list local-form*)}*) statement*

‘macrolet‘ establishes local macro definitions, using the same format as ‘defkernelmacro‘, and executes a series of ‘statement‘s with these definition bindings.

Example:

(macrolet ((square (a)
(if (numberp a)
(* a a)
‘(* ,a ,a))))
(return (square 2)))

Compiled:

{
return 4;
}

### DO statement

DO ({(var init-form step-form)}*) (test-form) statement*

‘do‘ iterates over a group of ‘statement‘s while ‘test-form‘ holds. ‘do‘ accepts an arbitrary number of iteration ‘var‘s and their initial values are supplied by ‘init-form‘s. ‘step-form‘s supply how the ‘var‘s should be updated on succeeding iterations through the loop.

Example:

(do ((a 0 (+ a 1))
(b 0 (+ b 1)))
((> a 15))
(do-some-statement))

Compiled:

for ( int a = 0, int b = 0; ! (a > 15); a = a + 1, b = b + 1 )
{
do_some_statement();
}

### WITH-SHARED-MEMORY statement

WITH-SHARED-MEMORY ({(var type size*)}*) statement*

‘with-shared-memory‘ declares new variable bindings on shared memory by adding ‘__shared__‘ variable specifiers. It allows to declare array variables if dimensions are provided. A series of ‘statement‘s are executed with these bindings.

Example:

(with-shared-memory ((a int 16)
(b float 16 16))
(return))

Compiled:

{
__shared__ int a[16];
__shared__ float b[16][16];
return;
}

### SET statement

SET reference expression

‘set‘ provides simple variable assignment. It accepts one of variable, structure and array references as ‘reference‘.

Example:

(set x 1.0)
(set (float4-x y 1.0)
(set (aref z 0) 1.0)

Compiled:

x = 1.0;
y.x = 1.0;
z[0] = 1.0;

### PROGN statement

PROGN statement*

‘progn‘ evaluates ‘statement‘s, in the order in which they are given.

Example:

(progn
(do-some-statements)
(do-more-statements))

Compiled:

do_some_statements();
do_more_statements();

### RETURN statement

RETURN [return-form]

‘return‘ returns control, with ‘return-form‘ if supplied, from a kernel function.

Example:

(return 0)

Compiled:

return 0;

## Architecture

The following figure illustrates cl-cuda’s overall architecture.

+———————————+———–+———–+
| defkernel | memory | context |
cl-cuda.api +———————————+ | |
| kernel-manager | | |
+———————————+———–+———–+
+—————————-+—————————-+
cl-cuda.lang | Kernel description lang. | the Compiler |
+—————————-+—————————-+
+———————————————————+
cl-cuda.driver-api | driver-api |
+———————————————————+
+———————————————————+
CUDA | CUDA driver API |
+———————————————————+

Cl-cuda consists of three subpackages: ‘api‘, ‘lang‘ and ‘driver-api‘.

‘driver-api‘ subpackage is a FFI binding to CUDA driver API. ‘api‘ subpackage invokes CUDA driver API via this binding internally.

‘lang‘ subpackage provides the kernel description language. It provides the language’s syntax, type, built-in functions and the compiler to CUDA C. ‘api‘ subpackage calls this compiler.

‘api‘ subpackage provides API for cl-cuda users. It further consists of ‘context‘, ‘memory‘, ‘kernel-manager‘ and ‘defkernel‘ subpackages. ‘context‘ subpackage has responsibility on initializing CUDA and managing CUDA contexts. ‘memory‘ subpackage offers memory management, providing high level API for memory block data structure and low level API for handling host memory and device memory directly. ‘kernel-manager‘ subpackage manages the entire process from compiling the kernel description language to loading/unloading obtained kernel module autonomously. Since it is wrapped by ‘defkernel‘ subpackage which provides the interface to define kernel functions, cl-cuda’s users usually do not need to use it for themselves.

## Kernel manager

The kernel manager is a module which manages defining kernel functions, compiling them into a CUDA kernel module, loading it and unloading it. I show you its work as a finite state machine here.

To begin with, the kernel manager has four states.

I initial state
II compiled state
III module-loaded state
IV function-loaded state

The initial state is its entry point. The compiled state is a state where kernel functions defined with the kernel descrpition language have been compiled into a CUDA kernel module (.ptx file). The obtained kernel module has been loaded in the module-loaded state. In the function-loaded state, each kernel function in the kernel module has been loaded.

Following illustrates the kernel manager’s state transfer.

compile-module load-module load-function
=================> =================> =================>
I II III IV
<================= <=================
define-function <========================================
define-macro unload
define-symbol-macro
define-global

‘kernel-manager-compile-module‘ function compiles defined kernel functions into a CUDA kernel module. ‘kernel-manager-load-module‘ function loads the obtained kernel module. ‘kernel-manager-load-function‘ function loads each kernel function in the kernel module.

In the module-loaded state and function-loaded state, ‘kernel-manager-unload‘ function unloads the kernel module and turn the kernel manager’s state back to the compiled state. ‘kernel-manager-define-function‘, ‘kernel-manager-define-macro‘, ‘kernel-manager-define-symbol-macro‘ and ‘kernel-manager-define-global‘ functions, which are wrapped as ‘defkernel‘, ‘defkernelmacro‘, ‘defkernel-symbol-macro‘ and ‘defglobal‘ macros respectively, change its state back into the initial state and make it require compilation again.

The kernel manager is stored in ‘*kernel-manager*‘ special variable when cl-cuda is loaded and keeps alive during the Common Lisp process. Usually, you do not need to manage it explicitly.

## How cl-cuda works when CUDA SDK is not installed

This section is for cl-cuda users who develop an application or a library which has alternative sub system other than cl-cuda and may run on environments CUDA SDK is not installed.

**Compile and load time**
Cl-cuda is compiled and loaded without causing any conditions on environments CUDA SDK is not installed. Since cl-cuda API ’s symbols are interned, user programs can use them normally.

**Run time**
At the time cl-cuda’s API is called, an error that tells CUDA SDK is not found should occur. With ‘*sdk-not-found*‘ special variable, user programs can get if cl-cuda has found CUDA SDK or not.

How cl-cuda determines CUDA SDK is installed or not is that if it has successfully loaded ‘libuda‘ dynamic library with ‘cffi:user-foreign-library‘ function.

## Streams

The low level interface works with multiple streams. With the async stuff it’s possible to overlap copy and computation with two streams. Cl-cuda provides ‘*cuda-stream*‘ special variable, to which bound stream is used in kernel function calls.

The following is for working with streams in [mgl-mat](https://github.com/melisgl/mgl-mat):

(defmacro with-cuda-stream ((stream) &body body)
(alexandria:with-gensyms (stream-pointer)
‘(cffi:with-foreign-objects
((,stream-pointer ’cl-cuda.driver-api:cu-stream))
(cl-cuda.driver-api:cu-stream-create ,stream-pointer 0)
(let ((,stream (cffi:mem-ref ,stream-pointer
’cl-cuda.driver-api:cu-stream)))
(unwind-protect
(locally ,@body)
(cl-cuda.driver-api:cu-stream-destroy ,stream))))))

then, call a kernel function with binding a stream to ‘*cuda-stream*‘:

(with-cuda-stream (*cuda-stream*)
(call-kernel-function))

## Author

* Masayuki Takagi (kamonama@gmail.com)

## Copyright

Copyright (c) 2012 Masayuki Takagi (kamonama@gmail.com)

## License

Licensed under the MIT License.

Version

0.1

Dependencies

• cffi (system).
• alexandria (system).
• external-program (system).
• osicat (system).
• cl-pattern (system).
• split-sequence (system).
• cl-reexport (system).
• cl-ppcre (system).

Source

cl-cuda.asd.

Child Component

src (module).

---

3.1 cl-cuda/src

Source

cl-cuda.asd.

Parent Component

cl-cuda (system).

Child Components

• driver-api (module).
• lang (module).
• api (module).
• cl-cuda.lisp (file).

---

3.2 cl-cuda/src/driver-api

Source

cl-cuda.asd.

Parent Component

src (module).

Child Components

• package.lisp (file).
• get-error-string.lisp (file).
• cffi-grovel.lisp (file).
• sdk-not-found.lisp (file).
• library.lisp (file).
• type.lisp (file).
• type-grovel.lisp (file).
• enum.lisp (file).
• function.lisp (file).

---

3.3 cl-cuda/src/lang

Dependency

driver-api (module).

Source

cl-cuda.asd.

Parent Component

src (module).

Child Components

• util.lisp (file).
• data.lisp (file).
• type.lisp (file).
• syntax.lisp (file).
• environment.lisp (file).
• built-in.lisp (file).
• kernel.lisp (file).
• compiler/compile-data.lisp (file).
• compiler/compile-type.lisp (file).
• compiler/type-of-expression.lisp (file).
• compiler/compile-expression.lisp (file).
• compiler/compile-statement.lisp (file).
• compiler/compile-kernel.lisp (file).
• lang.lisp (file).

---

3.4 cl-cuda/src/api

Dependency

lang (module).

Source

cl-cuda.asd.

Parent Component

src (module).

Child Components

• nvcc.lisp (file).
• kernel-manager.lisp (file).
• memory.lisp (file).
• context.lisp (file).
• defkernel.lisp (file).
• macro.lisp (file).
• timer.lisp (file).
• api.lisp (file).

---

4.1 Lisp

• cl-cuda/cl-cuda.asd
• cl-cuda/src/driver-api/package.lisp
• cl-cuda/src/driver-api/get-error-string.lisp
• cl-cuda/src/driver-api/cffi-grovel.lisp
• cl-cuda/src/driver-api/sdk-not-found.lisp
• cl-cuda/src/driver-api/library.lisp
• cl-cuda/src/driver-api/type.lisp
• cl-cuda/src/driver-api/type-grovel.lisp
• cl-cuda/src/driver-api/enum.lisp
• cl-cuda/src/driver-api/function.lisp
• cl-cuda/src/lang/util.lisp
• cl-cuda/src/lang/data.lisp
• cl-cuda/src/lang/type.lisp
• cl-cuda/src/lang/syntax.lisp
• cl-cuda/src/lang/environment.lisp
• cl-cuda/src/lang/built-in.lisp
• cl-cuda/src/lang/kernel.lisp
• cl-cuda/src/lang/compiler/compile-data.lisp
• cl-cuda/src/lang/compiler/compile-type.lisp
• cl-cuda/src/lang/compiler/type-of-expression.lisp
• cl-cuda/src/lang/compiler/compile-expression.lisp
• cl-cuda/src/lang/compiler/compile-statement.lisp
• cl-cuda/src/lang/compiler/compile-kernel.lisp
• cl-cuda/src/lang/lang.lisp
• cl-cuda/src/api/nvcc.lisp
• cl-cuda/src/api/kernel-manager.lisp
• cl-cuda/src/api/memory.lisp
• cl-cuda/src/api/context.lisp
• cl-cuda/src/api/defkernel.lisp
• cl-cuda/src/api/macro.lisp
• cl-cuda/src/api/timer.lisp
• cl-cuda/src/api/api.lisp
• cl-cuda/src/cl-cuda.lisp

---

5.1 cl-cuda.api.timer

Source

timer.lisp.

Use List

• cl-cuda.driver-api.
• common-lisp.

Public Interface

• create-timer (function).
• destroy-timer (function).
• elapsed-time (function).
• start-timer (function).
• stop-timer (function).
• synchronize-timer (function).
• with-timer (macro).

Internals

• %elapsed-time (function).
• %make-timer (function).
• copy-timer (function).
• create-cu-event (function).
• destroy-cu-event (function).
• record-cu-event (function).
• sync-cu-event (function).
• timer (structure).
• timer-p (function).
• timer-start-event (reader).
• timer-stop-event (reader).

---

5.2 cl-cuda.lang.environment

Source

environment.lisp.

Use List

• cl-cuda.lang.data.
• cl-cuda.lang.type.
• cl-cuda.lang.util.
• common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.
• cl-cuda.lang.compiler.type-of-expression.

Public Interface

• empty-function-environment (function).
• empty-variable-environment (function).
• function-environment-add-function (function).
• function-environment-add-macro (function).
• function-environment-function-argument-types (function).
• function-environment-function-c-name (function).
• function-environment-function-exists-p (function).
• function-environment-function-name (function).
• function-environment-function-return-type (function).
• function-environment-macro-exists-p (function).
• function-environment-macro-expander (function).
• function-environment-macro-name (function).
• variable-environment-add-global (function).
• variable-environment-add-symbol-macro (function).
• variable-environment-add-variable (function).
• variable-environment-global-c-name (function).
• variable-environment-global-exists-p (function).
• variable-environment-global-initializer (function).
• variable-environment-global-name (function).
• variable-environment-global-type (function).
• variable-environment-symbol-macro-exists-p (function).
• variable-environment-symbol-macro-expansion (function).
• variable-environment-symbol-macro-name (function).
• variable-environment-variable-exists-p (function).
• variable-environment-variable-name (function).
• variable-environment-variable-type (function).

Internals

• %function (structure).
• %lookup-function (function).
• %lookup-global (function).
• %lookup-macro (function).
• %lookup-symbol-macro (function).
• %lookup-variable (function).
• %make-function (function).
• %make-global (function).
• %make-macro (function).
• %make-symbol-macro (function).
• %make-variable (function).
• copy-%function (function).
• copy-global (function).
• copy-macro (function).
• copy-symbol-macro (function).
• copy-variable (function).
• function-argument-types (reader).
• function-c-name (function).
• function-name (reader).
• function-p (function).
• function-return-type (reader).
• global (structure).
• global-c-name (function).
• global-initializer (reader).
• global-name (reader).
• global-p (function).
• global-type (reader).
• macro (structure).
• macro-arguments (reader).
• macro-body (reader).
• macro-expander (function).
• macro-name (reader).
• macro-p (function).
• make-function (function).
• make-global (function).
• make-macro (function).
• make-symbol-macro (function).
• make-variable (function).
• symbol-macro (structure).
• symbol-macro-expansion (reader).
• symbol-macro-name (reader).
• symbol-macro-p (function).
• variable (structure).
• variable-name (reader).
• variable-p (function).
• variable-type (reader).

---

5.3 cl-cuda.api.defkernel

Source

defkernel.lisp.

Use List

• cl-cuda.api.kernel-manager.
• cl-cuda.api.memory.
• cl-cuda.driver-api.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.
• common-lisp.

Used By List

cl-cuda.api.macro.

Public Interface

• defglobal (macro).
• defkernel (macro).
• defkernel-symbol-macro (macro).
• defkernelmacro (macro).
• expand-macro (function).
• expand-macro-1 (function).
• global-ref (function).
• (setf global-ref) (function).

Internals

• argument-cffi-type (function).
• argument-var-ptr (function).
• argument-vars (function).
• ptr-binding (function).
• setf-to-argument-array-form (function).
• setf-to-foreign-object-form (function).
• with-launching-arguments (macro).

---

5.4 cl-cuda.lang.compiler.compile-type

Source

compiler/compile-type.lisp.

Use List

• cl-cuda.lang.type.
• common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.

Public Interface

compile-type (function).

---

5.5 cl-cuda.lang.compiler.compile-data

Source

compiler/compile-data.lisp.

Use List

• cl-cuda.lang.data.
• cl-cuda.lang.util.
• common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.

Public Interface

• compile-bool (function).
• compile-double (function).
• compile-float (function).
• compile-int (function).
• compile-symbol (function).

---

5.6 cl-cuda.lang.syntax

Source

syntax.lisp.

Use List

• cl-cuda.lang.data.
• cl-cuda.lang.type.
• common-lisp.

Used By List

• cl-cuda.api.defkernel.
• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.
• cl-cuda.lang.compiler.type-of-expression.
• cl-cuda.lang.kernel.

Public Interface

• argument (type).
• argument-p (function).
• argument-type (function).
• argument-var (function).
• arithmetic-operands (function).
• arithmetic-operator (function).
• arithmetic-p (function).
• array-reference-expr (function).
• array-reference-indices (function).
• array-reference-p (function).
• block-dim-p (function).
• block-idx-p (function).
• bool-literal-p (function).
• constructor-operands (function).
• constructor-operator (function).
• constructor-p (function).
• cuda-dimension-p (function).
• do-binding-init (function).
• do-binding-p (function).
• do-binding-step (function).
• do-binding-var (function).
• do-bindings (function).
• do-end-test (function).
• do-p (function).
• do-statements (function).
• double-literal-p (function).
• float-literal-p (function).
• function-operands (function).
• function-operator (function).
• function-p (function).
• grid-dim-p (function).
• if-else-statement (function).
• if-p (function).
• if-test-expression (function).
• if-then-statement (function).
• inline-if-else-expression (function).
• inline-if-p (function).
• inline-if-test-expression (function).
• inline-if-then-expression (function).
• int-literal-p (function).
• let-binding-expr (function).
• let-binding-p (function).
• let-binding-var (function).
• let-bindings (function).
• let-p (function).
• let-statements (function).
• literal-p (function).
• macro-operands (function).
• macro-operator (function).
• macro-p (function).
• macrolet-binding-arguments (function).
• macrolet-binding-body (function).
• macrolet-binding-p (function).
• macrolet-binding-symbol (function).
• macrolet-bindings (function).
• macrolet-p (function).
• macrolet-statements (function).
• progn-p (function).
• progn-statements (function).
• reference-p (function).
• return-expr (function).
• return-p (function).
• set-expression (function).
• set-p (function).
• set-reference (function).
• structure-reference-accessor (function).
• structure-reference-expr (function).
• structure-reference-p (function).
• symbol-macro-p (function).
• symbol-macrolet-binding-expansion (function).
• symbol-macrolet-binding-p (function).
• symbol-macrolet-binding-symbol (function).
• symbol-macrolet-bindings (function).
• symbol-macrolet-p (function).
• symbol-macrolet-statements (function).
• thread-idx-p (function).
• variable-reference-p (function).
• with-shared-memory-p (function).
• with-shared-memory-spec-dimensions (function).
• with-shared-memory-spec-p (function).
• with-shared-memory-spec-type (function).
• with-shared-memory-spec-var (function).
• with-shared-memory-specs (function).
• with-shared-memory-statements (function).

Internals

• +aritmetic-operators+ (special variable).
• +constructor-operators+ (special variable).

---

5.7 cl-cuda.driver-api

Source

package.lisp.

Use List

common-lisp.

Used By List

• cl-cuda.api.context.
• cl-cuda.api.defkernel.
• cl-cuda.api.kernel-manager.
• cl-cuda.api.memory.
• cl-cuda.api.timer.
• cl-cuda.lang.type.

Public Interface

• *sdk-not-found* (special variable).
• *show-messages* (special variable).
• cu-ctx-create (function).
• cu-ctx-destroy (function).
• cu-ctx-synchronize (function).
• cu-device-compute-capability (function).
• cu-device-get (function).
• cu-device-get-count (function).
• cu-device-get-name (function).
• cu-device-total-mem (function).
• cu-event-blocking-sync (constant).
• cu-event-create (function).
• cu-event-default (constant).
• cu-event-destroy (function).
• cu-event-disable-timing (constant).
• cu-event-elapsed-time (function).
• cu-event-interprocess (constant).
• cu-event-record (function).
• cu-event-synchronize (function).
• cu-init (function).
• cu-launch-kernel (function).
• cu-mem-alloc (function).
• cu-mem-free (function).
• cu-mem-host-register (function).
• cu-mem-host-unregister (function).
• cu-memcpy-device-to-host (function).
• cu-memcpy-device-to-host-async (function).
• cu-memcpy-host-to-device (function).
• cu-memcpy-host-to-device-async (function).
• cu-module-get-function (function).
• cu-module-get-global (function).
• cu-module-load (function).
• cu-module-unload (function).
• cu-stream-create (function).
• cu-stream-destroy (function).
• cu-stream-query (function).
• cu-stream-synchronize (function).
• cu-stream-wait-event (function).

Internals

• +cuda-success+ (special variable).
• +error-strings+ (special variable).
• check-cuda-error (function).
• cu-mem-host-register-devicemap (constant).
• cu-mem-host-register-portable (constant).
• cu-stream-default (constant).
• cu-stream-non-blocking (constant).
• defconstant-enum-value (function).
• defcuenum (macro).
• defcufun (macro).
• get-error-string (function).
• sdk-not-found-error (condition).
• without-fp-traps (macro).

---

5.8 cl-cuda.lang.compiler.type-of-expression

Source

compiler/type-of-expression.lisp.

Use List

• cl-cuda.lang.built-in.
• cl-cuda.lang.environment.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.
• common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.

Public Interface

type-of-expression (function).

Internals

• %macro-p (function).
• %symbol-macro-p (function).
• type-of-arithmetic (function).
• type-of-array-reference (function).
• type-of-built-in-function (function).
• type-of-constructor (function).
• type-of-cuda-dimension (function).
• type-of-function (function).
• type-of-inline-if (function).
• type-of-literal (function).
• type-of-macro (function).
• type-of-operands (function).
• type-of-reference (function).
• type-of-structure-reference (function).
• type-of-symbol-macro (function).
• type-of-user-defined-function (function).
• type-of-variable-reference (function).

---

5.9 cl-cuda.lang.data

Source

data.lisp.

Use List

common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-data.
• cl-cuda.lang.environment.
• cl-cuda.lang.kernel.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.

Public Interface

• cl-cuda-bool-p (function).
• cl-cuda-double-p (function).
• cl-cuda-float-p (function).
• cl-cuda-int-p (function).
• cl-cuda-symbol (type).
• cl-cuda-symbol-p (function).
• double3 (structure).
• double3-= (function).
• double3-p (function).
• double3-x (reader).
• (setf double3-x) (writer).
• double3-y (reader).
• (setf double3-y) (writer).
• double3-z (reader).
• (setf double3-z) (writer).
• double4 (structure).
• double4-= (function).
• double4-p (function).
• double4-w (reader).
• (setf double4-w) (writer).
• double4-x (reader).
• (setf double4-x) (writer).
• double4-y (reader).
• (setf double4-y) (writer).
• double4-z (reader).
• (setf double4-z) (writer).
• float3 (structure).
• float3-= (function).
• float3-p (function).
• float3-x (reader).
• (setf float3-x) (writer).
• float3-y (reader).
• (setf float3-y) (writer).
• float3-z (reader).
• (setf float3-z) (writer).
• float4 (structure).
• float4-= (function).
• float4-p (function).
• float4-w (reader).
• (setf float4-w) (writer).
• float4-x (reader).
• (setf float4-x) (writer).
• float4-y (reader).
• (setf float4-y) (writer).
• float4-z (reader).
• (setf float4-z) (writer).
• make-double3 (function).
• make-double4 (function).
• make-float3 (function).
• make-float4 (function).
• with-double3 (macro).
• with-double4 (macro).
• with-float3 (macro).
• with-float4 (macro).

Internals

• copy-double3 (function).
• copy-double4 (function).
• copy-float3 (function).
• copy-float4 (function).
• curand-state-xorwow-tclass (class).
• double3-c (class).
• double4-c (class).
• float3-c (class).
• float4-c (class).

---

5.10 cl-cuda-asd

Source

cl-cuda.asd.

Use List

• asdf/interface.
• common-lisp.
• uiop/driver.

Internals

cuda-grovel-file (class).

---

5.11 cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp.

Use List

• cl-cuda.lang.compiler.compile-data.
• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-statement.
• cl-cuda.lang.compiler.compile-type.
• cl-cuda.lang.compiler.type-of-expression.
• cl-cuda.lang.environment.
• cl-cuda.lang.kernel.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.
• cl-cuda.lang.util.
• common-lisp.

Used By List

cl-cuda.api.kernel-manager.

Public Interface

compile-kernel (function).

Internals

• %add-function-arguments (function).
• %add-functions (function).
• %add-globals (function).
• %add-macros (function).
• %add-symbol-macros (function).
• compile-argument (function).
• compile-arguments (function).
• compile-declaration (function).
• compile-definition (function).
• compile-definitions (function).
• compile-global (function).
• compile-globals (function).
• compile-includes (function).
• compile-prototype (function).
• compile-prototypes (function).
• compile-specifier (function).
• compile-statements (function).
• compile-variable-qualifier (function).
• kernel->function-environment (function).
• kernel->variable-environment (function).

---

5.12 cl-cuda.api.memory

Source

memory.lisp.

Use List

• cl-cuda.driver-api.
• cl-cuda.lang.type.
• common-lisp.

Used By List

cl-cuda.api.defkernel.

Public Interface

• alloc-device-memory (function).
• alloc-host-memory (function).
• alloc-memory-block (function).
• device-total-bytes (function).
• device-total-gbytes (function).
• device-total-kbytes (function).
• device-total-mbytes (function).
• free-device-memory (function).
• free-host-memory (function).
• free-memory-block (function).
• host-memory-aref (function).
• (setf host-memory-aref) (function).
• memcpy-device-to-host (function).
• memcpy-host-to-device (function).
• memory-block-aref (function).
• (setf memory-block-aref) (function).
• memory-block-device-ptr (reader).
• memory-block-host-ptr (reader).
• memory-block-p (function).
• memory-block-size (reader).
• memory-block-type (reader).
• sync-memory-block (function).
• with-device-memory (macro).
• with-host-memory (macro).
• with-memory-block (macro).
• with-memory-blocks (macro).

Internals

• %make-memory-block (function).
• copy-memory-block (function).
• memcpy-device-to-host-async (function).
• memcpy-host-to-device-async (function).
• memory-block (structure).

---

5.13 cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp.

Use List

• cl-cuda.lang.compiler.compile-data.
• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-type.
• cl-cuda.lang.compiler.type-of-expression.
• cl-cuda.lang.environment.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.
• cl-cuda.lang.util.
• common-lisp.

Used By List

cl-cuda.lang.compiler.compile-kernel.

Public Interface

compile-statement (function).

Internals

• %macro-p (function).
• compile-do (function).
• compile-do-init-part (function).
• compile-do-statements (function).
• compile-do-step-part (function).
• compile-do-test-part (function).
• compile-function (function).
• compile-if (function).
• compile-let (function).
• compile-let-bindings (function).
• compile-let-statements (function).
• compile-macro (function).
• compile-macrolet (function).
• compile-macrolet-statements (function).
• compile-progn (function).
• compile-return (function).
• compile-set (function).
• compile-symbol-macrolet (function).
• compile-symbol-macrolet-statements (function).
• compile-with-shared-memory (function).
• compile-with-shared-memory-spec-dimensions (function).
• compile-with-shared-memory-specs (function).
• compile-with-shared-memory-statements (function).
• func-env-add-macrolet-bindings (function).
• var-env-add-do-bindings (function).
• var-env-add-let-bindings (function).
• var-env-add-symbol-macrolet-bindings (function).
• var-env-add-with-shared-memory-specs (function).

---

5.14 cl-cuda.lang.built-in

Source

built-in.lisp.

Use List

• cl-cuda.lang.type.
• common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.type-of-expression.

Public Interface

• built-in-function-c-name (function).
• built-in-function-infix-p (function).
• built-in-function-return-type (function).

Internals

• +built-in-functions+ (special variable).
• inferred-function (function).
• inferred-function-candidates (function).

---

5.15 cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp.

Use List

• cl-cuda.lang.built-in.
• cl-cuda.lang.compiler.compile-data.
• cl-cuda.lang.compiler.type-of-expression.
• cl-cuda.lang.environment.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.
• common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.

Public Interface

compile-expression (function).

Internals

• %macro-p (function).
• %symbol-macro-p (function).
• compile-arithmetic (function).
• compile-array-indices (function).
• compile-array-reference (function).
• compile-bool-literal (function).
• compile-built-in-function (function).
• compile-built-in-infix-function (function).
• compile-built-in-prefix-function (function).
• compile-constructor (function).
• compile-cuda-dimension (function).
• compile-double-literal (function).
• compile-float-literal (function).
• compile-function (function).
• compile-inline-if (function).
• compile-int-literal (function).
• compile-literal (function).
• compile-macro (function).
• compile-operands (function).
• compile-reference (function).
• compile-structure-reference (function).
• compile-symbol-macro (function).
• compile-user-defined-function (function).
• compile-variable-reference (function).
• type-of-operands (function).

---

5.16 cl-cuda.api.nvcc

Source

nvcc.lisp.

Use List

common-lisp.

Used By List

• cl-cuda.api.context.
• cl-cuda.api.kernel-manager.

Public Interface

• *nvcc-binary* (special variable).
• *nvcc-options* (special variable).
• *tmp-path* (special variable).
• nvcc-compile (function).

Internals

• get-cu-path (function).
• get-include-path (function).
• get-nvcc-options (function).
• get-ptx-path (function).
• get-tmp-path (function).
• output-cuda-code (function).
• print-nvcc-command (function).
• run-nvcc-command (function).

---

5.17 cl-cuda.api.context

Source

context.lisp.

Use List

• cl-cuda.api.kernel-manager.
• cl-cuda.api.nvcc.
• cl-cuda.driver-api.
• common-lisp.

Public Interface

• *cuda-context* (special variable).
• *cuda-device* (special variable).
• *cuda-stream* (special variable).
• create-cuda-context (function).
• destroy-cuda-context (function).
• device-compute-capability (function).
• get-cuda-device (function).
• init-cuda (function).
• synchronize-context (function).
• with-cuda (macro).

Internals

• append-arch (function).
• arch-exists-p (function).
• get-nvcc-arch (function).

---

5.18 cl-cuda.lang

Source

lang.lisp.

Use List

• cl-reexport.
• common-lisp.

---

5.19 cl-cuda.api.macro

Source

macro.lisp.

Use List

• cl-cuda.api.defkernel.
• common-lisp.

---

5.20 cl-cuda.api

Source

api.lisp.

Use List

• cl-reexport.
• common-lisp.

---

5.21 cl-cuda.lang.kernel

Source

kernel.lisp.

Use List

• cl-cuda.lang.data.
• cl-cuda.lang.syntax.
• cl-cuda.lang.type.
• cl-cuda.lang.util.
• common-lisp.

Used By List

• cl-cuda.api.kernel-manager.
• cl-cuda.lang.compiler.compile-kernel.

Public Interface

• expand-macro (function).
• expand-macro-1 (function).
• kernel-define-function (function).
• kernel-define-global (function).
• kernel-define-macro (function).
• kernel-define-symbol-macro (function).
• kernel-function-argument-types (function).
• kernel-function-argument-vars (function).
• kernel-function-arguments (function).
• kernel-function-body (function).
• kernel-function-c-name (function).
• kernel-function-exists-p (function).
• kernel-function-name (function).
• kernel-function-names (function).
• kernel-function-return-type (function).
• kernel-global-c-name (function).
• kernel-global-exists-p (function).
• kernel-global-initializer (function).
• kernel-global-name (function).
• kernel-global-names (function).
• kernel-global-qualifiers (function).
• kernel-macro-arguments (function).
• kernel-macro-body (function).
• kernel-macro-exists-p (function).
• kernel-macro-expander (function).
• kernel-macro-name (function).
• kernel-macro-names (function).
• kernel-symbol-macro-exists-p (function).
• kernel-symbol-macro-expansion (function).
• kernel-symbol-macro-name (function).
• kernel-symbol-macro-names (function).
• make-kernel (function).

Internals

• %function (structure).
• %lookup-function (function).
• %lookup-global (function).
• %lookup-macro (function).
• %lookup-symbol-macro (function).
• %make-function (function).
• %make-global (function).
• %make-kernel (function).
• %make-macro (function).
• %make-symbol-macro (function).
• copy-%function (function).
• copy-global (function).
• copy-kernel (function).
• copy-macro (function).
• copy-symbol-macro (function).
• function-argument-types (function).
• function-argument-vars (function).
• function-arguments (reader).
• function-body (reader).
• function-c-name (function).
• function-name (reader).
• function-p (function).
• function-return-type (reader).
• global (structure).
• global-c-name (function).
• global-initializer (reader).
• global-name (reader).
• global-p (function).
• global-qualifiers (reader).
• kernel (structure).
• kernel-function-namespace (reader).
• (setf kernel-function-namespace) (writer).
• kernel-p (function).
• kernel-variable-namespace (reader).
• (setf kernel-variable-namespace) (writer).
• macro (structure).
• macro-arguments (reader).
• macro-body (reader).
• macro-expander (function).
• macro-name (reader).
• macro-p (function).
• make-function (function).
• make-global (function).
• make-macro (function).
• make-symbol-macro (function).
• symbol-macro (structure).
• symbol-macro-expansion (reader).
• symbol-macro-name (reader).
• symbol-macro-p (function).
• variable-qualifier (type).
• variable-qualifier-p (function).

---

5.22 cl-cuda.lang.util

Source

util.lisp.

Use List

common-lisp.

Used By List

• cl-cuda.lang.compiler.compile-data.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.
• cl-cuda.lang.environment.
• cl-cuda.lang.kernel.

Public Interface

• c-identifier (function).
• indent (function).
• lines (function).
• unlines (function).

Internals

%c-identifier (function).

---

5.23 cl-cuda

Source

cl-cuda.lisp.

Use List

• cl-reexport.
• common-lisp.

---

5.24 cl-cuda.api.kernel-manager

Source

kernel-manager.lisp.

Use List

• cl-cuda.api.nvcc.
• cl-cuda.driver-api.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.kernel.
• common-lisp.

Used By List

• cl-cuda.api.context.
• cl-cuda.api.defkernel.

Public Interface

• *kernel-manager* (special variable).
• ensure-kernel-function-loaded (function).
• ensure-kernel-global-loaded (function).
• ensure-kernel-module-compiled (function).
• ensure-kernel-module-loaded (function).
• expand-macro (function).
• expand-macro-1 (function).
• kernel-manager (structure).
• kernel-manager-compile-module (function).
• kernel-manager-compiled-p (function).
• kernel-manager-define-function (function).
• kernel-manager-define-global (function).
• kernel-manager-define-macro (function).
• kernel-manager-define-symbol-macro (function).
• kernel-manager-function-handle (function).
• kernel-manager-function-handles-empty-p (function).
• kernel-manager-global-device-ptr (function).
• kernel-manager-global-device-ptrs-empty-p (function).
• kernel-manager-global-qualifiers (function).
• kernel-manager-load-function (function).
• kernel-manager-load-global (function).
• kernel-manager-load-module (function).
• kernel-manager-module-handle (reader).
• (setf kernel-manager-module-handle) (writer).
• kernel-manager-unload (function).
• make-kernel-manager (function).

Internals

• %make-kernel-manager (function).
• copy-kernel-manager (function).
• function-modified-p (function).
• global-modified-p (function).
• kernel-manager-%function-handle (function).
• (setf kernel-manager-%function-handle) (function).
• kernel-manager-%function-handles (reader).
• (setf kernel-manager-%function-handles) (writer).
• kernel-manager-%global-device-ptr (function).
• (setf kernel-manager-%global-device-ptr) (function).
• kernel-manager-%global-device-ptrs (reader).
• (setf kernel-manager-%global-device-ptrs) (writer).
• kernel-manager-kernel (reader).
• (setf kernel-manager-kernel) (writer).
• kernel-manager-module-path (reader).
• (setf kernel-manager-module-path) (writer).
• kernel-manager-p (function).
• macro-modified-p (function).
• symbol-macro-modified-p (function).

---

5.25 cl-cuda.lang.type

Source

type.lisp.

Use List

• cl-cuda.driver-api.
• cl-cuda.lang.data.
• common-lisp.

Used By List

• cl-cuda.api.defkernel.
• cl-cuda.api.memory.
• cl-cuda.lang.built-in.
• cl-cuda.lang.compiler.compile-expression.
• cl-cuda.lang.compiler.compile-kernel.
• cl-cuda.lang.compiler.compile-statement.
• cl-cuda.lang.compiler.compile-type.
• cl-cuda.lang.compiler.type-of-expression.
• cl-cuda.lang.environment.
• cl-cuda.lang.kernel.
• cl-cuda.lang.syntax.

Public Interface

• array-type (function).
• array-type-base (function).
• array-type-dimension (function).
• array-type-p (function).
• cffi-type (function).
• cffi-type-size (function).
• cl-cuda-type (type).
• cl-cuda-type-p (function).
• cuda-type (function).
• scalar-type-p (function).
• structure-accessor-cuda-accessor (function).
• structure-accessor-p (function).
• structure-accessor-return-type (function).
• structure-from-accessor (function).
• structure-type-p (function).

Internals

• %structure-from-accessor (function).
• +accessor->structure+ (special variable).
• +array-type-regex+ (special variable).
• +scalar-types+ (special variable).
• +structure-table+ (special variable).
• +structure-types+ (special variable).
• array-cffi-type (function).
• array-cffi-type-size (function).
• array-cuda-type (function).
• array-type-stars (function).
• scalar-cffi-type (function).
• scalar-cffi-type-size (function).
• scalar-cuda-type (function).
• structure-accessors (function).
• structure-cffi-type (function).
• structure-cffi-type-size (function).
• structure-cuda-type (function).

---

6.1 Public Interface

• Constants
• Special variables
• Macros
• Ordinary functions
• Standalone methods
• Structures
• Types

---