nvmath-python 1.0.0__cp314-cp314t-win_amd64.whl

nvmath/internal/ndbuffer/copy_kernel/elementwise.h

@@ -0,0 +1,53 @@
+// Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef NVMATH_COPY_KERNEL_ELEMENTWISE_H
+#define NVMATH_COPY_KERNEL_ELEMENTWISE_H
+
+#include "args.h"
+#include "copy_kernel_impl/array_view.h"
+#include "copy_kernel_impl/elementwise.h"
+#include "copy_kernel_impl/grid_indexer.h"
+#include "copy_kernel_impl/type_utils.h"
+#include "copy_kernel_impl/utils.h"
+#include "copy_kernel_impl/vec.h"
+
+#define ELEMENTWISE_KERNEL(stride_t, dst_ndim, src_ndim, itemsize, needs_grid_stride_loop)                             \
+  extern "C" {                                                                                                         \
+  constexpr int N = dst_ndim > src_ndim ? dst_ndim : src_ndim;                                                         \
+  void __global__ elementwise_copy(const nvmath::KernelArgs<N> args) {                                                 \
+    nvmath::elementwise_copy<nvmath::##stride_t, dst_ndim, src_ndim, itemsize, needs_grid_stride_loop> kernel;         \
+    kernel(args);                                                                                                      \
+  }                                                                                                                    \
+  }
+
+namespace nvmath {
+
+template <typename stride_t, int dst_ndim, int src_ndim, int itemsize, int needs_grid_stride_loop>
+struct elementwise_copy {
+  using dtype_t = opaque_t<itemsize>;
+  using dst_coords_t = vec<dst_ndim, stride_t>;
+  using src_coords_t = vec<src_ndim, stride_t>;
+  using dst_array_view_t = array_view<dtype_t, dst_coords_t>;
+  using src_array_view_t = array_view<const dtype_t, src_coords_t>;
+  using grid_indexer_t = element_indexer<stride_t, needs_grid_stride_loop>;
+  constexpr static bool has_equal_shapes = dst_ndim == src_ndim;
+  constexpr static int ndim = dst_ndim > src_ndim ? dst_ndim : src_ndim;
+
+  void __forceinline__ __device__ operator()(const KernelArgs<ndim> args) {
+    dst_coords_t dst_shape{args.dst_shape};
+    src_coords_t src_shape{args.src_shape};
+    dst_coords_t dst_strides{args.dst_strides};
+    src_coords_t src_strides{args.src_strides};
+    dst_array_view_t dst_array_view{static_cast<dtype_t *>(args.dst_ptr), std::move(dst_shape), std::move(dst_strides)};
+    src_array_view_t src_array_view{static_cast<const dtype_t *>(args.src_ptr), std::move(src_shape),
+                                    std::move(src_strides)};
+    auto kernel = elementwise_copy_impl<has_equal_shapes, dst_array_view_t, src_array_view_t, grid_indexer_t>{};
+    kernel(std::move(dst_array_view), std::move(src_array_view), grid_indexer_t{static_cast<stride_t>(args.grid_arg)});
+  }
+};
+
+} // namespace nvmath
+
+#endif // NVMATH_COPY_KERNEL_ELEMENTWISE_H

nvmath/internal/ndbuffer/copy_kernel/transposed.h

@@ -0,0 +1,58 @@
+// Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef NVMATH_COPY_KERNEL_TRANSPOSED_H
+#define NVMATH_COPY_KERNEL_TRANSPOSED_H
+
+#include "args.h"
+#include "copy_kernel_impl/array_view.h"
+#include "copy_kernel_impl/grid_indexer.h"
+#include "copy_kernel_impl/transposed.h"
+#include "copy_kernel_impl/type_utils.h"
+#include "copy_kernel_impl/utils.h"
+#include "copy_kernel_impl/vec.h"
+
+#define TRANSPOSE_KERNEL(stride_t, ndim, itemsize, needs_grid_stride_loop, transposed_dim, tile_y, tile_x,             \
+                         reading_order)                                                                                \
+  extern "C" {                                                                                                         \
+  void __global__ transpose_copy(const nvmath::KernelArgs<ndim> args) {                                                \
+    nvmath::transpose_copy<nvmath::##stride_t, ndim, itemsize, needs_grid_stride_loop, transposed_dim, tile_y, tile_x, \
+                           reading_order>                                                                              \
+        kernel;                                                                                                        \
+    kernel(args);                                                                                                      \
+  }                                                                                                                    \
+  }
+
+namespace nvmath {
+
+template <typename stride_t, int ndim, int itemsize, int needs_grid_stride_loop, int transposed_dim, int tile_y,
+          int tile_x, char reading_order>
+struct transpose_copy {
+  using dtype_t = opaque_t<itemsize>;
+  using coords_t = vec<ndim, stride_t>;
+  using dst_array_view_t = array_view<dtype_t, coords_t>;
+  using src_array_view_t = array_view<const dtype_t, coords_t>;
+  using grid_indexer_t = block_indexer<stride_t, needs_grid_stride_loop>;
+  static_assert(tile_y > 0 && tile_x > 0, "tile_y and tile_x must be positive");
+  using copy_helper_t = detail::transpose2d<dtype_t, stride_t, transposed_dim, tile_y, tile_x, reading_order>;
+
+  void __forceinline__ __device__ operator()(const KernelArgs<ndim> args) {
+    __shared__ stride_t dst_offsets[copy_helper_t::tile_num_elements];
+    __shared__ dtype_t shared_data[copy_helper_t::tile_num_elements];
+    coords_t dst_shape{args.dst_shape};
+    coords_t src_shape{args.src_shape};
+    coords_t dst_strides{args.dst_strides};
+    coords_t src_strides{args.src_strides};
+    dst_array_view_t dst_array_view{static_cast<dtype_t *>(args.dst_ptr), std::move(dst_shape), std::move(dst_strides)};
+    src_array_view_t src_array_view{static_cast<const dtype_t *>(args.src_ptr), std::move(src_shape),
+                                    std::move(src_strides)};
+    auto kernel = transpose_copy_impl<dst_array_view_t, src_array_view_t, grid_indexer_t, copy_helper_t>{};
+    kernel(std::move(dst_array_view), std::move(src_array_view), grid_indexer_t{static_cast<stride_t>(args.grid_arg)},
+           copy_helper_t{shared_data, dst_offsets});
+  }
+};
+
+} // namespace nvmath
+
+#endif // NVMATH_COPY_KERNEL_TRANSPOSED_H

nvmath/internal/package_ifc.py

@@ -0,0 +1,168 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+An abstract interface to certain package-provided operations.
+
+Even though cuda.core does not have the concept of a "current stream" or a "stream context",
+we promise to honor third-party CUDA stream contexts if they match the input operand's
+package. The interface class defined in this module wraps around those stream concepts to
+make them uniform.
+
+The strategy is to use cuda.core everywhere internally except for context managers which
+will need to wrap back around to the external implementation.
+"""
+
+__all__ = ["Package", "StreamHolder"]
+
+from abc import ABC, abstractmethod
+from collections.abc import Hashable
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from typing import Generic, Protocol, TypeVar
+
+from cuda.core import Stream
+
+from ._device_utils import get_device
+
+
+class AnyStream(Hashable, Protocol):
+    """Any supported Stream object such as a Stream from cuda.core, CuPy, or PyTorch."""
+
+    # This empty protocol class is just a placeholder to make type checking more helpful.
+    # Since the class is empty, it doesn't assume anything is true about the implementation
+    # classes.
+    pass
+
+
+"""
+A generic type for the third-party Stream which a given Package implementation wraps
+around.
+"""
+S = TypeVar("S")
+
+
+# CUDA stream protocol version, see
+# https://nvidia.github.io/cuda-python/cuda-core/latest/interoperability.html#cuda-stream-protocol
+_CUDA_STREAM_PROTOCOL_VERSION = 0
+
+
+class _cuda_core_stream_holder(Generic[S]):
+    """
+    Expose a raw ``cudaStream_t`` handle through the CUDA stream protocol.
+
+    This adapter can be passed to consumers that accept the protocol, such as
+    ``cuda.core.Device.create_stream`` or ``cp.cuda.Stream.from_external``.
+
+    Args:
+        handle: The raw ``cudaStream_t`` value to expose.
+        external: Optional object that owns or keeps ``handle`` alive. The
+            holder stores a strong reference to this object but does not
+            otherwise use it. Pass ``None`` when the consumer only reads the
+            protocol immediately, or when the stream lifetime is guaranteed
+            elsewhere.
+    """
+
+    __slots__ = ("external", "handle")
+
+    def __init__(self, handle: int, external: S | None = None):
+        self.handle = handle
+        self.external = external
+
+    def __cuda_stream__(self):
+        return (_CUDA_STREAM_PROTOCOL_VERSION, self.handle)
+
+
+class Package(ABC, Generic[S]):
+    @staticmethod
+    @abstractmethod
+    def get_current_stream(device_id: int) -> S:
+        """
+        Obtain the current stream on the device.
+
+        Args:
+            device_id: The id (ordinal) of the device.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def to_stream_pointer(stream: S) -> int:
+        """
+        Obtain the stream pointer.
+
+        Args:
+            stream: The stream object.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def get_current_stream_ptr(device_id: int) -> int:
+        """
+        Return the raw ``cudaStream_t`` int for the current stream on ``device_id``.
+
+        Args:
+            device_id: The id (ordinal) of the device.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def to_stream_context(stream: S) -> AbstractContextManager[S]:
+        """
+        Create a context manager from the stream.
+
+        Args:
+            stream: The stream object.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def create_external_stream(device_id: int, stream_ptr: int) -> S:
+        """
+        Wrap a stream pointer into an external stream object.
+
+        Args:
+            device_id: The id (ordinal) of the device.
+            stream: The stream pointer (int) to be wrapped.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def create_stream(cls, external: S, device_id: int) -> Stream:
+        """
+        Wrap an external Stream object into a cuda.core.Stream.
+
+        Args:
+            external: The external Stream object.
+        """
+        # use get_device to ensure the initial set_current is called
+        device = get_device(device_id)
+        # the stream holder ensures we tie the external reference to the
+        # cuda.core stream object, extending its lifetime.
+        holder = _cuda_core_stream_holder(cls.to_stream_pointer(external), external)
+        return device.create_stream(holder)
+
+
+@dataclass
+class StreamHolder(Generic[S]):
+    """A data class for easing CUDA stream manipulation.
+
+    Attributes:
+        ctx: A context manager for using the specified stream.
+        device_id (int): The device ID where the encapsulated stream locates.
+        external: A foreign object that holds the stream alive.
+        obj: The cuda.core Stream object wrapping external.
+        package (str): The name of the package to which the external stream belongs.
+        ptr (int): The address of the underlying ``cudaStream_t`` object.
+    """
+
+    ctx: AbstractContextManager[S]
+    device_id: int
+    external: S
+    obj: Stream
+    package: str
+    ptr: int

nvmath/internal/package_ifc_cuda.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Interface to cuda.core operations.
+"""
+
+__all__ = ["CUDAPackage"]
+
+import contextlib
+import functools
+
+from cuda.core import Stream
+
+from ._device_utils import get_device
+from .package_ifc import Package
+
+
+# cuda.core's ``Device.default_stream`` wraps a CUDA driver *sentinel* pointer
+# (``CU_STREAM_LEGACY = 0x1`` or ``CU_STREAM_PER_THREAD = 0x2``) that is constant
+# for the life of the process, so the (device_id -> ptr) map can be cached.
+@functools.cache
+def _get_current_stream_ptr(device_id: int) -> int:
+    return int(get_device(device_id).default_stream.handle)
+
+
+class CUDAPackage(Package[Stream]):
+    @staticmethod
+    def get_current_stream(device_id: int):
+        # Use get_device to ensure the cuda.core
+        # device has been initialized.
+        # In cuda.core 0.5.0, Stream.__hash__ requires context
+        # to be set.
+        # See https://github.com/NVIDIA/cuda-python/issues/1480
+        # TODO(ktokarski): Once we drop support for cuda.core 0.5.0,
+        # we can remove this precaution.
+        device = get_device(device_id)
+        return device.default_stream
+
+    @staticmethod
+    def to_stream_pointer(stream: Stream) -> int:  # type: ignore[override]
+        return int(stream.handle)
+
+    get_current_stream_ptr = staticmethod(_get_current_stream_ptr)
+
+    @staticmethod
+    def to_stream_context(stream: Stream):  # type: ignore[override]
+        return contextlib.nullcontext(stream)
+
+    @staticmethod
+    def create_external_stream(device_id: int, stream_ptr: int) -> Stream:
+        return Stream.from_handle(stream_ptr)
+
+    @classmethod
+    def create_stream(cls, external: Stream, device_id: int) -> Stream:  # type: ignore[override]
+        return external

nvmath/internal/package_ifc_cupy.py

@@ -0,0 +1,67 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Interface to CuPy operations.
+"""
+
+__all__ = ["CupyPackage"]
+
+import cupy as cp
+
+from . import utils
+from .package_ifc import Package, _cuda_core_stream_holder
+
+_CUPY_MAJOR = int(cp.__version__.split(".")[0])
+
+# Using the functional API is faster than setting a device context
+if _CUPY_MAJOR >= 13:
+    _get_current_stream = cp.cuda.get_current_stream
+else:
+
+    def _get_current_stream(device_id: int):
+        with utils.device_ctx(device_id):
+            stream = cp.cuda.get_current_stream()
+        return stream
+
+
+# CuPy v14 deprecated ``cp.cuda.ExternalStream(int)`` in favor of
+# ``cp.cuda.Stream.from_external(obj)``, where ``obj`` must implement the
+# CUDA stream protocol.
+if _CUPY_MAJOR >= 14:
+
+    def _create_external_stream(stream_ptr: int):
+        return cp.cuda.Stream.from_external(_cuda_core_stream_holder(stream_ptr))
+
+else:
+    _create_external_stream = cp.cuda.ExternalStream
+
+
+class CupyPackage(Package[cp.cuda.Stream]):
+    @staticmethod
+    def get_current_stream(device_id: int):
+        return _get_current_stream(device_id)
+
+    @staticmethod
+    def to_stream_pointer(stream: cp.cuda.Stream) -> int:
+        return stream.ptr
+
+    # Goal: return the raw ``cudaStream_t`` int for the current stream on a
+    # given device. CuPy has a binding-level ptr getter at the runtime
+    # layer, but at the time this method was added it was only exposed as
+    # a Cython ``cdef`` function not callable from Python, so we can't
+    # reach it directly. ``cp.cuda.get_current_stream().ptr`` is nearly
+    # as fast empirically because CuPy caches the per-thread Stream object on
+    # ``_ThreadLocal.current_stream``.
+    @staticmethod
+    def get_current_stream_ptr(device_id: int) -> int:
+        return _get_current_stream(device_id).ptr
+
+    @staticmethod
+    def to_stream_context(stream: cp.cuda.Stream):
+        return stream
+
+    @staticmethod
+    def create_external_stream(device_id: int, stream_ptr: int):
+        return _create_external_stream(stream_ptr)

nvmath/internal/package_ifc_torch.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Interface to Torch operations.
+"""
+
+__all__ = ["TorchPackage"]
+
+import torch
+
+from .package_ifc import Package
+
+_TORCH_VERSION = tuple(int(p) for p in torch.__version__.split(".")[:2])
+
+# Goal: return the raw ``cudaStream_t`` int for the current stream on a
+# given device. ``torch.cuda.current_stream(device=...).cuda_stream``
+# does this but allocates a fresh ``torch.cuda.Stream`` Python wrapper
+# just to read one ``int`` off it. As an alternative, torch's C
+# bindings expose ``torch._C._cuda_getCurrentRawStream``, which returns
+# the raw int directly. Being a private symbol it is not guaranteed
+# on every torch build, so we guard with ``hasattr`` and fall back
+# to the other path when absent.
+# This is resolved once at import time, not per call.
+if hasattr(torch._C, "_cuda_getCurrentRawStream"):
+    _get_current_stream_ptr = torch._C._cuda_getCurrentRawStream
+else:
+    # Parameter is named ``device_id`` to match ``Package.get_current_stream_ptr``;
+    # the ``# type: ignore[misc]`` silences mypy's redefinition warning, since
+    # torch's typed signature for ``_cuda_getCurrentRawStream`` calls the
+    # argument ``device`` rather than ``device_id``. The runtime call is
+    # positional, so the name disagreement is purely a typing artifact.
+    def _get_current_stream_ptr(device_id: int) -> int:  # type: ignore[misc]
+        return torch.cuda.current_stream(device=device_id).cuda_stream
+
+
+class TorchPackage(Package[torch.cuda.Stream]):
+    @staticmethod
+    def get_current_stream(device_id: int) -> torch.cuda.Stream:
+        return torch.cuda.current_stream(device=device_id)
+
+    @staticmethod
+    def to_stream_pointer(stream: torch.cuda.Stream) -> int:
+        return stream.cuda_stream
+
+    # Same ``device`` vs ``device_id`` parameter-name disagreement as above:
+    # torch's typed signature uses ``device``, but ``Package`` declares
+    # ``device_id``. Runtime calls are positional, so this is type-only noise.
+    get_current_stream_ptr = staticmethod(_get_current_stream_ptr)  # type: ignore[assignment]
+
+    @staticmethod
+    def to_stream_context(stream: torch.cuda.Stream) -> torch.cuda.StreamContext:
+        return torch.cuda.stream(stream)
+
+    @staticmethod
+    def create_external_stream(device_id: int, stream_ptr: int) -> torch.cuda.Stream:
+        # Issue: ``torch.cuda.ExternalStream(0, ...)`` does not wrap handle
+        # ``0x0`` (= the device default stream). Its C++ ctor treats
+        # ``stream_ptr == 0`` as "no ptr supplied" and silently returns a
+        # fresh pooled stream instead.
+        #
+        # Use ``torch.cuda.get_stream_from_external`` (first shipped in
+        # torch 2.7), which routes through a different C++ path and faithfully
+        # wraps any handle, including ``0x0``. On older torch we leave the
+        # pre-existing buggy behavior in place.
+        if _TORCH_VERSION >= (2, 7):
+            return torch.cuda.get_stream_from_external(stream_ptr, device=device_id)
+        return torch.cuda.ExternalStream(stream_ptr, device=device_id)

nvmath/internal/package_wrapper.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Create map from package names to package interface objects.
+"""
+
+__all__ = ["PACKAGE", "AnyStream", "StreamHolder"]
+
+from .package_ifc import AnyStream, Package, StreamHolder
+from .package_ifc_cuda import CUDAPackage
+
+PACKAGE: dict[str, type[Package]] = {"cuda": CUDAPackage}

nvmath/internal/tensor_ifc.py

@@ -0,0 +1,179 @@
+# Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Interface to seamlessly use tensors (or ndarray-like objects) from different libraries.
+"""
+
+from __future__ import annotations  # allows typehint of class methods to return the self class
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
+from types import ModuleType
+from typing import Any, Generic, Literal, Protocol, TypeVar
+
+from . import typemaps
+from .ndbuffer import NDBuffer
+from .package_ifc import StreamHolder
+
+
+class AnyTensor(Protocol):
+    """Any supported external tensor object such as NumPy, CuPy, and PyTorch arrays."""
+
+    # This empty protocol class is just a placeholder to make type checking more helpful.
+    # Since the class is empty, it doesn't assume anything is true about the implementation
+    # classes. Used to type hint any object that TensorHolder knows how to wrap.
+    pass
+
+
+"""
+A generic type for the third-party Tensor which a given TensorHolder implementation wraps
+around.
+"""
+Tensor = TypeVar("Tensor")
+
+
+class TensorHolder(ABC, Generic[Tensor]):
+    """
+    A simple wrapper type for tensors to make the API package-agnostic.
+
+    Methods of a TensorHolder should always return a TensorHolder instead of a Tensor (one
+    of the wrapped classes) in order to prevent implementation details from the various
+    Tensor implementations from leaking into nvmath-python.
+
+    Tensors from the user should be immediately wrapped with a TensorHolder and should
+    remain wrapped until just before returning to the user.
+    """
+
+    name: str
+    module: ModuleType
+    name_to_dtype: dict[str, Any]
+
+    def __init__(self, tensor: Tensor):
+        self.tensor: Tensor = tensor
+
+    @property
+    @abstractmethod
+    def data_ptr(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def device(self) -> Literal["cuda"] | Literal["cpu"]:
+        """The type of the device which stores the tensor."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def device_id(self) -> int | Literal["cpu"]:
+        """The device ordinal of the device storing the tensor."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def dtype(self) -> str:
+        """Name of the data type"""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def itemsize(self) -> int:
+        """The size of the data type in bytes."""
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def empty(cls, shape: Sequence[int], device_id: int | Literal["cpu"], **context: Any) -> TensorHolder[Tensor]:
+        """Create an empty TensorHolder of the specified shape and data type."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def shape(self) -> Sequence[int]:
+        """The extent of each dimension in number of elements."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def size(self) -> int:
+        """The total number of elements in the tensor."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def strides(self) -> Sequence[int]:
+        """The stride of each dimension in number of elements."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def to(self, device_id: int | Literal["cpu"], stream_holder: StreamHolder | None) -> TensorHolder:
+        """Copy the TensorHolder to a different device.
+
+        No copy is performed if the TensorHolder is already on the requested device.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def asndbuffer(self) -> NDBuffer:
+        """Wraps the package tensor as a NDBuffer object."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def copy_(self, src: TensorHolder, stream_holder: StreamHolder | None) -> None:
+        """Overwrite self.tensor (in-place) with a copy of src."""
+        raise NotImplementedError
+
+    @staticmethod
+    def create_name_dtype_map(conversion_function: Callable[[str], Any], exception_type: type[Exception]) -> dict[str, Any]:
+        """
+        Create a map between CUDA data type names and the corresponding package dtypes for
+        supported data types.
+        """
+        names = typemaps.NAME_TO_DATA_TYPE.keys()
+        name_to_dtype = {}
+        for name in names:
+            try:
+                name_to_dtype[name] = conversion_function(name)
+            except exception_type:
+                pass
+        return name_to_dtype
+
+    @abstractmethod
+    def istensor(self) -> bool:
+        """Return whether self.tensor is the expected type."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def reshape(self, shape: Sequence[int], *, copy: bool | None = None) -> TensorHolder[Tensor]:
+        """Reshapes tensor without changing its data.
+
+        Args:
+            shape: a new shape compatible with the original shape.
+
+            copy (Optional[bool]): whether or not to copy the input tensor. If True, the
+                function must always copy. If False, the function must never copy. If None,
+                the function must avoid copying, if possible, and may copy otherwise.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def memory_buffer(self) -> TensorHolder[Tensor]:
+        """Creates a view of the memory buffer as a 1D tensor."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def memory_buffer_to_tensor(self, shape, strides) -> TensorHolder[Tensor]:
+        """
+        Creates a N-D tensor view of the memory buffer according to the specified
+        shape and strides.
+        """
+        raise NotImplementedError
+
+    @property
+    def is_conjugate(self) -> bool:
+        """Return True when self.tensor has a no-op conjugation flag enabled.
+
+        The default implementation always returns False.
+        """
+        return False