/**
* Tests creation, getting info from and destruction of
* profiler objects, and their relationship with context, device and
* queue wrapper objects.
* */
static void create_add_destroy_test() {
/* Test variables. */
CCLErr* err = NULL;
CCLBuffer* buf1 = NULL;
CCLBuffer* buf2 = NULL;
CCLProf* prof = NULL;
CCLContext* ctx = NULL;
CCLDevice* d = NULL;
CCLQueue* cq1 = NULL;
CCLQueue* cq2 = NULL;
CCLEvent* evt = NULL;
CCLEventWaitList ewl = NULL;
size_t buf_size = 8 * sizeof(cl_short);
cl_short hbuf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
cl_ulong duration, eff_duration;
double time_elapsed;
/* Create a new profile object. */
prof = ccl_prof_new();
/* Get a context and a device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
d = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Create two command queue wrappers. */
cq1 = ccl_queue_new(ctx, d, CL_QUEUE_PROFILING_ENABLE, &err);
g_assert_no_error(err);
cq2 = ccl_queue_new(ctx, d, CL_QUEUE_PROFILING_ENABLE, &err);
g_assert_no_error(err);
/* Create device buffers. */
buf1 = ccl_buffer_new(ctx, CL_MEM_READ_ONLY, buf_size, NULL, &err);
g_assert_no_error(err);
buf2 = ccl_buffer_new(ctx, CL_MEM_READ_WRITE, buf_size, NULL, &err);
g_assert_no_error(err);
/* Start profile object timer. */
ccl_prof_start(prof);
/* Transfer data to buffer. */
evt = ccl_buffer_enqueue_write(
buf1, cq1, CL_FALSE, 0, buf_size, hbuf, NULL, &err);
g_assert_no_error(err);
/* Transfer data from one buffer to another. */
evt = ccl_buffer_enqueue_copy(buf1, buf2, cq2, 0, 0, buf_size,
ccl_ewl(&ewl, evt, NULL), &err);
g_assert_no_error(err);
/* Wait for copy. */
ccl_event_wait(ccl_ewl(&ewl, evt, NULL), &err);
g_assert_no_error(err);
/* Stop profile object timer. */
ccl_prof_stop(prof);
/* Add both queues to profile object. */
ccl_prof_add_queue(prof, "A Queue", cq1);
ccl_prof_add_queue(prof, "Another Queue", cq2);
/* Process queues. */
ccl_prof_calc(prof, &err);
g_assert_no_error(err);
/* Request some profiling information. */
time_elapsed = ccl_prof_time_elapsed(prof);
duration = ccl_prof_get_duration(prof);
eff_duration = ccl_prof_get_eff_duration(prof);
g_debug("Profiling time elapsed: %lf", time_elapsed);
g_debug("Profiling duration: %d", (cl_int) duration);
g_debug("Profiling eff. duration: %d", (cl_int) eff_duration);
/* Destroy buffers. */
ccl_buffer_destroy(buf1);
ccl_buffer_destroy(buf2);
/* Unref cq1, which should not be destroyed because it is held
* by the profile object. */
ccl_queue_destroy(cq1);
/* Destroy the profile object, which will also destroy cq1. cq2
* will me merely unrefed and must still be explicitly destroyed. */
ccl_prof_destroy(prof);
/* Destroy cq2. */
ccl_queue_destroy(cq2);
/* Destroy the context. */
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* @internal
*
* @brief Tests the ccl_buffer_new_from_region() function.
* */
static void create_from_region_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLDevice * dev = NULL;
CCLQueue * cq = NULL;
CCLBuffer * buf = NULL;
CCLBuffer * subbuf = NULL;
CCLEvent * evt = NULL;
CCLEventWaitList ewl = NULL;
CCLErr * err = NULL;
cl_ulong * hbuf;
cl_ulong * hsubbuf;
cl_uint min_align;
size_t siz_buf;
size_t siz_subbuf;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Get first device in context. */
dev = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Get minimum alignment for sub-buffer in bits. */
min_align = ccl_device_get_info_scalar(
dev, CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint, &err);
g_assert_no_error(err);
/* Determine buffer and sub-buffer sizes (divide by 64 because its
* the number of bits in cl_ulong). */
siz_subbuf = sizeof(cl_ulong) * min_align / 64;
siz_buf = 4 * siz_subbuf;
/* Allocate memory for host buffer and host sub-buffer. */
hbuf = g_slice_alloc(siz_buf);
hsubbuf = g_slice_alloc(siz_subbuf);
/* Initialize initial host buffer. */
for (cl_uint i = 0; i < siz_buf / sizeof(cl_ulong); ++i)
hbuf[i] = g_test_rand_int();
/* Create a command queue. */
cq = ccl_queue_new(ctx, dev, 0, &err);
g_assert_no_error(err);
/* Create a regular buffer, put some data in it. */
buf = ccl_buffer_new(
ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, siz_buf, hbuf, &err);
g_assert_no_error(err);
/* Create sub-buffer from indexes 16 to 31 (16 positions) of
* original buffer. */
subbuf = ccl_buffer_new_from_region(
buf, 0, siz_subbuf, siz_subbuf, &err);
g_assert_no_error(err);
/* Get data in sub-buffer to a new host buffer. */
evt = ccl_buffer_enqueue_read(
subbuf, cq, CL_FALSE, 0, siz_subbuf, hsubbuf, NULL, &err);
g_assert_no_error(err);
/* Wait for read to be complete. */
ccl_event_wait(ccl_ewl(&ewl, evt, NULL), &err);
g_assert_no_error(err);
/* Check that expected values were successfully read. */
for (cl_uint i = 0; i < siz_subbuf / sizeof(cl_ulong); ++i)
g_assert_cmpuint(
hsubbuf[i], ==, hbuf[i + siz_subbuf / sizeof(cl_ulong)]);
/* Destroy stuff. */
ccl_buffer_destroy(buf);
ccl_buffer_destroy(subbuf);
ccl_queue_destroy(cq);
ccl_context_destroy(ctx);
g_slice_free1(siz_buf, hbuf);
g_slice_free1(siz_subbuf, hsubbuf);
/* 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;
}