Add torch.Tensor fast path for StridedMemoryView via AOTI tensor bridge

[leofang]

Summary

Add a fast path for constructing StridedMemoryView from torch.Tensor objects using PyTorch's AOT Inductor (AOTI) stable C ABI, bypassing the DLPack/CAI protocol overhead.

How it works

When a torch.Tensor is passed to any from_* classmethod (from_dlpack, from_cuda_array_interface, from_array_interface, or from_any_interface), the tensor metadata (data pointer, shape, strides, dtype, device) is read directly from the underlying C struct via AOTI function pointers, instead of going through the Python-level __dlpack__() or __cuda_array_interface__ protocols.

The key technique (pyobj_to_aten_handle) extracts the AtenTensorHandle by offsetting past PyObject_HEAD in the THPVariable struct — pure C pointer arithmetic with zero Python API calls. The AOTI functions (aoti_torch_get_data_ptr, aoti_torch_get_sizes, etc.) then read tensor metadata through PyTorch's stable C ABI.

PyTorch is NOT a build-time or runtime dependency. The AOTI symbols are resolved lazily at runtime from torch._C (loaded with RTLD_GLOBAL) only when the user actually passes a torch.Tensor. The _tensor_bridge module is never imported at cuda.core load time.

Performance

Benchmarked with %timeit (Python 3.12, PyTorch 2.11, NVIDIA RTX 6000 Ada):

                          v0.7.0 (DLPack)   tensor-bridge (AOTI)   speedup
GPU tensor stream_ptr=-1:    4.41 us             565 ns              ~8x
GPU tensor stream_ptr=0:    13.20 us             624 ns             ~21x
CPU tensor stream_ptr=-1:    5.08 us             552 ns              ~9x

At the C level (no Python overhead), AOTI extracts all 7 metadata fields in ~14 ns — ~4x faster than the DLPack C exchange API (~60 ns) for the same metadata.

Stream ordering

• AOTI fast path: When stream_ptr != -1, establishes stream ordering between PyTorch's current CUDA stream (queried via aoti_torch_get_current_cuda_stream) and the consumer stream, using the same event-based pattern as the existing CAI path.
• CAI fallback safety: PyTorch's __cuda_array_interface__ reports version 2 with no stream field, making the standard CAI sync path a no-op. We detect torch tensors in the CAI path and apply AOTI-based stream ordering to fix this safety gap.

Version compatibility

• Minimum: PyTorch 2.3 (when the AOTI functions we use were introduced)
• Maximum: PyTorch 2.11 (latest tested; the THPVariable struct layout and AtenTensorHandle == at::Tensor* identity are undocumented internals)
• Unknown versions gracefully fall back to DLPack/CAI paths

Files changed

• cuda/core/_tensor_bridge.pyx (new): AOTI tensor bridge — pyobj_to_aten_handle, view_as_torch_tensor, sync_torch_stream, dtype/itemsize mapping
• cuda/core/_include/aoti_shim.h (new): Vendored subset of PyTorch's AOTI stable C ABI declarations
• cuda/core/_memoryview.pyx: Torch detection (_is_torch_tensor with type cache + version bounds), lazy bridge loading, fast path in all from_* classmethods, CAI stream safety fix, lazy dtype resolution
• tests/test_utils.py: 12 new test cases (dtypes, shapes, slicing, devices, decorator)
• docs/source/release/1.0.0-notes.rst: Release notes entry

Closes #749

Co-Authored-By: Emilio Castillo ecastillo@nvidia.com

Test plan

• All existing tests pass (117 passed, 38 skipped)
• 12 new torch tensor bridge tests pass (CPU + GPU)
• Stream ordering verified for both AOTI and CAI paths
• Graceful fallback for torch < 2.3 (returns False, uses DLPack)
• CI validation

[copy-pr-bot]

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

[leofang]

Note: I have filed a feature request to discuss if this API can be formalized in AOTI directly, so that we can relax upper bound safely and be forward compatible: pytorch/pytorch#180107.