numba-cuda 0.19.1__py3-none-any.whl → 0.20.1__py3-none-any.whl

numba_cuda/numba/cuda/cudadecl.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 from numba.core import errors, types
-from numba.core.typing.npydecl import (
+from numba.cuda.typing.npydecl import (
     parse_dtype,
     parse_shape,
     register_number_classes,

numba_cuda/numba/cuda/cudadrv/__init__.py

@@ -9,6 +9,6 @@
 
 """
 
-from numba.core import config
+from numba.cuda.core import config
 
 assert not config.ENABLE_CUDASIM, "Cannot use real driver API with simulator"

numba_cuda/numba/cuda/cudadrv/devicearray.py

@@ -19,7 +19,8 @@ import numba
 from numba import _devicearray
 from numba.cuda.cudadrv import devices, dummyarray
 from numba.cuda.cudadrv import driver as _driver
-from numba.core import types, config
+from numba.core import types
+from numba.cuda.core import config
 from numba.np.unsafe.ndarray import to_fixed_tuple
 from numba.np.numpy_support import numpy_version
 from numba.np import numpy_support

numba_cuda/numba/cuda/cudadrv/driver.py

@@ -47,7 +47,7 @@ from collections import namedtuple, deque
 
 
 from numba import mviewbuf
-from numba.core import config
+from numba.cuda.core import config
 from numba.cuda import utils, serialize
 from .error import CudaSupportError, CudaDriverError
 from .drvapi import API_PROTOTYPES
@@ -82,12 +82,6 @@ _py_incref = ctypes.pythonapi.Py_IncRef
 _py_decref.argtypes = [ctypes.py_object]
 _py_incref.argtypes = [ctypes.py_object]
 
-
-_MVC_ERROR_MESSAGE = (
-    "Minor version compatibility requires ptxcompiler and cubinlinker packages "
-    "to be available"
-)
-
 USE_NV_BINDING = config.CUDA_USE_NVIDIA_BINDING
 
 if USE_NV_BINDING:
@@ -137,7 +131,7 @@ def _have_nvjitlink():
             nvjitlink_internal._inspect_function_pointer("__nvJitLinkVersion")
             != 0
         )
-    except NotSupportedError:
+    except (RuntimeError, NotSupportedError):
         # no driver
         return False
 
@@ -161,12 +155,6 @@ class CudaAPIError(CudaDriverError):
 
 
 def locate_driver_and_loader():
-    envpath = config.CUDA_DRIVER
-
-    if envpath == "0":
-        # Force fail
-        _raise_driver_not_found()
-
     # Determine DLL type
     if sys.platform == "win32":
         dlloader = ctypes.WinDLL
@@ -182,26 +170,11 @@ def locate_driver_and_loader():
         dldir = ["/usr/lib", "/usr/lib64"]
         dlnames = ["libcuda.so", "libcuda.so.1"]
 
-    if envpath:
-        try:
-            envpath = os.path.abspath(envpath)
-        except ValueError:
-            raise ValueError(
-                "NUMBA_CUDA_DRIVER %s is not a valid path" % envpath
-            )
-        if not os.path.isfile(envpath):
-            raise ValueError(
-                "NUMBA_CUDA_DRIVER %s is not a valid file "
-                "path.  Note it must be a filepath of the .so/"
-                ".dll/.dylib or the driver" % envpath
-            )
-        candidates = [envpath]
-    else:
-        # First search for the name in the default library path.
-        # If that is not found, try the specific path.
-        candidates = dlnames + [
-            os.path.join(x, y) for x, y in product(dldir, dlnames)
-        ]
+    # First search for the name in the default library path.
+    # If that is not found, try specific common paths.
+    candidates = dlnames + [
+        os.path.join(x, y) for x, y in product(dldir, dlnames)
+    ]
 
     return dlloader, candidates
 
@@ -237,9 +210,7 @@ def find_driver():
 
 DRIVER_NOT_FOUND_MSG = """
 CUDA driver library cannot be found.
-If you are sure that a CUDA driver is installed,
-try setting environment variable NUMBA_CUDA_DRIVER
-with the file path of the CUDA driver shared library.
+Ensure that a compatible NVIDIA driver is installed and available on your system path.
 """
 
 DRIVER_LOAD_ERROR_MSG = """
@@ -2842,10 +2813,7 @@ class _LinkerBase(metaclass=ABCMeta):
     def add_cu(self, cu, name):
         """Add CUDA source in a string to the link. The name of the source
         file should be specified in `name`."""
-        with driver.get_active_context() as ac:
-            dev = driver.get_device(ac.devnum)
-            cc = dev.compute_capability
-        ptx, log = nvrtc.compile(cu, name, cc)
+        ptx, log = nvrtc.compile(cu, name, self.cc)
 
         if config.DUMP_ASSEMBLY:
             print(("ASSEMBLY %s" % name).center(80, "-"))
@@ -3009,10 +2977,7 @@ class _Linker(_LinkerBase):
         self._object_codes.append(obj)
 
     def add_cu(self, cu, name="<cudapy-cu>"):
-        with driver.get_active_context() as ac:
-            dev = driver.get_device(ac.devnum)
-            cc = dev.compute_capability
-        obj, log = nvrtc.compile(cu, name, cc, ltoir=self.lto)
+        obj, log = nvrtc.compile(cu, name, self.cc, ltoir=self.lto)
 
         if not self.lto and config.DUMP_ASSEMBLY:
             print(("ASSEMBLY %s" % name).center(80, "-"))
@@ -3099,101 +3064,6 @@ class _Linker(_LinkerBase):
         return result
 
 
-class MVCLinker(_LinkerBase):
-    """
-    Linker supporting Minor Version Compatibility, backed by the cubinlinker
-    package.
-    """
-
-    def __init__(self, max_registers=None, lineinfo=False, cc=None):
-        try:
-            from cubinlinker import CubinLinker
-        except ImportError as err:
-            raise ImportError(_MVC_ERROR_MESSAGE) from err
-
-        if cc is None:
-            raise RuntimeError(
-                "MVCLinker requires Compute Capability to be "
-                "specified, but cc is None"
-            )
-
-        super().__init__(max_registers, lineinfo, cc)
-
-        arch = f"sm_{cc[0] * 10 + cc[1]}"
-        ptx_compile_opts = ["--gpu-name", arch, "-c"]
-        if max_registers:
-            arg = f"--maxrregcount={max_registers}"
-            ptx_compile_opts.append(arg)
-        if lineinfo:
-            ptx_compile_opts.append("--generate-line-info")
-        self.ptx_compile_options = tuple(ptx_compile_opts)
-
-        self._linker = CubinLinker(f"--arch={arch}")
-
-    @property
-    def info_log(self):
-        return self._linker.info_log
-
-    @property
-    def error_log(self):
-        return self._linker.error_log
-
-    def add_ptx(self, ptx, name="<cudapy-ptx>"):
-        try:
-            from ptxcompiler import compile_ptx
-            from cubinlinker import CubinLinkerError
-        except ImportError as err:
-            raise ImportError(_MVC_ERROR_MESSAGE) from err
-        compile_result = compile_ptx(ptx.decode(), self.ptx_compile_options)
-        try:
-            self._linker.add_cubin(compile_result.compiled_program, name)
-        except CubinLinkerError as e:
-            raise LinkerError from e
-
-    def add_data(self, data, kind, name):
-        msg = "Adding in-memory data unsupported in the MVC linker"
-        raise LinkerError(msg)
-
-    def add_file(self, path, kind):
-        try:
-            from cubinlinker import CubinLinkerError
-        except ImportError as err:
-            raise ImportError(_MVC_ERROR_MESSAGE) from err
-
-        try:
-            data = cached_file_read(path, how="rb")
-        except FileNotFoundError:
-            raise LinkerError(f"{path} not found")
-
-        name = pathlib.Path(path).name
-        if kind == FILE_EXTENSION_MAP["cubin"]:
-            fn = self._linker.add_cubin
-        elif kind == FILE_EXTENSION_MAP["fatbin"]:
-            fn = self._linker.add_fatbin
-        elif kind == FILE_EXTENSION_MAP["a"]:
-            raise LinkerError(f"Don't know how to link {kind}")
-        elif kind == FILE_EXTENSION_MAP["ptx"]:
-            return self.add_ptx(data, name)
-        else:
-            raise LinkerError(f"Don't know how to link {kind}")
-
-        try:
-            fn(data, name)
-        except CubinLinkerError as e:
-            raise LinkerError from e
-
-    def complete(self):
-        try:
-            from cubinlinker import CubinLinkerError
-        except ImportError as err:
-            raise ImportError(_MVC_ERROR_MESSAGE) from err
-
-        try:
-            return self._linker.complete()
-        except CubinLinkerError as e:
-            raise LinkerError from e
-
-
 class CtypesLinker(_LinkerBase):
     """
     Links for current device if no CC given
@@ -3218,6 +3088,7 @@ class CtypesLinker(_LinkerBase):
         if lineinfo:
             options[enums.CU_JIT_GENERATE_LINE_INFO] = c_void_p(1)
 
+        self.cc = cc
         if cc is None:
             # No option value is needed, but we need something as a placeholder
             options[enums.CU_JIT_TARGET_FROM_CUCONTEXT] = 1

numba_cuda/numba/cuda/cudadrv/dummyarray.py

@@ -5,25 +5,118 @@ from collections import namedtuple
 import itertools
 import functools
 import operator
-import ctypes
 
-import numpy as np
-
-from numba import _helperlib
 
 Extent = namedtuple("Extent", ["begin", "end"])
 
-attempt_nocopy_reshape = ctypes.CFUNCTYPE(
-    ctypes.c_int,
-    ctypes.c_long,  # nd
-    np.ctypeslib.ndpointer(np.ctypeslib.c_intp, ndim=1),  # dims
-    np.ctypeslib.ndpointer(np.ctypeslib.c_intp, ndim=1),  # strides
-    ctypes.c_long,  # newnd
-    np.ctypeslib.ndpointer(np.ctypeslib.c_intp, ndim=1),  # newdims
-    np.ctypeslib.ndpointer(np.ctypeslib.c_intp, ndim=1),  # newstrides
-    ctypes.c_long,  # itemsize
-    ctypes.c_int,  # is_f_order
-)(_helperlib.c_helpers["attempt_nocopy_reshape"])
+
+def attempt_nocopy_reshape(
+    nd, dims, strides, newnd, newdims, newstrides, itemsize, is_f_order
+):
+    """
+    Attempt to reshape an array without copying data.
+
+    This function should correctly handle all reshapes, including
+    axes of length 1. Zero strides should work but are untested.
+
+    If a copy is needed, returns 0
+    If no copy is needed, returns 1 and fills `newstrides`
+    with appropriate strides
+    """
+
+    olddims = []
+    oldstrides = []
+    oldnd = 0
+
+    # Remove axes with dimension 1 from the old array. They have no effect
+    # but would need special cases since their strides do not matter.
+    for oi in range(nd):
+        if dims[oi] != 1:
+            olddims.append(dims[oi])
+            oldstrides.append(strides[oi])
+            oldnd += 1
+
+    # Calculate total sizes
+    np_total = 1
+    for ni in range(newnd):
+        np_total *= newdims[ni]
+
+    op_total = 1
+    for oi in range(oldnd):
+        op_total *= olddims[oi]
+
+    if np_total != op_total:
+        # Different total sizes; no hope
+        return 0
+
+    if np_total == 0:
+        # Handle zero-sized arrays
+        # Just make the strides vaguely reasonable
+        # (they can have any value in theory).
+        for i in range(newnd):
+            newstrides[i] = itemsize
+        return 1
+
+    # oi to oj and ni to nj give the axis ranges currently worked with
+    oi = 0
+    oj = 1
+    ni = 0
+    nj = 1
+
+    while ni < newnd and oi < oldnd:
+        np = newdims[ni]
+        op = olddims[oi]
+
+        while np != op:
+            if np < op:
+                # Misses trailing 1s, these are handled later
+                np *= newdims[nj]
+                nj += 1
+            else:
+                op *= olddims[oj]
+                oj += 1
+
+        # Check whether the original axes can be combined
+        for ok in range(oi, oj - 1):
+            if is_f_order:
+                if oldstrides[ok + 1] != olddims[ok] * oldstrides[ok]:
+                    # not contiguous enough
+                    return 0
+            else:
+                # C order
+                if oldstrides[ok] != olddims[ok + 1] * oldstrides[ok + 1]:
+                    # not contiguous enough
+                    return 0
+
+        # Calculate new strides for all axes currently worked with
+        if is_f_order:
+            newstrides[ni] = oldstrides[oi]
+            for nk in range(ni + 1, nj):
+                newstrides[nk] = newstrides[nk - 1] * newdims[nk - 1]
+        else:
+            # C order
+            newstrides[nj - 1] = oldstrides[oj - 1]
+            for nk in range(nj - 1, ni, -1):
+                newstrides[nk - 1] = newstrides[nk] * newdims[nk]
+
+        ni = nj
+        nj += 1
+        oi = oj
+        oj += 1
+
+    # Set strides corresponding to trailing 1s of the new shape
+    if ni >= 1:
+        last_stride = newstrides[ni - 1]
+    else:
+        last_stride = itemsize
+
+    if is_f_order:
+        last_stride *= newdims[ni - 1]
+
+    for nk in range(ni, newnd):
+        newstrides[nk] = last_stride
+
+    return 1
 
 
 class Dim(object):
@@ -333,18 +426,12 @@ class Array(object):
             else:
                 raise AssertionError("unreachable")
         else:
-            newstrides = np.empty(newnd, np.ctypeslib.c_intp)
-
-            # need to keep these around in variables, not temporaries, so they
-            # don't get GC'ed before we call into the C code
-            olddims = np.array(self.shape, dtype=np.ctypeslib.c_intp)
-            oldstrides = np.array(self.strides, dtype=np.ctypeslib.c_intp)
-            newdims = np.array(newdims, dtype=np.ctypeslib.c_intp)
+            newstrides = [0] * newnd
 
             if not attempt_nocopy_reshape(
                 oldnd,
-                olddims,
-                oldstrides,
+                self.shape,
+                self.strides,
                 newnd,
                 newdims,
                 newstrides,

numba_cuda/numba/cuda/cudadrv/libs.py

@@ -16,11 +16,11 @@ import os
 import sys
 import ctypes
 
-from numba.misc.findlib import find_lib
+from numba.cuda.misc.findlib import find_lib
 from numba.cuda.cuda_paths import get_cuda_paths
 from numba.cuda.cudadrv.driver import locate_driver_and_loader, load_driver
 from numba.cuda.cudadrv.error import CudaSupportError
-from numba.core import config
+from numba.cuda.core import config
 
 
 if sys.platform == "win32":
@@ -54,9 +54,9 @@ def get_cudalib(lib, static=False):
     """
     if lib in {"nvrtc", "nvvm"}:
         return get_cuda_paths()[lib].info or _dllnamepattern % lib
-    else:
-        dir_type = "static_cudalib_dir" if static else "cudalib_dir"
-        libdir = get_cuda_paths()[dir_type].info
+
+    dir_type = "static_cudalib_dir" if static else "cudalib_dir"
+    libdir = get_cuda_paths()[dir_type].info
 
     candidates = find_lib(lib, libdir, static=static)
     namepattern = _staticnamepattern if static else _dllnamepattern

numba_cuda/numba/cuda/cudadrv/mappings.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
-from numba import config
+from numba.cuda import config
 from . import enums
 
 if config.CUDA_USE_NVIDIA_BINDING:

numba_cuda/numba/cuda/cudadrv/nvrtc.py

@@ -10,7 +10,7 @@ from numba.cuda.cudadrv.error import (
     NvrtcCompilationError,
     NvrtcSupportError,
 )
-from numba import config
+from numba.cuda import config
 from numba.cuda.cuda_paths import get_cuda_paths
 from numba.cuda.utils import _readenv
 
@@ -21,8 +21,8 @@ import warnings
 
 NVRTC_EXTRA_SEARCH_PATHS = _readenv(
     "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS", str, ""
-) or getattr(config, "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS", "")
-if not hasattr(config, "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS"):
+) or getattr(config, "CUDA_NVRTC_EXTRA_SEARCH_PATHS", "")
+if not hasattr(config, "CUDA_NVRTC_EXTRA_SEARCH_PATHS"):
     config.CUDA_NVRTC_EXTRA_SEARCH_PATHS = NVRTC_EXTRA_SEARCH_PATHS
 
 # Opaque handle for compilation unit
@@ -347,15 +347,26 @@ def compile(src, name, cc, ltoir=False):
         arch = f"--gpu-architecture=compute_{major}{minor}"
 
     cuda_include_dir = get_cuda_paths()["include_dir"].info
-    cuda_includes = [
-        f"{cuda_include_dir}",
-        f"{os.path.join(cuda_include_dir, 'cccl')}",
-    ]
+    cuda_includes = [f"{cuda_include_dir}"]
 
     cudadrv_path = os.path.dirname(os.path.abspath(__file__))
     numba_cuda_path = os.path.dirname(cudadrv_path)
 
-    numba_include = f"{os.path.join(numba_cuda_path, 'include', '12')}"
+    nvrtc_ver_major = version[0]
+    if nvrtc_ver_major == 12:
+        numba_include = f"{os.path.join(numba_cuda_path, 'include', '12')}"
+        # For CUDA 12 wheels, `cuda_include_dir` is `site-packages/nvidia/cuda_runtime/include`
+        # We need to find CCCL at `site-packages/nvidia/cuda_cccl/include`
+        # For CUDA 12 conda / system install, CCCL is just in the `include` directory
+        cuda_includes.append(
+            f"{os.path.join(cuda_include_dir, '..', '..', 'cuda_cccl', 'include')}"
+        )
+    elif nvrtc_ver_major == 13:
+        numba_include = f"{os.path.join(numba_cuda_path, 'include', '13')}"
+        # For CUDA 13 wheels, `cuda_include_dir` is `site-packages/nvidia/cu13/include`
+        # We need to find CCCL at `site-packages/nvidia/cu13/include/cccl`
+        # For CUDA 13 conda / system install, CCCL is in the `include/cccl` directory
+        cuda_includes.append(f"{os.path.join(cuda_include_dir, 'cccl')}")
 
     if config.CUDA_NVRTC_EXTRA_SEARCH_PATHS:
         extra_includes = config.CUDA_NVRTC_EXTRA_SEARCH_PATHS.split(":")

numba_cuda/numba/cuda/cudadrv/nvvm.py

@@ -154,10 +154,7 @@ class NVVM(object):
                     inst.driver = open_cudalib("nvvm")
                 except OSError as e:
                     cls.__INSTANCE = None
-                    errmsg = (
-                        "libNVVM cannot be found. Do `conda install "
-                        "cudatoolkit`:\n%s"
-                    )
+                    errmsg = "libNVVM cannot be found. Please install the cuda-toolkit conda package:\n%s"
                     raise NvvmSupportError(errmsg % e)
 
                 # Find & populate functions

numba_cuda/numba/cuda/cudadrv/runtime.py

@@ -8,7 +8,7 @@ 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 import config
 from numba.cuda.cudadrv.nvrtc import NVRTC
 
 

numba_cuda/numba/cuda/cudaimpl.py

@@ -10,7 +10,7 @@ from llvmlite import ir
 import llvmlite.binding as ll
 
 from numba.core.imputils import Registry
-from numba.core.typing.npydecl import parse_dtype
+from numba.cuda.typing.npydecl import parse_dtype
 from numba.core.datamodel import models
 from numba.core import types
 from numba.cuda import cgutils
@@ -25,6 +25,10 @@ registry = Registry()
 lower = registry.lower
 lower_attr = registry.lower_getattr
 lower_constant = registry.lower_constant
+lower_getattr_generic = registry.lower_getattr_generic
+lower_setattr = registry.lower_setattr
+lower_setattr_generic = registry.lower_setattr_generic
+lower_cast = registry.lower_cast
 
 
 def initialize_dim3(builder, prefix):

numba_cuda/numba/cuda/debuginfo.py

@@ -1,15 +1,98 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
+import abc
 import os
+from contextlib import contextmanager
 
 from llvmlite import ir
-from numba.core import types, config
+from numba.core import types
+from numba.cuda.core import config
 from numba.cuda import cgutils
 from numba.core.datamodel.models import ComplexModel, UnionModel, UniTupleModel
-from numba.core.debuginfo import AbstractDIBuilder
 from numba.cuda.types import GridGroup
 
+
+@contextmanager
+def suspend_emission(builder):
+    """Suspends the emission of debug_metadata for the duration of the context
+    managed block."""
+    ref = builder.debug_metadata
+    builder.debug_metadata = None
+    try:
+        yield
+    finally:
+        builder.debug_metadata = ref
+
+
+class AbstractDIBuilder(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def mark_variable(
+        self,
+        builder,
+        allocavalue,
+        name,
+        lltype,
+        size,
+        line,
+        datamodel=None,
+        argidx=None,
+    ):
+        """Emit debug info for the variable."""
+        pass
+
+    @abc.abstractmethod
+    def mark_location(self, builder, line):
+        """Emit source location information to the given IRBuilder."""
+        pass
+
+    @abc.abstractmethod
+    def mark_subprogram(self, function, qualname, argnames, argtypes, line):
+        """Emit source location information for the given function."""
+        pass
+
+    @abc.abstractmethod
+    def initialize(self):
+        """Initialize the debug info. An opportunity for the debuginfo to
+        prepare any necessary data structures.
+        """
+
+    @abc.abstractmethod
+    def finalize(self):
+        """Finalize the debuginfo by emitting all necessary metadata."""
+        pass
+
+
+class DummyDIBuilder(AbstractDIBuilder):
+    def __init__(self, module, filepath, cgctx, directives_only):
+        pass
+
+    def mark_variable(
+        self,
+        builder,
+        allocavalue,
+        name,
+        lltype,
+        size,
+        line,
+        datamodel=None,
+        argidx=None,
+    ):
+        pass
+
+    def mark_location(self, builder, line):
+        pass
+
+    def mark_subprogram(self, function, qualname, argnames, argtypes, line):
+        pass
+
+    def initialize(self):
+        pass
+
+    def finalize(self):
+        pass
+
+
 _BYTE_SIZE = 8
 
 

numba_cuda/numba/cuda/decorators.py

@@ -2,10 +2,10 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 from warnings import warn
-from numba.core import types, config
+from numba.core import types
 from numba.core.errors import DeprecationError, NumbaInvalidConfigWarning
 from numba.cuda.compiler import declare_device_function
-from numba.cuda.core import sigutils
+from numba.cuda.core import sigutils, config
 from numba.cuda.dispatcher import CUDADispatcher
 from numba.cuda.simulator.kernel import FakeCUDAKernel
 from numba.cuda.cudadrv.driver import _have_nvjitlink
@@ -199,7 +199,7 @@ def jit(
                     raise TypeError("CUDA kernel must have void return type.")
 
                 if device:
-                    from numba.core import typeinfer
+                    from numba.cuda.core import typeinfer
 
                     with typeinfer.register_dispatcher(disp):
                         disp.compile_device(argtypes, restype)

numba_cuda/numba/cuda/descriptor.py

@@ -1,8 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
-from numba.core.descriptors import TargetDescriptor
-from numba.core.options import TargetOptions
+from numba.cuda.core.options import TargetOptions
 from .target import CUDATargetContext, CUDATypingContext
 
 
@@ -10,7 +9,7 @@ class CUDATargetOptions(TargetOptions):
     pass
 
 
-class CUDATarget(TargetDescriptor):
+class CUDATarget:
     def __init__(self, name):
         self.options = CUDATargetOptions
         # The typing and target contexts are initialized only when needed -
@@ -18,7 +17,7 @@ class CUDATarget(TargetDescriptor):
         # systems that might not have them present.
         self._typingctx = None
         self._targetctx = None
-        super().__init__(name)
+        self._target_name = name
 
     @property
     def typing_context(self):