Move get_memory_resource into libcu++ (#4742)

* Move `get_memory_resource` into libcu++

* Expose a private __get_memory_resource_t regardless of `LIBCUDACXX_ENABLE_EXPERIMENTAL_MEMORY_RESOURCE`

Author: miscco

cudax/include/cuda/experimental/__container/async_buffer.cuh

@@ -27,6 +27,7 @@
 #include <thrust/fill.h>
 #include <thrust/for_each.h>
 
+#include <cuda/__memory_resource/get_memory_resource.h>
 #include <cuda/__memory_resource/properties.h>
 #include <cuda/__memory_resource/resource_ref.h>
 #include <cuda/__stream/get_stream.h>
@@ -64,7 +65,6 @@
 #include <cuda/experimental/__execution/policy.cuh>
 #include <cuda/experimental/__launch/host_launch.cuh>
 #include <cuda/experimental/__memory_resource/any_resource.cuh>
-#include <cuda/experimental/__memory_resource/get_memory_resource.cuh>
 #include <cuda/experimental/__memory_resource/properties.cuh>
 #include <cuda/experimental/__utility/ensure_current_device.cuh>
 #include <cuda/experimental/__utility/select_execution_space.cuh>
@@ -306,7 +306,7 @@ public:
   //! At the destruction of the \c async_buffer all elements in the range `[vec.begin(), vec.end())` will be destroyed.
   _CCCL_HIDE_FROM_ABI explicit async_buffer(
     const __env_t& __env, const size_type __size, ::cuda::experimental::no_init_t)
-      : __buf_(::cuda::experimental::get_memory_resource(__env), ::cuda::get_stream(__env), __size)
+      : __buf_(::cuda::mr::get_memory_resource(__env), ::cuda::get_stream(__env), __size)
   {}
 
   //! @brief Constructs a async_buffer using a memory resource and copy-constructs all elements from the forward range

cudax/include/cuda/experimental/__execution/env.cuh

@@ -21,6 +21,7 @@
 #  pragma system_header
 #endif // no system header
 
+#include <cuda/__memory_resource/get_memory_resource.h>
 #include <cuda/__memory_resource/properties.h>
 #include <cuda/__stream/get_stream.h>
 #include <cuda/std/__execution/env.h>
@@ -32,7 +33,6 @@
 #include <cuda/experimental/__execution/queries.cuh>
 #include <cuda/experimental/__memory_resource/any_resource.cuh>
 #include <cuda/experimental/__memory_resource/device_memory_resource.cuh>
-#include <cuda/experimental/__memory_resource/get_memory_resource.cuh>
 #include <cuda/experimental/__stream/stream_ref.cuh>
 
 #include <cuda/experimental/__execution/prologue.cuh>
@@ -141,7 +141,7 @@ public:
   //! properties we need
   template <class _Env>
   static constexpr bool __is_compatible_env =
-    _CUDA_STD_EXEC::__queryable_with<_Env, get_memory_resource_t> //
+    _CUDA_STD_EXEC::__queryable_with<_Env, ::cuda::mr::get_memory_resource_t> //
     && _CUDA_STD_EXEC::__queryable_with<_Env, ::cuda::get_stream_t>
     && _CUDA_STD_EXEC::__queryable_with<_Env, execution::get_execution_policy_t>;
 
@@ -150,12 +150,12 @@ public:
   _CCCL_TEMPLATE(class _Env)
   _CCCL_REQUIRES((!_CCCL_TRAIT(_CUDA_VSTD::is_same, _Env, env_t)) _CCCL_AND __is_compatible_env<_Env>)
   _CCCL_HIDE_FROM_ABI env_t(const _Env& __env) noexcept
-      : __mr_(__env.query(get_memory_resource))
+      : __mr_(__env.query(::cuda::mr::get_memory_resource))
       , __stream_(__env.query(::cuda::get_stream))
       , __policy_(__env.query(execution::get_execution_policy))
   {}
 
-  [[nodiscard]] _CCCL_HIDE_FROM_ABI const __resource& query(get_memory_resource_t) const noexcept
+  [[nodiscard]] _CCCL_HIDE_FROM_ABI const __resource& query(::cuda::mr::get_memory_resource_t) const noexcept
   {
     return __mr_;
   }

cudax/include/cuda/experimental/memory_resource.cuh

@@ -25,7 +25,6 @@
 #include <cuda/experimental/__memory_resource/any_resource.cuh>
 #include <cuda/experimental/__memory_resource/device_memory_pool.cuh>
 #include <cuda/experimental/__memory_resource/device_memory_resource.cuh>
-#include <cuda/experimental/__memory_resource/get_memory_resource.cuh>
 #include <cuda/experimental/__memory_resource/legacy_pinned_memory_resource.cuh>
 #include <cuda/experimental/__memory_resource/managed_memory_resource.cuh>
 #include <cuda/experimental/__memory_resource/pinned_memory_pool.cuh>

cudax/test/CMakeLists.txt

@@ -124,7 +124,6 @@ foreach(cn_target IN LISTS cudax_TARGETS)
     memory_resource/any_resource.cu
     memory_resource/memory_pools.cu
     memory_resource/device_memory_resource.cu
-    memory_resource/get_memory_resource.cu
     memory_resource/managed_memory_resource.cu
     memory_resource/pinned_memory_resource.cu
     memory_resource/shared_resource.cu

cudax/test/containers/async_buffer/copy.cu

@@ -99,15 +99,15 @@ C2H_TEST("cudax::async_buffer make_async_buffer", "[container][async_buffer]", t
     cudax::stream other_stream{};
     { // empty input
       const Buffer input{env};
-      const auto buf = cudax::make_async_buffer(other_stream, env.query(cudax::get_memory_resource), input);
+      const auto buf = cudax::make_async_buffer(other_stream, env.query(cuda::mr::get_memory_resource), input);
       static_assert(!cuda::std::is_same_v<Buffer, cuda::std::remove_const_t<decltype(buf)>>);
       CUDAX_CHECK(buf.empty());
       CUDAX_CHECK(buf.data() == nullptr);
     }
 
     { // non-empty input
       const Buffer input{env, {T(1), T(42), T(1337), T(0), T(12), T(-1)}};
-      const auto buf = cudax::make_async_buffer(other_stream, env.query(cudax::get_memory_resource), input);
+      const auto buf = cudax::make_async_buffer(other_stream, env.query(cuda::mr::get_memory_resource), input);
       static_assert(!cuda::std::is_same_v<Buffer, cuda::std::remove_const_t<decltype(buf)>>);
       CUDAX_CHECK(!buf.empty());
       CUDAX_CHECK(equal_range(buf));
@@ -118,31 +118,31 @@ C2H_TEST("cudax::async_buffer make_async_buffer", "[container][async_buffer]", t
   {
     { // empty input
       const Buffer input{env};
-      const auto buf = cudax::make_async_buffer(stream, env.query(cudax::get_memory_resource), input);
+      const auto buf = cudax::make_async_buffer(stream, env.query(cuda::mr::get_memory_resource), input);
       static_assert(!cuda::std::is_same_v<Buffer, cuda::std::remove_const_t<decltype(buf)>>);
       CUDAX_CHECK(buf.empty());
       CUDAX_CHECK(buf.data() == nullptr);
     }
 
     { // non-empty input
       const Buffer input{env, {T(1), T(42), T(1337), T(0), T(12), T(-1)}};
-      const auto buf = cudax::make_async_buffer(stream, env.query(cudax::get_memory_resource), input);
+      const auto buf = cudax::make_async_buffer(stream, env.query(cuda::mr::get_memory_resource), input);
       static_assert(!cuda::std::is_same_v<Buffer, cuda::std::remove_const_t<decltype(buf)>>);
       CUDAX_CHECK(!buf.empty());
       CUDAX_CHECK(equal_range(buf));
     }
 
     { // empty input
       const Buffer input{env};
-      const auto buf = cudax::make_async_buffer(stream, env.query(cudax::get_memory_resource), input);
+      const auto buf = cudax::make_async_buffer(stream, env.query(cuda::mr::get_memory_resource), input);
       static_assert(!cuda::std::is_same_v<Buffer, cuda::std::remove_const_t<decltype(buf)>>);
       CUDAX_CHECK(buf.empty());
       CUDAX_CHECK(buf.data() == nullptr);
     }
 
     { // non-empty input
       const Buffer input{env, {T(1), T(42), T(1337), T(0), T(12), T(-1)}};
-      const auto buf = cudax::make_async_buffer(stream, env.query(cudax::get_memory_resource), input);
+      const auto buf = cudax::make_async_buffer(stream, env.query(cuda::mr::get_memory_resource), input);
       static_assert(!cuda::std::is_same_v<Buffer, cuda::std::remove_const_t<decltype(buf)>>);
       CUDAX_CHECK(!buf.empty());
       CUDAX_CHECK(equal_range(buf));

cudax/test/execution/env.cu

@@ -48,7 +48,7 @@ struct test_resource
 C2H_TEST("env_t is queryable for all properties we want", "[execution, env]")
 {
   STATIC_REQUIRE(cuda::std::execution::__queryable_with<env_t, cuda::get_stream_t>);
-  STATIC_REQUIRE(cuda::std::execution::__queryable_with<env_t, cudax::get_memory_resource_t>);
+  STATIC_REQUIRE(cuda::std::execution::__queryable_with<env_t, cuda::mr::get_memory_resource_t>);
   STATIC_REQUIRE(cuda::std::execution::__queryable_with<env_t, cudax::execution::get_execution_policy_t>);
 }
 
@@ -58,7 +58,7 @@ C2H_TEST("env_t is default constructible", "[execution, env]")
   CHECK(env.query(cuda::get_stream) == ::cuda::experimental::detail::__invalid_stream);
   CHECK(env.query(cudax::execution::get_execution_policy)
         == cudax::execution::execution_policy::invalid_execution_policy);
-  CHECK(env.query(cudax::get_memory_resource) == cudax::device_memory_resource{});
+  CHECK(env.query(cuda::mr::get_memory_resource) == cudax::device_memory_resource{});
 }
 
 C2H_TEST("env_t is constructible from an any_resource", "[execution, env]")
@@ -71,7 +71,7 @@ C2H_TEST("env_t is constructible from an any_resource", "[execution, env]")
     CHECK(env.query(cuda::get_stream) == ::cuda::experimental::detail::__invalid_stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource) == mr);
+    CHECK(env.query(cuda::mr::get_memory_resource) == mr);
   }
 
   SECTION("Passing an any_resource and a stream")
@@ -81,7 +81,7 @@ C2H_TEST("env_t is constructible from an any_resource", "[execution, env]")
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource) == mr);
+    CHECK(env.query(cuda::mr::get_memory_resource) == mr);
   }
 
   SECTION("Passing an any_resource, a stream and a policy")
@@ -91,7 +91,7 @@ C2H_TEST("env_t is constructible from an any_resource", "[execution, env]")
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::parallel_unsequenced_device);
-    CHECK(env.query(cudax::get_memory_resource) == mr);
+    CHECK(env.query(cuda::mr::get_memory_resource) == mr);
   }
 }
 
@@ -103,7 +103,7 @@ C2H_TEST("env_t is constructible from an any_resource passed as an rvalue", "[ex
     CHECK(env.query(cuda::get_stream) == ::cuda::experimental::detail::__invalid_stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource)
+    CHECK(env.query(cuda::mr::get_memory_resource)
           == cudax::any_async_resource<cuda::mr::device_accessible>{test_resource{}});
   }
 
@@ -114,7 +114,7 @@ C2H_TEST("env_t is constructible from an any_resource passed as an rvalue", "[ex
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource)
+    CHECK(env.query(cuda::mr::get_memory_resource)
           == cudax::any_async_resource<cuda::mr::device_accessible>{test_resource{}});
   }
 
@@ -127,7 +127,7 @@ C2H_TEST("env_t is constructible from an any_resource passed as an rvalue", "[ex
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::parallel_unsequenced_device);
-    CHECK(env.query(cudax::get_memory_resource)
+    CHECK(env.query(cuda::mr::get_memory_resource)
           == cudax::any_async_resource<cuda::mr::device_accessible>{test_resource{}});
   }
 }
@@ -142,7 +142,7 @@ C2H_TEST("env_t is constructible from a resource", "[execution, env]")
     CHECK(env.query(cuda::get_stream) == ::cuda::experimental::detail::__invalid_stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource) == mr);
+    CHECK(env.query(cuda::mr::get_memory_resource) == mr);
   }
 
   SECTION("Passing an any_resource and a stream")
@@ -152,7 +152,7 @@ C2H_TEST("env_t is constructible from a resource", "[execution, env]")
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource) == mr);
+    CHECK(env.query(cuda::mr::get_memory_resource) == mr);
   }
 
   SECTION("Passing an any_resource, a stream and a policy")
@@ -162,7 +162,7 @@ C2H_TEST("env_t is constructible from a resource", "[execution, env]")
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::parallel_unsequenced_device);
-    CHECK(env.query(cudax::get_memory_resource) == mr);
+    CHECK(env.query(cuda::mr::get_memory_resource) == mr);
   }
 }
 
@@ -174,7 +174,7 @@ C2H_TEST("env_t is constructible from a resource passed as an rvalue", "[executi
     CHECK(env.query(cuda::get_stream) == ::cuda::experimental::detail::__invalid_stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource) == test_resource{});
+    CHECK(env.query(cuda::mr::get_memory_resource) == test_resource{});
   }
 
   SECTION("Passing an any_resource and a stream")
@@ -184,7 +184,7 @@ C2H_TEST("env_t is constructible from a resource passed as an rvalue", "[executi
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::invalid_execution_policy);
-    CHECK(env.query(cudax::get_memory_resource) == test_resource{});
+    CHECK(env.query(cuda::mr::get_memory_resource) == test_resource{});
   }
 
   SECTION("Passing an any_resource, a stream and a policy")
@@ -194,7 +194,7 @@ C2H_TEST("env_t is constructible from a resource passed as an rvalue", "[executi
     CHECK(env.query(cuda::get_stream) == stream);
     CHECK(env.query(cudax::execution::get_execution_policy)
           == cudax::execution::execution_policy::parallel_unsequenced_device);
-    CHECK(env.query(cudax::get_memory_resource) == test_resource{});
+    CHECK(env.query(cuda::mr::get_memory_resource) == test_resource{});
   }
 }
 
@@ -204,7 +204,7 @@ struct some_env_t
   cudax::stream stream_{};
   cudax::execution::execution_policy policy_ = cudax::execution::execution_policy::parallel_unsequenced_device;
 
-  const test_resource& query(cudax::get_memory_resource_t) const noexcept
+  const test_resource& query(cuda::mr::get_memory_resource_t) const noexcept
   {
     return res_;
   }
@@ -225,7 +225,7 @@ C2H_TEST("env_t is constructible from a suitable env", "[execution, env]")
   env_t env{other_env};
   CHECK(env.query(cuda::get_stream) == other_env.stream_);
   CHECK(env.query(cudax::execution::get_execution_policy) == other_env.policy_);
-  CHECK(env.query(cudax::get_memory_resource) == other_env.res_);
+  CHECK(env.query(cuda::mr::get_memory_resource) == other_env.res_);
 }
 
 template <bool WithResource, bool WithStream, bool WithPolicy>
@@ -236,7 +236,7 @@ struct bad_env_t
   cudax::execution::execution_policy policy_ = cudax::execution::execution_policy::parallel_unsequenced_device;
 
   template <bool Enable = WithResource, cuda::std::enable_if_t<Enable, int> = 0>
-  const test_resource& query(cudax::get_memory_resource_t) const noexcept
+  const test_resource& query(cuda::mr::get_memory_resource_t) const noexcept
   {
     return res_;
   }
@@ -266,7 +266,7 @@ C2H_TEST("Can use query to construct various objects", "[execution, env]")
   SECTION("Can create an any_resource")
   {
     env_t env{test_resource{}};
-    cudax::any_resource<cuda::mr::device_accessible> resource = env.query(cudax::get_memory_resource);
+    cudax::any_resource<cuda::mr::device_accessible> resource = env.query(cuda::mr::get_memory_resource);
     CHECK(resource == test_resource{});
   }
 
@@ -275,7 +275,7 @@ C2H_TEST("Can use query to construct various objects", "[execution, env]")
     cudax::stream stream_{};
     env_t env{test_resource{}, stream_};
     cudax::uninitialized_async_buffer<int, cuda::mr::device_accessible> buf{
-      env.query(cudax::get_memory_resource), env.query(cuda::get_stream), 0ull};
+      env.query(cuda::mr::get_memory_resource), env.query(cuda::get_stream), 0ull};
     CHECK(buf.get_memory_resource() == test_resource{});
     CHECK(buf.get_stream() == stream_);
   }