Require CUDA 12.9 for host numa implementation of pinned memory pool (#7856) (#7872)

pciolkosz · wmaxey · web-flow · commit 1b8de5e9657a · 2026-03-04T14:50:56.000-08:00
(cherry picked from commit 413e89a) Co-authored-by: Wesley Maxey <71408887+wmaxey@users.noreply.github.com>
diff --git a/cudax/examples/CMakeLists.txt b/cudax/examples/CMakeLists.txt
@@ -37,7 +37,7 @@ file(
 cccl_get_cudatoolkit()
 
 # Example requires pinned_memory_resource.
-if (CUDAToolkit_VERSION VERSION_LESS 12.6)
+if (CUDAToolkit_VERSION VERSION_LESS 12.9)
   list(REMOVE_ITEM example_srcs async_buffer_add.cu cub_reduce.cu)
 endif()
 
diff --git a/cudax/test/cuco/hyperloglog/test_hyperloglog.cu b/cudax/test/cuco/hyperloglog/test_hyperloglog.cu
@@ -215,7 +215,7 @@ C2H_TEST("HyperLogLog precision constructor", "[hyperloglog]")
   REQUIRE(estimator.estimate() == 0);
 }
 
-#if _CCCL_CTK_AT_LEAST(12, 6) // Pinned memory resource is only supported with CTK 12.6 and later
+#if _CCCL_CTK_AT_LEAST(12, 9) // Pinned memory resource is only supported with CTK 12.9 and later
 C2H_TEST("Hyperloglog estimate works with pinned memory pool", "[hyperloglog]")
 {
   using T              = int32_t;
@@ -243,4 +243,4 @@ C2H_TEST("Hyperloglog estimate works with pinned memory pool", "[hyperloglog]")
 
   REQUIRE(relative_error < tolerance_factor * relative_standard_deviation);
 }
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
diff --git a/docs/libcudacxx/runtime/legacy_resources.rst b/docs/libcudacxx/runtime/legacy_resources.rst
@@ -16,7 +16,7 @@ For the full memory resource model and property system, see
 .. _libcudacxx-memory-resource-legacy-pinned-memory-resource:
 
 Provides pinned (page-locked) host allocations using ``cudaMallocHost`` and ``cudaFreeHost``. This resource is
-*synchronous-only* and is intended as a compatibility fallback. For CUDA 12.6 and later, prefer
+*synchronous-only* and is intended as a compatibility fallback. For CUDA 12.9 and later, prefer
 ``cuda::pinned_memory_resource``.
 
 .. code:: cpp
diff --git a/docs/libcudacxx/runtime/memory_pools.rst b/docs/libcudacxx/runtime/memory_pools.rst
@@ -9,7 +9,7 @@ Memory pool objects implement the :ref:`cuda::memory_resource <libcudacxx-extend
 
 For the full memory resource model and property system, see :ref:`Memory Resources (Extended API) <libcudacxx-extended-api-memory-resources>`.
 
-Host memory pools are supported on CUDA 12.6 and later. Managed memory pools are supported on CUDA 13.0 and later and are not supported on Windows. For those cases use :ref:`cuda::mr::legacy_pinned_memory_resource <libcudacxx-memory-resource-legacy-pinned-memory-resource>` and :ref:`cuda::mr::legacy_managed_memory_resource <libcudacxx-memory-resource-legacy-managed-memory-resource>` instead.
+Host memory pools are supported on CUDA 12.9 and later. Managed memory pools are supported on CUDA 13.0 and later and are not supported on Windows. For those cases use :ref:`cuda::mr::legacy_pinned_memory_resource <libcudacxx-memory-resource-legacy-pinned-memory-resource>` and :ref:`cuda::mr::legacy_managed_memory_resource <libcudacxx-memory-resource-legacy-managed-memory-resource>` instead.
 
 ``cuda::device_memory_pool``
 ----------------------------
@@ -102,7 +102,7 @@ Availability: CCCL 3.2.0 / CUDA 13.2 (requires CTK 13.0+). Not supported on Wind
 
 ``cuda::pinned_memory_pool`` allocates pinned (page-locked) host memory using CUDA's memory pool API. Pinned memory enables faster host-to-device transfers and can be accessed from all devices. The pool can be optionally created for a specific host NUMA node.
 
-Availability: CCCL 3.2.0 / CUDA 13.2 (requires CTK 12.6+)
+Availability: CCCL 3.2.0 / CUDA 13.2 (requires CTK 12.9+)
 
 Example:
 
@@ -137,7 +137,7 @@ Example:
 
 ``cuda::pinned_memory_pool_ref`` is a non-owning reference to a pinned memory pool.
 
-Availability: CCCL 3.2.0 / CUDA 13.2 (requires CTK 12.6+)
+Availability: CCCL 3.2.0 / CUDA 13.2 (requires CTK 12.9+)
 
 Default Memory Pools
 --------------------
diff --git a/libcudacxx/include/cuda/__memory_pool/memory_pool_base.h b/libcudacxx/include/cuda/__memory_pool/memory_pool_base.h
@@ -178,7 +178,7 @@ inline bool __is_host_memory_pool_supported()
   // of the default pool just to be sure
 #  if _CCCL_CTK_AT_LEAST(13, 0)
   return ::cuda::device_attributes::host_memory_pools_supported(cuda::device_ref{0});
-#  elif _CCCL_CTK_AT_LEAST(12, 6)
+#  elif _CCCL_CTK_AT_LEAST(12, 9)
   return ::cuda::device_attributes::host_numa_memory_pools_supported(cuda::device_ref{0});
 #  else
   return false;
@@ -206,12 +206,12 @@ inline void __verify_device_supports_stream_ordered_allocations(
     ::cuda::__throw_cuda_error(::cudaErrorNotSupported, "managed memory pools are not supported");
   }
 #  endif // _CCCL_CTK_AT_LEAST(13, 0)
-#  if _CCCL_CTK_AT_LEAST(12, 6)
+#  if _CCCL_CTK_AT_LEAST(12, 9)
   if (__location.type == ::CU_MEM_LOCATION_TYPE_HOST && !__is_host_memory_pool_supported())
   {
     ::cuda::__throw_cuda_error(::cudaErrorNotSupported, "host memory pools are not supported");
   }
-#  endif // _CCCL_CTK_AT_LEAST(12, 6)
+#  endif // _CCCL_CTK_AT_LEAST(12, 9)
 }
 
 //! @brief Check whether the specified `cudaMemAllocationHandleType` is
@@ -228,7 +228,7 @@ inline void __verify_device_supports_export_handle_type(
     return;
   }
   if (__location.type != ::CU_MEM_LOCATION_TYPE_DEVICE
-#  if _CCCL_CTK_AT_LEAST(12, 6)
+#  if _CCCL_CTK_AT_LEAST(12, 9)
       && __location.type != ::CU_MEM_LOCATION_TYPE_HOST_NUMA
 #  endif
   )
diff --git a/libcudacxx/include/cuda/__memory_pool/pinned_memory_pool.h b/libcudacxx/include/cuda/__memory_pool/pinned_memory_pool.h
@@ -36,7 +36,7 @@
 //! allocates pinned memory.
 _CCCL_BEGIN_NAMESPACE_CUDA
 
-#  if _CCCL_CTK_AT_LEAST(12, 6)
+#  if _CCCL_CTK_AT_LEAST(12, 9)
 
 _CCCL_DIAG_PUSH
 _CCCL_DIAG_SUPPRESS_CLANG("-Wmissing-braces")
@@ -205,7 +205,7 @@ static_assert(::cuda::mr::resource_with<pinned_memory_pool, ::cuda::mr::host_acc
 
 _CCCL_DIAG_POP
 
-#  endif // _CCCL_CTK_AT_LEAST(12, 6)
+#  endif // _CCCL_CTK_AT_LEAST(12, 9)
 
 _CCCL_END_NAMESPACE_CUDA
 
diff --git a/libcudacxx/include/cuda/__memory_resource/legacy_pinned_memory_resource.h b/libcudacxx/include/cuda/__memory_resource/legacy_pinned_memory_resource.h
@@ -38,7 +38,7 @@
 _CCCL_BEGIN_NAMESPACE_CUDA_MR
 
 //! @brief legacy_pinned_memory_resource uses `cudaMallocHost` / `cudaFreeAsync` for allocation / deallocation.
-//! @note This memory resource will be deprecated in the future. For CUDA 12.6 and above, use
+//! @note This memory resource will be deprecated in the future. For CUDA 12.9 and above, use
 //! `cuda::pinned_memory_resource` instead, which is the long-term replacement.
 class legacy_pinned_memory_resource
 {
diff --git a/libcudacxx/test/libcudacxx/cuda/containers/buffer/constructor.cu b/libcudacxx/test/libcudacxx/cuda/containers/buffer/constructor.cu
@@ -465,7 +465,7 @@ C2H_CCCLRT_TEST("cuda::buffer constructors with legacy resource", "[container][b
   STATIC_CHECK(!decltype(buffer2)::properties_list::has_property(cuda::mr::device_accessible{}));
 }
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 C2H_CCCLRT_TEST("cuda::make_buffer narrowing properties", "[container][buffer]")
 {
   if (!cuda::__is_host_memory_pool_supported())
@@ -492,7 +492,7 @@ C2H_CCCLRT_TEST("cuda::make_buffer narrowing properties", "[container][buffer]")
   CCCLRT_CHECK(equal_range(buf_host));
   CCCLRT_CHECK(buf_device.size() == 2);
 }
-#endif // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^
+#endif // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^
 
 C2H_CCCLRT_TEST("cuda::make_buffer with memory_pool_ref", "[container][buffer]")
 {
diff --git a/libcudacxx/test/libcudacxx/cuda/containers/buffer/helper.h b/libcudacxx/test/libcudacxx/cuda/containers/buffer/helper.h
@@ -189,11 +189,11 @@ struct extract_properties<cuda::buffer<T, Properties...>>
   {
     if constexpr (cuda::mr::__is_host_accessible<Properties...>)
     {
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
       return offset_by_alignment_resource(cuda::pinned_default_memory_pool());
-#else // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^ / vvv _CCCL_CTK_BELOW(12, 6) vvv
+#else // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^ / vvv _CCCL_CTK_BELOW(12, 9) vvv
       throw std::runtime_error("Host accessible memory pools are not supported");
-#endif // ^^^ _CCCL_CTK_BELOW(12, 6) ^^^
+#endif // ^^^ _CCCL_CTK_BELOW(12, 9) ^^^
     }
     else
     {
@@ -220,12 +220,12 @@ struct extract_properties<cuda::buffer<T, Properties...>>
   using matching_resource = memory_resource_wrapper<other_property, Properties...>;
 };
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 using test_types = c2h::type_list<cuda::buffer<int, cuda::mr::host_accessible>,
                                   cuda::buffer<unsigned long long, cuda::mr::device_accessible>,
                                   cuda::buffer<int, cuda::mr::host_accessible, cuda::mr::device_accessible>>;
-#else // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^ / vvv _CCCL_CTK_BELOW(12, 6) vvv
+#else // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^ / vvv _CCCL_CTK_BELOW(12, 9) vvv
 using test_types = c2h::type_list<cuda::buffer<int, cuda::mr::device_accessible>>;
-#endif // ^^^ _CCCL_CTK_BELOW(12, 6) ^^^
+#endif // ^^^ _CCCL_CTK_BELOW(12, 9) ^^^
 
 #endif // CUDA_TEST_CONTAINER_VECTOR_HELPER_H
diff --git a/libcudacxx/test/libcudacxx/cuda/containers/buffer/properties.cu b/libcudacxx/test/libcudacxx/cuda/containers/buffer/properties.cu
@@ -20,14 +20,14 @@
 #include "helper.h"
 #include "types.h"
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 using property_test_types =
   c2h::type_list<cuda::buffer<int, cuda::mr::host_accessible>,
                  cuda::buffer<int, cuda::mr::device_accessible>,
                  cuda::buffer<int, cuda::mr::host_accessible, cuda::mr::device_accessible>>;
-#else // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^ / vvv _CCCL_CTK_BELOW(12, 6) vvv
+#else // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^ / vvv _CCCL_CTK_BELOW(12, 9) vvv
 using property_test_types = c2h::type_list<cuda::buffer<int, cuda::mr::device_accessible>>;
-#endif // ^^^ _CCCL_CTK_BELOW(12, 6) ^^^
+#endif // ^^^ _CCCL_CTK_BELOW(12, 9) ^^^
 
 C2H_CCCLRT_TEST("cuda::buffer properties", "[container][buffer]", property_test_types)
 {
diff --git a/libcudacxx/test/libcudacxx/cuda/memory_resource/resources/memory_pools.cu b/libcudacxx/test/libcudacxx/cuda/memory_resource/resources/memory_pools.cu
@@ -21,11 +21,11 @@
 
 #if _CCCL_CTK_AT_LEAST(13, 0) && !_CCCL_OS(WINDOWS)
 #  define TEST_TYPES cuda::managed_memory_pool, cuda::device_memory_pool, cuda::pinned_memory_pool
-#elif _CCCL_CTK_AT_LEAST(12, 6)
+#elif _CCCL_CTK_AT_LEAST(12, 9)
 #  define TEST_TYPES cuda::device_memory_pool, cuda::pinned_memory_pool
-#else // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^ / vvv _CCCL_CTK_BELOW(12, 6)
+#else // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^ / vvv _CCCL_CTK_BELOW(12, 9)
 #  define TEST_TYPES cuda::device_memory_pool
-#endif // ^^^ _CCCL_CTK_BELOW(12, 6) ^^^
+#endif // ^^^ _CCCL_CTK_BELOW(12, 9) ^^^
 
 // check if pinned and managed pools are supported
 
@@ -45,9 +45,9 @@ void pool_static_asserts()
 #if _CCCL_CTK_AT_LEAST(13, 0)
 template void pool_static_asserts<cuda::managed_memory_pool>();
 #endif // _CCCL_CTK_AT_LEAST(13, 0)
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 template void pool_static_asserts<cuda::pinned_memory_pool>();
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
 template void pool_static_asserts<cuda::device_memory_pool>();
 
 #if _CCCL_CTK_AT_LEAST(13, 0)
@@ -65,7 +65,7 @@ PoolType construct_pool([[maybe_unused]] int device_id, cuda::memory_pool_proper
   }
   else
   {
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
     if constexpr (cuda::std::is_same_v<PoolType, cuda::pinned_memory_pool>)
     {
       return cuda::pinned_memory_pool(0, props);
@@ -76,7 +76,7 @@ PoolType construct_pool([[maybe_unused]] int device_id, cuda::memory_pool_proper
       return cuda::managed_memory_pool(props);
 #  endif // _CCCL_CTK_AT_LEAST(13, 0)
     }
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
   }
 }
 
@@ -199,7 +199,7 @@ C2H_CCCLRT_TEST_LIST("device_memory_pool construction", "[memory_resource]", TES
       pool_properties.location.type = ::cudaMemLocationTypeDevice;
       pool_properties.location.id   = current_device;
     }
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
     else if (cuda::std::is_same_v<memory_pool, cuda::pinned_memory_pool>)
     {
       pool_properties.allocType     = ::cudaMemAllocationTypePinned;
@@ -214,7 +214,7 @@ C2H_CCCLRT_TEST_LIST("device_memory_pool construction", "[memory_resource]", TES
       pool_properties.location.id   = 0;
     }
 #  endif // _CCCL_CTK_AT_LEAST(13, 0)
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
     else
     {
       REQUIRE(false);
@@ -598,7 +598,7 @@ C2H_CCCLRT_TEST("device_memory_pool::enable_access", "[memory_resource]")
   }
 }
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 C2H_CCCLRT_TEST("pinned_memory_pool::enable_access", "[memory_resource]")
 {
   cuda::pinned_memory_pool pool{0};
@@ -611,7 +611,7 @@ C2H_CCCLRT_TEST("pinned_memory_pool::enable_access", "[memory_resource]")
   // pool.enable_access_from(cuda::devices[0]);
   // CCCLRT_CHECK(pool.is_accessible_from(cuda::devices[0]));
 }
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
 
 #if !_CCCL_OS(WINDOWS)
 C2H_CCCLRT_TEST("device_memory_pool with allocation handle", "[memory_resource]")
@@ -643,7 +643,7 @@ C2H_CCCLRT_TEST("device_memory_pool with allocation handle", "[memory_resource]"
   CHECK(ensure_export_handle(get, static_cast<cudaMemAllocationHandleType>(props.allocation_handle_type)));
 }
 
-#  if _CCCL_CTK_AT_LEAST(12, 6)
+#  if _CCCL_CTK_AT_LEAST(12, 9)
 C2H_CCCLRT_TEST("pinned_memory_pool with allocation handle", "[memory_resource]")
 {
   if (!(cuda::device_attributes::memory_pool_supported_handle_types(cuda::devices[0])
@@ -666,7 +666,7 @@ C2H_CCCLRT_TEST("pinned_memory_pool with allocation handle", "[memory_resource]"
   // Ensure that we disable export
   CHECK(ensure_export_handle(get, static_cast<cudaMemAllocationHandleType>(props.allocation_handle_type)));
 }
-#  endif // _CCCL_CTK_AT_LEAST(12, 6)
+#  endif // _CCCL_CTK_AT_LEAST(12, 9)
 
 // managed memory pool does not support allocation handles yet.
 #endif // !_CCCL_OS(WINDOWS)
diff --git a/libcudacxx/test/libcudacxx/cuda/memory_resource/resources/pinned_memory_resource.cu b/libcudacxx/test/libcudacxx/cuda/memory_resource/resources/pinned_memory_resource.cu
@@ -19,11 +19,11 @@
 
 #include "common_tests.cuh"
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 #  define TEST_TYPES cuda::mr::legacy_pinned_memory_resource, cuda::pinned_memory_pool_ref
-#else // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^ / vvv _CCCL_CTK_BELOW(12, 6) vvv
+#else // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^ / vvv _CCCL_CTK_BELOW(12, 9) vvv
 #  define TEST_TYPES cuda::mr::legacy_pinned_memory_resource
-#endif // ^^^ _CCCL_CTK_BELOW(12, 6) ^^^
+#endif // ^^^ _CCCL_CTK_BELOW(12, 9) ^^^
 
 template <typename Resource>
 void resource_static_asserts()
@@ -42,20 +42,20 @@ void resource_static_asserts()
 }
 
 template void resource_static_asserts<cuda::mr::legacy_pinned_memory_resource>();
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 template void resource_static_asserts<cuda::pinned_memory_pool_ref>();
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
 
 template <class Resource>
 Resource get_resource()
 {
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
   if constexpr (cuda::std::is_same_v<Resource, cuda::pinned_memory_pool_ref>)
   {
     return cuda::pinned_default_memory_pool();
   }
   else
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
   {
     return Resource{};
   }
@@ -77,12 +77,12 @@ C2H_CCCLRT_TEST_LIST("pinned_memory_resource allocation", "[memory_resource]", T
 {
   using pinned_resource = TestType;
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
   if (!cuda::__is_host_memory_pool_supported() && cuda::std::is_same_v<pinned_resource, cuda::pinned_memory_pool_ref>)
   {
     return;
   }
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
   pinned_resource res = get_resource<pinned_resource>();
   cuda::stream stream{cuda::device_ref{0}};
 
@@ -231,10 +231,10 @@ C2H_CCCLRT_TEST_LIST("pinned_memory_resource comparison", "[memory_resource]", T
   }
 }
 
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 C2H_CCCLRT_TEST("pinned_memory_resource async.deallocate_sync", "[memory_resource]")
 {
   cuda::pinned_memory_pool_ref resource = cuda::pinned_default_memory_pool();
   test_deallocate_async(resource);
 }
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
diff --git a/libcudacxx/test/libcudacxx/cuda/memory_resource/synchronous_adapter.cu b/libcudacxx/test/libcudacxx/cuda/memory_resource/synchronous_adapter.cu
@@ -70,18 +70,18 @@ C2H_CCCLRT_TEST("synchronous_resource_adapter", "[memory_resource]")
   }
   SECTION("test property passing through")
   {
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
     STATIC_CHECK(same_properties<cuda::pinned_memory_pool_ref>);
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
     STATIC_CHECK(same_properties<cuda::device_memory_pool_ref>);
     STATIC_CHECK(same_properties<cuda::mr::legacy_pinned_memory_resource>);
     STATIC_CHECK(same_properties<small_resource>);
   }
   SECTION("test default queries")
   {
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
     STATIC_CHECK(same_default_queries<cuda::pinned_memory_pool_ref>);
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
     STATIC_CHECK(same_default_queries<cuda::device_memory_pool_ref>);
     STATIC_CHECK(same_default_queries<cuda::mr::legacy_pinned_memory_resource>);
     STATIC_CHECK(same_default_queries<small_resource>);
diff --git a/libcudacxx/test/support/test_resources.h b/libcudacxx/test/support/test_resources.h
@@ -29,9 +29,9 @@ struct other_property
 // make the cudax resources have that property for tests
 inline void get_property(const cuda::device_memory_pool_ref&, other_property) {}
 inline void get_property(const cuda::mr::legacy_pinned_memory_resource&, other_property) {}
-#if _CCCL_CTK_AT_LEAST(12, 6)
+#if _CCCL_CTK_AT_LEAST(12, 9)
 inline void get_property(const cuda::pinned_memory_pool_ref&, other_property) {}
-#endif // _CCCL_CTK_AT_LEAST(12, 6)
+#endif // _CCCL_CTK_AT_LEAST(12, 9)
 
 //! @brief Simple wrapper around a memory resource to ensure that it compares
 //! differently and we can test those code paths

Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,7 @@ C2H_TEST("HyperLogLog precision constructor", "[hyperloglog]")`
`215`	`215`	`REQUIRE(estimator.estimate() == 0);`
`216`	`216`	`}`
`217`	`217`
`218`		`-#if _CCCL_CTK_AT_LEAST(12, 6) // Pinned memory resource is only supported with CTK 12.6 and later`
	`218`	`+#if _CCCL_CTK_AT_LEAST(12, 9) // Pinned memory resource is only supported with CTK 12.9 and later`
`219`	`219`	`C2H_TEST("Hyperloglog estimate works with pinned memory pool", "[hyperloglog]")`
`220`	`220`	`{`
`221`	`221`	`using T = int32_t;`
`@@ -243,4 +243,4 @@ C2H_TEST("Hyperloglog estimate works with pinned memory pool", "[hyperloglog]")`
`243`	`243`
`244`	`244`	`REQUIRE(relative_error < tolerance_factor * relative_standard_deviation);`
`245`	`245`	`}`
`246`		`-#endif // _CCCL_CTK_AT_LEAST(12, 6)`
	`246`	`+#endif // _CCCL_CTK_AT_LEAST(12, 9)`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ inline bool __is_host_memory_pool_supported()`
`178`	`178`	`// of the default pool just to be sure`
`179`	`179`	`# if _CCCL_CTK_AT_LEAST(13, 0)`
`180`	`180`	`return ::cuda::device_attributes::host_memory_pools_supported(cuda::device_ref{0});`
`181`		`-# elif _CCCL_CTK_AT_LEAST(12, 6)`
	`181`	`+# elif _CCCL_CTK_AT_LEAST(12, 9)`
`182`	`182`	`return ::cuda::device_attributes::host_numa_memory_pools_supported(cuda::device_ref{0});`
`183`	`183`	`# else`
`184`	`184`	`return false;`
`@@ -206,12 +206,12 @@ inline void __verify_device_supports_stream_ordered_allocations(`
`206`	`206`	`::cuda::__throw_cuda_error(::cudaErrorNotSupported, "managed memory pools are not supported");`
`207`	`207`	`}`
`208`	`208`	`# endif // _CCCL_CTK_AT_LEAST(13, 0)`
`209`		`-# if _CCCL_CTK_AT_LEAST(12, 6)`
	`209`	`+# if _CCCL_CTK_AT_LEAST(12, 9)`
`210`	`210`	`if (__location.type == ::CU_MEM_LOCATION_TYPE_HOST && !__is_host_memory_pool_supported())`
`211`	`211`	`{`
`212`	`212`	`::cuda::__throw_cuda_error(::cudaErrorNotSupported, "host memory pools are not supported");`
`213`	`213`	`}`
`214`		`-# endif // _CCCL_CTK_AT_LEAST(12, 6)`
	`214`	`+# endif // _CCCL_CTK_AT_LEAST(12, 9)`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	//! @brief Check whether the specified `cudaMemAllocationHandleType` is
`@@ -228,7 +228,7 @@ inline void __verify_device_supports_export_handle_type(`
`228`	`228`	`return;`
`229`	`229`	`}`
`230`	`230`	`if (__location.type != ::CU_MEM_LOCATION_TYPE_DEVICE`
`231`		`-# if _CCCL_CTK_AT_LEAST(12, 6)`
	`231`	`+# if _CCCL_CTK_AT_LEAST(12, 9)`
`232`	`232`	`&& __location.type != ::CU_MEM_LOCATION_TYPE_HOST_NUMA`
`233`	`233`	`# endif`
`234`	`234`	`)`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@`
`38`	`38`	`_CCCL_BEGIN_NAMESPACE_CUDA_MR`
`39`	`39`
`40`	`40`	//! @brief legacy_pinned_memory_resource uses `cudaMallocHost` / `cudaFreeAsync` for allocation / deallocation.
`41`		`-//! @note This memory resource will be deprecated in the future. For CUDA 12.6 and above, use`
	`41`	`+//! @note This memory resource will be deprecated in the future. For CUDA 12.9 and above, use`
`42`	`42`	//! `cuda::pinned_memory_resource` instead, which is the long-term replacement.
`43`	`43`	`class legacy_pinned_memory_resource`
`44`	`44`	`{`
Original file line number	Diff line number	Diff line change
`@@ -465,7 +465,7 @@ C2H_CCCLRT_TEST("cuda::buffer constructors with legacy resource", "[container][b`
`465`	`465`	`STATIC_CHECK(!decltype(buffer2)::properties_list::has_property(cuda::mr::device_accessible{}));`
`466`	`466`	`}`
`467`	`467`
`468`		`-#if _CCCL_CTK_AT_LEAST(12, 6)`
	`468`	`+#if _CCCL_CTK_AT_LEAST(12, 9)`
`469`	`469`	`C2H_CCCLRT_TEST("cuda::make_buffer narrowing properties", "[container][buffer]")`
`470`	`470`	`{`
`471`	`471`	`if (!cuda::__is_host_memory_pool_supported())`
`@@ -492,7 +492,7 @@ C2H_CCCLRT_TEST("cuda::make_buffer narrowing properties", "[container][buffer]")`
`492`	`492`	`CCCLRT_CHECK(equal_range(buf_host));`
`493`	`493`	`CCCLRT_CHECK(buf_device.size() == 2);`
`494`	`494`	`}`
`495`		`-#endif // ^^^ _CCCL_CTK_AT_LEAST(12, 6) ^^^`
	`495`	`+#endif // ^^^ _CCCL_CTK_AT_LEAST(12, 9) ^^^`
`496`	`496`
`497`	`497`	`C2H_CCCLRT_TEST("cuda::make_buffer with memory_pool_ref", "[container][buffer]")`
`498`	`498`	`{`