Add e2e test for queue::fill with a range of pattern sizes (#16544)

Add a new e2e test to validate queue::fill outputs for any pattern size
between 1 and 32 bytes.

Backend implementations of this feature commonly branch on the pattern
size to implement an optimized path for specific values. This test
ensures a wide range of cases is tested, including also odd numbers of
bytes.

Re-adds #15991 reverted in #16465 with changes to fix #16434.

---------

Co-authored-by: Udit Kumar Agarwal <[email protected]>

Author: rafbiels

sycl/test-e2e/USM/fill_any_size.cpp

@@ -0,0 +1,91 @@
+// RUN: %{build} -o %t1.out
+// RUN: %{run} %t1.out
+// clang-format off
+// UNSUPPORTED: (opencl && cpu)
+// UNSUPPORTED-TRACKER: https://github.com/oneapi-src/unified-runtime/issues/2440
+// clang-format on
+
+/**
+ * Test of the queue::fill interface with a range of pattern sizes and values.
+ *
+ * Loops over pattern sizes from 1 to MaxPatternSize bytes and calls queue::fill
+ * with std::array<uint8_t,Size> for the pattern. Two pattern values are tested,
+ * all zeros and value=index+42. The output is copied back to host and
+ * validated.
+ */
+
+#include <array>
+#include <cstdio>
+#include <sycl/detail/core.hpp>
+#include <sycl/usm.hpp>
+
+constexpr size_t MaxPatternSize{32}; // Bytes.
+constexpr size_t NumElements{10};
+constexpr bool verbose{false};
+
+template <size_t PatternSize, bool SameValue>
+int test(sycl::queue &q, uint8_t firstValue = 0) {
+  using T = std::array<uint8_t, PatternSize>;
+  T value{};
+
+  // Initialize the pattern value on host.
+  for (size_t i{0}; i < PatternSize; ++i) {
+    if constexpr (SameValue) {
+      value[i] = firstValue;
+    } else {
+      value[i] = firstValue + i;
+    }
+  }
+
+  // Allocate memory on the device.
+  T *dptr{sycl::malloc_device<T>(NumElements, q)};
+
+  // Fill the device memory with the pattern.
+  q.fill(dptr, value, NumElements).wait();
+
+  // Copy back the filled memory to host.
+  std::array<T, NumElements> host{};
+  q.copy<T>(dptr, host.data(), NumElements).wait();
+
+  // Validate whether the filled memory contains the expected values.
+  bool pass{true};
+  for (size_t i{0}; i < NumElements; ++i) {
+    for (size_t j{0}; j < PatternSize; ++j) {
+      if (host[i][j] != value[j]) {
+        pass = false;
+      }
+    }
+  }
+
+  // Release the device memory allocation.
+  sycl::free(dptr, q);
+
+  // Print info on failure or in verbose mode.
+  if (!pass || verbose) {
+    printf("Pattern size %3zu bytes, %s values (initial %3u) %s\n", PatternSize,
+           (SameValue ? " equal" : "varied"), firstValue,
+           (pass ? "== PASS ==" : "== FAIL =="));
+  }
+
+  return !pass;
+}
+
+template <size_t Size> int testOneSize(sycl::queue &q) {
+  return test<Size, true>(q, 0) + test<Size, false>(q, 42);
+}
+
+template <size_t... Sizes>
+int testSizes(sycl::queue &q, std::index_sequence<Sizes...>) {
+  return (testOneSize<1u + Sizes>(q) + ...);
+}
+
+int main() {
+  sycl::queue q{};
+  int failures = testSizes(q, std::make_index_sequence<MaxPatternSize>{});
+  if (failures > 0) {
+    printf("%d / %zu tests failed\n", failures, 2u * MaxPatternSize);
+  } else {
+    printf("All %zu tests passed\n", 2u * MaxPatternSize);
+  }
+  return failures;
+}