private synchronized void unload() {
if (initialized) {
if ((projectionVolume != null) && (!largeVolumeMode)) {
commandQueue.putReadBuffer(volumePointer, true).finish();
volumePointer.getBuffer().rewind();
volumePointer.getBuffer().get(h_volume);
volumePointer.getBuffer().rewind();
int width = projectionVolume.getSize()[0];
int height = projectionVolume.getSize()[1];
if (this.useVOImap) {
for (int k = 0; k < projectionVolume.getSize()[2]; k++) {
for (int j = 0; j < height; j++) {
for (int i = 0; i < width; i++) {
float value = h_volume[(((height * k) + j) * width) + i];
if (voiMap[i][j][k]) {
projectionVolume.setAtIndex(i, j, k, value);
} else {
projectionVolume.setAtIndex(i, j, k, 0);
}
}
}
}
} else {
for (int k = 0; k < projectionVolume.getSize()[2]; k++) {
for (int j = 0; j < height; j++) {
for (int i = 0; i < width; i++) {
float value = h_volume[(((height * k) + j) * width) + i];
projectionVolume.setAtIndex(i, j, k, value);
}
}
}
}
} else {
System.out.println("Check ProjectionVolume. It seems null.");
}
h_volume = null;
// free memory on device
commandQueue.release();
if (projectionTex != null) projectionTex.release();
if (projectionMatrix != null) projectionMatrix.release();
if (volStride != null) volStride.release();
if (projectionArray != null) projectionArray.release();
if (volumePointer != null) volumePointer.release();
kernelFunction.release();
program.release();
// destory context
context.release();
commandQueue = null;
projectionArray = null;
projectionMatrix = null;
projectionTex = null;
volStride = null;
volumePointer = null;
kernelFunction = null;
program = null;
context = null;
initialized = false;
}
}
protected void init() {
if (!initialized) {
largeVolumeMode = false;
int reconDimensionX = getGeometry().getReconDimensionX();
int reconDimensionY = getGeometry().getReconDimensionY();
int reconDimensionZ = getGeometry().getReconDimensionZ();
projectionsAvailable = new ArrayList<Integer>();
projectionsDone = new ArrayList<Integer>();
// Initialize JOCL.
context = OpenCLUtil.createContext();
try {
// get the fastest device
device = context.getMaxFlopsDevice();
// create the command queue
commandQueue = device.createCommandQueue();
// initialize the program
if (program == null || !program.getContext().equals(this.context)) {
program =
context
.createProgram(
OpenCLCompensatedBackProjector.class.getResourceAsStream(
"compensatedBackprojectCL.cl"))
.build();
}
} catch (Exception e) {
if (commandQueue != null) commandQueue.release();
if (kernelFunction != null) kernelFunction.release();
if (program != null) program.release();
// destory context
if (context != null) context.release();
// TODO: handle exception
e.printStackTrace();
}
// check space on device:
long memory = device.getMaxMemAllocSize();
long availableMemory = (memory);
long requiredMemory =
(long)
(((((double) reconDimensionX) * reconDimensionY * ((double) reconDimensionZ) * 4)
+ (((double)
Configuration.getGlobalConfiguration().getGeometry().getDetectorHeight())
* Configuration.getGlobalConfiguration().getGeometry().getDetectorWidth()
* 4)));
if (debug) {
System.out.println("Total available Memory on OpenCL card:" + availableMemory);
System.out.println("Required Memory on OpenCL card:" + requiredMemory);
}
if (requiredMemory > availableMemory) {
nSteps = (int) OpenCLUtil.iDivUp(requiredMemory, availableMemory);
if (debug) System.out.println("Switching to large volume mode with nSteps = " + nSteps);
largeVolumeMode = true;
}
if (debug) {
// TODO replace
/*
CUdevprop prop = new CUdevprop();
JCudaDriver.cuDeviceGetProperties(prop, dev);
System.out.println(prop.toFormattedString());
*/
}
// create the computing kernel
kernelFunction = program.createCLKernel("backprojectKernel");
// create the reconstruction volume;
int memorysize = reconDimensionX * reconDimensionY * reconDimensionZ * 4;
if (largeVolumeMode) {
subVolumeZ = OpenCLUtil.iDivUp(reconDimensionZ, nSteps);
if (debug) System.out.println("SubVolumeZ: " + subVolumeZ);
h_volume = new float[reconDimensionX * reconDimensionY * subVolumeZ];
memorysize = reconDimensionX * reconDimensionY * subVolumeZ * 4;
if (debug) System.out.println("Memory: " + memorysize);
} else {
h_volume = new float[reconDimensionX * reconDimensionY * reconDimensionZ];
}
// compute adapted volume size
// volume size in x = multiple of bpBlockSize[0]
// volume size in y = multiple of bpBlockSize[1]
int adaptedVolSize[] = new int[3];
if ((reconDimensionX % bpBlockSize[0]) == 0) {
adaptedVolSize[0] = reconDimensionX;
} else {
adaptedVolSize[0] = ((reconDimensionX / bpBlockSize[0]) + 1) * bpBlockSize[0];
}
if ((reconDimensionY % bpBlockSize[1]) == 0) {
adaptedVolSize[1] = reconDimensionY;
} else {
adaptedVolSize[1] = ((reconDimensionY / bpBlockSize[1]) + 1) * bpBlockSize[1];
}
adaptedVolSize[2] = reconDimensionZ;
int volStrideHost[] = new int[2];
// compute volstride and copy it to constant memory
volStrideHost[0] = adaptedVolSize[0];
volStrideHost[1] = adaptedVolSize[0] * adaptedVolSize[1];
// copy volume to device
volumePointer = context.createFloatBuffer(h_volume.length, Mem.WRITE_ONLY);
volumePointer.getBuffer().put(h_volume);
volumePointer.getBuffer().rewind();
// copy volume stride to device
volStride = context.createIntBuffer(volStrideHost.length, Mem.READ_ONLY);
volStride.getBuffer().put(volStrideHost);
volStride.getBuffer().rewind();
commandQueue.putWriteBuffer(volumePointer, true).putWriteBuffer(volStride, true).finish();
initialized = true;
}
}