OpenCLLink`

OpenCLFunctionLoad

OpenCLFunctionLoad["src",fun,argtypes,blockdims]

compiles the string src and makes fun available in the Wolfram Language as an OpenCLFunction.

OpenCLFunctionLoad[File[srcfile],fun,argtypes,blockdim]

compiles the source code file srcfile and then loads fun as an OpenCLFunction.

OpenCLFunctionLoad[File[libfile],fun,argtypes,blockdim]

loads fun as an OpenCLFunction. from the previously compiled library libfile.

Details and Options

The OpenCLLink application must be loaded using Needs["OpenCLLink`"].
If libfile is a dynamic library, then the dynamic library function fun is loaded.
Possible argument and return types, and their corresponding OpenCL type, include:

_Integer	mint	Wolfram Language integer
"Integer32"	int	32-bit integer
"Integer64"	long/long long	64-bit integer
_Real	Real_t	GPU real type
"Double"	double	machine double
"Float"	float	machine float
{base, rank, io}	OpenCLMemory	memory of specified base type, rank, and input/output option
"Local" \| "Shared"	mint	local or shared memory parameter
{"Local" \| "Shared", type}	mint	local or shared memory parameter

In the specification {base, rank, io}, valid settings of io are "Input", "Output", and "InputOutput".
The argument specification {base} is equivalent to {base,_,"InputOutput"}, and {base,rank} is equivalent to {base,rank,"InputOutput"}.
The rank can be omitted by using {base,_,io} or {base,io}.
Possible base types are:

_Integer	_Real	_Complex
"Byte"	"Bit16"	"Integer32"
"Byte[2]"	"Bit16[2]"	"Integer32[2]"
"Byte[4]"	"Bit16[4]"	"Integer32[4]"
"Byte[8]"	"Bit16[8]"	"Integer32[8]"
"Byte[16]"	"Bit16[16]"	"Integer32[16]"
"UnsignedByte"	"UnsignedBit16"	"UnsignedInteger"
"UnsignedByte[2]"	"UnsignedBit16[2]"	"UnsignedInteger[2]"
"UnsignedByte[4]"	"UnsignedBit16[4]"	"UnsignedInteger[4]"
"UnsignedByte[8]"	"UnsignedBit16[8]"	"UnsignedInteger[8]"
"UnsignedByte[16]"	"UnsignedBit16[16]"	"UnsignedInteger[16]"
"Double"	"Float"	"Integer64"
"Double[2]"	"Float[2]"	"Integer64[2]"
"Double[4]"	"Float[4]"	"Integer64[4]"
"Double[8]"	"Float[8]"	"Integer64[8]"
"Double[16]"	"Float[16]"	"Integer64[16]"

OpenCLFunctionLoad can be called more than once with different arguments.
Functions loaded by OpenCLFunctionLoad run in the same process as the Wolfram Language kernel.
Functions loaded by OpenCLFunctionLoad are unloaded when the Wolfram Language kernel exits.
Block dimensions can be either a list or an integer denoting how many threads per block to launch.
The maximum size of block dimensions is returned by the "Maximum Work Group Size" property of OpenCLInformation.
On launch, if the number of threads is not specified (as an extra argument to OpenCLFunction), then the dimension of the element with largest rank and dimension is chosen. For images, the rank is set to 2.
On launch, if the number of threads is not a multiple of the block dimension, then it is incremented to be a multiple of the block dimension.
The following options can be given:

"CompileOptions"	{}	compile options passed directly to the OpenCL compiler
"Defines"	Automatic	defines passed to the OpenCL preprocessor
"Device"	$OpenCLDevice	OpenCL device used in computation
"IncludeDirectories"	{}	directories to include in the compilation
"Platform"	$OpenCLPlatform	OpenCL platform used in computation
"ShellCommandFunction"	None	function to call with the shell commands used for compilation
"ShellOutputFunction"	None	function to call with the shell output of running the compilation commands
"TargetPrecision"	Automatic	precision used in computation
"WorkingDirectory"	Automatic	the directory in which temporary files will be generated

Examples

open allclose all

Basic Examples (5)Summary of the most common use cases

First, load the OpenCLLink application:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-dvgu9k

Define the OpenCL source code to load:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-dix3zk

Loads the OpenCL function:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-b2k0qc

Out[3]=3

Define the input parameters:

In[4]:=4

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-l8catb

Calls the function with the arguments:

In[8]:=8

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-6wjo6

Plot the result using ArrayPlot:

In[9]:=9

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-6c2yj5

Out[9]=9

Define the path to the OpenCL source file from the "SupportFiles/vectorAdd.cl":

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cjxj9c

Out[1]=1

Compile and load the OpenCL function from the file:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cr596a

Out[2]=2

This calls the function:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-jmd2fh

Out[3]=3

Locate the example OpenCLLink library "addTwo_Dobule":

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-f1c2nr

Out[1]=1

Load the library using OpenCLFunctionLoad:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-hsj5m4

The function adds two to an input list:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ed7tas

Out[3]=3

The source code for this example is bundled with OpenCLLink:

In[4]:=4

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-go264y

Out[4]=4

An extra argument can be given when calling OpenCLFunction. The argument denotes the number of threads to launch (or the global work group size). Using the previous example:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cs6mvn

Out[1]=1

This loads the OpenCL function from the file:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-juf3

Out[2]=2

This calls the function with 32 threads, which results in only the first 32 values in the vector add being computed:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-hdgtbt

Out[3]=3

If code contains syntax errors, then a "compilation failed" error is returned:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ch7ddt

The "ShellOutputFunction" option can be used to print the build log:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-dyz540

The above error states that there is a typo in the code, with a z after the 0 in the code:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bdyu1p

Out[3]=3

Scope (2)Survey of the scope of standard use cases

Templated Function (1)

Templated functions can be simulated using macros. Leave as an undefined macro:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-nux43o

Set the macro to during compilation:

In[15]:=15

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-g7px

Out[15]=15

Sets to instead:

In[16]:=16

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-f3wad

Out[16]=16

Shared or Local Memory (1)

OpenCLFunctionLoad can be used to specify "Local" or "Shared" memory on launch. The following code uses shared memory to store global memory for gradient computation:

In[6]:=6

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bjuef1

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

In[7]:=7

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-km361w

Out[7]=7

This computes the flattened length of a grayscale image:

In[8]:=8

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bee3hm

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

In[10]:=10

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-pbnqzg

Out[10]=10

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

In[12]:=12

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-hacg9m

Out[12]=12

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

In[13]:=13

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bfbkno

Out[13]=13

Applications (10)Sample problems that can be solved with this function

Image Input (1)

The input can be images; here you write code that performs linear interpolation between images (this can be done using ImageCompose):

In[36]:=36

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ize2d7

This loads OpenCLFunction from the source code above:

In[37]:=37

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cf90uv

Out[37]=37

This sets the height, width, and channel values. It also allocates memory for the output:

In[38]:=38

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-fmxebe

Out[39]=39

This calls the function with {width,height} threads:

In[40]:=40

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-b6jdp

Out[40]=40

This gets the memory and displays it as an image:

In[41]:=41

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-igf4qv

Out[41]=41

You can take the above and make a function OpenCLImageLinearCombine:

In[42]:=42

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-lnwzq9

The function now has similar syntax to ImageCompose:

In[43]:=43

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-39wd

Out[43]=43

A Manipulate can be used to play with the interpolation coefficients:

In[45]:=45

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cjao5c

Out[45]=45

Effects can be made; in this example, a smooth animation is viewed:

In[46]:=46

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-919e1

Out[46]=46

Uniform Random Number Generation (1)

Uniform random number generators are common seed problems in many applications. This implements uniform random number generators in OpenCL:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-6hiqb

Out[1]=1

This loads the source as an OpenCLFunction. This algorithm uses an image to provide an upper bound to the random number:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ck1sn0

Out[2]=2

This calls OpenCLFunction; note that you can pass images directly into an OpenCLFunction so long as it can be interpreted using the appropriate specified type:

In[9]:=9

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-vrim2

Out[1]=1

Notice that this is not a regular duck image; it is a 4-channel image with alpha channel set to 1 (using SetAlphaChannel):

In[10]:=10

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-g4ur4z

Out[10]=10

The random output can be used to detect important edges in an image:

In[11]:=11

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-fm27d1

Out[11]=11

Random Number Generation Using the Mersenne Twister (1)

The Mersenne Twister is another uniform random number generator algorithm (more sophisticated than the one mentioned above). The implementation is located here:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-d84o29

Out[1]=1

This loads OpenCLFunction; you specify the type _Real, which means that the Real type is dependent on the CPU capabilities (whether it supports double precision or not):

In[68]:=68

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-u3efc

Out[68]=68

This sets up the Mersenne Twister's input and output parameters (for more information, refer to the algorithm description):

In[69]:=69

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-dscs93

Out[76]=76

This invokes OpenCLFunction:

In[77]:=77

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-flxpbs

Out[77]=77

This plots the output's results:

In[78]:=78

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-jwzkjc

Out[78]=78

If the output is timed:

In[79]:=79

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-id9577

Out[79]=79

There is almost an 11× increase in speed:

In[80]:=80

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cmnqr0

Out[80]=80

Prefix Sum Algorithm (1)

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 OpenCL implementation is found in:

In[26]:=26

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-j0jfac

Out[26]=26

This loads the three kernels used in computation:

In[82]:=82

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-i0l2j

This generates random input data:

In[85]:=85

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-haj3tp

This allocates the output buffer:

In[86]:=86

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-odg7fy

This computes the block and grid dimensions:

In[87]:=87

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-imsy46

A temporary buffer is needed in computation:

In[89]:=89

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-gv3flm

This performs the scan operation:

In[90]:=90

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-zajes

This retrieves the output buffer:

In[93]:=93

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bpzz7i

Out[93]=93

This deallocates the OpenCLMemory elements:

In[94]:=94

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-jb9a64

Matrix Operations (1)

Matrix transpose is a fundamental algorithm in many applications. This specifies the inputs:

In[104]:=104

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-f2v1b

This loads OpenCLFunction:

In[109]:=109

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-t5ko2

Out[109]=109

This calls OpenCLFunction:

In[110]:=110

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-brz2lr

This shows the MatrixForm of the result:

In[111]:=111

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-4uqcz

The result agrees with the Wolfram Language:

In[112]:=112

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cu84qw

Matrix Multiplication (1)

Matrix multiplication is implemented here:

In[32]:=32

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-kbhsg4

Out[32]=32

This defines the block size:

In[114]:=114

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bc7p4e

This loads OpenCLFunction; note it is specified that the input must be rank 2:

In[115]:=115

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-efumj9

Out[115]=115

This creates random input and allocates the output:

In[116]:=116

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bh6566

Out[118]=118

This calls OpenCLFunction:

In[119]:=119

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-byody3

Out[119]=119

This gets the output memory using OpenCLMemoryGet:

In[120]:=120

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-g7ryrf

The output agrees with the Wolfram Language:

In[121]:=121

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-mymz7d

Fast Fourier Transform (1)

The one-dimensional discrete fast Fourier transform can be implemented using OpenCLLink; this implementation assumes that the input is a power of 2:

In[33]:=33

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-kta8r

Out[33]=33

This loads OpenCLFunction using OpenCLFunctionLoad:

In[123]:=123

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-b79qf1

Out[123]=123

This creates input and output lists:

In[124]:=124

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-faw8ln

This calls the output memory and creates a complex list, displaying only the first 50 elements:

In[126]:=126

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-pffo6

Out[126]=126

The result agrees with Fourier:

In[127]:=127

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ci7qx3

Out[127]=127

Financial Derivative (1)

Black–Scholes models financial derivative investments and is implemented in OpenCL:

In[34]:=34

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-d987ze

Out[34]=34

This loads OpenCLFunction:

In[129]:=129

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-skspx

Out[129]=129

This assigns the input parameters:

In[130]:=130

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-l7kojx

This invokes OpenCLFunction:

In[138]:=138

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ll9lsh

Out[138]=138

This gets the call values:

In[139]:=139

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-c0igvs

Out[139]=139

The result agrees with the output of FinancialDerivative:

In[140]:=140

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-i4djch

Out[140]=140

For timing, the number of options to be valuated is increased:

In[141]:=141

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-knztu9

On the C2050, it takes 1/100 of a second to valuate 2048 options:

In[149]:=149

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-c1rwbc

Out[149]=149

On a Core i7 950, FinancialDerivative takes 1.13 seconds. This is a speedup of 280×. Note that increasing the number of options will exhibit more speedups:

In[150]:=150

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cp8ocy

Out[150]=150

Gaussian Filter (1)

Recursive Gaussian is used to approximate the Gaussian filter. The Gaussian matrix is separable:

In[22]:=22

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bcauo

Out[22]=22

It can be written as the outer product of two 1D Gaussians:

In[23]:=23

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-kdo1w9

Out[23]=23

Locate the implementation of the recursive Gaussian:

In[24]:=24

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-dqz9rh

Out[24]=24

Load two functions using OpenCLFunctionLoad:

In[25]:=25

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-q5sxq

Specifies the value in the Gaussian :

In[27]:=27

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-eozwvz

Calculate the normal distribution:

In[28]:=28

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-mirxko

Out[28]=28

The Wolfram Language can plot the distribution:

In[29]:=29

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-tppv0

Out[29]=29

Calculate the recursive Gaussian parameters:

In[30]:=30

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-mmxvhv

Allocate OpenCLMemory for the input, output, and temporary storage:

In[46]:=46

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bnmjyb

Perform the Gaussian horizontally, then transpose, then perform the Gaussian vertically, and finally transpose to get the full Gaussian:

In[50]:=50

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bivzqd

Reconstruct the image from the data:

In[54]:=54

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-hzpns8

Out[54]=54

Again you compare timing:

In[55]:=55

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-caac8i

Out[55]=55

And notice a 4× performance boost:

In[57]:=57

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bjizga

Out[57]=57

Sorting (1)

Bitonic sort sorts a given set of integers. It is similar in principle to merge sort. The OpenCL implementation only works on lists of length of a power of 2 and can be found here:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cgwlu6

Out[1]=1

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-5h3u0

Out[2]=2

This sets the length of the input and loads it. The direction denotes whether to sort from highest to lowest or lowest to highest. In this case, you sort from lowest to highest:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-mdjhax

This gets the input list:

In[4]:=4

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cvb8s

Out[4]=4

This calls bitonic sort, similar to merge sort; multiple calls are needed for a full sort:

In[5]:=5

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-c7hmzl

The output list is retrieved sorted:

In[6]:=6

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-pccb9

Out[6]=6

Possible Issues (5)Common pitfalls and unexpected behavior

The maximum work item sizes (block dimensions) are returned by OpenCLInformation:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-h0obz

Out[1]=1

On some systems, this can be limited to 1.

To use double-precision operations in the OpenCL code, the user must place the following pragmas in the code header:

#ifdef USING_DOUBLE_PRECISIONQ
#pragma OPENCL EXTENSION cl_khr_fp64 : enable
#pragma OPENCL EXTENSION cl_amd_fp64 : enable
#endif /* USING_DOUBLE_PRECISIONQ */

Errors in the function call can place OpenCLLink in an unusable state. This is a side effect of allowing users to write arbitrary kernels. Infinite loops, buffer overflows, etc. in the kernel code can make both OpenCLLink and the video driver unstable. In an extreme case, this may crash the display driver, but usually it just makes further evaluation of OpenCL code return invalid results.

Bugs in some OpenCL implementations may cause the kernel to crash if one of the "IncludeDirectories" contains a space.

Use of memory modifiers such as is not supported by OpenCLLink. Memory passed into an OpenCLFunction must be .

Interactive Examples (5)Examples with interactive outputs

Mandelbrot Set (1)

The Mandelbrot set plots all points satisfying the recurrence equation with a complex number. The following implements the set in OpenCL (a slightly more complicated coloring strategy is used to ensure colors have smooth transition):

In[180]:=180

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-fpfe3h

In[181]:=181

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-daweyh

Out[181]=181

In[182]:=182

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bwo2m6

In[185]:=185

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-gae8gd

Out[185]=185

In[186]:=186

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-dgijpw

Out[186]=186

In[187]:=187

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-njf1w

Out[187]=187

Julia Set (1)

The Mandelbrot set is a restricted form of the Julia set; here is the code for the Julia set:

In[188]:=188

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-scs1h

This defines the input memory and parameters:

In[189]:=189

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-mb7u29

This loads OpenCLFunction:

In[191]:=191

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-mqrc2a

This computes the Julia set and plots it using ReliefPlot:

In[192]:=192

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-c5j10z

Out[192]=192

This computes the Julia set and displays it as a grayscale image:

In[193]:=193

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-2tawu

Out[193]=193

Image Adjustment (1)

ImageAdjust rescales the image to input high and low values. Gamma correction is also considered. The following defines a simplified version of ImageAdjust in OpenCL:

In[194]:=194

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bfo9f5

This loads OpenCLFunction:

In[195]:=195

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-c4uzlf

This defines a simple Wolfram Language wrapper function to make the OpenCL function have similar syntax to ImageAdjust:

In[196]:=196

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-bahhhm

This adjusts the image by rescaling the values between 0.3 and 0.8 to 0.0 and 1.0:

In[198]:=198

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-edzxkh

Out[198]=198

This adjusts the image by rescaling the values using Manipulate:

In[199]:=199

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-gt1sws

Out[199]=199

This adjusts the image by rescaling the values between 0.3 and 0.8 to 0.0 and 1.0:

In[200]:=200

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-hamjdh

Out[200]=200

Bouncing Ball (1)

In this example, you compute the position of each particle in a box with varying initial forces. You delegate the particle physics simulation to OpenCL, while all the rest is done in the Wolfram Language:

In[204]:=204

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-e42ymr

This defines the OpenCL code and loads the function into the Wolfram Language:

In[205]:=205

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-qlpny

In[206]:=206

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ehdx15

Out[206]=206

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-cp9b56

N-Body Simulation (1)

The N-body simulation is a classic Newtonian problem. This implements it in OpenCL:

In[1]:=1

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-hyehcj

This loads OpenCLFunction:

In[2]:=2

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-iwnx5u

Out[2]=2

The number of particles, time step, and epsilon distance are chosen:

In[3]:=3

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-d5npco

This sets the input and output memories:

In[4]:=4

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-h0a1ek

This calls the NBody function:

In[5]:=5

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-fhxghw

This plots the body points:

In[6]:=6

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-icyd85

Out[6]=6

This shows the result as a Dynamic:

In[7]:=7

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-ll80vc

Out[7]=7

Neat Examples (1)Surprising or curious use cases

SymbolicC (1)

OpenCLLink can use SymbolicC's code generation capabilities. To use SymbolicC, the user needs to load it:

In[220]:=220

✖

https://wolfram.com/xid/0isq3flowdud5n74bny881he6-0wsz71

OpenCLLink can use SymbolicC's code generation capabilities; here a method toSymbolicC is defined that takes a Wolfram Language statement and translates it to a SymbolicC expression (it cannot translate all Wolfram Language commands, but they can be added by the user):

In[221]:=221