This is the cl-cuda Reference Manual, version 0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 03:52:03 2024 GMT+0.
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
cl-cuda.api.timer
cl-cuda.lang.environment
cl-cuda.api.defkernel
cl-cuda.lang.compiler.compile-type
cl-cuda.lang.compiler.compile-data
cl-cuda.lang.syntax
cl-cuda.driver-api
cl-cuda.lang.compiler.type-of-expression
cl-cuda.lang.data
cl-cuda-asd
cl-cuda.lang.compiler.compile-kernel
cl-cuda.api.memory
cl-cuda.lang.compiler.compile-statement
cl-cuda.lang.built-in
cl-cuda.lang.compiler.compile-expression
cl-cuda.api.nvcc
cl-cuda.api.context
cl-cuda.lang
cl-cuda.api.macro
cl-cuda.api
cl-cuda.lang.kernel
cl-cuda.lang.util
cl-cuda
cl-cuda.api.kernel-manager
cl-cuda.lang.type
The main system appears first, followed by any subsystem dependency.
cl-cuda
Cl-cuda is a library to use NVIDIA CUDA in Common Lisp programs.
Masayuki Takagi
MIT
# 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.
0.1
cffi
(system).
alexandria
(system).
external-program
(system).
osicat
(system).
cl-pattern
(system).
split-sequence
(system).
cl-reexport
(system).
cl-ppcre
(system).
src
(module).
Modules are listed depth-first from the system components tree.
cl-cuda/src
cl-cuda
(system).
driver-api
(module).
lang
(module).
api
(module).
cl-cuda.lisp
(file).
cl-cuda/src/driver-api
src
(module).
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).
cl-cuda/src/lang
driver-api
(module).
src
(module).
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).
cl-cuda/src/api
lang
(module).
src
(module).
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).
Files are sorted by type and then listed depth-first from the systems components trees.
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
cl-cuda/cl-cuda.asd
cl-cuda
(system).
perform
(method).
cuda-grovel-file
(class).
cl-cuda/src/driver-api/get-error-string.lisp
package.lisp
(file).
driver-api
(module).
+error-strings+
(special variable).
get-error-string
(function).
cl-cuda/src/driver-api/cffi-grovel.lisp
get-error-string.lisp
(file).
driver-api
(module).
cl-cuda/src/driver-api/sdk-not-found.lisp
cffi-grovel.lisp
(file).
driver-api
(module).
*sdk-not-found*
(special variable).
sdk-not-found-error
(condition).
cl-cuda/src/driver-api/library.lisp
sdk-not-found.lisp
(file).
driver-api
(module).
cl-cuda/src/driver-api/type.lisp
library.lisp
(file).
driver-api
(module).
cl-cuda/src/driver-api/type-grovel.lisp
:cuda-sdk
type.lisp
(file).
driver-api
(module).
cl-cuda/src/driver-api/enum.lisp
type-grovel.lisp
(file).
type.lisp
(file).
driver-api
(module).
cu-event-blocking-sync
(constant).
cu-event-default
(constant).
cu-event-disable-timing
(constant).
cu-event-interprocess
(constant).
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).
cl-cuda/src/driver-api/function.lisp
enum.lisp
(file).
driver-api
(module).
*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-create
(function).
cu-event-destroy
(function).
cu-event-elapsed-time
(function).
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).
+cuda-success+
(special variable).
check-cuda-error
(function).
defcufun
(macro).
without-fp-traps
(macro).
cl-cuda/src/lang/util.lisp
lang
(module).
c-identifier
(function).
indent
(function).
lines
(function).
unlines
(function).
%c-identifier
(function).
cl-cuda/src/lang/data.lisp
util.lisp
(file).
lang
(module).
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).
translate-from-foreign
(method).
translate-from-foreign
(method).
translate-from-foreign
(method).
translate-into-foreign-memory
(method).
translate-into-foreign-memory
(method).
translate-into-foreign-memory
(method).
translate-into-foreign-memory
(method).
with-double3
(macro).
with-double4
(macro).
with-float3
(macro).
with-float4
(macro).
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).
cl-cuda/src/lang/type.lisp
data.lisp
(file).
lang
(module).
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).
%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).
cl-cuda/src/lang/syntax.lisp
type.lisp
(file).
lang
(module).
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).
+aritmetic-operators+
(special variable).
+constructor-operators+
(special variable).
cl-cuda/src/lang/environment.lisp
syntax.lisp
(file).
lang
(module).
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).
%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).
cl-cuda/src/lang/built-in.lisp
environment.lisp
(file).
lang
(module).
built-in-function-c-name
(function).
built-in-function-infix-p
(function).
built-in-function-return-type
(function).
+built-in-functions+
(special variable).
inferred-function
(function).
inferred-function-candidates
(function).
cl-cuda/src/lang/kernel.lisp
built-in.lisp
(file).
lang
(module).
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).
%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).
cl-cuda/src/lang/compiler/compile-data.lisp
kernel.lisp
(file).
lang
(module).
compile-bool
(function).
compile-double
(function).
compile-float
(function).
compile-int
(function).
compile-symbol
(function).
cl-cuda/src/lang/compiler/compile-type.lisp
compiler/compile-data.lisp
(file).
lang
(module).
compile-type
(function).
cl-cuda/src/lang/compiler/type-of-expression.lisp
compiler/compile-type.lisp
(file).
lang
(module).
type-of-expression
(function).
%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).
cl-cuda/src/lang/compiler/compile-expression.lisp
compiler/type-of-expression.lisp
(file).
lang
(module).
compile-expression
(function).
%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).
cl-cuda/src/lang/compiler/compile-statement.lisp
compiler/compile-expression.lisp
(file).
lang
(module).
compile-statement
(function).
%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).
cl-cuda/src/lang/compiler/compile-kernel.lisp
compiler/compile-statement.lisp
(file).
lang
(module).
compile-kernel
(function).
%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).
cl-cuda/src/lang/lang.lisp
compiler/compile-kernel.lisp
(file).
lang
(module).
cl-cuda/src/api/nvcc.lisp
api
(module).
*nvcc-binary*
(special variable).
*nvcc-options*
(special variable).
*tmp-path*
(special variable).
nvcc-compile
(function).
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).
cl-cuda/src/api/kernel-manager.lisp
nvcc.lisp
(file).
api
(module).
*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).
%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).
cl-cuda/src/api/memory.lisp
kernel-manager.lisp
(file).
api
(module).
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).
%make-memory-block
(function).
copy-memory-block
(function).
memcpy-device-to-host-async
(function).
memcpy-host-to-device-async
(function).
memory-block
(structure).
cl-cuda/src/api/context.lisp
memory.lisp
(file).
api
(module).
*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).
append-arch
(function).
arch-exists-p
(function).
get-nvcc-arch
(function).
cl-cuda/src/api/defkernel.lisp
context.lisp
(file).
api
(module).
defglobal
(macro).
defkernel
(macro).
defkernel-symbol-macro
(macro).
defkernelmacro
(macro).
expand-macro
(function).
expand-macro-1
(function).
global-ref
(function).
(setf global-ref)
(function).
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).
cl-cuda/src/api/macro.lisp
defkernel.lisp
(file).
api
(module).
cl-cuda/src/api/timer.lisp
macro.lisp
(file).
api
(module).
create-timer
(function).
destroy-timer
(function).
elapsed-time
(function).
start-timer
(function).
stop-timer
(function).
synchronize-timer
(function).
with-timer
(macro).
%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).
cl-cuda/src/api/api.lisp
timer.lisp
(file).
api
(module).
Packages are listed by definition order.
cl-cuda.api.timer
cl-cuda.lang.environment
cl-cuda.api.defkernel
cl-cuda.lang.compiler.compile-type
cl-cuda.lang.compiler.compile-data
cl-cuda.lang.syntax
cl-cuda.driver-api
cl-cuda.lang.compiler.type-of-expression
cl-cuda.lang.data
cl-cuda-asd
cl-cuda.lang.compiler.compile-kernel
cl-cuda.api.memory
cl-cuda.lang.compiler.compile-statement
cl-cuda.lang.built-in
cl-cuda.lang.compiler.compile-expression
cl-cuda.api.nvcc
cl-cuda.api.context
cl-cuda.lang
cl-cuda.api.macro
cl-cuda.api
cl-cuda.lang.kernel
cl-cuda.lang.util
cl-cuda
cl-cuda.api.kernel-manager
cl-cuda.lang.type
cl-cuda.api.timer
cl-cuda.driver-api
.
common-lisp
.
create-timer
(function).
destroy-timer
(function).
elapsed-time
(function).
start-timer
(function).
stop-timer
(function).
synchronize-timer
(function).
with-timer
(macro).
%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).
cl-cuda.lang.environment
cl-cuda.lang.data
.
cl-cuda.lang.type
.
cl-cuda.lang.util
.
common-lisp
.
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).
%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).
cl-cuda.api.defkernel
defglobal
(macro).
defkernel
(macro).
defkernel-symbol-macro
(macro).
defkernelmacro
(macro).
expand-macro
(function).
expand-macro-1
(function).
global-ref
(function).
(setf global-ref)
(function).
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).
cl-cuda.lang.compiler.compile-type
cl-cuda.lang.type
.
common-lisp
.
compile-type
(function).
cl-cuda.lang.compiler.compile-data
cl-cuda.lang.data
.
cl-cuda.lang.util
.
common-lisp
.
compile-bool
(function).
compile-double
(function).
compile-float
(function).
compile-int
(function).
compile-symbol
(function).
cl-cuda.lang.syntax
cl-cuda.lang.data
.
cl-cuda.lang.type
.
common-lisp
.
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).
+aritmetic-operators+
(special variable).
+constructor-operators+
(special variable).
cl-cuda.driver-api
common-lisp
.
*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).
+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).
cl-cuda.lang.compiler.type-of-expression
type-of-expression
(function).
%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).
cl-cuda.lang.data
common-lisp
.
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).
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).
cl-cuda-asd
asdf/interface
.
common-lisp
.
uiop/driver
.
cuda-grovel-file
(class).
cl-cuda.lang.compiler.compile-kernel
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
.
compile-kernel
(function).
%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).
cl-cuda.api.memory
cl-cuda.driver-api
.
cl-cuda.lang.type
.
common-lisp
.
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).
%make-memory-block
(function).
copy-memory-block
(function).
memcpy-device-to-host-async
(function).
memcpy-host-to-device-async
(function).
memory-block
(structure).
cl-cuda.lang.compiler.compile-statement
compile-statement
(function).
%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).
cl-cuda.lang.built-in
cl-cuda.lang.type
.
common-lisp
.
built-in-function-c-name
(function).
built-in-function-infix-p
(function).
built-in-function-return-type
(function).
+built-in-functions+
(special variable).
inferred-function
(function).
inferred-function-candidates
(function).
cl-cuda.lang.compiler.compile-expression
compile-expression
(function).
%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).
cl-cuda.api.nvcc
common-lisp
.
*nvcc-binary*
(special variable).
*nvcc-options*
(special variable).
*tmp-path*
(special variable).
nvcc-compile
(function).
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).
cl-cuda.api.context
cl-cuda.api.kernel-manager
.
cl-cuda.api.nvcc
.
cl-cuda.driver-api
.
common-lisp
.
*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).
append-arch
(function).
arch-exists-p
(function).
get-nvcc-arch
(function).
cl-cuda.lang.kernel
cl-cuda.lang.data
.
cl-cuda.lang.syntax
.
cl-cuda.lang.type
.
cl-cuda.lang.util
.
common-lisp
.
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).
%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).
cl-cuda.lang.util
common-lisp
.
c-identifier
(function).
indent
(function).
lines
(function).
unlines
(function).
%c-identifier
(function).
cl-cuda.api.kernel-manager
*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).
%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).
cl-cuda.lang.type
cl-cuda.driver-api
.
cl-cuda.lang.data
.
common-lisp
.
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
.
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).
%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).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Set this to an absolute path if your lisp doesn’t search PATH.
operation
) (c cuda-grovel-file
)) ¶asdf/action
.
structure-object
.
double-float
0.0d0
double-float
0.0d0
double-float
0.0d0
double-float
0.0d0
structure-object
.
single-float
0.0
single-float
0.0
single-float
0.0
single-float
0.0
structure-object
.
:name
This slot is read-only.
:return-type
This slot is read-only.
:argument-types
This slot is read-only.
structure-object
.
:name
This slot is read-only.
:return-type
This slot is read-only.
:arguments
This slot is read-only.
:body
This slot is read-only.
structure-object
.
:name
This slot is read-only.
common-lisp
.
:type
This slot is read-only.
:initializer
This slot is read-only.
structure-object
.
:device-ptr
This slot is read-only.
:host-ptr
This slot is read-only.
common-lisp
.
:type
This slot is read-only.
:size
This slot is read-only.
grovel-file
.
foreign-struct-type
.
translatable-foreign-type
.
foreign-struct-type
.
translatable-foreign-type
.
foreign-struct-type
.
translatable-foreign-type
.
foreign-struct-type
.
translatable-foreign-type
.
foreign-struct-type
.
translatable-foreign-type
.
Jump to: | %
(
A B C D E F G H I K L M N O P R S T U V W |
---|