Synchronise with Khronos-private Gitlab branch

The maintenance of the conformance tests is moving to Github.

This commit contains all the changes that have been done in
Gitlab since the first public release of the conformance tests.

Signed-off-by: Kevin Petit kevin.petit@arm.com

test_conformance/compatibility/test_conformance/api/CMakeLists.txt

@@ -20,6 +20,7 @@ set(${MODULE_NAME}_SOURCES
          test_mem_object_info.cpp
          test_null_buffer_arg.c
          test_kernel_arg_info.c
+         test_queue_properties.cpp
          ../../test_common/harness/errorHelpers.c
          ../../test_common/harness/threadTesting.c
          ../../test_common/harness/testHarness.c

test_conformance/compatibility/test_conformance/api/main.c

@@ -113,6 +113,7 @@ basefn    basefn_list[] = {
     test_get_image1d_info,
     test_get_image1d_array_info,
     test_get_image2d_array_info,
+    test_queue_properties,
 };
 
 
@@ -200,6 +201,7 @@ const char    *basefn_names[] = {
     "get_image1d_info",
     "get_image1d_array_info",
     "get_image2d_array_info",
+    "queue_properties",
 };
 
 ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));

test_conformance/compatibility/test_conformance/api/procs.h

@@ -105,4 +105,5 @@ extern int      test_get_image1d_info( cl_device_id deviceID, cl_context context
 extern int      test_get_image1d_array_info( cl_device_id deviceID, cl_context context, cl_command_queue ignoreQueue, int num_elements );
 extern int      test_get_image2d_array_info( cl_device_id deviceID, cl_context context, cl_command_queue ignoreQueue, int num_elements );
 extern int      test_get_kernel_arg_info( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements );
+extern int      test_queue_properties( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements );
 

test_conformance/compatibility/test_conformance/api/test_queue_properties.cpp

@@ -0,0 +1,174 @@
+//
+// Copyright (c) 2018 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+
+#include "testBase.h"
+#include "../../test_common/harness/typeWrappers.h"
+#include "../../test_common/harness/conversions.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+using namespace std;
+/*
+The test against cl_khr_create_command_queue extension. It validates if devices with Opencl 1.X can use clCreateCommandQueueWithPropertiesKHR function.
+Based on device capabilities test will create queue with NULL properties, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE property and
+CL_QUEUE_PROFILING_ENABLE property. Finally simple kernel will be executed on such queue.
+*/
+
+const char *queue_test_kernel[] = {
+"__kernel void vec_cpy(__global int *src, __global int *dst)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    dst[tid] = src[tid];\n"
+"\n"
+"}\n" };
+
+int enqueue_kernel(cl_context context, const cl_queue_properties_khr *queue_prop_def, cl_device_id deviceID, clKernelWrapper& kernel, size_t num_elements)
+{
+    clMemWrapper streams[2];
+    int error;
+    std::vector<int> buf(num_elements);
+    clCreateCommandQueueWithPropertiesKHR_fn clCreateCommandQueueWithPropertiesKHR = NULL;
+    cl_platform_id platform;
+    clEventWrapper event;
+
+    error = clGetDeviceInfo(deviceID, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &platform, NULL);
+    test_error(error, "clGetDeviceInfo for CL_DEVICE_PLATFORM failed");
+
+    clCreateCommandQueueWithPropertiesKHR = (clCreateCommandQueueWithPropertiesKHR_fn) clGetExtensionFunctionAddressForPlatform(platform, "clCreateCommandQueueWithPropertiesKHR");
+    if (clCreateCommandQueueWithPropertiesKHR == NULL)
+    {
+        log_error("ERROR: clGetExtensionFunctionAddressForPlatform failed\n");
+        return -1;
+    }
+
+    clCommandQueueWrapper queue = clCreateCommandQueueWithPropertiesKHR(context, deviceID, queue_prop_def, &error);
+    test_error(error, "clCreateCommandQueueWithPropertiesKHR failed");
+
+    for (int i = 0; i < num_elements; ++i)
+    {
+        buf[i] = i;
+    }
+
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, num_elements * sizeof(int), buf.data(), &error);
+    test_error( error, "clCreateBuffer failed." );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, num_elements * sizeof(int), NULL, &error);
+    test_error( error, "clCreateBuffer failed." );
+
+    error = clSetKernelArg(kernel, 0, sizeof(streams[0]), &streams[0]);
+    test_error( error, "clSetKernelArg failed." );
+
+    error = clSetKernelArg(kernel, 1, sizeof(streams[1]), &streams[1]);
+    test_error( error, "clSetKernelArg failed." );
+
+    error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &num_elements, NULL, 0, NULL, &event);
+    test_error( error, "clEnqueueNDRangeKernel failed." );
+    
+    error = clWaitForEvents(1, &event);
+    test_error(error, "clWaitForEvents failed.");
+    
+    error = clEnqueueReadBuffer(queue, streams[1], CL_TRUE, 0, num_elements, buf.data(), 0, NULL, NULL);
+    test_error( error, "clEnqueueReadBuffer failed." );
+
+    for (int i = 0; i < num_elements; ++i)
+    {
+        if (buf[i] != i)
+        {
+            log_error("ERROR: Incorrect vector copy result.");
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+int test_queue_properties(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
+{
+    if (num_elements <= 0)
+    {
+        num_elements = 128;
+    }
+    int error = 0;
+
+    clProgramWrapper program;
+    clKernelWrapper kernel;
+    size_t strSize;
+    std::string strExt(0, '\0');
+    cl_queue_properties_khr device_props = NULL;
+    cl_queue_properties_khr queue_prop_def[] = { CL_QUEUE_PROPERTIES, 0, 0 };
+
+    // Query extension
+    error = clGetDeviceInfo(deviceID, CL_DEVICE_EXTENSIONS, 0, NULL, &strSize);
+    test_error(error, "clGetDeviceInfo for CL_DEVICE_EXTENSIONS failed");
+    strExt.resize(strSize);
+    error = clGetDeviceInfo(deviceID, CL_DEVICE_EXTENSIONS, strExt.size(), &strExt[0], NULL);
+    test_error(error, "clGetDeviceInfo for CL_DEVICE_EXTENSIONS failed");
+    log_info("CL_DEVICE_EXTENSIONS:\n%s\n\n", strExt.c_str());
+
+    if (strExt.find("cl_khr_create_command_queue") == string::npos)
+    {
+        log_info("extension cl_khr_create_command_queue is not supported.\n");
+        return 0;
+    }
+
+    error = create_single_kernel_helper(context, &program, &kernel, 1, queue_test_kernel, "vec_cpy");
+    test_error(error, "create_single_kernel_helper failed");
+
+    log_info("Queue property NULL. Testing ... \n");
+    error = enqueue_kernel(context, NULL,deviceID, kernel, (size_t)num_elements);
+    test_error(error, "enqueue_kernel failed");
+
+    error = clGetDeviceInfo(deviceID, CL_DEVICE_QUEUE_PROPERTIES, sizeof(device_props), &device_props, NULL);
+    test_error(error, "clGetDeviceInfo for CL_DEVICE_QUEUE_PROPERTIES failed");
+
+    if (device_props & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
+    {
+        log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE supported. Testing ... \n");
+        queue_prop_def[1] = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+        error = enqueue_kernel(context, queue_prop_def, deviceID, kernel, (size_t)num_elements);
+        test_error(error, "enqueue_kernel failed");
+    } else
+    {
+        log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE not supported \n");
+    }
+
+    if (device_props & CL_QUEUE_PROFILING_ENABLE)
+    {
+        log_info("Queue property CL_QUEUE_PROFILING_ENABLE supported. Testing ... \n");
+        queue_prop_def[1] = CL_QUEUE_PROFILING_ENABLE;
+        error = enqueue_kernel(context, queue_prop_def, deviceID, kernel, (size_t)num_elements);
+        test_error(error, "enqueue_kernel failed");
+    } else
+    {
+        log_info("Queue property CL_QUEUE_PROFILING_ENABLE not supported \n");
+    }
+
+    if (device_props & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE && device_props & CL_QUEUE_PROFILING_ENABLE)
+    {
+        log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE & CL_QUEUE_PROFILING_ENABLE supported. Testing ... \n");
+        queue_prop_def[1] = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE|CL_QUEUE_PROFILING_ENABLE;
+        error = enqueue_kernel(context, queue_prop_def, deviceID, kernel, (size_t)num_elements);
+        test_error(error, "enqueue_kernel failed");
+    }
+    else
+    {
+        log_info("Queue property CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE or CL_QUEUE_PROFILING_ENABLE not supported \n");
+    }
+
+    return 0;
+}

test_conformance/compatibility/test_conformance/basic/test_async_strided_copy.cpp

@@ -202,10 +202,10 @@ int test_strided_copy(cl_device_id deviceID, cl_context context, cl_command_queu
             log_error( "ERROR: Results of copy did not validate!\n" );
             sprintf(values + strlen( values), "%d -> [", i);
             for (int j=0; j<(int)elementSize; j++)
-                sprintf(values + strlen( values), "%2x ", inchar[i*elementSize+j]);
+                sprintf(values + strlen( values), "%2x ", inchar[j]);
             sprintf(values + strlen(values), "] != [");
             for (int j=0; j<(int)elementSize; j++)
-                sprintf(values + strlen( values), "%2x ", outchar[i*elementSize+j]);
+                sprintf(values + strlen( values), "%2x ", outchar[j]);
             sprintf(values + strlen(values), "]");
             log_error("%s\n", values);
 

test_conformance/compatibility/test_conformance/basic/test_sizeof.c

@@ -133,7 +133,7 @@ const size_table  vector_table[] =
 
 const char  *ptr_table[] =
 {
-    "void*",
+    "global void*",
     "size_t",
     "sizeof(int)",      // check return type of sizeof
     "ptrdiff_t"

test_conformance/compatibility/test_conformance/images/image_helpers.h

@@ -481,7 +481,6 @@ extern char *create_random_image_data( ExplicitType dataType, image_descriptor *
 extern void get_sampler_kernel_code( image_sampler_data *imageSampler, char *outLine );
 extern float get_max_absolute_error( cl_image_format *format, image_sampler_data *sampler);
 extern float get_max_relative_error( cl_image_format *format, image_sampler_data *sampler, int is3D, int isLinearFilter );
-extern int issubnormal(float);
 
 
 #define errMax( _x , _y )       ( (_x) != (_x) ? (_x) : (_x) > (_y) ? (_x) : (_y) )