Add files using upload-large-folder tool

.gitattributes

@@ -1791,3 +1791,5 @@ infer_4_30_0/lib/python3.10/site-packages/tiktoken/_tiktoken.cpython-310-x86_64-
 infer_4_30_0/lib/python3.10/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_30_0/lib/python3.10/site-packages/sympy/tensor/__pycache__/tensor.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_tf437/lib/python3.10/site-packages/nvidia/curand/lib/libcurand.so.10 filter=lfs diff=lfs merge=lfs -text
+deepseek/lib/python3.10/site-packages/torch/lib/libtorch_cuda_linalg.so filter=lfs diff=lfs merge=lfs -text
+infer_4_30_0/lib/python3.10/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

deepseek/lib/python3.10/site-packages/torch/lib/libtorch_cuda_linalg.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02f46e8430411ff6e43340722e6c4957554f731833ebcdd00b59c0ea86c412fe
+size 96295585

infer_4_30_0/lib/python3.10/site-packages/cupy/_core/__init__.py

@@ -0,0 +1,79 @@
+# mypy: ignore-errors
+
+from cupy._core import core  # NOQA
+from cupy._core import fusion  # NOQA
+from cupy._core import internal  # NOQA
+
+
+# internal APIs for testing and development
+from cupy._core._accelerator import set_elementwise_accelerators  # NOQA
+from cupy._core._accelerator import set_reduction_accelerators  # NOQA
+from cupy._core._accelerator import set_routine_accelerators  # NOQA
+from cupy._core._accelerator import get_elementwise_accelerators  # NOQA
+from cupy._core._accelerator import get_reduction_accelerators  # NOQA
+from cupy._core._accelerator import get_routine_accelerators  # NOQA
+
+
+# import class and function
+from cupy._core._kernel import create_ufunc  # NOQA
+from cupy._core._kernel import ElementwiseKernel  # NOQA
+from cupy._core._kernel import ufunc  # NOQA
+from cupy._core._kernel import _get_warpsize  # NOQA
+from cupy._core._reduction import create_reduction_func  # NOQA
+from cupy._core._reduction import ReductionKernel  # NOQA
+from cupy._core._routines_binary import bitwise_and  # NOQA
+from cupy._core._routines_binary import bitwise_or  # NOQA
+from cupy._core._routines_binary import bitwise_xor  # NOQA
+from cupy._core._routines_binary import invert  # NOQA
+from cupy._core._routines_binary import left_shift  # NOQA
+from cupy._core._routines_binary import right_shift  # NOQA
+from cupy._core._routines_linalg import _mat_ptrs  # NOQA
+from cupy._core._routines_linalg import dot  # NOQA
+from cupy._core._routines_linalg import get_compute_type  # NOQA
+from cupy._core._routines_linalg import matmul  # NOQA
+from cupy._core._routines_linalg import set_compute_type  # NOQA
+from cupy._core._routines_linalg import tensordot_core  # NOQA
+from cupy._core._routines_logic import create_comparison  # NOQA
+from cupy._core._routines_logic import equal  # NOQA
+from cupy._core._routines_logic import greater  # NOQA
+from cupy._core._routines_logic import greater_equal  # NOQA
+from cupy._core._routines_logic import less  # NOQA
+from cupy._core._routines_logic import less_equal  # NOQA
+from cupy._core._routines_logic import not_equal  # NOQA
+from cupy._core._routines_manipulation import array_split  # NOQA
+from cupy._core._routines_manipulation import broadcast  # NOQA
+from cupy._core._routines_manipulation import broadcast_to  # NOQA
+from cupy._core._routines_manipulation import concatenate_method  # NOQA
+from cupy._core._routines_manipulation import moveaxis  # NOQA
+from cupy._core._routines_manipulation import rollaxis  # NOQA
+from cupy._core._routines_manipulation import size  # NOQA
+from cupy._core._routines_math import absolute  # NOQA
+from cupy._core._routines_math import add  # NOQA
+from cupy._core._routines_math import angle, angle_deg  # NOQA
+from cupy._core._routines_math import conjugate  # NOQA
+from cupy._core._routines_math import divide  # NOQA
+from cupy._core._routines_math import floor_divide  # NOQA
+from cupy._core._routines_math import multiply  # NOQA
+from cupy._core._routines_math import negative  # NOQA
+from cupy._core._routines_math import positive  # NOQA
+from cupy._core._routines_math import power  # NOQA
+from cupy._core._routines_math import remainder  # NOQA
+from cupy._core._routines_math import sqrt  # NOQA
+from cupy._core._routines_math import subtract  # NOQA
+from cupy._core._routines_math import true_divide  # NOQA
+from cupy._core._routines_statistics import nanmax  # NOQA
+from cupy._core._routines_statistics import nanmin  # NOQA
+from cupy._core.core import _internal_ascontiguousarray  # NOQA
+from cupy._core.core import _internal_asfortranarray  # NOQA
+from cupy._core.core import array  # NOQA
+from cupy._core.core import ascontiguousarray  # NOQA
+from cupy._core.core import asfortranarray  # NOQA
+from cupy._core.core import divmod  # NOQA
+from cupy._core.core import elementwise_copy  # NOQA
+from cupy._core.core import ndarray  # NOQA
+from cupy._core.dlpack import fromDlpack  # NOQA
+from cupy._core.dlpack import from_dlpack  # NOQA
+from cupy._core.internal import complete_slice  # NOQA
+from cupy._core.internal import get_size  # NOQA
+from cupy._core.raw import RawKernel  # NOQA
+from cupy._core.raw import RawModule  # NOQA

infer_4_30_0/lib/python3.10/site-packages/cupy/_core/_codeblock.py

@@ -0,0 +1,38 @@
+from typing import Any, List
+
+_CodeType = Any  # TODO(asi1024): Correct type annotation
+
+
+class CodeBlock:
+    """Code fragment for the readable format.
+    """
+
+    def __init__(self, head: str, codes: _CodeType) -> None:
+        self._head = '' if head == '' else head + ' '
+        self._codes = codes
+
+    def _to_str_list(self, indent_width: int = 0) -> List[str]:
+        codes: List[str] = []
+        codes.append(' ' * indent_width + self._head + '{')
+        for code in self._codes:
+            next_indent_width = indent_width + 2
+            if isinstance(code, str):
+                codes.append(' ' * next_indent_width + code)
+            elif isinstance(code, CodeBlock):
+                codes += code._to_str_list(indent_width=next_indent_width)
+            else:
+                assert False
+        codes.append(' ' * indent_width + '}')
+        return codes
+
+    def __str__(self) -> str:
+        """Emit CUDA program like the following format.
+
+        <<head>> {
+          <<begin codes>>
+          ...;
+          <<end codes>>
+        }
+        """
+
+        return '\n'.join(self._to_str_list())

infer_4_30_0/lib/python3.10/site-packages/cupy/_core/syncdetect.py

@@ -0,0 +1,68 @@
+import contextlib
+import threading
+import warnings
+
+
+_thread_local = threading.local()
+
+
+class DeviceSynchronized(RuntimeError):
+    """Raised when device synchronization is detected while disallowed.
+
+    .. warning::
+
+       This API has been deprecated in CuPy v10 and will be removed in future
+       releases.
+
+    .. seealso:: :func:`cupyx.allow_synchronize`
+
+    """
+
+    def __init__(self, message=None):
+        if message is None:
+            message = 'Device synchronization was detected while disallowed.'
+        super().__init__(message)
+
+
+def _is_allowed():
+    # Returns whether device synchronization is allowed in the current thread.
+    try:
+        return _thread_local.allowed
+    except AttributeError:
+        _thread_local.allowed = True
+        return True
+
+
+def _declare_synchronize():
+    # Raises DeviceSynchronized if device synchronization is disallowed in
+    # the current thread.
+    if not _is_allowed():
+        raise DeviceSynchronized()
+
+
+@contextlib.contextmanager
+def allow_synchronize(allow):
+    """Allows or disallows device synchronization temporarily in the current \
+thread.
+
+    .. warning::
+
+       This API has been deprecated in CuPy v10 and will be removed in future
+       releases.
+
+    If device synchronization is detected, :class:`cupyx.DeviceSynchronized`
+    will be raised.
+
+    Note that there can be false negatives and positives.
+    Device synchronization outside CuPy will not be detected.
+    """
+    warnings.warn(
+        'cupyx.allow_synchronize will be removed in future releases as it '
+        'is not possible to reliably detect synchronizations.')
+
+    old = _is_allowed()
+    _thread_local.allowed = allow
+    try:
+        yield
+    finally:
+        _thread_local.allowed = old

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/__init__.py

@@ -0,0 +1,202 @@
+import contextlib
+import warnings
+
+import cupy as _cupy
+from cupy._environment import get_cuda_path  # NOQA
+from cupy._environment import get_nvcc_path  # NOQA
+from cupy._environment import get_rocm_path  # NOQA
+from cupy._environment import get_hipcc_path  # NOQA
+from cupy.cuda import compiler  # NOQA
+from cupy.cuda import device  # NOQA
+from cupy.cuda import function  # NOQA
+from cupy.cuda import memory  # NOQA
+from cupy.cuda import memory_hook  # NOQA
+from cupy.cuda import memory_hooks  # NOQA
+from cupy.cuda import pinned_memory  # NOQA
+from cupy.cuda import profiler  # NOQA
+from cupy.cuda import stream  # NOQA
+from cupy.cuda import texture  # NOQA
+from cupy_backends.cuda.api import driver  # NOQA
+from cupy_backends.cuda.api import runtime  # NOQA
+from cupy_backends.cuda.libs import nvrtc  # NOQA
+
+
+_available = None
+
+
+class _UnavailableModule():
+    available = False
+
+    def __init__(self, name):
+        self.__name__ = name
+
+
+from cupy.cuda import cub  # NOQA
+
+
+try:
+    from cupy_backends.cuda.libs import nvtx  # NOQA
+except ImportError:
+    nvtx = _UnavailableModule('cupy.cuda.nvtx')
+
+try:
+    from cupy.cuda import thrust  # NOQA
+except ImportError:
+    thrust = _UnavailableModule('cupy.cuda.thrust')
+
+
+def __getattr__(key):
+    if key == 'cusolver':
+        from cupy_backends.cuda.libs import cusolver
+        _cupy.cuda.cusolver = cusolver
+        return cusolver
+    elif key == 'cusparse':
+        from cupy_backends.cuda.libs import cusparse
+        _cupy.cuda.cusparse = cusparse
+        return cusparse
+    elif key == 'curand':
+        from cupy_backends.cuda.libs import curand
+        _cupy.cuda.curand = curand
+        return curand
+    elif key == 'cublas':
+        from cupy_backends.cuda.libs import cublas
+        _cupy.cuda.cublas = cublas
+        return cublas
+    elif key == 'jitify':
+        if not runtime.is_hip and driver.get_build_version() > 0:
+            import cupy.cuda.jitify as jitify
+        else:
+            jitify = _UnavailableModule('cupy.cuda.jitify')
+        _cupy.cuda.jitify = jitify
+        return jitify
+
+    # `nvtx_enabled` flags are kept for backward compatibility with Chainer.
+    # Note: module-level getattr only runs on Python 3.7+.
+    for mod in [nvtx]:
+        flag = '{}_enabled'.format(mod.__name__.split('.')[-1])
+        if key == flag:
+            warnings.warn('''
+cupy.cuda.{} has been deprecated in CuPy v8 and will be removed in the future release.
+Use {}.available instead.
+                '''.format(flag, mod.__name__), DeprecationWarning)  # NOQA
+            return not isinstance(mod, _UnavailableModule)
+
+    raise AttributeError(
+        "module '{}' has no attribute '{}'".format(__name__, key))
+
+
+def is_available():
+    global _available
+    if _available is None:
+        _available = False
+        try:
+            _available = runtime.getDeviceCount() > 0
+        except Exception as e:
+            if (not runtime.is_hip and e.args[0] !=
+                    'cudaErrorNoDevice: no CUDA-capable device is detected'):
+                raise
+            elif runtime.is_hip and 'hipErrorNoDevice' not in e.args[0]:
+                raise
+    return _available
+
+
+def get_local_runtime_version() -> int:
+    """
+    Returns the version of the CUDA Runtime installed in the environment.
+
+    Unlike :func:`cupy.cuda.runtime.runtimeGetVersion`, which returns the
+    CUDA Runtime version statically linked to CuPy, this function returns the
+    version retrieved from the shared library installed on the host.
+    Use this method to probe the CUDA Runtime version installed in the
+    environment.
+    """
+    return runtime._getLocalRuntimeVersion()
+
+
+# import class and function
+from cupy.cuda.device import Device  # NOQA
+from cupy.cuda.device import get_cublas_handle  # NOQA
+from cupy.cuda.device import get_device_id  # NOQA
+from cupy.cuda.function import Function  # NOQA
+from cupy.cuda.function import Module  # NOQA
+from cupy.cuda.memory import alloc  # NOQA
+from cupy.cuda.memory import BaseMemory  # NOQA
+from cupy.cuda.memory import malloc_managed  # NOQA
+from cupy.cuda.memory import malloc_async  # NOQA
+from cupy.cuda.memory import ManagedMemory  # NOQA
+from cupy.cuda.memory import Memory  # NOQA
+from cupy.cuda.memory import MemoryAsync  # NOQA
+from cupy.cuda.memory import MemoryPointer  # NOQA
+from cupy.cuda.memory import MemoryPool  # NOQA
+from cupy.cuda.memory import MemoryAsyncPool  # NOQA
+from cupy.cuda.memory import PythonFunctionAllocator  # NOQA
+from cupy.cuda.memory import CFunctionAllocator  # NOQA
+from cupy.cuda.memory import set_allocator  # NOQA
+from cupy.cuda.memory import get_allocator  # NOQA
+from cupy.cuda.memory import UnownedMemory  # NOQA
+from cupy.cuda.memory_hook import MemoryHook  # NOQA
+from cupy.cuda.pinned_memory import alloc_pinned_memory  # NOQA
+from cupy.cuda.pinned_memory import PinnedMemory  # NOQA
+from cupy.cuda.pinned_memory import PinnedMemoryPointer  # NOQA
+from cupy.cuda.pinned_memory import PinnedMemoryPool  # NOQA
+from cupy.cuda.pinned_memory import set_pinned_memory_allocator  # NOQA
+from cupy.cuda.stream import Event  # NOQA
+from cupy.cuda.stream import get_current_stream  # NOQA
+from cupy.cuda.stream import get_elapsed_time  # NOQA
+from cupy.cuda.stream import Stream  # NOQA
+from cupy.cuda.stream import ExternalStream  # NOQA
+from cupy.cuda.graph import Graph  # NOQA
+
+
+@contextlib.contextmanager
+def using_allocator(allocator=None):
+    """Sets a thread-local allocator for GPU memory inside
+       context manager
+
+    Args:
+        allocator (function): CuPy memory allocator. It must have the same
+            interface as the :func:`cupy.cuda.alloc` function, which takes the
+            buffer size as an argument and returns the device buffer of that
+            size. When ``None`` is specified, raw memory allocator will be
+            used (i.e., memory pool is disabled).
+    """
+    # Note: cupy/memory.pyx would be the better place to implement this
+    # function but `contextmanager` decoration doesn't behave well in Cython.
+    if allocator is None:
+        allocator = memory._malloc
+    previous_allocator = memory._get_thread_local_allocator()
+    memory._set_thread_local_allocator(allocator)
+    try:
+        yield
+    finally:
+        memory._set_thread_local_allocator(previous_allocator)
+
+
+@contextlib.contextmanager
+def profile():
+    """Enable CUDA profiling during with statement.
+
+    This function enables profiling on entering a with statement, and disables
+    profiling on leaving the statement.
+
+    >>> with cupy.cuda.profile():
+    ...    # do something you want to measure
+    ...    pass
+
+    .. note::
+        When starting ``nvprof`` from the command line, manually setting
+        ``--profile-from-start off`` may be required for the desired behavior.
+
+    .. warning:: This context manager is deprecated. Please use
+        :class:`cupyx.profiler.profile` instead.
+    """
+    warnings.warn(
+        'cupy.cuda.profile has been deprecated since CuPy v10 '
+        'and will be removed in the future. Use cupyx.profiler.profile '
+        'instead.')
+
+    profiler.start()
+    try:
+        yield
+    finally:
+        profiler.stop()

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/compiler.py

@@ -0,0 +1,991 @@
+import copy
+import hashlib
+import math
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from typing import Optional
+import warnings
+
+from cupy.cuda import device
+from cupy.cuda import function
+from cupy.cuda import get_rocm_path
+from cupy_backends.cuda.api import driver
+from cupy_backends.cuda.api import runtime
+from cupy_backends.cuda.libs import nvrtc
+from cupy import _environment
+from cupy import _util
+
+_cuda_hip_version = driver.get_build_version()
+
+
+_nvrtc_version = None
+_win32 = sys.platform.startswith('win32')
+_rdc_flags = ('--device-c', '-dc', '-rdc=true',
+              '--relocatable-device-code=true')
+_cudadevrt = None
+
+
+class NVCCException(Exception):
+    pass
+
+
+class HIPCCException(Exception):
+    pass
+
+
+class JitifyException(Exception):
+    pass
+
+
+def _run_cc(cmd, cwd, backend, log_stream=None):
+    # backend in ('nvcc', 'hipcc')
+    try:
+        # Inherit the environment variable as NVCC refers to PATH, TMPDIR/TMP,
+        # NVCC_PREPEND_FLAGS, NVCC_APPEND_FLAGS.
+        env = os.environ
+        if _win32:
+            # Adds the extra PATH for NVCC invocation.
+            # When running NVCC, a host compiler must be available in PATH,
+            # but this is not true in general Windows environment unless
+            # running inside the SDK Tools command prompt.
+            # To mitigate the situation CuPy automatically adds a path to
+            # the VC++ compiler (cl.exe) found via setuptools, if it is not
+            # on the PATH.
+            extra_path = _get_extra_path_for_msvc()
+            if extra_path is not None:
+                path = extra_path + os.pathsep + os.environ.get('PATH', '')
+                env = copy.deepcopy(env)
+                env['PATH'] = path
+        log = subprocess.check_output(
+            cmd, cwd=cwd, env=env,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            creationflags=(subprocess.CREATE_NO_WINDOW if _win32 else 0))
+        if log_stream is not None:
+            log_stream.write(log)
+        return log
+    except subprocess.CalledProcessError as e:
+        msg = ('`{0}` command returns non-zero exit status. \n'
+               'command: {1}\n'
+               'return-code: {2}\n'
+               'stdout/stderr: \n'
+               '{3}'.format(backend,
+                            e.cmd,
+                            e.returncode,
+                            e.output))
+        if backend == 'nvcc':
+            raise NVCCException(msg)
+        elif backend == 'hipcc':
+            raise HIPCCException(msg)
+        else:
+            raise RuntimeError(msg)
+    except OSError as e:
+        msg = 'Failed to run `{0}` command. ' \
+              'Check PATH environment variable: ' \
+              + str(e)
+        raise OSError(msg.format(backend))
+
+
+@_util.memoize()
+def _get_extra_path_for_msvc():
+    cl_exe = shutil.which('cl.exe')
+    if cl_exe:
+        # The compiler is already on PATH, no extra path needed.
+        return None
+
+    cl_exe_dir = _get_cl_exe_dir()
+    if cl_exe_dir:
+        return cl_exe_dir
+
+    cl_exe_dir = _get_cl_exe_dir_fallback()
+    if cl_exe_dir:
+        return cl_exe_dir
+
+    return None
+
+
+def _get_cl_exe_dir() -> Optional[str]:
+    try:
+        try:
+            # setuptools.msvc is missing in setuptools v74.0.0.
+            # setuptools.msvc requires explicit import in setuptools v74.1.0+.
+            import setuptools.msvc
+        except Exception:
+            return None
+        vctools = setuptools.msvc.EnvironmentInfo(platform.machine()).VCTools
+        for path in vctools:
+            cl_exe = os.path.join(path, 'cl.exe')
+            if os.path.exists(cl_exe):
+                return path
+        warnings.warn(f'cl.exe could not be found in {vctools}')
+    except Exception as e:
+        warnings.warn(
+            f'Failed to find cl.exe with setuptools.msvc: {type(e)}: {e}')
+    return None
+
+
+def _get_cl_exe_dir_fallback() -> Optional[str]:
+    # Discover cl.exe without relying on undocumented setuptools.msvc API.
+    # As of now this code path exists only for setuptools 74.0.0 (see #8583).
+    # N.B. This takes few seconds as this incurs cmd.exe (vcvarsall.bat)
+    # invocation.
+    try:
+        from setuptools import Distribution
+        from setuptools.command.build_ext import build_ext
+        ext = build_ext(Distribution({'name': 'cupy_cl_exe_discover'}))
+        ext.setup_shlib_compiler()
+        ext.shlib_compiler.initialize()  # MSVCCompiler only
+        return os.path.dirname(ext.shlib_compiler.cc)
+    except Exception as e:
+        warnings.warn(
+            f'Failed to find cl.exe with setuptools: {type(e)}: {e}')
+    return None
+
+
+def _get_nvrtc_version():
+    global _nvrtc_version
+    if _nvrtc_version is None:
+        _nvrtc_version = nvrtc.getVersion()
+
+    return _nvrtc_version
+
+
+@_util.memoize()
+def _get_cupy_cache_key():
+    from cupy._core import core
+    return core.CUPY_CACHE_KEY
+
+
+# Known archs for Tegra/Jetson/Xavier/etc
+_tegra_archs = ('32', '53', '62', '72', '87')
+
+
+@_util.memoize()
+def _get_max_compute_capability():
+    major, minor = _get_nvrtc_version()
+    if major < 11:
+        # CUDA 10.2
+        nvrtc_max_compute_capability = '75'
+    elif major == 11 and minor == 0:
+        # CUDA 11.0
+        nvrtc_max_compute_capability = '80'
+    elif major == 11 and minor < 8:
+        # CUDA 11.1 - 11.7
+        # Note: 87 is for Jetson Orin
+        nvrtc_max_compute_capability = '86'
+    elif (major == 11 and minor == 8) or (major == 12 and minor < 8):
+        # CUDA 11.8, 12.0 - 12.7
+        nvrtc_max_compute_capability = '90'
+    else:
+        # CUDA 12.8+
+        nvrtc_max_compute_capability = '120'
+
+    return nvrtc_max_compute_capability
+
+
+@_util.memoize()
+def _get_extra_include_dir_opts():
+    major, minor = _get_nvrtc_version()
+    return tuple(
+        f'-I{d}'
+        for d in _environment._get_include_dir_from_conda_or_wheel(
+            major, minor
+        )
+    )
+
+
+@_util.memoize(for_each_device=True)
+def _get_arch():
+    # See Supported Compile Options section of NVRTC User Guide for
+    # the maximum value allowed for `--gpu-architecture`.
+    nvrtc_max_compute_capability = _get_max_compute_capability()
+
+    arch = device.Device().compute_capability
+    if arch in _tegra_archs:
+        return arch
+    else:
+        return min(arch, nvrtc_max_compute_capability, key=int)
+
+
+@_util.memoize(for_each_device=True)
+def _get_arch_for_options_for_nvrtc(arch=None):
+    # NVRTC in CUDA 11.3+ generates PTX that cannot be run an earlier driver
+    # version than the one included in the used CUDA version, as
+    # documented in:
+    # https://docs.nvidia.com/cuda/archive/11.3.0/nvrtc/index.html#versioning
+    # Here we use `-arch=sm_*` instead of `-arch=compute_*` to directly
+    # generate cubin (SASS) instead of PTX. See #5097 for details.
+    if arch is None:
+        arch = _get_arch()
+    if (
+        not _use_ptx
+        and int(arch) <= int(_get_max_compute_capability())
+    ):
+        return f'-arch=sm_{arch}', 'cubin'
+    return f'-arch=compute_{arch}', 'ptx'
+
+
+def _is_cudadevrt_needed(options):
+    return any(o for o in options if o in _rdc_flags)
+
+
+def _get_cudadevrt_path():
+    global _cudadevrt
+    if _cudadevrt is not None:
+        return _cudadevrt
+
+    # defer import to here to avoid circular dependency
+    from cupy.cuda import get_cuda_path
+    global _win32
+
+    cudadevrt = get_cuda_path()
+    if cudadevrt is None:
+        raise RuntimeError('CUDA is not found.')
+
+    if _win32:
+        # rely on os.altsep
+        cudadevrt += '/lib/x64/cudadevrt.lib'
+    else:  # linux & osx: search twice as in cupy/install/build.py
+        cudadevrt64 = cudadevrt + '/lib64/libcudadevrt.a'
+        if not os.path.isfile(cudadevrt64):
+            cudadevrt += '/lib/libcudadevrt.a'
+        else:
+            cudadevrt = cudadevrt64
+    if not os.path.isfile(cudadevrt):
+        raise RuntimeError(
+            'Relocatable PTX code is requested, but cudadevrt '
+            'is not found.')
+    return cudadevrt
+
+
+def _remove_rdc_option(options):
+    return tuple(o for o in options if o not in _rdc_flags)
+
+
+def _get_bool_env_variable(name, default):
+    val = os.environ.get(name)
+    if val is None or len(val) == 0:
+        return default
+    try:
+        return int(val) == 1
+    except ValueError:
+        return False
+
+
+_use_ptx = _get_bool_env_variable('CUPY_COMPILE_WITH_PTX', False)
+_jitify_header_source_map_populated = False
+
+
+def _jitify_prep(source, options, cu_path):
+    from cupy.cuda import jitify
+
+    # TODO(leofang): refactor this?
+    global _jitify_header_source_map_populated
+    if not _jitify_header_source_map_populated:
+        from cupy._core import core
+        jitify._init_module()
+        jitify._add_sources(core._get_header_source_map())
+        _jitify_header_source_map_populated = True
+
+    # jitify requires the 1st line to be the program name
+    old_source = source
+    source = cu_path + '\n' + source
+
+    # Upon failure, in addition to throw an error Jitify also prints the log
+    # to stdout. In principle we could intercept that by hijacking stdout's
+    # file descriptor (tested locally), but the problem is pytest also does
+    # the same thing internally, causing strange errors when running the tests.
+    # As a result, we currently maintain Jitify's default behavior for easy
+    # debugging, and wait for the upstream to address this issue
+    # (NVIDIA/jitify#79).
+
+    try:
+        name, options, headers, include_names = jitify.jitify(source, options)
+    except Exception as e:  # C++ could throw all kinds of errors
+        cex = CompileException(str(e), old_source, cu_path, options, 'jitify')
+        dump = _get_bool_env_variable(
+            'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+        if dump:
+            cex.dump(sys.stderr)
+        raise JitifyException(str(cex)) from e
+    assert name == cu_path
+
+    return options, headers, include_names
+
+
+_has_usedforsecurity = (sys.version_info >= (3, 9))
+
+
+def _hash_hexdigest(value):
+    if _has_usedforsecurity:
+        hashobj = hashlib.sha1(value, usedforsecurity=False)
+    else:
+        hashobj = hashlib.sha1(value)
+    return hashobj.hexdigest()
+
+
+_hash_length = len(_hash_hexdigest(b''))  # 40 for SHA1
+
+
+def compile_using_nvrtc(source, options=(), arch=None, filename='kern.cu',
+                        name_expressions=None, log_stream=None,
+                        cache_in_memory=False, jitify=False):
+    def _compile(
+            source, options, cu_path, name_expressions, log_stream, jitify):
+
+        if not runtime.is_hip:
+            arch_opt, method = _get_arch_for_options_for_nvrtc(arch)
+            options += (arch_opt,)
+        else:
+            method = 'ptx'
+
+        if jitify:
+            options, headers, include_names = _jitify_prep(
+                source, options, cu_path)
+        else:
+            headers = include_names = ()
+            major_version, minor_version = _get_nvrtc_version()
+            if major_version >= 12:
+                # Starting with CUDA 12.0, even without using jitify, some
+                # tests cause an error if the following option is not included.
+                options += ('--device-as-default-execution-space',)
+
+        prog = _NVRTCProgram(source, cu_path, headers, include_names,
+                             name_expressions=name_expressions, method=method)
+        try:
+            compiled_obj, mapping = prog.compile(options, log_stream)
+        except CompileException as e:
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                e.dump(sys.stderr)
+            raise
+        return compiled_obj, mapping
+
+    if not cache_in_memory:
+        with tempfile.TemporaryDirectory() as root_dir:
+            cu_path = os.path.join(root_dir, filename)
+
+            with open(cu_path, 'w') as cu_file:
+                cu_file.write(source)
+
+            return _compile(source, options, cu_path,
+                            name_expressions, log_stream, jitify)
+    else:
+        cu_path = '' if not jitify else filename
+        return _compile(source, options, cu_path, name_expressions,
+                        log_stream, jitify)
+
+
+def compile_using_nvcc(source, options=(), arch=None,
+                       filename='kern.cu', code_type='cubin',
+                       separate_compilation=False, log_stream=None):
+    # defer import to here to avoid circular dependency
+    from cupy.cuda import get_nvcc_path
+
+    if not arch:
+        arch = _get_arch()
+
+    if code_type not in ('cubin', 'ptx'):
+        raise ValueError('Invalid code_type %s. Should be cubin or ptx')
+    if code_type == 'ptx':
+        assert not separate_compilation
+
+    arch_str = '-gencode=arch=compute_{cc},code=sm_{cc}'.format(cc=arch)
+    _nvcc = get_nvcc_path()
+    # split() is needed because _nvcc could come from the env var NVCC
+    cmd = _nvcc.split()
+    cmd.append(arch_str)
+
+    with tempfile.TemporaryDirectory() as root_dir:
+        first_part = filename.split('.')[0]
+
+        path = os.path.join(root_dir, first_part)
+        cu_path = '%s.cu' % path
+        result_path = '%s.%s' % (path, code_type)
+
+        with open(cu_path, 'w') as cu_file:
+            cu_file.write(source)
+
+        if not separate_compilation:  # majority cases
+            cmd.append('--%s' % code_type)
+            cmd += list(options)
+            cmd.append(cu_path)
+
+            try:
+                _run_cc(cmd, root_dir, 'nvcc', log_stream)
+            except NVCCException as e:
+                cex = CompileException(str(e), source, cu_path, options,
+                                       'nvcc')
+
+                dump = _get_bool_env_variable(
+                    'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+                if dump:
+                    cex.dump(sys.stderr)
+
+                raise cex
+        else:  # two steps: compile to object and device-link
+            cmd_partial = cmd.copy()
+            cmd_partial.append('--cubin')
+
+            obj = path + '.o'
+            cmd += list(options + ('-o', obj))
+            cmd.append(cu_path)
+
+            try:
+                _run_cc(cmd, root_dir, 'nvcc', log_stream)
+            except NVCCException as e:
+                cex = CompileException(str(e), source, cu_path, options,
+                                       'nvcc')
+
+                dump = _get_bool_env_variable(
+                    'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+                if dump:
+                    cex.dump(sys.stderr)
+
+                raise cex
+
+            options = _remove_rdc_option(options)
+            options += ('--device-link', obj, '-o', path + '.cubin')
+            cmd = cmd_partial + list(options)
+
+            try:
+                _run_cc(cmd, root_dir, 'nvcc', log_stream)
+            except NVCCException as e:
+                cex = CompileException(str(e), '', '', options, 'nvcc')
+                raise cex
+
+        if code_type == 'ptx':
+            with open(result_path, 'rb') as ptx_file:
+                return ptx_file.read()
+        elif code_type == 'cubin':
+            with open(result_path, 'rb') as bin_file:
+                return bin_file.read()
+        else:
+            assert False, code_type
+
+
+def _preprocess(source, options, arch, backend):
+    if backend == 'nvrtc':
+        # For the preprocess it is enough to use PTX method
+        # we don't need to explicitly obtain a CUBIN file.
+        options += ('-arch=compute_{}'.format(arch),)
+        prog = _NVRTCProgram(source)
+        try:
+            result, _ = prog.compile(options)
+        except CompileException as e:
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                e.dump(sys.stderr)
+            raise
+    elif backend == 'nvcc':
+        try:
+            result = compile_using_nvcc(source, options, arch, 'preprocess.cu',
+                                        code_type='ptx')
+        except CompileException as e:
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                e.dump(sys.stderr)
+            raise
+    else:
+        raise ValueError('Invalid backend %s' % backend)
+
+    assert isinstance(result, bytes)
+
+    # Extract the part containing version information.
+    return '\n'.join(
+        x for x in result.decode().splitlines() if x.startswith('//'))
+
+
+_default_cache_dir = os.path.expanduser('~/.cupy/kernel_cache')
+
+
+def get_cache_dir():
+    return os.environ.get('CUPY_CACHE_DIR', _default_cache_dir)
+
+
+_empty_file_preprocess_cache: dict = {}
+
+
+def _compile_module_with_cache(
+        source, options=(), arch=None, cache_dir=None, extra_source=None,
+        backend='nvrtc', *, enable_cooperative_groups=False,
+        name_expressions=None, log_stream=None, jitify=False):
+
+    if enable_cooperative_groups:
+        if runtime.is_hip:
+            raise ValueError(
+                'Cooperative groups is not supported in HIP.')
+
+    if name_expressions is not None and backend != 'nvrtc':
+        raise NotImplementedError
+
+    # We silently ignore CUPY_CACHE_IN_MEMORY if nvcc/hipcc are in use, because
+    # they must dump files to disk.
+    cache_in_memory = (
+        _get_bool_env_variable('CUPY_CACHE_IN_MEMORY', False)
+        and backend == 'nvrtc')
+
+    if runtime.is_hip:
+        backend = 'hiprtc' if backend == 'nvrtc' else 'hipcc'
+        return _compile_with_cache_hip(
+            source, options, arch, cache_dir, extra_source, backend,
+            name_expressions, log_stream, cache_in_memory)
+    else:
+        return _compile_with_cache_cuda(
+            source, options, arch, cache_dir, extra_source, backend,
+            enable_cooperative_groups, name_expressions, log_stream,
+            cache_in_memory, jitify)
+
+
+def _compile_with_cache_cuda(
+        source, options, arch, cache_dir, extra_source=None, backend='nvrtc',
+        enable_cooperative_groups=False, name_expressions=None,
+        log_stream=None, cache_in_memory=False, jitify=False):
+    # NVRTC does not use extra_source. extra_source is used for cache key.
+    global _empty_file_preprocess_cache
+    if cache_dir is None:
+        cache_dir = get_cache_dir()
+    if arch is None:
+        arch = _get_arch()
+
+    options += ('-ftz=true',)
+
+    if enable_cooperative_groups:
+        # `cooperative_groups` requires relocatable device code.
+        options += ('--device-c',)
+
+    if _get_bool_env_variable('CUPY_CUDA_COMPILE_WITH_DEBUG', False):
+        options += ('--device-debug', '--generate-line-info')
+
+    is_jitify_requested = ('-DCUPY_USE_JITIFY' in options)
+    if jitify and not is_jitify_requested:
+        # jitify is set in RawKernel/RawModule, translate it to an option
+        # that is useless to the compiler, but can be used as part of the
+        # hash key
+        options += ('-DCUPY_USE_JITIFY',)
+    elif is_jitify_requested and not jitify:
+        # jitify is requested internally, just set the flag
+        jitify = True
+    if jitify and backend != 'nvrtc':
+        raise ValueError('jitify only works with NVRTC')
+
+    options += _get_extra_include_dir_opts()
+    env = ((arch, options, _get_nvrtc_version(), backend)
+           + _get_arch_for_options_for_nvrtc(arch))
+    base = _empty_file_preprocess_cache.get(env, None)
+    if base is None:
+        # This is for checking NVRTC/NVCC compiler internal version
+        base = _preprocess('', options, arch, backend)
+        _empty_file_preprocess_cache[env] = base
+
+    key_src = '%s %s %s %s %s' % (
+        env, base, source, extra_source, _get_cupy_cache_key())
+    key_src = key_src.encode('utf-8')
+    name = _hash_hexdigest(key_src) + '.cubin'
+
+    mod = function.Module()
+
+    if not cache_in_memory:
+        # Read from disk cache
+        if not os.path.isdir(cache_dir):
+            os.makedirs(cache_dir, exist_ok=True)
+
+        # To handle conflicts in concurrent situation, we adopt lock-free
+        # method to avoid performance degradation.
+        # We force recompiling to retrieve C++ mangled names if so desired.
+        path = os.path.join(cache_dir, name)
+        if os.path.exists(path) and not name_expressions:
+            with open(path, 'rb') as file:
+                data = file.read()
+            if len(data) >= _hash_length:
+                hash = data[:_hash_length]
+                cubin = data[_hash_length:]
+                cubin_hash = _hash_hexdigest(cubin).encode('ascii')
+                if hash == cubin_hash:
+                    mod.load(cubin)
+                    return mod
+    else:
+        # Enforce compiling -- the resulting kernel will be cached elsewhere,
+        # so we do nothing
+        pass
+
+    if backend == 'nvrtc':
+        cu_name = '' if cache_in_memory else name + '.cu'
+        ptx, mapping = compile_using_nvrtc(
+            source, options, arch, cu_name, name_expressions,
+            log_stream, cache_in_memory, jitify)
+        if _is_cudadevrt_needed(options):
+            # for separate compilation
+            ls = function.LinkState()
+            ls.add_ptr_data(ptx, 'cupy.ptx')
+            _cudadevrt = _get_cudadevrt_path()
+            ls.add_ptr_file(_cudadevrt)
+            cubin = ls.complete()
+        else:
+            cubin = ptx
+        mod._set_mapping(mapping)
+    elif backend == 'nvcc':
+        rdc = _is_cudadevrt_needed(options)
+        cubin = compile_using_nvcc(source, options, arch,
+                                   name + '.cu', code_type='cubin',
+                                   separate_compilation=rdc,
+                                   log_stream=log_stream)
+    else:
+        raise ValueError('Invalid backend %s' % backend)
+
+    if not cache_in_memory:
+        # Write to disk cache
+        cubin_hash = _hash_hexdigest(cubin).encode('ascii')
+
+        # shutil.move is not atomic operation, so it could result in a
+        # corrupted file. We detect it by appending a hash at the beginning
+        # of each cache file. If the file is corrupted, it will be ignored
+        # next time it is read.
+        with tempfile.NamedTemporaryFile(dir=cache_dir, delete=False) as tf:
+            tf.write(cubin_hash)
+            tf.write(cubin)
+            temp_path = tf.name
+        shutil.move(temp_path, path)
+
+        # Save .cu source file along with .cubin
+        if _get_bool_env_variable('CUPY_CACHE_SAVE_CUDA_SOURCE', False):
+            with open(path + '.cu', 'w') as f:
+                f.write(source)
+    else:
+        # we don't do any disk I/O
+        pass
+
+    mod.load(cubin)
+    return mod
+
+
+class CompileException(Exception):
+
+    def __init__(self, msg, source, name, options, backend='nvrtc'):
+        self._msg = msg
+        self.source = source
+        self.name = name
+        self.options = options
+        self.backend = backend
+        super(CompileException, self).__init__()
+
+    def __reduce__(self):
+        return (type(self), (self._msg, self.source, self.name,
+                             self.options, self.backend))
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return self.get_message()
+
+    def get_message(self):
+        return self._msg
+
+    def dump(self, f):
+        lines = self.source.split('\n')
+        digits = int(math.floor(math.log10(len(lines)))) + 1
+        linum_fmt = '{{:0{}d}} '.format(digits)
+        f.write('{} '.format(self.backend.upper()))
+        f.write('compilation error: {}\n'.format(self))
+        f.write('-----\n')
+        f.write('Name: {}\n'.format(self.name))
+        f.write('Options: {}\n'.format(' '.join(self.options)))
+        f.write('CUDA source:\n')
+        for i, line in enumerate(lines):
+            f.write(linum_fmt.format(i + 1) + line.rstrip() + '\n')
+        f.write('-----\n')
+        f.flush()
+
+
+class _NVRTCProgram(object):
+
+    def __init__(self, src, name='default_program', headers=(),
+                 include_names=(), name_expressions=None, method='ptx'):
+        self.ptr = None
+
+        if isinstance(src, bytes):
+            src = src.decode('UTF-8')
+        if isinstance(name, bytes):
+            name = name.decode('UTF-8')
+
+        self.src = src
+        self.name = name
+        self.ptr = nvrtc.createProgram(src, name, headers, include_names)
+        self.name_expressions = name_expressions
+        self.method = method
+
+    def __del__(self, is_shutting_down=_util.is_shutting_down):
+        if is_shutting_down():
+            return
+        if self.ptr:
+            nvrtc.destroyProgram(self.ptr)
+
+    def compile(self, options=(), log_stream=None):
+        try:
+            if self.name_expressions:
+                for ker in self.name_expressions:
+                    nvrtc.addNameExpression(self.ptr, ker)
+            nvrtc.compileProgram(self.ptr, options)
+            mapping = None
+            if self.name_expressions:
+                mapping = {}
+                for ker in self.name_expressions:
+                    mapping[ker] = nvrtc.getLoweredName(self.ptr, ker)
+            if log_stream is not None:
+                log_stream.write(nvrtc.getProgramLog(self.ptr))
+            # This is to ensure backwards compatibility with nvrtc
+            if self.method == 'cubin':
+                return nvrtc.getCUBIN(self.ptr), mapping
+            elif self.method == 'ptx':
+                return nvrtc.getPTX(self.ptr), mapping
+            # TODO(leofang): support JIT LTO using nvrtc.getNVVM()?
+            # need -dlto and -arch=compute_XX
+            else:
+                raise RuntimeError('Unknown NVRTC compile method')
+        except nvrtc.NVRTCError:
+            log = nvrtc.getProgramLog(self.ptr)
+            raise CompileException(log, self.src, self.name, options,
+                                   'nvrtc' if not runtime.is_hip else 'hiprtc')
+
+
+def is_valid_kernel_name(name):
+    return re.match('^[a-zA-Z_][a-zA-Z_0-9]*$', name) is not None
+
+
+def compile_using_hipcc(source, options, arch, log_stream=None):
+    # As of ROCm 3.5.0 hiprtc/hipcc can automatically pick up the
+    # right arch without setting HCC_AMDGPU_TARGET, so we don't need
+    # to set arch here
+    cmd = ['hipcc', '--genco'] + list(options)
+
+    with tempfile.TemporaryDirectory() as root_dir:
+        path = os.path.join(root_dir, 'kern')
+        in_path = path + '.cpp'
+        out_path = path + '.hsaco'
+
+        with open(in_path, 'w') as f:
+            f.write(source)
+
+        cmd += [in_path, '-o', out_path]
+
+        try:
+            output = _run_cc(cmd, root_dir, 'hipcc', log_stream)
+        except HIPCCException as e:
+            cex = CompileException(str(e), source, in_path, options,
+                                   'hipcc')
+
+            dump = _get_bool_env_variable(
+                'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+            if dump:
+                cex.dump(sys.stderr)
+
+            raise cex
+        if not os.path.isfile(out_path):
+            raise HIPCCException(
+                '`hipcc` command does not generate output file. \n'
+                'command: {0}\n'
+                'stdout/stderr: \n'
+                '{1}'.format(cmd, output))
+        with open(out_path, 'rb') as f:
+            return f.read()
+
+
+# TODO(leofang): consider merge _preprocess_hipcc with _preprocess_hiprtc,
+# perhaps also with _preprocess?
+def _preprocess_hipcc(source, options):
+    cmd = ['hipcc', '--preprocess'] + list(options)
+    with tempfile.TemporaryDirectory() as root_dir:
+        path = os.path.join(root_dir, 'kern')
+        cu_path = '%s.cpp' % path
+
+        with open(cu_path, 'w') as cu_file:
+            cu_file.write(source)
+
+        cmd.append(cu_path)
+        pp_src = _run_cc(cmd, root_dir, 'hipcc')
+        assert isinstance(pp_src, str)
+        return re.sub('(?m)^#.*$', '', pp_src)
+
+
+def _preprocess_hiprtc(source, options):
+    # source is ignored
+    if _cuda_hip_version >= 40400000:
+        # HIP runtime headers can be no longer explicitly included on ROCm 4.5+
+        code = '''
+        // hiprtc segfaults if the input code is empty
+        __global__ void _cupy_preprocess_dummy_kernel_() { }
+        '''
+    else:
+        code = '''
+        // hiprtc segfaults if the input code is empty
+        #include <hip/hip_runtime.h>
+        __global__ void _cupy_preprocess_dummy_kernel_() { }
+        '''
+
+    prog = _NVRTCProgram(code)
+    try:
+        result, _ = prog.compile(options)
+    except CompileException as e:
+        dump = _get_bool_env_variable(
+            'CUPY_DUMP_CUDA_SOURCE_ON_ERROR', False)
+        if dump:
+            e.dump(sys.stderr)
+        raise
+    assert isinstance(result, bytes)
+    return result
+
+
+_hip_extra_source = None
+
+
+def _convert_to_hip_source(source, extra_source, is_hiprtc):
+    if not is_hiprtc:
+        return '#include <hip/hip_runtime.h>\n' + source
+    if _cuda_hip_version >= 40400000:
+        # HIP runtime headers can be no longer explicitly included on ROCm 4.5+
+        return source
+    if _cuda_hip_version >= 402:
+        # "-I" is fixed on ROCm 4.2.0+
+        return '#include <hip/hip_runtime.h>\n' + source
+
+    # Workaround for hiprtc: it does not follow the -I option to search
+    # headers (as of ROCm 3.5.0), so we must prepend all CuPy's headers
+    global _hip_extra_source
+    if _hip_extra_source is None:
+        if extra_source is not None:
+            extra_source = extra_source.split('\n')
+            extra_source = [line for line in extra_source if (
+                not line.startswith('#include')
+                and not line.startswith('#pragma once'))]
+            _hip_extra_source = extra_source = '\n'.join(extra_source)
+
+    source = source.split('\n')
+    source = [line for line in source if not line.startswith('#include')]
+    source = ('#include <hip/hip_runtime.h>\n#include <hip/hip_fp16.h>\n'
+              + _hip_extra_source + '\n'.join(source))
+
+    return source
+
+
+# TODO(leofang): evaluate if this can be merged with _compile_with_cache_cuda()
+def _compile_with_cache_hip(source, options, arch, cache_dir, extra_source,
+                            backend='hiprtc', name_expressions=None,
+                            log_stream=None, cache_in_memory=False,
+                            use_converter=True):
+    global _empty_file_preprocess_cache
+
+    # TODO(leofang): this might be possible but is currently undocumented
+    if _is_cudadevrt_needed(options):
+        raise ValueError('separate compilation is not supported in HIP')
+
+    # HIP's equivalent of -ftz=true, see ROCm-Developer-Tools/HIP#2252
+    # Notes:
+    # - For hipcc, this should just work, as invalid options would cause errors
+    #   See https://clang.llvm.org/docs/ClangCommandLineReference.html.
+    # - For hiprtc, this is a no-op until the compiler options like -D and -I
+    #   are accepted, see ROCm-Developer-Tools/HIP#2182 and
+    #   ROCm-Developer-Tools/HIP#2248
+    options += ('-fcuda-flush-denormals-to-zero',)
+
+    # Workaround ROCm 4.3 LLVM_PATH issue in hipRTC #5689
+    rocm_build_version = driver.get_build_version()
+    if rocm_build_version >= 40300000 and rocm_build_version < 40500000:
+        options += (
+            '-I' + get_rocm_path() + '/llvm/lib/clang/13.0.0/include/',)
+
+    if cache_dir is None:
+        cache_dir = get_cache_dir()
+    # As of ROCm 3.5.0 hiprtc/hipcc can automatically pick up the
+    # right arch without setting HCC_AMDGPU_TARGET, so we don't need
+    # to tell the compiler which arch we are targeting. But, we still
+    # need to know arch as part of the cache key:
+    if arch is None:
+        # On HIP, gcnArch is computed from "compute capability":
+        # https://github.com/ROCm-Developer-Tools/HIP/blob/rocm-4.0.0/rocclr/hip_device.cpp#L202
+        arch = device.Device().compute_capability
+    if use_converter:
+        source = _convert_to_hip_source(source, extra_source,
+                                        is_hiprtc=(backend == 'hiprtc'))
+
+    env = (arch, options, _get_nvrtc_version(), backend)
+    base = _empty_file_preprocess_cache.get(env, None)
+    if base is None:
+        # This is for checking HIPRTC/HIPCC compiler internal version
+        if backend == 'hiprtc':
+            base = _preprocess_hiprtc('', options)
+        else:
+            base = _preprocess_hipcc('', options)
+        _empty_file_preprocess_cache[env] = base
+
+    key_src = '%s %s %s %s' % (env, base, source, extra_source)
+    key_src = key_src.encode('utf-8')
+    name = _hash_hexdigest(key_src) + '.hsaco'
+
+    mod = function.Module()
+
+    if not cache_in_memory:
+        # Read from disk cache
+        if not os.path.isdir(cache_dir):
+            os.makedirs(cache_dir, exist_ok=True)
+
+        # To handle conflicts in concurrent situation, we adopt lock-free
+        # method to avoid performance degradation.
+        # We force recompiling to retrieve C++ mangled names if so desired.
+        path = os.path.join(cache_dir, name)
+        if os.path.exists(path) and not name_expressions:
+            with open(path, 'rb') as f:
+                data = f.read()
+            if len(data) >= _hash_length:
+                hash_value = data[:_hash_length]
+                binary = data[_hash_length:]
+                binary_hash = _hash_hexdigest(binary).encode('ascii')
+                if hash_value == binary_hash:
+                    mod.load(binary)
+                    return mod
+    else:
+        # Enforce compiling -- the resulting kernel will be cached elsewhere,
+        # so we do nothing
+        pass
+
+    if backend == 'hiprtc':
+        # compile_using_nvrtc calls hiprtc for hip builds
+        binary, mapping = compile_using_nvrtc(
+            source, options, arch, name + '.cu', name_expressions,
+            log_stream, cache_in_memory)
+        mod._set_mapping(mapping)
+    else:
+        binary = compile_using_hipcc(source, options, arch, log_stream)
+
+    if not cache_in_memory:
+        # Write to disk cache
+        binary_hash = _hash_hexdigest(binary).encode('ascii')
+
+        # shutil.move is not atomic operation, so it could result in a
+        # corrupted file. We detect it by appending a hash at the beginning
+        # of each cache file. If the file is corrupted, it will be ignored
+        # next time it is read.
+        with tempfile.NamedTemporaryFile(dir=cache_dir, delete=False) as tf:
+            tf.write(binary_hash)
+            tf.write(binary)
+            temp_path = tf.name
+        shutil.move(temp_path, path)
+
+        # Save .cu source file along with .hsaco
+        if _get_bool_env_variable('CUPY_CACHE_SAVE_CUDA_SOURCE', False):
+            with open(path + '.cpp', 'w') as f:
+                f.write(source)
+    else:
+        # we don't do any disk I/O
+        pass
+
+    mod.load(binary)
+    return mod

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cudnn.py

@@ -0,0 +1,17 @@
+"""
+cuDNN Wrapper
+
+Use `cupy_backends.cuda.libs.cudnn` directly in CuPy codebase.
+"""
+
+from cupy import _environment
+
+
+available = True
+
+try:
+    _environment._preload_library('cudnn')
+    from cupy_backends.cuda.libs.cudnn import *  # NOQA
+except ImportError as e:
+    available = False
+    _environment._preload_warning('cudnn', e)

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cufft.pxd

@@ -0,0 +1,99 @@
+# Note: nothing exposed in this pxd header is considered public API;
+# we copy this to sdist only because it's needed at runtime to support
+# cuFFT callbacks
+
+from libc.stdint cimport intptr_t
+
+cdef extern from *:
+    ctypedef float Float 'cufftReal'
+    ctypedef double Double 'cufftDoubleReal'
+    ctypedef int Result 'cufftResult_t'
+
+    IF CUPY_HIP_VERSION > 0:
+        ctypedef int Handle 'cufftHandle'
+    ELSE:
+        ctypedef struct hipHandle 'hipfftHandle_t':
+            pass
+        ctypedef hipHandle* Handle 'cufftHandle'
+
+    ctypedef enum Type 'cufftType_t':
+        pass
+
+
+cpdef enum:
+    CUFFT_C2C = 0x29
+    CUFFT_R2C = 0x2a
+    CUFFT_C2R = 0x2c
+    CUFFT_Z2Z = 0x69
+    CUFFT_D2Z = 0x6a
+    CUFFT_Z2D = 0x6c
+
+    CUFFT_FORWARD = -1
+    CUFFT_INVERSE = 1
+
+    CUFFT_CB_LD_COMPLEX = 0x0,
+    CUFFT_CB_LD_COMPLEX_DOUBLE = 0x1,
+    CUFFT_CB_LD_REAL = 0x2,
+    CUFFT_CB_LD_REAL_DOUBLE = 0x3,
+    CUFFT_CB_ST_COMPLEX = 0x4,
+    CUFFT_CB_ST_COMPLEX_DOUBLE = 0x5,
+    CUFFT_CB_ST_REAL = 0x6,
+    CUFFT_CB_ST_REAL_DOUBLE = 0x7,
+
+
+cpdef get_current_plan()
+cpdef int getVersion() except? -1
+
+
+cdef class Plan1d:
+    cdef:
+        readonly intptr_t handle
+        readonly object work_area  # can be MemoryPointer or a list of it
+        readonly int nx
+        readonly int batch
+        readonly Type fft_type
+
+        readonly list gpus
+        list batch_share
+        list gather_streams
+        list gather_events
+        dict scatter_streams
+        dict scatter_events
+        intptr_t xtArr
+        list xtArr_buffer
+
+        void _single_gpu_get_plan(
+            self, Handle plan, int nx, int fft_type, int batch) except*
+        void _multi_gpu_get_plan(
+            self, Handle plan, int nx, int fft_type, int batch,
+            devices, out) except*
+
+
+cdef class PlanNd:
+    cdef:
+        readonly intptr_t handle
+        readonly object work_area  # memory.MemoryPointer
+        readonly tuple shape
+        readonly Type fft_type
+        readonly str order
+        readonly int last_axis
+        readonly object last_size
+
+        # TODO(leofang): support multi-GPU transforms
+        readonly list gpus
+
+
+cdef class XtPlanNd:
+    cdef:
+        readonly intptr_t handle
+        readonly object work_area  # memory.MemoryPointer
+        readonly tuple shape
+        readonly int itype
+        readonly int otype
+        readonly int etype
+        readonly str order
+        readonly int last_axis
+        readonly object last_size
+
+        # TODO(leofang): support multi-GPU transforms
+        readonly list gpus

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cufft.pyx

@@ -0,0 +1,1205 @@
+cimport cython  # NOQA
+from cpython.mem cimport PyMem_Malloc, PyMem_Free
+from libc.string cimport memset as c_memset
+from libcpp cimport vector
+
+import numpy
+import threading
+
+import cupy
+from cupy.cuda import device
+from cupy.cuda import memory
+from cupy.cuda import runtime
+from cupy.cuda import stream
+
+
+cdef object _thread_local = threading.local()
+
+
+cpdef get_current_plan():
+    """Get current cuFFT plan.
+
+    Returns:
+        None or cupy.cuda.cufft.Plan1d or cupy.cuda.cufft.PlanNd
+    """
+    if not hasattr(_thread_local, '_current_plan'):
+        _thread_local._current_plan = None
+    return _thread_local._current_plan
+
+
+cdef enum:
+    # Actually, this is 64, but it's undocumented. For the sake
+    # of safety, let us use 16, which agrees with the cuFFT doc.
+    MAX_CUDA_DESCRIPTOR_GPUS = 16
+
+
+cdef extern from 'cupy_cufft.h' nogil:
+    # we duplicate some types here to avoid cimporting from driver/runtime,
+    # as we don't include their .pxd files in the sdist
+    ctypedef void* Stream 'cudaStream_t'
+    ctypedef int DataType 'cudaDataType'
+
+    ctypedef struct Complex 'cufftComplex':
+        float x, y
+    ctypedef struct DoubleComplex 'cufftDoubleComplex':
+        double x, y
+
+    # cuFFT Helper Function
+    Result cufftCreate(Handle *plan)
+    Result cufftDestroy(Handle plan)
+    Result cufftSetAutoAllocation(Handle plan, int autoAllocate)
+    Result cufftSetWorkArea(Handle plan, void *workArea)
+
+    # cuFFT Stream Function
+    Result cufftSetStream(Handle plan, Stream streamId)
+
+    # cuFFT Plan Functions
+    Result cufftMakePlan1d(Handle plan, int nx, Type type, int batch,
+                           size_t *workSize)
+    Result cufftMakePlanMany(Handle plan, int rank, int *n, int *inembed,
+                             int istride, int idist, int *onembed, int ostride,
+                             int odist, Type type, int batch,
+                             size_t *workSize)
+
+    # cuFFT Exec Function
+    Result cufftExecC2C(Handle plan, Complex *idata, Complex *odata,
+                        int direction)
+    Result cufftExecR2C(Handle plan, Float *idata, Complex *odata)
+    Result cufftExecC2R(Handle plan, Complex *idata, Float *odata)
+    Result cufftExecZ2Z(Handle plan, DoubleComplex *idata,
+                        DoubleComplex *odata, int direction)
+    Result cufftExecD2Z(Handle plan, Double *idata, DoubleComplex *odata)
+    Result cufftExecZ2D(Handle plan, DoubleComplex *idata, Double *odata)
+
+    # Version
+    Result cufftGetVersion(int* version)
+
+    # cufftXt data types
+    ctypedef struct XtArrayDesc 'cudaXtDesc':
+        int version
+        int nGPUs
+        int GPUs[MAX_CUDA_DESCRIPTOR_GPUS]
+        void* data[MAX_CUDA_DESCRIPTOR_GPUS]
+        size_t size[MAX_CUDA_DESCRIPTOR_GPUS]
+        void* cudaXtState
+
+    ctypedef enum XtSubFormat 'cufftXtSubFormat':
+        CUFFT_XT_FORMAT_INPUT
+        CUFFT_XT_FORMAT_OUTPUT
+        CUFFT_XT_FORMAT_INPLACE
+        CUFFT_XT_FORMAT_INPLACE_SHUFFLED
+        CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED
+
+    ctypedef struct XtArray 'cudaLibXtDesc':
+        int version
+        XtArrayDesc* descriptor
+        int library
+        XtSubFormat subFormat
+        void* libDescriptor
+
+    ctypedef enum XtCopyType 'cufftXtCopyType':
+        CUFFT_COPY_HOST_TO_DEVICE = 0x00
+        CUFFT_COPY_DEVICE_TO_HOST = 0x01
+        CUFFT_COPY_DEVICE_TO_DEVICE = 0x02
+
+    # cufftXt functions
+    Result cufftXtSetGPUs(Handle plan, int nGPUs, int* gpus)
+    Result cufftXtSetWorkArea(Handle plan, void** workArea)
+    Result cufftXtMemcpy(Handle plan, void *dst, void *src, XtCopyType type)
+    Result cufftXtExecDescriptorC2C(Handle plan, XtArray* idata,
+                                    XtArray* odata, int direction)
+    Result cufftXtExecDescriptorZ2Z(Handle plan, XtArray* idata,
+                                    XtArray* odata, int direction)
+    Result cufftXtMakePlanMany(Handle plan, int rank, long long int* n,
+                               long long int* inembed,
+                               long long int istride,
+                               long long int idist,
+                               DataType inputtype,
+                               long long int* onembed,
+                               long long int ostride,
+                               long long int odist,
+                               DataType outputtype,
+                               long long int batch, size_t* workSize,
+                               DataType executiontype)
+    Result cufftXtExec(Handle plan, void* inarr, void* outarr, int d)
+
+
+IF CUPY_CUFFT_STATIC:
+    # cuFFT callback
+    cdef extern from 'cupy_cufftXt.h' nogil:
+        ctypedef enum callbackType 'cufftXtCallbackType':
+            pass
+        Result set_callback(Handle, callbackType, bint, void**)
+
+
+cdef dict RESULT = {
+    0: 'CUFFT_SUCCESS',
+    1: 'CUFFT_INVALID_PLAN',
+    2: 'CUFFT_ALLOC_FAILED',
+    3: 'CUFFT_INVALID_TYPE',
+    4: 'CUFFT_INVALID_VALUE',
+    5: 'CUFFT_INTERNAL_ERROR',
+    6: 'CUFFT_EXEC_FAILED',
+    7: 'CUFFT_SETUP_FAILED',
+    8: 'CUFFT_INVALID_SIZE',
+    9: 'CUFFT_UNALIGNED_DATA',
+    10: 'CUFFT_INCOMPLETE_PARAMETER_LIST',
+    11: 'CUFFT_INVALID_DEVICE',
+    12: 'CUFFT_PARSE_ERROR',
+    13: 'CUFFT_NO_WORKSPACE',
+    14: 'CUFFT_NOT_IMPLEMENTED',
+    15: 'CUFFT_LICENSE_ERROR',
+    16: 'CUFFT_NOT_SUPPORTED',
+}
+
+
+class CuFFTError(RuntimeError):
+
+    def __init__(self, int result):
+        self.result = result
+        super(CuFFTError, self).__init__('%s' % (RESULT[result]))
+
+    def __reduce__(self):
+        return (type(self), (self.result,))
+
+
+@cython.profile(False)
+cpdef inline void check_result(int result) except *:
+    if result != 0:
+        raise CuFFTError(result)
+
+
+cpdef int getVersion() except? -1:
+    cdef int version, result
+    result = cufftGetVersion(&version)
+    check_result(result)
+    return version
+
+
+# This is necessary for single-batch transforms: "when batch is one, data is
+# left in the GPU memory in a permutation of the natural output", see
+# https://docs.nvidia.com/cuda/cufft/index.html#multiple-GPU-cufft-intermediate-helper  # NOQA
+cdef _reorder_buffers(Handle plan, intptr_t xtArr, list xtArr_buffer):
+    cdef int i, result, nGPUs
+    cdef intptr_t temp_xtArr
+    cdef XtArray* temp_arr
+    cdef XtArray* arr
+    cdef list gpus = []
+    cdef list sizes = []
+    cdef list temp_xtArr_buffer
+
+    arr = <XtArray*>xtArr
+    nGPUs = len(xtArr_buffer)
+    assert nGPUs == arr.descriptor.nGPUs
+
+    # allocate another buffer to prepare for order conversion
+    for i in range(nGPUs):
+        gpus.append(arr.descriptor.GPUs[i])
+        sizes.append(arr.descriptor.size[i])
+    temp_xtArr, temp_xtArr_buffer = _XtMalloc(gpus, sizes,
+                                              CUFFT_XT_FORMAT_INPLACE)
+    temp_arr = <XtArray*>temp_xtArr
+
+    # Make a device copy to bring the data from the permuted order back to
+    # the natural order. Note that this works because after FFT
+    # arr.subFormat is silently changed to CUFFT_XT_FORMAT_INPLACE_SHUFFLED
+    with nogil:
+        result = cufftXtMemcpy(plan, <void*>temp_arr, <void*>arr,
+                               CUFFT_COPY_DEVICE_TO_DEVICE)
+    check_result(result)
+
+    for i in range(nGPUs):
+        # swap MemoryPointer in xtArr_buffer
+        temp = temp_xtArr_buffer[i]
+        temp_xtArr_buffer[i] = xtArr_buffer[i]
+        xtArr_buffer[i] = temp
+
+        # swap pointer in xtArr
+        arr.descriptor.data[i] = temp_arr.descriptor.data[i]
+        assert arr.descriptor.size[i] == temp_arr.descriptor.size[i]
+        temp_arr.descriptor.data[i] = NULL
+        temp_arr.descriptor.size[i] = 0
+
+    # temp_xtArr now points to the old data, which is now in temp_xtArr_buffer
+    # and will be deallocated after this line (out of scope)
+    _XtFree(temp_xtArr)
+
+
+# This is meant to replace cufftXtMalloc().
+# We need to manage the buffers ourselves in order to 1. avoid excessive,
+# uncessary memory usage, and 2. use CuPy's memory pool.
+cdef _XtMalloc(list gpus, list sizes, XtSubFormat fmt):
+    cdef XtArrayDesc* xtArr_desc
+    cdef XtArray* xtArr
+    cdef list xtArr_buffer = []
+    cdef int i, nGPUs
+    cdef size_t size
+
+    nGPUs = len(gpus)
+    assert nGPUs == len(sizes)
+    xtArr_desc = <XtArrayDesc*>PyMem_Malloc(sizeof(XtArrayDesc))
+    xtArr = <XtArray*>PyMem_Malloc(sizeof(XtArray))
+    c_memset(xtArr_desc, 0, sizeof(XtArrayDesc))
+    c_memset(xtArr, 0, sizeof(XtArray))
+
+    xtArr_desc.nGPUs = nGPUs
+    for i, (gpu, size) in enumerate(zip(gpus, sizes)):
+        prev_device = runtime.getDevice()
+        runtime.setDevice(gpu)
+        try:
+            buf = memory.alloc(size)
+        finally:
+            runtime.setDevice(prev_device)
+        assert gpu == buf.device_id
+        xtArr_buffer.append(buf)
+        xtArr_desc.GPUs[i] = gpu
+        xtArr_desc.data[i] = <void*><intptr_t>(buf.ptr)
+        xtArr_desc.size[i] = size
+
+    xtArr.descriptor = xtArr_desc
+    xtArr.subFormat = fmt
+
+    return <intptr_t>xtArr, xtArr_buffer
+
+
+# This is meant to replace cufftXtFree().
+# We only free the C structs. The underlying GPU buffers are deallocated when
+# going out of scope.
+cdef _XtFree(intptr_t ptr):
+    cdef XtArray* xtArr = <XtArray*>ptr
+    cdef XtArrayDesc* xtArr_desc = xtArr.descriptor
+    PyMem_Free(xtArr_desc)
+    PyMem_Free(xtArr)
+
+
+cdef class Plan1d:
+    def __init__(self, int nx, int fft_type, int batch, *,
+                 devices=None, out=None):
+        cdef Handle plan
+        cdef bint use_multi_gpus = 0 if devices is None else 1
+        cdef int result
+
+        self.handle = <intptr_t>0
+        self.xtArr = <intptr_t>0  # pointer to metadata for multi-GPU buffer
+        self.xtArr_buffer = None  # actual multi-GPU intermediate buffer
+
+        with nogil:
+            result = cufftCreate(&plan)
+            if result == 0:
+                result = cufftSetAutoAllocation(plan, 0)
+        check_result(result)
+
+        self.handle = <intptr_t>plan
+        self.work_area = None
+        self.gpus = None
+
+        self.gather_streams = None
+        self.gather_events = None
+        self.scatter_streams = None
+        self.scatter_events = None
+
+        if batch != 0:
+            # set plan, work_area, gpus, streams, and events
+            if not use_multi_gpus:
+                self._single_gpu_get_plan(plan, nx, fft_type, batch)
+            else:
+                self._multi_gpu_get_plan(
+                    plan, nx, fft_type, batch, devices, out)
+        else:
+            if use_multi_gpus:
+                # multi-GPU FFT cannot transform 0-size arrays, and attempting
+                # to create such a plan will error out, but we still need this
+                # for bookkeeping
+                if isinstance(devices, (tuple, list)):
+                    self.gpus = list(devices)
+                elif isinstance(devices, int) and devices > 0:
+                    self.gpus = [i for i in range(int)]
+                else:
+                    raise ValueError
+
+        self.nx = nx
+        self.fft_type = <Type>fft_type
+        self.batch = batch
+        self.batch_share = None
+
+    cdef void _single_gpu_get_plan(self, Handle plan, int nx, int fft_type,
+                                   int batch) except*:
+        cdef int result
+        cdef size_t work_size
+        cdef intptr_t ptr
+
+        with nogil:
+            result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                     &work_size)
+
+        # cufftMakePlan1d uses large memory when nx has large divisor.
+        # See https://github.com/cupy/cupy/issues/1063
+        if result == 2:
+            cupy.get_default_memory_pool().free_all_blocks()
+            with nogil:
+                result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                         &work_size)
+        check_result(result)
+
+        work_area = memory.alloc(work_size)
+        ptr = <intptr_t>(work_area.ptr)
+        with nogil:
+            result = cufftSetWorkArea(plan, <void*>(ptr))
+        check_result(result)
+
+        self.work_area = work_area  # this is for cuFFT plan
+
+    cdef void _multi_gpu_get_plan(self, Handle plan, int nx, int fft_type,
+                                  int batch, devices, out) except*:
+        cdef int nGPUs, min_len, result
+        cdef vector.vector[int] gpus
+        cdef vector.vector[size_t] work_size
+        cdef list work_area = []
+        cdef list gather_streams = []
+        cdef list gather_events = []
+        cdef vector.vector[void*] work_area_ptr
+
+        # some sanity checks
+        if runtime.is_hip:
+            raise RuntimeError('hipFFT/rocFFT does not support multi-GPU FFT')
+        if fft_type != CUFFT_C2C and fft_type != CUFFT_Z2Z:
+            raise ValueError('Currently for multiple GPUs only C2C and Z2Z are'
+                             ' supported.')
+        if isinstance(devices, (tuple, list)):
+            nGPUs = len(devices)
+            for i in range(nGPUs):
+                gpus.push_back(devices[i])
+        elif isinstance(devices, int):
+            nGPUs = devices
+            for i in range(nGPUs):
+                gpus.push_back(i)
+        else:
+            raise ValueError('\"devices\" should be an int or an iterable '
+                             'of int.')
+        if batch == 1:
+            if (nx & (nx - 1)) != 0:
+                raise ValueError('For multi-GPU FFT with batch = 1, the array '
+                                 'size must be a power of 2.')
+            if nGPUs not in (2, 4, 8, 16):
+                raise ValueError('For multi-GPU FFT with batch = 1, the number'
+                                 ' of devices must be 2, 4, 8, or 16.')
+            if nGPUs in (2, 4):
+                min_len = 64
+            elif nGPUs == 8:
+                min_len = 128
+            else:  # nGPU = 16
+                min_len = 1024
+            if nx < min_len:
+                raise ValueError('For {} GPUs, the array length must be at '
+                                 'least {} (you have {}).'
+                                 .format(nGPUs, min_len, nx))
+        work_size.resize(nGPUs)
+
+        with nogil:
+            result = cufftXtSetGPUs(plan, nGPUs, gpus.data())
+            if result == 0:
+                result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                         work_size.data())
+
+        # cufftMakePlan1d uses large memory when nx has large divisor.
+        # See https://github.com/cupy/cupy/issues/1063
+        if result == 2:
+            cupy.get_default_memory_pool().free_all_blocks()
+            with nogil:
+                result = cufftMakePlan1d(plan, nx, <Type>fft_type, batch,
+                                         work_size.data())
+        check_result(result)
+
+        for i in range(nGPUs):
+            prev_device = runtime.getDevice()
+            runtime.setDevice(gpus[i])
+            try:
+                buf = memory.alloc(work_size[i])
+                s = stream.Stream()
+                e = stream.Event()
+            finally:
+                runtime.setDevice(prev_device)
+            work_area.append(buf)
+            work_area_ptr.push_back(<void*><intptr_t>(buf.ptr))
+            gather_streams.append(s)
+            gather_events.append(e)
+        with nogil:
+            result = cufftXtSetWorkArea(plan, work_area_ptr.data())
+        check_result(result)
+
+        self.work_area = work_area  # this is for cuFFT plan
+        self.gpus = list(gpus)
+
+        # For async, overlapped copies. We need to distinguish scatter and
+        # gather because for async memcpy, the stream is on the source device
+        self.gather_streams = gather_streams
+        self.gather_events = gather_events
+        self.scatter_streams = {}
+        self.scatter_events = {}
+        self._multi_gpu_get_scatter_streams_events(runtime.getDevice())
+
+    def _multi_gpu_get_scatter_streams_events(self, int curr_device):
+        '''
+        create a list of streams and events on the current device
+        '''
+        cdef int i
+        cdef list scatter_streams = []
+        cdef list scatter_events = []
+
+        assert curr_device in self.gpus
+        prev_device = runtime.getDevice()
+        runtime.setDevice(curr_device)
+        try:
+            for i in self.gpus:
+                scatter_streams.append(stream.Stream())
+                scatter_events.append(stream.Event())
+        finally:
+            runtime.setDevice(prev_device)
+        self.scatter_streams[curr_device] = scatter_streams
+        self.scatter_events[curr_device] = scatter_events
+
+    def __dealloc__(self):
+        cdef Handle plan = <Handle>self.handle
+        cdef int dev, result
+
+        if self.xtArr != 0:
+            _XtFree(self.xtArr)
+            self.xtArr = 0
+
+        try:
+            dev = runtime.getDevice()
+        except Exception as e:
+            # hack: the runtime module is purged at interpreter shutdown,
+            # since this is not a __del__ method, we can't use
+            # cupy._util.is_shutting_down()...
+            return
+
+        if plan != <Handle>0:
+            with nogil:
+                result = cufftDestroy(plan)
+            check_result(result)
+            self.handle = <intptr_t>0
+
+        # cuFFT bug: after cufftDestroy(), the current device is mistakenly
+        # set to the last device in self.gpus, so we must correct it. See
+        # https://github.com/cupy/cupy/pull/2644#discussion_r347567899 and
+        # NVIDIA internal ticket 2761341.
+        runtime.setDevice(dev)
+
+    def __enter__(self):
+        _thread_local._current_plan = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _thread_local._current_plan = None
+
+    def fft(self, a, out, direction):
+        if self.gpus is not None:
+            self._multi_gpu_fft(a, out, direction)
+        else:
+            self._single_gpu_fft(a, out, direction)
+
+    def _single_gpu_fft(self, a, out, direction):
+        cdef intptr_t plan = self.handle
+        cdef intptr_t s = stream.get_current_stream().ptr
+        cdef int result
+
+        with nogil:
+            result = cufftSetStream(<Handle>plan, <Stream>s)
+        check_result(result)
+
+        if self.fft_type == CUFFT_C2C:
+            execC2C(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_R2C:
+            execR2C(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_C2R:
+            execC2R(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2Z:
+            execZ2Z(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_D2Z:
+            execD2Z(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2D:
+            execZ2D(plan, a.data.ptr, out.data.ptr)
+        else:
+            raise ValueError
+
+    def _multi_gpu_setup_buffer(self, a):
+        cdef XtArrayDesc* xtArr_desc
+        cdef XtArray* xtArr
+        cdef intptr_t ptr
+        cdef list xtArr_buffer, share, sizes
+        cdef int i, nGPUs
+        cdef XtSubFormat fmt
+
+        # First, get the buffers:
+        # We need to manage the buffers ourselves in order to avoid excessive,
+        # uncessary memory usage. Note that these buffers are used for in-place
+        # transforms, and are re-used (lifetime tied to the plan).
+
+        if isinstance(a, cupy.ndarray) or isinstance(a, numpy.ndarray):
+            if self.xtArr == 0 and self.xtArr_buffer is None:
+                nGPUs = len(self.gpus)
+
+                # this is the rule for distributing the workload
+                if self.batch > 1:
+                    share = [self.batch // nGPUs] * nGPUs
+                    for i in range(self.batch % nGPUs):
+                        share[i] += 1
+                else:
+                    share = [1.0 / nGPUs] * nGPUs
+                sizes = [int(share[i] * self.nx * a.dtype.itemsize)
+                         for i in range(nGPUs)]
+
+                # get buffer
+                if isinstance(a, cupy.ndarray):
+                    fmt = CUFFT_XT_FORMAT_INPLACE
+                else:  # from numpy
+                    fmt = CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED
+                ptr, xtArr_buffer = _XtMalloc(self.gpus, sizes, fmt)
+
+                xtArr = <XtArray*>ptr
+                xtArr_desc = xtArr.descriptor
+                assert xtArr_desc.nGPUs == nGPUs
+
+                self.batch_share = share
+                self.xtArr = ptr
+                self.xtArr_buffer = xtArr_buffer  # kept to ensure lifetime
+            else:
+                # After FFT the subFormat flag is silently changed to
+                # CUFFT_XT_FORMAT_INPLACE_SHUFFLED. For reuse we must correct
+                # it, otherwise in the next run we would encounter
+                # CUFFT_INVALID_TYPE!
+                ptr = self.xtArr
+                xtArr = <XtArray*>ptr
+                if self.batch == 1:
+                    if isinstance(a, cupy.ndarray):
+                        fmt = CUFFT_XT_FORMAT_INPLACE
+                    else:  # from numpy
+                        fmt = CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED
+                    xtArr.subFormat = fmt
+        elif isinstance(a, list):
+            # TODO(leofang): For users running Plan1d.fft() (bypassing all
+            # checks in cupy.fft.fft), they are allowed to send in a list of
+            # ndarrays, each of which is on a different GPU. Then, no data
+            # copy is needed, just replace the pointers in the descriptor.
+            raise NotImplementedError('User-managed buffer area is not yet '
+                                      'supported.')
+        else:
+            raise ValueError('Impossible to reach.')
+
+    def _multi_gpu_memcpy(self, a, str action):
+        cdef Handle plan = <Handle>self.handle
+        cdef list xtArr_buffer, share
+        cdef int nGPUs, dev, s_device, start, count, result
+        cdef XtArray* arr
+        cdef intptr_t ptr, ptr2
+        cdef size_t size
+
+        assert isinstance(a, (cupy.ndarray, numpy.ndarray))
+
+        start = 0
+        assert a.flags.c_contiguous  # NumPy does not have _c_contiguous
+        b = a.ravel()
+        assert b.flags['OWNDATA'] is False
+        assert self.xtArr_buffer is not None
+        ptr = self.xtArr
+        arr = <XtArray*>ptr
+        xtArr_buffer = self.xtArr_buffer
+        nGPUs = len(self.gpus)
+        share = self.batch_share
+
+        if action == 'scatter':
+            if isinstance(a, cupy.ndarray):
+                s_device = b.data.device_id
+                if s_device not in self.scatter_streams:
+                    self._multi_gpu_get_scatter_streams_events(s_device)
+
+                # When we come here, another stream could still be
+                # copying data for us, so we wait patiently...
+                outer_stream = stream.get_current_stream()
+                outer_stream.synchronize()
+
+                for dev in range(nGPUs):
+                    count = int(share[dev] * self.nx)
+                    size = count * b.dtype.itemsize
+                    curr_stream = self.scatter_streams[s_device][dev]
+                    curr_event = self.scatter_events[s_device][dev]
+                    xtArr_buffer[dev].copy_from_device_async(
+                        b[start:start+count].data, size, curr_stream)
+                    if dev != 0:
+                        prev_event = self.scatter_events[s_device][dev-1]
+                        curr_stream.wait_event(prev_event)
+                    curr_event.record(curr_stream)
+                    start += count
+                assert start == b.size
+                self.scatter_events[s_device][-1].synchronize()
+            else:  # numpy
+                ptr2 = b.ctypes.data
+                with nogil:
+                    result = cufftXtMemcpy(
+                        plan, <void*>arr, <void*>ptr2,
+                        CUFFT_COPY_HOST_TO_DEVICE)
+                check_result(result)
+        elif action == 'gather':
+            if isinstance(a, cupy.ndarray):
+                if self.batch == 1:
+                    _reorder_buffers(plan, self.xtArr, xtArr_buffer)
+
+                # When we come here, another stream could still be
+                # copying data for us, so we wait patiently...
+                outer_stream = stream.get_current_stream()
+                outer_stream.synchronize()
+
+                for i in range(nGPUs):
+                    count = int(share[i] * self.nx)
+                    size = count * b.dtype.itemsize
+                    curr_stream = self.gather_streams[i]
+                    curr_event = self.gather_events[i]
+                    b[start:start+count].data.copy_from_device_async(
+                        xtArr_buffer[i], size, curr_stream)
+                    if i != 0:
+                        prev_event = self.gather_events[i-1]
+                        curr_stream.wait_event(prev_event)
+                    curr_event.record(curr_stream)
+                    start += count
+                assert start == b.size
+                self.gather_events[-1].synchronize()
+            else:  # numpy
+                ptr2 = b.ctypes.data
+                with nogil:
+                    result = cufftXtMemcpy(
+                        plan, <void*>ptr2, <void*>arr,
+                        CUFFT_COPY_DEVICE_TO_HOST)
+                check_result(result)
+        else:
+            raise ValueError
+
+    def _multi_gpu_fft(self, a, out, direction):
+        # When we arrive here, the normal CuPy call path ensures a and out
+        # reside on the same GPU -> must distribute a to all of the GPUs
+        self._multi_gpu_setup_buffer(a)
+
+        # Next, copy data to buffer
+        self._multi_gpu_memcpy(a, 'scatter')
+
+        # Actual workhorses
+        # Note: mult-GPU plans cannot set stream
+        cdef intptr_t plan = self.handle
+        if self.fft_type == CUFFT_C2C:
+            multi_gpu_execC2C(plan, self.xtArr, self.xtArr, direction)
+        elif self.fft_type == CUFFT_Z2Z:
+            multi_gpu_execZ2Z(plan, self.xtArr, self.xtArr, direction)
+        else:
+            raise ValueError
+
+        # Gather the distributed outputs
+        self._multi_gpu_memcpy(out, 'gather')
+
+    def _output_dtype_and_shape(self, a):
+        shape = list(a.shape)
+        if self.fft_type == CUFFT_C2C:
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_R2C:
+            shape[-1] = shape[-1] // 2 + 1
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_C2R:
+            shape[-1] = self.nx
+            dtype = numpy.float32
+        elif self.fft_type == CUFFT_Z2Z:
+            dtype = numpy.complex128
+        elif self.fft_type == CUFFT_D2Z:
+            shape[-1] = shape[-1] // 2 + 1
+            dtype = numpy.complex128
+        else:
+            shape[-1] = self.nx
+            dtype = numpy.float64
+        return tuple(shape), dtype
+
+    def get_output_array(self, a):
+        shape, dtype = self._output_dtype_and_shape(a)
+        return cupy.empty(shape, dtype)
+
+    def check_output_array(self, a, out):
+        """Verify shape and dtype of the output array.
+
+        Parameters
+        ----------
+        a : cupy.array
+            The input to the transform
+        out : cupy.array
+            The array where the output of the transform will be stored.
+        """
+        shape, dtype = self._output_dtype_and_shape(a)
+        if out.shape != shape:
+            raise ValueError(
+                ('out must have shape {}.').format(shape))
+        if out.dtype != dtype:
+            raise ValueError(
+                'out dtype mismatch: found {}, expected {}'.format(
+                    out.dtype, dtype))
+
+
+cdef class PlanNd:
+    def __init__(self, object shape, object inembed, int istride,
+                 int idist, object onembed, int ostride, int odist,
+                 int fft_type, int batch, str order, int last_axis, last_size):
+        cdef Handle plan
+        cdef size_t work_size
+        cdef int ndim, result
+        cdef vector.vector[int] shape_arr = shape
+        cdef vector.vector[int] inembed_arr
+        cdef vector.vector[int] onembed_arr
+        cdef int* shape_ptr = shape_arr.data()
+        cdef int* inembed_ptr
+        cdef int* onembed_ptr
+        cdef intptr_t ptr
+
+        self.handle = <intptr_t>0
+        ndim = len(shape)
+
+        if inembed is None:
+            inembed_ptr = NULL  # ignore istride and use default strides
+        else:
+            inembed_arr = inembed
+            inembed_ptr = inembed_arr.data()
+
+        if onembed is None:
+            onembed_ptr = NULL  # ignore ostride and use default strides
+        else:
+            onembed_arr = onembed
+            onembed_ptr = onembed_arr.data()
+
+        with nogil:
+            result = cufftCreate(&plan)
+            if result == 0:
+                result = cufftSetAutoAllocation(plan, 0)
+        check_result(result)
+
+        self.handle = <intptr_t>plan
+        self.gpus = None  # TODO(leofang): support multi-GPU PlanNd
+
+        if batch == 0:
+            work_size = 0
+        else:
+            with nogil:
+                result = cufftMakePlanMany(plan, ndim, shape_ptr,
+                                           inembed_ptr, istride, idist,
+                                           onembed_ptr, ostride, odist,
+                                           <Type>fft_type, batch,
+                                           &work_size)
+
+            # cufftMakePlanMany could use a large amount of memory
+            if result == 2:
+                cupy.get_default_memory_pool().free_all_blocks()
+                with nogil:
+                    result = cufftMakePlanMany(plan, ndim, shape_ptr,
+                                               inembed_ptr, istride, idist,
+                                               onembed_ptr, ostride, odist,
+                                               <Type>fft_type, batch,
+                                               &work_size)
+            check_result(result)
+
+        # TODO: for CUDA>=9.2 could also allow setting a work area policy
+        # result = cufftXtSetWorkAreaPolicy(plan, policy, &work_size)
+
+        work_area = memory.alloc(work_size)
+        ptr = <intptr_t>(work_area.ptr)
+        with nogil:
+            result = cufftSetWorkArea(plan, <void*>(ptr))
+        check_result(result)
+
+        self.shape = tuple(shape)
+        self.fft_type = <Type>fft_type
+        self.work_area = work_area
+        self.order = order  # either 'C' or 'F'
+        self.last_axis = last_axis  # ignored for C2C
+        self.last_size = last_size  # = None (and ignored) for C2C
+
+    def __dealloc__(self):
+        cdef Handle plan = <Handle>self.handle
+        cdef int result
+
+        if plan != <Handle>0:
+            with nogil:
+                result = cufftDestroy(plan)
+            check_result(result)
+            self.handle = <intptr_t>0
+
+    def __enter__(self):
+        _thread_local._current_plan = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _thread_local._current_plan = None
+
+    def fft(self, a, out, direction):
+        cdef intptr_t plan = self.handle
+        cdef intptr_t s = stream.get_current_stream().ptr
+        cdef int result
+
+        with nogil:
+            result = cufftSetStream(<Handle>plan, <Stream>s)
+        check_result(result)
+
+        if self.fft_type == CUFFT_C2C:
+            execC2C(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_R2C:
+            execR2C(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_C2R:
+            execC2R(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2Z:
+            execZ2Z(plan, a.data.ptr, out.data.ptr, direction)
+        elif self.fft_type == CUFFT_D2Z:
+            execD2Z(plan, a.data.ptr, out.data.ptr)
+        elif self.fft_type == CUFFT_Z2D:
+            execZ2D(plan, a.data.ptr, out.data.ptr)
+        else:
+            raise ValueError
+
+    def _output_dtype_and_shape(self, a):
+        shape = list(a.shape)
+        if self.fft_type == CUFFT_C2C:
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_R2C:
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.complex64
+        elif self.fft_type == CUFFT_C2R:
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.float32
+        elif self.fft_type == CUFFT_Z2Z:
+            dtype = numpy.complex128
+        elif self.fft_type == CUFFT_D2Z:
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.complex128
+        else:  # CUFFT_Z2D
+            shape[self.last_axis] = self.last_size
+            dtype = numpy.float64
+        return tuple(shape), dtype
+
+    def get_output_array(self, a, order='C'):
+        shape, dtype = self._output_dtype_and_shape(a)
+        return cupy.empty(shape, dtype, order=order)
+
+    def check_output_array(self, a, out):
+        if out is a:
+            # TODO(leofang): think about in-place transforms for C2R & R2C
+            return
+        if self.fft_type in (CUFFT_C2C, CUFFT_Z2Z):
+            if out.shape != a.shape:
+                raise ValueError('output shape mismatch')
+            if out.dtype != a.dtype:
+                raise ValueError('output dtype mismatch')
+        else:
+            if out.ndim != a.ndim:
+                raise ValueError('output dimension mismatch')
+            for i, size in enumerate(out.shape):
+                if (i != self.last_axis and size != a.shape[i]) or \
+                   (i == self.last_axis and size != self.last_size):
+                    raise ValueError('output shape is incorrecct')
+            if self.fft_type in (CUFFT_R2C, CUFFT_D2Z):
+                if out.dtype != cupy.dtype(a.dtype.char.upper()):
+                    raise ValueError('output dtype is unexpected')
+            else:  # CUFFT_C2R or CUFFT_Z2D
+                if out.dtype != cupy.dtype(a.dtype.char.lower()):
+                    raise ValueError('output dtype is unexpected')
+        if not ((out.flags.f_contiguous == a.flags.f_contiguous) and
+                (out.flags.c_contiguous == a.flags.c_contiguous)):
+            raise ValueError('output contiguity mismatch')
+
+
+# TODO(leofang): Unify with PlanND?!
+# TODO(leofang): support cufftXtSetGPUs?
+cdef class XtPlanNd:
+    def __init__(self, shape,
+                 inembed, long long int istride, long long int idist, idtype,
+                 onembed, long long int ostride, long long int odist, odtype,
+                 long long int batch, edtype, *,
+                 str order, int last_axis, last_size):
+        # Note: we don't pass in fft_type here because it's redundant and
+        # does not cover exotic types like complex32 or bf16
+
+        cdef Handle plan
+        cdef size_t work_size
+        cdef int ndim, result
+        cdef vector.vector[long long int] shape_arr = shape
+        cdef vector.vector[long long int] inembed_arr
+        cdef vector.vector[long long int] onembed_arr
+        cdef long long int* shape_ptr = shape_arr.data()
+        cdef long long int* inembed_ptr
+        cdef long long int* onembed_ptr
+
+        self.handle = <intptr_t>0
+        ndim = len(shape)
+
+        if inembed is None:
+            inembed_ptr = NULL  # ignore istride and use default strides
+        else:
+            inembed_arr = inembed
+            inembed_ptr = inembed_arr.data()
+
+        if onembed is None:
+            onembed_ptr = NULL  # ignore ostride and use default strides
+        else:
+            onembed_arr = onembed
+            onembed_ptr = onembed_arr.data()
+
+        with nogil:
+            result = cufftCreate(&plan)
+            if result == 0:
+                result = cufftSetAutoAllocation(plan, 0)
+        check_result(result)
+
+        self.handle = <intptr_t>plan
+        self.gpus = None  # TODO(leofang): support multi-GPU plans
+
+        # determine input/output/execution types here; note that we don't
+        # cimport to_cuda_dtype due to circular dependency
+        from cupy._core._dtype import to_cuda_dtype
+        cdef int itype = to_cuda_dtype(idtype, True)
+        cdef int otype = to_cuda_dtype(odtype, True)
+        cdef int etype = to_cuda_dtype(edtype, True)
+
+        cdef long long int length
+        cdef long long int full = 1
+        for length in shape:
+            full *= length
+        length = last_size if last_size is not None else shape[-1]
+        try:
+            self._sanity_checks(itype, otype, etype, length, full)
+        except AssertionError:
+            raise ValueError('input/output/execution types mismatch')
+
+        if batch == 0:
+            work_size = 0
+        else:
+            with nogil:
+                result = cufftXtMakePlanMany(
+                    plan, ndim, shape_ptr,
+                    inembed_ptr, istride, idist, <DataType>itype,
+                    onembed_ptr, ostride, odist, <DataType>otype,
+                    batch, &work_size, <DataType>etype)
+
+            # cufftMakePlanMany could use a large amount of memory
+            if result == 2:
+                cupy.get_default_memory_pool().free_all_blocks()
+                with nogil:
+                    result = cufftXtMakePlanMany(
+                        plan, ndim, shape_ptr,
+                        inembed_ptr, istride, idist, <DataType>itype,
+                        onembed_ptr, ostride, odist, <DataType>otype,
+                        batch, &work_size, <DataType>etype)
+            check_result(result)
+
+        work_area = memory.alloc(work_size)
+        cdef intptr_t ptr = <intptr_t>(work_area.ptr)
+        with nogil:
+            result = cufftSetWorkArea(plan, <void*>(ptr))
+        check_result(result)
+
+        self.shape = tuple(shape)
+        self.itype = itype
+        self.otype = otype
+        self.etype = etype
+        self.work_area = work_area
+        self.order = order  # either 'C' or 'F'
+        self.last_axis = last_axis  # ignored for C2C
+        self.last_size = last_size  # = None (and ignored) for C2C
+
+    def __dealloc__(self):
+        cdef Handle plan = <Handle>self.handle
+        cdef int result
+
+        if plan != <Handle>0:
+            with nogil:
+                result = cufftDestroy(plan)
+            check_result(result)
+            self.handle = <intptr_t>0
+
+    def __enter__(self):
+        _thread_local._current_plan = self
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        _thread_local._current_plan = None
+
+    def fft(self, a, out, direction):
+        cdef intptr_t plan = self.handle
+        cdef intptr_t s = stream.get_current_stream().ptr
+        cdef int result
+
+        with nogil:
+            result = cufftSetStream(<Handle>plan, <Stream>s)
+        check_result(result)
+        XtExec(plan, a.data.ptr, out.data.ptr, direction)
+
+    def _sanity_checks(self, int itype, int otype, int etype,
+                       long long int last_size, long long int full_size):
+        # not every possible type combination is legit
+        # TODO(leofang): support bf16?
+        # C2C
+        if itype == runtime.CUDA_C_16F and otype == runtime.CUDA_C_16F:
+            assert etype == runtime.CUDA_C_16F
+        elif itype == runtime.CUDA_C_32F and otype == runtime.CUDA_C_32F:
+            assert etype == runtime.CUDA_C_32F
+        elif itype == runtime.CUDA_C_64F and otype == runtime.CUDA_C_64F:
+            assert etype == runtime.CUDA_C_64F
+        # C2R
+        elif itype == runtime.CUDA_C_16F and otype == runtime.CUDA_R_16F:
+            assert etype == runtime.CUDA_C_16F
+        elif itype == runtime.CUDA_C_32F and otype == runtime.CUDA_R_32F:
+            assert etype == runtime.CUDA_C_32F
+        elif itype == runtime.CUDA_C_64F and otype == runtime.CUDA_R_64F:
+            assert etype == runtime.CUDA_C_64F
+        # R2C
+        elif itype == runtime.CUDA_R_16F and otype == runtime.CUDA_C_16F:
+            assert etype == runtime.CUDA_C_16F
+        elif itype == runtime.CUDA_R_32F and otype == runtime.CUDA_C_32F:
+            assert etype == runtime.CUDA_C_32F
+        elif itype == runtime.CUDA_R_64F and otype == runtime.CUDA_C_64F:
+            assert etype == runtime.CUDA_C_64F
+        else:
+            assert False
+
+        # check fp16 runtime constraints
+        # https://docs.nvidia.com/cuda/cufft/index.html#half-precision-transforms
+        if etype == runtime.CUDA_C_16F:
+            if int(device.get_compute_capability()) < 53:
+                raise RuntimeError("this device doesn't support complex32 FFT")
+            if (last_size & (last_size - 1)) != 0:
+                raise ValueError('size must be power of 2')
+            if full_size > 4000000000:
+                raise ValueError('input array too large')
+            # TODO(leofang): check if multi-GPU is requested
+        # TODO(leofang): also check for bf16?
+        # https://docs.nvidia.com/cuda/cufft/index.html#bfloat16-precision-transforms
+
+    def _output_dtype_and_shape(self, a):
+        shape = list(a.shape)
+        if self.itype != self.otype:  # R2C or C2R
+            shape[self.last_axis] = self.last_size
+        if self.otype == runtime.CUDA_C_16F:
+            # dtype = numpy.complex32
+            raise NotImplementedError('complex32 is not supported yet, please '
+                                      'allocate the output array manually')
+        elif self.otype == runtime.CUDA_C_32F:
+            dtype = numpy.complex64
+        elif self.otype == runtime.CUDA_C_64F:
+            dtype = numpy.complex128
+        elif self.otype == runtime.CUDA_R_16F:
+            dtype = numpy.float16
+        elif self.otype == runtime.CUDA_R_32F:
+            dtype = numpy.float32
+        elif self.otype == runtime.CUDA_R_64F:
+            dtype = numpy.float64
+        return tuple(shape), dtype
+
+    def get_output_array(self, a, order='C'):
+        shape, dtype = self._output_dtype_and_shape(a)
+        return cupy.empty(shape, dtype, order=order)
+
+
+cpdef execC2C(intptr_t plan, intptr_t idata, intptr_t odata, int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecC2C(h, <Complex*>idata, <Complex*>odata,
+                              direction)
+    check_result(result)
+
+
+cpdef execR2C(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecR2C(h, <Float*>idata, <Complex*>odata)
+    check_result(result)
+
+
+cpdef execC2R(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecC2R(h, <Complex*>idata, <Float*>odata)
+    check_result(result)
+
+
+cpdef execZ2Z(intptr_t plan, intptr_t idata, intptr_t odata, int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecZ2Z(h, <DoubleComplex*>idata,
+                              <DoubleComplex*>odata, direction)
+    check_result(result)
+
+
+cpdef execD2Z(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecD2Z(h, <Double*>idata, <DoubleComplex*>odata)
+    check_result(result)
+
+
+cpdef execZ2D(intptr_t plan, intptr_t idata, intptr_t odata):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftExecZ2D(h, <DoubleComplex*>idata, <Double*>odata)
+    check_result(result)
+
+
+cpdef multi_gpu_execC2C(intptr_t plan, intptr_t idata, intptr_t odata,
+                        int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftXtExecDescriptorC2C(h, <XtArray*>idata,
+                                          <XtArray*>odata, direction)
+    check_result(result)
+
+
+cpdef multi_gpu_execZ2Z(intptr_t plan, intptr_t idata, intptr_t odata,
+                        int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftXtExecDescriptorZ2Z(h, <XtArray*>idata,
+                                          <XtArray*>odata, direction)
+    check_result(result)
+
+
+cpdef XtExec(intptr_t plan, intptr_t idata, intptr_t odata, int direction):
+    cdef Handle h = <Handle>plan
+    cdef int result
+
+    with nogil:
+        result = cufftXtExec(h, <void*>idata, <void*>odata, direction)
+    check_result(result)
+
+
+cpdef intptr_t setCallback(
+        intptr_t plan, int cb_type, bint is_load, intptr_t aux_arr=0):
+    cdef Handle h = <Handle>plan  # no-cython-lint
+    cdef int result  # no-cython-lint
+    cdef void** callerInfo  # no-cython-lint
+
+    IF CUPY_CUFFT_STATIC:
+        with nogil:
+            if aux_arr > 0:
+                callerInfo = (<void**>(&aux_arr))
+            else:
+                callerInfo = NULL
+            result = set_callback(
+                h, <callbackType>cb_type, is_load, callerInfo)
+        check_result(result)
+    ELSE:
+        raise RuntimeError('cuFFT is dynamically linked and thus does not '
+                           'support callback')

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cupy_cub.cu

@@ -0,0 +1,1189 @@
+#include "cupy_cub.h"  // need to make atomicAdd visible to CUB templates early
+#include <cupy/type_dispatcher.cuh>
+
+#ifndef CUPY_USE_HIP
+#include <cfloat> // For FLT_MAX definitions
+#include <cub/device/device_reduce.cuh>
+#include <cub/device/device_segmented_reduce.cuh>
+#include <cub/device/device_spmv.cuh>
+#include <cub/device/device_scan.cuh>
+#include <cub/device/device_histogram.cuh>
+#include <cub/iterator/counting_input_iterator.cuh>
+#include <cub/iterator/transform_input_iterator.cuh>
+#include <cuda/functional>
+#include <cuda/std/functional>
+#else
+#include <hipcub/device/device_reduce.hpp>
+#include <hipcub/device/device_segmented_reduce.hpp>
+#include <hipcub/device/device_scan.hpp>
+#include <hipcub/device/device_histogram.hpp>
+#include <rocprim/iterator/counting_iterator.hpp>
+#include <hipcub/iterator/transform_input_iterator.hpp>
+#endif
+
+
+/* ------------------------------------ Minimum boilerplate to support complex numbers ------------------------------------ */
+#ifndef CUPY_USE_HIP
+// - This works only because all data fields in the *Traits struct are not
+//   used in <cub/device/device_reduce.cuh>.
+// - The Max() and Lowest() below are chosen to comply with NumPy's lexical
+//   ordering; note that std::numeric_limits<T> does not support complex
+//   numbers as in general the comparison is ill defined.
+// - DO NOT USE THIS STUB for supporting CUB sorting!!!!!!
+using namespace cub;
+#define CUPY_CUB_NAMESPACE cub
+
+template <>
+struct FpLimits<complex<float>>
+{
+    static __host__ __device__ __forceinline__ complex<float> Max() {
+        return (complex<float>(FLT_MAX, FLT_MAX));
+    }
+
+    static __host__ __device__ __forceinline__ complex<float> Lowest() {
+        return (complex<float>(FLT_MAX * float(-1), FLT_MAX * float(-1)));
+    }
+};
+
+template <>
+struct FpLimits<complex<double>>
+{
+    static __host__ __device__ __forceinline__ complex<double> Max() {
+        return (complex<double>(DBL_MAX, DBL_MAX));
+    }
+
+    static __host__ __device__ __forceinline__ complex<double> Lowest() {
+        return (complex<double>(DBL_MAX * double(-1), DBL_MAX * double(-1)));
+    }
+};
+
+template <> struct NumericTraits<complex<float>>  : BaseTraits<FLOATING_POINT, true, false, unsigned int, complex<float>> {};
+template <> struct NumericTraits<complex<double>> : BaseTraits<FLOATING_POINT, true, false, unsigned long long, complex<double>> {};
+
+// need specializations for initial values
+namespace std {
+
+template <>
+class numeric_limits<thrust::complex<float>> {
+  public:
+    static __host__ __device__ thrust::complex<float> infinity() noexcept {
+        return thrust::complex<float>(std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+template <>
+class numeric_limits<thrust::complex<double>> {
+  public:
+    static __host__ __device__ thrust::complex<double> infinity() noexcept {
+        return thrust::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+template <>
+class numeric_limits<__half> {
+  public:
+    static __host__ __device__ constexpr __half infinity() noexcept {
+        unsigned short inf_half = 0x7C00U;
+        #if (defined(_MSC_VER) && _MSC_VER >= 1920)
+        #if CUDA_VERSION < 11030
+        // WAR: CUDA 11.2.x + VS 2019 fails with __builtin_bit_cast
+        union caster {
+            unsigned short u_;
+            __half h_;
+        };
+        return caster{inf_half}.h_;
+        #else  // CUDA_VERSION < 11030
+        // WAR:
+        // - we want a constexpr here, but reinterpret_cast cannot be used
+        // - we want to use std::bit_cast, but it requires C++20 which is too new
+        // - we use the compiler builtin, fortunately both gcc and msvc have it
+        return __builtin_bit_cast(__half, inf_half);
+        #endif
+        #else
+        return *reinterpret_cast<__half*>(&inf_half);
+        #endif
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+}  // namespace std
+
+
+#else
+
+// hipCUB internally uses std::numeric_limits, so we should provide specializations for the complex numbers.
+// Note that there's std::complex, so to avoid name collision we must use the full decoration (thrust::complex)!
+// TODO(leofang): wrap CuPy's thrust namespace with another one (say, cupy::thrust) for safer scope resolution?
+#define CUPY_CUB_NAMESPACE hipcub
+
+namespace std {
+template <>
+class numeric_limits<thrust::complex<float>> {
+  public:
+    static __host__ __device__ thrust::complex<float> max() noexcept {
+        return thrust::complex<float>(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
+    }
+
+    static __host__ __device__ thrust::complex<float> lowest() noexcept {
+        return thrust::complex<float>(-std::numeric_limits<float>::max(), -std::numeric_limits<float>::max());
+    }
+
+    static __host__ __device__ thrust::complex<float> infinity() noexcept {
+        return thrust::complex<float>(std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+template <>
+class numeric_limits<thrust::complex<double>> {
+  public:
+    static __host__ __device__ thrust::complex<double> max() noexcept {
+        return thrust::complex<double>(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
+    }
+
+    static __host__ __device__ thrust::complex<double> lowest() noexcept {
+        return thrust::complex<double>(-std::numeric_limits<double>::max(), -std::numeric_limits<double>::max());
+    }
+
+    static __host__ __device__ thrust::complex<double> infinity() noexcept {
+        return thrust::complex<double>(std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity());
+    }
+
+    static constexpr bool has_infinity = true;
+};
+
+// Copied from https://github.com/ROCmSoftwarePlatform/hipCUB/blob/master-rocm-3.5/hipcub/include/hipcub/backend/rocprim/device/device_reduce.hpp
+// (For some reason the specialization for __half defined in the above file does not work, so we have to go
+// through the same route as we did above for complex numbers.)
+template <>
+class numeric_limits<__half> {
+  public:
+    static __host__ __device__ __half max() noexcept {
+        unsigned short max_half = 0x7bff;
+        __half max_value = *reinterpret_cast<__half*>(&max_half);
+        return max_value;
+    }
+
+    static __host__ __device__ __half lowest() noexcept {
+        unsigned short lowest_half = 0xfbff;
+        __half lowest_value = *reinterpret_cast<__half*>(&lowest_half);
+        return lowest_value;
+    }
+
+    static __host__ __device__ __half infinity() noexcept {
+        unsigned short inf_half = 0x7C00U;
+        __half inf_value = *reinterpret_cast<__half*>(&inf_half);
+        return inf_value;
+    }
+
+    static constexpr bool has_infinity = true;
+};
+}  // namespace std
+
+using namespace hipcub;
+
+#endif  // ifndef CUPY_USE_HIP
+
+__host__ __device__ __half half_negate_inf() {
+    unsigned short minf_half = 0xFC00U;
+    __half* minf_value = reinterpret_cast<__half*>(&minf_half);
+    return *minf_value;
+}
+
+/* ------------------------------------ end of boilerplate ------------------------------------ */
+
+
+/* ------------------------------------ "Patches" to CUB ------------------------------------
+   This stub is needed because CUB does not have a built-in "prod" operator
+*/
+
+//
+// product functor
+//
+#ifdef CUPY_USE_HIP
+struct _multiply
+{
+    template <typename T>
+    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const
+    {
+        return a * b;
+    }
+};
+#else
+using _multiply = cuda::std::multiplies<>;
+#endif
+
+//
+// arange functor: arange(0, n+1) -> arange(0, n+1, step_size)
+//
+struct _arange
+{
+    private:
+        int step_size;
+
+    public:
+    __host__ __device__ __forceinline__ _arange(int i): step_size(i) {}
+    __host__ __device__ __forceinline__ int operator()(const int &in) const {
+        return step_size * in;
+    }
+};
+
+#ifndef CUPY_USE_HIP
+typedef TransformInputIterator<int, _arange, CountingInputIterator<int>> seg_offset_itr;
+#else
+typedef TransformInputIterator<int, _arange, rocprim::counting_iterator<int>> seg_offset_itr;
+#endif
+
+/*
+   These stubs are needed because CUB does not handle NaNs properly, while NumPy has certain
+   behaviors with which we must comply.
+
+   CUDA/HIP have different signatures for Max/Min because of the recent changes in CCCL (for the former).
+*/
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+__host__ __device__ __forceinline__ bool half_isnan(const __half& x) {
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
+    return __hisnan(x);
+#else
+    // TODO: avoid cast to float
+    return isnan(__half2float(x));
+#endif
+}
+
+__host__ __device__ __forceinline__ bool half_less(const __half& l, const __half& r) {
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
+    return l < r;
+#else
+    // TODO: avoid cast to float
+    return __half2float(l) < __half2float(r);
+#endif
+}
+
+__host__ __device__ __forceinline__ bool half_equal(const __half& l, const __half& r) {
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
+    return l == r;
+#else
+    // TODO: avoid cast to float
+    return __half2float(l) == __half2float(r);
+#endif
+}
+#endif
+
+#ifdef CUPY_USE_HIP
+
+//
+// Max()
+//
+
+template <typename T>
+struct select_max {
+    using type = Max;
+};
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ float Max::operator()(const float &a, const float &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ double Max::operator()(const double &a, const double &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<float> Max::operator()(const complex<float> &a, const complex<float> &b) const
+{
+    // - TODO(leofang): just call max() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and max() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<double> Max::operator()(const complex<double> &a, const complex<double> &b) const
+{
+    // - TODO(leofang): just call max() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and max() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? b : a;}
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ __half Max::operator()(const __half &a, const __half &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (half_isnan(a)) {return a;}
+    else if (half_isnan(b)) {return b;}
+    else { return half_less(a, b) ? b : a; }
+}
+#endif
+
+//
+// Min()
+//
+
+template <typename T>
+struct select_min {
+    using type = Min;
+};
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ float Min::operator()(const float &a, const float &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ double Min::operator()(const double &a, const double &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<float> Min::operator()(const complex<float> &a, const complex<float> &b) const
+{
+    // - TODO(leofang): just call min() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and min() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ complex<double> Min::operator()(const complex<double> &a, const complex<double> &b) const
+{
+    // - TODO(leofang): just call min() here when the bug in cupy/complex.cuh is fixed
+    // - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+    // - isnan() and min() are defined in cupy/complex.cuh
+    if (isnan(a)) {return a;}
+    else if (isnan(b)) {return b;}
+    else {return a < b ? a : b;}
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ __half Min::operator()(const __half &a, const __half &b) const
+{
+    // NumPy behavior: NaN is always chosen!
+    if (half_isnan(a)) {return a;}
+    else if (half_isnan(b)) {return b;}
+    else { return half_less(a, b) ? a : b; }
+}
+#endif
+
+#endif  // ifdef CUPY_USE_HIP
+
+//
+// ArgMax()
+//
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, float> ArgMax::operator()(
+    const KeyValuePair<int, float> &a,
+    const KeyValuePair<int, float> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, double> ArgMax::operator()(
+    const KeyValuePair<int, double> &a,
+    const KeyValuePair<int, double> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<float>> ArgMax::operator()(
+    const KeyValuePair<int, complex<float>> &a,
+    const KeyValuePair<int, complex<float>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<double>> ArgMax::operator()(
+    const KeyValuePair<int, complex<double>> &a,
+    const KeyValuePair<int, complex<double>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value > a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, __half> ArgMax::operator()(
+    const KeyValuePair<int, __half> &a,
+    const KeyValuePair<int, __half> &b) const
+{
+    if (half_isnan(a.value))
+        return a;
+    else if (half_isnan(b.value))
+        return b;
+    else if ((half_less(a.value, b.value)) ||
+             (half_equal(a.value, b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+#endif
+
+//
+// ArgMin()
+//
+
+// specialization for float for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, float> ArgMin::operator()(
+    const KeyValuePair<int, float> &a,
+    const KeyValuePair<int, float> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for double for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, double> ArgMin::operator()(
+    const KeyValuePair<int, double> &a,
+    const KeyValuePair<int, double> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<float> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<float>> ArgMin::operator()(
+    const KeyValuePair<int, complex<float>> &a,
+    const KeyValuePair<int, complex<float>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+// specialization for complex<double> for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, complex<double>> ArgMin::operator()(
+    const KeyValuePair<int, complex<double>> &a,
+    const KeyValuePair<int, complex<double>> &b) const
+{
+    if (isnan(a.value))
+        return a;
+    else if (isnan(b.value))
+        return b;
+    else if ((b.value < a.value) || ((a.value == b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+}
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+    && (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+// specialization for half for handling NaNs
+template <>
+__host__ __device__ __forceinline__ KeyValuePair<int, __half> ArgMin::operator()(
+    const KeyValuePair<int, __half> &a,
+    const KeyValuePair<int, __half> &b) const
+{
+    if (half_isnan(a.value))
+        return a;
+    else if (half_isnan(b.value))
+        return b;
+    else if ((half_less(b.value, a.value)) ||
+             (half_equal(a.value, b.value) && (b.key < a.key)))
+        return b;
+    else
+        return a;
+
+}
+#endif
+
+#ifndef CUPY_USE_HIP
+
+//
+// Max()
+//
+
+template <typename T>
+struct select_max {
+#if CCCL_VERSION >= 2008000
+    using type = cuda::maximum<>;
+#else
+    using type = cub::Max;
+#endif
+};
+
+template <typename T>
+struct nan_handling_max {
+    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const {
+        // NumPy behavior: NaN is always chosen!
+        if (isnan(a)) {return a;}
+        else if (isnan(b)) {return b;}
+        else {return a < b ? b : a;}
+    }
+};
+
+template <>
+struct select_max<float> {
+    using type = nan_handling_max<float>;
+};
+
+template <>
+struct select_max<double> {
+    using type = nan_handling_max<double>;
+};
+
+// - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+// - isnan() and max() are defined in cupy/complex.cuh
+template <>
+struct select_max<complex<float>> {
+    using type = nan_handling_max<complex<float>>;
+};
+template <>
+struct select_max<complex<double>> {
+    using type = nan_handling_max<complex<double>>;
+};
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+&& (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+template <>
+struct select_max<__half> {
+    struct type {
+        __host__ __device__ __forceinline__ __half operator()(const __half &a, const __half &b) const {
+            // NumPy behavior: NaN is always chosen!
+            if (half_isnan(a)) {return a;}
+            else if (half_isnan(b)) {return b;}
+            else { return half_less(a, b) ? b : a; }
+        }
+    };
+};
+#endif
+
+//
+// Min()
+//
+template <typename T>
+struct select_min {
+#if CCCL_VERSION >= 2008000
+    using type = cuda::minimum<>;
+#else
+    using type = cub::Min;
+#endif
+};
+
+template <typename T>
+struct nan_handling_min {
+    __host__ __device__ __forceinline__ T operator()(const T &a, const T &b) const {
+        // NumPy behavior: NaN is always chosen!
+        if (isnan(a)) {return a;}
+        else if (isnan(b)) {return b;}
+        else {return a < b ? a : b;}
+    }
+};
+
+template <>
+struct select_min<float> {
+    using type = nan_handling_min<float>;
+};
+
+template <>
+struct select_min<double> {
+    using type = nan_handling_min<double>;
+};
+
+// - NumPy behavior: If both a and b contain NaN, the first argument is chosen
+// - isnan() and min() are defined in cupy/complex.cuh
+template <>
+struct select_min<complex<float>> {
+    using type = nan_handling_min<complex<float>>;
+};
+template <>
+struct select_min<complex<double>> {
+    using type = nan_handling_min<complex<double>>;
+};
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+&& (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+template <>
+struct select_min<__half> {
+    struct type {
+        __host__ __device__ __forceinline__ __half operator()(const __half &a, const __half &b) const {
+            // NumPy behavior: NaN is always chosen!
+            if (half_isnan(a)) {return a;}
+            else if (half_isnan(b)) {return b;}
+            else { return half_less(a, b) ? a: b; }
+        }
+    };
+};
+#endif
+
+#endif  // #ifndef CUPY_USE_HIP
+
+/* ------------------------------------ End of "patches" ------------------------------------ */
+
+//
+// **** CUB Sum ****
+//
+struct _cub_reduce_sum {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        DeviceReduce::Sum(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<T*>(y), num_items, s);
+    }
+};
+
+struct _cub_segmented_reduce_sum {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        DeviceSegmentedReduce::Sum(workspace, workspace_size,
+            static_cast<T*>(x), static_cast<T*>(y), num_segments,
+            offset_start, offset_start+1, s);
+    }
+};
+
+//
+// **** CUB Prod ****
+//
+struct _cub_reduce_prod {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        _multiply product_op;
+        // the init value is cast from 1.0f because on host __half can only be
+        // initialized by float or double; static_cast<__half>(1) = 0 on host.
+        DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<T*>(y), num_items, product_op, static_cast<T>(1.0f), s);
+    }
+};
+
+struct _cub_segmented_reduce_prod {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        _multiply product_op;
+        // the init value is cast from 1.0f because on host __half can only be
+        // initialized by float or double; static_cast<__half>(1) = 0 on host.
+        DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+            static_cast<T*>(x), static_cast<T*>(y), num_segments,
+            offset_start, offset_start+1,
+            product_op, static_cast<T>(1.0f), s);
+    }
+};
+
+//
+// **** CUB Min ****
+//
+struct _cub_reduce_min {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+                static_cast<T*>(y), num_items,
+                typename select_min<T>::type{}, std::numeric_limits<T>::infinity(), s);
+        }
+        else
+        {
+            DeviceReduce::Min(workspace, workspace_size, static_cast<T*>(x),
+                static_cast<T*>(y), num_items, s);
+        }
+    }
+};
+
+struct _cub_segmented_reduce_min {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+                static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                offset_start, offset_start+1,
+                typename select_min<T>::type{}, std::numeric_limits<T>::infinity(), s);
+        }
+        else
+        {
+            DeviceSegmentedReduce::Min(workspace, workspace_size,
+                static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                offset_start, offset_start+1, s);
+        }
+    }
+};
+
+//
+// **** CUB Max ****
+//
+struct _cub_reduce_max {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            // to avoid compiler error: invalid argument type '__half' to unary expression on HIP...
+            if constexpr (std::is_same_v<T, __half>)
+            {
+                DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+                    static_cast<T*>(y), num_items,
+                    typename select_max<T>::type{}, half_negate_inf(), s);
+            }
+            else
+            {
+                DeviceReduce::Reduce(workspace, workspace_size, static_cast<T*>(x),
+                    static_cast<T*>(y), num_items,
+                    typename select_max<T>::type{}, -std::numeric_limits<T>::infinity(), s);
+
+            }
+        }
+        else
+        {
+            DeviceReduce::Max(workspace, workspace_size, static_cast<T*>(x),
+                static_cast<T*>(y), num_items, s);
+        }
+    }
+};
+
+struct _cub_segmented_reduce_max {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_segments, seg_offset_itr offset_start, cudaStream_t s)
+    {
+        if constexpr (std::numeric_limits<T>::has_infinity)
+        {
+            // to avoid compiler error: invalid argument type '__half' to unary expression on HIP...
+            if constexpr (std::is_same_v<T, __half>)
+            {
+                DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+                    static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                    offset_start, offset_start+1,
+                    typename select_max<T>::type{}, half_negate_inf(), s);
+            }
+            else
+            {
+                DeviceSegmentedReduce::Reduce(workspace, workspace_size,
+                    static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                    offset_start, offset_start+1,
+                    typename select_max<T>::type{}, -std::numeric_limits<T>::infinity(), s);
+            }
+        }
+        else
+        {
+            DeviceSegmentedReduce::Max(workspace, workspace_size,
+                static_cast<T*>(x), static_cast<T*>(y), num_segments,
+                offset_start, offset_start+1, s);
+        }
+    }
+};
+
+//
+// **** CUB ArgMin ****
+//
+struct _cub_reduce_argmin {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        DeviceReduce::ArgMin(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<KeyValuePair<int, T>*>(y), num_items, s);
+    }
+};
+
+// TODO(leofang): add _cub_segmented_reduce_argmin
+
+//
+// **** CUB ArgMax ****
+//
+struct _cub_reduce_argmax {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* x, void* y,
+        int num_items, cudaStream_t s)
+    {
+        DeviceReduce::ArgMax(workspace, workspace_size, static_cast<T*>(x),
+            static_cast<KeyValuePair<int, T>*>(y), num_items, s);
+    }
+};
+
+// TODO(leofang): add _cub_segmented_reduce_argmax
+
+//
+// **** CUB SpMV ****
+//
+struct _cub_device_spmv {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* values,
+        void* row_offsets, void* column_indices, void* x, void* y,
+        int num_rows, int num_cols, int num_nonzeros, cudaStream_t stream)
+    {
+        #ifndef CUPY_USE_HIP
+        DeviceSpmv::CsrMV(workspace, workspace_size, static_cast<T*>(values),
+            static_cast<int*>(row_offsets), static_cast<int*>(column_indices),
+            static_cast<T*>(x), static_cast<T*>(y), num_rows, num_cols,
+            num_nonzeros, stream);
+        #endif
+    }
+};
+
+//
+// **** CUB InclusiveSum  ****
+//
+struct _cub_inclusive_sum {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int num_items, cudaStream_t s)
+    {
+        DeviceScan::InclusiveSum(workspace, workspace_size, static_cast<T*>(input),
+            static_cast<T*>(output), num_items, s);
+    }
+};
+
+//
+// **** CUB inclusive product  ****
+//
+struct _cub_inclusive_product {
+    template <typename T>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int num_items, cudaStream_t s)
+    {
+        _multiply product_op;
+        DeviceScan::InclusiveScan(workspace, workspace_size, static_cast<T*>(input),
+            static_cast<T*>(output), product_op, num_items, s);
+    }
+};
+
+//
+// **** CUB histogram range ****
+//
+struct _cub_histogram_range {
+    template <typename sampleT,
+              typename binT = typename std::conditional<std::is_integral<sampleT>::value, double, sampleT>::type>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int n_bins, void* bins, size_t n_samples, cudaStream_t s) const
+    {
+        // Ugly hack to avoid specializing complex types, which cub::DeviceHistogram does not support.
+        // TODO(leofang): revisit this part when complex support is added to cupy.histogram()
+        typedef typename std::conditional<(std::is_same<sampleT, complex<float>>::value || std::is_same<sampleT, complex<double>>::value),
+                                          double,
+                                          sampleT>::type h_sampleT;
+        typedef typename std::conditional<(std::is_same<binT, complex<float>>::value || std::is_same<binT, complex<double>>::value),
+                                          double,
+                                          binT>::type h_binT;
+
+        // TODO(leofang): CUB has a bug that when specializing n_samples with type size_t,
+        // it would error out. Before the fix (thrust/cub#38) is merged we disable the code
+        // path splitting for now. A type/range check must be done in the caller.
+        // TODO(leofang): check if hipCUB has the same bug or not
+
+        // if (n_samples < (1ULL << 31)) {
+            int num_samples = n_samples;
+            DeviceHistogram::HistogramRange(workspace, workspace_size, static_cast<h_sampleT*>(input),
+                #ifndef CUPY_USE_HIP
+                static_cast<long long*>(output), n_bins, static_cast<h_binT*>(bins), num_samples, s);
+                #else
+                // rocPRIM looks up atomic_add() from the namespace rocprim::detail; there's no way we can
+                // inject a "long long" version as we did for CUDA, so we must do it in "unsigned long long"
+                // and convert later...
+                static_cast<unsigned long long*>(output), n_bins, static_cast<h_binT*>(bins), num_samples, s);
+                #endif
+        // } else {
+        //     DeviceHistogram::HistogramRange(workspace, workspace_size, static_cast<h_sampleT*>(input),
+        //         static_cast<long long*>(output), n_bins, static_cast<h_binT*>(bins), n_samples, s);
+        // }
+    }
+};
+
+//
+// **** CUB histogram even ****
+//
+struct _cub_histogram_even {
+    template <typename sampleT>
+    void operator()(void* workspace, size_t& workspace_size, void* input, void* output,
+        int& n_bins, int& lower, int& upper, size_t n_samples, cudaStream_t s) const
+    {
+        #ifndef CUPY_USE_HIP
+        // Ugly hack to avoid specializing numerical types
+        typedef typename std::conditional<std::is_integral<sampleT>::value, sampleT, int>::type h_sampleT;
+        int num_samples = n_samples;
+        static_assert(sizeof(long long) == sizeof(intptr_t), "not supported");
+        DeviceHistogram::HistogramEven(workspace, workspace_size, static_cast<h_sampleT*>(input),
+            static_cast<long long*>(output), n_bins, lower, upper, num_samples, s);
+        #else
+        throw std::runtime_error("HIP is not supported yet");
+        #endif
+    }
+};
+
+//
+// APIs exposed to CuPy
+//
+
+/* -------- device reduce -------- */
+
+void cub_device_reduce(void* workspace, size_t& workspace_size, void* x, void* y,
+    int num_items, cudaStream_t stream, int op, int dtype_id)
+{
+    switch(op) {
+    case CUPY_CUB_SUM:      return dtype_dispatcher(dtype_id, _cub_reduce_sum(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_MIN:      return dtype_dispatcher(dtype_id, _cub_reduce_min(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_MAX:      return dtype_dispatcher(dtype_id, _cub_reduce_max(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_ARGMIN:   return dtype_dispatcher(dtype_id, _cub_reduce_argmin(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_ARGMAX:   return dtype_dispatcher(dtype_id, _cub_reduce_argmax(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_PROD:     return dtype_dispatcher(dtype_id, _cub_reduce_prod(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    default:            throw std::runtime_error("Unsupported operation");
+    }
+}
+
+size_t cub_device_reduce_get_workspace_size(void* x, void* y, int num_items,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_reduce(NULL, workspace_size, x, y, num_items, stream,
+                      op, dtype_id);
+    return workspace_size;
+}
+
+/* -------- device segmented reduce -------- */
+
+void cub_device_segmented_reduce(void* workspace, size_t& workspace_size,
+    void* x, void* y, int num_segments, int segment_size,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    // CUB internally use int for offset...
+    // This iterates over [0, segment_size, 2*segment_size, 3*segment_size, ...]
+    #ifndef CUPY_USE_HIP
+    CountingInputIterator<int> count_itr(0);
+    #else
+    rocprim::counting_iterator<int> count_itr(0);
+    #endif
+    _arange scaling(segment_size);
+    seg_offset_itr itr(count_itr, scaling);
+
+    switch(op) {
+    case CUPY_CUB_SUM:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_sum(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    case CUPY_CUB_MIN:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_min(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    case CUPY_CUB_MAX:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_max(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    case CUPY_CUB_PROD:
+        return dtype_dispatcher(dtype_id, _cub_segmented_reduce_prod(),
+                   workspace, workspace_size, x, y, num_segments, itr, stream);
+    default:
+        throw std::runtime_error("Unsupported operation");
+    }
+}
+
+size_t cub_device_segmented_reduce_get_workspace_size(void* x, void* y,
+    int num_segments, int segment_size,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_segmented_reduce(NULL, workspace_size, x, y,
+                                num_segments, segment_size, stream,
+                                op, dtype_id);
+    return workspace_size;
+}
+
+/*--------- device spmv (sparse-matrix dense-vector multiply) ---------*/
+
+void cub_device_spmv(void* workspace, size_t& workspace_size, void* values,
+    void* row_offsets, void* column_indices, void* x, void* y, int num_rows,
+    int num_cols, int num_nonzeros, cudaStream_t stream,
+    int dtype_id)
+{
+    #ifndef CUPY_USE_HIP
+    return dtype_dispatcher(dtype_id, _cub_device_spmv(),
+                            workspace, workspace_size, values, row_offsets,
+                            column_indices, x, y, num_rows, num_cols,
+                            num_nonzeros, stream);
+    #endif
+}
+
+size_t cub_device_spmv_get_workspace_size(void* values, void* row_offsets,
+    void* column_indices, void* x, void* y, int num_rows, int num_cols,
+    int num_nonzeros, cudaStream_t stream, int dtype_id)
+{
+    size_t workspace_size = 0;
+    #ifndef CUPY_USE_HIP
+    cub_device_spmv(NULL, workspace_size, values, row_offsets, column_indices,
+                    x, y, num_rows, num_cols, num_nonzeros, stream, dtype_id);
+    #endif
+    return workspace_size;
+}
+
+/* -------- device scan -------- */
+
+void cub_device_scan(void* workspace, size_t& workspace_size, void* x, void* y,
+    int num_items, cudaStream_t stream, int op, int dtype_id)
+{
+    switch(op) {
+    case CUPY_CUB_CUMSUM:
+        return dtype_dispatcher(dtype_id, _cub_inclusive_sum(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    case CUPY_CUB_CUMPROD:
+        return dtype_dispatcher(dtype_id, _cub_inclusive_product(),
+                                workspace, workspace_size, x, y, num_items, stream);
+    default:
+        throw std::runtime_error("Unsupported operation");
+    }
+}
+
+size_t cub_device_scan_get_workspace_size(void* x, void* y, int num_items,
+    cudaStream_t stream, int op, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_scan(NULL, workspace_size, x, y, num_items, stream,
+                    op, dtype_id);
+    return workspace_size;
+}
+
+/* -------- device histogram -------- */
+
+void cub_device_histogram_range(void* workspace, size_t& workspace_size, void* x, void* y,
+    int n_bins, void* bins, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    // TODO(leofang): support complex
+    if (dtype_id == CUPY_TYPE_COMPLEX64 || dtype_id == CUPY_TYPE_COMPLEX128) {
+	    throw std::runtime_error("complex dtype is not yet supported");
+    }
+
+    // TODO(leofang): n_samples is of type size_t, but if it's < 2^31 we cast it to int later
+    return dtype_dispatcher(dtype_id, _cub_histogram_range(),
+                            workspace, workspace_size, x, y, n_bins, bins, n_samples, stream);
+}
+
+size_t cub_device_histogram_range_get_workspace_size(void* x, void* y, int n_bins,
+    void* bins, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_histogram_range(NULL, workspace_size, x, y, n_bins, bins, n_samples,
+                               stream, dtype_id);
+    return workspace_size;
+}
+
+void cub_device_histogram_even(void* workspace, size_t& workspace_size, void* x, void* y,
+    int n_bins, int lower, int upper, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    #ifndef CUPY_USE_HIP
+    return dtype_dispatcher(dtype_id, _cub_histogram_even(),
+                            workspace, workspace_size, x, y, n_bins, lower, upper, n_samples, stream);
+    #endif
+}
+
+size_t cub_device_histogram_even_get_workspace_size(void* x, void* y, int n_bins,
+    int lower, int upper, size_t n_samples, cudaStream_t stream, int dtype_id)
+{
+    size_t workspace_size = 0;
+    cub_device_histogram_even(NULL, workspace_size, x, y, n_bins, lower, upper, n_samples,
+                              stream, dtype_id);
+    return workspace_size;
+}

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cupy_cufft.h

@@ -0,0 +1,324 @@
+#ifndef INCLUDE_GUARD_CUPY_CUFFT_H
+#define INCLUDE_GUARD_CUPY_CUFFT_H
+
+/*
+ * Note: this file should *not* be split into 3 and moved under cupy_backends/,
+ * because we need to copy this header to sdist and use it at runtime for cuFFT
+ * callbacks.
+ */
+
+#if !defined(CUPY_NO_CUDA) && !defined(CUPY_USE_HIP)
+#include <cufft.h>
+#include <cufftXt.h>
+
+#elif defined(CUPY_USE_HIP)
+#include <hipfft.h>
+
+extern "C" {
+
+typedef hipfftComplex cufftComplex;
+typedef hipfftDoubleComplex cufftDoubleComplex;
+typedef hipfftReal cufftReal;
+typedef hipfftDoubleReal cufftDoubleReal;
+
+typedef hipfftResult_t cufftResult_t;
+typedef hipfftHandle cufftHandle;
+typedef hipfftType_t cufftType_t;
+typedef hipStream_t cudaStream_t;
+
+// cuFFT Helper Function
+cufftResult_t cufftCreate(cufftHandle* plan) {
+    return hipfftCreate(plan);
+}
+
+cufftResult_t cufftDestroy(cufftHandle plan) {
+    return hipfftDestroy(plan);
+}
+
+cufftResult_t cufftSetAutoAllocation(cufftHandle plan, int autoAllocate) {
+    return hipfftSetAutoAllocation(plan, autoAllocate);
+}
+
+cufftResult_t cufftSetWorkArea(cufftHandle plan, void *workArea) {
+    return hipfftSetWorkArea(plan, workArea);
+}
+
+// cuFFT Stream Function
+cufftResult_t cufftSetStream(cufftHandle plan, cudaStream_t stream) {
+    return hipfftSetStream(plan, stream);
+}
+
+// cuFFT Plan Functions
+cufftResult_t cufftMakePlan1d(cufftHandle plan,
+                              int nx,
+                              cufftType_t type,
+                              int batch,
+                              size_t *workSize) {
+    return hipfftMakePlan1d(plan, nx, type, batch, workSize);
+}
+
+cufftResult_t cufftMakePlanMany(cufftHandle plan,
+                                int rank,
+                                int *n,
+                                int *inembed, int istride, int idist,
+                                int *onembed, int ostride, int odist,
+                                cufftType_t type,
+                                int batch,
+                                size_t *workSize) {
+    return hipfftMakePlanMany(plan, rank, n,
+                              inembed, istride, idist,
+                              onembed, ostride, odist,
+                              type, batch, workSize);
+}
+
+// cuFFT Exec Function
+cufftResult_t cufftExecC2C(cufftHandle plan,
+                           cufftComplex *idata,
+                           cufftComplex *odata,
+                           int direction) {
+    return hipfftExecC2C(plan, idata, odata, direction);
+}
+
+cufftResult_t cufftExecR2C(cufftHandle plan,
+                           cufftReal *idata,
+                           cufftComplex *odata) {
+    return hipfftExecR2C(plan, idata, odata);
+}
+
+cufftResult_t cufftExecC2R(cufftHandle plan,
+                           cufftComplex *idata,
+                           cufftReal *odata) {
+    return hipfftExecC2R(plan, idata, odata);
+}
+
+cufftResult_t cufftExecZ2Z(cufftHandle plan,
+                           cufftDoubleComplex *idata,
+                           cufftDoubleComplex *odata,
+                           int direction) {
+    return hipfftExecZ2Z(plan, idata, odata, direction);
+}
+
+cufftResult_t cufftExecD2Z(cufftHandle plan,
+                           cufftDoubleReal *idata,
+                           cufftDoubleComplex *odata) {
+    return hipfftExecD2Z(plan, idata, odata);
+}
+
+cufftResult_t cufftExecZ2D(cufftHandle plan,
+                           cufftDoubleComplex *idata,
+                           cufftDoubleReal *odata) {
+    return hipfftExecZ2D(plan, idata, odata);
+}
+
+// cuFFT Version
+cufftResult_t cufftGetVersion(int *version) {
+    return hipfftGetVersion(version);
+}
+
+// TODO(leofang): move this header to cupy_backends/ and include hip/cupy_hip_common.h
+typedef enum {} cudaDataType;
+
+// cufftXt functions
+cufftResult_t cufftXtSetGPUs(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtSetWorkArea(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtMemcpy(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtMakePlanMany(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtExec(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtExecDescriptorC2C(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+cufftResult_t cufftXtExecDescriptorZ2Z(...) {
+    return HIPFFT_NOT_IMPLEMENTED;
+}
+
+} // extern "C"
+
+#else  // defined(CUPY_NO_CUDA)
+
+#include "../../cupy_backends/stub/cupy_cuda_common.h"
+#include "../../cupy_backends/stub/cupy_cuComplex.h"
+
+extern "C" {
+
+typedef float cufftReal;
+typedef double cufftDoubleReal;
+typedef cuComplex cufftComplex;
+typedef cuDoubleComplex cufftDoubleComplex;
+
+typedef enum {
+    CUFFT_SUCCESS = 0,
+    CUFFT_INVALID_PLAN = 1,
+    CUFFT_ALLOC_FAILED = 2,
+    CUFFT_INVALID_TYPE = 3,
+    CUFFT_INVALID_VALUE = 4,
+    CUFFT_INTERNAL_ERROR = 5,
+    CUFFT_EXEC_FAILED = 6,
+    CUFFT_SETUP_FAILED = 7,
+    CUFFT_INVALID_SIZE = 8,
+    CUFFT_UNALIGNED_DATA = 9,
+    CUFFT_INCOMPLETE_PARAMETER_LIST = 10,
+    CUFFT_INVALID_DEVICE = 11,
+    CUFFT_PARSE_ERROR = 12,
+    CUFFT_NO_WORKSPACE = 13,
+    CUFFT_NOT_IMPLEMENTED = 14,
+    CUFFT_LICENSE_ERROR = 15,
+    CUFFT_NOT_SUPPORTED = 16,
+} cufftResult_t;
+
+typedef int cufftHandle;
+
+typedef enum {} cufftType_t;
+
+// cuFFT Helper Function
+cufftResult_t cufftCreate(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftDestroy(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftSetAutoAllocation(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftSetWorkArea(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Stream Function
+cufftResult_t cufftSetStream(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Plan Functions
+cufftResult_t cufftMakePlan1d(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftMakePlanMany(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Exec Function
+cufftResult_t cufftExecC2C(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecR2C(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecC2R(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecZ2Z(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecD2Z(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftExecZ2D(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cuFFT Version
+cufftResult_t cufftGetVersion(...) {
+    return CUFFT_SUCCESS;
+}
+
+// cufftXt functions
+cufftResult_t cufftXtSetGPUs(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtSetWorkArea(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtMemcpy(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtMakePlanMany(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtExec(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtExecDescriptorC2C(...) {
+    return CUFFT_SUCCESS;
+}
+
+cufftResult_t cufftXtExecDescriptorZ2Z(...) {
+    return CUFFT_SUCCESS;
+}
+
+}  // extern "C"
+
+#endif  // #if !defined(CUPY_NO_CUDA) && !defined(CUPY_USE_HIP)
+
+#if defined(CUPY_NO_CUDA) || defined(CUPY_USE_HIP)
+// common stubs for both no-cuda and hip environments
+
+extern "C" {
+// cufftXt relevant data structs
+typedef struct cudaXtDesc_t {
+   int version;
+   int nGPUs;
+   int GPUs[64];
+   void* data[64];
+   size_t size[64];
+   void* cudaXtState;
+} cudaXtDesc;
+
+typedef enum cufftXtSubFormat_t {
+    CUFFT_XT_FORMAT_INPUT = 0x00,
+    CUFFT_XT_FORMAT_OUTPUT = 0x01,
+    CUFFT_XT_FORMAT_INPLACE = 0x02,
+    CUFFT_XT_FORMAT_INPLACE_SHUFFLED = 0x03,
+    CUFFT_XT_FORMAT_1D_INPUT_SHUFFLED = 0x04,
+    CUFFT_FORMAT_UNDEFINED = 0x05
+} cufftXtSubFormat;
+
+typedef struct cudaLibXtDesc_t{
+    int version;
+    cudaXtDesc *descriptor;
+    int library;  // libFormat is an undoumented type, so use int here
+    int subFormat;
+    void *libDescriptor;
+} cudaLibXtDesc;
+
+typedef enum cufftXtCopyType_t {
+    CUFFT_COPY_HOST_TO_DEVICE = 0x00,
+    CUFFT_COPY_DEVICE_TO_HOST = 0x01,
+    CUFFT_COPY_DEVICE_TO_DEVICE = 0x02,
+    CUFFT_COPY_UNDEFINED = 0x03
+} cufftXtCopyType;
+
+} // extern "C"
+
+#endif // #if defined(CUPY_NO_CUDA) || defined(CUPY_USE_HIP)
+
+#endif  // INCLUDE_GUARD_CUPY_CUFFT_H

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cupy_cufftXt.cu

@@ -0,0 +1,68 @@
+#include "cupy_cufftXt.h"
+
+
+// this must define d_loadCallbackPtr
+${dev_load_callback_ker}
+
+// this must define d_storeCallbackPtr
+${dev_store_callback_ker}
+
+cufftResult set_callback(cufftHandle plan, cufftXtCallbackType type, bool cb_load, void** callerInfo) {
+    if (cb_load) {
+        switch (type) {
+            #ifdef HAS_LOAD_CALLBACK
+            case CUFFT_CB_LD_COMPLEX: {
+                cufftCallbackLoadC h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_LD_COMPLEX_DOUBLE: {
+                cufftCallbackLoadZ h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_LD_REAL: {
+                cufftCallbackLoadR h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_LD_REAL_DOUBLE: {
+                cufftCallbackLoadD h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_loadCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            #endif  // HAS_LOAD_CALLBACK
+            default: {
+                throw std::runtime_error("unrecognized callback");
+            }
+        }
+    } else {
+        switch (type) {
+            #ifdef HAS_STORE_CALLBACK
+            case CUFFT_CB_ST_COMPLEX: {
+                cufftCallbackStoreC h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_ST_COMPLEX_DOUBLE: {
+                cufftCallbackStoreZ h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_ST_REAL: {
+                cufftCallbackStoreR h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            case CUFFT_CB_ST_REAL_DOUBLE: {
+                cufftCallbackStoreD h_ptr;
+                cudaMemcpyFromSymbol(&h_ptr, d_storeCallbackPtr, sizeof(h_ptr));
+                return cufftXtSetCallback(plan, (void**)&h_ptr, type, callerInfo);
+            }
+            #endif  // HAS_STORE_CALLBACK
+            default: {
+                throw std::runtime_error("unrecognized callback");
+            }
+        }
+    }
+}

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cupy_cufftXt.h

@@ -0,0 +1,10 @@
+#include <cufftXt.h>
+#include <cstdint>
+#include <stdexcept>
+
+
+extern "C" {
+
+cufftResult set_callback(cufftHandle plan, cufftXtCallbackType cbType, bool cb_load, void** callerInfo=NULL);
+
+}

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cupy_thrust.cu

@@ -0,0 +1,526 @@
+#include "cupy_thrust.h"
+#include <cupy/type_dispatcher.cuh>
+#include <thrust/device_ptr.h>
+#include <thrust/device_vector.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/iterator/constant_iterator.h>
+#include <thrust/sequence.h>
+#include <thrust/sort.h>
+#include <thrust/tuple.h>
+#include <thrust/execution_policy.h>
+#include <type_traits>
+#if (__CUDACC_VER_MAJOR__ >11 || (__CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ >= 2) || HIP_VERSION >= 402)
+// This is used to avoid a problem with constexpr in functions declarations introduced in
+// cuda 11.2, MSVC 15 does not fully support it so we need a dummy constexpr declaration
+// that is provided by this header. However optional.h is only available
+// starting CUDA 10.1
+#include <thrust/optional.h>
+
+#ifdef _MSC_VER
+#define THRUST_OPTIONAL_CPP11_CONSTEXPR_LESS constexpr
+#else
+#define THRUST_OPTIONAL_CPP11_CONSTEXPR_LESS THRUST_OPTIONAL_CPP11_CONSTEXPR
+#endif
+
+#endif
+
+
+#if CUPY_USE_HIP
+typedef hipStream_t cudaStream_t;
+namespace cuda {
+    using thrust::hip::par;
+}
+#else // #if CUPY_USE_HIP
+namespace cuda {
+    using thrust::cuda::par;
+}
+#endif // #if CUPY_USE_HIP
+
+
+extern "C" char *cupy_malloc(void *, size_t);
+extern "C" int cupy_free(void *, char *);
+
+
+class cupy_allocator {
+private:
+    void* memory;
+
+public:
+    typedef char value_type;
+
+    cupy_allocator(void* memory) : memory(memory) {}
+
+    char *allocate(size_t num_bytes) {
+        return cupy_malloc(memory, num_bytes);
+    }
+
+    void deallocate(char *ptr, size_t n) {
+        cupy_free(memory, ptr);
+    }
+};
+
+
+/*
+ * ------------------------------------- Minimum boilerplate for NumPy compatibility --------------------------------------
+ * We need a specialized operator< here in order to match the NumPy behavior:
+ * "The sort order for complex numbers is lexicographic. If both the real and imaginary parts are non-nan then the order is
+ * determined by the real parts except when they are equal, in which case the order is determined by the imaginary parts.
+ *
+ * In numpy versions >= 1.4.0 nan values are sorted to the end. The extended sort order is:
+ *     Real: [R, nan]
+ *     Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]
+ * where R is a non-nan real value. Complex values with the same nan placements are sorted according to the non-nan part if
+ * it exists. Non-nan values are sorted as before."
+ * Ref: https://numpy.org/doc/stable/reference/generated/numpy.sort.html
+ */
+
+#if ((__CUDACC_VER_MAJOR__ > 9 || (__CUDACC_VER_MAJOR__ == 9 && __CUDACC_VER_MINOR__ == 2)) \
+&& (__CUDA_ARCH__ >= 530 || !defined(__CUDA_ARCH__))) || (defined(__HIPCC__) || defined(CUPY_USE_HIP))
+    #define ENABLE_HALF
+#endif
+
+#if (__CUDACC_VER_MAJOR__ >11 || (__CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ >= 2))
+    #define CONSTEXPR_FUNC THRUST_OPTIONAL_CPP11_CONSTEXPR
+#else
+    #define CONSTEXPR_FUNC
+#endif
+
+#if (__CUDACC_VER_MAJOR__ >11 || (__CUDACC_VER_MAJOR__ == 11 && __CUDACC_VER_MINOR__ >= 2) || HIP_VERSION >= 402)
+    #define CONSTEXPR_COMPARATOR THRUST_OPTIONAL_CPP11_CONSTEXPR_LESS
+#else
+    #define CONSTEXPR_COMPARATOR
+#endif
+
+#ifdef ENABLE_HALF
+__host__ __device__ __forceinline__ bool isnan(const __half& x) {
+    #if (defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__))
+    return __hisnan(x);
+    #else
+    return false;  // This will never be called on the host
+    #endif
+}
+#endif // ENABLE_HALF
+
+template <typename T>
+__host__ __device__ __forceinline__ CONSTEXPR_FUNC
+static bool real_less(const T& lhs, const T& rhs) {
+#if  (defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__))
+    if (isnan(lhs)) {
+        return false;
+    } else if (isnan(rhs)) {
+        return true;
+    } else {
+        return lhs < rhs;
+    }
+#else
+    return false;  // This will be never executed in the host
+#endif
+}
+
+template <typename T>
+__host__ __device__ __forceinline__ CONSTEXPR_FUNC
+static bool tuple_less(const thrust::tuple<size_t, T>& lhs,
+		 const thrust::tuple<size_t, T>& rhs) {
+    const size_t& lhs_k = thrust::get<0>(lhs);
+    const size_t& rhs_k = thrust::get<0>(rhs);
+    const T& lhs_v = thrust::get<1>(lhs);
+    const T& rhs_v = thrust::get<1>(rhs);
+
+    // tuple's comparison rule: compare the 1st member, then 2nd, then 3rd, ...,
+    // which should be respected
+    if (lhs_k < rhs_k) {
+        return true;
+    } else if (lhs_k == rhs_k) {
+        // same key, compare values
+        // note that we can't rely on native operator< due to NaN, so we rely on our custom comparison object
+        return real_less(lhs_v, rhs_v);
+    } else {
+        return false;
+    }
+}
+
+/*
+ * ********** complex numbers **********
+ * We need a custom comparator because we can't overload operator< for complex numbers...
+ */
+
+template <typename T>
+__host__ __device__ __forceinline__ CONSTEXPR_FUNC
+static bool complex_less(const T& lhs, const T& rhs) {
+    const bool lhsRe = isnan(lhs.real());
+    const bool lhsIm = isnan(lhs.imag());
+    const bool rhsRe = isnan(rhs.real());
+    const bool rhsIm = isnan(rhs.imag());
+
+    // neither side has nan
+    if (!lhsRe && !lhsIm && !rhsRe && !rhsIm) {
+        return lhs < rhs;
+    }
+
+    // one side has nan, and the other does not
+    if (!lhsRe && !lhsIm && (rhsRe || rhsIm)) {
+        return true;
+    }
+    if ((lhsRe || lhsIm) && !rhsRe && !rhsIm) {
+        return false;
+    }
+
+    // pick 2 from 3 possibilities (R + nanj, nan + Rj, nan + nanj)
+    if (lhsRe && !rhsRe) {
+        return false;
+    }
+    if (!lhsRe && rhsRe) {
+        return true;
+    }
+    if (lhsIm && !rhsIm) {
+        return false;
+    }
+    if (!lhsIm && rhsIm) {
+        return true;
+    }
+
+    // pick 1 from 3 and compare the numerical values (nan+nan*I compares to itself as false)
+    return (((lhsIm && rhsIm) && (lhs.real() < rhs.real())) || ((lhsRe && rhsRe) && (lhs.imag() < rhs.imag())));
+}
+
+// Type function giving us the right comparison operator. We use a custom one for all the specializations below,
+// but otherwise just default to thrust::less. We notable do not define a specialization for float and double, since
+// thrust uses radix sort for them and sorts NaNs to the back.
+template <typename T>
+struct select_less {
+    using type = thrust::less<T>;
+};
+
+// complex numbers
+
+template <>
+struct select_less<complex<float>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const complex<float>& lhs, const complex<float>& rhs) const {
+            return complex_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<complex<double>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const complex<double>& lhs, const complex<double>& rhs) const {
+            return complex_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, complex<float>>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, complex<float>>& lhs, const thrust::tuple<size_t, complex<float>>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, complex<double>>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, complex<double>>& lhs, const thrust::tuple<size_t, complex<double>>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, float>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, float>& lhs, const thrust::tuple<size_t, float>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, double>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, double>& lhs, const thrust::tuple<size_t, double>& rhs) const {
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+
+// floating points
+
+template <>
+struct select_less<float> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (const float& lhs, const float& rhs) const {
+            return real_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<double> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (const double& lhs, const double& rhs) const {
+            return real_less(lhs, rhs);
+        }
+    };
+};
+
+#ifdef ENABLE_HALF
+template <>
+struct select_less<__half> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (const __half& lhs, const __half& rhs) const {
+            return real_less(lhs, rhs);
+        }
+    };
+};
+
+template <>
+struct select_less<thrust::tuple<size_t, __half>> {
+    struct type {
+        __host__ __device__ __forceinline__ CONSTEXPR_COMPARATOR
+        bool operator() (
+            const thrust::tuple<size_t, __half>& lhs, const thrust::tuple<size_t, __half>& rhs) const {
+
+            return tuple_less(lhs, rhs);
+        }
+    };
+};
+#endif  // ENABLE_HALF
+
+/*
+ * -------------------------------------------------- end of boilerplate --------------------------------------------------
+ */
+
+
+/*
+ * sort
+ */
+
+struct _sort {
+    template <typename T>
+    __forceinline__ void operator()(void *data_start, size_t *keys_start,
+                                    const std::vector<ptrdiff_t>& shape, intptr_t stream,
+                                    void* memory) {
+        size_t ndim = shape.size();
+        ptrdiff_t size;
+        thrust::device_ptr<T> dp_data_first, dp_data_last;
+        thrust::device_ptr<size_t> dp_keys_first, dp_keys_last;
+        cudaStream_t stream_ = (cudaStream_t)stream;
+        cupy_allocator alloc(memory);
+
+        // Compute the total size of the array.
+        size = shape[0];
+        for (size_t i = 1; i < ndim; ++i) {
+            size *= shape[i];
+        }
+
+        dp_data_first = thrust::device_pointer_cast(static_cast<T*>(data_start));
+        dp_data_last  = thrust::device_pointer_cast(static_cast<T*>(data_start) + size);
+
+        if (ndim == 1) {
+            // we use thrust::less directly to sort floating points, because then it can use radix sort, which happens to sort NaNs to the back
+            using compare_op = std::conditional_t<std::is_floating_point<T>::value, thrust::less<T>, typename select_less<T>::type>;
+            stable_sort(cuda::par(alloc).on(stream_), dp_data_first, dp_data_last, compare_op{});
+        } else {
+            // Generate key indices.
+            dp_keys_first = thrust::device_pointer_cast(keys_start);
+            dp_keys_last  = thrust::device_pointer_cast(keys_start + size);
+            transform(cuda::par(alloc).on(stream_),
+                      #ifdef __HIP_PLATFORM_HCC__
+                      rocprim::make_counting_iterator<size_t>(0),
+                      rocprim::make_counting_iterator<size_t>(size),
+                      rocprim::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #else
+                      thrust::make_counting_iterator<size_t>(0),
+                      thrust::make_counting_iterator<size_t>(size),
+                      thrust::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #endif
+                      dp_keys_first,
+                      thrust::divides<size_t>());
+
+            stable_sort(
+                cuda::par(alloc).on(stream_),
+                make_zip_iterator(dp_keys_first, dp_data_first),
+                make_zip_iterator(dp_keys_last, dp_data_last),
+                typename select_less<thrust::tuple<size_t, T>>::type{});
+        }
+    }
+};
+
+
+/*
+ * lexsort
+ */
+
+template <typename T>
+class elem_less {
+public:
+    elem_less(const T *data):_data(data) {}
+    __device__ __forceinline__ bool operator()(size_t i, size_t j) const {
+        return typename select_less<T>::type{}(_data[i], _data[j]);
+    }
+private:
+    const T *_data;
+};
+
+struct _lexsort {
+    template <typename T>
+    __forceinline__ void operator()(size_t *idx_start, void *keys_start, size_t k,
+                                    size_t n, intptr_t stream, void *memory) {
+        /* idx_start is the beginning of the output array where the indexes that
+           would sort the data will be placed. The original contents of idx_start
+           will be destroyed. */
+        thrust::device_ptr<size_t> dp_first = thrust::device_pointer_cast(idx_start);
+        thrust::device_ptr<size_t> dp_last  = thrust::device_pointer_cast(idx_start + n);
+        cudaStream_t stream_ = (cudaStream_t)stream;
+        cupy_allocator alloc(memory);
+        sequence(cuda::par(alloc).on(stream_), dp_first, dp_last);
+        for (size_t i = 0; i < k; ++i) {
+            T *key_start = static_cast<T*>(keys_start) + i * n;
+            stable_sort(
+                cuda::par(alloc).on(stream_),
+                dp_first,
+                dp_last,
+                elem_less<T>(key_start)
+            );
+        }
+    }
+};
+
+
+/*
+ * argsort
+ */
+
+struct _argsort {
+    template <typename T>
+    __forceinline__ void operator()(size_t *idx_start, void *data_start,
+                                    void *keys_start,
+                                    const std::vector<ptrdiff_t>& shape,
+                                    intptr_t stream, void *memory) {
+        /* idx_start is the beginning of the output array where the indexes that
+           would sort the data will be placed. The original contents of idx_start
+           will be destroyed. */
+
+        size_t ndim = shape.size();
+        ptrdiff_t size;
+        cudaStream_t stream_ = (cudaStream_t)stream;
+        cupy_allocator alloc(memory);
+
+        thrust::device_ptr<size_t> dp_idx_first, dp_idx_last;
+        thrust::device_ptr<T> dp_data_first, dp_data_last;
+        thrust::device_ptr<size_t> dp_keys_first, dp_keys_last;
+
+        // Compute the total size of the data array.
+        size = shape[0];
+        for (size_t i = 1; i < ndim; ++i) {
+            size *= shape[i];
+        }
+
+        // Cast device pointers of data.
+        dp_data_first = thrust::device_pointer_cast(static_cast<T*>(data_start));
+        dp_data_last  = thrust::device_pointer_cast(static_cast<T*>(data_start) + size);
+
+        // Generate an index sequence.
+        dp_idx_first = thrust::device_pointer_cast(static_cast<size_t*>(idx_start));
+        dp_idx_last  = thrust::device_pointer_cast(static_cast<size_t*>(idx_start) + size);
+        transform(cuda::par(alloc).on(stream_),
+                  #ifdef __HIP_PLATFORM_HCC__
+                  rocprim::make_counting_iterator<size_t>(0),
+                  rocprim::make_counting_iterator<size_t>(size),
+                  rocprim::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                  #else
+                  thrust::make_counting_iterator<size_t>(0),
+                  thrust::make_counting_iterator<size_t>(size),
+                  thrust::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                  #endif
+                  dp_idx_first,
+                  thrust::modulus<size_t>());
+
+        if (ndim == 1) {
+            // we use thrust::less directly to sort floating points, because then it can use radix sort, which happens to sort NaNs to the back
+            using compare_op = std::conditional_t<std::is_floating_point<T>::value, thrust::less<T>, typename select_less<T>::type>;
+            // Sort the index sequence by data.
+            stable_sort_by_key(cuda::par(alloc).on(stream_),
+                               dp_data_first,
+                               dp_data_last,
+                               dp_idx_first,
+                               compare_op{});
+        } else {
+            // Generate key indices.
+            dp_keys_first = thrust::device_pointer_cast(static_cast<size_t*>(keys_start));
+            dp_keys_last  = thrust::device_pointer_cast(static_cast<size_t*>(keys_start) + size);
+            transform(cuda::par(alloc).on(stream_),
+                      #ifdef __HIP_PLATFORM_HCC__
+                      rocprim::make_counting_iterator<size_t>(0),
+                      rocprim::make_counting_iterator<size_t>(size),
+                      rocprim::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #else
+                      thrust::make_counting_iterator<size_t>(0),
+                      thrust::make_counting_iterator<size_t>(size),
+                      thrust::make_constant_iterator<ptrdiff_t>(shape[ndim-1]),
+                      #endif
+                      dp_keys_first,
+                      thrust::divides<size_t>());
+
+            stable_sort_by_key(
+                cuda::par(alloc).on(stream_),
+                make_zip_iterator(dp_keys_first, dp_data_first),
+                make_zip_iterator(dp_keys_last, dp_data_last),
+                dp_idx_first,
+                typename select_less<thrust::tuple<size_t, T>>::type{});
+        }
+    }
+};
+
+
+//
+// APIs exposed to CuPy
+//
+
+/* -------- sort -------- */
+
+void thrust_sort(int dtype_id, void *data_start, size_t *keys_start,
+    const std::vector<ptrdiff_t>& shape, intptr_t stream, void* memory) {
+
+    _sort op;
+    return dtype_dispatcher(dtype_id, op, data_start, keys_start, shape, stream, memory);
+}
+
+
+/* -------- lexsort -------- */
+void thrust_lexsort(int dtype_id, size_t *idx_start, void *keys_start, size_t k,
+    size_t n, intptr_t stream, void *memory) {
+
+    _lexsort op;
+    return dtype_dispatcher(dtype_id, op, idx_start, keys_start, k, n, stream, memory);
+}
+
+
+/* -------- argsort -------- */
+void thrust_argsort(int dtype_id, size_t *idx_start, void *data_start,
+    void *keys_start, const std::vector<ptrdiff_t>& shape, intptr_t stream, void *memory) {
+
+    _argsort op;
+    return dtype_dispatcher(dtype_id, op, idx_start, data_start, keys_start, shape,
+                            stream, memory);
+}
+

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/cutensor.py

@@ -0,0 +1,14 @@
+"""
+cuTENSOR Wrapper
+
+Use `cupy_backends.cuda.libs.cutensor` directly in CuPy codebase.
+"""
+
+available = True
+
+try:
+    from cupy_backends.cuda.libs.cutensor import *  # NOQA
+except ImportError as e:
+    available = False
+    from cupy._environment import _preload_warning
+    _preload_warning('cutensor', e)

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/memory_hooks/__init__.py

@@ -0,0 +1,6 @@
+from cupy.cuda.memory_hooks import debug_print  # NOQA
+from cupy.cuda.memory_hooks import line_profile  # NOQA
+
+# import class and function
+from cupy.cuda.memory_hooks.debug_print import DebugPrintHook  # NOQA
+from cupy.cuda.memory_hooks.line_profile import LineProfileHook  # NOQA

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/memory_hooks/debug_print.py

@@ -0,0 +1,78 @@
+import sys
+
+from cupy.cuda import memory_hook
+
+
+class DebugPrintHook(memory_hook.MemoryHook):
+    """Memory hook that prints debug information.
+
+    This memory hook outputs the debug information of input arguments of
+    ``malloc`` and ``free`` methods involved in the hooked functions
+    at postprocessing time (that is, just after each method is called).
+
+    Example:
+        The basic usage is to use it with ``with`` statement.
+
+        Code example::
+
+            >>> import cupy
+            >>> from cupy.cuda import memory_hooks
+            >>>
+            >>> cupy.cuda.set_allocator(cupy.cuda.MemoryPool().malloc)
+            >>> with memory_hooks.DebugPrintHook():
+            ...     x = cupy.array([1, 2, 3])
+            ...     del x  # doctest:+SKIP
+
+        Output example::
+
+            {"hook":"alloc","device_id":0,"mem_size":512,"mem_ptr":150496608256}
+            {"hook":"malloc","device_id":0,"size":24,"mem_size":512,"mem_ptr":150496608256,"pmem_id":"0x7f39200c5278"}
+            {"hook":"free","device_id":0,"mem_size":512,"mem_ptr":150496608256,"pmem_id":"0x7f39200c5278"}
+
+        where the output format is JSONL (JSON Lines) and
+        ``hook`` is the name of hook point, and
+        ``device_id`` is the CUDA Device ID, and
+        ``size`` is the requested memory size to allocate, and
+        ``mem_size`` is the rounded memory size to be allocated, and
+        ``mem_ptr`` is the memory pointer, and
+        ``pmem_id`` is the pooled memory object ID.
+
+    Attributes:
+        file: Output file_like object that redirect to.
+        flush: If ``True``, this hook forcibly flushes the text stream
+            at the end of print. The default is ``True``.
+
+    """
+
+    name = 'DebugPrintHook'
+
+    def __init__(self, file=sys.stdout, flush=True):
+        self.file = file
+        self.flush = flush
+
+    def _print(self, msg):
+        self.file.write(msg)
+        self.file.write('\n')
+        if self.flush:
+            self.file.flush()
+
+    def alloc_postprocess(self, **kwargs):
+        msg = '{"hook":"%s","device_id":%d,' \
+              '"mem_size":%d,"mem_ptr":%d}'
+        msg %= ('alloc', kwargs['device_id'],
+                kwargs['mem_size'], kwargs['mem_ptr'])
+        self._print(msg)
+
+    def malloc_postprocess(self, **kwargs):
+        msg = '{"hook":"%s","device_id":%d,"size":%d,' \
+              '"mem_size":%d,"mem_ptr":%d,"pmem_id":"%s"}'
+        msg %= ('malloc', kwargs['device_id'], kwargs['size'],
+                kwargs['mem_size'], kwargs['mem_ptr'], hex(kwargs['pmem_id']))
+        self._print(msg)
+
+    def free_postprocess(self, **kwargs):
+        msg = '{"hook":"%s","device_id":%d,' \
+              '"mem_size":%d,"mem_ptr":%d,"pmem_id":"%s"}'
+        msg %= ('free', kwargs['device_id'],
+                kwargs['mem_size'], kwargs['mem_ptr'], hex(kwargs['pmem_id']))
+        self._print(msg)

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/memory_hooks/line_profile.py

@@ -0,0 +1,171 @@
+from os import path
+import sys
+import traceback
+
+from cupy.cuda import memory_hook
+
+
+class LineProfileHook(memory_hook.MemoryHook):
+    """Code line CuPy memory profiler.
+
+    This profiler shows line-by-line GPU memory consumption using traceback
+    module. But, note that it can trace only CPython level, no Cython level.
+    ref. https://github.com/cython/cython/issues/1755
+
+    Example:
+        Code example::
+
+            from cupy.cuda import memory_hooks
+            hook = memory_hooks.LineProfileHook()
+            with hook:
+                # some CuPy codes
+            hook.print_report()
+
+        Output example::
+
+            _root (4.00KB, 4.00KB)
+              lib/python3.6/unittest/__main__.py:18:<module> (4.00KB, 4.00KB)
+                lib/python3.6/unittest/main.py:255:runTests (4.00KB, 4.00KB)
+                  tests/cupy_tests/test.py:37:test (1.00KB, 1.00KB)
+                  tests/cupy_tests/test.py:38:test (1.00KB, 1.00KB)
+                  tests/cupy_tests/test.py:39:test (2.00KB, 2.00KB)
+
+        Each line shows::
+
+            {filename}:{lineno}:{func_name} ({used_bytes}, {acquired_bytes})
+
+        where *used_bytes* is the memory bytes used from CuPy memory pool, and
+        *acquired_bytes* is the actual memory bytes the CuPy memory pool
+        acquired from GPU device.
+        *_root* is a root node of the stack trace to show total memory usage.
+
+    Args:
+        max_depth (int): maximum depth to follow stack traces.
+            Default is 0 (no limit).
+    """
+
+    name = 'LineProfileHook'
+
+    def __init__(self, max_depth=0):
+        self._memory_frames = {}
+        self._root = MemoryFrame(None, None)
+        self._filename = path.abspath(__file__)
+        self._max_depth = max_depth
+
+    # callback
+    def malloc_preprocess(self, device_id, size, mem_size):
+        self._create_frame_tree(used_bytes=mem_size)
+
+    # callback
+    def alloc_preprocess(self, device_id, mem_size):
+        self._create_frame_tree(acquired_bytes=mem_size)
+
+    def _create_frame_tree(self, used_bytes=0, acquired_bytes=0):
+        self._root.used_bytes += used_bytes
+        self._root.acquired_bytes += acquired_bytes
+        parent = self._root
+        for depth, stackframe in enumerate(self._extract_stackframes()):
+            if 0 < self._max_depth <= depth + 1:
+                break
+            memory_frame = self._add_frame(parent, stackframe)
+            memory_frame.used_bytes += used_bytes
+            memory_frame.acquired_bytes += acquired_bytes
+            parent = memory_frame
+
+    def _extract_stackframes(self):
+        stackframes = traceback.extract_stack()
+        stackframes = [StackFrame(st) for st in stackframes]
+        stackframes = [
+            st for st in stackframes if st.filename != self._filename]
+        return stackframes
+
+    def _key_frame(self, parent, stackframe):
+        return (parent,
+                stackframe.filename,
+                stackframe.lineno,
+                stackframe.name)
+
+    def _add_frame(self, parent, stackframe):
+        key = self._key_frame(parent, stackframe)
+        if key in self._memory_frames:
+            memory_frame = self._memory_frames[key]
+        else:
+            memory_frame = MemoryFrame(parent, stackframe)
+            self._memory_frames[key] = memory_frame
+        return memory_frame
+
+    def print_report(self, file=sys.stdout):
+        """Prints a report of line memory profiling."""
+        line = '_root (%s, %s)\n' % self._root.humanized_bytes()
+        file.write(line)
+        for child in self._root.children:
+            self._print_frame(child, depth=1, file=file)
+        file.flush()
+
+    def _print_frame(self, memory_frame, depth=0, file=sys.stdout):
+        indent = ' ' * (depth * 2)
+        st = memory_frame.stackframe
+        used_bytes, acquired_bytes = memory_frame.humanized_bytes()
+        line = '%s%s:%s:%s (%s, %s)\n' % (
+            indent, st.filename, st.lineno, st.name,
+            used_bytes, acquired_bytes)
+        file.write(line)
+        for child in memory_frame.children:
+            self._print_frame(child, depth=depth + 1, file=file)
+
+
+class StackFrame(object):
+    """Compatibility layer for outputs of traceback.extract_stack().
+
+    Attributes:
+        filename (string): filename
+        lineno (int): line number
+        name (string): function name
+    """
+
+    def __init__(self, obj):
+        if isinstance(obj, tuple):  # < 3.5
+            self.filename = obj[0]
+            self.lineno = obj[1]
+            self.name = obj[2]
+        else:  # >= 3.5 FrameSummary
+            self.filename = obj.filename
+            self.lineno = obj.lineno
+            self.name = obj.name
+
+
+class MemoryFrame(object):
+    """A single stack frame along with sum of memory usage at the frame.
+
+    Attributes:
+        stackframe (FrameSummary): stackframe from traceback.extract_stack().
+        parent (MemoryFrame): parent frame, that is, caller.
+        children (list of MemoryFrame): child frames, that is, callees.
+        used_bytes (int): memory bytes that users used from CuPy memory pool.
+        acquired_bytes (int): memory bytes that CuPy memory pool acquired
+            from GPU device.
+    """
+
+    def __init__(self, parent, stackframe):
+        self.stackframe = stackframe
+        self.children = []
+        self._set_parent(parent)
+        self.used_bytes = 0
+        self.acquired_bytes = 0
+
+    def humanized_bytes(self):
+        used_bytes = self._humanized_size(self.used_bytes)
+        acquired_bytes = self._humanized_size(self.acquired_bytes)
+        return (used_bytes, acquired_bytes)
+
+    def _set_parent(self, parent):
+        if parent and parent not in parent.children:
+            self.parent = parent
+            parent.children.append(self)
+
+    def _humanized_size(self, size):
+        for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E']:
+            if size < 1024.0:
+                return '%3.2f%sB' % (size, unit)
+            size /= 1024.0
+        return '%.2f%sB' % (size, 'Z')

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/nccl.py

@@ -0,0 +1,17 @@
+"""
+NCCL Wrapper
+
+Use `cupy_backends.cuda.libs.nccl` directly in CuPy codebase.
+"""
+
+from cupy import _environment
+
+
+available = True
+
+try:
+    _environment._preload_library('nccl')
+    from cupy_backends.cuda.libs.nccl import *  # NOQA
+except ImportError as e:
+    available = False
+    _environment._preload_warning('nccl', e)

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/nvtx.py

@@ -0,0 +1 @@
+from cupy_backends.cuda.libs.nvtx import *  # NOQA

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/profiler.py

@@ -0,0 +1,3 @@
+# For backward compatibility only.
+from cupy_backends.cuda.api.runtime import profilerStart as start  # noqa
+from cupy_backends.cuda.api.runtime import profilerStop as stop  # noqa

infer_4_30_0/lib/python3.10/site-packages/cupy/cuda/runtime.py

@@ -0,0 +1 @@
+from cupy_backends.cuda.api.runtime import *  # NOQA

infer_4_30_0/lib/python3.10/site-packages/cupy/fft/__init__.py

@@ -0,0 +1,19 @@
+from cupy.fft._fft import fft  # NOQA
+from cupy.fft._fft import fft2  # NOQA
+from cupy.fft._fft import fftfreq  # NOQA
+from cupy.fft._fft import fftn  # NOQA
+from cupy.fft._fft import fftshift  # NOQA
+from cupy.fft._fft import hfft  # NOQA
+from cupy.fft._fft import ifft  # NOQA
+from cupy.fft._fft import ifft2  # NOQA
+from cupy.fft._fft import ifftn  # NOQA
+from cupy.fft._fft import ifftshift  # NOQA
+from cupy.fft._fft import ihfft  # NOQA
+from cupy.fft._fft import irfft  # NOQA
+from cupy.fft._fft import irfft2  # NOQA
+from cupy.fft._fft import irfftn  # NOQA
+from cupy.fft._fft import rfft  # NOQA
+from cupy.fft._fft import rfft2  # NOQA
+from cupy.fft._fft import rfftfreq  # NOQA
+from cupy.fft._fft import rfftn  # NOQA
+from cupy.fft import config  # NOQA

infer_4_30_0/lib/python3.10/site-packages/cupy/fft/config.py

@@ -0,0 +1,61 @@
+from cupy import _util
+
+# expose cache handles to this module
+from cupy.fft._cache import get_plan_cache  # NOQA
+from cupy.fft._cache import clear_plan_cache  # NOQA
+from cupy.fft._cache import get_plan_cache_size  # NOQA
+from cupy.fft._cache import set_plan_cache_size  # NOQA
+from cupy.fft._cache import get_plan_cache_max_memsize  # NOQA
+from cupy.fft._cache import set_plan_cache_max_memsize  # NOQA
+from cupy.fft._cache import show_plan_cache_info  # NOQA
+
+# on Linux, expose callback handles to this module
+import sys as _sys
+if _sys.platform.startswith('linux'):
+    from cupy.fft._callback import get_current_callback_manager  # NOQA
+    from cupy.fft._callback import set_cufft_callbacks  # NOQA
+else:
+    def get_current_callback_manager(*args, **kwargs):
+        return None
+
+    class set_cufft_callbacks:  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise RuntimeError('cuFFT callback is only available on Linux')
+
+
+enable_nd_planning = True
+use_multi_gpus = False
+_devices = None
+
+
+def set_cufft_gpus(gpus):
+    '''Set the GPUs to be used in multi-GPU FFT.
+
+    Args:
+        gpus (int or list of int): The number of GPUs or a list of GPUs
+            to be used. For the former case, the first ``gpus`` GPUs
+            will be used.
+
+    .. warning::
+        This API is currently experimental and may be changed in the future
+        version.
+
+    .. seealso:: `Multiple GPU cuFFT Transforms`_
+
+    .. _Multiple GPU cuFFT Transforms:
+        https://docs.nvidia.com/cuda/cufft/index.html#multiple-GPU-cufft-transforms
+    '''
+    _util.experimental('cupy.fft.config.set_cufft_gpus')
+    global _devices
+
+    if isinstance(gpus, int):
+        devs = [i for i in range(gpus)]
+    elif isinstance(gpus, list):
+        devs = gpus
+    else:
+        raise ValueError("gpus must be an int or a list of int.")
+    if len(devs) <= 1:
+        raise ValueError("Must use at least 2 GPUs.")
+
+    # make it hashable
+    _devices = tuple(devs)

infer_4_30_0/lib/python3.10/site-packages/cupy/lib/__init__.py

@@ -0,0 +1 @@
+from cupy.lib import stride_tricks  # NOQA