bool Sample::begin()
{
initGL();
initOpenCL();
m_control.m_sceneOrbit = nvmath::vec3f(-0.25f, 0.0f, 0.0f);
m_control.m_sceneDimension = float(10) * 0.2f;
m_control.m_viewMatrix = nvmath::look_at(m_control.m_sceneOrbit - nvmath::vec3f(0, 0, -m_control.m_sceneDimension), m_control.m_sceneOrbit, nvmath::vec3f(0, 1, 0));
return true;
}
int main (int argc, char* argv[]) {
struct timespec start, end;
initOpenCL();
/* START Measurements */
get_date(argc, argv);
clock_gettime(CLOCK_MONOTONIC, &start);
int arraySize = SIZE;
size_t bufferSize = arraySize * sizeof(double);
double* inputA = (double*) malloc (bufferSize);
double* inputB = (double*) malloc (bufferSize);
double* output = (double*) malloc (bufferSize);
/* Initilise data */
initialize_data(arraySize, inputA, inputB);
/* Computation */
vector_sum(arraySize, inputA, inputB, output);
/* END Measurements */
clock_gettime(CLOCK_MONOTONIC, &end);
get_date(argc, argv);
/* Check results */
//check_results(arraySize, inputA, inputB, output);
/* Cleaning */
cleanUpOpenCL();
double res=0;
int i;
for (i = 0; i < arraySize; i++) {
res = res + output[i] ;
}
times = (((double)(end.tv_sec - start.tv_sec)*1000) +
((double)(end.tv_nsec - start.tv_nsec)/1000000));
//cout << "Time to finish: " << times << " ms" << endl;
printf("Time to finish %6.0f ms [check = %e]\n", times, res);
}
int main(int argc, char const *argv[])
{
unsigned int i;
if(argc < 2) {
std::cout << "Usage: " << argv[0] << "<numberElements> <Optional_numberOverlapPerGPU>" << std::endl;
return -1;
} else {
// Set the values in regards to the supplied arguments
if(argc >= 2) {
numberElems = atoi(argv[1]);
if(argc == 3) {
numOverlap = atoi(argv[2]);
} else {
numOverlap = DEFAULT_OVERLAP;
}
}
}
inValues1 = new float[numberElems];
inValues2 = new float[numberElems];
outValues = new float[numberElems];
// Initialize the example matrices
for(i = 0; i < numberElems; i++) {
inValues1[i] = 10;
inValues2[i] = 15;
}
initOpenCL();
startExecution();
finishOpenCL();
free(inValues1);
free(inValues2);
free(outValues);
return 0;
}
bool bakeTextureMap(const Surface &src, const Surface &target) {
OCL ocl;
if (!initOpenCL(ocl, 2)) {
BAKE_LOG("Failed to initialize OpenCL.");
return false;
}
SurfaceVolume sv;
if (!buildSurfaceVolume(src, Eigen::Vector3i::Constant(64), sv)) {
BAKE_LOG("Failed to create surface volume.");
return false;
}
// Target
cl_int err;
cl::Buffer bTargetVertexPositions(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
target.vertexPositions.array().size() * sizeof(float),
const_cast<float*>(target.vertexPositions.data()),
&err);
ASSERT_OPENCL(err, "Failed to create vertex buffer for target.");
cl::Buffer bTargetVertexUVs(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
target.vertexUVs.array().size() * sizeof(float),
const_cast<float*>(target.vertexUVs.data()), &err);
ASSERT_OPENCL(err, "Failed to create UV buffer for target.");
cl::Buffer bTargetVertexNormals(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
target.vertexNormals.array().size() * sizeof(float),
const_cast<float*>(target.vertexNormals.data()), &err);
ASSERT_OPENCL(err, "Failed to create normals buffer for target.");
// Source
cl::Buffer bSrcVertexPositions(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
src.vertexPositions.array().size() * sizeof(float),
const_cast<float*>(src.vertexPositions.data()),
&err);
ASSERT_OPENCL(err, "Failed to create vertex buffer for source.");
cl::Buffer bSrcVertexNormals(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
src.vertexNormals.array().size() * sizeof(float),
const_cast<float*>(src.vertexNormals.data()), &err);
ASSERT_OPENCL(err, "Failed to create normals buffer for source.");
cl::Buffer bSrcVertexColors(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
src.vertexColors.array().size() * sizeof(float),
const_cast<float*>(src.vertexColors.data()), &err);
ASSERT_OPENCL(err, "Failed to create color buffer for source.");
// Volume
cl::Buffer bSrcVoxels(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
(int)sv.cells.size() * sizeof(int),
const_cast<int*>(sv.cells.data()),
&err);
ASSERT_OPENCL(err, "Failed to create voxel buffer for source.");
cl::Buffer bSrcTrianglesInVoxels(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
(int)sv.triangleIndices.size() * sizeof(int),
const_cast<int*>(sv.triangleIndices.data()),
&err);
ASSERT_OPENCL(err, "Failed to triangle index buffer for source.");
float minmax[8] = {
sv.bounds.min().x(), sv.bounds.min().y(), sv.bounds.min().z(), 0.f,
sv.bounds.max().x(), sv.bounds.max().y(), sv.bounds.max().z(), 0.f,
};
cl_float4 voxelSizes = {{sv.voxelSizes.x(), sv.voxelSizes.y(), sv.voxelSizes.z(), 0}};
cl_float4 invVoxelSizes = {{1.f / sv.voxelSizes.x(), 1.f / sv.voxelSizes.y(), 1.f / sv.voxelSizes.z(), 0}};
cl_int4 voxelsPerDim = {{sv.voxelsPerDimension.x(), sv.voxelsPerDimension.y(), sv.voxelsPerDimension.z(), 0}};
// Texture
const int imagesize = 512;
Image<unsigned char> texture(imagesize, imagesize, 3);
texture.toOpenCV().setTo(0);
cl::Image2D bTexture(ocl.ctx,
CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_PTR,
cl::ImageFormat(CL_RGB, CL_UNORM_INT8),
imagesize, imagesize, 0, texture.row(0), &err);
ASSERT_OPENCL(err, "Failed to create texture image.");
int argc = 0;
ocl.kBakeTexture.setArg(0, bTargetVertexPositions);
ocl.kBakeTexture.setArg(1, bTargetVertexNormals);
ocl.kBakeTexture.setArg(2, bTargetVertexUVs);
ocl.kBakeTexture.setArg(3, bSrcVertexPositions);
ocl.kBakeTexture.setArg(4, bSrcVertexNormals);
ocl.kBakeTexture.setArg(5, bSrcVertexColors);
ocl.kBakeTexture.setArg(6, bSrcVoxels);
ocl.kBakeTexture.setArg(7, bSrcTrianglesInVoxels);
ocl.kBakeTexture.setArg(8, carray(minmax, 8));
ocl.kBakeTexture.setArg(9, sizeof(cl_float4), voxelSizes.s);
ocl.kBakeTexture.setArg(10, sizeof(cl_float4), invVoxelSizes.s);
ocl.kBakeTexture.setArg(11, sizeof(cl_int4), voxelsPerDim.s);
ocl.kBakeTexture.setArg(12, bTexture);
ocl.kBakeTexture.setArg(13, imagesize);
ocl.kBakeTexture.setArg(14, 0.5f);
ocl.kBakeTexture.setArg(15, (int)target.vertexPositions.cols()/3);
int nTrianglesDivisableBy2 = target.vertexPositions.cols()/3 + (target.vertexPositions.cols()/3) % 2;
err = ocl.q.enqueueNDRangeKernel(ocl.kBakeTexture, cl::NullRange, cl::NDRange(nTrianglesDivisableBy2), cl::NullRange);
ASSERT_OPENCL(err, "Failed to run bake kernel.");
cl::size_t<3> origin;
origin.push_back(0);
origin.push_back(0);
origin.push_back(0);
cl::size_t<3> region;
region.push_back(imagesize);
region.push_back(imagesize);
region.push_back(1);
err = ocl.q.enqueueReadImage(bTexture, false, origin, region, 0, 0, texture.row(0));
ASSERT_OPENCL(err, "Failed to read image.");
ocl.q.finish();
cv::Mat m = texture.toOpenCV();
cv::flip(m, m, 0);
cv::imwrite("input.png", m);
cv::imshow("test", m);
cv::waitKey();
return false;
}
OCLSample::OCLSample()
: numIterations_(4) {
initOpenCL();
}
int main(int argc, const char * argv[]) {
// Simulation parameters
cl_float T = 100; // Maximum time
cl_float dt = 0.01; // Length of timestep
int planets = 3; // Number of bodies (sun, earth, moon)
Planet universe[planets];
Planet output[planets];
memset(universe, 0, planets*sizeof(Planet));
printf("Size of universe: %lu bytes\n", sizeof(universe));
// Initialisation
// Sun at center - according to G. Galilei
universe[0].x_old = 0;
universe[0].y_old = 0;
universe[0].z_old = 0;
universe[0].mass = 5;
// Earth
universe[1].x_old = 40;
universe[1].y_old = 0;
universe[1].z_old = 0;
universe[1].mass = 81.3;
universe[1].vy = 2;
// Moon
universe[2].x_old = 44;
universe[2].y_old = 0;
universe[2].z_old = 0;
universe[2].mass = 10;
universe[2].vy = -0.8;
printf("Position of sun: %9.6f, %9.6f, %9.6f\n", universe[0].x_old, universe[0].y_old, universe[0].z_old);
printf("Position of earth: %9.6f, %9.6f, %9.6f\n", universe[1].x_old, universe[1].y_old, universe[1].z_old);
printf("Position of moon: %9.6f, %9.6f, %9.6f\n", universe[2].x_old, universe[2].y_old, universe[2].z_old);
// Initialize OpenCL and create leap_frog integration kernel
initOpenCL();
cl_program program = buildCLProgram("calc.cl");
cl_kernel kernel = buildCLKernel(program, "leap_frog");
// Create memory buffer andy copy universe
cl_mem univ = createCLBuffer(sizeof(universe));
writeDataToCLBuffer(universe, sizeof(universe), univ);
waitForCLOperations();
// Set kernel arguments
cl_int error = CL_SUCCESS;
error = clSetKernelArg (kernel, 0, sizeof(cl_mem), &univ);
error = clSetKernelArg (kernel, 1, sizeof(cl_float), &dt);
error = clSetKernelArg (kernel, 2, sizeof(cl_int), &planets);
error = clSetKernelArg (kernel, 3, sizeof(cl_float), &T);
showCLError(error);
// Run kernel
const size_t globalSize = planets;
enqueueCLKernel(kernel, globalSize);
waitForCLOperations();
// Read results
readDataFromCLBuffer(output, sizeof(universe), univ);
waitForCLOperations();
// Clean up
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseMemObject(univ);
releaseCLHelper();
printf("%lu Bytes of data read from graphics card\n", sizeof(universe));
printf("Position of sun: %9.6f, %9.6f, %9.6f\n", output[0].x, output[0].y, output[0].z);
printf("Position of earth: %9.6f, %9.6f, %9.6f\n", output[1].x, output[1].y, output[1].z);
printf("Position of moon: %9.6f, %9.6f, %9.6f\n", output[2].x, output[2].y, output[2].z);
return 0;
}
