test(memory): add direct is_managed coverage for ManagedMemoryResource

The existing test_managed_buffer_dlpack_roundtrip_device_type uses a
DummyUnifiedMemoryResource backed by cuMemAllocManaged, which sets
CU_POINTER_ATTRIBUTE_IS_MANAGED and so never exercised the pool-allocated
path that surfaced the bug.

Add two targeted tests:

- test_managed_memory_resource_buffer_dlpack_device_type: allocates from
  ManagedMemoryResource (cuMemAllocFromPoolAsync on a managed pool) and
  asserts is_managed and kDLCUDAManaged through Buffer and view.
- test_non_managed_resources_report_not_managed: parametrized smoke test
  ensuring DeviceMemoryResource and PinnedMemoryResource still report
  is_managed=False so the new MemoryResource.is_managed default does not
  silently misclassify non-managed resources.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: cpcloud

cuda_core/tests/test_memory.py

@@ -605,6 +605,51 @@ def test_managed_buffer_dlpack_roundtrip_device_type():
     assert view.__dlpack_device__() == (int(DLDeviceType.kDLCUDAManaged), 0)
 
 
+def test_managed_memory_resource_buffer_dlpack_device_type():
+    """Verify that pool-allocated managed memory reports kDLCUDAManaged.
+
+    Allocations from ManagedMemoryResource go through cuMemAllocFromPoolAsync
+    on a CU_MEM_ALLOCATION_TYPE_MANAGED pool, which does not set
+    CU_POINTER_ATTRIBUTE_IS_MANAGED.  The Buffer must still report itself as
+    managed via its memory resource so that DLPack consumers (e.g. CCCL's
+    make_tma_descriptor) accept the buffer.
+    """
+    device = Device()
+    device.set_current()
+    skip_if_managed_memory_unsupported(device)
+    mr = create_managed_memory_resource_or_skip(
+        ManagedMemoryResourceOptions(preferred_location=device.device_id)
+    )
+    buf = mr.allocate(1024)
+
+    assert mr.is_managed
+    assert buf.is_managed
+    assert buf.__dlpack_device__() == (DLDeviceType.kDLCUDAManaged, 0)
+
+    view = StridedMemoryView.from_any_interface(buf, stream_ptr=-1)
+    assert view.__dlpack_device__() == (int(DLDeviceType.kDLCUDAManaged), 0)
+
+
+@pytest.mark.parametrize(
+    ("mr_factory", "expected_managed"),
+    [
+        (lambda dev: DeviceMemoryResource(dev), False),
+        (lambda dev: PinnedMemoryResource(), False),
+    ],
+)
+def test_non_managed_resources_report_not_managed(mr_factory, expected_managed):
+    """Non-managed memory resources must report is_managed=False."""
+    device = Device()
+    device.set_current()
+    if not device.properties.memory_pools_supported:
+        pytest.skip("Device does not support mempool operations")
+    mr = mr_factory(device)
+    assert mr.is_managed is expected_managed
+    buf = mr.allocate(1024)
+    assert buf.is_managed is expected_managed
+    buf.close()
+
+
 @pytest.mark.parametrize("use_device_object", [True, False])
 def test_device_memory_resource_initialization(use_device_object):
     """Test that DeviceMemoryResource can be initialized successfully.