test_vulkan: fix build flags and warnings (#2443)

- Do not override parent-provided value for CMAKE_CXX_FLAGS
- Stop building with -fpermissive (not required/bad practice)
- Delete unused variables
- Remove unnecessary casts

Signed-off-by: Kévin Petit <kpet@free.fr>

test_conformance/vulkan/CMakeLists.txt

@@ -2,7 +2,6 @@ set (MODULE_NAME VULKAN)
 
 list(APPEND CLConform_LIBRARIES vulkan_wrapper)
 set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
-set(CMAKE_CXX_FLAGS "-fpermissive")
 if(WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_USE_PLATFORM_WIN32_KHR")
 endif(WIN32)

test_conformance/vulkan/test_vulkan_interop_buffer.cpp

@@ -34,7 +34,6 @@
 
 namespace {
 
-cl_uchar uuid[CL_UUID_SIZE_KHR];
 cl_device_id deviceId = nullptr;
 
 struct Params
@@ -86,10 +85,10 @@ const char *kernel_text_verify = " \
 
 
 int run_test_with_two_queue(
-    cl_context &context, cl_command_queue &cmd_queue1,
-    cl_command_queue &cmd_queue2, cl_kernel *kernel, cl_kernel &verify_kernel,
-    VulkanDevice &vkDevice, uint32_t numBuffers, uint32_t bufferSize,
-    bool use_fence,
+    cl_context context, cl_command_queue cmd_queue1,
+    cl_command_queue cmd_queue2, clKernelWrapper *kernel,
+    cl_kernel verify_kernel, VulkanDevice &vkDevice, uint32_t numBuffers,
+    uint32_t bufferSize, bool use_fence,
     VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType)
 {
     int err = CL_SUCCESS;
@@ -211,7 +210,6 @@ int run_test_with_two_queue(
             vkDescriptorSet.update(0, vkParamsBuffer);
             for (size_t bIdx = 0; bIdx < vkBufferList.size(); bIdx++)
             {
-                size_t buffer_size = vkBufferList[bIdx].getSize();
                 vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
                                                            0);
                 buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer();
@@ -430,8 +428,8 @@ CLEANUP:
 }
 
 int run_test_with_one_queue(
-    cl_context &context, cl_command_queue &cmd_queue1, cl_kernel *kernel,
-    cl_kernel &verify_kernel, VulkanDevice &vkDevice, uint32_t numBuffers,
+    cl_context context, cl_command_queue cmd_queue1, clKernelWrapper *kernel,
+    cl_kernel verify_kernel, VulkanDevice &vkDevice, uint32_t numBuffers,
     uint32_t bufferSize,
     VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType,
     bool use_fence)
@@ -545,7 +543,6 @@ int run_test_with_one_queue(
             vkDescriptorSet.update(0, vkParamsBuffer);
             for (size_t bIdx = 0; bIdx < vkBufferList.size(); bIdx++)
             {
-                size_t buffer_size = vkBufferList[bIdx].getSize();
                 vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
                                                            0);
                 buffers[bIdx] = externalMemory[bIdx]->getExternalMemoryBuffer();
@@ -735,8 +732,8 @@ CLEANUP:
 }
 
 int run_test_with_multi_import_same_ctx(
-    cl_context &context, cl_command_queue &cmd_queue1, cl_kernel *kernel,
-    cl_kernel &verify_kernel, VulkanDevice &vkDevice, uint32_t numBuffers,
+    cl_context context, cl_command_queue cmd_queue1, clKernelWrapper *kernel,
+    cl_kernel verify_kernel, VulkanDevice &vkDevice, uint32_t numBuffers,
     uint32_t bufferSize, bool use_fence,
     VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType)
 {
@@ -858,7 +855,6 @@ int run_test_with_multi_import_same_ctx(
             vkDescriptorSet.update(0, vkParamsBuffer);
             for (size_t bIdx = 0; bIdx < vkBufferList.size(); bIdx++)
             {
-                size_t buffer_size = vkBufferList[bIdx].getSize();
                 vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
                                                            0);
                 for (size_t cl_bIdx = 0; cl_bIdx < numImports; cl_bIdx++)
@@ -1068,10 +1064,11 @@ CLEANUP:
 }
 
 int run_test_with_multi_import_diff_ctx(
-    cl_context &context, cl_context &context2, cl_command_queue &cmd_queue1,
-    cl_command_queue &cmd_queue2, cl_kernel *kernel1, cl_kernel *kernel2,
-    cl_kernel &verify_kernel, cl_kernel verify_kernel2, VulkanDevice &vkDevice,
-    uint32_t numBuffers, uint32_t bufferSize, bool use_fence,
+    cl_context context, cl_context context2, cl_command_queue cmd_queue1,
+    cl_command_queue cmd_queue2, clKernelWrapper *kernel1,
+    clKernelWrapper *kernel2, cl_kernel verify_kernel, cl_kernel verify_kernel2,
+    VulkanDevice &vkDevice, uint32_t numBuffers, uint32_t bufferSize,
+    bool use_fence,
     VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType)
 {
     size_t global_work_size[1];
@@ -1087,7 +1084,6 @@ int run_test_with_multi_import_diff_ctx(
     clExternalExportableSemaphore *clCl2VkExternalSemaphore2 = nullptr;
     int err = CL_SUCCESS;
     int calc_max_iter;
-    bool withOffset;
     uint32_t pBufferSize;
 
     const std::vector<VulkanExternalMemoryHandleType>
@@ -1180,7 +1176,6 @@ int run_test_with_multi_import_diff_ctx(
             pBufferSize = bufferSize;
             VulkanBufferList vkBufferList(numBuffers, vkDevice, pBufferSize,
                                           vkExternalMemoryHandleType);
-            uint32_t interBufferOffset = (uint32_t)(vkBufferList[0].getSize());
 
             for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
             {
@@ -1212,7 +1207,6 @@ int run_test_with_multi_import_diff_ctx(
             vkDescriptorSet.update(0, vkParamsBuffer);
             for (size_t bIdx = 0; bIdx < vkBufferList.size(); bIdx++)
             {
-                size_t buffer_size = vkBufferList[bIdx].getSize();
                 vkBufferListDeviceMemory[bIdx]->bindBuffer(vkBufferList[bIdx],
                                                            0);
                 for (size_t cl_bIdx = 0; cl_bIdx < numImports; cl_bIdx++)
@@ -1597,14 +1591,7 @@ struct BufferTestBase : public VulkanTestBase
 
     int test_buffer_common(bool use_fence)
     {
-        int current_device = 0;
-        int device_count = 0;
-        int devices_prohibited = 0;
         cl_int errNum = CL_SUCCESS;
-        size_t extensionSize = 0;
-        const size_t bufsize = BUFFERSIZE;
-        char buf[BUFFERSIZE];
-        char *extensions = NULL;
         clKernelWrapper verify_kernel;
         clKernelWrapper verify_kernel2;
         clKernelWrapper kernel[3] = { NULL, NULL, NULL };
@@ -1624,7 +1611,6 @@ struct BufferTestBase : public VulkanTestBase
 
         uint32_t numBuffersList[] = { 1, 2, 4 };
         uint32_t bufferSizeList[] = { 4 * 1024, 64 * 1024, 2 * 1024 * 1024 };
-        uint32_t bufferSizeListforOffset[] = { 256, 512, 1024 };
 
         std::vector<VulkanExternalSemaphoreHandleType> supportedSemaphoreTypes;
 
@@ -1740,36 +1726,28 @@ struct BufferTestBase : public VulkanTestBase
                     if (multiImport && !multiCtx)
                     {
                         errNum = run_test_with_multi_import_same_ctx(
-                            context, (cl_command_queue &)cmd_queue1,
-                            (cl_kernel *)&kernel, (cl_kernel &)verify_kernel,
+                            context, cmd_queue1, kernel, verify_kernel,
                             *vkDevice, numBuffers, bufferSize, use_fence,
                             semaphoreType);
                     }
                     else if (multiImport && multiCtx)
                     {
                         errNum = run_test_with_multi_import_diff_ctx(
-                            context, (cl_context &)context2,
-                            (cl_command_queue &)cmd_queue1,
-                            (cl_command_queue &)cmd_queue3,
-                            (cl_kernel *)&kernel, (cl_kernel *)&kernel2,
-                            (cl_kernel &)verify_kernel, verify_kernel2,
-                            *vkDevice, numBuffers, bufferSize, use_fence,
-                            semaphoreType);
+                            context, context2, cmd_queue1, cmd_queue3, kernel,
+                            kernel2, verify_kernel, verify_kernel2, *vkDevice,
+                            numBuffers, bufferSize, use_fence, semaphoreType);
                     }
                     else if (numCQ == 2)
                     {
                         errNum = run_test_with_two_queue(
-                            context, (cl_command_queue &)cmd_queue1,
-                            (cl_command_queue &)cmd_queue2,
-                            (cl_kernel *)&kernel, (cl_kernel &)verify_kernel,
-                            *vkDevice, numBuffers + 1, bufferSize, use_fence,
-                            semaphoreType);
+                            context, cmd_queue1, cmd_queue2, kernel,
+                            verify_kernel, *vkDevice, numBuffers + 1,
+                            bufferSize, use_fence, semaphoreType);
                     }
                     else
                     {
                         errNum = run_test_with_one_queue(
-                            context, (cl_command_queue &)cmd_queue1,
-                            (cl_kernel *)&kernel, (cl_kernel &)verify_kernel,
+                            context, cmd_queue1, kernel, verify_kernel,
                             *vkDevice, numBuffers, bufferSize, semaphoreType,
                             use_fence);
                     }

test_conformance/vulkan/test_vulkan_interop_image.cpp

@@ -55,7 +55,6 @@ struct Params
     uint32_t numImage2DDescriptors;
 };
 
-cl_uchar uuid[CL_UUID_SIZE_KHR];
 cl_device_id deviceId = NULL;
 size_t max_width = MAX_2D_IMAGE_WIDTH;
 size_t max_height = MAX_2D_IMAGE_HEIGHT;
@@ -195,9 +194,10 @@ const cl_kernel getKernelType(VulkanFormat format, cl_kernel kernel_float,
 }
 
 int run_test_with_two_queue(
-    cl_context &context, cl_command_queue &cmd_queue1,
-    cl_command_queue &cmd_queue2, cl_kernel *kernel_unsigned,
-    cl_kernel *kernel_signed, cl_kernel *kernel_float, VulkanDevice &vkDevice,
+    cl_context context, cl_command_queue cmd_queue1,
+    cl_command_queue cmd_queue2, clKernelWrapper *kernel_unsigned,
+    clKernelWrapper *kernel_signed, clKernelWrapper *kernel_float,
+    VulkanDevice &vkDevice,
     VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType)
 {
     cl_int err = CL_SUCCESS;
@@ -408,7 +408,6 @@ int run_test_with_two_queue(
                             }
 
                             size_t totalImageMemSize = 0;
-                            uint64_t interImageOffset = 0;
                             {
                                 VulkanImage2D vkImage2D(
                                     vkDevice, vkFormat, width, height,
@@ -732,9 +731,6 @@ int run_test_with_two_queue(
                                     "Failed to signal CL semaphore\n");
                             }
 
-                            unsigned int flags = 0;
-                            size_t mipmapLevelOffset = 0;
-                            cl_event eventReadImage = NULL;
                             clFinish(cmd_queue2);
                             for (int i = 0; i < num2DImages; i++)
                             {
@@ -817,9 +813,9 @@ CLEANUP:
 }
 
 int run_test_with_one_queue(
-    cl_context &context, cl_command_queue &cmd_queue1,
-    cl_kernel *kernel_unsigned, cl_kernel *kernel_signed,
-    cl_kernel *kernel_float, VulkanDevice &vkDevice,
+    cl_context context, cl_command_queue cmd_queue1,
+    clKernelWrapper *kernel_unsigned, clKernelWrapper *kernel_signed,
+    clKernelWrapper *kernel_float, VulkanDevice &vkDevice,
     VulkanExternalSemaphoreHandleType vkExternalSemaphoreHandleType)
 {
     cl_int err = CL_SUCCESS;
@@ -1027,7 +1023,6 @@ int run_test_with_one_queue(
                                 }
                             }
                             size_t totalImageMemSize = 0;
-                            uint64_t interImageOffset = 0;
                             {
                                 VulkanImage2D vkImage2D(
                                     vkDevice, vkFormat, width, height,
@@ -1289,9 +1284,6 @@ int run_test_with_one_queue(
                                     "Failed to signal CL semaphore\n");
                             }
 
-                            unsigned int flags = 0;
-                            size_t mipmapLevelOffset = 0;
-                            cl_event eventReadImage = NULL;
                             for (int i = 0; i < num2DImages; i++)
                             {
                                 err = clEnqueueReadImage(
@@ -1508,20 +1500,16 @@ struct ImageCommonTest : public VulkanTestBase
         {
             if (numCQ == 2)
             {
-                err = run_test_with_two_queue(
-                    context, (cl_command_queue &)cmd_queue1,
-                    (cl_command_queue &)cmd_queue2,
-                    (cl_kernel *)kernel_unsigned, (cl_kernel *)kernel_signed,
-                    (cl_kernel *)kernel_float, *vkDevice,
-                    externalSemaphoreType);
+                err = run_test_with_two_queue(context, cmd_queue1, cmd_queue2,
+                                              kernel_unsigned, kernel_signed,
+                                              kernel_float, *vkDevice,
+                                              externalSemaphoreType);
             }
             else
             {
                 err = run_test_with_one_queue(
-                    context, (cl_command_queue &)cmd_queue1,
-                    (cl_kernel *)kernel_unsigned, (cl_kernel *)kernel_signed,
-                    (cl_kernel *)kernel_float, *vkDevice,
-                    externalSemaphoreType);
+                    context, cmd_queue1, kernel_unsigned, kernel_signed,
+                    kernel_float, *vkDevice, externalSemaphoreType);
             }
             test_error(err, "func_name failed \n");
         }