Memory Resource / View

.upstream-tests/test/cuda/exception/exception.pass.cpp

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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 <cuda/exception>
+#include <cuda/std/type_traits>
+
+#include <cassert>
+#include <iostream>
+
+#include <cuda_runtime_api.h>
+
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+void test_throw() { throw cuda::cuda_error{cudaErrorInvalidKernelImage}; }
+#endif
+
+int main(int argc, char **argv) {
+
+#ifndef __CUDA_ARCH__
+  static_assert(std::is_base_of<::std::runtime_error, cuda::cuda_error>::value,
+                "");
+
+  cuda::cuda_error e{cudaErrorMemoryAllocation};
+  assert(e.what() == std::string{"cudaErrorMemoryAllocation: out of memory"});
+  assert(e.code() == cudaErrorMemoryAllocation);
+
+  std::string msg = "test message";
+  cuda::cuda_error e2{cudaErrorMemoryAllocation, msg};
+  assert(e2.what() == msg + ": cudaErrorMemoryAllocation: out of memory");
+  assert(e2.code() == cudaErrorMemoryAllocation);
+
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+  try {
+    test_throw();
+  } catch (cuda::cuda_error const &e) {
+    assert(e.what() ==
+           std::string{
+               "cudaErrorInvalidKernelImage: device kernel image is invalid"});
+    assert(e.code() == cudaErrorInvalidKernelImage);
+  }
+
+  try {
+    test_throw();
+  } catch (::std::runtime_error const &e) {
+    assert(e.what() ==
+           std::string{
+               "cudaErrorInvalidKernelImage: device kernel image is invalid"});
+  }
+#endif // _LIBCUDACXX_NO_EXCEPTIONS
+#endif // __CUDA_ARCH__
+
+  return 0;
+}

.upstream-tests/test/cuda/exception_helper.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+#define _LIBCUDACXX_TEST_TRY try
+#define _LIBCUDACXX_TEST_CATCH(...) catch(__VA_ARGS__)
+#else
+#define _LIBCUDACXX_TEST_TRY if (1)
+#define _LIBCUDACXX_TEST_CATCH(...) else if (0)
+#endif // _LIBCUDACXX_NO_EXCEPTIONS

.upstream-tests/test/cuda/memory_resource/memres_derived.pass.cpp

@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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 <cassert>
+#include <cuda/memory_resource>
+#include <cuda/std/cstddef>
+#include <cuda/std/type_traits>
+#include <cuda/stream_view>
+#include <vector>
+#include <memory>
+#include <tuple>
+
+struct event {
+  enum action { ALLOCATE, DEALLOCATE };
+  action act;
+  std::uintptr_t pointer;
+  cuda::std::size_t bytes;
+  cuda::std::size_t alignment;
+};
+
+bool operator==(event const& lhs, event const& rhs){
+  return std::tie(lhs.act, lhs.pointer, lhs.bytes, lhs.alignment) ==
+         std::tie(rhs.act, rhs.pointer, rhs.bytes, rhs.alignment);
+}
+
+template <typename MemoryKind>
+class derived_resource : public cuda::memory_resource<MemoryKind> {
+public:
+  std::vector<event> &events() { return events_; }
+private:
+  void *do_allocate(cuda::std::size_t bytes,
+                    cuda::std::size_t alignment) override {
+    auto p = 0xDEADBEEF;
+    events().push_back(event{event::ALLOCATE, p, bytes, alignment});
+    return reinterpret_cast<void*>(p);
+  }
+
+  void do_deallocate(void *p, cuda::std::size_t bytes,
+                     cuda::std::size_t alignment) override {
+    events().push_back(event{event::DEALLOCATE,
+                             reinterpret_cast<std::uintptr_t>(p), bytes,
+                             alignment});
+  }
+
+  std::vector<event> events_;
+};
+
+template <typename MemoryKind>
+void test_derived_resource(){
+    using derived = derived_resource<MemoryKind>;
+    using base = cuda::memory_resource<MemoryKind>;
+
+    derived d;
+    base * b = &d;
+
+    assert(b->is_equal(*b));
+    assert(b->is_equal(d));
+
+    auto p0 = b->allocate(100);
+    assert(d.events().size() == 1);
+    assert((d.events().back() == event{event::ALLOCATE,
+                                       reinterpret_cast<std::uintptr_t>(p0),
+                                       100, derived::default_alignment}));
+
+    auto p1 = b->allocate(42, 32);
+    assert(d.events().size() == 2);
+    assert(
+        (d.events().back() ==
+         event{event::ALLOCATE, reinterpret_cast<std::uintptr_t>(p1), 42, 32}));
+
+    b->deallocate(p0, 100);
+    assert(d.events().size() == 3);
+    assert((d.events().back() == event{event::DEALLOCATE,
+                                       reinterpret_cast<std::uintptr_t>(p0),
+                                       100, derived::default_alignment}));
+
+    b->deallocate(p1, 42, 32);
+    assert(d.events().size() == 4);
+    assert((d.events().back() == event{event::DEALLOCATE,
+                                       reinterpret_cast<std::uintptr_t>(p1), 42,
+                                       32}));
+}
+
+int main(int argc, char **argv) {
+
+#ifndef __CUDA_ARCH__
+  test_derived_resource<cuda::memory_kind::host>();
+  test_derived_resource<cuda::memory_kind::device>();
+  test_derived_resource<cuda::memory_kind::managed>();
+  test_derived_resource<cuda::memory_kind::pinned>();
+#endif
+
+  return 0;
+}

.upstream-tests/test/cuda/memory_resource/memres_members.pass.cpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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 <cassert>
+#include <cuda/memory_resource>
+#include <cuda/std/type_traits>
+#include <cuda/stream_view>
+#include <cuda/std/cstddef>
+
+template <typename Kind>
+constexpr bool test_memory_kind() {
+  using mr = cuda::memory_resource<Kind>;
+  return std::is_same<typename mr::memory_kind, Kind>::value;
+}
+
+template <typename Kind, std::size_t Alignment>
+constexpr bool test_alignment() {
+  using mr = cuda::memory_resource<Kind>;
+  return mr::default_alignment == Alignment;
+}
+
+int main(int argc, char **argv) {
+
+#ifndef __CUDA_ARCH__
+  namespace memory_kind = cuda::memory_kind;
+  static_assert(test_memory_kind<memory_kind::host>(), "");
+  static_assert(test_memory_kind<memory_kind::device>(), "");
+  static_assert(test_memory_kind<memory_kind::managed>(), "");
+  static_assert(test_memory_kind<memory_kind::pinned>(), "");
+
+  static_assert(test_alignment<memory_kind::host, alignof(cuda::std::max_align_t)>(), "");
+  static_assert(test_alignment<memory_kind::device, alignof(cuda::std::max_align_t)>(), "");
+  static_assert(test_alignment<memory_kind::managed, alignof(cuda::std::max_align_t)>(), "");
+  static_assert(test_alignment<memory_kind::pinned, alignof(cuda::std::max_align_t)>(), "");
+#endif
+
+  return 0;
+}

.upstream-tests/test/cuda/memory_resource/pmr_adaptor/pmr_adaptor.pass.cpp

@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <cassert>
+#include <cuda/memory_resource>
+#include <cuda/std/cstddef>
+#include <cuda/std/type_traits>
+#include <cuda/stream_view>
+#include <memory>
+#include <iostream>
+#include <vector>
+
+
+#if __has_include(<memory_resource>)
+#include <memory_resource>
+namespace pmr = ::std::pmr;
+#elif __has_include(<experimental/memory_resource>)
+#include <experimental/memory_resource>
+namespace pmr = ::std::experimental::pmr;
+#endif 
+
+
+struct event {
+  enum action { ALLOCATE, DEALLOCATE };
+  action act;
+  std::uintptr_t pointer;
+  cuda::std::size_t bytes;
+  cuda::std::size_t alignment;
+};
+
+bool operator==(event const& lhs, event const& rhs){
+  return std::tie(lhs.act, lhs.pointer, lhs.bytes, lhs.alignment) ==
+         std::tie(rhs.act, rhs.pointer, rhs.bytes, rhs.alignment);
+}
+
+class derived_resource : public cuda::memory_resource<cuda::memory_kind::host> {
+public:
+  std::vector<event> &events() { return events_; }
+private:
+  void *do_allocate(cuda::std::size_t bytes,
+                    cuda::std::size_t alignment) override {
+    auto p = 0xDEADBEEF;
+    events().push_back(event{event::ALLOCATE, p, bytes, alignment});
+    return reinterpret_cast<void*>(p);
+  }
+
+  void do_deallocate(void *p, cuda::std::size_t bytes,
+                     cuda::std::size_t alignment) override {
+    events().push_back(event{event::DEALLOCATE,
+                             reinterpret_cast<std::uintptr_t>(p), bytes,
+                             alignment});
+  }
+
+  std::vector<event> events_;
+};
+
+
+template <typename Pointer>
+void test_adaptor(Pointer mr){
+  auto p = &*mr;
+  cuda::pmr_adaptor<Pointer> adapted{std::move(mr)};
+  assert(p == adapted.resource());
+  assert(adapted.is_equal(adapted));
+
+  pmr::memory_resource * std_mr = &adapted;
+  assert(std_mr->is_equal(adapted));
+  assert(adapted.is_equal(*std_mr));
+
+  auto p0 = std_mr->allocate(42);
+  assert(p->events().size() == 1);
+  assert((p->events().back() == event{event::ALLOCATE,
+                                      reinterpret_cast<std::uintptr_t>(p0), 42,
+                                      alignof(std::max_align_t)}));
+
+  std_mr->deallocate(p0, 42);
+  assert(p->events().size() == 2);
+  assert((p->events().back() == event{event::DEALLOCATE,
+                                      reinterpret_cast<std::uintptr_t>(p0), 42,
+                                      alignof(std::max_align_t)}));
+
+  auto p1 = std_mr->allocate(42, 16);
+  assert(p->events().size() == 3);
+  assert(
+      (p->events().back() ==
+       event{event::ALLOCATE, reinterpret_cast<std::uintptr_t>(p1), 42, 16}));
+
+  std_mr->deallocate(p1, 42, 16);
+  assert(p->events().size() == 4);
+  assert(
+      (p->events().back() ==
+       event{event::DEALLOCATE, reinterpret_cast<std::uintptr_t>(p1), 42, 16}));
+}
+
+int main(int argc, char **argv) {
+
+#ifndef __CUDA_ARCH__
+#if defined(_LIBCUDACXX_STD_PMR_NS)
+   derived_resource mr_raw;
+   test_adaptor(&mr_raw);
+   test_adaptor(std::make_unique<derived_resource>());
+   test_adaptor(std::make_shared<derived_resource>());
+#endif
+#endif
+
+  return 0;
+}