The cl-cuda Reference Manual

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

The cl-cuda Reference Manual

This is the cl-cuda Reference Manual, version 0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 03:34:25 2022 GMT+0.

Table of Contents


1 Introduction

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 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 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.

(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:

Verification environments

Cl-cuda is verified to work in following environments:

Environment 1

Environment2

Environment3 (Thanks to Viktor Cerovski)

Environment4 (Thanks to wvxvw)

Further information:

Environment5 (Thanks to Atabey Kaygun)

Environment6 (Thanks to @gos-k)

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-forms to them and execute a series of statements 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 statements that use these rules. In cl-cuda's compilation process, the symbol macros found in a form are replaces by corresponding expansions.

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 statements 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 statements while test-form holds. do accepts an arbitrary number of iteration vars and their initial values are supplied by init-forms. step-forms supply how the vars 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 statements 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 statements, 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:

(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

Copyright

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

License

Licensed under the MIT License.


2 Systems

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


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

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 Modules

Modules are listed depth-first from the system components tree.


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

3.1 cl-cuda/src

Source

cl-cuda.asd.

Parent Component

cl-cuda (system).

Child Components

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

3.2 cl-cuda/src/driver-api

Source

cl-cuda.asd.

Parent Component

src (module).

Child Components

3.3 cl-cuda/src/lang

Dependency

driver-api (module).

Source

cl-cuda.asd.

Parent Component

src (module).

Child Components

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

3.4 cl-cuda/src/api

Dependency

lang (module).

Source

cl-cuda.asd.

Parent Component

src (module).

Child Components

4 Files

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


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

4.1 Lisp


4.1.1 cl-cuda/cl-cuda.asd

Source

cl-cuda.asd.

Parent Component

cl-cuda (system).

ASDF Systems

cl-cuda.

Packages

cl-cuda-asd.

Public Interface

perform (method).

Internals

cuda-grovel-file (class).


4.1.2 cl-cuda/src/driver-api/package.lisp

Source

cl-cuda.asd.

Parent Component

driver-api (module).

Packages

cl-cuda.driver-api.


4.1.3 cl-cuda/src/driver-api/get-error-string.lisp

Dependency

package.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).

Internals

4.1.4 cl-cuda/src/driver-api/cffi-grovel.lisp

Dependency

get-error-string.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).


4.1.5 cl-cuda/src/driver-api/sdk-not-found.lisp

Dependency

cffi-grovel.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).

Public Interface

*sdk-not-found* (special variable).

Internals

sdk-not-found-error (condition).


4.1.6 cl-cuda/src/driver-api/library.lisp

Dependency

sdk-not-found.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).


4.1.7 cl-cuda/src/driver-api/type.lisp

Dependency

library.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).


4.1.8 cl-cuda/src/driver-api/type-grovel.lisp

If Feature

:cuda-sdk

Dependency

type.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).


4.1.9 cl-cuda/src/driver-api/enum.lisp

Dependencies
Source

cl-cuda.asd.

Parent Component

driver-api (module).

Public Interface
Internals

4.1.10 cl-cuda/src/driver-api/function.lisp

Dependency

enum.lisp (file).

Source

cl-cuda.asd.

Parent Component

driver-api (module).

Public Interface
Internals

4.1.11 cl-cuda/src/lang/util.lisp

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.util.

Public Interface
Internals

%c-identifier (function).


4.1.12 cl-cuda/src/lang/data.lisp

Dependency

util.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.data.

Public Interface
Internals

4.1.13 cl-cuda/src/lang/type.lisp

Dependency

data.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.type.

Public Interface
Internals

4.1.14 cl-cuda/src/lang/syntax.lisp

Dependency

type.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.syntax.

Public Interface
Internals

4.1.15 cl-cuda/src/lang/environment.lisp

Dependency

syntax.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.environment.

Public Interface
Internals

4.1.16 cl-cuda/src/lang/built-in.lisp

Dependency

environment.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.built-in.

Public Interface
Internals

4.1.17 cl-cuda/src/lang/kernel.lisp

Dependency

built-in.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.kernel.

Public Interface
Internals

4.1.18 cl-cuda/src/lang/compiler/compile-data.lisp

Dependency

kernel.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

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

Public Interface

4.1.19 cl-cuda/src/lang/compiler/compile-type.lisp

Dependency

compiler/compile-data.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

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

Public Interface

compile-type (function).


4.1.20 cl-cuda/src/lang/compiler/type-of-expression.lisp

Dependency

compiler/compile-type.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

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

Public Interface

type-of-expression (function).

Internals

4.1.21 cl-cuda/src/lang/compiler/compile-expression.lisp

Dependency

compiler/type-of-expression.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

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

Public Interface

compile-expression (function).

Internals

4.1.22 cl-cuda/src/lang/compiler/compile-statement.lisp

Dependency

compiler/compile-expression.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

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

Public Interface

compile-statement (function).

Internals

4.1.23 cl-cuda/src/lang/compiler/compile-kernel.lisp

Dependency

compiler/compile-statement.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

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

Public Interface

compile-kernel (function).

Internals

4.1.24 cl-cuda/src/lang/lang.lisp

Dependency

compiler/compile-kernel.lisp (file).

Source

cl-cuda.asd.

Parent Component

lang (module).

Packages

cl-cuda.lang.


4.1.25 cl-cuda/src/api/nvcc.lisp

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.nvcc.

Public Interface
Internals

4.1.26 cl-cuda/src/api/kernel-manager.lisp

Dependency

nvcc.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.kernel-manager.

Public Interface
Internals

4.1.27 cl-cuda/src/api/memory.lisp

Dependency

kernel-manager.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.memory.

Public Interface
Internals

4.1.28 cl-cuda/src/api/context.lisp

Dependency

memory.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.context.

Public Interface
Internals

4.1.29 cl-cuda/src/api/defkernel.lisp

Dependency

context.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.defkernel.

Public Interface
Internals

4.1.30 cl-cuda/src/api/macro.lisp

Dependency

defkernel.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.macro.


4.1.31 cl-cuda/src/api/timer.lisp

Dependency

macro.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.timer.

Public Interface
Internals

4.1.32 cl-cuda/src/api/api.lisp

Dependency

timer.lisp (file).

Source

cl-cuda.asd.

Parent Component

api (module).

Packages

cl-cuda.api.


4.1.33 cl-cuda/src/cl-cuda.lisp

Dependency

api (module).

Source

cl-cuda.asd.

Parent Component

src (module).

Packages

cl-cuda.


5 Packages

Packages are listed by definition order.


5.1 cl-cuda

Source

cl-cuda.lisp.

Use List
  • cl-reexport.
  • common-lisp.

5.3 cl-cuda.lang.kernel

Source

kernel.lisp.

Use List
Used By List
Public Interface
Internals

5.4 cl-cuda.lang.type

Source

type.lisp.

Use List
Used By List
Public Interface
Internals

5.5 cl-cuda.lang

Source

lang.lisp.

Use List
  • cl-reexport.
  • common-lisp.

5.6 cl-cuda.lang.data

Source

data.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

5.7 cl-cuda.api.defkernel

Source

defkernel.lisp.

Use List
Used By List

cl-cuda.api.macro.

Public Interface
Internals

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

Source

compiler/compile-type.lisp.

Use List
Used By List
Public Interface

compile-type (function).


5.9 cl-cuda.api.memory

Source

memory.lisp.

Use List
Used By List

cl-cuda.api.defkernel.

Public Interface
Internals

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

5.10 cl-cuda.lang.built-in

Source

built-in.lisp.

Use List
Used By List
Public Interface
Internals

5.11 cl-cuda.api

Source

api.lisp.

Use List
  • cl-reexport.
  • common-lisp.

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

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

Source

compiler/compile-data.lisp.

Use List
Used By List
Public Interface

5.13 cl-cuda.api.nvcc

Source

nvcc.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

5.14 cl-cuda.api.timer

Source

timer.lisp.

Use List
Public Interface
Internals

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

Source

compiler/compile-statement.lisp.

Use List
Used By List

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

Public Interface

compile-statement (function).

Internals

5.16 cl-cuda.lang.util

Source

util.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

%c-identifier (function).


5.17 cl-cuda.lang.syntax

Source

syntax.lisp.

Use List
Used By List
Public Interface
Internals

5.18 cl-cuda.driver-api

Source

package.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

5.20 cl-cuda-asd

Source

cl-cuda.asd.

Use List
  • asdf/interface.
  • common-lisp.
  • uiop/driver.
Internals

cuda-grovel-file (class).


5.21 cl-cuda.api.macro

Source

macro.lisp.

Use List

5.23 cl-cuda.api.kernel-manager

Source

kernel-manager.lisp.

Use List
Used By List
Public Interface
Internals

5.24 cl-cuda.lang.environment

Source

environment.lisp.

Use List
Used By List
Public Interface
Internals

5.25 cl-cuda.api.context

Source

context.lisp.

Use List
Public Interface
Internals

6 Definitions

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


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

6.1 Public Interface


6.1.1 Constants

Constant: cu-event-blocking-sync
Package

cl-cuda.driver-api.

Source

enum.lisp.

Constant: cu-event-default
Package

cl-cuda.driver-api.

Source

enum.lisp.

Constant: cu-event-disable-timing
Package

cl-cuda.driver-api.

Source

enum.lisp.

Constant: cu-event-interprocess
Package

cl-cuda.driver-api.

Source

enum.lisp.


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

6.1.2 Special variables

Special Variable: *cuda-context*
Package

cl-cuda.api.context.

Source

context.lisp.

Special Variable: *cuda-device*
Package

cl-cuda.api.context.

Source

context.lisp.

Special Variable: *cuda-stream*
Package

cl-cuda.api.context.

Source

context.lisp.

Special Variable: *kernel-manager*
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Special Variable: *nvcc-binary*

Set this to an absolute path if your lisp doesn’t search PATH.

Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Special Variable: *nvcc-options*
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Special Variable: *sdk-not-found*
Package

cl-cuda.driver-api.

Source

sdk-not-found.lisp.

Special Variable: *show-messages*
Package

cl-cuda.driver-api.

Source

function.lisp.

Special Variable: *tmp-path*
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.


6.1.3 Macros

Macro: defglobal (name expression &optional qualifiers)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Macro: defkernel (name (return-type arguments) &body body)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Macro: defkernel-symbol-macro (name expansion)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Macro: defkernelmacro (name arguments &body body)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Macro: with-cuda ((dev-id) &body body)
Package

cl-cuda.api.context.

Source

context.lisp.

Macro: with-device-memory ((var type n) &body body)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Macro: with-double3 ((x y z) value &body body)
Package

cl-cuda.lang.data.

Source

data.lisp.

Macro: with-double4 ((x y z w) value &body body)
Package

cl-cuda.lang.data.

Source

data.lisp.

Macro: with-float3 ((x y z) value &body body)
Package

cl-cuda.lang.data.

Source

data.lisp.

Macro: with-float4 ((x y z w) value &body body)
Package

cl-cuda.lang.data.

Source

data.lisp.

Macro: with-host-memory ((var type n) &body body)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Macro: with-memory-block ((var type size) &body body)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Macro: with-memory-blocks (bindings &body body)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Macro: with-timer ((var) &body body)
Package

cl-cuda.api.timer.

Source

timer.lisp.


6.1.4 Ordinary functions

Function: alloc-device-memory (type n)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: alloc-host-memory (type n)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: alloc-memory-block (type size)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: argument-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: argument-type (argument)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: argument-var (argument)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: arithmetic-operands (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: arithmetic-operator (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: arithmetic-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: array-reference-expr (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: array-reference-indices (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: array-reference-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: array-type (type dimension)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: array-type-base (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: array-type-dimension (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: array-type-p (object)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: block-dim-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: block-idx-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: bool-literal-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: built-in-function-c-name (name argument-types)
Package

cl-cuda.lang.built-in.

Source

built-in.lisp.

Function: built-in-function-infix-p (name argument-types)
Package

cl-cuda.lang.built-in.

Source

built-in.lisp.

Function: built-in-function-return-type (name argument-types)
Package

cl-cuda.lang.built-in.

Source

built-in.lisp.

Function: c-identifier (symbol &optional package-p)
Package

cl-cuda.lang.util.

Source

util.lisp.

Function: cffi-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: cffi-type-size (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: cl-cuda-bool-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: cl-cuda-double-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: cl-cuda-float-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: cl-cuda-int-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: cl-cuda-symbol-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: cl-cuda-type-p (object)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: compile-bool (expr)
Package

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

Source

compiler/compile-data.lisp.

Function: compile-double (expr)
Package

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

Source

compiler/compile-data.lisp.

Function: compile-expression (form var-env func-env &optional initializer-p)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-float (expr)
Package

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

Source

compiler/compile-data.lisp.

Function: compile-int (expr)
Package

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

Source

compiler/compile-data.lisp.

Function: compile-kernel (kernel)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-statement (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-symbol (expr)
Package

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

Source

compiler/compile-data.lisp.

Function: compile-type (type)
Package

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

Source

compiler/compile-type.lisp.

Function: constructor-operands (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: constructor-operator (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: constructor-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: create-cuda-context (device)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: create-timer ()
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: cu-ctx-create (pctx flags dev)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-ctx-destroy (ctx)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-ctx-synchronize ()
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-device-compute-capability (major minor dev)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-device-get (device ordinal)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-device-get-count (count)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-device-get-name (name len dev)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-device-total-mem (bytes dev)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-event-create (phevent flags)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-event-destroy (h-event)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-event-elapsed-time (pmilliseconds hstart hend)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-event-record (hevent hstream)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-event-synchronize (hevent)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-init (flags)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-launch-kernel (f grid-dim-x grid-dim-y grid-dim-z block-dim-x block-dim-y block-dim-z shared-mem-bytes hstream kernel-params extra)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-mem-alloc (dptr bytesize)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-mem-free (dptr)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-mem-host-register (p byte-size flags)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-mem-host-unregister (p)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-memcpy-device-to-host (dst-host src-device byte-count)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-memcpy-device-to-host-async (dst-host src-device byte-count hstream)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-memcpy-host-to-device (dst-device src-host byte-count)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-memcpy-host-to-device-async (dst-device src-host byte-count hstream)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-module-get-function (hfunc hmod name)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-module-get-global (dptr bytes hmod name)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-module-load (module fname)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-module-unload (module)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-stream-create (phstream flags)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-stream-destroy (hstream)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-stream-query (hstream)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-stream-synchronize (hstream)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cu-stream-wait-event (hstream hevent flags)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: cuda-dimension-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: cuda-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: destroy-cuda-context (context)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: destroy-timer (timer)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: device-compute-capability (device)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: device-total-bytes (device)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: device-total-gbytes (device)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: device-total-kbytes (device)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: device-total-mbytes (device)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: do-binding-init (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-binding-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-binding-step (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-binding-var (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-bindings (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-end-test (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: do-statements (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: double-literal-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: double3-= (a b)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: double3-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Reader: double3-x (instance)
Writer: (setf double3-x) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

x.

Reader: double3-y (instance)
Writer: (setf double3-y) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

y.

Reader: double3-z (instance)
Writer: (setf double3-z) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

z.

Function: double4-= (a b)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: double4-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Reader: double4-w (instance)
Writer: (setf double4-w) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

w.

Reader: double4-x (instance)
Writer: (setf double4-x) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

x.

Reader: double4-y (instance)
Writer: (setf double4-y) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

y.

Reader: double4-z (instance)
Writer: (setf double4-z) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

z.

Function: elapsed-time (timer)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: empty-function-environment ()
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: empty-variable-environment ()
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: ensure-kernel-function-loaded (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: ensure-kernel-global-loaded (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: ensure-kernel-module-compiled (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: ensure-kernel-module-loaded (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: expand-macro (form kernel)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: expand-macro (form)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: expand-macro (form manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: expand-macro-1 (form kernel)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: expand-macro-1 (form)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: expand-macro-1 (form manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: float-literal-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: float3-= (a b)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: float3-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Reader: float3-x (instance)
Writer: (setf float3-x) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

x.

Reader: float3-y (instance)
Writer: (setf float3-y) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

y.

Reader: float3-z (instance)
Writer: (setf float3-z) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

z.

Function: float4-= (a b)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: float4-p (object)
Package

cl-cuda.lang.data.

Source

data.lisp.

Reader: float4-w (instance)
Writer: (setf float4-w) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

w.

Reader: float4-x (instance)
Writer: (setf float4-x) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

x.

Reader: float4-y (instance)
Writer: (setf float4-y) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

y.

Reader: float4-z (instance)
Writer: (setf float4-z) (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Target Slot

z.

Function: free-device-memory (device-ptr)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: free-host-memory (host-ptr)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: free-memory-block (memory-block)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: function-environment-add-function (name return-type argument-types func-env)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-add-macro (name arguments body func-env)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-function-argument-types (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-function-c-name (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-function-exists-p (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-function-name (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-function-return-type (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-macro-exists-p (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-macro-expander (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-environment-macro-name (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-operands (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: function-operator (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: function-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: get-cuda-device (dev-id)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: global-ref (name type &optional manager)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: (setf global-ref) (name type &optional manager)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: grid-dim-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: host-memory-aref (host-ptr type index)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: (setf host-memory-aref) (host-ptr type index)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: if-else-statement (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: if-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: if-test-expression (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: if-then-statement (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: indent (n str)
Package

cl-cuda.lang.util.

Source

util.lisp.

Function: init-cuda ()
Package

cl-cuda.api.context.

Source

context.lisp.

Function: inline-if-else-expression (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: inline-if-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: inline-if-test-expression (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: inline-if-then-expression (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: int-literal-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: kernel-define-function (kernel name return-type arguments body)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-define-global (kernel name qualifiers expression)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-define-macro (kernel name arguments body)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-define-symbol-macro (kernel name expansion)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-argument-types (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-argument-vars (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-arguments (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-body (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-c-name (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-exists-p (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-name (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-names (kernel)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-function-return-type (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-global-c-name (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-global-exists-p (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-global-initializer (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-global-name (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-global-names (kernel)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-global-qualifiers (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-macro-arguments (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-macro-body (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-macro-exists-p (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-macro-expander (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-macro-name (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-macro-names (kernel)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-manager-compile-module (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-compiled-p (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-define-function (manager name return-type arguments body)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-define-global (manager name qualifiers &optional expression)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-define-macro (manager name arguments body)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-define-symbol-macro (manager name expansion)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-function-handle (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-function-handles-empty-p (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-global-device-ptr (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-global-device-ptrs-empty-p (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-global-qualifiers (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-load-function (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-load-global (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-manager-load-module (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: kernel-manager-module-handle (instance)
Writer: (setf kernel-manager-module-handle) (instance)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Target Slot

module-handle.

Function: kernel-manager-unload (manager)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-symbol-macro-exists-p (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-symbol-macro-expansion (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-symbol-macro-name (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: kernel-symbol-macro-names (kernel)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: let-binding-expr (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: let-binding-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: let-binding-var (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: let-bindings (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: let-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: let-statements (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: lines (str)
Package

cl-cuda.lang.util.

Source

util.lisp.

Function: literal-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macro-operands (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macro-operator (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macro-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-binding-arguments (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-binding-body (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-binding-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-binding-symbol (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-bindings (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: macrolet-statements (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: make-double3 (x y z)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: make-double4 (x y z w)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: make-float3 (x y z)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: make-float4 (x y z w)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: make-kernel ()
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: make-kernel-manager ()
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: memcpy-device-to-host (host-ptr device-ptr type n)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: memcpy-host-to-device (device-ptr host-ptr type n)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: memory-block-aref (memory-block index)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: (setf memory-block-aref) (memory-block index)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Reader: memory-block-device-ptr (instance)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Target Slot

device-ptr.

Reader: memory-block-host-ptr (instance)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Target Slot

host-ptr.

Function: memory-block-p (object)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Reader: memory-block-size (instance)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Target Slot

size.

Reader: memory-block-type (instance)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Target Slot

type.

Function: nvcc-compile (cuda-code)
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: progn-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: progn-statements (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: reference-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: return-expr (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: return-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: scalar-type-p (object)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: set-expression (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: set-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: set-reference (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: start-timer (timer)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: stop-timer (timer)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: structure-accessor-cuda-accessor (accessor)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-accessor-p (accessor)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-accessor-return-type (accessor)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-from-accessor (accessor)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-reference-accessor (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: structure-reference-expr (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: structure-reference-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: structure-type-p (object)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: symbol-macro-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: symbol-macrolet-binding-expansion (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: symbol-macrolet-binding-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: symbol-macrolet-binding-symbol (binding)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: symbol-macrolet-bindings (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: symbol-macrolet-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: symbol-macrolet-statements (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: sync-memory-block (memory-block direction)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: synchronize-context ()
Package

cl-cuda.api.context.

Source

context.lisp.

Function: synchronize-timer (timer)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: thread-idx-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: type-of-expression (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: unlines (&rest args)
Package

cl-cuda.lang.util.

Source

util.lisp.

Function: variable-environment-add-global (name type expression var-env)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-add-symbol-macro (name expansion var-env)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-add-variable (name type var-env)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-global-c-name (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-global-exists-p (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-global-initializer (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-global-name (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-global-type (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-symbol-macro-exists-p (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-symbol-macro-expansion (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-symbol-macro-name (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-variable-exists-p (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-variable-name (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-environment-variable-type (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-reference-p (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-spec-dimensions (spec)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-spec-p (object)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-spec-type (spec)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-spec-var (spec)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-specs (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Function: with-shared-memory-statements (form)
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.


6.1.5 Standalone methods

Method: perform :around ((o operation) (c cuda-grovel-file))
Package

asdf/action.

Source

cl-cuda.asd.

Method: translate-from-foreign (value (type double3-c))
Package

cffi.

Source

data.lisp.

Method: translate-from-foreign (value (type float4-c))
Package

cffi.

Source

data.lisp.

Method: translate-from-foreign (value (type float3-c))
Package

cffi.

Source

data.lisp.

Method: translate-into-foreign-memory ((value float4) (type float4-c) ptr)
Package

cffi.

Source

data.lisp.

Method: translate-into-foreign-memory ((value float3) (type float3-c) ptr)
Package

cffi.

Source

data.lisp.

Method: translate-into-foreign-memory ((value double4) (type double4-c) ptr)
Package

cffi.

Source

data.lisp.

Method: translate-into-foreign-memory ((value double3) (type double3-c) ptr)
Package

cffi.

Source

data.lisp.


6.1.6 Structures

Structure: double3
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses

structure-object.

Direct methods

translate-into-foreign-memory.

Direct slots
Slot: x
Type

double-float

Initform

0.0d0

Readers

double3-x.

Writers

(setf double3-x).

Slot: y
Type

double-float

Initform

0.0d0

Readers

double3-y.

Writers

(setf double3-y).

Slot: z
Type

double-float

Initform

0.0d0

Readers

double3-z.

Writers

(setf double3-z).

Structure: double4
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses

structure-object.

Direct methods

translate-into-foreign-memory.

Direct slots
Slot: x
Type

double-float

Initform

0.0d0

Readers

double4-x.

Writers

(setf double4-x).

Slot: y
Type

double-float

Initform

0.0d0

Readers

double4-y.

Writers

(setf double4-y).

Slot: z
Type

double-float

Initform

0.0d0

Readers

double4-z.

Writers

(setf double4-z).

Slot: w
Type

double-float

Initform

0.0d0

Readers

double4-w.

Writers

(setf double4-w).

Structure: float3
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses

structure-object.

Direct methods

translate-into-foreign-memory.

Direct slots
Slot: x
Type

single-float

Initform

0.0

Readers

float3-x.

Writers

(setf float3-x).

Slot: y
Type

single-float

Initform

0.0

Readers

float3-y.

Writers

(setf float3-y).

Slot: z
Type

single-float

Initform

0.0

Readers

float3-z.

Writers

(setf float3-z).

Structure: float4
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses

structure-object.

Direct methods

translate-into-foreign-memory.

Direct slots
Slot: x
Type

single-float

Initform

0.0

Readers

float4-x.

Writers

(setf float4-x).

Slot: y
Type

single-float

Initform

0.0

Readers

float4-y.

Writers

(setf float4-y).

Slot: z
Type

single-float

Initform

0.0

Readers

float4-z.

Writers

(setf float4-z).

Slot: w
Type

single-float

Initform

0.0

Readers

float4-w.

Writers

(setf float4-w).

Structure: kernel-manager
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: module-path
Readers

kernel-manager-module-path.

Writers

(setf kernel-manager-module-path).

Slot: module-handle
Readers

kernel-manager-module-handle.

Writers

(setf kernel-manager-module-handle).

Slot: %function-handles
Readers

kernel-manager-%function-handles.

Writers

(setf kernel-manager-%function-handles).

Slot: %global-device-ptrs
Readers

kernel-manager-%global-device-ptrs.

Writers

(setf kernel-manager-%global-device-ptrs).

Slot: kernel
Readers

kernel-manager-kernel.

Writers

(setf kernel-manager-kernel).


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

6.1.7 Types

Type: argument ()
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Type: cl-cuda-symbol ()
Package

cl-cuda.lang.data.

Source

data.lisp.

Type: cl-cuda-type ()
Package

cl-cuda.lang.type.

Source

type.lisp.


6.2 Internals


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

6.2.1 Constants

Constant: cu-mem-host-register-devicemap
Package

cl-cuda.driver-api.

Source

enum.lisp.

Constant: cu-mem-host-register-portable
Package

cl-cuda.driver-api.

Source

enum.lisp.

Constant: cu-stream-default
Package

cl-cuda.driver-api.

Source

enum.lisp.

Constant: cu-stream-non-blocking
Package

cl-cuda.driver-api.

Source

enum.lisp.


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

6.2.2 Special variables

Special Variable: +accessor->structure+
Package

cl-cuda.lang.type.

Source

type.lisp.

Special Variable: +aritmetic-operators+
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Special Variable: +array-type-regex+
Package

cl-cuda.lang.type.

Source

type.lisp.

Special Variable: +built-in-functions+
Package

cl-cuda.lang.built-in.

Source

built-in.lisp.

Special Variable: +constructor-operators+
Package

cl-cuda.lang.syntax.

Source

syntax.lisp.

Special Variable: +cuda-success+
Package

cl-cuda.driver-api.

Source

function.lisp.

Special Variable: +error-strings+
Package

cl-cuda.driver-api.

Source

get-error-string.lisp.

Special Variable: +scalar-types+
Package

cl-cuda.lang.type.

Source

type.lisp.

Special Variable: +structure-table+
Package

cl-cuda.lang.type.

Source

type.lisp.

Special Variable: +structure-types+
Package

cl-cuda.lang.type.

Source

type.lisp.


6.2.3 Macros

Macro: defcuenum (name-and-options &body enum-list)
Package

cl-cuda.driver-api.

Source

enum.lisp.

Macro: defcufun ((name c-name &key disable-fp-traps) return-type &rest arguments)
Package

cl-cuda.driver-api.

Source

function.lisp.

Macro: with-launching-arguments ((var arguments) &body body)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Macro: without-fp-traps (() &body body)
Package

cl-cuda.driver-api.

Source

function.lisp.


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

6.2.4 Ordinary functions

Function: %add-function-arguments (kernel name var-env)
Package

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

Source

compiler/compile-kernel.lisp.

Function: %add-functions (kernel func-env)
Package

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

Source

compiler/compile-kernel.lisp.

Function: %add-globals (kernel var-env)
Package

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

Source

compiler/compile-kernel.lisp.

Function: %add-macros (kernel func-env)
Package

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

Source

compiler/compile-kernel.lisp.

Function: %add-symbol-macros (kernel var-env)
Package

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

Source

compiler/compile-kernel.lisp.

Function: %c-identifier (object)
Package

cl-cuda.lang.util.

Source

util.lisp.

Function: %elapsed-time (start stop)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: %lookup-function (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %lookup-function (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %lookup-global (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %lookup-global (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %lookup-macro (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %lookup-macro (func-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %lookup-symbol-macro (kernel name)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %lookup-symbol-macro (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %lookup-variable (var-env name)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %macro-p (form func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: %macro-p (form func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: %macro-p (form func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: %make-function (&key name return-type arguments body)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %make-function (&key name return-type argument-types)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %make-global (&key name qualifiers initializer)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %make-global (&key name type initializer)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %make-kernel (&key variable-namespace function-namespace)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %make-kernel-manager (&key module-path module-handle %function-handles %global-device-ptrs kernel)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: %make-macro (&key name arguments body)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %make-macro (&key name arguments body)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %make-memory-block (&key device-ptr host-ptr type size)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: %make-symbol-macro (&key name expansion)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: %make-symbol-macro (&key name expansion)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %make-timer (&key start-event stop-event)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: %make-variable (&key name type)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: %structure-from-accessor (accessor)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: %symbol-macro-p (form var-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: %symbol-macro-p (form var-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: append-arch (options dev-id)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: arch-exists-p (options)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: argument-cffi-type (argument)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: argument-var-ptr (argument)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: argument-vars (arguments)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: array-cffi-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: array-cffi-type-size (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: array-cuda-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: array-type-stars (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: check-cuda-error (name return-code)
Package

cl-cuda.driver-api.

Source

function.lisp.

Function: compile-argument (argument)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-arguments (arguments)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-arithmetic (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-array-indices (indices var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-array-reference (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-bool-literal (form)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-built-in-function (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-built-in-infix-function (operator operands operand-types var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-built-in-prefix-function (operator operands operand-types var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-constructor (form var-env func-env initializer-p)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-cuda-dimension (form)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-declaration (kernel name)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-definition (kernel name)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-definitions (kernel)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-do (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-do-init-part (bindings var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-do-statements (statements var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-do-step-part (bindings var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-do-test-part (end-test var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-double-literal (form)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-float-literal (form)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-function (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-function (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-global (kernel name)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-globals (kernel)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-if (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-includes ()
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-inline-if (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-int-literal (form)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-let (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-let-bindings (bindings var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-let-statements (statements var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-literal (form)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-macro (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-macro (form var-env func-env initializer-p)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-macrolet (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-macrolet-statements (statements var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-operands (operands var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-progn (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-prototype (kernel name)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-prototypes (kernel)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-reference (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-return (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-set (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-specifier (return-type)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-statements (kernel name)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-structure-reference (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-symbol-macro (form var-env func-env initializer-p)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-symbol-macrolet (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-symbol-macrolet-statements (statements var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-user-defined-function (form var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-variable-qualifier (qualifier)
Package

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

Source

compiler/compile-kernel.lisp.

Function: compile-variable-reference (form var-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: compile-with-shared-memory (form var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-with-shared-memory-spec-dimensions (dims var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-with-shared-memory-specs (specs var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: compile-with-shared-memory-statements (statements var-env func-env)
Package

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

Source

compiler/compile-statement.lisp.

Function: copy-%function (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: copy-%function (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: copy-double3 (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: copy-double4 (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: copy-float3 (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: copy-float4 (instance)
Package

cl-cuda.lang.data.

Source

data.lisp.

Function: copy-global (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: copy-global (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: copy-kernel (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: copy-kernel-manager (instance)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: copy-macro (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: copy-macro (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: copy-memory-block (instance)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: copy-symbol-macro (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: copy-symbol-macro (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: copy-timer (instance)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: copy-variable (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: create-cu-event ()
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: defconstant-enum-value (name enum-elem)
Package

cl-cuda.driver-api.

Source

enum.lisp.

Function: destroy-cu-event (cu-event)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: func-env-add-macrolet-bindings (func-env bindings)
Package

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

Source

compiler/compile-statement.lisp.

Function: function-argument-types (function)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Reader: function-argument-types (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

argument-types.

Function: function-argument-vars (function)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Reader: function-arguments (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

arguments.

Reader: function-body (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

body.

Function: function-c-name (function)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: function-c-name (function)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: function-modified-p (kernel name return-type arguments body)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: function-name (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

name.

Reader: function-name (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

name.

Function: function-p (object)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: function-p (object)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Reader: function-return-type (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

return-type.

Reader: function-return-type (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

return-type.

Function: get-cu-path ()
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: get-error-string (n)
Package

cl-cuda.driver-api.

Source

get-error-string.lisp.

Function: get-include-path ()
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: get-nvcc-arch (dev-id)
Package

cl-cuda.api.context.

Source

context.lisp.

Function: get-nvcc-options (cu-path ptx-path)
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: get-ptx-path (cu-path)
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: get-tmp-path ()
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: global-c-name (global)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: global-c-name (global)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Reader: global-initializer (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

initializer.

Reader: global-initializer (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

initializer.

Function: global-modified-p (kernel name qualifiers expression)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: global-name (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

name.

Reader: global-name (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

name.

Function: global-p (object)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: global-p (object)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Reader: global-qualifiers (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

qualifiers.

Reader: global-type (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

type.

Function: inferred-function (name argument-types)
Package

cl-cuda.lang.built-in.

Source

built-in.lisp.

Function: inferred-function-candidates (name)
Package

cl-cuda.lang.built-in.

Source

built-in.lisp.

Function: kernel->function-environment (kernel)
Package

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

Source

compiler/compile-kernel.lisp.

Function: kernel->variable-environment (kernel name)
Package

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

Source

compiler/compile-kernel.lisp.

Reader: kernel-function-namespace (instance)
Writer: (setf kernel-function-namespace) (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

function-namespace.

Function: kernel-manager-%function-handle (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: (setf kernel-manager-%function-handle) (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: kernel-manager-%function-handles (instance)
Writer: (setf kernel-manager-%function-handles) (instance)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Target Slot

%function-handles.

Function: kernel-manager-%global-device-ptr (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: (setf kernel-manager-%global-device-ptr) (manager name)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: kernel-manager-%global-device-ptrs (instance)
Writer: (setf kernel-manager-%global-device-ptrs) (instance)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Target Slot

%global-device-ptrs.

Reader: kernel-manager-kernel (instance)
Writer: (setf kernel-manager-kernel) (instance)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Target Slot

kernel.

Reader: kernel-manager-module-path (instance)
Writer: (setf kernel-manager-module-path) (instance)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Target Slot

module-path.

Function: kernel-manager-p (object)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Function: kernel-p (object)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Reader: kernel-variable-namespace (instance)
Writer: (setf kernel-variable-namespace) (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

variable-namespace.

Reader: macro-arguments (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

arguments.

Reader: macro-arguments (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

arguments.

Reader: macro-body (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

body.

Reader: macro-body (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

body.

Function: macro-expander (macro)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: macro-expander (macro)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: macro-modified-p (kernel name arguments body)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: macro-name (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

name.

Reader: macro-name (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

name.

Function: macro-p (object)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: macro-p (object)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: make-function (name return-type arguments body)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: make-function (name return-type argument-types)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: make-global (name qualifiers initializer)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: make-global (name type initializer)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: make-macro (name arguments body)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: make-macro (name arguments body)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: make-symbol-macro (name expansion)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: make-symbol-macro (name expansion)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: make-variable (name type)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: memcpy-device-to-host-async (host-ptr device-ptr type n stream)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: memcpy-host-to-device-async (device-ptr host-ptr type n stream)
Package

cl-cuda.api.memory.

Source

memory.lisp.

Function: output-cuda-code (cu-path cuda-code)
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: print-nvcc-command (cu-path ptx-path)
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: ptr-binding (argument)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: record-cu-event (cu-event)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: run-nvcc-command (cu-path ptx-path)
Package

cl-cuda.api.nvcc.

Source

nvcc.lisp.

Function: scalar-cffi-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: scalar-cffi-type-size (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: scalar-cuda-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: setf-to-argument-array-form (var argument i)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: setf-to-foreign-object-form (argument)
Package

cl-cuda.api.defkernel.

Source

defkernel.lisp.

Function: structure-accessors (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-cffi-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-cffi-type-size (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Function: structure-cuda-type (type)
Package

cl-cuda.lang.type.

Source

type.lisp.

Reader: symbol-macro-expansion (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

expansion.

Reader: symbol-macro-expansion (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

expansion.

Function: symbol-macro-modified-p (kernel name expansion)
Package

cl-cuda.api.kernel-manager.

Source

kernel-manager.lisp.

Reader: symbol-macro-name (instance)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Target Slot

name.

Reader: symbol-macro-name (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

name.

Function: symbol-macro-p (object)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Function: symbol-macro-p (object)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: sync-cu-event (cu-event)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Function: timer-p (object)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Reader: timer-start-event (instance)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Target Slot

start-event.

Reader: timer-stop-event (instance)
Package

cl-cuda.api.timer.

Source

timer.lisp.

Target Slot

stop-event.

Function: type-of-arithmetic (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-array-reference (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-built-in-function (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-constructor (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-cuda-dimension (form)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-function (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-inline-if (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-literal (form)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-macro (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-operands (operands var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-operands (operands var-env func-env)
Package

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

Source

compiler/compile-expression.lisp.

Function: type-of-reference (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-structure-reference (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-symbol-macro (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-user-defined-function (form var-env func-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: type-of-variable-reference (form var-env)
Package

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

Source

compiler/type-of-expression.lisp.

Function: var-env-add-do-bindings (var-env func-env bindings)
Package

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

Source

compiler/compile-statement.lisp.

Function: var-env-add-let-bindings (var-env func-env bindings)
Package

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

Source

compiler/compile-statement.lisp.

Function: var-env-add-symbol-macrolet-bindings (var-env bindings)
Package

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

Source

compiler/compile-statement.lisp.

Function: var-env-add-with-shared-memory-specs (var-env specs)
Package

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

Source

compiler/compile-statement.lisp.

Reader: variable-name (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

name.

Function: variable-p (object)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Function: variable-qualifier-p (object)
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Reader: variable-type (instance)
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Target Slot

type.


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

6.2.5 Conditions

Condition: sdk-not-found-error
Package

cl-cuda.driver-api.

Source

sdk-not-found.lisp.

Direct superclasses

simple-error.


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

6.2.6 Structures

Structure: %function
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

function-name.

Writers

This slot is read-only.

Slot: return-type
Initform

:return-type

Readers

function-return-type.

Writers

This slot is read-only.

Slot: arguments
Initform

:arguments

Readers

function-arguments.

Writers

This slot is read-only.

Slot: body
Initform

:body

Readers

function-body.

Writers

This slot is read-only.

Structure: %function
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

function-name.

Writers

This slot is read-only.

Slot: return-type
Initform

:return-type

Readers

function-return-type.

Writers

This slot is read-only.

Slot: argument-types
Initform

:argument-types

Readers

function-argument-types.

Writers

This slot is read-only.

Structure: global
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

global-name.

Writers

This slot is read-only.

Slot: qualifiers
Initform

:qualifiers

Readers

global-qualifiers.

Writers

This slot is read-only.

Slot: initializer
Initform

:initializer

Readers

global-initializer.

Writers

This slot is read-only.

Structure: global
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

global-name.

Writers

This slot is read-only.

Slot: type
Package

common-lisp.

Initform

:type

Readers

global-type.

Writers

This slot is read-only.

Slot: initializer
Initform

:initializer

Readers

global-initializer.

Writers

This slot is read-only.

Structure: kernel
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: variable-namespace
Initform

:variable-namespace

Readers

kernel-variable-namespace.

Writers

(setf kernel-variable-namespace).

Slot: function-namespace
Initform

:function-namespace

Readers

kernel-function-namespace.

Writers

(setf kernel-function-namespace).

Structure: macro
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

macro-name.

Writers

This slot is read-only.

Slot: arguments
Initform

:arguments

Readers

macro-arguments.

Writers

This slot is read-only.

Slot: body
Initform

:body

Readers

macro-body.

Writers

This slot is read-only.

Structure: macro
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

macro-name.

Writers

This slot is read-only.

Slot: arguments
Initform

:arguments

Readers

macro-arguments.

Writers

This slot is read-only.

Slot: body
Initform

:body

Readers

macro-body.

Writers

This slot is read-only.

Structure: memory-block
Package

cl-cuda.api.memory.

Source

memory.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: device-ptr
Initform

:device-ptr

Readers

memory-block-device-ptr.

Writers

This slot is read-only.

Slot: host-ptr
Initform

:host-ptr

Readers

memory-block-host-ptr.

Writers

This slot is read-only.

Slot: type
Package

common-lisp.

Initform

:type

Readers

memory-block-type.

Writers

This slot is read-only.

Slot: size
Initform

:size

Readers

memory-block-size.

Writers

This slot is read-only.

Structure: symbol-macro
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

symbol-macro-name.

Writers

This slot is read-only.

Slot: expansion
Initform

:expansion

Readers

symbol-macro-expansion.

Writers

This slot is read-only.

Structure: symbol-macro
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

symbol-macro-name.

Writers

This slot is read-only.

Slot: expansion
Initform

:expansion

Readers

symbol-macro-expansion.

Writers

This slot is read-only.

Structure: timer
Package

cl-cuda.api.timer.

Source

timer.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: start-event
Readers

timer-start-event.

Writers

This slot is read-only.

Slot: stop-event
Readers

timer-stop-event.

Writers

This slot is read-only.

Structure: variable
Package

cl-cuda.lang.environment.

Source

environment.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Initform

:name

Readers

variable-name.

Writers

This slot is read-only.

Slot: type
Package

common-lisp.

Initform

:type

Readers

variable-type.

Writers

This slot is read-only.


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

6.2.7 Classes

Class: cuda-grovel-file
Package

cl-cuda-asd.

Source

cl-cuda.asd.

Direct superclasses

grovel-file.

Direct methods

perform.

Class: curand-state-xorwow-tclass
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses
  • foreign-struct-type.
  • translatable-foreign-type.
Class: double3-c
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses
  • foreign-struct-type.
  • translatable-foreign-type.
Direct methods
Class: double4-c
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses
  • foreign-struct-type.
  • translatable-foreign-type.
Direct methods

translate-into-foreign-memory.

Class: float3-c
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses
  • foreign-struct-type.
  • translatable-foreign-type.
Direct methods
Class: float4-c
Package

cl-cuda.lang.data.

Source

data.lisp.

Direct superclasses
  • foreign-struct-type.
  • translatable-foreign-type.
Direct methods

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

6.2.8 Types

Type: variable-qualifier ()
Package

cl-cuda.lang.kernel.

Source

kernel.lisp.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

%
%add-function-arguments: Private ordinary functions
%add-functions: Private ordinary functions
%add-globals: Private ordinary functions
%add-macros: Private ordinary functions
%add-symbol-macros: Private ordinary functions
%c-identifier: Private ordinary functions
%elapsed-time: Private ordinary functions
%lookup-function: Private ordinary functions
%lookup-function: Private ordinary functions
%lookup-global: Private ordinary functions
%lookup-global: Private ordinary functions
%lookup-macro: Private ordinary functions
%lookup-macro: Private ordinary functions
%lookup-symbol-macro: Private ordinary functions
%lookup-symbol-macro: Private ordinary functions
%lookup-variable: Private ordinary functions
%macro-p: Private ordinary functions
%macro-p: Private ordinary functions
%macro-p: Private ordinary functions
%make-function: Private ordinary functions
%make-function: Private ordinary functions
%make-global: Private ordinary functions
%make-global: Private ordinary functions
%make-kernel: Private ordinary functions
%make-kernel-manager: Private ordinary functions
%make-macro: Private ordinary functions
%make-macro: Private ordinary functions
%make-memory-block: Private ordinary functions
%make-symbol-macro: Private ordinary functions
%make-symbol-macro: Private ordinary functions
%make-timer: Private ordinary functions
%make-variable: Private ordinary functions
%structure-from-accessor: Private ordinary functions
%symbol-macro-p: Private ordinary functions
%symbol-macro-p: Private ordinary functions

(
(setf double3-x): Public ordinary functions
(setf double3-y): Public ordinary functions
(setf double3-z): Public ordinary functions
(setf double4-w): Public ordinary functions
(setf double4-x): Public ordinary functions
(setf double4-y): Public ordinary functions
(setf double4-z): Public ordinary functions
(setf float3-x): Public ordinary functions
(setf float3-y): Public ordinary functions
(setf float3-z): Public ordinary functions
(setf float4-w): Public ordinary functions
(setf float4-x): Public ordinary functions
(setf float4-y): Public ordinary functions
(setf float4-z): Public ordinary functions
(setf global-ref): Public ordinary functions
(setf host-memory-aref): Public ordinary functions
(setf kernel-function-namespace): Private ordinary functions
(setf kernel-manager-%function-handle): Private ordinary functions
(setf kernel-manager-%function-handles): Private ordinary functions
(setf kernel-manager-%global-device-ptr): Private ordinary functions
(setf kernel-manager-%global-device-ptrs): Private ordinary functions
(setf kernel-manager-kernel): Private ordinary functions
(setf kernel-manager-module-handle): Public ordinary functions
(setf kernel-manager-module-path): Private ordinary functions
(setf kernel-variable-namespace): Private ordinary functions
(setf memory-block-aref): Public ordinary functions

A
alloc-device-memory: Public ordinary functions
alloc-host-memory: Public ordinary functions
alloc-memory-block: Public ordinary functions
append-arch: Private ordinary functions
arch-exists-p: Private ordinary functions
argument-cffi-type: Private ordinary functions
argument-p: Public ordinary functions
argument-type: Public ordinary functions
argument-var: Public ordinary functions
argument-var-ptr: Private ordinary functions
argument-vars: Private ordinary functions
arithmetic-operands: Public ordinary functions
arithmetic-operator: Public ordinary functions
arithmetic-p: Public ordinary functions
array-cffi-type: Private ordinary functions
array-cffi-type-size: Private ordinary functions
array-cuda-type: Private ordinary functions
array-reference-expr: Public ordinary functions
array-reference-indices: Public ordinary functions
array-reference-p: Public ordinary functions
array-type: Public ordinary functions
array-type-base: Public ordinary functions
array-type-dimension: Public ordinary functions
array-type-p: Public ordinary functions
array-type-stars: Private ordinary functions

B
block-dim-p: Public ordinary functions
block-idx-p: Public ordinary functions
bool-literal-p: Public ordinary functions
built-in-function-c-name: Public ordinary functions
built-in-function-infix-p: Public ordinary functions
built-in-function-return-type: Public ordinary functions

C
c-identifier: Public ordinary functions
cffi-type: Public ordinary functions
cffi-type-size: Public ordinary functions
check-cuda-error: Private ordinary functions
cl-cuda-bool-p: Public ordinary functions
cl-cuda-double-p: Public ordinary functions
cl-cuda-float-p: Public ordinary functions
cl-cuda-int-p: Public ordinary functions
cl-cuda-symbol-p: Public ordinary functions
cl-cuda-type-p: Public ordinary functions
compile-argument: Private ordinary functions
compile-arguments: Private ordinary functions
compile-arithmetic: Private ordinary functions
compile-array-indices: Private ordinary functions
compile-array-reference: Private ordinary functions
compile-bool: Public ordinary functions
compile-bool-literal: Private ordinary functions
compile-built-in-function: Private ordinary functions
compile-built-in-infix-function: Private ordinary functions
compile-built-in-prefix-function: Private ordinary functions
compile-constructor: Private ordinary functions
compile-cuda-dimension: Private ordinary functions
compile-declaration: Private ordinary functions
compile-definition: Private ordinary functions
compile-definitions: Private ordinary functions
compile-do: Private ordinary functions
compile-do-init-part: Private ordinary functions
compile-do-statements: Private ordinary functions
compile-do-step-part: Private ordinary functions
compile-do-test-part: Private ordinary functions
compile-double: Public ordinary functions
compile-double-literal: Private ordinary functions
compile-expression: Public ordinary functions
compile-float: Public ordinary functions
compile-float-literal: Private ordinary functions
compile-function: Private ordinary functions
compile-function: Private ordinary functions
compile-global: Private ordinary functions
compile-globals: Private ordinary functions
compile-if: Private ordinary functions
compile-includes: Private ordinary functions
compile-inline-if: Private ordinary functions
compile-int: Public ordinary functions
compile-int-literal: Private ordinary functions
compile-kernel: Public ordinary functions
compile-let: Private ordinary functions
compile-let-bindings: Private ordinary functions
compile-let-statements: Private ordinary functions
compile-literal: Private ordinary functions
compile-macro: Private ordinary functions
compile-macro: Private ordinary functions
compile-macrolet: Private ordinary functions
compile-macrolet-statements: Private ordinary functions
compile-operands: Private ordinary functions
compile-progn: Private ordinary functions
compile-prototype: Private ordinary functions
compile-prototypes: Private ordinary functions
compile-reference: Private ordinary functions
compile-return: Private ordinary functions
compile-set: Private ordinary functions
compile-specifier: Private ordinary functions
compile-statement: Public ordinary functions
compile-statements: Private ordinary functions
compile-structure-reference: Private ordinary functions
compile-symbol: Public ordinary functions
compile-symbol-macro: Private ordinary functions
compile-symbol-macrolet: Private ordinary functions
compile-symbol-macrolet-statements: Private ordinary functions
compile-type: Public ordinary functions
compile-user-defined-function: Private ordinary functions
compile-variable-qualifier: Private ordinary functions
compile-variable-reference: Private ordinary functions
compile-with-shared-memory: Private ordinary functions
compile-with-shared-memory-spec-dimensions: Private ordinary functions
compile-with-shared-memory-specs: Private ordinary functions
compile-with-shared-memory-statements: Private ordinary functions
constructor-operands: Public ordinary functions
constructor-operator: Public ordinary functions
constructor-p: Public ordinary functions
copy-%function: Private ordinary functions
copy-%function: Private ordinary functions
copy-double3: Private ordinary functions
copy-double4: Private ordinary functions
copy-float3: Private ordinary functions
copy-float4: Private ordinary functions
copy-global: Private ordinary functions
copy-global: Private ordinary functions
copy-kernel: Private ordinary functions
copy-kernel-manager: Private ordinary functions
copy-macro: Private ordinary functions
copy-macro: Private ordinary functions
copy-memory-block: Private ordinary functions
copy-symbol-macro: Private ordinary functions
copy-symbol-macro: Private ordinary functions
copy-timer: Private ordinary functions
copy-variable: Private ordinary functions
create-cu-event: Private ordinary functions
create-cuda-context: Public ordinary functions
create-timer: Public ordinary functions
cu-ctx-create: Public ordinary functions
cu-ctx-destroy: Public ordinary functions
cu-ctx-synchronize: Public ordinary functions
cu-device-compute-capability: Public ordinary functions
cu-device-get: Public ordinary functions
cu-device-get-count: Public ordinary functions
cu-device-get-name: Public ordinary functions
cu-device-total-mem: Public ordinary functions
cu-event-create: Public ordinary functions
cu-event-destroy: Public ordinary functions
cu-event-elapsed-time: Public ordinary functions
cu-event-record: Public ordinary functions
cu-event-synchronize: Public ordinary functions
cu-init: Public ordinary functions
cu-launch-kernel: Public ordinary functions
cu-mem-alloc: Public ordinary functions
cu-mem-free: Public ordinary functions
cu-mem-host-register: Public ordinary functions
cu-mem-host-unregister: Public ordinary functions
cu-memcpy-device-to-host: Public ordinary functions
cu-memcpy-device-to-host-async: Public ordinary functions
cu-memcpy-host-to-device: Public ordinary functions
cu-memcpy-host-to-device-async: Public ordinary functions
cu-module-get-function: Public ordinary functions
cu-module-get-global: Public ordinary functions
cu-module-load: Public ordinary functions
cu-module-unload: Public ordinary functions
cu-stream-create: Public ordinary functions
cu-stream-destroy: Public ordinary functions
cu-stream-query: Public ordinary functions
cu-stream-synchronize: Public ordinary functions
cu-stream-wait-event: Public ordinary functions
cuda-dimension-p: Public ordinary functions
cuda-type: Public ordinary functions

D
defconstant-enum-value: Private ordinary functions
defcuenum: Private macros
defcufun: Private macros
defglobal: Public macros
defkernel: Public macros
defkernel-symbol-macro: Public macros
defkernelmacro: Public macros
destroy-cu-event: Private ordinary functions
destroy-cuda-context: Public ordinary functions
destroy-timer: Public ordinary functions
device-compute-capability: Public ordinary functions
device-total-bytes: Public ordinary functions
device-total-gbytes: Public ordinary functions
device-total-kbytes: Public ordinary functions
device-total-mbytes: Public ordinary functions
do-binding-init: Public ordinary functions
do-binding-p: Public ordinary functions
do-binding-step: Public ordinary functions
do-binding-var: Public ordinary functions
do-bindings: Public ordinary functions
do-end-test: Public ordinary functions
do-p: Public ordinary functions
do-statements: Public ordinary functions
double-literal-p: Public ordinary functions
double3-=: Public ordinary functions
double3-p: Public ordinary functions
double3-x: Public ordinary functions
double3-y: Public ordinary functions
double3-z: Public ordinary functions
double4-=: Public ordinary functions
double4-p: Public ordinary functions
double4-w: Public ordinary functions
double4-x: Public ordinary functions
double4-y: Public ordinary functions
double4-z: Public ordinary functions

E
elapsed-time: Public ordinary functions
empty-function-environment: Public ordinary functions
empty-variable-environment: Public ordinary functions
ensure-kernel-function-loaded: Public ordinary functions
ensure-kernel-global-loaded: Public ordinary functions
ensure-kernel-module-compiled: Public ordinary functions
ensure-kernel-module-loaded: Public ordinary functions
expand-macro: Public ordinary functions
expand-macro: Public ordinary functions
expand-macro: Public ordinary functions
expand-macro-1: Public ordinary functions
expand-macro-1: Public ordinary functions
expand-macro-1: Public ordinary functions

F
float-literal-p: Public ordinary functions
float3-=: Public ordinary functions
float3-p: Public ordinary functions
float3-x: Public ordinary functions
float3-y: Public ordinary functions
float3-z: Public ordinary functions
float4-=: Public ordinary functions
float4-p: Public ordinary functions
float4-w: Public ordinary functions
float4-x: Public ordinary functions
float4-y: Public ordinary functions
float4-z: Public ordinary functions
free-device-memory: Public ordinary functions
free-host-memory: Public ordinary functions
free-memory-block: Public ordinary functions
func-env-add-macrolet-bindings: Private ordinary functions
Function, %add-function-arguments: Private ordinary functions
Function, %add-functions: Private ordinary functions
Function, %add-globals: Private ordinary functions
Function, %add-macros: Private ordinary functions
Function, %add-symbol-macros: Private ordinary functions
Function, %c-identifier: Private ordinary functions
Function, %elapsed-time: Private ordinary functions
Function, %lookup-function: Private ordinary functions
Function, %lookup-function: Private ordinary functions
Function, %lookup-global: Private ordinary functions
Function, %lookup-global: Private ordinary functions
Function, %lookup-macro: Private ordinary functions
Function, %lookup-macro: Private ordinary functions
Function, %lookup-symbol-macro: Private ordinary functions
Function, %lookup-symbol-macro: Private ordinary functions
Function, %lookup-variable: Private ordinary functions
Function, %macro-p: Private ordinary functions
Function, %macro-p: Private ordinary functions
Function, %macro-p: Private ordinary functions
Function, %make-function: Private ordinary functions
Function, %make-function: Private ordinary functions
Function, %make-global: Private ordinary functions
Function, %make-global: Private ordinary functions
Function, %make-kernel: Private ordinary functions
Function, %make-kernel-manager: Private ordinary functions
Function, %make-macro: Private ordinary functions
Function, %make-macro: Private ordinary functions
Function, %make-memory-block: Private ordinary functions
Function, %make-symbol-macro: Private ordinary functions
Function, %make-symbol-macro: Private ordinary functions
Function, %make-timer: Private ordinary functions
Function, %make-variable: Private ordinary functions
Function, %structure-from-accessor: Private ordinary functions
Function, %symbol-macro-p: Private ordinary functions
Function, %symbol-macro-p: Private ordinary functions
Function, (setf double3-x): Public ordinary functions
Function, (setf double3-y): Public ordinary functions
Function, (setf double3-z): Public ordinary functions
Function, (setf double4-w): Public ordinary functions
Function, (setf double4-x): Public ordinary functions
Function, (setf double4-y): Public ordinary functions
Function, (setf double4-z): Public ordinary functions
Function, (setf float3-x): Public ordinary functions
Function, (setf float3-y): Public ordinary functions
Function, (setf float3-z): Public ordinary functions
Function, (setf float4-w): Public ordinary functions
Function, (setf float4-x): Public ordinary functions
Function, (setf float4-y): Public ordinary functions
Function, (setf float4-z): Public ordinary functions
Function, (setf global-ref): Public ordinary functions
Function, (setf host-memory-aref): Public ordinary functions
Function, (setf kernel-function-namespace): Private ordinary functions
Function, (setf kernel-manager-%function-handle): Private ordinary functions
Function, (setf kernel-manager-%function-handles): Private ordinary functions
Function, (setf kernel-manager-%global-device-ptr): Private ordinary functions
Function, (setf kernel-manager-%global-device-ptrs): Private ordinary functions
Function, (setf kernel-manager-kernel): Private ordinary functions
Function, (setf kernel-manager-module-handle): Public ordinary functions
Function, (setf kernel-manager-module-path): Private ordinary functions
Function, (setf kernel-variable-namespace): Private ordinary functions
Function, (setf memory-block-aref): Public ordinary functions
Function, alloc-device-memory: Public ordinary functions
Function, alloc-host-memory: Public ordinary functions
Function, alloc-memory-block: Public ordinary functions
Function, append-arch: Private ordinary functions
Function, arch-exists-p: Private ordinary functions
Function, argument-cffi-type: Private ordinary functions
Function, argument-p: Public ordinary functions
Function, argument-type: Public ordinary functions
Function, argument-var: Public ordinary functions
Function, argument-var-ptr: Private ordinary functions
Function, argument-vars: Private ordinary functions
Function, arithmetic-operands: Public ordinary functions
Function, arithmetic-operator: Public ordinary functions
Function, arithmetic-p: Public ordinary functions
Function, array-cffi-type: Private ordinary functions
Function, array-cffi-type-size: Private ordinary functions
Function, array-cuda-type: Private ordinary functions
Function, array-reference-expr: Public ordinary functions
Function, array-reference-indices: Public ordinary functions
Function, array-reference-p: Public ordinary functions
Function, array-type: Public ordinary functions
Function, array-type-base: Public ordinary functions
Function, array-type-dimension: Public ordinary functions
Function, array-type-p: Public ordinary functions
Function, array-type-stars: Private ordinary functions
Function, block-dim-p: Public ordinary functions
Function, block-idx-p: Public ordinary functions
Function, bool-literal-p: Public ordinary functions
Function, built-in-function-c-name: Public ordinary functions
Function, built-in-function-infix-p: Public ordinary functions
Function, built-in-function-return-type: Public ordinary functions
Function, c-identifier: Public ordinary functions
Function, cffi-type: Public ordinary functions
Function, cffi-type-size: Public ordinary functions
Function, check-cuda-error: Private ordinary functions
Function, cl-cuda-bool-p: Public ordinary functions
Function, cl-cuda-double-p: Public ordinary functions
Function, cl-cuda-float-p: Public ordinary functions
Function, cl-cuda-int-p: Public ordinary functions
Function, cl-cuda-symbol-p: Public ordinary functions
Function, cl-cuda-type-p: Public ordinary functions
Function, compile-argument: Private ordinary functions
Function, compile-arguments: Private ordinary functions
Function, compile-arithmetic: Private ordinary functions
Function, compile-array-indices: Private ordinary functions
Function, compile-array-reference: Private ordinary functions
Function, compile-bool: Public ordinary functions
Function, compile-bool-literal: Private ordinary functions
Function, compile-built-in-function: Private ordinary functions
Function, compile-built-in-infix-function: Private ordinary functions
Function, compile-built-in-prefix-function: Private ordinary functions
Function, compile-constructor: Private ordinary functions
Function, compile-cuda-dimension: Private ordinary functions
Function, compile-declaration: Private ordinary functions
Function, compile-definition: Private ordinary functions
Function, compile-definitions: Private ordinary functions
Function, compile-do: Private ordinary functions
Function, compile-do-init-part: Private ordinary functions
Function, compile-do-statements: Private ordinary functions
Function, compile-do-step-part: Private ordinary functions
Function, compile-do-test-part: Private ordinary functions
Function, compile-double: Public ordinary functions
Function, compile-double-literal: Private ordinary functions
Function, compile-expression: Public ordinary functions
Function, compile-float: Public ordinary functions
Function, compile-float-literal: Private ordinary functions
Function, compile-function: Private ordinary functions
Function, compile-function: Private ordinary functions
Function, compile-global: Private ordinary functions
Function, compile-globals: Private ordinary functions
Function, compile-if: Private ordinary functions
Function, compile-includes: Private ordinary functions
Function, compile-inline-if: Private ordinary functions
Function, compile-int: Public ordinary functions
Function, compile-int-literal: Private ordinary functions
Function, compile-kernel: Public ordinary functions
Function, compile-let: Private ordinary functions
Function, compile-let-bindings: Private ordinary functions
Function, compile-let-statements: Private ordinary functions
Function, compile-literal: Private ordinary functions
Function, compile-macro: Private ordinary functions
Function, compile-macro: Private ordinary functions
Function, compile-macrolet: Private ordinary functions
Function, compile-macrolet-statements: Private ordinary functions
Function, compile-operands: Private ordinary functions
Function, compile-progn: Private ordinary functions
Function, compile-prototype: Private ordinary functions
Function, compile-prototypes: Private ordinary functions
Function, compile-reference: Private ordinary functions
Function, compile-return: Private ordinary functions
Function, compile-set: Private ordinary functions
Function, compile-specifier: Private ordinary functions
Function, compile-statement: Public ordinary functions
Function, compile-statements: Private ordinary functions
Function, compile-structure-reference: Private ordinary functions
Function, compile-symbol: Public ordinary functions
Function, compile-symbol-macro: Private ordinary functions
Function, compile-symbol-macrolet: Private ordinary functions
Function, compile-symbol-macrolet-statements: Private ordinary functions
Function, compile-type: Public ordinary functions
Function, compile-user-defined-function: Private ordinary functions
Function, compile-variable-qualifier: Private ordinary functions
Function, compile-variable-reference: Private ordinary functions
Function, compile-with-shared-memory: Private ordinary functions
Function, compile-with-shared-memory-spec-dimensions: Private ordinary functions
Function, compile-with-shared-memory-specs: Private ordinary functions
Function, compile-with-shared-memory-statements: Private ordinary functions
Function, constructor-operands: Public ordinary functions
Function, constructor-operator: Public ordinary functions
Function, constructor-p: Public ordinary functions
Function, copy-%function: Private ordinary functions
Function, copy-%function: Private ordinary functions
Function, copy-double3: Private ordinary functions
Function, copy-double4: Private ordinary functions
Function, copy-float3: Private ordinary functions
Function, copy-float4: Private ordinary functions
Function, copy-global: Private ordinary functions
Function, copy-global: Private ordinary functions
Function, copy-kernel: Private ordinary functions
Function, copy-kernel-manager: Private ordinary functions
Function, copy-macro: Private ordinary functions
Function, copy-macro: Private ordinary functions
Function, copy-memory-block: Private ordinary functions
Function, copy-symbol-macro: Private ordinary functions
Function, copy-symbol-macro: Private ordinary functions
Function, copy-timer: Private ordinary functions
Function, copy-variable: Private ordinary functions
Function, create-cu-event: Private ordinary functions
Function, create-cuda-context: Public ordinary functions
Function, create-timer: Public ordinary functions
Function, cu-ctx-create: Public ordinary functions
Function, cu-ctx-destroy: Public ordinary functions
Function, cu-ctx-synchronize: Public ordinary functions
Function, cu-device-compute-capability: Public ordinary functions
Function, cu-device-get: Public ordinary functions
Function, cu-device-get-count: Public ordinary functions
Function, cu-device-get-name: Public ordinary functions
Function, cu-device-total-mem: Public ordinary functions
Function, cu-event-create: Public ordinary functions
Function, cu-event-destroy: Public ordinary functions
Function, cu-event-elapsed-time: Public ordinary functions
Function, cu-event-record: Public ordinary functions
Function, cu-event-synchronize: Public ordinary functions
Function, cu-init: Public ordinary functions
Function, cu-launch-kernel: Public ordinary functions
Function, cu-mem-alloc: Public ordinary functions
Function, cu-mem-free: Public ordinary functions
Function, cu-mem-host-register: Public ordinary functions
Function, cu-mem-host-unregister: Public ordinary functions
Function, cu-memcpy-device-to-host: Public ordinary functions
Function, cu-memcpy-device-to-host-async: Public ordinary functions
Function, cu-memcpy-host-to-device: Public ordinary functions
Function, cu-memcpy-host-to-device-async: Public ordinary functions
Function, cu-module-get-function: Public ordinary functions
Function, cu-module-get-global: Public ordinary functions
Function, cu-module-load: Public ordinary functions
Function, cu-module-unload: Public ordinary functions
Function, cu-stream-create: Public ordinary functions
Function, cu-stream-destroy: Public ordinary functions
Function, cu-stream-query: Public ordinary functions
Function, cu-stream-synchronize: Public ordinary functions
Function, cu-stream-wait-event: Public ordinary functions
Function, cuda-dimension-p: Public ordinary functions
Function, cuda-type: Public ordinary functions
Function, defconstant-enum-value: Private ordinary functions
Function, destroy-cu-event: Private ordinary functions
Function, destroy-cuda-context: Public ordinary functions
Function, destroy-timer: Public ordinary functions
Function, device-compute-capability: Public ordinary functions
Function, device-total-bytes: Public ordinary functions
Function, device-total-gbytes: Public ordinary functions
Function, device-total-kbytes: Public ordinary functions
Function, device-total-mbytes: Public ordinary functions
Function, do-binding-init: Public ordinary functions
Function, do-binding-p: Public ordinary functions
Function, do-binding-step: Public ordinary functions
Function, do-binding-var: Public ordinary functions
Function, do-bindings: Public ordinary functions
Function, do-end-test: Public ordinary functions
Function, do-p: Public ordinary functions
Function, do-statements: Public ordinary functions
Function, double-literal-p: Public ordinary functions
Function, double3-=: Public ordinary functions
Function, double3-p: Public ordinary functions
Function, double3-x: Public ordinary functions
Function, double3-y: Public ordinary functions
Function, double3-z: Public ordinary functions
Function, double4-=: Public ordinary functions
Function, double4-p: Public ordinary functions
Function, double4-w: Public ordinary functions
Function, double4-x: Public ordinary functions
Function, double4-y: Public ordinary functions
Function, double4-z: Public ordinary functions
Function, elapsed-time: Public ordinary functions
Function, empty-function-environment: Public ordinary functions
Function, empty-variable-environment: Public ordinary functions
Function, ensure-kernel-function-loaded: Public ordinary functions
Function, ensure-kernel-global-loaded: Public ordinary functions
Function, ensure-kernel-module-compiled: Public ordinary functions
Function, ensure-kernel-module-loaded: Public ordinary functions
Function, expand-macro: Public ordinary functions
Function, expand-macro: Public ordinary functions
Function, expand-macro: Public ordinary functions
Function, expand-macro-1: Public ordinary functions
Function, expand-macro-1: Public ordinary functions
Function, expand-macro-1: Public ordinary functions
Function, float-literal-p: Public ordinary functions
Function, float3-=: Public ordinary functions
Function, float3-p: Public ordinary functions
Function, float3-x: Public ordinary functions
Function, float3-y: Public ordinary functions
Function, float3-z: Public ordinary functions
Function, float4-=: Public ordinary functions
Function, float4-p: Public ordinary functions
Function, float4-w: Public ordinary functions
Function, float4-x: Public ordinary functions
Function, float4-y: Public ordinary functions
Function, float4-z: Public ordinary functions
Function, free-device-memory: Public ordinary functions
Function, free-host-memory: Public ordinary functions
Function, free-memory-block: Public ordinary functions
Function, func-env-add-macrolet-bindings: Private ordinary functions
Function, function-argument-types: Private ordinary functions
Function, function-argument-types: Private ordinary functions
Function, function-argument-vars: Private ordinary functions
Function, function-arguments: Private ordinary functions
Function, function-body: Private ordinary functions
Function, function-c-name: Private ordinary functions
Function, function-c-name: Private ordinary functions
Function, function-environment-add-function: Public ordinary functions
Function, function-environment-add-macro: Public ordinary functions
Function, function-environment-function-argument-types: Public ordinary functions
Function, function-environment-function-c-name: Public ordinary functions
Function, function-environment-function-exists-p: Public ordinary functions
Function, function-environment-function-name: Public ordinary functions
Function, function-environment-function-return-type: Public ordinary functions
Function, function-environment-macro-exists-p: Public ordinary functions
Function, function-environment-macro-expander: Public ordinary functions
Function, function-environment-macro-name: Public ordinary functions
Function, function-modified-p: Private ordinary functions
Function, function-name: Private ordinary functions
Function, function-name: Private ordinary functions
Function, function-operands: Public ordinary functions
Function, function-operator: Public ordinary functions
Function, function-p: Public ordinary functions
Function, function-p: Private ordinary functions
Function, function-p: Private ordinary functions
Function, function-return-type: Private ordinary functions
Function, function-return-type: Private ordinary functions
Function, get-cu-path: Private ordinary functions
Function, get-cuda-device: Public ordinary functions
Function, get-error-string: Private ordinary functions
Function, get-include-path: Private ordinary functions
Function, get-nvcc-arch: Private ordinary functions
Function, get-nvcc-options: Private ordinary functions
Function, get-ptx-path: Private ordinary functions
Function, get-tmp-path: Private ordinary functions
Function, global-c-name: Private ordinary functions
Function, global-c-name: Private ordinary functions
Function, global-initializer: Private ordinary functions
Function, global-initializer: Private ordinary functions
Function, global-modified-p: Private ordinary functions
Function, global-name: Private ordinary functions
Function, global-name: Private ordinary functions
Function, global-p: Private ordinary functions
Function, global-p: Private ordinary functions
Function, global-qualifiers: Private ordinary functions
Function, global-ref: Public ordinary functions
Function, global-type: Private ordinary functions
Function, grid-dim-p: Public ordinary functions
Function, host-memory-aref: Public ordinary functions
Function, if-else-statement: Public ordinary functions
Function, if-p: Public ordinary functions
Function, if-test-expression: Public ordinary functions
Function, if-then-statement: Public ordinary functions
Function, indent: Public ordinary functions
Function, inferred-function: Private ordinary functions
Function, inferred-function-candidates: Private ordinary functions
Function, init-cuda: Public ordinary functions
Function, inline-if-else-expression: Public ordinary functions
Function, inline-if-p: Public ordinary functions
Function, inline-if-test-expression: Public ordinary functions
Function, inline-if-then-expression: Public ordinary functions
Function, int-literal-p: Public ordinary functions
Function, kernel->function-environment: Private ordinary functions
Function, kernel->variable-environment: Private ordinary functions
Function, kernel-define-function: Public ordinary functions
Function, kernel-define-global: Public ordinary functions
Function, kernel-define-macro: Public ordinary functions
Function, kernel-define-symbol-macro: Public ordinary functions
Function, kernel-function-argument-types: Public ordinary functions
Function, kernel-function-argument-vars: Public ordinary functions
Function, kernel-function-arguments: Public ordinary functions
Function, kernel-function-body: Public ordinary functions
Function, kernel-function-c-name: Public ordinary functions
Function, kernel-function-exists-p: Public ordinary functions
Function, kernel-function-name: Public ordinary functions
Function, kernel-function-names: Public ordinary functions
Function, kernel-function-namespace: Private ordinary functions
Function, kernel-function-return-type: Public ordinary functions
Function, kernel-global-c-name: Public ordinary functions
Function, kernel-global-exists-p: Public ordinary functions
Function, kernel-global-initializer: Public ordinary functions
Function, kernel-global-name: Public ordinary functions
Function, kernel-global-names: Public ordinary functions
Function, kernel-global-qualifiers: Public ordinary functions
Function, kernel-macro-arguments: Public ordinary functions
Function, kernel-macro-body: Public ordinary functions
Function, kernel-macro-exists-p: Public ordinary functions
Function, kernel-macro-expander: Public ordinary functions
Function, kernel-macro-name: Public ordinary functions
Function, kernel-macro-names: Public ordinary functions
Function, kernel-manager-%function-handle: Private ordinary functions
Function, kernel-manager-%function-handles: Private ordinary functions
Function, kernel-manager-%global-device-ptr: Private ordinary functions
Function, kernel-manager-%global-device-ptrs: Private ordinary functions
Function, kernel-manager-compile-module: Public ordinary functions
Function, kernel-manager-compiled-p: Public ordinary functions
Function, kernel-manager-define-function: Public ordinary functions
Function, kernel-manager-define-global: Public ordinary functions
Function, kernel-manager-define-macro: Public ordinary functions
Function, kernel-manager-define-symbol-macro: Public ordinary functions
Function, kernel-manager-function-handle: Public ordinary functions
Function, kernel-manager-function-handles-empty-p: Public ordinary functions
Function, kernel-manager-global-device-ptr: Public ordinary functions
Function, kernel-manager-global-device-ptrs-empty-p: Public ordinary functions
Function, kernel-manager-global-qualifiers: Public ordinary functions
Function, kernel-manager-kernel: Private ordinary functions
Function, kernel-manager-load-function: Public ordinary functions
Function, kernel-manager-load-global: Public ordinary functions
Function, kernel-manager-load-module: Public ordinary functions
Function, kernel-manager-module-handle: Public ordinary functions
Function, kernel-manager-module-path: Private ordinary functions
Function, kernel-manager-p: Private ordinary functions
Function, kernel-manager-unload: Public ordinary functions
Function, kernel-p: Private ordinary functions
Function, kernel-symbol-macro-exists-p: Public ordinary functions
Function, kernel-symbol-macro-expansion: Public ordinary functions
Function, kernel-symbol-macro-name: Public ordinary functions
Function, kernel-symbol-macro-names: Public ordinary functions
Function, kernel-variable-namespace: Private ordinary functions
Function, let-binding-expr: Public ordinary functions
Function, let-binding-p: Public ordinary functions
Function, let-binding-var: Public ordinary functions
Function, let-bindings: Public ordinary functions
Function, let-p: Public ordinary functions
Function, let-statements: Public ordinary functions
Function, lines: Public ordinary functions
Function, literal-p: Public ordinary functions
Function, macro-arguments: Private ordinary functions
Function, macro-arguments: Private ordinary functions
Function, macro-body: Private ordinary functions
Function, macro-body: Private ordinary functions
Function, macro-expander: Private ordinary functions
Function, macro-expander: Private ordinary functions
Function, macro-modified-p: Private ordinary functions
Function, macro-name: Private ordinary functions
Function, macro-name: Private ordinary functions
Function, macro-operands: Public ordinary functions
Function, macro-operator: Public ordinary functions
Function, macro-p: Public ordinary functions
Function, macro-p: Private ordinary functions
Function, macro-p: Private ordinary functions
Function, macrolet-binding-arguments: Public ordinary functions
Function, macrolet-binding-body: Public ordinary functions
Function, macrolet-binding-p: Public ordinary functions
Function, macrolet-binding-symbol: Public ordinary functions
Function, macrolet-bindings: Public ordinary functions
Function, macrolet-p: Public ordinary functions
Function, macrolet-statements: Public ordinary functions
Function, make-double3: Public ordinary functions
Function, make-double4: Public ordinary functions
Function, make-float3: Public ordinary functions
Function, make-float4: Public ordinary functions
Function, make-function: Private ordinary functions
Function, make-function: Private ordinary functions
Function, make-global: Private ordinary functions
Function, make-global: Private ordinary functions
Function, make-kernel: Public ordinary functions
Function, make-kernel-manager: Public ordinary functions
Function, make-macro: Private ordinary functions
Function, make-macro: Private ordinary functions
Function, make-symbol-macro: Private ordinary functions
Function, make-symbol-macro: Private ordinary functions
Function, make-variable: Private ordinary functions
Function, memcpy-device-to-host: Public ordinary functions
Function, memcpy-device-to-host-async: Private ordinary functions
Function, memcpy-host-to-device: Public ordinary functions
Function, memcpy-host-to-device-async: Private ordinary functions
Function, memory-block-aref: Public ordinary functions
Function, memory-block-device-ptr: Public ordinary functions
Function, memory-block-host-ptr: Public ordinary functions
Function, memory-block-p: Public ordinary functions
Function, memory-block-size: Public ordinary functions
Function, memory-block-type: Public ordinary functions
Function, nvcc-compile: Public ordinary functions
Function, output-cuda-code: Private ordinary functions
Function, print-nvcc-command: Private ordinary functions
Function, progn-p: Public ordinary functions
Function, progn-statements: Public ordinary functions
Function, ptr-binding: Private ordinary functions
Function, record-cu-event: Private ordinary functions
Function, reference-p: Public ordinary functions
Function, return-expr: Public ordinary functions
Function, return-p: Public ordinary functions
Function, run-nvcc-command: Private ordinary functions
Function, scalar-cffi-type: Private ordinary functions
Function, scalar-cffi-type-size: Private ordinary functions
Function, scalar-cuda-type: Private ordinary functions
Function, scalar-type-p: Public ordinary functions
Function, set-expression: Public ordinary functions
Function, set-p: Public ordinary functions
Function, set-reference: Public ordinary functions
Function, setf-to-argument-array-form: Private ordinary functions
Function, setf-to-foreign-object-form: Private ordinary functions
Function, start-timer: Public ordinary functions
Function, stop-timer: Public ordinary functions
Function, structure-accessor-cuda-accessor: Public ordinary functions
Function, structure-accessor-p: Public ordinary functions
Function, structure-accessor-return-type: Public ordinary functions
Function, structure-accessors: Private ordinary functions
Function, structure-cffi-type: Private ordinary functions
Function, structure-cffi-type-size: Private ordinary functions
Function, structure-cuda-type: Private ordinary functions
Function, structure-from-accessor: Public ordinary functions
Function, structure-reference-accessor: Public ordinary functions
Function, structure-reference-expr: Public ordinary functions
Function, structure-reference-p: Public ordinary functions
Function, structure-type-p: Public ordinary functions
Function, symbol-macro-expansion: Private ordinary functions
Function, symbol-macro-expansion: Private ordinary functions
Function, symbol-macro-modified-p: Private ordinary functions
Function, symbol-macro-name: Private ordinary functions
Function, symbol-macro-name: Private ordinary functions
Function, symbol-macro-p: Public ordinary functions
Function, symbol-macro-p: Private ordinary functions
Function, symbol-macro-p: Private ordinary functions
Function, symbol-macrolet-binding-expansion: Public ordinary functions
Function, symbol-macrolet-binding-p: Public ordinary functions
Function, symbol-macrolet-binding-symbol: Public ordinary functions
Function, symbol-macrolet-bindings: Public ordinary functions
Function, symbol-macrolet-p: Public ordinary functions
Function, symbol-macrolet-statements: Public ordinary functions
Function, sync-cu-event: Private ordinary functions
Function, sync-memory-block: Public ordinary functions
Function, synchronize-context: Public ordinary functions
Function, synchronize-timer: Public ordinary functions
Function, thread-idx-p: Public ordinary functions
Function, timer-p: Private ordinary functions
Function, timer-start-event: Private ordinary functions
Function, timer-stop-event: Private ordinary functions
Function, type-of-arithmetic: Private ordinary functions
Function, type-of-array-reference: Private ordinary functions
Function, type-of-built-in-function: Private ordinary functions
Function, type-of-constructor: Private ordinary functions
Function, type-of-cuda-dimension: Private ordinary functions
Function, type-of-expression: Public ordinary functions
Function, type-of-function: Private ordinary functions
Function, type-of-inline-if: Private ordinary functions
Function, type-of-literal: Private ordinary functions
Function, type-of-macro: Private ordinary functions
Function, type-of-operands: Private ordinary functions
Function, type-of-operands: Private ordinary functions
Function, type-of-reference: Private ordinary functions
Function, type-of-structure-reference: Private ordinary functions
Function, type-of-symbol-macro: Private ordinary functions
Function, type-of-user-defined-function: Private ordinary functions
Function, type-of-variable-reference: Private ordinary functions
Function, unlines: Public ordinary functions
Function, var-env-add-do-bindings: Private ordinary functions
Function, var-env-add-let-bindings: Private ordinary functions
Function, var-env-add-symbol-macrolet-bindings: Private ordinary functions
Function, var-env-add-with-shared-memory-specs: Private ordinary functions
Function, variable-environment-add-global: Public ordinary functions
Function, variable-environment-add-symbol-macro: Public ordinary functions
Function, variable-environment-add-variable: Public ordinary functions
Function, variable-environment-global-c-name: Public ordinary functions
Function, variable-environment-global-exists-p: Public ordinary functions
Function, variable-environment-global-initializer: Public ordinary functions
Function, variable-environment-global-name: Public ordinary functions
Function, variable-environment-global-type: Public ordinary functions
Function, variable-environment-symbol-macro-exists-p: Public ordinary functions
Function, variable-environment-symbol-macro-expansion: Public ordinary functions
Function, variable-environment-symbol-macro-name: Public ordinary functions
Function, variable-environment-variable-exists-p: Public ordinary functions
Function, variable-environment-variable-name: Public ordinary functions
Function, variable-environment-variable-type: Public ordinary functions
Function, variable-name: Private ordinary functions
Function, variable-p: Private ordinary functions
Function, variable-qualifier-p: Private ordinary functions
Function, variable-reference-p: Public ordinary functions
Function, variable-type: Private ordinary functions
Function, with-shared-memory-p: Public ordinary functions
Function, with-shared-memory-spec-dimensions: Public ordinary functions
Function, with-shared-memory-spec-p: Public ordinary functions
Function, with-shared-memory-spec-type: Public ordinary functions
Function, with-shared-memory-spec-var: Public ordinary functions
Function, with-shared-memory-specs: Public ordinary functions
Function, with-shared-memory-statements: Public ordinary functions
function-argument-types: Private ordinary functions
function-argument-types: Private ordinary functions
function-argument-vars: Private ordinary functions
function-arguments: Private ordinary functions
function-body: Private ordinary functions
function-c-name: Private ordinary functions
function-c-name: Private ordinary functions
function-environment-add-function: Public ordinary functions
function-environment-add-macro: Public ordinary functions
function-environment-function-argument-types: Public ordinary functions
function-environment-function-c-name: Public ordinary functions
function-environment-function-exists-p: Public ordinary functions
function-environment-function-name: Public ordinary functions
function-environment-function-return-type: Public ordinary functions
function-environment-macro-exists-p: Public ordinary functions
function-environment-macro-expander: Public ordinary functions
function-environment-macro-name: Public ordinary functions
function-modified-p: Private ordinary functions
function-name: Private ordinary functions
function-name: Private ordinary functions
function-operands: Public ordinary functions
function-operator: Public ordinary functions
function-p: Public ordinary functions
function-p: Private ordinary functions
function-p: Private ordinary functions
function-return-type: Private ordinary functions
function-return-type: Private ordinary functions

G
get-cu-path: Private ordinary functions
get-cuda-device: Public ordinary functions
get-error-string: Private ordinary functions
get-include-path: Private ordinary functions
get-nvcc-arch: Private ordinary functions
get-nvcc-options: Private ordinary functions
get-ptx-path: Private ordinary functions
get-tmp-path: Private ordinary functions
global-c-name: Private ordinary functions
global-c-name: Private ordinary functions
global-initializer: Private ordinary functions
global-initializer: Private ordinary functions
global-modified-p: Private ordinary functions
global-name: Private ordinary functions
global-name: Private ordinary functions
global-p: Private ordinary functions
global-p: Private ordinary functions
global-qualifiers: Private ordinary functions
global-ref: Public ordinary functions
global-type: Private ordinary functions
grid-dim-p: Public ordinary functions

H
host-memory-aref: Public ordinary functions

I
if-else-statement: Public ordinary functions
if-p: Public ordinary functions
if-test-expression: Public ordinary functions
if-then-statement: Public ordinary functions
indent: Public ordinary functions
inferred-function: Private ordinary functions
inferred-function-candidates: Private ordinary functions
init-cuda: Public ordinary functions
inline-if-else-expression: Public ordinary functions
inline-if-p: Public ordinary functions
inline-if-test-expression: Public ordinary functions
inline-if-then-expression: Public ordinary functions
int-literal-p: Public ordinary functions

K
kernel->function-environment: Private ordinary functions
kernel->variable-environment: Private ordinary functions
kernel-define-function: Public ordinary functions
kernel-define-global: Public ordinary functions
kernel-define-macro: Public ordinary functions
kernel-define-symbol-macro: Public ordinary functions
kernel-function-argument-types: Public ordinary functions
kernel-function-argument-vars: Public ordinary functions
kernel-function-arguments: Public ordinary functions
kernel-function-body: Public ordinary functions
kernel-function-c-name: Public ordinary functions
kernel-function-exists-p: Public ordinary functions
kernel-function-name: Public ordinary functions
kernel-function-names: Public ordinary functions
kernel-function-namespace: Private ordinary functions
kernel-function-return-type: Public ordinary functions
kernel-global-c-name: Public ordinary functions
kernel-global-exists-p: Public ordinary functions
kernel-global-initializer: Public ordinary functions
kernel-global-name: Public ordinary functions
kernel-global-names: Public ordinary functions
kernel-global-qualifiers: Public ordinary functions
kernel-macro-arguments: Public ordinary functions
kernel-macro-body: Public ordinary functions
kernel-macro-exists-p: Public ordinary functions
kernel-macro-expander: Public ordinary functions
kernel-macro-name: Public ordinary functions
kernel-macro-names: Public ordinary functions
kernel-manager-%function-handle: Private ordinary functions
kernel-manager-%function-handles: Private ordinary functions
kernel-manager-%global-device-ptr: Private ordinary functions
kernel-manager-%global-device-ptrs: Private ordinary functions
kernel-manager-compile-module: Public ordinary functions
kernel-manager-compiled-p: Public ordinary functions
kernel-manager-define-function: Public ordinary functions
kernel-manager-define-global: Public ordinary functions
kernel-manager-define-macro: Public ordinary functions
kernel-manager-define-symbol-macro: Public ordinary functions
kernel-manager-function-handle: Public ordinary functions
kernel-manager-function-handles-empty-p: Public ordinary functions
kernel-manager-global-device-ptr: Public ordinary functions
kernel-manager-global-device-ptrs-empty-p: Public ordinary functions
kernel-manager-global-qualifiers: Public ordinary functions
kernel-manager-kernel: Private ordinary functions
kernel-manager-load-function: Public ordinary functions
kernel-manager-load-global: Public ordinary functions
kernel-manager-load-module: Public ordinary functions
kernel-manager-module-handle: Public ordinary functions
kernel-manager-module-path: Private ordinary functions
kernel-manager-p: Private ordinary functions
kernel-manager-unload: Public ordinary functions
kernel-p: Private ordinary functions
kernel-symbol-macro-exists-p: Public ordinary functions
kernel-symbol-macro-expansion: Public ordinary functions
kernel-symbol-macro-name: Public ordinary functions
kernel-symbol-macro-names: Public ordinary functions
kernel-variable-namespace: Private ordinary functions

L
let-binding-expr: Public ordinary functions
let-binding-p: Public ordinary functions
let-binding-var: Public ordinary functions
let-bindings: Public ordinary functions
let-p: Public ordinary functions
let-statements: Public ordinary functions
lines: Public ordinary functions
literal-p: Public ordinary functions

M
Macro, defcuenum: Private macros
Macro, defcufun: Private macros
Macro, defglobal: Public macros
Macro, defkernel: Public macros
Macro, defkernel-symbol-macro: Public macros
Macro, defkernelmacro: Public macros
Macro, with-cuda: Public macros
Macro, with-device-memory: Public macros
Macro, with-double3: Public macros
Macro, with-double4: Public macros
Macro, with-float3: Public macros
Macro, with-float4: Public macros
Macro, with-host-memory: Public macros
Macro, with-launching-arguments: Private macros
Macro, with-memory-block: Public macros
Macro, with-memory-blocks: Public macros
Macro, with-timer: Public macros
Macro, without-fp-traps: Private macros
macro-arguments: Private ordinary functions
macro-arguments: Private ordinary functions
macro-body: Private ordinary functions
macro-body: Private ordinary functions
macro-expander: Private ordinary functions
macro-expander: Private ordinary functions
macro-modified-p: Private ordinary functions
macro-name: Private ordinary functions
macro-name: Private ordinary functions
macro-operands: Public ordinary functions
macro-operator: Public ordinary functions
macro-p: Public ordinary functions
macro-p: Private ordinary functions
macro-p: Private ordinary functions
macrolet-binding-arguments: Public ordinary functions
macrolet-binding-body: Public ordinary functions
macrolet-binding-p: Public ordinary functions
macrolet-binding-symbol: Public ordinary functions
macrolet-bindings: Public ordinary functions
macrolet-p: Public ordinary functions
macrolet-statements: Public ordinary functions
make-double3: Public ordinary functions
make-double4: Public ordinary functions
make-float3: Public ordinary functions
make-float4: Public ordinary functions
make-function: Private ordinary functions
make-function: Private ordinary functions
make-global: Private ordinary functions
make-global: Private ordinary functions
make-kernel: Public ordinary functions
make-kernel-manager: Public ordinary functions
make-macro: Private ordinary functions
make-macro: Private ordinary functions
make-symbol-macro: Private ordinary functions
make-symbol-macro: Private ordinary functions
make-variable: Private ordinary functions
memcpy-device-to-host: Public ordinary functions
memcpy-device-to-host-async: Private ordinary functions
memcpy-host-to-device: Public ordinary functions
memcpy-host-to-device-async: Private ordinary functions
memory-block-aref: Public ordinary functions
memory-block-device-ptr: Public ordinary functions
memory-block-host-ptr: Public ordinary functions
memory-block-p: Public ordinary functions
memory-block-size: Public ordinary functions
memory-block-type: Public ordinary functions
Method, perform: Public standalone methods
Method, translate-from-foreign: Public standalone methods
Method, translate-from-foreign: Public standalone methods
Method, translate-from-foreign: Public standalone methods
Method, translate-into-foreign-memory: Public standalone methods
Method, translate-into-foreign-memory: Public standalone methods
Method, translate-into-foreign-memory: Public standalone methods
Method, translate-into-foreign-memory: Public standalone methods

N
nvcc-compile: Public ordinary functions

O
output-cuda-code: Private ordinary functions

P
perform: Public standalone methods
print-nvcc-command: Private ordinary functions
progn-p: Public ordinary functions
progn-statements: Public ordinary functions
ptr-binding: Private ordinary functions

R
record-cu-event: Private ordinary functions
reference-p: Public ordinary functions
return-expr: Public ordinary functions
return-p: Public ordinary functions
run-nvcc-command: Private ordinary functions

S
scalar-cffi-type: Private ordinary functions
scalar-cffi-type-size: Private ordinary functions
scalar-cuda-type: Private ordinary functions
scalar-type-p: Public ordinary functions
set-expression: Public ordinary functions
set-p: Public ordinary functions
set-reference: Public ordinary functions
setf-to-argument-array-form: Private ordinary functions
setf-to-foreign-object-form: Private ordinary functions
start-timer: Public ordinary functions
stop-timer: Public ordinary functions
structure-accessor-cuda-accessor: Public ordinary functions
structure-accessor-p: Public ordinary functions
structure-accessor-return-type: Public ordinary functions
structure-accessors: Private ordinary functions
structure-cffi-type: Private ordinary functions
structure-cffi-type-size: Private ordinary functions
structure-cuda-type: Private ordinary functions
structure-from-accessor: Public ordinary functions
structure-reference-accessor: Public ordinary functions
structure-reference-expr: Public ordinary functions
structure-reference-p: Public ordinary functions
structure-type-p: Public ordinary functions
symbol-macro-expansion: Private ordinary functions
symbol-macro-expansion: Private ordinary functions
symbol-macro-modified-p: Private ordinary functions
symbol-macro-name: Private ordinary functions
symbol-macro-name: Private ordinary functions
symbol-macro-p: Public ordinary functions
symbol-macro-p: Private ordinary functions
symbol-macro-p: Private ordinary functions
symbol-macrolet-binding-expansion: Public ordinary functions
symbol-macrolet-binding-p: Public ordinary functions
symbol-macrolet-binding-symbol: Public ordinary functions
symbol-macrolet-bindings: Public ordinary functions
symbol-macrolet-p: Public ordinary functions
symbol-macrolet-statements: Public ordinary functions
sync-cu-event: Private ordinary functions
sync-memory-block: Public ordinary functions
synchronize-context: Public ordinary functions
synchronize-timer: Public ordinary functions

T
thread-idx-p: Public ordinary functions
timer-p: Private ordinary functions
timer-start-event: Private ordinary functions
timer-stop-event: Private ordinary functions
translate-from-foreign: Public standalone methods
translate-from-foreign: Public standalone methods
translate-from-foreign: Public standalone methods
translate-into-foreign-memory: Public standalone methods
translate-into-foreign-memory: Public standalone methods
translate-into-foreign-memory: Public standalone methods
translate-into-foreign-memory: Public standalone methods
type-of-arithmetic: Private ordinary functions
type-of-array-reference: Private ordinary functions
type-of-built-in-function: Private ordinary functions
type-of-constructor: Private ordinary functions
type-of-cuda-dimension: Private ordinary functions
type-of-expression: Public ordinary functions
type-of-function: Private ordinary functions
type-of-inline-if: Private ordinary functions
type-of-literal: Private ordinary functions
type-of-macro: Private ordinary functions
type-of-operands: Private ordinary functions
type-of-operands: Private ordinary functions
type-of-reference: Private ordinary functions
type-of-structure-reference: Private ordinary functions
type-of-symbol-macro: Private ordinary functions
type-of-user-defined-function: Private ordinary functions
type-of-variable-reference: Private ordinary functions

U
unlines: Public ordinary functions

V
var-env-add-do-bindings: Private ordinary functions
var-env-add-let-bindings: Private ordinary functions
var-env-add-symbol-macrolet-bindings: Private ordinary functions
var-env-add-with-shared-memory-specs: Private ordinary functions
variable-environment-add-global: Public ordinary functions
variable-environment-add-symbol-macro: Public ordinary functions
variable-environment-add-variable: Public ordinary functions
variable-environment-global-c-name: Public ordinary functions
variable-environment-global-exists-p: Public ordinary functions
variable-environment-global-initializer: Public ordinary functions
variable-environment-global-name: Public ordinary functions
variable-environment-global-type: Public ordinary functions
variable-environment-symbol-macro-exists-p: Public ordinary functions
variable-environment-symbol-macro-expansion: Public ordinary functions
variable-environment-symbol-macro-name: Public ordinary functions
variable-environment-variable-exists-p: Public ordinary functions
variable-environment-variable-name: Public ordinary functions
variable-environment-variable-type: Public ordinary functions
variable-name: Private ordinary functions
variable-p: Private ordinary functions
variable-qualifier-p: Private ordinary functions
variable-reference-p: Public ordinary functions
variable-type: Private ordinary functions

W
with-cuda: Public macros
with-device-memory: Public macros
with-double3: Public macros
with-double4: Public macros
with-float3: Public macros
with-float4: Public macros
with-host-memory: Public macros
with-launching-arguments: Private macros
with-memory-block: Public macros
with-memory-blocks: Public macros
with-shared-memory-p: Public ordinary functions
with-shared-memory-spec-dimensio