CUDAFunctionLoad ignores the C portion of code. This allows you to write code that can be compiled by itself as a binary, but can also be loaded in as a CUDAFunction. The following loads a CUDA source file (mixed with C code) into the Wolfram Language:

This calls the function:

CUDAFunctionLoad can specify the shared (local) memory size of the function at runtime. The following code uses shared memory to store global memory for gradient computation:

This specifies the input arguments, with the last argument being "Shared" for shared memory. The block size is set to 256:

This computes the flattened length of a grayscale image:

This invokes the function. The shared memory size is set to (blockSize+2)*sizeof(mint), and the number of launch threads is set to the flattened length of the image:

A nicer way of specifying the shared memory size is using types:

Using shared memory types, you need not pass in the size of the type:

Templated functions can be called. The only limitation is that the templated functions must be instantiated as a device function, and the "UnmangleCode" must be set to False. This compiles a templated function into PTX byte code, using a dispatch function to determine what device function to call:

This loads the function for integers:

This runs the function. Here, the 3 specifies that the input type is integer:

Templated functions can be simulated using macros. This source code has Generic_t as an undefined macro:

This sets the macro Generic_t to mint:

This sets the macro Generic_t to unsigned char:

Using the above method, you can simulate template types without the need to find the mangled name.

Three-dimensional block sizes are supported. This inverts a volumetric dataset:

This loads the function, passing a three-dimensional block size:

This loads data from a file:

This performs the computation:

This renders the result:

Perlin noise is a common algorithm used to generate procedural textures. This is a textbook implementation of the noise function:

This loads the "classicPerlin" function:

This generates the permutation table used in the noise algorithm:

This sets the width and height. It also allocates the output memory:

This defines the parameters to the Perlin noise:

This calls the Perlin noise function. The output is a CUDAMemory handle:

The memory is retrieved from the GPU and displayed as an image:

Putting the result in Manipulate, you can see the output as parameters change:

With Perlin noise, you can create procedural landscapes. Define the width and height and allocate memory for the landscape:

The parameters used define the landscape:

The data is retrieved and some image processing functions are used to smooth the elevation map:

The result is similar to a mountain range:

This deallocates the memory:

Varying parameters to the noise results in difference patterns. Here, wood texture is created:

The following are known parameters for wood:

This defines a helper function that recolors the grayscale image:

Here, the wood texture is generated:

As before, the result can be plotted onto a surface:

The original source code defines more noise functions. This loads all functions:

Here, Manipulate is used to showcase the different noise functions:

This deallocates the memory:

The histogram algorithm places elements in a list in separate bins, depending on their values. The following implements a histogram that places values between 0 and 255 in separate bins:

This loads the two CUDA kernel functions:

This gets sample data. An image is chosen in this case, and the ImageData is flattened:

The algorithm requires some temporary data that would be used as intermediate histograms:

This computes sub-histograms and places them in the intermediate list generated before:

This merges the temporary histograms:

This gets the output histogram:

This unloads the temporary memory. Failing to do so results in a memory leak:

This plots the output histogram:

The scan, or prefix sum, algorithm is similar to FoldList and is a very useful primitive algorithm that can be used in a variety of scenarios. The CUDA implementation is found in the following location:

This loads the three kernels used in computation:

This generates random input data:

This allocates the output buffer:

This computes the block and grid dimensions:

A temporary buffer is needed in computation:

This performs the scan operation:

This retrieves the output buffer:

Minus the first term, the result agrees with FoldList:

This deallocates the CUDAMemory elements:

The reduction kernel is similar to Fold in the Wolfram Language because it reduces a list, given a binary operation. Whereas scan kept the previous elements in the computation, reduce discards them. This loads the reduction CUDAFunction:

This sets the input and output buffers:

This performs the computation:

Each block reduces 512 elements of the list; therefore, you need multiple calls to reduce lists larger than 512 elements. This list is small, so no loop is necessary. This gets the output memory from the previous step, assigns the memory in out to in, and frees out:

This allocates a new output buffer:

This performs a second reduction:

The output is retrieved and the output buffer is unloaded:

The result agrees with the Wolfram Language:

The following implements a color converter, converting from RGB color space to HSB. The CUDA implementation is in the file:

This loads the "rgb2hsb" function from the source file:

This sets the input image along with the input parameters:

This allocates memory for the output:

This converts the image to HSB space:

By default, Image views the data in RGB space. This results in wrong output:

Use ColorSpace->"HSB" to get proper output:

The following code implements the Caesar cipher. The Caesar cipher is a simple cypher that adds the value 3 to each character in the text. Here is the CUDA implementation:

This loads some example text; the Declaration of Independence is loaded in this case:

Here, the function is loaded from the code string:

This calls the CUDA function and displays only the first 100 characters of the output:

The following implements a moving average:

This loads the CUDAFunction defining the macro "BLOCK_DIM" as 256:

This defines the input parameters and allocates memory for the output:

This calls the CUDAFunction:

This gets the output memory:

Memory is unloaded:

The Black–Scholes formula is a commonly used formula used in financial computation. CUDALink provides CUDAFinancialDerivative, which can compute financial options. To demonstrate how it is written, implement as a simple version:

This loads the CUDAFunction. Set the "TargetPrecision" to "Single", which means that _Real is interpreted as "Float":

This assigns the input parameters:

This calls the function:

This gets the output memory:

This unloads allocated memory:

Conway's Game of Life is a cellular automaton that evolves a cell, based on the state of the surroundings. This loads the CUDALink function:

For the initialization, you need to initialize randomly, but cannot have the initial state too sparse, or else all the cells will die:

This displays the function using Dynamic and ArrayPlot. Notice that it is slightly slow:

This displays the function using Dynamic and Image. Notice that it is slightly faster:

Using CUDAMemory, you can speed up the rendering:

The following physical simulation shows how to utilize a CUDAFunction to perform computation while delegating the rest to the Wolfram Language. This function loads the CUDAFunction and calls the BallBounceEffect function:

The following draws the particles, updating to create the effect:

This invokes the function:

The Julia set is a generalization of the Mandelbrot set. This implements the CUDA kernel:

The width and height are set. Since the set is computed, the memory need not be set—that is, only memory allocation is needed:

This loads the CUDAFunction. Macros are used to allow the compiler to optimize the code—doing things like loop unrolling:

This computes the set and views it using ReliefImage:

This creates an interface using Manipulate and ReliefPlot, where the user can adjust the value of :

The user can substitute ReliefPlot for Image to make the visualization even faster:

The Mandelbrot set is defined by . This code showcases how to define your own type in a kernel file, demonstrating this by considering sets of the form , where is a user-defined parameter. The kernel is defined here:

This sets the width and height variables:

The output set's memory is allocated using CUDAMemoryAllocate:

This loads the function from the above file:

This computes and displays the set when the power is 2:

This computes and displays the set when the power varies:

This generates a set of 200 frames:

This renders each frame as a texture on a polygon:

Using CUDALink's symbolic capabilities, you can write CUDA code using Wolfram Language expressions and transform them to CUDA code. The following implements a simple 1D discrete Haar wavelet transform, using symbolic code:

The symbolic code can then be converted to CUDA code, using ToCCodeString from SymbolicC:

The code can then be loaded using CUDAFunctionLoad:

This creates some input data:

This calls the CUDAFunction with maxStage=1:

This gets the resulting CUDAMemory:

One of the interesting aspects of symbolic code generation is being able to manipulate the syntax tree. In this case, change the function arguments from CPointerType["mint"] to CPointerType["float"]:

Again, you generate the CUDA code from the result:

The other interesting aspect of code generation is that the CUDA symbolic functions are mirrored by OpenCL symbolic functions. So, taking the above symbolic code, you can generate OpenCL code by changing only the CUDA symbolic function. First, load OpenCLLink:

This implements the OpenCL 1D discrete Haar wavelet transform:

Note that only two words are changed for this translation: SymbolicCUDAFunction became SymbolicOpenCLFunction, and SymbolicCUDADeclareIndexBlock became SymbolicOpenCLDeclareIndexBlock.

The following code calculates the Mandelbrot set:

Rule 30 cellular automaton does not gain much from CUDA until the column count becomes very large, since the next row is dependent on the previous. Nonetheless, you can write a simple rule 30 cellular automaton as a CUDA function:

This creates the memory buffers:

This applies rule30 128 times:

This plots the result using ArrayPlot:

The following implements triplex Mandelbrot ("Mandelbulb")—an analog to the Mandelbrot set in 3D. Triplex numbers extend the polar form of complex exponentiation to spherical coordinates in three dimensions; . Addition is simply vector addition. This specifies the Mandelbulb parameters (width, height, camera position, and light position):

This allocates the output memory:

The implementation is loaded from the source:

This loads the CUDAFunction:

This runs the CUDAFunction:

This gets the CUDAMemory into the Wolfram Language:

This displays the result as an image:

The result can be placed into a Manipulate:

The creates an interface that allows the user to adjust the camera position: