JCuda in Processing, drawing example

Library and Tool Development

noahbuddy..

JCuda in Processing, drawing example

in Library and Tool Development • 6 months ago

Following in Dippo's footsteps, I have been trying to use JCuda within Processing. With success. :]

What it does: Uses a compiled GPU kernel to generate a wave centered on the mouse, propagating outward.

Setup:

Follow these links, download and install for your machine (assuming you have a CUDA capable graphics card):

CUDA Toolkit (5.0 at this time)

JCUDA library

(mostly from Dippo's post)

Copy DLL files from:

C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v5.0/bin

The JCUDA libraries needs to be placed in :

C:/<user>/Documents/Processing/libraries/jcuda/library

Rename all the JAR files so that only a name is visible. You have to remove the version numbers and the minus char. For example, "jcuda.jar"

The JCUDA documention needs to be extracted to :

"C:/<user>/Documents/Processing/libraries/jcuda/documentation"

Install the CUDA Toolkit;

Almost identical with the exception of cudpp64_32_16.dll and cudpp32_32_16.dll's. I couldn't find them on my machine. There is an npp32(64?)_50_35.dll as well as cublas32_50_35.dll; perhaps NVIDIA has another way of handling newer libraries.

Known quirks: On exit, the debug window reports "jcuda.CudaException: CUDA_ERROR_INVALID_CONTEXT" after attempting to free RAM on the graphics card. Still works on the next run... I don't know if this will cause trouble with other software.

Code to follow

Save the cuda portion of code as a *.cu file in data folder of sketch.

-Noah

My system:

Windows XP pro, SP3

AMD Athlon 64 X2 Dual core, 2.27GHz

3GB (usable by Windows) RAM

NVIDIA GeForce GT 430

Replies(2)

noahbuddy..

Re: JCuda in Processing, drawing example

6 months ago

Source for cudawavedraw.pde

import java.io.*;
import jcuda.*;
import jcuda.driver.*;
/**
* Edited by Noah Buddy
* Based on sourcecode from and two helper functions at the end provided by:
* http://www.jcuda.org
*/
//Used to define the ripple
float freq = 0.1; //determines wavelength
float timeoffset = 0.0; //if animated, increment this by some time step
float timestep = 1.4;
int numElements = 1; //redefined in setup as width*height, aka: pixels' array size
CUdeviceptr deviceOutput = null;
CUfunction function = null;
void setup() {
size(1024, 768, P2D);
// Enable exceptions and omit all subsequent error checks
JCudaDriver.setExceptionsEnabled(true);
// Create the PTX file by calling the NVCC
String ptxFileName = "";
try {
ptxFileName = preparePtxFile( dataPath("waveKernel.cu") );
} catch (Exception e) {
e.printStackTrace();
}
// Initialize the driver and create a context for the first device.
JCudaDriver.cuInit(0);
CUdevice device = new CUdevice();
JCudaDriver.cuDeviceGet(device, 0);
CUcontext context = new CUcontext();
JCudaDriver.cuCtxCreate(context, 0, device);
// Load the ptx file.
CUmodule module = new CUmodule();
JCudaDriver.cuModuleLoad(module, ptxFileName);
// Obtain a function pointer to the "wave" function.
//CUfunction function = new CUfunction();
function = new CUfunction();
JCudaDriver.cuModuleGetFunction(function, module, "wave");
numElements = width * height;
// Allocate device memory
deviceOutput = new CUdeviceptr();
JCudaDriver.cuMemAlloc(deviceOutput, numElements * Sizeof.INT);
//Exit handler
//http://stackoverflow.com/questions/2361510/how-to-save-application-options-before-exit
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
public void run () {
// Clean up.
println("Exit sequence.");
try {
JCudaDriver.cuMemFree(deviceOutput);
} catch(Exception e) {
e.printStackTrace();
}
}
}));
frameRate(200); //on my machine, I don't think this matters anymore
}
void draw() {
/*
* Set up the kernel parameters: A pointer to an array
* of pointers which point to the actual values.
*
* Yes,.. you do have to define the parameters this way.
* If you are not familiar with pointers, in Java, "int[] array1 = new int[L];" is the same as
* assigning the reference variable "array1" to some address, or, a pointer.
* Then, using Pointer.to(), we send that reference to JCuda in a format it will understand.
*/
Pointer kernelParameters = Pointer.to(
Pointer.to( new int[] { numElements } ),
Pointer.to( new int[] { width } ),
Pointer.to( new int[] { mouseX } ),
Pointer.to( new int[] { mouseY } ),
Pointer.to( new float[] { freq } ),
Pointer.to( new float[] { timeoffset } ),
Pointer.to(deviceOutput)
);
// Call the kernel function in tiles of 16x16 squares
int blockW = 16; //Tile size
int blockH = 16;
int gridW = width / blockW; //Number of tiles
int gridH = height / blockH;
JCudaDriver.cuLaunchKernel(
function,
gridW, gridH, 1, //tiles of 16x16
blockW, blockH, 1, //number of tiles
0, null, // Shared memory size and stream
kernelParameters, null // Kernel- and extra parameters
);
JCudaDriver.cuCtxSynchronize();
loadPixels();
//As long as the array type on the GPU is int, we can copy directly to pixels[]
//Could even load pixels[] of a PImage for textures, drawing, etc. Just make sure the array size is the same...
JCudaDriver.cuMemcpyDtoH(Pointer.to(pixels), deviceOutput, numElements * Sizeof.INT);
updatePixels();
timeoffset += timestep;
}
/**
* The extension of the given file name is replaced with "ptx".
* If the file with the resulting name does not exist, it is
* compiled from the given file using NVCC. The name of the
* PTX file is returned.
*
* @param cuFileName The name of the .CU file
* @return The name of the PTX file
* @throws IOException If an I/O error occurs
*/
String preparePtxFile(String cuFileName) throws IOException
{
int endIndex = cuFileName.lastIndexOf('.');
if (endIndex == -1)
{
endIndex = cuFileName.length()-1;
}
String ptxFileName = cuFileName.substring(0, endIndex+1)+"ptx";
File ptxFile = new File(ptxFileName);
if (ptxFile.exists())
{
return ptxFileName;
}
File cuFile = new File(cuFileName);
if (!cuFile.exists())
{
throw new IOException("Input file not found: " + cuFileName);
}
String modelString = "-m" + System.getProperty("sun.arch.data.model");
String command = "nvcc " + modelString + " -ptx \"" + cuFile.getPath() + "\" -o \"" + ptxFileName + "\"";
System.out.println("Executing\n"+command);
Process process = Runtime.getRuntime().exec(command);
String errorMessage =
new String(toByteArray(process.getErrorStream()));
String outputMessage =
new String(toByteArray(process.getInputStream()));
int exitValue = 0;
try
{
exitValue = process.waitFor();
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
throw new IOException(
"Interrupted while waiting for nvcc output", e);
}
if (exitValue != 0)
{
System.out.println("nvcc process exitValue "+exitValue);
System.out.println("errorMessage:\n"+errorMessage);
System.out.println("outputMessage:\n"+outputMessage);
throw new IOException(
"Could not create .ptx file: " + errorMessage);
}
System.out.println("Finished creating PTX file");
return ptxFileName;
}
/**
* Fully reads the given InputStream and returns it as a byte array
*
* @param inputStream The input stream to read
* @return The byte array containing the data from the input stream
* @throws IOException If an I/O error occurs
*/
byte[] toByteArray(InputStream inputStream)
throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte buffer[] = new byte[8192];
while (true)
{
int read = inputStream.read(buffer);
if (read == -1)
{
break;
}
baos.write(buffer, 0, read);
}
return baos.toByteArray();
}

noahbuddy..

Re: JCuda in Processing, drawing example

6 months ago

Source for waveKernel.cu

Save as "waveKernel.cu" in the data folder of the sketch.

If you have questions, please bare with me as I am often only online once a day (or less).

extern "C"
__global__ void wave(int n, int width, int centerX, int centerY, float freq, float time, int *out)
{
//
//This is the tricky part; calculating which thread we are before doing something
//
int pixelX = blockIdx.x*blockDim.x + threadIdx.x;
int pixelY = blockIdx.y*blockDim.y + threadIdx.y;
if ( (pixelX*pixelY) < n) //out of bounds catch, just in case
{
int diffX = centerX - pixelX;
int diffY = centerY - pixelY;
float dist = sqrtf( diffX*diffX + diffY*diffY );
//fill pixels to match sine wave based on distance from center point and time
out[pixelY*width + pixelX] = ((int)(127.0*sinf(freq*(dist - time)) + 128) | 0xFF000000);
}
}

Top Reply