[SYCL][Bindless][E2E] fix unsampled images test failure (intel#13007)

* Update the test to initialize the input vectors with 0s to match
`bindless_helpers::fill_rand` requirement of non empty vector.
* Change the name of function `initVector` to  `init_vector`.
* move `init_vector`, `equal_vec` and `operator<<` in header
`bindless_helpers.hpp`.

Author: cppchedy

sycl/test-e2e/bindless_images/bindless_helpers.hpp

@@ -2,11 +2,48 @@
 #include <random>
 #include <sycl/sycl.hpp>
 
+template <typename DType, int NChannels>
+std::ostream &operator<<(std::ostream &os,
+                         const sycl::vec<DType, NChannels> &vec) {
+  std::string str{""};
+  for (int i = 0; i < NChannels; ++i) {
+    str += std::to_string(vec[i]) + ",";
+  }
+  str.pop_back();
+  os << str;
+  return os;
+}
+
 namespace bindless_helpers {
 
+template <typename DType, int NChannel>
+constexpr sycl::vec<DType, NChannel> init_vector(DType val) {
+  if constexpr (NChannel == 1) {
+    return sycl::vec<DType, NChannel>{val};
+  } else if constexpr (NChannel == 2) {
+    return sycl::vec<DType, NChannel>{val, val};
+  } else if constexpr (NChannel == 4) {
+    return sycl::vec<DType, NChannel>{val, val, val, val};
+  } else {
+    std::cerr << "Unsupported number of channels " << NChannel << "\n";
+    exit(-1);
+  }
+}
+
+template <typename DType, int NChannels>
+bool equal_vec(sycl::vec<DType, NChannels> v1, sycl::vec<DType, NChannels> v2) {
+  for (int i = 0; i < NChannels; ++i) {
+    if (v1[i] != v2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 template <typename DType, int NChannels>
 static void fill_rand(std::vector<sycl::vec<DType, NChannels>> &v,
                       int seed = std::default_random_engine::default_seed) {
+  assert(!v.empty());
   std::default_random_engine generator;
   generator.seed(seed);
   auto distribution = [&]() {

sycl/test-e2e/bindless_images/vulkan_interop/mipmaps.cpp

@@ -10,6 +10,7 @@
 
 #include <sycl/sycl.hpp>
 
+#include "../bindless_helpers.hpp"
 #include "vulkan_common.hpp"
 
 namespace syclexp = sycl::ext::oneapi::experimental;
@@ -163,13 +164,13 @@ bool run_sycl(sycl::range<NDims> globalSize, sycl::range<NDims> localSize,
           float norm_coord_z = ((k + 0.5f) / (float)depth);
           int z = norm_coord_z * (depth >> 1);
 
-          VecType expected =
-              initVector<DType, NChannels>(i + width * (j + height * k)) +
-              initVector<DType, NChannels>(x + (width / 2) *
-                                                   (y + (height / 2) * z));
+          VecType expected = bindless_helpers::init_vector<DType, NChannels>(
+                                 i + width * (j + height * k)) +
+                             bindless_helpers::init_vector<DType, NChannels>(
+                                 x + (width / 2) * (y + (height / 2) * z));
 
-          if (!equal_vec<DType, NChannels>(out[i + width * (j + height * k)],
-                                           expected)) {
+          if (!bindless_helpers::equal_vec<DType, NChannels>(
+                  out[i + width * (j + height * k)], expected)) {
             mismatch = true;
             validated = false;
           }
@@ -194,8 +195,10 @@ bool run_sycl(sycl::range<NDims> globalSize, sycl::range<NDims> localSize,
         float norm_coord_y = ((j + 0.5f) / (float)height);
         int y = norm_coord_y * (height >> 1);
 
-        VecType expected = initVector<DType, NChannels>(j + (width * i)) +
-                           initVector<DType, NChannels>(y + (width / 2 * x));
+        VecType expected =
+            bindless_helpers::init_vector<DType, NChannels>(j + (width * i)) +
+            bindless_helpers::init_vector<DType, NChannels>(y +
+                                                            (width / 2 * x));
 
         if (!equal_vec<DType, NChannels>(out[j + (width * i)], expected)) {
           mismatch = true;
@@ -289,7 +292,8 @@ bool run_test(sycl::range<NDims> dims, sycl::range<NDims> localSize,
                 std::max(height >> i, (uint32_t)1) *
                 std::max(depth >> i, (uint32_t)1));
     for (int j = 0; j < mipElems; ++j) {
-      inputStagingData[j + offset] = initVector<DType, NChannels>(j);
+      inputStagingData[j + offset] =
+          bindless_helpers::init_vector<DType, NChannels>(j);
     }
     offset += mipElems;
   }

sycl/test-e2e/bindless_images/vulkan_interop/sampled_images.cpp

@@ -10,6 +10,7 @@
 
 #include <sycl/sycl.hpp>
 
+#include "../bindless_helpers.hpp"
 #include "vulkan_common.hpp"
 
 namespace syclexp = sycl::ext::oneapi::experimental;
@@ -147,9 +148,9 @@ bool run_sycl(sycl::range<NDims> globalSize, sycl::range<NDims> localSize,
   bool validated = true;
   for (int i = 0; i < globalSize.size(); i++) {
     bool mismatch = false;
-    VecType expected =
-        initVector<DType, NChannels>(i) * static_cast<DType>(10.1f);
-    if (!equal_vec<DType, NChannels>(out[i], expected)) {
+    VecType expected = bindless_helpers::init_vector<DType, NChannels>(i) *
+                       static_cast<DType>(10.1f);
+    if (!bindless_helpers::equal_vec<DType, NChannels>(out[i], expected)) {
       mismatch = true;
       validated = false;
     }
@@ -233,7 +234,7 @@ bool run_test(sycl::range<NDims> dims, sycl::range<NDims> localSize,
                             imageSizeBytes, 0 /*flags*/,
                             (void **)&inputStagingData));
   for (int i = 0; i < numElems; ++i) {
-    inputStagingData[i] = initVector<DType, NChannels>(i);
+    inputStagingData[i] = bindless_helpers::init_vector<DType, NChannels>(i);
   }
   vkUnmapMemory(vk_device, inputStagingMemory);
 

sycl/test-e2e/bindless_images/vulkan_interop/unsampled_images.cpp

@@ -264,8 +264,10 @@ bool run_test(sycl::range<NDims> dims, sycl::range<NDims> local_size,
   printString("Populating staging buffer\n");
   // Populate staging memory
   using VecType = sycl::vec<DType, NChannels>;
-  std::vector<VecType> input_vector_0;
-  input_vector_0.reserve(num_elems);
+  auto init =
+      bindless_helpers::init_vector<DType, NChannels>(static_cast<DType>(0));
+
+  std::vector<VecType> input_vector_0(num_elems, init);
   std::srand(seed);
   bindless_helpers::fill_rand(input_vector_0);
 
@@ -278,8 +280,7 @@ bool run_test(sycl::range<NDims> dims, sycl::range<NDims> local_size,
   }
   vkUnmapMemory(vk_device, inVkImgRes1.stagingMemory);
 
-  std::vector<VecType> input_vector_1;
-  input_vector_1.reserve(num_elems);
+  std::vector<VecType> input_vector_1(num_elems, init);
   std::srand(seed);
   bindless_helpers::fill_rand(input_vector_1);
 

sycl/test-e2e/bindless_images/vulkan_interop/vulkan_common.hpp

@@ -11,42 +11,6 @@ void printString(std::string str) {
 #endif
 }
 
-template <typename DType, int NChannels>
-std::ostream &operator<<(std::ostream &os,
-                         const sycl::vec<DType, NChannels> &vec) {
-  std::string str{""};
-  for (int i = 0; i < NChannels; ++i) {
-    str += std::to_string(vec[i]) + ",";
-  }
-  str.pop_back();
-  os << str;
-  return os;
-}
-
-template <typename DType, int NChannels>
-bool equal_vec(sycl::vec<DType, NChannels> v1, sycl::vec<DType, NChannels> v2) {
-  for (int i = 0; i < NChannels; ++i) {
-    if (v1[i] != v2[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <typename DType, int NChannel>
-constexpr sycl::vec<DType, NChannel> initVector(DType val) {
-  if constexpr (NChannel == 1) {
-    return sycl::vec<DType, NChannel>{val};
-  } else if constexpr (NChannel == 2) {
-    return sycl::vec<DType, NChannel>{val, val};
-  } else if constexpr (NChannel == 4) {
-    return sycl::vec<DType, NChannel>{val, val, val, val};
-  } else {
-    std::cerr << "unsupported number of channels " << NChannel << "\n";
-    exit(-1);
-  }
-}
-
 #define VK_CHECK_CALL_RET(call)                                                \
   {                                                                            \
     VkResult err = call;                                                       \