/**
* @internal
*
* @brief Tests creation, getting info from and destruction of
* buffer wrapper objects.
* */
static void create_info_destroy_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLBuffer * b = NULL;
CCLErr * err = NULL;
size_t buf_size = sizeof(cl_uint) * CCL_TEST_BUFFER_SIZE;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create regular buffer. */
b = ccl_buffer_new(ctx, CL_MEM_READ_WRITE, buf_size, NULL, &err);
g_assert_no_error(err);
/* Get some info and check if the return value is as expected. */
cl_mem_object_type mot;
mot = ccl_memobj_get_info_scalar(
b, CL_MEM_TYPE, cl_mem_object_type, &err);
g_assert_no_error(err);
g_assert_cmphex(mot, ==, CL_MEM_OBJECT_BUFFER);
cl_mem_flags flags;
flags = ccl_memobj_get_info_scalar(
b, CL_MEM_FLAGS, cl_mem_flags, &err);
g_assert_no_error(err);
g_assert_cmphex(flags, ==, CL_MEM_READ_WRITE);
size_t mem_size;
mem_size = ccl_memobj_get_info_scalar(b, CL_MEM_SIZE, size_t, &err);
g_assert_no_error(err);
g_assert_cmpuint(mem_size, ==, buf_size);
void * host_ptr = NULL;
host_ptr = ccl_memobj_get_info_scalar(
b, CL_MEM_HOST_PTR, void*, &err);
g_assert((err == NULL) || (err->code == CCL_ERROR_INFO_UNAVAILABLE_OCL));
g_assert_cmphex(GPOINTER_TO_UINT(host_ptr), ==,
GPOINTER_TO_UINT(NULL));
g_clear_error(&err);
cl_context context;
context = ccl_memobj_get_info_scalar(
b, CL_MEM_CONTEXT, cl_context, &err);
g_assert_no_error(err);
g_assert_cmphex(GPOINTER_TO_UINT(context), ==,
GPOINTER_TO_UINT(ccl_context_unwrap(ctx)));
/* Destroy stuff. */
ccl_buffer_destroy(b);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* @internal
*
* @brief Tests map/unmap operations in buffer objects.
* */
static void map_unmap_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLDevice * d = NULL;
CCLBuffer * b = NULL;
CCLQueue * q;
cl_uint h_in[CCL_TEST_BUFFER_SIZE];
cl_uint * h_out;
size_t buf_size = sizeof(cl_uint) * CCL_TEST_BUFFER_SIZE;
CCLErr * err = NULL;
/* Create a host array, put some stuff in it. */
for (guint i = 0; i < CCL_TEST_BUFFER_SIZE; ++i)
h_in[i] = g_test_rand_int();
/* 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. */
d = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Create a command queue. */
q = ccl_queue_new(ctx, d, 0, &err);
g_assert_no_error(err);
/* Create regular buffer and write data from the host buffer. */
b = ccl_buffer_new(
ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, buf_size, h_in, &err);
g_assert_no_error(err);
/* Map buffer onto host memory. */
h_out = ccl_buffer_enqueue_map(
b, q, CL_TRUE, CL_MAP_READ, 0, buf_size, NULL, NULL, &err);
g_assert_no_error(err);
/* Check data is OK. */
for (guint i = 0; i < CCL_TEST_BUFFER_SIZE; ++i)
g_assert_cmpuint(h_in[i], ==, h_out[i]);
/* Unmap buffer. */
ccl_memobj_enqueue_unmap(
(CCLMemObj *) b, q, h_out, NULL, &err);
g_assert_no_error(err);
/* Free stuff. */
ccl_buffer_destroy(b);
ccl_queue_destroy(q);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* Tests creation (using "full" constructor), getting info from and
* destruction of sampler wrapper objects.
* */
static void create_full_info_destroy_test() {
/* Test variables. */
CCLContext* ctx = NULL;
CCLSampler* s = NULL;
const cl_sampler_properties sampler_properties[] = {
CL_SAMPLER_NORMALIZED_COORDS, CL_FALSE,
CL_SAMPLER_ADDRESSING_MODE, CL_ADDRESS_CLAMP_TO_EDGE,
CL_SAMPLER_FILTER_MODE, CL_FILTER_NEAREST,
0};
GError* err = NULL;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create sampler using "full" constructor. */
s = ccl_sampler_new_full(ctx, sampler_properties, &err);
g_assert_no_error(err);
/* Get some info and check if the return value is as expected. */
cl_addressing_mode am;
am = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_ADDRESSING_MODE, cl_addressing_mode, &err);
g_assert_no_error(err);
g_assert_cmpuint(am, ==, CL_ADDRESS_CLAMP_TO_EDGE);
cl_filter_mode fm;
fm = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_FILTER_MODE, cl_filter_mode, &err);
g_assert_no_error(err);
g_assert_cmpuint(fm, ==, CL_FILTER_NEAREST);
cl_bool nc;
nc = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_NORMALIZED_COORDS, cl_bool, &err);
g_assert_no_error(err);
g_assert_cmpuint(nc, ==, CL_FALSE);
cl_context context;
context = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_CONTEXT, cl_context, &err);
g_assert_no_error(err);
g_assert_cmphex(GPOINTER_TO_UINT(context), ==,
GPOINTER_TO_UINT(ccl_context_unwrap(ctx)));
/* Destroy sampler. */
ccl_sampler_destroy(s);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* @internal
*
* @brief Tests buffer wrapping and unwrapping.
* */
static void wrap_unwrap_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLBuffer * b = NULL;
CCLBuffer * b_aux = NULL;
cl_mem buffer = NULL;
CCLErr * err = NULL;
size_t buf_size = sizeof(cl_uint) * CCL_TEST_BUFFER_SIZE;
cl_int status;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create a buffer using OpenCL functions directly. */
buffer = clCreateBuffer(
ccl_context_unwrap(ctx), CL_MEM_READ_ONLY, buf_size, NULL, &status);
g_assert_cmpint(status, ==, CL_SUCCESS);
/* Wrap buffer. */
b = ccl_buffer_new_wrap(buffer);
/* If we now unwrap the wrapper, we must get the originally created
* buffer. */
g_assert(buffer == ccl_buffer_unwrap(b));
/* If we again wrap the original buffer... */
b_aux = ccl_buffer_new_wrap(buffer);
/* ...we must get the same wrapper... */
g_assert(b == b_aux);
/* ... and the buffer wrapper ref count must be 2. */
g_assert_cmpuint(2, ==, ccl_wrapper_ref_count((CCLWrapper *) b));
/* Unref buffer, twice. */
ccl_buffer_unref(b);
/* Check that buffer ref count is 1. */
g_assert_cmpuint(1, ==, ccl_wrapper_ref_count((CCLWrapper *) b));
/* Destroy stuff. */
ccl_buffer_destroy(b);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* @internal
*
* @brief Tests buffer wrapper class reference counting.
* */
static void ref_unref_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLBuffer * b = NULL;
CCLErr * err = NULL;
size_t buf_size = sizeof(cl_uint) * CCL_TEST_BUFFER_SIZE;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create regular buffer. */
b = ccl_buffer_new(ctx, CL_MEM_READ_WRITE, buf_size, NULL, &err);
g_assert_no_error(err);
/* Increase buffer reference count. */
ccl_memobj_ref(b);
/* Check that buffer ref count is 2. */
g_assert_cmpuint(2, ==, ccl_wrapper_ref_count((CCLWrapper *) b));
/* Increase buffer reference count again, this time using helper
* macro. */
ccl_buffer_ref(b);
/* Check that buffer ref count is 3. */
g_assert_cmpuint(3, ==, ccl_wrapper_ref_count((CCLWrapper *) b));
/* Unref buffer, twice. */
ccl_buffer_unref(b);
ccl_buffer_unref(b);
/* Check that buffer ref count is 1. */
g_assert_cmpuint(1, ==, ccl_wrapper_ref_count((CCLWrapper *) b));
/* Destroy stuff. */
ccl_buffer_unref(b);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* @internal
*
* @brief Test memory object destructor callbacks.
* */
static void destructor_callback_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLBuffer * b = NULL;
CCLErr * err = NULL;
GTimer * timer = NULL;
cl_bool test_var = CL_FALSE;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create a buffer. */
b = ccl_buffer_new(
ctx, CL_MEM_READ_WRITE, 128 * sizeof(cl_uint), NULL, &err);
/* Add destructor callback. */
ccl_memobj_set_destructor_callback(
(CCLMemObj *) b, destructor_callback, &test_var, &err);
g_assert_no_error(err);
/* Destroy buffer. */
ccl_buffer_destroy(b);
/* Destroy context. */
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
/* Wait some more... */
timer = g_timer_new();
while (g_timer_elapsed(timer, NULL) < 2.0);
g_timer_stop(timer);
g_timer_destroy(timer);
/* Confirm that test_var is CL_TRUE. */
g_assert_cmpuint(test_var, ==, CL_TRUE);
}
/**
* Tests sampler wrapper class reference counting.
* */
static void ref_unref_test() {
/* Test variables. */
CCLContext* ctx = NULL;
CCLSampler* s = NULL;
GError* err = NULL;
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Create sampler. */
s = ccl_sampler_new(ctx, CL_TRUE, CL_ADDRESS_CLAMP,
CL_FILTER_NEAREST, &err);
g_assert_no_error(err);
/* Increase sampler reference count. */
ccl_sampler_ref(s);
/* Check that sampler ref count is 2. */
g_assert_cmpuint(2, ==, ccl_wrapper_ref_count((CCLWrapper*) s));
/* Unref sampler. */
ccl_sampler_unref(s);
/* Check that sampler ref count is 1. */
g_assert_cmpuint(1, ==, ccl_wrapper_ref_count((CCLWrapper*) s));
/* Destroy stuff. */
ccl_sampler_unref(s);
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());
}
/**
* @internal
*
* @brief Tests rect buffer operations.
* */
static void rect_read_write_copy_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLDevice * d = NULL;
CCLBuffer * b1 = NULL;
CCLBuffer * b2 = NULL;
CCLQueue * cq;
cl_uchar h1[CCL_TEST_BUFFER_SIZE * CCL_TEST_BUFFER_SIZE];
cl_uchar h2[CCL_TEST_BUFFER_SIZE * CCL_TEST_BUFFER_SIZE];
size_t buf_size = sizeof(cl_uchar) * sizeof(cl_uchar)
* CCL_TEST_BUFFER_SIZE * CCL_TEST_BUFFER_SIZE;
CCLErr * err = NULL;
const size_t origin[] = {0, 0, 0};
const size_t region[] = {CCL_TEST_BUFFER_SIZE * sizeof(cl_uchar),
CCL_TEST_BUFFER_SIZE * sizeof(cl_uchar), 1};
/* Create a "2D" host array, put some stuff in it. */
for (cl_uint i = 0; i < CCL_TEST_BUFFER_SIZE; ++i)
for (cl_uint j = 0; j < CCL_TEST_BUFFER_SIZE; ++j)
h1[i * CCL_TEST_BUFFER_SIZE + j] =
(cl_uchar) (g_test_rand_int() % 0xFF);
/* 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. */
d = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Create a command queue. */
cq = ccl_queue_new(ctx, d, 0, &err);
g_assert_no_error(err);
/* Create device buffers. */
b1 = ccl_buffer_new(ctx, CL_MEM_READ_WRITE, buf_size, NULL, &err);
g_assert_no_error(err);
b2 = ccl_buffer_new(ctx, CL_MEM_READ_WRITE, buf_size, NULL, &err);
g_assert_no_error(err);
/* Write "rect" data to first buffer in device. */
ccl_buffer_enqueue_write_rect(
b1, cq, CL_TRUE, origin, origin, region, 0, 0, 0, 0, h1, NULL, &err);
g_assert_no_error(err);
/* Copy "rect" data from first buffer to second buffer. */
ccl_buffer_enqueue_copy_rect(
b1, b2, cq, origin, origin, region, 0, 0, 0, 0, NULL, &err);
g_assert_no_error(err);
/* Read data "rect" back to host from the second buffer. */
ccl_buffer_enqueue_read_rect(
b2, cq, CL_TRUE, origin, origin, region, 0, 0, 0, 0, h2, NULL, &err);
g_assert_no_error(err);
/* Check data is OK doing a flat comparison. */
for (cl_uint i = 0; i < CCL_TEST_BUFFER_SIZE * CCL_TEST_BUFFER_SIZE; ++i)
g_assert_cmpuint(h1[i], ==, h2[i]);
/* Free stuff. */
ccl_buffer_destroy(b1);
ccl_buffer_destroy(b2);
ccl_queue_destroy(cq);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* @internal
*
* @brief Tests copy operations from one buffer to another.
* */
static void copy_test() {
/* Test variables. */
CCLContext * ctx = NULL;
CCLDevice * d = NULL;
CCLBuffer * b1 = NULL;
CCLBuffer * b2 = NULL;
CCLQueue * q;
cl_long h1[CCL_TEST_BUFFER_SIZE];
cl_long h2[CCL_TEST_BUFFER_SIZE];
size_t buf_size = sizeof(cl_long) * CCL_TEST_BUFFER_SIZE;
CCLErr * err = NULL;
/* Create a host array, put some stuff in it. */
for (guint i = 0; i < CCL_TEST_BUFFER_SIZE; ++i)
h1[i] = g_test_rand_int();
/* 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. */
d = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Create a command queue. */
q = ccl_queue_new(ctx, d, 0, &err);
g_assert_no_error(err);
/* Create regular buffer and write data from the host buffer. */
b1 = ccl_buffer_new(
ctx, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, buf_size, h1, &err);
g_assert_no_error(err);
/* Create another buffer, double the size. */
b2 = ccl_buffer_new(ctx, CL_MEM_READ_WRITE, 2 * buf_size, NULL, &err);
g_assert_no_error(err);
/* Copy data from first buffer to second buffer, using an offset on
* the second buffer. */
ccl_buffer_enqueue_copy(
b1, b2, q, 0, buf_size / 2, buf_size, NULL, &err);
g_assert_no_error(err);
/* Read data back to host from the second buffer. */
ccl_buffer_enqueue_read(
b2, q, CL_TRUE, buf_size / 2, buf_size, h2, NULL, &err);
g_assert_no_error(err);
/* Check data is OK. */
for (guint i = 0; i < CCL_TEST_BUFFER_SIZE; ++i)
g_assert_cmpuint(h1[i], ==, h2[i]);
/* Free stuff. */
ccl_buffer_destroy(b1);
ccl_buffer_destroy(b2);
ccl_queue_destroy(q);
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* 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());
}
/**
* 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 {
/**
* Tests creation (using "simple" constructor), getting info from and
* destruction of sampler wrapper objects.
* */
static void create_info_destroy_test() {
/* Test variables. */
CCLContext* ctx = NULL;
CCLSampler* s = NULL;
cl_sampler sampler = NULL;
GError* err = NULL;
cl_int ocl_status;
const cl_sampler_properties sampler_properties[] = {
CL_SAMPLER_NORMALIZED_COORDS, CL_TRUE,
CL_SAMPLER_ADDRESSING_MODE, CL_ADDRESS_NONE,
CL_SAMPLER_FILTER_MODE, CL_FILTER_NEAREST,
0};
/* Get the test context with the pre-defined device. */
ctx = ccl_test_context_new(&err);
g_assert_no_error(err);
/* Test three ways to create a sampler. */
for (cl_uint i = 0; i < 3; ++i) {
/* Create sampler wrapper. */
switch (i) {
case 0:
/* Create sampler using "simple" constructor. */
s = ccl_sampler_new(ctx, CL_TRUE, CL_ADDRESS_NONE,
CL_FILTER_NEAREST, &err);
g_assert_no_error(err);
break;
case 1:
/* Using the "full" constructor. */
s = ccl_sampler_new_full(ctx, sampler_properties, &err);
g_assert_no_error(err);
break;
case 2:
/* Using the "wrap" constructor. */
CCL_BEGIN_IGNORE_DEPRECATIONS
sampler = clCreateSampler(ccl_context_unwrap(ctx),
CL_TRUE, CL_ADDRESS_NONE, CL_FILTER_NEAREST,
&ocl_status);
g_assert_cmpint(ocl_status, ==, CL_SUCCESS);
CCL_END_IGNORE_DEPRECATIONS
s = ccl_sampler_new_wrap(sampler);
g_assert_cmphex(GPOINTER_TO_UINT(sampler), ==,
GPOINTER_TO_UINT(ccl_sampler_unwrap(s)));
break;
}
/* Get some info and check if the return value is as expected. */
cl_addressing_mode am;
am = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_ADDRESSING_MODE, cl_addressing_mode, &err);
g_assert_no_error(err);
g_assert_cmpuint(am, ==, CL_ADDRESS_NONE);
cl_filter_mode fm;
fm = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_FILTER_MODE, cl_filter_mode, &err);
g_assert_no_error(err);
g_assert_cmpuint(fm, ==, CL_FILTER_NEAREST);
cl_bool nc;
nc = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_NORMALIZED_COORDS, cl_bool, &err);
g_assert_no_error(err);
g_assert_cmpuint(nc, ==, CL_TRUE);
cl_context context;
context = ccl_sampler_get_info_scalar(
s, CL_SAMPLER_CONTEXT, cl_context, &err);
g_assert_no_error(err);
g_assert_cmphex(GPOINTER_TO_UINT(context), ==,
GPOINTER_TO_UINT(ccl_context_unwrap(ctx)));
/* Destroy sampler. */
ccl_sampler_destroy(s);
}
/* Destroy context. */
ccl_context_destroy(ctx);
/* Confirm that memory allocated by wrappers has been properly
* freed. */
g_assert(ccl_wrapper_memcheck());
}
/**
* Tests creation, getting info from and destruction of
* program wrapper objects.
* */
static void create_info_destroy_test() {
/* Test variables. */
CCLContext* ctx = NULL;
CCLProgram* prg = NULL;
CCLProgram* prg2 = NULL;
CCLKernel* krnl = NULL;
CCLWrapperInfo* info = NULL;
CCLDevice* d = NULL;
CCLQueue* cq = NULL;
size_t gws;
size_t lws;
cl_uint a_h[CCL_TEST_PROGRAM_BUF_SIZE];
cl_uint b_h[CCL_TEST_PROGRAM_BUF_SIZE];
cl_uint c_h[CCL_TEST_PROGRAM_BUF_SIZE];
cl_uint d_h ;
CCLBuffer* a_w;
CCLBuffer* b_w;
CCLBuffer* c_w;
CCLEvent* evt_w1;
CCLEvent* evt_w2;
CCLEvent* evt_kr;
CCLEvent* evt_r1;
CCLEventWaitList ewl = NULL;
GError* err = NULL;
gchar* tmp_dir_name;
gchar* tmp_file_prefix;
/* Get a temp. dir. */
tmp_dir_name = g_dir_make_tmp("test_program_XXXXXX", &err);
g_assert_no_error(err);
/* Get a temp file prefix. */
tmp_file_prefix = g_strdup_printf("%s%c%s",
tmp_dir_name, G_DIR_SEPARATOR, CCL_TEST_PROGRAM_SUM_FILENAME);
/* Create a temporary kernel file. */
g_file_set_contents(
tmp_file_prefix, CCL_TEST_PROGRAM_SUM_CONTENT, -1, &err);
g_assert_no_error(err);
/* 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 kernel file. */
prg = ccl_program_new_from_source_file(
ctx, tmp_file_prefix, &err);
g_assert_no_error(err);
ccl_program_destroy(prg);
const char* file_pref = (const char*) tmp_file_prefix;
prg = ccl_program_new_from_source_files(ctx, 1, &file_pref, &err);
g_assert_no_error(err);
g_free(tmp_file_prefix);
/* Get some program info, compare it with expected info. */
info = ccl_program_get_info(prg, CL_PROGRAM_CONTEXT, &err);
g_assert_no_error(err);
g_assert(*((cl_context*) info->value) == ccl_context_unwrap(ctx));
/* Get number of devices from program info, check that this is the
* same value as the number of devices in context. */
info = ccl_program_get_info(prg, CL_PROGRAM_NUM_DEVICES, &err);
g_assert_no_error(err);
g_assert_cmpuint(*((cl_uint*) info->value),
==, ccl_context_get_num_devices(ctx, &err));
g_assert_no_error(err);
/* Get program source from program info, check that it is the
* same as the passed source. */
info = ccl_program_get_info(prg, CL_PROGRAM_SOURCE, &err);
g_assert_no_error(err);
g_assert_cmpstr((char*) info->value,
==, CCL_TEST_PROGRAM_SUM_CONTENT);
/* Get first device in context (and in program). */
d = ccl_context_get_device(ctx, 0, &err);
g_assert_no_error(err);
/* Check that no build was performed yet. */
info = ccl_program_get_build_info(
prg, d, CL_PROGRAM_BUILD_STATUS, &err);
g_assert_no_error(err);
g_assert_cmpint(*((cl_build_status*) info->value), ==, CL_BUILD_NONE);
/* **** BUILD PROGRAM **** */
ccl_program_build(prg, NULL, &err);
g_assert_no_error(err);
/* Get some program build info, compare it with expected values. */
info = ccl_program_get_build_info(
prg, d, CL_PROGRAM_BUILD_STATUS, &err);
g_assert_no_error(err);
g_assert((*((cl_build_status*) info->value) == CL_BUILD_SUCCESS)
|| (*((cl_build_status*) info->value) == CL_BUILD_IN_PROGRESS));
/* Get the build log, check that no error occurs. */
info = ccl_program_get_build_info(prg, d, CL_PROGRAM_BUILD_LOG, &err);
g_assert_no_error(err);
/* Get kernel wrapper object. */
krnl = ccl_program_get_kernel(
prg, CCL_TEST_PROGRAM_SUM, &err);
g_assert_no_error(err);
/* Get some kernel info, compare it with expected info. */
/* Get kernel function name from kernel info, compare it with the
* expected value. */
info = ccl_kernel_get_info(krnl, CL_KERNEL_FUNCTION_NAME, &err);
g_assert_no_error(err);
g_assert_cmpstr(
(gchar*) info->value, ==, CCL_TEST_PROGRAM_SUM);
/* Check if the kernel context is the same as the initial context
* and the program context. */
info = ccl_kernel_get_info(krnl, CL_KERNEL_CONTEXT, &err);
g_assert_no_error(err);
g_assert(*((cl_context*) info->value) == ccl_context_unwrap(ctx));
info = ccl_kernel_get_info(krnl, CL_KERNEL_PROGRAM, &err);
g_assert_no_error(err);
g_assert(*((cl_program*) info->value) == ccl_program_unwrap(prg));
#ifndef OPENCL_STUB
#ifdef CL_VERSION_1_2
cl_kernel_arg_address_qualifier kaaq;
char* kernel_arg_type_name;
char* kernel_arg_name;
cl_uint ocl_ver;
/* Get OpenCL version of program's underlying platform. */
ocl_ver = ccl_program_get_opencl_version(prg, &err);
g_assert_no_error(err);
/* If platform supports kernel argument queries, get kernel argument
* information and compare it with expected info. */
if (ocl_ver >= 120) {
/* First kernel argument. */
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 {