Skip to content

Commit

Permalink
refactor: add documentation, comment out unused methods
Browse files Browse the repository at this point in the history
  • Loading branch information
@RaghavRamesh
RaghavRamesh committed Apr 22, 2015
1 parent 7f3cf8d commit 3a6b06f
Show file tree
Hide file tree
Showing 3 changed files with 217 additions and 202 deletions.
382 changes: 193 additions & 189 deletions ACP/ACP/AdvancedProcessor.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,198 +10,202 @@

// Simple compute kernel which computes the square of an input array
//
const char *KernelSource = "\n" \
"__kernel void extractText ( \n"\
" __global Mat input, \n"\
" __global string output, \n"\
" int count) \n"\
" { \n"\
" tessAPI = new tesseract::TessBaseAPI(); \n"\
" tessAPI->SetImage(input.data, input.cols, input.rows, \n"\
" input.channels(), input.step); \n"\
" int i = get_global_id(0); \n"\
" if(i < count) { \n"\
" output[i] = tessAPI->GetUTF8Text(); \n"\
" tessAPI->End(); \n"\
" } \n"\
" } \n"\
"\n";
//const char *KernelSource = "\n" \
//"__kernel void extractText ( \n"\
//" __global Mat input, \n"\
//" __global string output, \n"\
//" int count) \n"\
//" { \n"\
//" tessAPI = new tesseract::TessBaseAPI(); \n"\
//" tessAPI->SetImage(input.data, input.cols, input.rows, \n"\
//" input.channels(), input.step); \n"\
//" int i = get_global_id(0); \n"\
//" if(i < count) { \n"\
//" output[i] = tessAPI->GetUTF8Text(); \n"\
//" tessAPI->End(); \n"\
//" } \n"\
//" } \n"\
//"\n";

////////////////////////////////////////////////////////////////////////////////


// This class was created to use OpenCL for extracting text in parallel. This method was discarded because
// Tesseract is not written in C++. The code is not deleted just in case some workaround can be devised.
int AdvancedProcessor :: processAcrossCores()
{
int err; // error code returned from api calls

float data[DATA_SIZE]; // original data set given to device
float results[DATA_SIZE]; // results returned from device
unsigned int correct; // number of correct results returned

size_t global; // global domain size for our calculation
size_t local; // local domain size for our calculation

// Setup objects
cl_device_id device_id; // compute device id
cl_context context; // compute context
cl_command_queue commands; // compute command queue
// Execution objects
cl_program program; // compute program
cl_kernel kernel; // compute kernel

cl_mem input; // device memory used for the input array
cl_mem output; // device memory used for the output array

// Fill our data set with random float values
//
int i = 0;
unsigned int count = DATA_SIZE;
for(i = 0; i < count; i++)
data[i] = rand() / (float)RAND_MAX;

// Connect to a compute device
// Give me a GPU or a CPU device
int gpu = 1;
err = clGetDeviceIDs(NULL, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, &device_id, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to create a device group!\n");
return EXIT_FAILURE;
}

// Create a compute context
//
context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
if (!context)
{
printf("Error: Failed to create a compute context!\n");
return EXIT_FAILURE;
}

// Create a command commands
// One command queue for each device
commands = clCreateCommandQueue(context, device_id, 0, &err);
if (!commands)
{
printf("Error: Failed to create a command commands!\n");
return EXIT_FAILURE;
}

// Create the compute program from the source buffer
//
program = clCreateProgramWithSource(context, 1, (const char **) & KernelSource, NULL, &err);
if (!program)
{
printf("Error: Failed to create compute program!\n");
return EXIT_FAILURE;
}

// Build the program executable
//
err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
if (err != CL_SUCCESS)
{
size_t len;
char buffer[2048];

printf("Error: Failed to build program executable!\n");
clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
printf("%s\n", buffer);
exit(1);
}

// Create the compute kernel in the program we wish to run
//
kernel = clCreateKernel(program, "square", &err);
if (!kernel || err != CL_SUCCESS)
{
printf("Error: Failed to create compute kernel!\n");
exit(1);
}

// Create the input and output arrays in device memory for our calculation
// size in bytes
input = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float) * count, NULL, NULL);
output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * count, NULL, NULL);
if (!input || !output)
{
printf("Error: Failed to allocate device memory!\n");
exit(1);
}

// Write our data set into the input array in device memory
// Refer evernote for syntax
err = clEnqueueWriteBuffer(commands, input, CL_TRUE, 0, sizeof(float) * count, data, 0, NULL, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to write to source array!\n");
exit(1);
}

// Set the arguments to our compute kernel
//
err = 0;
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &input);
err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &output);
err |= clSetKernelArg(kernel, 2, sizeof(unsigned int), &count);
if (err != CL_SUCCESS)
{
printf("Error: Failed to set kernel arguments! %d\n", err);
exit(1);
}

// Get the maximum work group size for executing the kernel on the device
//
err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(local), &local, NULL);
if (err != CL_SUCCESS)
{
printf("Error: Failed to retrieve kernel work group info! %d\n", err);
exit(1);
}

// Execute the kernel over the entire range of our 1d input data set
// using the maximum number of work group items for this device
// Enqueue the work
global = count;
err = clEnqueueNDRangeKernel(commands, kernel, 1, NULL, &global, &local, 0, NULL, NULL);
if (err)
{
printf("Error: Failed to execute kernel!\n");
return EXIT_FAILURE;
}

// Wait for the command commands to get serviced before reading back results
//
clFinish(commands);

// Read back the results from the device to verify the output
//
err = clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(float) * count, results, 0, NULL, NULL );
if (err != CL_SUCCESS)
{
printf("Error: Failed to read output array! %d\n", err);
exit(1);
}

// Validate our results
//
correct = 0;
for(i = 0; i < count; i++)
{
if(results[i] == data[i] * data[i])
correct++;
}

// Print a brief summary detailing the results
//
printf("Computed '%d/%d' correct values!\n", correct, count);

// Shutdown and cleanup
//
clReleaseMemObject(input);
clReleaseMemObject(output);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(commands);
clReleaseContext(context);

// int err; // error code returned from api calls
//
// float data[DATA_SIZE]; // original data set given to device
// float results[DATA_SIZE]; // results returned from device
// unsigned int correct; // number of correct results returned
//
// size_t global; // global domain size for our calculation
// size_t local; // local domain size for our calculation
//
// // Setup objects
// cl_device_id device_id; // compute device id
// cl_context context; // compute context
// cl_command_queue commands; // compute command queue
// // Execution objects
// cl_program program; // compute program
// cl_kernel kernel; // compute kernel
//
// cl_mem input; // device memory used for the input array
// cl_mem output; // device memory used for the output array
//
// // Fill our data set with random float values
// //
// int i = 0;
// unsigned int count = DATA_SIZE;
// for(i = 0; i < count; i++)
// data[i] = rand() / (float)RAND_MAX;
//
// // Connect to a compute device
// // Give me a GPU or a CPU device
// int gpu = 1;
// err = clGetDeviceIDs(NULL, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, &device_id, NULL);
// if (err != CL_SUCCESS)
// {
// printf("Error: Failed to create a device group!\n");
// return EXIT_FAILURE;
// }
//
// // Create a compute context
// //
// context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
// if (!context)
// {
// printf("Error: Failed to create a compute context!\n");
// return EXIT_FAILURE;
// }
//
// // Create a command commands
// // One command queue for each device
// commands = clCreateCommandQueue(context, device_id, 0, &err);
// if (!commands)
// {
// printf("Error: Failed to create a command commands!\n");
// return EXIT_FAILURE;
// }
//
// // Create the compute program from the source buffer
// //
// program = clCreateProgramWithSource(context, 1, (const char **) & KernelSource, NULL, &err);
// if (!program)
// {
// printf("Error: Failed to create compute program!\n");
// return EXIT_FAILURE;
// }
//
// // Build the program executable
// //
// err = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
// if (err != CL_SUCCESS)
// {
// size_t len;
// char buffer[2048];
//
// printf("Error: Failed to build program executable!\n");
// clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
// printf("%s\n", buffer);
// exit(1);
// }
//
// // Create the compute kernel in the program we wish to run
// //
// kernel = clCreateKernel(program, "square", &err);
// if (!kernel || err != CL_SUCCESS)
// {
// printf("Error: Failed to create compute kernel!\n");
// exit(1);
// }
//
// // Create the input and output arrays in device memory for our calculation
// // size in bytes
// input = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float) * count, NULL, NULL);
// output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * count, NULL, NULL);
// if (!input || !output)
// {
// printf("Error: Failed to allocate device memory!\n");
// exit(1);
// }
//
// // Write our data set into the input array in device memory
// // Refer evernote for syntax
// err = clEnqueueWriteBuffer(commands, input, CL_TRUE, 0, sizeof(float) * count, data, 0, NULL, NULL);
// if (err != CL_SUCCESS)
// {
// printf("Error: Failed to write to source array!\n");
// exit(1);
// }
//
// // Set the arguments to our compute kernel
// //
// err = 0;
// err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &input);
// err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &output);
// err |= clSetKernelArg(kernel, 2, sizeof(unsigned int), &count);
// if (err != CL_SUCCESS)
// {
// printf("Error: Failed to set kernel arguments! %d\n", err);
// exit(1);
// }
//
// // Get the maximum work group size for executing the kernel on the device
// //
// err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(local), &local, NULL);
// if (err != CL_SUCCESS)
// {
// printf("Error: Failed to retrieve kernel work group info! %d\n", err);
// exit(1);
// }
//
// // Execute the kernel over the entire range of our 1d input data set
// // using the maximum number of work group items for this device
// // Enqueue the work
// global = count;
// err = clEnqueueNDRangeKernel(commands, kernel, 1, NULL, &global, &local, 0, NULL, NULL);
// if (err)
// {
// printf("Error: Failed to execute kernel!\n");
// return EXIT_FAILURE;
// }
//
// // Wait for the command commands to get serviced before reading back results
// //
// clFinish(commands);
//
// // Read back the results from the device to verify the output
// //
// err = clEnqueueReadBuffer( commands, output, CL_TRUE, 0, sizeof(float) * count, results, 0, NULL, NULL );
// if (err != CL_SUCCESS)
// {
// printf("Error: Failed to read output array! %d\n", err);
// exit(1);
// }
//
// // Validate our results
// //
// correct = 0;
// for(i = 0; i < count; i++)
// {
// if(results[i] == data[i] * data[i])
// correct++;
// }
//
// // Print a brief summary detailing the results
// //
// printf("Computed '%d/%d' correct values!\n", correct, count);
//
// // Shutdown and cleanup
// //
// clReleaseMemObject(input);
// clReleaseMemObject(output);
// clReleaseProgram(program);
// clReleaseKernel(kernel);
// clReleaseCommandQueue(commands);
// clReleaseContext(context);
//
return 0;
}
Loading

0 comments on commit 3a6b06f

Please sign in to comment.