fix(core): compare CUdeviceptr as int so the VMM grow fast path can run

`modify_allocation()` asks `cuMemAddressReserve` for the address immediately
after the current range, then checks whether the driver granted that exact
address before taking the fast path.

`cuMemAddressReserve` returns `new_ptr` as a `CUdeviceptr`. That type defines
`__int__` and `__repr__` but no `__eq__` or `__richcmp__`, so `new_ptr != <int>`
falls back to identity comparison and is unconditionally true. The guard is
therefore always taken and `_grow_allocation_fast_path` is unreachable: every
grow runs the slow path, re-reserving the whole range and remapping it, so the
buffer's base pointer changes even when a contiguous extension was available.

Convert with `int()` before comparing. Reported as defect 2 in #2388.

Two tests cover this:

- `test_cudeviceptr_is_never_equal_to_plain_int` pins the underlying pitfall,
  that `CUdeviceptr(x) == x` is False and call sites must go through `int()`.
- `test_vmm_allocator_grow_dispatches_to_fast_path` stubs `cuMemAddressReserve`
  to grant the requested address and asserts the dispatch reaches the fast path.
  It fails on the current code, which records "slow".

Note this makes a previously unreachable code path live, so it is a behavior
change rather than a pure cleanup: successful contiguous grows now preserve the
base pointer instead of moving it. The existing
`test_vmm_allocator_grow_allocation_fast_path` already exercised
`_grow_allocation_fast_path` directly, so the helper itself is covered; what was
missing was coverage of the dispatch decision that reaches it.

Signed-off-by: Aryan Putta <aryansputta@gmail.com>

Author: aryanputta

cuda_core/cuda/core/_memory/_virtual_memory_resource.py

@@ -265,7 +265,11 @@ def modify_allocation(
             0,
         )
 
-        if res != driver.CUresult.CUDA_SUCCESS or new_ptr != (int(buf.handle) + aligned_prev_size):
+        # `new_ptr` is a `CUdeviceptr`, which defines `__int__` but not `__eq__`, so
+        # comparing it directly against a plain int always evaluates False. Without
+        # the `int()` conversion this branch is always taken and the fast path below
+        # is unreachable, even when the driver granted the requested address.
+        if res != driver.CUresult.CUDA_SUCCESS or int(new_ptr) != (int(buf.handle) + aligned_prev_size):
             # Check for specific errors that are not recoverable with the slow path
             if res in (
                 driver.CUresult.CUDA_ERROR_INVALID_VALUE,

cuda_core/tests/test_memory.py

@@ -1035,6 +1035,65 @@ def __init__(self, size):
     assert ("set_access", new_ptr, aligned_additional, 1) in calls
 
 
+@pytest.mark.agent_authored(model="claude-opus-4-8")
+def test_cudeviceptr_is_never_equal_to_plain_int():
+    """`CUdeviceptr` has `__int__` but no `__eq__`, so `==` against an int is always False.
+
+    Address comparisons against driver return values must go through `int()`.
+    """
+    ptr = driver.CUdeviceptr(0x1000)
+    assert int(ptr) == 0x1000
+    assert ptr != 0x1000
+
+
+@pytest.mark.agent_authored(model="claude-opus-4-8")
+def test_vmm_allocator_grow_dispatches_to_fast_path(init_cuda, monkeypatch):
+    """A contiguous reservation must dispatch to the fast path, not the slow path.
+
+    `cuMemAddressReserve` returns a `CUdeviceptr`. Comparing that object against
+    the plain-int address that was requested is always False, so the dispatch in
+    `modify_allocation` fell through to the slow path (full re-reserve and remap,
+    base pointer changes) even when the driver granted exactly the adjacent range.
+    """
+    device = Device()
+    if not device.properties.virtual_memory_management_supported:
+        pytest.skip("Virtual memory management is not supported on this device")
+
+    vmm_mr = VirtualMemoryResource(
+        device,
+        config=VirtualMemoryResourceOptions(handle_type="win32_kmt" if IS_WINDOWS else "posix_fd"),
+    )
+    try:
+        buffer = vmm_mr.allocate(2 * 1024 * 1024)
+    except NotImplementedError:
+        pytest.skip("handle_type not implemented on this platform")
+
+    # Grant the reservation at exactly the address the caller asked for, which is
+    # the contiguous-extension case the fast path exists to serve.
+    def fake_addr_reserve(size, alignment, addr, flags):
+        return (driver.CUresult.CUDA_SUCCESS, driver.CUdeviceptr(addr))
+
+    chosen = []
+
+    def record_fast(*_args, **_kwargs):
+        chosen.append("fast")
+        return buffer
+
+    def record_slow(*_args, **_kwargs):
+        chosen.append("slow")
+        return buffer
+
+    monkeypatch.setattr(driver, "cuMemAddressReserve", fake_addr_reserve)
+    monkeypatch.setattr(vmm_mr, "_grow_allocation_fast_path", record_fast)
+    monkeypatch.setattr(vmm_mr, "_grow_allocation_slow_path", record_slow)
+
+    try:
+        vmm_mr.modify_allocation(buffer, 4 * 1024 * 1024)
+        assert chosen == ["fast"]
+    finally:
+        buffer.close()
+
+
 def test_vmm_allocator_rdma_unsupported_exception():
     """Test that VirtualMemoryResource throws an exception when RDMA is requested but device doesn't support it.