v6: Fix OpenCL C version test if test is compiled against OpenCL 1.0
v5: Use sscanf, fix CL_DEVICE_OPENCL_C_VERSION include guard, fix
logic
v4: Test against env->version instead of opencl_version and never
report PIGLIT_SKIP for the values of IMAGE_SUPPORT and
ENDIAN_LITTLE
v3: Fix alignment and typos
v2: Check the values of the defines and add more checks
Signed-off-by: Niels Ole Salscheider <niels_...@salscheider-online.de>
Reviewed-by: Jan Vesely <jan.ves...@rutgers.edu>
---
tests/cl.py | 1 +
tests/cl/program/CMakeLists.cl.txt | 1 +
tests/cl/program/predefined-macros.c | 463
+++++++++++++++++++++++++++++++++++
3 files changed, 465 insertions(+)
create mode 100644 tests/cl/program/predefined-macros.c
diff --git a/tests/cl.py b/tests/cl.py
index 353ab05..73fba0d 100644
--- a/tests/cl.py
+++ b/tests/cl.py
@@ -96,6 +96,7 @@ with profile.group_manager(PiglitCLTest, 'program')
as g:
g(['cl-program-max-work-item-sizes'],
'Run kernel with max work item sizes')
g(['cl-program-bitcoin-phatk'], 'Bitcoin: phatk kernel')
+ g(['cl-program-predefined-macros'], 'Check predefined
preprocessor macros')
with profile.group_manager(PiglitCLTest, 'interop') as g:
g(['cl-interop-egl_khr_cl_event2'], 'EGL_KHR_cl_event2')
diff --git a/tests/cl/program/CMakeLists.cl.txt
b/tests/cl/program/CMakeLists.cl.txt
index 82dc675..c8d7307 100644
--- a/tests/cl/program/CMakeLists.cl.txt
+++ b/tests/cl/program/CMakeLists.cl.txt
@@ -1,3 +1,4 @@
piglit_cl_add_program_test (tester program-tester.c)
piglit_cl_add_program_test (max-work-item-sizes
max-work-item-sizes.c)
piglit_cl_add_program_test (bitcoin-phatk bitcoin-phatk.c)
+piglit_cl_add_program_test (predefined-macros predefined-macros.c)
diff --git a/tests/cl/program/predefined-macros.c
b/tests/cl/program/predefined-macros.c
new file mode 100644
index 0000000..f94812c
--- /dev/null
+++ b/tests/cl/program/predefined-macros.c
@@ -0,0 +1,463 @@
+/*
+ * Copyright © 2016 Niels Ole Salscheider
<niels_...@salscheider-online.de>
+ *
+ * Permission is hereby granted, free of charge, to any person
obtaining a
+ * copy of this software and associated documentation files (the
"Software"),
+ * to deal in the Software without restriction, including without
limitation
+ * the rights to use, copy, modify, merge, publish, distribute,
sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom
the
+ * Software is furnished to do so, subject to the following
conditions:
+ *
+ * The above copyright notice and this permission notice (including
the next
+ * paragraph) shall be included in all copies or substantial portions
of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "piglit-framework-cl-program.h"
+
+char *program_source =
+"kernel void test(global int* file_defined, global int* line_defined,
\n"
+" global int* opencl_version_defined, global int*
opencl_version, \n"
+" global int* opencl_c_version_defined, global int*
opencl_c_version, \n"
+" global int* cl_version_defined, global int*
cl_version, \n"
+" global int* endian_little_defined, global int*
endian_little, \n"
+" global int* image_support_defined, global int*
image_support) \n"
+"{ \n"
+"#ifdef __FILE__ \n"
+" *file_defined = 1; \n"
+"#else \n"
+" *file_defined = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef __LINE__ \n"
+" *line_defined = 1; \n"
+"#else \n"
+" *line_defined = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef __OPENCL_VERSION__ \n"
+" *opencl_version_defined = 1; \n"
+" *opencl_version = __OPENCL_VERSION__; \n"
+"#else \n"
+" *opencl_version_defined = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef __OPENCL_C_VERSION__ \n"
+" *opencl_c_version_defined = 1; \n"
+" *opencl_c_version = __OPENCL_C_VERSION__; \n"
+"#else \n"
+" *opencl_c_version_defined = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef CL_VERSION_1_0 \n"
+" cl_version_defined[0] = 1; \n"
+" cl_version[0] = CL_VERSION_1_0; \n"
+"#else \n"
+" cl_version_defined[0] = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef CL_VERSION_1_1 \n"
+" cl_version_defined[1] = 1; \n"
+" cl_version[1] = CL_VERSION_1_1; \n"
+"#else \n"
+" cl_version_defined[1] = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef CL_VERSION_1_2 \n"
+" cl_version_defined[2] = 1; \n"
+" cl_version[2] = CL_VERSION_1_2; \n"
+"#else \n"
+" cl_version_defined[2] = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef CL_VERSION_2_0 \n"
+" cl_version_defined[3] = 1; \n"
+" cl_version[3] = CL_VERSION_2_0; \n"
+"#else \n"
+" cl_version_defined[3] = 0; \n"
+"#endif \n"
+"\n"
+"#ifdef __ENDIAN_LITTLE__ \n"
+" *endian_little_defined = 1; \n"
+" *endian_little = __ENDIAN_LITTLE__; \n"
+"#else \n"
+" *endian_little_defined = 0; \n"
+"#endif \n"
+"#ifdef __IMAGE_SUPPORT__ \n"
+" *image_support_defined = 1; \n"
+" *image_support = __IMAGE_SUPPORT__; \n"
+"#else \n"
+" *image_support_defined = 0; \n"
+"#endif \n"
+"}";
+
+PIGLIT_CL_PROGRAM_TEST_CONFIG_BEGIN
+
+ config.name = "Preprocessor Macros";
+ config.clc_version_min = 10;
+ config.run_per_device = true;
+
+ config.program_source = program_source;
+ config.kernel_name = "test";
+
+PIGLIT_CL_PROGRAM_TEST_CONFIG_END
+
+int
+version_from_string(char* string, int *version)
+{
+ int major, minor;
+ if (!string || sscanf(string, "%*s %d.%d %*s", &major, &minor) != 2)
{
+ return 0;
+ }
+ *version = 100 * major + 10 * minor;
+ return 1;
+}
+
+#define NUM_CL_VERSION 4
+
+enum piglit_result
+piglit_cl_test(const int argc,
+ const char** argv,
+ const struct piglit_cl_program_test_config* config,
+ const struct piglit_cl_program_test_env* env)
+{
+ enum piglit_result result = PIGLIT_SKIP;
+ enum piglit_result result_file_defined = PIGLIT_SKIP;
+ enum piglit_result result_line_defined = PIGLIT_SKIP;
+ enum piglit_result result_opencl_version_defined = PIGLIT_SKIP;
+ enum piglit_result result_opencl_version = PIGLIT_SKIP;
+ enum piglit_result result_opencl_c_version_defined = PIGLIT_SKIP;
+ enum piglit_result result_opencl_c_version = PIGLIT_SKIP;
+ enum piglit_result result_cl_version_defined[NUM_CL_VERSION];
+ enum piglit_result result_cl_version[NUM_CL_VERSION];
+ enum piglit_result result_endian_little_defined = PIGLIT_SKIP;
+ enum piglit_result result_endian_little = PIGLIT_SKIP;
+ enum piglit_result result_image_support_defined = PIGLIT_SKIP;
+ enum piglit_result result_image_support = PIGLIT_SKIP;
+
+ size_t work_size = 1;
+
+ cl_int file_defined;
+ cl_mem file_defined_mem = NULL;
+ cl_int line_defined;
+ cl_mem line_defined_mem = NULL;
+ cl_int opencl_version_defined;
+ cl_mem opencl_version_defined_mem = NULL;
+ cl_int opencl_version;
+ cl_mem opencl_version_mem = NULL;
+ cl_int opencl_c_version_defined;
+ cl_mem opencl_c_version_defined_mem = NULL;
+ cl_int opencl_c_version;
+ cl_mem opencl_c_version_mem = NULL;
+ cl_int cl_version_defined[NUM_CL_VERSION];
+ cl_mem cl_version_defined_mem = NULL;
+ cl_int cl_version[NUM_CL_VERSION];
+ cl_mem cl_version_mem = NULL;
+ cl_int endian_little_defined;
+ cl_mem endian_little_defined_mem = NULL;
+ cl_int endian_little;
+ cl_mem endian_little_mem = NULL;
+ cl_int image_support_defined;
+ cl_mem image_support_defined_mem = NULL;
+ cl_int image_support;
+ cl_mem image_support_mem = NULL;
+
+ char* opencl_version_str_host = NULL;
+ char* opencl_c_version_str_host = NULL;
+ cl_bool* endian_little_host = NULL;
+ cl_bool* image_support_host = NULL;
+
+ int i;
+ for (i = 0; i < NUM_CL_VERSION; ++i) {
+ result_cl_version_defined[i] = PIGLIT_SKIP;
+ result_cl_version[i] = PIGLIT_SKIP;
+ }
+
+ opencl_version_str_host = piglit_cl_get_device_info(env->device_id,
+
CL_DEVICE_VERSION);
+#ifdef CL_VERSION_1_1
+ opencl_c_version_str_host =
piglit_cl_get_device_info(env->device_id,
+
CL_DEVICE_OPENCL_C_VERSION);
+#endif
+ endian_little_host = piglit_cl_get_device_info(env->device_id,
+
CL_DEVICE_ENDIAN_LITTLE);
+ image_support_host = piglit_cl_get_device_info(env->device_id,
+
CL_DEVICE_IMAGE_SUPPORT);
+
+ /* create buffers for the results */
+ file_defined_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ line_defined_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ opencl_version_defined_mem = piglit_cl_create_buffer(env->context,
+
CL_MEM_WRITE_ONLY,
+
sizeof(cl_int));
+ opencl_version_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ opencl_c_version_defined_mem = piglit_cl_create_buffer(env->context,
+
CL_MEM_WRITE_ONLY,
+
sizeof(cl_int));
+ opencl_c_version_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ cl_version_defined_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ NUM_CL_VERSION *
sizeof(cl_int));
+ cl_version_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ NUM_CL_VERSION *
sizeof(cl_int));
+ endian_little_defined_mem = piglit_cl_create_buffer(env->context,
+
CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ endian_little_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ image_support_defined_mem = piglit_cl_create_buffer(env->context,
+
CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+ image_support_mem = piglit_cl_create_buffer(env->context,
+ CL_MEM_WRITE_ONLY,
+ sizeof(cl_int));
+
+ /* set kernel args and run the kernel */
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 0, &file_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 1, &line_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 2,
+ &opencl_version_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 3,
&opencl_version_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 4,
+ &opencl_c_version_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 5,
&opencl_c_version_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 6,
+ &cl_version_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 7, &cl_version_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 8,
+ &endian_little_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 9, &endian_little_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 10,
+ &image_support_defined_mem);
+ piglit_cl_set_kernel_buffer_arg(env->kernel, 11,
&image_support_mem);
+ piglit_cl_execute_ND_range_kernel(env->context->command_queues[0],
+ env->kernel,
+ 1,
+ NULL,
+ &work_size,
+ &work_size);
+
+ /* read the buffers */
+ piglit_cl_read_buffer(env->context->command_queues[0],
file_defined_mem,
+ 0, sizeof(cl_int), &file_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
line_defined_mem,
+ 0, sizeof(cl_int), &line_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ opencl_version_defined_mem, 0, sizeof(cl_int),
+ &opencl_version_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ opencl_version_mem, 0, sizeof(cl_int),
+ &opencl_version);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ opencl_c_version_defined_mem, 0,
sizeof(cl_int),
+ &opencl_c_version_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ opencl_c_version_mem, 0, sizeof(cl_int),
+ &opencl_c_version);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ cl_version_defined_mem, 0,
+ NUM_CL_VERSION * sizeof(cl_int),
+ cl_version_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ cl_version_mem, 0,
+ NUM_CL_VERSION * sizeof(cl_int),
+ cl_version);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ endian_little_defined_mem, 0, sizeof(cl_int),
+ &endian_little_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ endian_little_mem, 0, sizeof(cl_int),
+ &endian_little);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ image_support_defined_mem, 0, sizeof(cl_int),
+ &image_support_defined);
+ piglit_cl_read_buffer(env->context->command_queues[0],
+ image_support_mem, 0, sizeof(cl_int),
+ &image_support);
+
+ /* check the values */
+ result_file_defined = (file_defined == 1) ? PIGLIT_PASS :
PIGLIT_FAIL;
+ result_line_defined = (line_defined == 1) ? PIGLIT_PASS :
PIGLIT_FAIL;
+
+ if (!opencl_version_defined) {
+ result_opencl_version_defined = PIGLIT_FAIL;
+ } else {
+ int opencl_version_host;
+ result_opencl_version_defined = PIGLIT_PASS;
+ if (!version_from_string(opencl_version_str_host,
+ &opencl_version_host)) {
+ printf("Could not determine host OpenCL version.\n");
+ piglit_merge_result(&result, PIGLIT_FAIL);
+ } else {
+ result_opencl_version = (opencl_version ==
opencl_version_host) ?
+ PIGLIT_PASS : PIGLIT_FAIL;
+ }
+ }
+
+ if (env->version >= 11) {
+ result_cl_version_defined[0] = cl_version_defined[0] ?
+ PIGLIT_PASS : PIGLIT_FAIL;
+ result_cl_version_defined[1] = cl_version_defined[1] ?
+ PIGLIT_PASS : PIGLIT_FAIL;
+ }
+ if (env->version >= 12) {
+ result_cl_version_defined[2] = cl_version_defined[2] ?
+ PIGLIT_PASS : PIGLIT_FAIL;
+ }
+ if (env->version >= 20) {
+ result_cl_version_defined[3] = cl_version_defined[3] ?
+ PIGLIT_PASS : PIGLIT_FAIL;
+ }
+
+ if (env->version >= 12) {
+ if (!opencl_c_version_defined) {
+ result_opencl_c_version_defined = PIGLIT_FAIL;
+ } else {
+#ifdef CL_VERSION_1_1
+ int opencl_c_version_host;
+#endif
+ result_opencl_c_version_defined = PIGLIT_PASS;
