[Piglit] [PATCH v6] cl: Add a test for the predefined macros
Serge Martin
edb+piglit at sigluy.net
Mon Oct 17 19:14:30 UTC 2016
Le 2016-10-17 16:20, Jan Vesely a écrit :
> On Sat, 2016-10-15 at 14:43 +0200, Niels Ole Salscheider wrote:
>> 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_ole at salscheider-online.de>
>> Reviewed-by: Jan Vesely <jan.vesely at 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_ole at 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;
>
> I think it'd be better to let this be the default PIGLIT_SKIP. I can
> fix that locally before pushing if you concur.
>
either way, you've got my R-B
Serge
> thanks for your patience,
> Jan
>
>> +#ifdef CL_VERSION_1_1
>> + if (!version_from_string(opencl_c_version_str_host,
>> + &opencl_c_version_host)) {
>> + printf("Could not determine host OpenCL C version.\n");
>> + piglit_merge_result(&result, PIGLIT_FAIL);
>> + } else {
>> + result_opencl_c_version = (opencl_c_version ==
>> opencl_c_version_host) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + }
>> +#endif
>> + }
>> + }
>> +
>> + if (cl_version_defined[0]) {
>> + result_cl_version[0] = (cl_version[0] == 100) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + }
>> + if (cl_version_defined[1]) {
>> + result_cl_version[1] = (cl_version[1] == 110) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + }
>> + if (cl_version_defined[2]) {
>> + result_cl_version[2] = (cl_version[2] == 120) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + }
>> + if (cl_version_defined[3]) {
>> + result_cl_version[3] = (cl_version[3] == 200) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + }
>> +
>> + result_endian_little_defined = (*endian_little_host ==
>> endian_little_defined) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + if (endian_little_defined) {
>> + result_endian_little = (endian_little == 1) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + } else if (!*endian_little_host) {
>> + result_endian_little = PIGLIT_PASS;
>> + }
>> +
>> + result_image_support_defined = (*image_support_host ==
>> image_support_defined) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + if (image_support_defined) {
>> + result_image_support = (image_support == 1) ?
>> + PIGLIT_PASS : PIGLIT_FAIL;
>> + } else if (!*image_support_host) {
>> + result_image_support = PIGLIT_PASS;
>> + }
>> +
>> + /* report the results */
>> + piglit_report_subtest_result(result_file_defined,
>> + "__FILE__ must be defined");
>> + piglit_merge_result(&result, result_file_defined);
>> + piglit_report_subtest_result(result_line_defined,
>> + "__LINE__ must be defined");
>> + piglit_merge_result(&result, result_line_defined);
>> + piglit_report_subtest_result(result_opencl_version_defined,
>> + "__OPENCL_VERSION__ must be defined");
>> + piglit_merge_result(&result, result_opencl_version_defined);
>> + piglit_report_subtest_result(result_opencl_version,
>> + "__OPENCL_VERSION__ must be consistent
>> with host");
>> + piglit_merge_result(&result, result_opencl_version);
>> + piglit_report_subtest_result(result_opencl_c_version_defined,
>> + "__OPENCL_C_VERSION__ must be defined
>> for OpenCL 1.2 and later");
>> + piglit_merge_result(&result, result_opencl_c_version_defined);
>> + piglit_report_subtest_result(result_opencl_c_version,
>> + "__OPENCL_C_VERSION__ must be
>> consistent with host (if defined)");
>> + piglit_merge_result(&result, result_opencl_c_version);
>> + piglit_report_subtest_result(result_cl_version_defined[0],
>> + "CL_VERSION_1_0 must be defined for
>> OpenCL 1.1 and later");
>> + piglit_merge_result(&result, result_cl_version_defined[0]);
>> + piglit_report_subtest_result(result_cl_version_defined[1],
>> + "CL_VERSION_1_1 must be defined for
>> OpenCL 1.1 and later");
>> + piglit_merge_result(&result, result_cl_version_defined[1]);
>> + piglit_report_subtest_result(result_cl_version_defined[2],
>> + "CL_VERSION_1_2 must be defined for
>> OpenCL 1.2 and later");
>> + piglit_merge_result(&result, result_cl_version_defined[2]);
>> + piglit_report_subtest_result(result_cl_version_defined[3],
>> + "CL_VERSION_2_0 must be defined for
>> OpenCL 2.0 and later");
>> + piglit_merge_result(&result, result_cl_version_defined[3]);
>> + piglit_report_subtest_result(result_cl_version[0],
>> + "CL_VERSION_1_0 must be 100 if
>> defined");
>> + piglit_merge_result(&result, result_cl_version[0]);
>> + piglit_report_subtest_result(result_cl_version[1],
>> + "CL_VERSION_1_1 must be 110 if
>> defined");
>> + piglit_merge_result(&result, result_cl_version[1]);
>> + piglit_report_subtest_result(result_cl_version[2],
>> + "CL_VERSION_1_2 must be 120 if
>> defined");
>> + piglit_merge_result(&result, result_cl_version[2]);
>> + piglit_report_subtest_result(result_cl_version[3],
>> + "CL_VERSION_2_0 must be 200 if
>> defined");
>> + piglit_merge_result(&result, result_cl_version[3]);
>> + piglit_report_subtest_result(result_endian_little_defined,
>> + "__ENDIAN_LITTLE__ must be consistent
>> with host");
>> + piglit_merge_result(&result, result_endian_little_defined);
>> + piglit_report_subtest_result(result_endian_little,
>> + "__ENDIAN_LITTLE__ must be 1 if
>> defined");
>> + piglit_merge_result(&result, result_endian_little);
>> + piglit_report_subtest_result(result_image_support_defined,
>> + "__IMAGE_SUPPORT__ must be consistent
>> with host");
>> + piglit_merge_result(&result, result_image_support_defined);
>> + piglit_report_subtest_result(result_image_support,
>> + "__IMAGE_SUPPORT__ must be 1 if
>> defined");
>> + piglit_merge_result(&result, result_image_support);
>> +
>> + /* free cl resources */
>> + clReleaseMemObject(file_defined_mem);
>> + clReleaseMemObject(line_defined_mem);
>> + clReleaseMemObject(opencl_version_defined_mem);
>> + clReleaseMemObject(opencl_version_mem);
>> + clReleaseMemObject(opencl_c_version_defined_mem);
>> + clReleaseMemObject(opencl_c_version_mem);
>> + clReleaseMemObject(cl_version_defined_mem);
>> + clReleaseMemObject(cl_version_mem);
>> + clReleaseMemObject(endian_little_defined_mem);
>> + clReleaseMemObject(endian_little_mem);
>> + clReleaseMemObject(image_support_defined_mem);
>> + clReleaseMemObject(image_support_mem);
>> +
>> + /* free host resources */
>> + free(opencl_version_str_host);
>> + free(opencl_c_version_str_host);
>> + free(endian_little_host);
>> + free(image_support_host);
>> +
>> + return result;
>> +}
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/piglit
More information about the Piglit
mailing list