The cl-cuda Reference Manual

Table of Contents

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 3.0 "Montgomery Scott" on Fri Jun 26 10:08:13 2020 GMT+0.


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

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.


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

2 Systems

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


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

2.1 cl-cuda

Author

Masayuki Takagi

License

MIT

Description

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

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
Source

cl-cuda.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 cl-cuda/src

Parent

cl-cuda (system)

Location

src/

Components

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

3.2 cl-cuda/src/driver-api

Parent

src (module)

Location

src/driver-api/

Components

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

3.3 cl-cuda/src/lang

Dependency

driver-api (module)

Parent

src (module)

Location

src/lang/

Components

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

3.4 cl-cuda/src/api

Dependency

lang (module)

Parent

src (module)

Location

src/api/

Components

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

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


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

4.1.1 cl-cuda.asd

Location

cl-cuda.asd

Systems

cl-cuda (system)

Packages

cl-cuda-asd

Internal Definitions

cuda-grovel-file (class)


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

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

Parent

driver-api (module)

Location

src/driver-api/package.lisp

Packages

cl-cuda.driver-api


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

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

Dependency

package.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/get-error-string.lisp

Internal Definitions

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

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

Dependency

get-error-string.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/cffi-grovel.lisp


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

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

Dependency

cffi-grovel.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/sdk-not-found.lisp

Exported Definitions

*sdk-not-found* (special variable)

Internal Definitions

sdk-not-found-error (condition)


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

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

Dependency

sdk-not-found.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/library.lisp


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

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

Dependency

library.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/type.lisp


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

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

If Feature

cuda-sdk

Dependency

type.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/type-grovel.lisp


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

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

Dependency

type-grovel.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/enum.lisp

Exported Definitions
Internal Definitions

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

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

Dependency

enum.lisp (file)

Parent

driver-api (module)

Location

src/driver-api/function.lisp

Exported Definitions
Internal Definitions

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

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

Parent

lang (module)

Location

src/lang/util.lisp

Packages

cl-cuda.lang.util

Exported Definitions
Internal Definitions

%c-identifier (function)


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

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

Dependency

util.lisp (file)

Parent

lang (module)

Location

src/lang/data.lisp

Packages

cl-cuda.lang.data

Exported Definitions
Internal Definitions

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

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

Dependency

data.lisp (file)

Parent

lang (module)

Location

src/lang/type.lisp

Packages

cl-cuda.lang.type

Exported Definitions
Internal Definitions

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

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

Dependency

type.lisp (file)

Parent

lang (module)

Location

src/lang/syntax.lisp

Packages

cl-cuda.lang.syntax

Exported Definitions
Internal Definitions

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

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

Dependency

syntax.lisp (file)

Parent

lang (module)

Location

src/lang/environment.lisp

Packages

cl-cuda.lang.environment

Exported Definitions
Internal Definitions

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

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

Dependency

environment.lisp (file)

Parent

lang (module)

Location

src/lang/built-in.lisp

Packages

cl-cuda.lang.built-in

Exported Definitions
Internal Definitions

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

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

Dependency

built-in.lisp (file)

Parent

lang (module)

Location

src/lang/kernel.lisp

Packages

cl-cuda.lang.kernel

Exported Definitions
Internal Definitions

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

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

Dependency

kernel.lisp (file)

Parent

lang (module)

Location

src/lang/compiler/compile-data.lisp

Packages

cl-cuda.lang.compiler.compile-data

Exported Definitions

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

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

Dependency

compiler/compile-data.lisp (file)

Parent

lang (module)

Location

src/lang/compiler/compile-type.lisp

Packages

cl-cuda.lang.compiler.compile-type

Exported Definitions

compile-type (function)


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

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

Dependency

compiler/compile-type.lisp (file)

Parent

lang (module)

Location

src/lang/compiler/type-of-expression.lisp

Packages

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

Exported Definitions

type-of-expression (function)

Internal Definitions

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

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

Dependency

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

Parent

lang (module)

Location

src/lang/compiler/compile-expression.lisp

Packages

cl-cuda.lang.compiler.compile-expression

Exported Definitions

compile-expression (function)

Internal Definitions

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

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

Dependency

compiler/compile-expression.lisp (file)

Parent

lang (module)

Location

src/lang/compiler/compile-statement.lisp

Packages

cl-cuda.lang.compiler.compile-statement

Exported Definitions

compile-statement (function)

Internal Definitions

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

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

Dependency

compiler/compile-statement.lisp (file)

Parent

lang (module)

Location

src/lang/compiler/compile-kernel.lisp

Packages

cl-cuda.lang.compiler.compile-kernel

Exported Definitions

compile-kernel (function)

Internal Definitions

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

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

Dependency

compiler/compile-kernel.lisp (file)

Parent

lang (module)

Location

src/lang/lang.lisp

Packages

cl-cuda.lang


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

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

Parent

api (module)

Location

src/api/nvcc.lisp

Packages

cl-cuda.api.nvcc

Exported Definitions
Internal Definitions

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

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

Dependency

nvcc.lisp (file)

Parent

api (module)

Location

src/api/kernel-manager.lisp

Packages

cl-cuda.api.kernel-manager

Exported Definitions
Internal Definitions

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

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

Dependency

kernel-manager.lisp (file)

Parent

api (module)

Location

src/api/memory.lisp

Packages

cl-cuda.api.memory

Exported Definitions
Internal Definitions

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

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

Dependency

memory.lisp (file)

Parent

api (module)

Location

src/api/context.lisp

Packages

cl-cuda.api.context

Exported Definitions
Internal Definitions

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

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

Dependency

context.lisp (file)

Parent

api (module)

Location

src/api/defkernel.lisp

Packages

cl-cuda.api.defkernel

Exported Definitions
Internal Definitions

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

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

Dependency

defkernel.lisp (file)

Parent

api (module)

Location

src/api/macro.lisp

Packages

cl-cuda.api.macro


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

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

Dependency

macro.lisp (file)

Parent

api (module)

Location

src/api/timer.lisp

Packages

cl-cuda.api.timer

Exported Definitions
Internal Definitions

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

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

Dependency

timer.lisp (file)

Parent

api (module)

Location

src/api/api.lisp

Packages

cl-cuda.api


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

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

Dependency

api (module)

Parent

src (module)

Location

src/cl-cuda.lisp

Packages

cl-cuda


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

5 Packages

Packages are listed by definition order.


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

5.1 cl-cuda-asd

Source

cl-cuda.asd

Use List
Internal Definitions

cuda-grovel-file (class)


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

5.2 cl-cuda.driver-api

Source

package.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

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

5.3 cl-cuda.lang.util

Source

util.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

%c-identifier (function)


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

5.4 cl-cuda.lang.data

Source

data.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

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

5.5 cl-cuda.lang.type

Source

type.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.6 cl-cuda.lang.syntax

Source

syntax.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.7 cl-cuda.lang.environment

Source

environment.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.8 cl-cuda.lang.built-in

Source

built-in.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.9 cl-cuda.lang.kernel

Source

kernel.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

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

Source

compiler/compile-data.lisp (file)

Use List
Used By List
Exported Definitions

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

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

Source

compiler/compile-type.lisp (file)

Use List
Used By List
Exported Definitions

compile-type (function)


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

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

Source

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

Use List
Used By List
Exported Definitions

type-of-expression (function)

Internal Definitions

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

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

Source

compiler/compile-expression.lisp (file)

Use List
Used By List
Exported Definitions

compile-expression (function)

Internal Definitions

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

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

Source

compiler/compile-statement.lisp (file)

Use List
Used By List

cl-cuda.lang.compiler.compile-kernel

Exported Definitions

compile-statement (function)

Internal Definitions

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

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

Source

compiler/compile-kernel.lisp (file)

Use List
Used By List

cl-cuda.api.kernel-manager

Exported Definitions

compile-kernel (function)

Internal Definitions

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

5.16 cl-cuda.lang

Source

lang.lisp (file)

Use List

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

5.17 cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

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

5.18 cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.19 cl-cuda.api.memory

Source

memory.lisp (file)

Use List
Used By List

cl-cuda.api.defkernel

Exported Definitions
Internal Definitions

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

5.20 cl-cuda.api.context

Source

context.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.21 cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Use List
Used By List

cl-cuda.api.macro

Exported Definitions
Internal Definitions

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

5.22 cl-cuda.api.macro

Source

macro.lisp (file)

Use List

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

5.23 cl-cuda.api.timer

Source

timer.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.24 cl-cuda.api

Source

api.lisp (file)

Use List

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

5.25 cl-cuda

Source

cl-cuda.lisp (file)

Use List

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Constants

Constant: cu-event-blocking-sync
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Constant: cu-event-default
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Constant: cu-event-disable-timing
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Constant: cu-event-interprocess
Package

cl-cuda.driver-api

Source

enum.lisp (file)


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

6.1.2 Special variables

Special Variable: *cuda-context*
Package

cl-cuda.api.context

Source

context.lisp (file)

Special Variable: *cuda-device*
Package

cl-cuda.api.context

Source

context.lisp (file)

Special Variable: *cuda-stream*
Package

cl-cuda.api.context

Source

context.lisp (file)

Special Variable: *kernel-manager*
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

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 (file)

Special Variable: *nvcc-options*
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Special Variable: *sdk-not-found*
Package

cl-cuda.driver-api

Source

sdk-not-found.lisp (file)

Special Variable: *show-messages*
Package

cl-cuda.driver-api

Source

function.lisp (file)

Special Variable: *tmp-path*
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)


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

6.1.3 Macros

Macro: defglobal NAME EXPRESSION &optional QUALIFIERS
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Macro: defkernel NAME (RETURN-TYPE ARGUMENTS) &body BODY
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Macro: defkernel-symbol-macro NAME EXPANSION
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Macro: defkernelmacro NAME ARGUMENTS &body BODY
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Macro: with-cuda (DEV-ID) &body BODY
Package

cl-cuda.api.context

Source

context.lisp (file)

Macro: with-device-memory (VAR TYPE N) &body BODY
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Macro: with-double3 (X Y Z) VALUE &body BODY
Package

cl-cuda.lang.data

Source

data.lisp (file)

Macro: with-double4 (X Y Z W) VALUE &body BODY
Package

cl-cuda.lang.data

Source

data.lisp (file)

Macro: with-float3 (X Y Z) VALUE &body BODY
Package

cl-cuda.lang.data

Source

data.lisp (file)

Macro: with-float4 (X Y Z W) VALUE &body BODY
Package

cl-cuda.lang.data

Source

data.lisp (file)

Macro: with-host-memory (VAR TYPE N) &body BODY
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Macro: with-memory-block (VAR TYPE SIZE) &body BODY
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Macro: with-memory-blocks BINDINGS &body BODY
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Macro: with-timer (VAR) &body BODY
Package

cl-cuda.api.timer

Source

timer.lisp (file)


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

6.1.4 Functions

Function: alloc-device-memory TYPE N
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: alloc-host-memory TYPE N
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: alloc-memory-block TYPE SIZE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: argument-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: argument-type ARGUMENT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: argument-var ARGUMENT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: arithmetic-operands FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: arithmetic-operator FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: arithmetic-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: array-reference-expr FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: array-reference-indices FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: array-reference-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: array-type TYPE DIMENSION
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: array-type-base TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: array-type-dimension TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: array-type-p OBJECT
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: block-dim-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: block-idx-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: bool-literal-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: built-in-function-c-name NAME ARGUMENT-TYPES
Package

cl-cuda.lang.built-in

Source

built-in.lisp (file)

Function: built-in-function-infix-p NAME ARGUMENT-TYPES
Package

cl-cuda.lang.built-in

Source

built-in.lisp (file)

Function: built-in-function-return-type NAME ARGUMENT-TYPES
Package

cl-cuda.lang.built-in

Source

built-in.lisp (file)

Function: c-identifier SYMBOL &optional PACKAGE-P
Package

cl-cuda.lang.util

Source

util.lisp (file)

Function: cffi-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: cffi-type-size TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: cl-cuda-bool-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: cl-cuda-double-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: cl-cuda-float-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: cl-cuda-int-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: cl-cuda-symbol-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: cl-cuda-type-p OBJECT
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: compile-bool EXPR
Package

cl-cuda.lang.compiler.compile-data

Source

compiler/compile-data.lisp (file)

Function: compile-double EXPR
Package

cl-cuda.lang.compiler.compile-data

Source

compiler/compile-data.lisp (file)

Function: compile-expression FORM VAR-ENV FUNC-ENV &optional INITIALIZER-P
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-float EXPR
Package

cl-cuda.lang.compiler.compile-data

Source

compiler/compile-data.lisp (file)

Function: compile-int EXPR
Package

cl-cuda.lang.compiler.compile-data

Source

compiler/compile-data.lisp (file)

Function: compile-kernel KERNEL
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-statement FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-symbol EXPR
Package

cl-cuda.lang.compiler.compile-data

Source

compiler/compile-data.lisp (file)

Function: compile-type TYPE
Package

cl-cuda.lang.compiler.compile-type

Source

compiler/compile-type.lisp (file)

Function: constructor-operands FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: constructor-operator FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: constructor-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: create-cuda-context DEVICE
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: create-timer ()
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: cu-ctx-create PCTX FLAGS DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-ctx-destroy CTX
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-ctx-synchronize ()
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-device-compute-capability MAJOR MINOR DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-device-get DEVICE ORDINAL
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-device-get-count COUNT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-device-get-name NAME LEN DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-device-total-mem BYTES DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-event-create PHEVENT FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-event-destroy H-EVENT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-event-elapsed-time PMILLISECONDS HSTART HEND
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-event-record HEVENT HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-event-synchronize HEVENT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-init FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

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 (file)

Function: cu-mem-alloc DPTR BYTESIZE
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-mem-free DPTR
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-mem-host-register P BYTE-SIZE FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-mem-host-unregister P
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-memcpy-device-to-host DST-HOST SRC-DEVICE BYTE-COUNT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-memcpy-device-to-host-async DST-HOST SRC-DEVICE BYTE-COUNT HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-memcpy-host-to-device DST-DEVICE SRC-HOST BYTE-COUNT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-memcpy-host-to-device-async DST-DEVICE SRC-HOST BYTE-COUNT HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-module-get-function HFUNC HMOD NAME
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-module-get-global DPTR BYTES HMOD NAME
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-module-load MODULE FNAME
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-module-unload MODULE
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-stream-create PHSTREAM FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-stream-destroy HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-stream-query HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-stream-synchronize HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cu-stream-wait-event HSTREAM HEVENT FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: cuda-dimension-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: cuda-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: destroy-cuda-context CONTEXT
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: destroy-timer TIMER
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: device-compute-capability DEVICE
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: device-total-bytes DEVICE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: device-total-gbytes DEVICE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: device-total-kbytes DEVICE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: device-total-mbytes DEVICE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: do-binding-init BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-binding-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-binding-step BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-binding-var BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-bindings FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-end-test FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: do-statements FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: double-literal-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: double3-= A B
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double3-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double3-x INSTANCE
Function: (setf double3-x) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double3-y INSTANCE
Function: (setf double3-y) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double3-z INSTANCE
Function: (setf double3-z) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double4-= A B
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double4-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double4-w INSTANCE
Function: (setf double4-w) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double4-x INSTANCE
Function: (setf double4-x) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double4-y INSTANCE
Function: (setf double4-y) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: double4-z INSTANCE
Function: (setf double4-z) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: elapsed-time TIMER
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: empty-function-environment ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: empty-variable-environment ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: ensure-kernel-function-loaded MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: ensure-kernel-global-loaded MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: ensure-kernel-module-compiled MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: ensure-kernel-module-loaded MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: expand-macro FORM KERNEL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: expand-macro FORM MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: expand-macro FORM
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: expand-macro-1 FORM KERNEL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: expand-macro-1 FORM MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: expand-macro-1 FORM
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: float-literal-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: float3-= A B
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float3-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float3-x INSTANCE
Function: (setf float3-x) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float3-y INSTANCE
Function: (setf float3-y) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float3-z INSTANCE
Function: (setf float3-z) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float4-= A B
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float4-p OBJECT
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float4-w INSTANCE
Function: (setf float4-w) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float4-x INSTANCE
Function: (setf float4-x) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float4-y INSTANCE
Function: (setf float4-y) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: float4-z INSTANCE
Function: (setf float4-z) VALUE INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: free-device-memory DEVICE-PTR
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: free-host-memory HOST-PTR
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: free-memory-block MEMORY-BLOCK
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: function-environment-add-function NAME RETURN-TYPE ARGUMENT-TYPES FUNC-ENV
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-add-macro NAME ARGUMENTS BODY FUNC-ENV
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-function-argument-types FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-function-c-name FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-function-exists-p FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-function-name FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-function-return-type FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-macro-exists-p FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-macro-expander FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-environment-macro-name FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-operands FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: function-operator FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: function-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: get-cuda-device DEV-ID
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: global-ref NAME TYPE &optional MANAGER
Function: (setf global-ref) VALUE NAME TYPE &optional MANAGER
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: grid-dim-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: host-memory-aref HOST-PTR TYPE INDEX
Function: (setf host-memory-aref) NEW-VALUE HOST-PTR TYPE INDEX
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: if-else-statement FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: if-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: if-test-expression FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: if-then-statement FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: indent N STR
Package

cl-cuda.lang.util

Source

util.lisp (file)

Function: init-cuda ()
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: inline-if-else-expression FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: inline-if-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: inline-if-test-expression FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: inline-if-then-expression FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: int-literal-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: kernel-define-function KERNEL NAME RETURN-TYPE ARGUMENTS BODY
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-define-global KERNEL NAME QUALIFIERS EXPRESSION
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-define-macro KERNEL NAME ARGUMENTS BODY
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-define-symbol-macro KERNEL NAME EXPANSION
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-argument-types KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-argument-vars KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-arguments KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-body KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-c-name KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-exists-p KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-name KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-names KERNEL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-function-return-type KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-global-c-name KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-global-exists-p KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-global-initializer KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-global-name KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-global-names KERNEL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-global-qualifiers KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-macro-arguments KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-macro-body KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-macro-exists-p KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-macro-expander KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-macro-name KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-macro-names KERNEL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-manager-compile-module MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-compiled-p MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-define-function MANAGER NAME RETURN-TYPE ARGUMENTS BODY
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-define-global MANAGER NAME QUALIFIERS &optional EXPRESSION
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-define-macro MANAGER NAME ARGUMENTS BODY
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-define-symbol-macro MANAGER NAME EXPANSION
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-function-handle MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-function-handles-empty-p MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-global-device-ptr MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-global-device-ptrs-empty-p MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-global-qualifiers MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-load-function MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-load-global MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-load-module MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-module-handle INSTANCE
Function: (setf kernel-manager-module-handle) VALUE INSTANCE
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-unload MANAGER
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-symbol-macro-exists-p KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-symbol-macro-expansion KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-symbol-macro-name KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-symbol-macro-names KERNEL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: let-binding-expr BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: let-binding-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: let-binding-var BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: let-bindings FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: let-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: let-statements FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: lines STR
Package

cl-cuda.lang.util

Source

util.lisp (file)

Function: literal-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macro-operands FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macro-operator FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macro-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-binding-arguments BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-binding-body BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-binding-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-binding-symbol BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-bindings FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: macrolet-statements FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: make-double3 X Y Z
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: make-double4 X Y Z W
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: make-float3 X Y Z
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: make-float4 X Y Z W
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: make-kernel ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: make-kernel-manager ()
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: memcpy-device-to-host HOST-PTR DEVICE-PTR TYPE N
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memcpy-host-to-device DEVICE-PTR HOST-PTR TYPE N
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memory-block-aref MEMORY-BLOCK INDEX
Function: (setf memory-block-aref) NEW-VALUE MEMORY-BLOCK INDEX
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memory-block-device-ptr INSTANCE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memory-block-host-ptr INSTANCE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memory-block-p OBJECT
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memory-block-size INSTANCE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memory-block-type INSTANCE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: nvcc-compile CUDA-CODE
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: progn-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: progn-statements FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: reference-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: return-expr FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: return-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: scalar-type-p OBJECT
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: set-expression FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: set-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: set-reference FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: start-timer TIMER
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: stop-timer TIMER
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: structure-accessor-cuda-accessor ACCESSOR
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-accessor-p ACCESSOR
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-accessor-return-type ACCESSOR
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-from-accessor ACCESSOR
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-reference-accessor FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: structure-reference-expr FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: structure-reference-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: structure-type-p OBJECT
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: symbol-macro-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: symbol-macrolet-binding-expansion BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: symbol-macrolet-binding-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: symbol-macrolet-binding-symbol BINDING
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: symbol-macrolet-bindings FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: symbol-macrolet-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: symbol-macrolet-statements FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: sync-memory-block MEMORY-BLOCK DIRECTION
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: synchronize-context ()
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: synchronize-timer TIMER
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: thread-idx-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: type-of-expression FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: unlines &rest ARGS
Package

cl-cuda.lang.util

Source

util.lisp (file)

Function: variable-environment-add-global NAME TYPE EXPRESSION VAR-ENV
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-add-symbol-macro NAME EXPANSION VAR-ENV
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-add-variable NAME TYPE VAR-ENV
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-global-c-name VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-global-exists-p VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-global-initializer VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-global-name VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-global-type VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-symbol-macro-exists-p VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-symbol-macro-expansion VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-symbol-macro-name VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-variable-exists-p VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-variable-name VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-environment-variable-type VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-reference-p FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-spec-dimensions SPEC
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-spec-p OBJECT
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-spec-type SPEC
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-spec-var SPEC
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-specs FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Function: with-shared-memory-statements FORM
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)


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

6.1.5 Structures

Structure: double3 ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

translate-into-foreign-memory (method)

Direct slots
Slot: x
Type

double-float

Initform

0.0d0

Readers

double3-x (function)

Writers

(setf double3-x) (function)

Slot: y
Type

double-float

Initform

0.0d0

Readers

double3-y (function)

Writers

(setf double3-y) (function)

Slot: z
Type

double-float

Initform

0.0d0

Readers

double3-z (function)

Writers

(setf double3-z) (function)

Structure: double4 ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

translate-into-foreign-memory (method)

Direct slots
Slot: x
Type

double-float

Initform

0.0d0

Readers

double4-x (function)

Writers

(setf double4-x) (function)

Slot: y
Type

double-float

Initform

0.0d0

Readers

double4-y (function)

Writers

(setf double4-y) (function)

Slot: z
Type

double-float

Initform

0.0d0

Readers

double4-z (function)

Writers

(setf double4-z) (function)

Slot: w
Type

double-float

Initform

0.0d0

Readers

double4-w (function)

Writers

(setf double4-w) (function)

Structure: float3 ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

translate-into-foreign-memory (method)

Direct slots
Slot: x
Type

single-float

Initform

0.0

Readers

float3-x (function)

Writers

(setf float3-x) (function)

Slot: y
Type

single-float

Initform

0.0

Readers

float3-y (function)

Writers

(setf float3-y) (function)

Slot: z
Type

single-float

Initform

0.0

Readers

float3-z (function)

Writers

(setf float3-z) (function)

Structure: float4 ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

translate-into-foreign-memory (method)

Direct slots
Slot: x
Type

single-float

Initform

0.0

Readers

float4-x (function)

Writers

(setf float4-x) (function)

Slot: y
Type

single-float

Initform

0.0

Readers

float4-y (function)

Writers

(setf float4-y) (function)

Slot: z
Type

single-float

Initform

0.0

Readers

float4-z (function)

Writers

(setf float4-z) (function)

Slot: w
Type

single-float

Initform

0.0

Readers

float4-w (function)

Writers

(setf float4-w) (function)

Structure: kernel-manager ()
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: module-path
Readers

kernel-manager-module-path (function)

Writers

(setf kernel-manager-module-path) (function)

Slot: module-handle
Readers

kernel-manager-module-handle (function)

Writers

(setf kernel-manager-module-handle) (function)

Slot: %function-handles
Readers

kernel-manager-%function-handles (function)

Writers

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

Slot: %global-device-ptrs
Readers

kernel-manager-%global-device-ptrs (function)

Writers

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

Slot: kernel
Readers

kernel-manager-kernel (function)

Writers

(setf kernel-manager-kernel) (function)


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

6.1.6 Types

Type: argument ()
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Type: cl-cuda-symbol ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Type: cl-cuda-type ()
Package

cl-cuda.lang.type

Source

type.lisp (file)


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

6.2 Internal definitions


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

6.2.1 Constants

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

cl-cuda.driver-api

Source

enum.lisp (file)

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

cl-cuda.driver-api

Source

enum.lisp (file)

Constant: cu-stream-default
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Constant: cu-stream-non-blocking
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Constant: size-of-cu-event
Package

cl-cuda.driver-api

Source

/home/quickref/.cache/common-lisp/sbcl-1.5.8-linux-x64/home/quickref/quicklisp/dists/quicklisp/software/cl-cuda-20200610-git/src/driver-api/type-grovel.processed-grovel-file

Constant: size-of-size-t
Package

cl-cuda.driver-api

Source

/home/quickref/.cache/common-lisp/sbcl-1.5.8-linux-x64/home/quickref/quicklisp/dists/quicklisp/software/cl-cuda-20200610-git/src/driver-api/type-grovel.processed-grovel-file


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

6.2.2 Special variables

Special Variable: +accessor->structure+
Package

cl-cuda.lang.type

Source

type.lisp (file)

Special Variable: +aritmetic-operators+
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Special Variable: +array-type-regex+
Package

cl-cuda.lang.type

Source

type.lisp (file)

Special Variable: +built-in-functions+
Package

cl-cuda.lang.built-in

Source

built-in.lisp (file)

Special Variable: +constructor-operators+
Package

cl-cuda.lang.syntax

Source

syntax.lisp (file)

Special Variable: +cuda-success+
Package

cl-cuda.driver-api

Source

function.lisp (file)

Special Variable: +error-strings+
Package

cl-cuda.driver-api

Source

get-error-string.lisp (file)

Special Variable: +scalar-types+
Package

cl-cuda.lang.type

Source

type.lisp (file)

Special Variable: +structure-table+
Package

cl-cuda.lang.type

Source

type.lisp (file)

Special Variable: +structure-types+
Package

cl-cuda.lang.type

Source

type.lisp (file)


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

6.2.3 Macros

Macro: defcuenum NAME-AND-OPTIONS &body ENUM-LIST
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Macro: defcufun (NAME C-NAME &key DISABLE-FP-TRAPS) RETURN-TYPE &rest ARGUMENTS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Macro: with-launching-arguments (VAR ARGUMENTS) &body BODY
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

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

cl-cuda.driver-api

Source

function.lisp (file)


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

6.2.4 Functions

Function: %add-function-arguments KERNEL NAME VAR-ENV
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: %add-functions KERNEL FUNC-ENV
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: %add-globals KERNEL VAR-ENV
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: %add-macros KERNEL FUNC-ENV
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: %add-symbol-macros KERNEL VAR-ENV
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: %c-identifier OBJECT
Package

cl-cuda.lang.util

Source

util.lisp (file)

Function: %cu-ctx-create PCTX FLAGS DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-ctx-destroy CTX
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-ctx-synchronize ()
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-device-compute-capability MAJOR MINOR DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-device-get DEVICE ORDINAL
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-device-get-count COUNT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-device-get-name NAME LEN DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-device-total-mem BYTES DEV
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-event-create PHEVENT FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-event-destroy H-EVENT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-event-elapsed-time PMILLISECONDS HSTART HEND
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-event-record HEVENT HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-event-synchronize HEVENT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-init FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

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 (file)

Function: %cu-mem-alloc DPTR BYTESIZE
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-mem-free DPTR
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-mem-host-register P BYTE-SIZE FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-mem-host-unregister P
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-memcpy-device-to-host DST-HOST SRC-DEVICE BYTE-COUNT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-memcpy-device-to-host-async DST-HOST SRC-DEVICE BYTE-COUNT HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-memcpy-host-to-device DST-DEVICE SRC-HOST BYTE-COUNT
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-memcpy-host-to-device-async DST-DEVICE SRC-HOST BYTE-COUNT HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-module-get-function HFUNC HMOD NAME
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-module-get-global DPTR BYTES HMOD NAME
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-module-load MODULE FNAME
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-module-unload MODULE
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-stream-create PHSTREAM FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-stream-destroy HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-stream-query HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-stream-synchronize HSTREAM
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %cu-stream-wait-event HSTREAM HEVENT FLAGS
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: %elapsed-time START STOP
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: %lookup-function FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %lookup-function KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %lookup-global VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %lookup-global KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %lookup-macro FUNC-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %lookup-macro KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %lookup-symbol-macro VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %lookup-symbol-macro KERNEL NAME
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %lookup-variable VAR-ENV NAME
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %macro-p FORM FUNC-ENV
Package

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

Source

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

Function: %macro-p FORM FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: %macro-p FORM FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: %make-function &key (NAME NAME) (RETURN-TYPE RETURN-TYPE) (ARGUMENT-TYPES ARGUMENT-TYPES)
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %make-function &key (NAME NAME) (RETURN-TYPE RETURN-TYPE) (ARGUMENTS ARGUMENTS) (BODY BODY)
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %make-global &key (NAME NAME) (TYPE TYPE) (INITIALIZER INITIALIZER)
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %make-global &key (NAME NAME) (QUALIFIERS QUALIFIERS) (INITIALIZER INITIALIZER)
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %make-kernel &key (VARIABLE-NAMESPACE VARIABLE-NAMESPACE) (FUNCTION-NAMESPACE FUNCTION-NAMESPACE)
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %make-kernel-manager &key (MODULE-PATH MODULE-PATH) (MODULE-HANDLE MODULE-HANDLE) (%FUNCTION-HANDLES %FUNCTION-HANDLES) (%GLOBAL-DEVICE-PTRS %GLOBAL-DEVICE-PTRS) (KERNEL KERNEL)
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: %make-macro &key (NAME NAME) (ARGUMENTS ARGUMENTS) (BODY BODY)
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %make-macro &key (NAME NAME) (ARGUMENTS ARGUMENTS) (BODY BODY)
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %make-memory-block &key (DEVICE-PTR DEVICE-PTR) (HOST-PTR HOST-PTR) (TYPE TYPE) (SIZE SIZE)
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: %make-symbol-macro &key (NAME NAME) (EXPANSION EXPANSION)
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %make-symbol-macro &key (NAME NAME) (EXPANSION EXPANSION)
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: %make-timer &key (START-EVENT START-EVENT) (STOP-EVENT STOP-EVENT)
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: %make-variable &key (NAME NAME) (TYPE TYPE)
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: %structure-from-accessor ACCESSOR
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: %symbol-macro-p FORM VAR-ENV
Package

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

Source

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

Function: %symbol-macro-p FORM VAR-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: append-arch OPTIONS DEV-ID
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: arch-exists-p OPTIONS
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: argument-cffi-type ARGUMENT
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: argument-var-ptr ARGUMENT
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: argument-vars ARGUMENTS
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: array-cffi-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: array-cffi-type-size TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: array-cuda-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: array-type-stars TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: check-cuda-error NAME RETURN-CODE
Package

cl-cuda.driver-api

Source

function.lisp (file)

Function: compile-argument ARGUMENT
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-arguments ARGUMENTS
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-arithmetic FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-array-indices INDICES VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-array-reference FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-bool-literal FORM
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-built-in-function FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

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 (file)

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 (file)

Function: compile-constructor FORM VAR-ENV FUNC-ENV INITIALIZER-P
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-cuda-dimension FORM
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-declaration KERNEL NAME
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-definition KERNEL NAME
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-definitions KERNEL
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-do FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-do-init-part BINDINGS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-do-statements STATEMENTS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-do-step-part BINDINGS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-do-test-part END-TEST VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-double-literal FORM
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-float-literal FORM
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-function FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-function FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-global KERNEL NAME
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-globals KERNEL
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-if FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-includes ()
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-inline-if FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-int-literal FORM
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-let FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-let-bindings BINDINGS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-let-statements STATEMENTS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-literal FORM
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-macro FORM VAR-ENV FUNC-ENV INITIALIZER-P
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-macro FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-macrolet FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-macrolet-statements STATEMENTS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-operands OPERANDS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-progn FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-prototype KERNEL NAME
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-prototypes KERNEL
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-reference FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-return FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-set FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-specifier RETURN-TYPE
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-statements KERNEL NAME
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-structure-reference FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-symbol-macro FORM VAR-ENV FUNC-ENV INITIALIZER-P
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-symbol-macrolet FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-symbol-macrolet-statements STATEMENTS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-user-defined-function FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-variable-qualifier QUALIFIER
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: compile-variable-reference FORM VAR-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: compile-with-shared-memory FORM VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-with-shared-memory-spec-dimensions DIMS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-with-shared-memory-specs SPECS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: compile-with-shared-memory-statements STATEMENTS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: copy-%function INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: copy-%function INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: copy-double3 INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: copy-double4 INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: copy-float3 INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: copy-float4 INSTANCE
Package

cl-cuda.lang.data

Source

data.lisp (file)

Function: copy-global INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: copy-global INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: copy-kernel INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: copy-kernel-manager INSTANCE
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: copy-macro INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: copy-macro INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: copy-memory-block INSTANCE
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: copy-symbol-macro INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: copy-symbol-macro INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: copy-timer INSTANCE
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: copy-variable INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: create-cu-event ()
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: defconstant-enum-value NAME ENUM-ELEM
Package

cl-cuda.driver-api

Source

enum.lisp (file)

Function: destroy-cu-event CU-EVENT
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: func-env-add-macrolet-bindings FUNC-ENV BINDINGS
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: function-argument-types INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-argument-types FUNCTION
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-argument-vars FUNCTION
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-arguments INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-body INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-c-name FUNCTION
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-c-name FUNCTION
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-modified-p KERNEL NAME RETURN-TYPE ARGUMENTS BODY
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: function-name INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-name INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-p OBJECT
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-p OBJECT
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: function-return-type INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: function-return-type INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: get-cu-path ()
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: get-error-string N
Package

cl-cuda.driver-api

Source

get-error-string.lisp (file)

Function: get-include-path ()
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: get-nvcc-arch DEV-ID
Package

cl-cuda.api.context

Source

context.lisp (file)

Function: get-nvcc-options CU-PATH PTX-PATH
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: get-ptx-path CU-PATH
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: get-tmp-path ()
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: global-c-name GLOBAL
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: global-c-name GLOBAL
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: global-initializer INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: global-initializer INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: global-modified-p KERNEL NAME QUALIFIERS EXPRESSION
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: global-name INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: global-name INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: global-p OBJECT
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: global-p OBJECT
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: global-qualifiers INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: global-type INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: inferred-function NAME ARGUMENT-TYPES
Package

cl-cuda.lang.built-in

Source

built-in.lisp (file)

Function: inferred-function-candidates NAME
Package

cl-cuda.lang.built-in

Source

built-in.lisp (file)

Function: kernel->function-environment KERNEL
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: kernel->variable-environment KERNEL NAME
Package

cl-cuda.lang.compiler.compile-kernel

Source

compiler/compile-kernel.lisp (file)

Function: kernel-function-namespace INSTANCE
Function: (setf kernel-function-namespace) VALUE INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-manager-%function-handle MANAGER NAME
Function: (setf kernel-manager-%function-handle) VALUE MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-%function-handles INSTANCE
Function: (setf kernel-manager-%function-handles) VALUE INSTANCE
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-%global-device-ptr MANAGER NAME
Function: (setf kernel-manager-%global-device-ptr) VALUE MANAGER NAME
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-%global-device-ptrs INSTANCE
Function: (setf kernel-manager-%global-device-ptrs) VALUE INSTANCE
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-kernel INSTANCE
Function: (setf kernel-manager-kernel) VALUE INSTANCE
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-module-path INSTANCE
Function: (setf kernel-manager-module-path) VALUE INSTANCE
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-manager-p OBJECT
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: kernel-p OBJECT
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: kernel-variable-namespace INSTANCE
Function: (setf kernel-variable-namespace) VALUE INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: macro-arguments INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: macro-arguments INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: macro-body INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: macro-body INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: macro-expander MACRO
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: macro-expander MACRO
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: macro-modified-p KERNEL NAME ARGUMENTS BODY
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: macro-name INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: macro-name INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: macro-p OBJECT
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: macro-p OBJECT
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: make-function NAME RETURN-TYPE ARGUMENT-TYPES
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: make-function NAME RETURN-TYPE ARGUMENTS BODY
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: make-global NAME TYPE INITIALIZER
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: make-global NAME QUALIFIERS INITIALIZER
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: make-macro NAME ARGUMENTS BODY
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: make-macro NAME ARGUMENTS BODY
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: make-symbol-macro NAME EXPANSION
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: make-symbol-macro NAME EXPANSION
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: make-variable NAME TYPE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: memcpy-device-to-host-async HOST-PTR DEVICE-PTR TYPE N STREAM
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: memcpy-host-to-device-async DEVICE-PTR HOST-PTR TYPE N STREAM
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Function: output-cuda-code CU-PATH CUDA-CODE
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: print-nvcc-command CU-PATH PTX-PATH
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: ptr-binding ARGUMENT
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: record-cu-event CU-EVENT
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: run-nvcc-command CU-PATH PTX-PATH
Package

cl-cuda.api.nvcc

Source

nvcc.lisp (file)

Function: scalar-cffi-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: scalar-cffi-type-size TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: scalar-cuda-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: setf-to-argument-array-form VAR ARGUMENT I
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: setf-to-foreign-object-form ARGUMENT
Package

cl-cuda.api.defkernel

Source

defkernel.lisp (file)

Function: structure-accessors TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-cffi-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-cffi-type-size TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: structure-cuda-type TYPE
Package

cl-cuda.lang.type

Source

type.lisp (file)

Function: symbol-macro-expansion INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: symbol-macro-expansion INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: symbol-macro-modified-p KERNEL NAME EXPANSION
Package

cl-cuda.api.kernel-manager

Source

kernel-manager.lisp (file)

Function: symbol-macro-name INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: symbol-macro-name INSTANCE
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: symbol-macro-p OBJECT
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: symbol-macro-p OBJECT
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: sync-cu-event CU-EVENT
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: timer-p OBJECT
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: timer-start-event INSTANCE
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: timer-stop-event INSTANCE
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Function: type-of-arithmetic FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-array-reference FORM VAR-ENV FUNC-ENV
Package

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

Source

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

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 (file)

Function: type-of-constructor FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-cuda-dimension FORM
Package

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

Source

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

Function: type-of-function FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-inline-if FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-literal FORM
Package

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

Source

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

Function: type-of-macro FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-operands OPERANDS VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-operands OPERANDS VAR-ENV FUNC-ENV
Package

cl-cuda.lang.compiler.compile-expression

Source

compiler/compile-expression.lisp (file)

Function: type-of-reference FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-structure-reference FORM VAR-ENV FUNC-ENV
Package

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

Source

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

Function: type-of-symbol-macro FORM VAR-ENV FUNC-ENV
Package

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

Source

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

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 (file)

Function: type-of-variable-reference FORM VAR-ENV
Package

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

Source

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

Function: var-env-add-do-bindings VAR-ENV FUNC-ENV BINDINGS
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: var-env-add-let-bindings VAR-ENV FUNC-ENV BINDINGS
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: var-env-add-symbol-macrolet-bindings VAR-ENV BINDINGS
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: var-env-add-with-shared-memory-specs VAR-ENV SPECS
Package

cl-cuda.lang.compiler.compile-statement

Source

compiler/compile-statement.lisp (file)

Function: variable-name INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-p OBJECT
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Function: variable-qualifier-p OBJECT
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Function: variable-type INSTANCE
Package

cl-cuda.lang.environment

Source

environment.lisp (file)


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

6.2.5 Conditions

Condition: sdk-not-found-error ()
Package

cl-cuda.driver-api

Source

sdk-not-found.lisp (file)

Direct superclasses

simple-error (condition)


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

6.2.6 Structures

Structure: %function ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

function-name (function)

Writers

(setf function-name) (function)

Slot: return-type
Initform

:return-type

Readers

function-return-type (function)

Writers

(setf function-return-type) (function)

Slot: argument-types
Initform

:argument-types

Readers

function-argument-types (function)

Writers

(setf function-argument-types) (function)

Structure: %function ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

function-name (function)

Writers

(setf function-name) (function)

Slot: return-type
Initform

:return-type

Readers

function-return-type (function)

Writers

(setf function-return-type) (function)

Slot: arguments
Initform

:arguments

Readers

function-arguments (function)

Writers

(setf function-arguments) (function)

Slot: body
Initform

:body

Readers

function-body (function)

Writers

(setf function-body) (function)

Structure: global ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

global-name (function)

Writers

(setf global-name) (function)

Slot: type
Initform

:type

Readers

global-type (function)

Writers

(setf global-type) (function)

Slot: initializer
Initform

:initializer

Readers

global-initializer (function)

Writers

(setf global-initializer) (function)

Structure: global ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

global-name (function)

Writers

(setf global-name) (function)

Slot: qualifiers
Initform

:qualifiers

Readers

global-qualifiers (function)

Writers

(setf global-qualifiers) (function)

Slot: initializer
Initform

:initializer

Readers

global-initializer (function)

Writers

(setf global-initializer) (function)

Structure: kernel ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: variable-namespace
Initform

:variable-namespace

Readers

kernel-variable-namespace (function)

Writers

(setf kernel-variable-namespace) (function)

Slot: function-namespace
Initform

:function-namespace

Readers

kernel-function-namespace (function)

Writers

(setf kernel-function-namespace) (function)

Structure: macro ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

macro-name (function)

Writers

(setf macro-name) (function)

Slot: arguments
Initform

:arguments

Readers

macro-arguments (function)

Writers

(setf macro-arguments) (function)

Slot: body
Initform

:body

Readers

macro-body (function)

Writers

(setf macro-body) (function)

Structure: macro ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

macro-name (function)

Writers

(setf macro-name) (function)

Slot: arguments
Initform

:arguments

Readers

macro-arguments (function)

Writers

(setf macro-arguments) (function)

Slot: body
Initform

:body

Readers

macro-body (function)

Writers

(setf macro-body) (function)

Structure: memory-block ()
Package

cl-cuda.api.memory

Source

memory.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: device-ptr
Initform

:device-ptr

Readers

memory-block-device-ptr (function)

Writers

(setf memory-block-device-ptr) (function)

Slot: host-ptr
Initform

:host-ptr

Readers

memory-block-host-ptr (function)

Writers

(setf memory-block-host-ptr) (function)

Slot: type
Initform

:type

Readers

memory-block-type (function)

Writers

(setf memory-block-type) (function)

Slot: size
Initform

:size

Readers

memory-block-size (function)

Writers

(setf memory-block-size) (function)

Structure: symbol-macro ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

symbol-macro-name (function)

Writers

(setf symbol-macro-name) (function)

Slot: expansion
Initform

:expansion

Readers

symbol-macro-expansion (function)

Writers

(setf symbol-macro-expansion) (function)

Structure: symbol-macro ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

symbol-macro-name (function)

Writers

(setf symbol-macro-name) (function)

Slot: expansion
Initform

:expansion

Readers

symbol-macro-expansion (function)

Writers

(setf symbol-macro-expansion) (function)

Structure: timer ()
Package

cl-cuda.api.timer

Source

timer.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: start-event
Readers

timer-start-event (function)

Writers

(setf timer-start-event) (function)

Slot: stop-event
Readers

timer-stop-event (function)

Writers

(setf timer-stop-event) (function)

Structure: variable ()
Package

cl-cuda.lang.environment

Source

environment.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Initform

:name

Readers

variable-name (function)

Writers

(setf variable-name) (function)

Slot: type
Initform

:type

Readers

variable-type (function)

Writers

(setf variable-type) (function)


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

6.2.7 Classes

Class: cuda-grovel-file ()
Package

cl-cuda-asd

Source

cl-cuda.asd

Direct superclasses

grovel-file (class)

Direct methods

perform (method)

Class: curand-state-xorwow-tclass ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: double3-c ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Direct methods
  • translate-from-foreign (method)
  • translate-into-foreign-memory (method)
Class: double4-c ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Direct methods

translate-into-foreign-memory (method)

Class: float3-c ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Direct methods
  • translate-from-foreign (method)
  • translate-into-foreign-memory (method)
Class: float4-c ()
Package

cl-cuda.lang.data

Source

data.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Direct methods
  • translate-from-foreign (method)
  • translate-into-foreign-memory (method)

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

6.2.8 Types

Type: variable-qualifier ()
Package

cl-cuda.lang.kernel

Source

kernel.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

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

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

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

M
Module, cl-cuda/src: The cl-cuda/src module
Module, cl-cuda/src/api: The cl-cuda/src/api module
Module, cl-cuda/src/driver-api: The cl-cuda/src/driver-api module
Module, cl-cuda/src/lang: The cl-cuda/src/lang module

Jump to:   C   F   L   M  

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: Internal functions
%add-functions: Internal functions
%add-globals: Internal functions
%add-macros: Internal functions
%add-symbol-macros: Internal functions
%c-identifier: Internal functions
%cu-ctx-create: Internal functions
%cu-ctx-destroy: Internal functions
%cu-ctx-synchronize: Internal functions
%cu-device-compute-capability: Internal functions
%cu-device-get: Internal functions
%cu-device-get-count: Internal functions
%cu-device-get-name: Internal functions
%cu-device-total-mem: Internal functions
%cu-event-create: Internal functions
%cu-event-destroy: Internal functions
%cu-event-elapsed-time: Internal functions
%cu-event-record: Internal functions
%cu-event-synchronize: Internal functions
%cu-init: Internal functions
%cu-launch-kernel: Internal functions
%cu-mem-alloc: Internal functions
%cu-mem-free: Internal functions
%cu-mem-host-register: Internal functions
%cu-mem-host-unregister: Internal functions
%cu-memcpy-device-to-host: Internal functions
%cu-memcpy-device-to-host-async: Internal functions
%cu-memcpy-host-to-device: Internal functions
%cu-memcpy-host-to-device-async: Internal functions
%cu-module-get-function: Internal functions
%cu-module-get-global: Internal functions
%cu-module-load: Internal functions
%cu-module-unload: Internal functions
%cu-stream-create: Internal functions
%cu-stream-destroy: Internal functions
%cu-stream-query: Internal functions
%cu-stream-synchronize: Internal functions
%cu-stream-wait-event: Internal functions
%elapsed-time: Internal functions
%lookup-function: Internal functions
%lookup-function: Internal functions
%lookup-global: Internal functions
%lookup-global: Internal functions
%lookup-macro: Internal functions
%lookup-macro: Internal functions
%lookup-symbol-macro: Internal functions
%lookup-symbol-macro: Internal functions
%lookup-variable: Internal functions
%macro-p: Internal functions
%macro-p: Internal functions
%macro-p: Internal functions
%make-function: Internal functions
%make-function: Internal functions
%make-global: Internal functions
%make-global: Internal functions
%make-kernel: Internal functions
%make-kernel-manager: Internal functions
%make-macro: Internal functions
%make-macro: Internal functions
%make-memory-block: Internal functions
%make-symbol-macro: Internal functions
%make-symbol-macro: Internal functions
%make-timer: Internal functions
%make-variable: Internal functions
%structure-from-accessor: Internal functions
%symbol-macro-p: Internal functions
%symbol-macro-p: Internal functions

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

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

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

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

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

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

F
float-literal-p: Exported functions
float3-=: Exported functions
float3-p: Exported functions
float3-x: Exported functions
float3-y: Exported functions
float3-z: Exported functions
float4-=: Exported functions
float4-p: Exported functions
float4-w: Exported functions
float4-x: Exported functions
float4-y: Exported functions
float4-z: Exported functions
free-device-memory: Exported functions
free-host-memory: Exported functions
free-memory-block: Exported functions
func-env-add-macrolet-bindings: Internal functions
Function, %add-function-arguments: Internal functions
Function, %add-functions: Internal functions
Function, %add-globals: Internal functions
Function, %add-macros: Internal functions
Function, %add-symbol-macros: Internal functions
Function, %c-identifier: Internal functions
Function, %cu-ctx-create: Internal functions
Function, %cu-ctx-destroy: Internal functions
Function, %cu-ctx-synchronize: Internal functions
Function, %cu-device-compute-capability: Internal functions
Function, %cu-device-get: Internal functions
Function, %cu-device-get-count: Internal functions
Function, %cu-device-get-name: Internal functions
Function, %cu-device-total-mem: Internal functions
Function, %cu-event-create: Internal functions
Function, %cu-event-destroy: Internal functions
Function, %cu-event-elapsed-time: Internal functions
Function, %cu-event-record: Internal functions
Function, %cu-event-synchronize: Internal functions
Function, %cu-init: Internal functions
Function, %cu-launch-kernel: Internal functions
Function, %cu-mem-alloc: Internal functions
Function, %cu-mem-free: Internal functions
Function, %cu-mem-host-register: Internal functions
Function, %cu-mem-host-unregister: Internal functions
Function, %cu-memcpy-device-to-host: Internal functions
Function, %cu-memcpy-device-to-host-async: Internal functions
Function, %cu-memcpy-host-to-device: Internal functions
Function, %cu-memcpy-host-to-device-async: Internal functions
Function, %cu-module-get-function: Internal functions
Function, %cu-module-get-global: Internal functions
Function, %cu-module-load: Internal functions
Function, %cu-module-unload: Internal functions
Function, %cu-stream-create: Internal functions
Function, %cu-stream-destroy: Internal functions
Function, %cu-stream-query: Internal functions
Function, %cu-stream-synchronize: Internal functions
Function, %cu-stream-wait-event: Internal functions
Function, %elapsed-time: Internal functions
Function, %lookup-function: Internal functions
Function, %lookup-function: Internal functions
Function, %lookup-global: Internal functions
Function, %lookup-global: Internal functions
Function, %lookup-macro: Internal functions
Function, %lookup-macro: Internal functions
Function, %lookup-symbol-macro: Internal functions
Function, %lookup-symbol-macro: Internal functions
Function, %lookup-variable: Internal functions
Function, %macro-p: Internal functions
Function, %macro-p: Internal functions
Function, %macro-p: Internal functions
Function, %make-function: Internal functions
Function, %make-function: Internal functions
Function, %make-global: Internal functions
Function, %make-global: Internal functions
Function, %make-kernel: Internal functions
Function, %make-kernel-manager: Internal functions
Function, %make-macro: Internal functions
Function, %make-macro: Internal functions
Function, %make-memory-block: Internal functions
Function, %make-symbol-macro: Internal functions
Function, %make-symbol-macro: Internal functions
Function, %make-timer: Internal functions
Function, %make-variable: Internal functions
Function, %structure-from-accessor: Internal functions
Function, %symbol-macro-p: Internal functions
Function, %symbol-macro-p: Internal functions
Function, (setf double3-x): Exported functions
Function, (setf double3-y): Exported functions
Function, (setf double3-z): Exported functions
Function, (setf double4-w): Exported functions
Function, (setf double4-x): Exported functions
Function, (setf double4-y): Exported functions
Function, (setf double4-z): Exported functions
Function, (setf float3-x): Exported functions
Function, (setf float3-y): Exported functions
Function, (setf float3-z): Exported functions
Function, (setf float4-w): Exported functions
Function, (setf float4-x): Exported functions
Function, (setf float4-y): Exported functions
Function, (setf float4-z): Exported functions
Function, (setf global-ref): Exported functions
Function, (setf host-memory-aref): Exported functions
Function, (setf kernel-function-namespace): Internal functions
Function, (setf kernel-manager-%function-handle): Internal functions
Function, (setf kernel-manager-%function-handles): Internal functions
Function, (setf kernel-manager-%global-device-ptr): Internal functions
Function, (setf kernel-manager-%global-device-ptrs): Internal functions
Function, (setf kernel-manager-kernel): Internal functions
Function, (setf kernel-manager-module-handle): Exported functions
Function, (setf kernel-manager-module-path): Internal functions
Function, (setf kernel-variable-namespace): Internal functions
Function, (setf memory-block-aref): Exported functions
Function, alloc-device-memory: Exported functions
Function, alloc-host-memory: Exported functions
Function, alloc-memory-block: Exported functions
Function, append-arch: Internal functions
Function, arch-exists-p: Internal functions
Function, argument-cffi-type: Internal functions
Function, argument-p: Exported functions
Function, argument-type: Exported functions
Function, argument-var: Exported functions
Function, argument-var-ptr: Internal functions
Function, argument-vars: Internal functions
Function, arithmetic-operands: Exported functions
Function, arithmetic-operator: Exported functions
Function, arithmetic-p: Exported functions
Function, array-cffi-type: Internal functions
Function, array-cffi-type-size: Internal functions
Function, array-cuda-type: Internal functions
Function, array-reference-expr: Exported functions
Function, array-reference-indices: Exported functions
Function, array-reference-p: Exported functions
Function, array-type: Exported functions
Function, array-type-base: Exported functions
Function, array-type-dimension: Exported functions
Function, array-type-p: Exported functions
Function, array-type-stars: Internal functions
Function, block-dim-p: Exported functions
Function, block-idx-p: Exported functions
Function, bool-literal-p: Exported functions
Function, built-in-function-c-name: Exported functions
Function, built-in-function-infix-p: Exported functions
Function, built-in-function-return-type: Exported functions
Function, c-identifier: Exported functions
Function, cffi-type: Exported functions
Function, cffi-type-size: Exported functions
Function, check-cuda-error: Internal functions
Function, cl-cuda-bool-p: Exported functions
Function, cl-cuda-double-p: Exported functions
Function, cl-cuda-float-p: Exported functions
Function, cl-cuda-int-p: Exported functions
Function, cl-cuda-symbol-p: Exported functions
Function, cl-cuda-type-p: Exported functions
Function, compile-argument: Internal functions
Function, compile-arguments: Internal functions
Function, compile-arithmetic: Internal functions
Function, compile-array-indices: Internal functions
Function, compile-array-reference: Internal functions
Function, compile-bool: Exported functions
Function, compile-bool-literal: Internal functions
Function, compile-built-in-function: Internal functions
Function, compile-built-in-infix-function: Internal functions
Function, compile-built-in-prefix-function: Internal functions
Function, compile-constructor: Internal functions
Function, compile-cuda-dimension: Internal functions
Function, compile-declaration: Internal functions
Function, compile-definition: Internal functions
Function, compile-definitions: Internal functions
Function, compile-do: Internal functions
Function, compile-do-init-part: Internal functions
Function, compile-do-statements: Internal functions
Function, compile-do-step-part: Internal functions
Function, compile-do-test-part: Internal functions
Function, compile-double: Exported functions
Function, compile-double-literal: Internal functions
Function, compile-expression: Exported functions
Function, compile-float: Exported functions
Function, compile-float-literal: Internal functions
Function, compile-function: Internal functions
Function, compile-function: Internal functions
Function, compile-global: Internal functions
Function, compile-globals: Internal functions
Function, compile-if: Internal functions
Function, compile-includes: Internal functions
Function, compile-inline-if: Internal functions
Function, compile-int: Exported functions
Function, compile-int-literal: Internal functions
Function, compile-kernel: Exported functions
Function, compile-let: Internal functions
Function, compile-let-bindings: Internal functions
Function, compile-let-statements: Internal functions
Function, compile-literal: Internal functions
Function, compile-macro: Internal functions
Function, compile-macro: Internal functions
Function, compile-macrolet: Internal functions
Function, compile-macrolet-statements: Internal functions
Function, compile-operands: Internal functions
Function, compile-progn: