[SYCL] Add a test with rebound usm_allocator

Author: aelovikov-intel

SYCL/USM/allocator_rebind.cpp

@@ -0,0 +1,88 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple %s -o %t1.out
+// RUN: %HOST_RUN_PLACEHOLDER %t1.out
+// RUN: %CPU_RUN_PLACEHOLDER %t1.out
+// RUN: %GPU_RUN_PLACEHOLDER %t1.out
+// RUN: %ACC_RUN_PLACEHOLDER %t1.out
+
+//==------------------------------------------------------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <CL/sycl.hpp>
+
+using namespace cl::sycl;
+
+// Allocator has a minimum internal alignment of 64, so use higher values for
+// the purpose of this test.
+struct alignas(256) Aligned256 {
+  int x;
+};
+struct alignas(128) Aligned128 {
+  int x;
+};
+
+template <class T, class Allocator>
+void test_align(Allocator alloc, size_t Align) {
+  std::vector<T *> Ptrs;
+  for (int i =0; i < 10; ++i)
+    Ptrs.push_back(alloc.allocate(1));
+
+  int NumExactlyAligned = 0;
+
+  for (T *Ptr : Ptrs) {
+    auto Val = reinterpret_cast<uintptr_t>(Ptr);
+    assert((Val & (Align - 1)) == 0 && "Not properly aligned!");
+    if ((Val & (Align*2 - 1)) != 0)
+      ++NumExactlyAligned;
+  }
+
+  // There was a bug that we didn't lower allocator's alignment when we rebound
+  // it to less-aligned type. Here, we verify that Aligned128's alignment is in
+  // fact 128 and not 256 (we also check that Aligned256's alignment isn't 512
+  // but that is less important).
+  //
+  // Technically, the underlying runtime might do overalignment itself (as it
+  // does for int, for example - always aligning for 64). In such case, the test
+  // needs to be updated to find configuration where we still test our runtime
+  // by ensuring that underlying allocations' alignment differs between
+  // Aligned128/Aligned256.
+  assert(NumExactlyAligned != 0 && "All allocations are over-aligned!");
+
+  for (T *Ptr : Ptrs)
+    alloc.deallocate(Ptr, 1);
+
+}
+
+int main() {
+  queue q;
+  auto dev = q.get_device();
+  auto ctx = q.get_context();
+  {
+    // Test default value of Alignment template parameter.
+    usm_allocator<Aligned256, usm::alloc::host> alloc(ctx, dev);
+    test_align<Aligned256>(alloc, 256);
+
+    using traits_t = std::allocator_traits<decltype(alloc)>;
+    using rebind_t = typename traits_t::template rebind_alloc<Aligned128>;
+    rebind_t alloc_rebound = alloc;
+    test_align<Aligned128>(alloc_rebound, 128);
+  }
+
+  {
+    // Test explicit value of Alignment template parameter.
+    usm_allocator<Aligned256, usm::alloc::host, 256> alloc(ctx, dev);
+    test_align<Aligned256>(alloc, 256);
+    using traits_t = std::allocator_traits<decltype(alloc)>;
+    using rebind_t = typename traits_t::template rebind_alloc<Aligned128>;
+    rebind_t alloc_rebound = alloc;
+    // Rebound allocator must use the higher alignment from the explicit
+    // template parameter, not the type's alignment.
+    test_align<Aligned128>(alloc_rebound, 256);
+  }
+
+  return 0;
+}