/**
* Test RNG with GID-based device generated seeds.
* */
static void seed_dev_gid_test() {
/* Test variables. */
CCLContext* ctx = NULL;
CCLDevice* dev = NULL;
CCLQueue* cq = NULL;
CCLProgram* prg = NULL;
CCLKernel* krnl = NULL;
CCLBuffer* seeds_dev = NULL;
CCLBuffer* output_dev = NULL;
GError* err = NULL;
CloRng* rng = NULL;
size_t lws = 0;
size_t ws = CLO_RNG_TEST_NUM_SEEDS;
gchar* src;
/* Get context and device. */
ctx = ccl_context_new_any(&err);
g_assert_no_error(err);
dev = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Create command queue. */
cq = ccl_queue_new(ctx, dev, 0, &err);
g_assert_no_error(err);
/* Test all RNGs. */
for (cl_uint i = 0; clo_rng_infos[i].name != NULL; ++i) {
/* Create RNG object. */
rng = clo_rng_new(clo_rng_infos[i].name, CLO_RNG_SEED_DEV_GID,
NULL, CLO_RNG_TEST_NUM_SEEDS, CLO_RNG_TEST_INIT_SEED,
CLO_RNG_TEST_HASH, ctx, cq, &err);
g_assert_no_error(err);
/* Get RNG seeds device buffer. */
seeds_dev = clo_rng_get_device_seeds(rng);
/* Get RNG kernels source. */
src = g_strconcat(
clo_rng_get_source(rng), CLO_RNG_TEST_SRC, NULL);
/* Create and build program. */
prg = ccl_program_new_from_source(ctx, src, &err);
g_assert_no_error(err);
ccl_program_build(prg, NULL, &err);
g_assert_no_error(err);
/* Create output buffer. */
output_dev = ccl_buffer_new(ctx, CL_MEM_WRITE_ONLY,
CLO_RNG_TEST_NUM_SEEDS * sizeof(cl_ulong), NULL, &err);
g_assert_no_error(err);
/* Get kernel from program. */
krnl = ccl_program_get_kernel(prg, CLO_RNG_TEST_KERNEL, &err);
g_assert_no_error(err);
/* Get a "nice" local worksize. */
ccl_kernel_suggest_worksizes(
krnl, dev, 1, &ws, NULL, &lws, &err);
g_assert_no_error(err);
/* Execute kernel. */
ccl_kernel_set_args_and_enqueue_ndrange(
krnl, cq, 1, NULL, &ws, &lws, NULL, &err,
seeds_dev, output_dev, NULL);
g_assert_no_error(err);
/* Release this iteration stuff. */
g_free(src);
ccl_buffer_destroy(output_dev);
ccl_program_destroy(prg);
clo_rng_destroy(rng);
}
/* Destroy queue and context. */
ccl_queue_destroy(cq);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* Test RNG with client generated seeds in device.
* */
static void seed_ext_dev_test() {
/* Test variables. */
CCLContext* ctx = NULL;
CCLDevice* dev = NULL;
CCLQueue* cq = NULL;
CCLProgram* prg = NULL;
CCLKernel* krnl = NULL;
CCLBuffer* seeds_dev = NULL;
CCLBuffer* output_dev = NULL;
GError* err = NULL;
CloRng* rng = NULL;
size_t lws = 0;
size_t ws = CLO_RNG_TEST_NUM_SEEDS;
gchar* src;
cl_uchar* host_seeds;
/* Get context and device. */
ctx = ccl_context_new_any(&err);
g_assert_no_error(err);
dev = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Create command queue. */
cq = ccl_queue_new(ctx, dev, 0, &err);
g_assert_no_error(err);
/* Test all RNGs. */
for (cl_uint i = 0; clo_rng_infos[i].name != NULL; ++i) {
/* Host seeds must account for the seed size of current RNG. */
size_t seed_size =
clo_rng_infos[i].seed_size * CLO_RNG_TEST_NUM_SEEDS;
host_seeds = g_slice_alloc(seed_size);
/* Initialize host seeds with any value. */
for (cl_uint i = 0; i < seed_size; ++i)
host_seeds[i] = (cl_uchar) (((i + 1) * 3) & 0xFF);
/* Allocate memory for device seeds and copy host seeds. */
seeds_dev = ccl_buffer_new(
ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, seed_size,
host_seeds, &err);
g_assert_no_error(err);
/* Create RNG object. */
rng = clo_rng_new(clo_rng_infos[i].name, CLO_RNG_SEED_EXT_DEV,
seeds_dev, CLO_RNG_TEST_NUM_SEEDS, CLO_RNG_TEST_INIT_SEED,
NULL, ctx, cq, &err);
g_assert_no_error(err);
/* Get RNG kernels source. */
src = g_strconcat(
clo_rng_get_source(rng), CLO_RNG_TEST_SRC, NULL);
/* Create and build program. */
prg = ccl_program_new_from_source(ctx, src, &err);
g_assert_no_error(err);
ccl_program_build(prg, NULL, &err);
g_assert_no_error(err);
/* Create output buffer. */
output_dev = ccl_buffer_new(ctx, CL_MEM_WRITE_ONLY,
CLO_RNG_TEST_NUM_SEEDS * sizeof(cl_ulong), NULL, &err);
g_assert_no_error(err);
/* Get kernel from program. */
krnl = ccl_program_get_kernel(prg, CLO_RNG_TEST_KERNEL, &err);
g_assert_no_error(err);
/* Get a "nice" local worksize. */
ccl_kernel_suggest_worksizes(
krnl, dev, 1, &ws, NULL, &lws, &err);
g_assert_no_error(err);
/* Execute kernel. */
ccl_kernel_set_args_and_enqueue_ndrange(
krnl, cq, 1, NULL, &ws, &lws, NULL, &err,
seeds_dev, output_dev, NULL);
g_assert_no_error(err);
/* Release this iteration stuff. */
g_slice_free1(seed_size, host_seeds);
g_free(src);
ccl_buffer_destroy(seeds_dev);
ccl_buffer_destroy(output_dev);
ccl_program_destroy(prg);
clo_rng_destroy(rng);
}
/* Destroy queue and context. */
ccl_queue_destroy(cq);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* Cellular automata sample main function.
* */
int main(int argc, char* argv[]) {
/* Wrappers for OpenCL objects. */
CCLContext* ctx;
CCLDevice* dev;
CCLImage* img1;
CCLImage* img2;
CCLProgram* prg;
CCLKernel* krnl;
CCLEvent* evt1;
CCLEvent* evt2;
/* Other variables. */
CCLEventWaitList ewl = NULL;
/* Profiler object. */
CCLProf* prof;
/* Output images filename. */
char* filename;
/* Selected device, may be given in command line. */
int dev_idx = -1;
/* Error handling object (must be NULL). */
GError* err = NULL;
/* Does selected device support images? */
cl_bool image_ok;
/* Initial sim state. */
cl_uchar4* input_image;
/* Simulation states. */
cl_uchar4** output_images;
/* RNG seed, may be given in command line. */
unsigned int seed;
/* Image file write status. */
int file_write_status;
/* Image format. */
cl_image_format image_format = { CL_RGBA, CL_UNSIGNED_INT8 };
/* Thread data. */
struct thread_data td;
/* Global and local worksizes. */
size_t gws[2];
size_t lws[2];
/* Threads. */
GThread* comm_thread;
GThread* exec_thread;
/* Check arguments. */
if (argc >= 2) {
/* Check if a device was specified in the command line. */
dev_idx = atoi(argv[1]);
}
if (argc >= 3) {
/* Check if a RNG seed was specified. */
seed = atoi(argv[2]);
} else {
seed = (unsigned int) time(NULL);
}
/* Initialize RNG. */
srand(seed);
/* Create random initial state. */
input_image = (cl_uchar4*)
malloc(CA_WIDTH * CA_HEIGHT * sizeof(cl_uchar4));
for (cl_uint i = 0; i < CA_WIDTH * CA_HEIGHT; ++i) {
cl_uchar state = (rand() & 0x3) ? 0xFF : 0x00;
input_image[i] = (cl_uchar4) {{ state, state, state, 0xFF }};
}
/* Allocate space for simulation results. */
output_images = (cl_uchar4**)
malloc((CA_ITERS + 1) * sizeof(cl_uchar4*));
for (cl_uint i = 0; i < CA_ITERS + 1; ++i)
output_images[i] = (cl_uchar4*)
malloc(CA_WIDTH * CA_HEIGHT * sizeof(cl_uchar4));
/* Create context using device selected from menu. */
ctx = ccl_context_new_from_menu_full(&dev_idx, &err);
HANDLE_ERROR(err);
/* Get first device in context. */
dev = ccl_context_get_device(ctx, 0, &err);
HANDLE_ERROR(err);
/* Ask device if it supports images. */
image_ok = ccl_device_get_info_scalar(
dev, CL_DEVICE_IMAGE_SUPPORT, cl_bool, &err);
HANDLE_ERROR(err);
if (!image_ok)
ERROR_MSG_AND_EXIT("Selected device doesn't support images.");
/* Create command queues. */
queue_exec = ccl_queue_new(ctx, dev, CL_QUEUE_PROFILING_ENABLE, &err);
HANDLE_ERROR(err);
queue_comm = ccl_queue_new(ctx, dev, CL_QUEUE_PROFILING_ENABLE, &err);
HANDLE_ERROR(err);
/* Create 2D image for initial state. */
img1 = ccl_image_new(ctx, CL_MEM_READ_WRITE,
&image_format, NULL, &err,
"image_type", (cl_mem_object_type) CL_MEM_OBJECT_IMAGE2D,
"image_width", (size_t) CA_WIDTH,
"image_height", (size_t) CA_HEIGHT,
NULL);
HANDLE_ERROR(err);
/* Create another 2D image for double buffering. */
img2 = ccl_image_new(ctx, CL_MEM_READ_WRITE,
&image_format, NULL, &err,
"image_type", (cl_mem_object_type) CL_MEM_OBJECT_IMAGE2D,
"image_width", (size_t) CA_WIDTH,
"image_height", (size_t) CA_HEIGHT,
NULL);
HANDLE_ERROR(err);
/* Create program from kernel source and compile it. */
prg = ccl_program_new_from_source(ctx, CA_KERNEL, &err);
HANDLE_ERROR(err);
ccl_program_build(prg, NULL, &err);
HANDLE_ERROR(err);
/* Get kernel wrapper. */
krnl = ccl_program_get_kernel(prg, "ca", &err);
HANDLE_ERROR(err);
/* Determine nice local and global worksizes. */
ccl_kernel_suggest_worksizes(krnl, dev, 2, real_ws, gws, lws, &err);
HANDLE_ERROR(err);
printf("\n * Global work-size: (%d, %d)\n", (int) gws[0], (int) gws[1]);
printf(" * Local work-size: (%d, %d)\n", (int) lws[0], (int) lws[1]);
/* Create thread communication queues. */
comm_thread_queue = g_async_queue_new();
exec_thread_queue = g_async_queue_new();
host_thread_queue = g_async_queue_new();
/* Setup thread data. */
td.krnl = krnl;
td.img1 = img1;
td.img2 = img2;
td.gws = gws;
td.lws = lws;
td.output_images = output_images;
/* Create threads. */
exec_thread = g_thread_new("exec_thread", exec_func, &td);
comm_thread = g_thread_new("comm_thread", comm_func, &td);
/* Start profiling. */
prof = ccl_prof_new();
ccl_prof_start(prof);
/* Write initial state. */
ccl_image_enqueue_write(img1, queue_comm, CL_TRUE,
origin, region, 0, 0, input_image, NULL, &err);
HANDLE_ERROR(err);
/* Run CA_ITERS iterations of the CA. */
for (cl_uint i = 0; i < CA_ITERS; ++i) {
/* Send message to comms thread. */
g_async_queue_push(comm_thread_queue, &go_msg);
/* Send message to exec thread. */
g_async_queue_push(exec_thread_queue, &go_msg);
/* Get event wrappers from both threads. */
evt1 = (CCLEvent*) g_async_queue_pop(host_thread_queue);
evt2 = (CCLEvent*) g_async_queue_pop(host_thread_queue);
/* Can't continue until this iteration is over. */
ccl_event_wait_list_add(&ewl, evt1, evt2, NULL);
/* Wait for events. */
ccl_event_wait(&ewl, &err);
HANDLE_ERROR(err);
}
/* Send message to comms thread to read last result. */
g_async_queue_push(comm_thread_queue, &go_msg);
/* Send stop messages to both threads. */
g_async_queue_push(comm_thread_queue, &stop_msg);
g_async_queue_push(exec_thread_queue, &stop_msg);
/* Get event wrapper from comms thread. */
evt1 = (CCLEvent*) g_async_queue_pop(host_thread_queue);
/* Can't continue until final read is over. */
ccl_event_wait_list_add(&ewl, evt1, NULL);
ccl_event_wait(&ewl, &err);
HANDLE_ERROR(err);
/* Make sure both queues are finished. */
ccl_queue_finish(queue_comm, &err);
HANDLE_ERROR(err);
ccl_queue_finish(queue_exec, &err);
HANDLE_ERROR(err);
/* Stop profiling timer and add queues for analysis. */
ccl_prof_stop(prof);
ccl_prof_add_queue(prof, "Comms", queue_comm);
ccl_prof_add_queue(prof, "Exec", queue_exec);
/* Allocate space for base filename. */
filename = (char*) malloc(
(strlen(IMAGE_FILE_PREFIX ".png") + IMAGE_FILE_NUM_DIGITS + 1) * sizeof(char));
/* Write results to image files. */
for (cl_uint i = 0; i < CA_ITERS; ++i) {
/* Determine next filename. */
sprintf(filename, "%s%0" G_STRINGIFY(IMAGE_FILE_NUM_DIGITS) "d.png", IMAGE_FILE_PREFIX, i);
/* Save next image. */
file_write_status = stbi_write_png(filename, CA_WIDTH, CA_HEIGHT, 4,
output_images[i], CA_WIDTH * sizeof(cl_uchar4));
/* Give feedback if unable to save image. */
if (!file_write_status) {
ERROR_MSG_AND_EXIT("Unable to save image in file.");
}
}
/* Process profiling info. */
ccl_prof_calc(prof, &err);
HANDLE_ERROR(err);
/* Print profiling info. */
ccl_prof_print_summary(prof);
/* Save profiling info. */
ccl_prof_export_info_file(prof, "prof.tsv", &err);
HANDLE_ERROR(err);
/* Destroy threads. */
g_thread_join(exec_thread);
g_thread_join(comm_thread);
/* Destroy thread communication queues. */
g_async_queue_unref(comm_thread_queue);
g_async_queue_unref(exec_thread_queue);
g_async_queue_unref(host_thread_queue);
/* Release host buffers. */
free(filename);
free(input_image);
for (cl_uint i = 0; i < CA_ITERS + 1; ++i)
free(output_images[i]);
free(output_images);
/* Release wrappers. */
ccl_image_destroy(img1);
ccl_image_destroy(img2);
ccl_program_destroy(prg);
ccl_queue_destroy(queue_comm);
ccl_queue_destroy(queue_exec);
ccl_context_destroy(ctx);
/* Destroy profiler. */
ccl_prof_destroy(prof);
/* Check all wrappers have been destroyed. */
g_assert(ccl_wrapper_memcheck());
/* Terminate. */
return 0;
}
/**
* Tests creation, getting info from and destruction of
* kernel wrapper objects.
* */
static void create_info_destroy_test() {
/* Test variables. */
CCLContext* ctx = NULL;
cl_context context = NULL;
CCLProgram* prg = NULL;
cl_program program = NULL;
CCLKernel* krnl = NULL;
cl_kernel kernel = NULL;
CCLDevice* d = NULL;
CCLQueue* cq = NULL;
size_t gws;
size_t lws;
cl_uint host_buf[CCL_TEST_KERNEL_BUF_SIZE];
cl_uint host_buf_aux[CCL_TEST_KERNEL_BUF_SIZE];
CCLBuffer* buf;
GError* err = NULL;
CCLEvent* evt = NULL;
CCLEventWaitList ewl = NULL;
const char* krnl_name;
void* args[] = { NULL, NULL };
cl_bool release_krnl;
cl_int ocl_status;
/* Create a context with devices from first available platform. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create a new program from source and build it. */
prg = ccl_program_new_from_source(
ctx, CCL_TEST_KERNEL_CONTENT, &err);
g_assert_no_error(err);
ccl_program_build(prg, NULL, &err);
g_assert_no_error(err);
/* Create a command queue. */
cq = ccl_queue_new(ctx, d, CL_QUEUE_PROFILING_ENABLE, &err);
g_assert_no_error(err);
/* Test three ways to create a kernel wrapper. */
for (cl_uint i = 0; i < 3; ++i) {
/* Create kernel wrapper. */
switch (i) {
case 0:
/* Instantiate kernel directly. */
krnl = ccl_kernel_new(prg, CCL_TEST_KERNEL_NAME, &err);
g_assert_no_error(err);
release_krnl = CL_TRUE;
break;
case 1:
/* Using the program utility function. No need to free
* kernel in this case, because it will be freed when
* program is destroyed. */
krnl = ccl_program_get_kernel(
prg, CCL_TEST_KERNEL_NAME, &err);
g_assert_no_error(err);
release_krnl = CL_FALSE;
break;
case 2:
/* Using the "wrap" constructor. */
kernel = clCreateKernel(ccl_program_unwrap(prg),
CCL_TEST_KERNEL_NAME, &ocl_status);
g_assert_cmpint(ocl_status, ==, CL_SUCCESS);
krnl = ccl_kernel_new_wrap(kernel);
g_assert_cmphex(GPOINTER_TO_UINT(kernel), ==,
GPOINTER_TO_UINT(ccl_kernel_unwrap(krnl)));
release_krnl = CL_TRUE;
break;
}
/* Get some kernel info, compare it with expected info. */
/* Get kernel function name from kernel info, compare it with the
* expected value. */
krnl_name = ccl_kernel_get_info_array(
krnl, CL_KERNEL_FUNCTION_NAME, char*, &err);
g_assert_no_error(err);
g_assert_cmpstr(krnl_name, ==, CCL_TEST_KERNEL_NAME);
/* Check if the kernel context is the same as the initial context
* and the program context. */
context = ccl_kernel_get_info_scalar(
krnl, CL_KERNEL_CONTEXT, cl_context, &err);
g_assert_no_error(err);
g_assert(context == ccl_context_unwrap(ctx));
program = ccl_kernel_get_info_scalar(
krnl, CL_KERNEL_PROGRAM, cl_program, &err);
g_assert_no_error(err);
g_assert(program == ccl_program_unwrap(prg));
#ifndef OPENCL_STUB
cl_uint ocl_ver;
/* Get OpenCL version of kernel's underlying platform. */
ocl_ver = ccl_kernel_get_opencl_version(krnl, &err);
g_assert_no_error(err);
(void)ocl_ver;
#ifdef CL_VERSION_1_1
size_t kwgz;
size_t* kcwgs;
CCLDevice* dev = NULL;
/* If platform supports kernel work group queries, get kernel
* work group information and compare it with expected info. */
if (ocl_ver >= 110) {
dev = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
kwgz = ccl_kernel_get_workgroup_info_scalar(
krnl, dev, CL_KERNEL_WORK_GROUP_SIZE, size_t, &err);
g_assert_no_error(err);
(void)kwgz;
kcwgs = ccl_kernel_get_workgroup_info_array(krnl, dev,
CL_KERNEL_COMPILE_WORK_GROUP_SIZE, size_t*, &err);
g_assert_no_error(err);
(void)kcwgs;
}
#endif /* ifdef CL_VERSION_1_1 */
#ifdef CL_VERSION_1_2
cl_kernel_arg_address_qualifier kaaq;
char* kernel_arg_type_name;
char* kernel_arg_name;
/* If platform supports kernel argument queries, get kernel argument
* information and compare it with expected info. */
if (ocl_ver >= 120) {
kaaq = ccl_kernel_get_arg_info_scalar(krnl, 0,
CL_KERNEL_ARG_ADDRESS_QUALIFIER,
cl_kernel_arg_address_qualifier, &err);
g_assert((err == NULL) || (err->code == CCL_ERROR_INFO_UNAVAILABLE_OCL));
if (err == NULL) {
g_assert_cmphex(kaaq, ==, CL_KERNEL_ARG_ADDRESS_GLOBAL);
} else {
/**
* Image filter main function.
* */
int main(int argc, char * argv[]) {
/* Wrappers for OpenCL objects. */
CCLContext * ctx;
CCLDevice * dev;
CCLImage * img_in;
CCLImage * img_out;
CCLQueue * queue;
CCLProgram * prg;
CCLKernel * krnl;
CCLSampler * smplr;
/* Device selected specified in the command line. */
int dev_idx = -1;
/* Error handling object (must be initialized to NULL). */
CCLErr * err = NULL;
/* Does selected device support images? */
cl_bool image_ok;
/* Image data in host. */
unsigned char * input_image;
unsigned char * output_image;
/* Image properties. */
int width, height, n_channels;
/* Image file write status. */
int file_write_status;
/* Image parameters. */
cl_image_format image_format = { CL_RGBA, CL_UNSIGNED_INT8 };
/* Origin and region of complete image. */
size_t origin[3] = { 0, 0, 0 };
size_t region[3];
/* Real worksize. */
size_t real_ws[2];
/* Global and local worksizes. */
size_t gws[2];
size_t lws[2];
/* Check arguments. */
if (argc < 2) {
ERROR_MSG_AND_EXIT("Usage: image_filter <image_file> [device_index]");
} else if (argc >= 3) {
/* Check if a device was specified in the command line. */
dev_idx = atoi(argv[2]);
}
/* Load image. */
input_image = stbi_load(argv[1], &width, &height, &n_channels, 4);
if (!input_image) ERROR_MSG_AND_EXIT(stbi_failure_reason());
/* Real work size. */
real_ws[0] = width; real_ws[1] = height;
/* Set image region. */
region[0] = width; region[1] = height; region[2] = 1;
/* Create context using device selected from menu. */
ctx = ccl_context_new_from_menu_full(&dev_idx, &err);
HANDLE_ERROR(err);
/* Get first device in context. */
dev = ccl_context_get_device(ctx, 0, &err);
HANDLE_ERROR(err);
/* Ask device if it supports images. */
image_ok = ccl_device_get_info_scalar(
dev, CL_DEVICE_IMAGE_SUPPORT, cl_bool, &err);
HANDLE_ERROR(err);
if (!image_ok)
ERROR_MSG_AND_EXIT("Selected device doesn't support images.");
/* Create a command queue. */
queue = ccl_queue_new(ctx, dev, 0, &err);
HANDLE_ERROR(err);
/* Create 2D input image using loaded image data. */
img_in = ccl_image_new(ctx, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
&image_format, input_image, &err,
"image_type", (cl_mem_object_type) CL_MEM_OBJECT_IMAGE2D,
"image_width", (size_t) width,
"image_height", (size_t) height,
NULL);
HANDLE_ERROR(err);
/* Create 2D output image. */
img_out = ccl_image_new(ctx, CL_MEM_WRITE_ONLY,
&image_format, NULL, &err,
"image_type", (cl_mem_object_type) CL_MEM_OBJECT_IMAGE2D,
"image_width", (size_t) width,
"image_height", (size_t) height,
NULL);
HANDLE_ERROR(err);
/* Create program from kernel source and compile it. */
prg = ccl_program_new_from_source(ctx, FILTER_KERNEL, &err);
HANDLE_ERROR(err);
ccl_program_build(prg, NULL, &err);
HANDLE_ERROR(err);
/* Get kernel wrapper. */
krnl = ccl_program_get_kernel(prg, "do_filter", &err);
HANDLE_ERROR(err);
/* Determine nice local and global worksizes. */
ccl_kernel_suggest_worksizes(krnl, dev, 2, real_ws, gws, lws, &err);
HANDLE_ERROR(err);
/* Show information to user. */
printf("\n * Image size: %d x %d, %d channels\n",
width, height, n_channels);
printf(" * Global work-size: (%d, %d)\n", (int) gws[0], (int) gws[1]);
printf(" * Local work-size: (%d, %d)\n", (int) lws[0], (int) lws[1]);
/* Create sampler (this could also be created in-kernel). */
smplr = ccl_sampler_new(ctx, CL_FALSE, CL_ADDRESS_CLAMP_TO_EDGE,
CL_FILTER_NEAREST, &err);
HANDLE_ERROR(err);
/* Apply filter. */
ccl_kernel_set_args_and_enqueue_ndrange(
krnl, queue, 2, NULL, gws, lws, NULL, &err,
img_in, img_out, smplr, NULL);
HANDLE_ERROR(err);
/* Allocate space for output image. */
output_image = (unsigned char *)
malloc(width * height * 4 * sizeof(unsigned char));
/* Read image data back to host. */
ccl_image_enqueue_read(img_out, queue, CL_TRUE, origin, region,
0, 0, output_image, NULL, &err);
HANDLE_ERROR(err);
/* Write image to file. */
file_write_status = stbi_write_png(IMAGE_FILE, width, height, 4,
output_image, width * 4);
/* Give feedback. */
if (file_write_status) {
fprintf(stdout, "\nImage saved in file '" IMAGE_FILE "'\n");
} else {
ERROR_MSG_AND_EXIT("Unable to save image in file.");
}
/* Release host images. */
free(output_image);
stbi_image_free(input_image);
/* Release wrappers. */
ccl_image_destroy(img_in);
ccl_image_destroy(img_out);
ccl_sampler_destroy(smplr);
ccl_program_destroy(prg);
ccl_queue_destroy(queue);
ccl_context_destroy(ctx);
/* Check all wrappers have been destroyed. */
assert(ccl_wrapper_memcheck());
/* Terminate. */
return EXIT_SUCCESS;
}
/**
* Canonical example main function.
* */
int main(int argc, char** argv) {
/* Number of elements in buffer. */
size_t buf_n = DEF_BUF_N;
/* Device selected specified in the command line. */
int dev_idx = -1;
/* Program return value. */
int ret_val;
/* Check if a device was specified in the command line. */
if (argc >= 2) {
dev_idx = atoi(argv[1]);
}
/* Check if a new buffer size was specified in the command line. */
if (argc >= 3) {
buf_n = atoi(argv[2]);
}
/* Wrappers. */
CCLContext* ctx = NULL;
CCLProgram* prg = NULL;
CCLDevice* dev = NULL;
CCLQueue* queue = NULL;
CCLKernel* krnl = NULL;
CCLBuffer* a_dev;
CCLBuffer* b_dev;
CCLBuffer* c_dev;
CCLEvent* evt_write1;
CCLEvent* evt_write2;
CCLEvent* evt_exec;
CCLEventWaitList ewl = NULL;
/* Profiler. */
CCLProf* prof;
/* Global and local worksizes. */
size_t gws = 0;
size_t lws = 0;
/* Host buffers. */
cl_uint* a_host = NULL;
cl_uint* b_host = NULL;
cl_uint* c_host = NULL;
cl_uint d_host;
/* Error reporting object. */
CCLErr* err = NULL;
/* Check results flag. */
cl_bool check_result;
/* Create a context with device selected from menu. */
ctx = ccl_context_new_from_menu_full(&dev_idx, &err);
HANDLE_ERROR(err);
/* Get the selected device. */
dev = ccl_context_get_device(ctx, 0, &err);
HANDLE_ERROR(err);
/* Create a new program from kernel source. */
prg = ccl_program_new_from_source(ctx, KERNEL_SRC, &err);
HANDLE_ERROR(err);
/* Build program. */
ccl_program_build(prg, NULL, &err);
HANDLE_ERROR(err);
/* Create a command queue. */
queue = ccl_queue_new(ctx, dev, CL_QUEUE_PROFILING_ENABLE, &err);
HANDLE_ERROR(err);
/* Get kernel object. */
krnl = ccl_program_get_kernel(prg, KERNEL_NAME, &err);
HANDLE_ERROR(err);
/* Get worksizes. */
lws = ccl_kernel_suggest_worksizes(krnl, dev, 1, &buf_n, &gws, &lws, &err);
HANDLE_ERROR(err);
/* Show worksizes. */
printf("\n");
printf(" * Global worksize: %d\n", (int) gws);
printf(" * Local worksize : %d\n", (int) lws);
/* Initialize host buffers. */
a_host = (cl_uint*) malloc(sizeof(cl_uint) * buf_n);
b_host = (cl_uint*) malloc(sizeof(cl_uint) * buf_n);
c_host = (cl_uint*) malloc(sizeof(cl_uint) * buf_n);
/* Fill host buffers. */
for (cl_uint i = 0; i < buf_n; ++i) {
a_host[i] = i;
b_host[i] = buf_n - i;
}
d_host = buf_n / 4;
/* Create device buffers. */
a_dev = ccl_buffer_new(ctx, CL_MEM_READ_ONLY,
buf_n * sizeof(cl_uint), NULL, &err);
HANDLE_ERROR(err);
b_dev = ccl_buffer_new(ctx, CL_MEM_READ_ONLY,
buf_n * sizeof(cl_uint), NULL, &err);
HANDLE_ERROR(err);
c_dev = ccl_buffer_new(ctx, CL_MEM_WRITE_ONLY,
buf_n * sizeof(cl_uint), NULL, &err);
HANDLE_ERROR(err);
/* Copy host data to device buffers without waiting for transfer
* to terminate before continuing host program. */
evt_write1 = ccl_buffer_enqueue_write(a_dev, queue, CL_FALSE, 0,
buf_n * sizeof(cl_uint), a_host, NULL, &err);
HANDLE_ERROR(err);
evt_write2 = ccl_buffer_enqueue_write(b_dev, queue, CL_FALSE, 0,
buf_n * sizeof(cl_uint), b_host, NULL, &err);
HANDLE_ERROR(err);
/* Initialize event wait list and add the two transfer events. */
ccl_event_wait_list_add(&ewl, evt_write1, evt_write2, NULL);
/* Execute program kernel, waiting for the two transfer events
* to terminate (this will empty the event wait list). */
evt_exec = ccl_program_enqueue_kernel(prg, KERNEL_NAME, queue, 1,
NULL, &gws, &lws, &ewl, &err,
/* Kernel arguments. */
a_dev, b_dev, c_dev,
ccl_arg_priv(d_host, cl_uint), ccl_arg_priv(buf_n, cl_uint),
NULL);
HANDLE_ERROR(err);
/* Add the kernel termination event to the wait list. */
ccl_event_wait_list_add(&ewl, evt_exec, NULL);
/* Sync. queue for events in wait list (just the execute event in
* this case) to terminate before going forward... */
ccl_enqueue_barrier(queue, &ewl, &err);
HANDLE_ERROR(err);
/* Read back results from host waiting for transfer to terminate
* before continuing host program. */
ccl_buffer_enqueue_read(c_dev, queue, CL_TRUE, 0,
buf_n * sizeof(cl_uint), c_host, NULL, &err);
HANDLE_ERROR(err);
/* Check results are as expected (not available with OpenCL stub). */
check_result = CL_TRUE;
for (cl_uint i = 0; i < buf_n; ++i) {
if(c_host[i] != a_host[i] + b_host[i] + d_host) {
check_result = CL_FALSE;
break;
}
}
if (check_result) {
fprintf(stdout, " * Kernel execution produced the expected results.\n");
ret_val = EXIT_SUCCESS;
} else {
fprintf(stderr,
" * Kernel execution failed to produce the expected results.\n");
ret_val = EXIT_FAILURE;
}
/* Perform profiling. */
prof = ccl_prof_new();
ccl_prof_add_queue(prof, "queue1", queue);
ccl_prof_calc(prof, &err);
HANDLE_ERROR(err);
/* Show profiling info. */
ccl_prof_print_summary(prof);
/* Export profiling info. */
ccl_prof_export_info_file(prof, "out.tsv", &err);
HANDLE_ERROR(err);
/* Destroy profiler object. */
ccl_prof_destroy(prof);
/* Destroy host buffers. */
free(a_host);
free(b_host);
free(c_host);
/* Destroy wrappers. */
ccl_buffer_destroy(a_dev);
ccl_buffer_destroy(b_dev);
ccl_buffer_destroy(c_dev);
ccl_queue_destroy(queue);
ccl_program_destroy(prg);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly freed. */
assert(ccl_wrapper_memcheck());
/* Bye. */
return ret_val;
}
