numba-cuda 0.18.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

numba_cuda/numba/cuda/core/sigutils.py

@@ -0,0 +1,55 @@
+from numba.core import types, typing
+
+
+def is_signature(sig):
+    """
+    Return whether *sig* is a potentially valid signature
+    specification (for user-facing APIs).
+    """
+    return isinstance(sig, (str, tuple, typing.Signature))
+
+
+def _parse_signature_string(signature_str):
+    """
+    Parameters
+    ----------
+    signature_str : str
+    """
+    # Just eval signature_str using the types submodules as globals
+    return eval(signature_str, {}, types.__dict__)
+
+
+def normalize_signature(sig):
+    """
+    From *sig* (a signature specification), return a ``(args, return_type)``
+    tuple, where ``args`` itself is a tuple of types, and ``return_type``
+    can be None if not specified.
+    """
+    if isinstance(sig, str):
+        parsed = _parse_signature_string(sig)
+    else:
+        parsed = sig
+    if isinstance(parsed, tuple):
+        args, return_type = parsed, None
+    elif isinstance(parsed, typing.Signature):
+        args, return_type = parsed.args, parsed.return_type
+    else:
+        raise TypeError(
+            "invalid signature: %r (type: %r) evaluates to %r "
+            "instead of tuple or Signature"
+            % (sig, sig.__class__.__name__, parsed.__class__.__name__)
+        )
+
+    def check_type(ty):
+        if not isinstance(ty, types.Type):
+            raise TypeError(
+                "invalid type in signature: expected a type "
+                "instance, got %r" % (ty,)
+            )
+
+    if return_type is not None:
+        check_type(return_type)
+    for ty in args:
+        check_type(ty)
+
+    return args, return_type

numba_cuda/numba/cuda/cuda_paths.py

@@ -148,7 +148,6 @@ def get_nvrtc_dso_path():
             # Check for each version of the NVRTC DLL, preferring the most
             # recent.
             versions = (
-                "112" if IS_WIN32 else "11.2",
                 "120" if IS_WIN32 else "12",
                 "130" if IS_WIN32 else "13",
             )
@@ -303,16 +302,16 @@ def get_nvidia_nvvm_ctk():
 
     # Assume the existence of NVVM in the conda env implies that a CUDA toolkit
     # conda package is installed.
+    if IS_WIN32:
+        # The path used on Windows
+        libdir = os.path.join(sys.prefix, "Library", "nvvm", _cudalib_path())
+    else:
+        # The path used on Linux is different to that on Windows
+        libdir = os.path.join(sys.prefix, "nvvm", _cudalib_path())
 
-    # First, try the location used on Linux and the Windows 11.x packages
-    libdir = os.path.join(sys.prefix, "nvvm", _cudalib_path())
     if not os.path.exists(libdir) or not os.path.isdir(libdir):
-        # If that fails, try the location used for Windows 12.x packages
-        libdir = os.path.join(sys.prefix, "Library", "nvvm", _cudalib_path())
-        if not os.path.exists(libdir) or not os.path.isdir(libdir):
-            # If that doesn't exist either, assume we don't have the NVIDIA
-            # conda package
-            return
+        # If the path doesn't exist, we didn't find the NVIDIA conda package
+        return
 
     paths = find_lib("nvvm", libdir=libdir)
     if not paths:
@@ -346,15 +345,8 @@ def get_nvidia_static_cudalib_ctk():
     if not nvvm_ctk:
         return
 
-    if IS_WIN32 and ("Library" not in nvvm_ctk):
-        # Location specific to CUDA 11.x packages on Windows
-        dirs = ("Lib", "x64")
-    else:
-        # Linux, or Windows with CUDA 12.x packages
-        dirs = ("lib",)
-
     env_dir = os.path.dirname(os.path.dirname(nvvm_ctk))
-    return os.path.join(env_dir, *dirs)
+    return os.path.join(env_dir, "lib")
 
 
 def get_cuda_home(*subdirs):

numba_cuda/numba/cuda/cudadecl.py

@@ -9,7 +9,7 @@ from numba.core.typing.npydecl import (
     math_operations,
     bit_twiddling_functions,
 )
-from numba.core.typing.templates import (
+from numba.cuda.typing.templates import (
     AttributeTemplate,
     ConcreteTemplate,
     AbstractTemplate,

numba_cuda/numba/cuda/cudadrv/driver.py

@@ -54,12 +54,6 @@ from .linkable_code import LinkableCode, LTOIR, Fatbin, Object
 from numba.cuda.utils import cached_file_read
 from numba.cuda.cudadrv import enums, drvapi, nvrtc
 
-try:
-    from pynvjitlink.api import NvJitLinker, NvJitLinkError
-except ImportError:
-    NvJitLinker, NvJitLinkError = None, None
-
-
 USE_NV_BINDING = config.CUDA_USE_NVIDIA_BINDING
 
 if USE_NV_BINDING:
@@ -640,7 +634,7 @@ class Device(object):
 
         if USE_NV_BINDING:
             buf = driver.cuDeviceGetName(bufsz, self.id)
-            name = buf.decode("utf-8").rstrip("\0")
+            name = buf.split(b"\x00")[0]
         else:
             buf = (c_char * bufsz)()
             driver.cuDeviceGetName(buf, bufsz, self.id)
@@ -2808,19 +2802,10 @@ class _LinkerBase(metaclass=ABCMeta):
         lto=None,
         additional_flags=None,
     ):
-        driver_ver = driver.get_version()
-        if driver_ver < (12, 0):
-            if config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY:
-                linker = MVCLinker
-            elif USE_NV_BINDING:
-                linker = _Linker
-            else:
-                linker = CtypesLinker
+        if USE_NV_BINDING:
+            linker = _Linker
         else:
-            if USE_NV_BINDING:
-                linker = _Linker
-            else:
-                linker = CtypesLinker
+            linker = CtypesLinker
 
         params = (max_registers, lineinfo, cc)
         if linker is _Linker:

numba_cuda/numba/cuda/cudadrv/libs.py

@@ -2,8 +2,7 @@
 
 CUDA Toolkit libraries can be available via either:
 
-- the `cuda-nvcc` and `cuda-nvrtc` conda packages for CUDA 12,
-- the `cudatoolkit` conda package for CUDA 11,
+- the `cuda-nvcc` and `cuda-nvrtc` conda packages,
 - a user supplied location from CUDA_HOME,
 - a system wide location,
 - package-specific locations (e.g. the Debian NVIDIA packages),

numba_cuda/numba/cuda/cudadrv/nvrtc.py

@@ -29,6 +29,7 @@ nvrtc_program = c_void_p
 nvrtc_result = c_int
 
 if config.CUDA_USE_NVIDIA_BINDING:
+    from cuda.bindings import nvrtc as bindings_nvrtc
     from cuda.core.experimental import Program, ProgramOptions
 
 
@@ -142,6 +143,10 @@ class NVRTC:
 
     def __new__(cls):
         with _nvrtc_lock:
+            if config.CUDA_USE_NVIDIA_BINDING:
+                raise RuntimeError(
+                    "NVRTC objects should not be used with cuda-python bindings"
+                )
             if cls.__INSTANCE is None:
                 from numba.cuda.cudadrv.libs import open_cudalib
 
@@ -154,16 +159,9 @@ class NVRTC:
 
                 # Find & populate functions
                 for name, proto in inst._PROTOTYPES.items():
-                    try:
-                        func = getattr(lib, name)
-                        func.restype = proto[0]
-                        func.argtypes = proto[1:]
-                    except AttributeError:
-                        if "LTOIR" in name:
-                            # CUDA 11 does not have LTOIR functions; ignore
-                            continue
-                        else:
-                            raise
+                    func = getattr(lib, name)
+                    func.restype = proto[0]
+                    func.argtypes = proto[1:]
 
                     @functools.wraps(func)
                     def checked_call(*args, func=func, name=name):
@@ -303,32 +301,35 @@ def compile(src, name, cc, ltoir=False):
     :return: The compiled PTX and compilation log
     :rtype: tuple
     """
-    nvrtc = NVRTC()
-    program = nvrtc.create_program(src, name)
 
-    version = nvrtc.get_version()
-    ver_str = lambda v: ".".join(v)
-    if version < (11, 2):
-        raise RuntimeError(
-            "Unsupported CUDA version. CUDA 11.2 or higher is required."
-        )
-    else:
-        supported_arch = nvrtc.get_supported_archs()
-        try:
-            found = max(filter(lambda v: v <= cc, [v for v in supported_arch]))
-        except ValueError:
+    if config.CUDA_USE_NVIDIA_BINDING:
+        retcode, *version = bindings_nvrtc.nvrtcVersion()
+        if retcode != bindings_nvrtc.nvrtcResult.NVRTC_SUCCESS:
             raise RuntimeError(
-                f"Device compute capability {ver_str(cc)} is less than the "
-                f"minimum supported by NVRTC {ver_str(version)}. Supported "
-                "compute capabilities are "
-                f"{', '.join([ver_str(v) for v in supported_arch])}."
+                f"{retcode.name} when calling nvrtcGetSupportedArchs()"
             )
+        version = tuple(version)
+    else:
+        nvrtc = NVRTC()
+        version = nvrtc.get_version()
 
-        if found != cc:
-            warnings.warn(
-                f"Device compute capability {ver_str(cc)} is not supported by "
-                f"NVRTC {ver_str(version)}. Using {ver_str(found)} instead."
-            )
+    ver_str = lambda version: ".".join(str(v) for v in version)
+    supported_ccs = get_supported_ccs()
+    try:
+        found = max(filter(lambda v: v <= cc, [v for v in supported_ccs]))
+    except ValueError:
+        raise RuntimeError(
+            f"Device compute capability {ver_str(cc)} is less than the "
+            f"minimum supported by NVRTC {ver_str(version)}. Supported "
+            "compute capabilities are "
+            f"{', '.join([ver_str(v) for v in supported_ccs])}."
+        )
+
+    if found != cc:
+        warnings.warn(
+            f"Device compute capability {ver_str(cc)} is not supported by "
+            f"NVRTC {ver_str(version)}. Using {ver_str(found)} instead."
+        )
 
     # Compilation options:
     # - Compile for the current device's compute capability.
@@ -348,16 +349,10 @@ def compile(src, name, cc, ltoir=False):
         f"{os.path.join(cuda_include_dir, 'cccl')}",
     ]
 
-    nvrtc_version = nvrtc.get_version()
-    nvrtc_ver_major = nvrtc_version[0]
-
     cudadrv_path = os.path.dirname(os.path.abspath(__file__))
     numba_cuda_path = os.path.dirname(cudadrv_path)
 
-    if nvrtc_ver_major == 11:
-        numba_include = f"{os.path.join(numba_cuda_path, 'include', '11')}"
-    else:
-        numba_include = f"{os.path.join(numba_cuda_path, 'include', '12')}"
+    numba_include = f"{os.path.join(numba_cuda_path, 'include', '12')}"
 
     if config.CUDA_NVRTC_EXTRA_SEARCH_PATHS:
         extra_includes = config.CUDA_NVRTC_EXTRA_SEARCH_PATHS.split(":")
@@ -373,7 +368,6 @@ def compile(src, name, cc, ltoir=False):
             arch=arch,
             include_path=includes,
             relocatable_device_code=True,
-            std="c++17" if nvrtc_version < (12, 0) else None,
             link_time_optimization=ltoir,
             name=name,
         )
@@ -399,6 +393,7 @@ def compile(src, name, cc, ltoir=False):
         return result, log
 
     else:
+        program = nvrtc.create_program(src, name)
         includes = [f"-I{path}" for path in includes]
         options = [
             arch,
@@ -410,9 +405,6 @@ def compile(src, name, cc, ltoir=False):
         if ltoir:
             options.append("-dlto")
 
-        if nvrtc_version < (12, 0):
-            options.append("-std=c++17")
-
         # Compile the program
         compile_error = nvrtc.compile_program(program, options)
 
@@ -482,4 +474,12 @@ def get_lowest_supported_cc():
 
 
 def get_supported_ccs():
-    return NVRTC().get_supported_archs()
+    if config.CUDA_USE_NVIDIA_BINDING:
+        retcode, archs = bindings_nvrtc.nvrtcGetSupportedArchs()
+        if retcode != bindings_nvrtc.nvrtcResult.NVRTC_SUCCESS:
+            raise RuntimeError(
+                f"{retcode.name} when calling nvrtcGetSupportedArchs()"
+            )
+        return [(arch // 10, arch % 10) for arch in archs]
+    else:
+        return NVRTC().get_supported_archs()

numba_cuda/numba/cuda/cudadrv/nvvm.py

@@ -47,14 +47,7 @@ NVVM_ERROR_COMPILATION
 for i, k in enumerate(RESULT_CODE_NAMES):
     setattr(sys.modules[__name__], k, i)
 
-# Data layouts. NVVM IR 1.8 (CUDA 11.6) introduced 128-bit integer support.
-
-_datalayout_original = (
-    "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
-    "i64:64:64-f32:32:32-f64:64:64-v16:16:16-v32:32:32-"
-    "v64:64:64-v128:128:128-n16:32:64"
-)
-_datalayout_i128 = (
+_datalayout = (
     "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
     "i128:128:128-f32:32:32-f64:64:64-v16:16:16-v32:32:32-"
     "v64:64:64-v128:128:128-n16:32:64"
@@ -182,10 +175,7 @@ class NVVM(object):
 
     @property
     def data_layout(self):
-        if (self._majorIR, self._minorIR) < (1, 8):
-            return _datalayout_original
-        else:
-            return _datalayout_i128
+        return _datalayout
 
     def get_version(self):
         major = c_int()
@@ -346,14 +336,9 @@ class CompilationUnit(object):
 
 
 MISSING_LIBDEVICE_FILE_MSG = """Missing libdevice file.
-Please ensure you have a CUDA Toolkit 11.2 or higher.
-For CUDA 12, ``cuda-nvcc`` and ``cuda-nvrtc`` are required:
+``cuda-nvcc`` and ``cuda-nvrtc`` are required:
 
     $ conda install -c conda-forge cuda-nvcc cuda-nvrtc "cuda-version>=12.0"
-
-For CUDA 11, ``cudatoolkit`` is required:
-
-    $ conda install -c conda-forge cudatoolkit "cuda-version>=11.2,<12.0"
 """
 
 

numba_cuda/numba/cuda/cudadrv/runtime.py

@@ -5,12 +5,23 @@ The toolkit version can now be obtained from NVRTC, so we don't use a binding
 to the runtime anymore. This file is provided to maintain the existing API.
 """
 
+from numba import config
 from numba.cuda.cudadrv.nvrtc import NVRTC
 
 
 class Runtime:
     def get_version(self):
-        return NVRTC().get_version()
+        if config.CUDA_USE_NVIDIA_BINDING:
+            from cuda.bindings import nvrtc
+
+            retcode, *version = nvrtc.nvrtcVersion()
+            if retcode != nvrtc.nvrtcResult.NVRTC_SUCCESS:
+                raise RuntimeError(
+                    f"{retcode.name} when calling nvrtcGetVersion()"
+                )
+            return tuple(version)
+        else:
+            return NVRTC().get_version()
 
 
 runtime = Runtime()

numba_cuda/numba/cuda/cudamath.py

@@ -1,6 +1,6 @@
 import math
 from numba.core import types
-from numba.core.typing.templates import ConcreteTemplate, signature, Registry
+from numba.cuda.typing.templates import ConcreteTemplate, signature, Registry
 
 
 registry = Registry()

numba_cuda/numba/cuda/decorators.py

@@ -1,7 +1,8 @@
 from warnings import warn
-from numba.core import types, config, sigutils
+from numba.core import types, config
 from numba.core.errors import DeprecationError, NumbaInvalidConfigWarning
 from numba.cuda.compiler import declare_device_function
+from numba.cuda.core import sigutils
 from numba.cuda.dispatcher import CUDADispatcher
 from numba.cuda.simulator.kernel import FakeCUDAKernel
 from numba.cuda.cudadrv.driver import _have_nvjitlink
@@ -86,7 +87,7 @@ def jit(
                           number of threads per block.
     :type launch_bounds: int | tuple[int]
     :param lto: Whether to enable LTO. If unspecified, LTO is enabled by
-                default when pynvjitlink is available, except for kernels where
+                default when nvjitlink is available, except for kernels where
                 ``debug=True``.
     :type lto: bool
     """
@@ -143,7 +144,7 @@ def jit(
         raise ValueError("link keyword invalid for device function")
 
     if lto is None:
-        # Default to using LTO if pynvjitlink is available and we're not debugging
+        # Default to using LTO if nvjitlink is available and we're not debugging
         lto = _have_nvjitlink() and not debug
     else:
         if lto and not _have_nvjitlink():

numba_cuda/numba/cuda/deviceufunc.py

@@ -11,8 +11,9 @@ from functools import reduce
 import numpy as np
 
 from numba.np.ufunc.ufuncbuilder import _BaseUFuncBuilder, parse_identity
-from numba.core import types, sigutils
+from numba.core import types
 from numba.core.typing import signature
+from numba.cuda.core import sigutils
 from numba.np.ufunc.sigparse import parse_signature
 
 

numba_cuda/numba/cuda/dispatcher.py

@@ -8,13 +8,13 @@ import types as pytypes
 import weakref
 import uuid
 
-from numba.core import compiler, sigutils, types, typing, config
+from numba.core import compiler, types, typing, config
 from numba.cuda import serialize, utils
 from numba.cuda.core.caching import Cache, CacheImpl, NullCache
 from numba.core.compiler_lock import global_compiler_lock
 from numba.core.dispatcher import _DispatcherBase
 from numba.core.errors import NumbaPerformanceWarning, TypingError
-from numba.core.typing.templates import fold_arguments
+from numba.cuda.typing.templates import fold_arguments
 from numba.core.typing.typeof import Purpose, typeof
 from numba.cuda.api import get_current_device
 from numba.cuda.args import wrap_arg
@@ -23,6 +23,7 @@ from numba.cuda.compiler import (
     CUDACompiler,
     kernel_fixup,
 )
+from numba.cuda.core import sigutils
 import re
 from numba.cuda.cudadrv import driver, nvvm
 from numba.cuda.cudadrv.linkable_code import LinkableCode

numba_cuda/numba/cuda/extending.py

@@ -18,7 +18,7 @@ def make_attribute_wrapper(typeclass, struct_attr, python_attr):
     Vendored from numba.core.extending with a change to consider the CUDA data
     model manager.
     """
-    from numba.core.typing.templates import AttributeTemplate
+    from numba.cuda.typing.templates import AttributeTemplate
 
     from numba.core.datamodel import default_manager
     from numba.core.datamodel.models import StructModel