numba-cuda 0.21.1__cp313-cp313-win_amd64.whl → 0.24.0__cp313-cp313-win_amd64.whl

numba_cuda/VERSION

@@ -1 +1 @@
-0.21.1
+0.24.0

numba_cuda/numba/cuda/__init__.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
+# delvewheel: patch
+
 import importlib
 from numba.cuda.core import config
 from .utils import _readenv
@@ -23,7 +25,8 @@ if not (
 ):
     raise ImportError(
         "NVIDIA CUDA Python bindings not found. Install the 'cuda' package "
-        "(e.g. pip install nvidia-cuda-python or numba-cuda[cuXY])."
+        '(e.g. pip install "cuda-bindings==XY.*" or "numba-cuda[cuXY]", '
+        "with XY=12 or XY=13)."
     )
 
 if config.ENABLE_CUDASIM:

numba_cuda/numba/cuda/_compat.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+from packaging import version
+from cuda import core
+
+
+CUDA_CORE_VERSION = version.parse(core.__version__)
+if CUDA_CORE_VERSION < version.parse("0.5.0"):
+    from cuda.core.experimental import (
+        Program,
+        ProgramOptions,
+        Linker,
+        LinkerOptions,
+        Stream,
+        Device,
+        launch,
+        ObjectCode,
+        LaunchConfig,
+    )
+    from cuda.core.experimental._utils.cuda_utils import CUDAError, NVRTCError
+else:
+    from cuda.core import (
+        Program,
+        ProgramOptions,
+        Linker,
+        LinkerOptions,
+        Stream,
+        Device,
+        launch,
+        ObjectCode,
+        LaunchConfig,
+    )
+    from cuda.core._utils.cuda_utils import CUDAError, NVRTCError
+
+__all__ = [
+    "Program",
+    "ProgramOptions",
+    "Linker",
+    "LinkerOptions",
+    "Stream",
+    "Device",
+    "launch",
+    "CUDAError",
+    "NVRTCError",
+    "ObjectCode",
+    "LaunchConfig",
+]

numba_cuda/numba/cuda/api.py

@@ -21,6 +21,7 @@ current_context = devices.get_context
 gpus = devices.gpus
 
 
+@require_context
 def from_cuda_array_interface(desc, owner=None, sync=True):
     """Create a DeviceNDArray from a cuda-array-interface description.
     The ``owner`` is the owner of the underlying memory.
@@ -47,7 +48,9 @@ def from_cuda_array_interface(desc, owner=None, sync=True):
 
     cudevptr_class = driver.binding.CUdeviceptr
     devptr = cudevptr_class(desc["data"][0])
-    data = driver.MemoryPointer(devptr, size=size, owner=owner)
+    data = driver.MemoryPointer(
+        current_context(), devptr, size=size, owner=owner
+    )
     stream_ptr = desc.get("stream", None)
     if stream_ptr is not None:
         stream = external_stream(stream_ptr)

numba_cuda/numba/cuda/cext/_dispatcher.cpp

@@ -12,7 +12,6 @@
 #include "frameobject.h"
 #include "traceback.h"
 #include "typeconv.hpp"
-#include "_devicearray.h"
 
 /*
  * Notes on the C_TRACE macro:
@@ -30,7 +29,7 @@
  *
  */
 
-#if (PY_MAJOR_VERSION >= 3) && ((PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
+#if (PY_MAJOR_VERSION >= 3) && ((PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13) || (PY_MINOR_VERSION == 14))
 
 #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
@@ -940,37 +939,6 @@ CLEANUP:
     return retval;
 }
 
-static int
-import_devicearray(void)
-{
-    PyObject *devicearray = PyImport_ImportModule(NUMBA_DEVICEARRAY_IMPORT_NAME);
-    if (devicearray == NULL) {
-        return -1;
-    }
-
-    PyObject *d = PyModule_GetDict(devicearray);
-    if (d == NULL) {
-      Py_DECREF(devicearray);
-      return -1;
-    }
-
-    PyObject *key = PyUnicode_FromString("_DEVICEARRAY_API");
-    PyObject *c_api = PyDict_GetItemWithError(d, key);
-    int retcode = 0;
-    if (PyCapsule_IsValid(c_api, NUMBA_DEVICEARRAY_IMPORT_NAME "._DEVICEARRAY_API")) {
-      DeviceArray_API = (void**)PyCapsule_GetPointer(c_api, NUMBA_DEVICEARRAY_IMPORT_NAME "._DEVICEARRAY_API");
-      if (DeviceArray_API == NULL) {
-        retcode = -1;
-      }
-    } else {
-      retcode = -1;
-    }
-
-    Py_DECREF(key);
-    Py_DECREF(devicearray);
-    return retcode;
-}
-
 static PyMethodDef Dispatcher_methods[] = {
     { "_clear", (PyCFunction)Dispatcher_clear, METH_NOARGS, NULL },
     { "_insert", (PyCFunction)Dispatcher_Insert, METH_VARARGS | METH_KEYWORDS,
@@ -1036,12 +1004,18 @@ static PyTypeObject DispatcherType = {
     0,                                           /* tp_version_tag */
     0,                                           /* tp_finalize */
     0,                                           /* tp_vectorcall */
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 12)
 /* This was introduced first in 3.12
  * https://github.com/python/cpython/issues/91051
  */
     0,                                           /* tp_watched */
 #endif
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 13)
+/* This was introduced in 3.13
+ * https://github.com/python/cpython/pull/114900
+ */
+    0,                                           /* tp_versions_used */
+#endif
 
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */
@@ -1076,12 +1050,6 @@ static PyMethodDef ext_methods[] = {
 
 
 MOD_INIT(_dispatcher) {
-    if (import_devicearray() < 0) {
-      PyErr_Print();
-      PyErr_SetString(PyExc_ImportError, NUMBA_DEVICEARRAY_IMPORT_NAME " failed to import");
-      return MOD_ERROR_VAL;
-    }
-
     PyObject *m;
     MOD_DEF(m, "_dispatcher", "No docs", ext_methods)
     if (m == NULL)

numba_cuda/numba/cuda/cext/_hashtable.cpp

@@ -110,7 +110,12 @@ _Numba_hashtable_hash_int(const void *key)
 extern "C" Py_uhash_t
 _Numba_hashtable_hash_ptr(const void *key)
 {
+/* Use public API on Python 3.13+; _Py_HashPointer is deprecated on 3.14+ */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 13)
+    return (Py_uhash_t)Py_HashPointer((void *)key);
+#else
     return (Py_uhash_t)_Py_HashPointer((void *)key);
+#endif
 }
 
 extern "C" int

numba_cuda/numba/cuda/cext/_pymodule.h

@@ -33,6 +33,6 @@
         Py_DECREF(tmp); } while (0)
 
 
-#define NB_SUPPORTED_PYTHON_MINOR ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
+#define NB_SUPPORTED_PYTHON_MINOR ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13) || (PY_MINOR_VERSION == 14))
 
 #endif /* NUMBA_PY_MODULE_H_ */

numba_cuda/numba/cuda/cext/_typeof.cpp

@@ -9,7 +9,6 @@
 
 #include "_typeof.h"
 #include "_hashtable.h"
-#include "_devicearray.h"
 #include "pyerrors.h"
 
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
@@ -18,11 +17,24 @@
     #include <numpy/npy_2_compat.h>
 #endif
 
-#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
-    #ifndef Py_BUILD_CORE
-        #define Py_BUILD_CORE 1
-    #endif
-    #include "internal/pycore_setobject.h"  // _PySet_NextEntry()
+#ifndef Py_BUILD_CORE
+#define Py_BUILD_CORE 1
+#endif
+
+#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION >= 13)
+// required include from Python 3.13+
+#include "internal/pycore_setobject.h"
+#ifndef PySet_NextEntry
+#define PySet_NextEntry _PySet_NextEntryRef
+#endif
+#else
+#ifndef PySet_NextEntry
+#define PySet_NextEntry _PySet_NextEntry
+#endif
+#endif
+
+#ifdef Py_BUILD_CORE
+#undef Py_BUILD_CORE
 #endif
 
 
@@ -56,9 +68,6 @@ static PyObject *str_typeof_pyval = NULL;
 static PyObject *str_value = NULL;
 static PyObject *str_numba_type = NULL;
 
-/* CUDA device array API */
-void **DeviceArray_API;
-
 /*
  * Type fingerprint computation.
  */
@@ -414,17 +423,52 @@ compute_fingerprint(string_writer_t *w, PyObject *val)
         Py_hash_t h;
         PyObject *item;
         Py_ssize_t pos = 0;
+        int rc;
+
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 13
+        // needed when using _PySet_NextEntryRef
+        Py_BEGIN_CRITICAL_SECTION(val);
+#endif
         /* Only one item is considered, as in typeof.py */
-        if (!_PySet_NextEntry(val, &pos, &item, &h)) {
+        rc = PySet_NextEntry(val, &pos, &item, &h);
+
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 13
+        // needed when using _PySet_NextEntryRef
+        Py_END_CRITICAL_SECTION();
+#endif
+
+        if (!rc) {
             /* Empty set */
             PyErr_SetString(PyExc_ValueError,
                             "cannot compute fingerprint of empty set");
             return -1;
         }
-        TRY(string_writer_put_char, w, OP_SET);
-        TRY(compute_fingerprint, w, item);
+
+        if (string_writer_put_char(w, OP_SET)) {
+            goto fingerprint_error;
+        }
+
+        if (compute_fingerprint(w, item)) {
+            goto fingerprint_error;
+        }
+
+        goto fingerprint_success;
+
+fingerprint_error:
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 13
+        // extra ref if using python >= 3.13
+        Py_XDECREF(item);
+#endif
+        return -1;
+
+fingerprint_success:
+#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 13
+        // extra ref if using python >= 3.13
+        Py_XDECREF(item);
+#endif
         return 0;
     }
+
     if (PyObject_CheckBuffer(val)) {
         Py_buffer buf;
         int flags = PyBUF_ND | PyBUF_STRIDES | PyBUF_FORMAT;
@@ -857,109 +901,6 @@ int typecode_arrayscalar(PyObject *dispatcher, PyObject* aryscalar) {
     return BASIC_TYPECODES[typecode];
 }
 
-static
-int typecode_devicendarray(PyObject *dispatcher, PyObject *ary)
-{
-    int typecode;
-    int dtype;
-    int ndim;
-    int layout = 0;
-    PyObject *ndim_obj = nullptr;
-    PyObject *num_obj = nullptr;
-    PyObject *dtype_obj = nullptr;
-    int dtype_num = 0;
-
-    PyObject* flags = PyObject_GetAttrString(ary, "flags");
-    if (flags == NULL)
-    {
-        PyErr_Clear();
-        goto FALLBACK;
-    }
-
-    if (PyDict_GetItemString(flags, "C_CONTIGUOUS") == Py_True) {
-        layout = 1;
-    } else if (PyDict_GetItemString(flags, "F_CONTIGUOUS") == Py_True) {
-        layout = 2;
-    }
-
-    Py_DECREF(flags);
-
-    ndim_obj = PyObject_GetAttrString(ary, "ndim");
-    if (ndim_obj == NULL) {
-        /* If there's no ndim, try to proceed by clearing the error and using the
-         * fallback. */
-        PyErr_Clear();
-        goto FALLBACK;
-    }
-
-    ndim = PyLong_AsLong(ndim_obj);
-    Py_DECREF(ndim_obj);
-
-    if (PyErr_Occurred()) {
-        /* ndim wasn't an integer for some reason - unlikely to happen, but try
-         * the fallback. */
-        PyErr_Clear();
-        goto FALLBACK;
-    }
-
-    if (ndim <= 0 || ndim > N_NDIM)
-        goto FALLBACK;
-
-    dtype_obj = PyObject_GetAttrString(ary, "dtype");
-    if (dtype_obj == NULL) {
-        /* No dtype: try the fallback. */
-        PyErr_Clear();
-        goto FALLBACK;
-    }
-
-    num_obj = PyObject_GetAttrString(dtype_obj, "num");
-    Py_DECREF(dtype_obj);
-
-    if (num_obj == NULL) {
-        /* This strange dtype has no num - try the fallback. */
-        PyErr_Clear();
-        goto FALLBACK;
-    }
-
-    dtype_num = PyLong_AsLong(num_obj);
-    Py_DECREF(num_obj);
-
-    if (PyErr_Occurred()) {
-        /* num wasn't an integer for some reason - unlikely to happen, but try
-         * the fallback. */
-        PyErr_Clear();
-        goto FALLBACK;
-    }
-
-    dtype = dtype_num_to_typecode(dtype_num);
-    if (dtype == -1) {
-        /* Not a dtype we have in the global lookup table. */
-        goto FALLBACK;
-    }
-
-    /* Fast path, using direct table lookup */
-    assert(layout < N_LAYOUT);
-    assert(ndim <= N_NDIM);
-    assert(dtype < N_DTYPES);
-    typecode = cached_arycode[ndim - 1][layout][dtype];
-
-    if (typecode == -1) {
-        /* First use of this table entry, so it requires populating */
-        typecode = typecode_fallback_keep_ref(dispatcher, (PyObject*)ary);
-        cached_arycode[ndim - 1][layout][dtype] = typecode;
-    }
-
-    return typecode;
-
-FALLBACK:
-    /* Slower path, for non-trivial array types. At present this always uses
-       the fingerprinting to get the typecode. Future optimization might
-       implement a cache, but this would require some fast equivalent of
-       PyArray_DESCR for a device array. */
-
-    return typecode_using_fingerprint(dispatcher, (PyObject *) ary);
-}
-
 extern "C" int
 typeof_typecode(PyObject *dispatcher, PyObject *val)
 {
@@ -994,10 +935,6 @@ typeof_typecode(PyObject *dispatcher, PyObject *val)
     else if (tyobj == &PyArray_Type) {
         return typecode_ndarray(dispatcher, (PyArrayObject*)val);
     }
-    /* Subtype of CUDA device array */
-    else if (PyType_IsSubtype(tyobj, &DeviceArrayType)) {
-        return typecode_devicendarray(dispatcher, val);
-    }
     /* Subtypes of Array handling */
     else if (PyType_IsSubtype(tyobj, &PyArray_Type)) {
         /* By default, Numba will treat all numpy.ndarray subtypes as if they

numba_cuda/numba/cuda/cext/mviewbuf.c

@@ -337,12 +337,18 @@ static PyTypeObject MemAllocType = {
     0,                                          /* tp_version_tag */
     0,                                          /* tp_finalize */
     0,                                          /* tp_vectorcall */
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 12)
 /* This was introduced first in 3.12
  * https://github.com/python/cpython/issues/91051
  */
     0,                                           /* tp_watched */
 #endif
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 13)
+/* This was introduced in 3.13
+ * https://github.com/python/cpython/pull/114900
+ */
+    0,                                           /* tp_versions_used */
+#endif
 
 /* WARNING: Do not remove this, only modify it! It is a version guard to
  * act as a reminder to update this struct on Python version update! */

numba_cuda/numba/cuda/cloudpickle/cloudpickle.py

@@ -422,10 +422,9 @@ HAVE_ARGUMENT = dis.HAVE_ARGUMENT
 EXTENDED_ARG = dis.EXTENDED_ARG
 
 
-_BUILTIN_TYPE_NAMES = {}
-for k, v in types.__dict__.items():
-    if type(v) is type:
-        _BUILTIN_TYPE_NAMES[v] = k
+_BUILTIN_TYPE_NAMES = {
+    v: k for k, v in types.__dict__.items() if type(v) is type
+}
 
 
 def _builtin_type(name):
@@ -463,7 +462,7 @@ def _extract_class_dict(cls):
             base_value = inherited_dict[name]
             if value is base_value:
                 to_remove.append(name)
-        except KeyError:
+        except KeyError:  # noqa: PERF203
             pass
     for name in to_remove:
         clsdict.pop(name)

numba_cuda/numba/cuda/codegen.py

@@ -12,6 +12,7 @@ from numba.cuda.cudadrv.linkable_code import LinkableCode
 from numba.cuda.memory_management.nrt import NRT_LIBRARY
 
 import os
+import pickle
 import subprocess
 import tempfile
 
@@ -189,6 +190,11 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
 
         self.use_cooperative = False
 
+        # Objects that need to be kept alive for the lifetime of the
+        # kernels or device functions generated by this code library,
+        # e.g., device arrays captured from global scope.
+        self.referenced_objects = {}
+
     @property
     def llvm_strs(self):
         if self._llvm_strs is None:
@@ -203,9 +209,14 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
             return cc
 
         device = devices.get_context().device
-        return device.compute_capability
+        cc = device.compute_capability
+        cc = (cc[0], cc[1], "a" if cc >= (9, 0) else "")
+        return cc
 
     def get_asm_str(self, cc=None):
+        return "\n".join(self.get_asm_strs(cc=cc))
+
+    def get_asm_strs(self, cc=None):
         cc = self._ensure_cc(cc)
 
         ptxes = self._ptx_cache.get(cc, None)
@@ -218,21 +229,25 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
 
         irs = self.llvm_strs
 
-        ptx = nvvm.compile_ir(irs, **options)
+        if "g" in options:
+            ptxes = [nvvm.compile_ir(ir, **options) for ir in irs]
+        else:
+            ptxes = [nvvm.compile_ir(irs, **options)]
 
         # Sometimes the result from NVVM contains trailing whitespace and
         # nulls, which we strip so that the assembly dump looks a little
         # tidier.
-        ptx = ptx.decode().strip("\x00").strip()
+        ptxes = [ptx.decode().strip("\x00").strip() for ptx in ptxes]
 
         if config.DUMP_ASSEMBLY:
             print(("ASSEMBLY %s" % self._name).center(80, "-"))
-            print(ptx)
+            for ptx in ptxes:
+                print(ptx)
             print("=" * 80)
 
-        self._ptx_cache[cc] = ptx
+        self._ptx_cache[cc] = ptxes
 
-        return ptx
+        return ptxes
 
     def get_lto_ptx(self, cc=None):
         """
@@ -247,7 +262,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
 
         cc = self._ensure_cc(cc)
 
-        linker = driver._Linker.new(
+        linker = driver._Linker(
             max_registers=self._max_registers,
             cc=cc,
             additional_flags=["-ptx"],
@@ -284,8 +299,9 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
             ltoir = self.get_ltoir(cc=cc)
             linker.add_ltoir(ltoir)
         else:
-            ptx = self.get_asm_str(cc=cc)
-            linker.add_ptx(ptx.encode())
+            ptxes = self.get_asm_strs(cc=cc)
+            for ptx in ptxes:
+                linker.add_ptx(ptx.encode())
 
         for path in self._linking_files:
             linker.add_file_guess_ext(path, ignore_nonlto)
@@ -308,7 +324,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
             print(ptx)
             print("=" * 80)
 
-        linker = driver._Linker.new(
+        linker = driver._Linker(
             max_registers=self._max_registers, cc=cc, lto=self._lto
         )
         self._link_all(linker, cc, ignore_nonlto=False)
@@ -333,7 +349,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         cufunc = self._cufunc_cache.get(device.id, None)
         if cufunc:
             return cufunc
-        cubin = self.get_cubin(cc=device.compute_capability)
+        cubin = self.get_cubin()
         module = ctx.create_module_image(
             cubin, self._setup_functions, self._teardown_functions
         )
@@ -377,6 +393,9 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         self._setup_functions.extend(library._setup_functions)
         self._teardown_functions.extend(library._teardown_functions)
         self.use_cooperative |= library.use_cooperative
+        self.referenced_objects.update(
+            getattr(library, "referenced_objects", {})
+        )
 
     def add_linking_file(self, path_or_obj):
         if isinstance(path_or_obj, LinkableCode):
@@ -432,7 +451,10 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
             for mod in library.modules:
                 for fn in mod.functions:
                     if not fn.is_declaration:
-                        fn.linkage = "linkonce_odr"
+                        if "g" in self._nvvm_options:
+                            fn.linkage = "weak_odr"
+                        else:
+                            fn.linkage = "linkonce_odr"
 
         self._finalized = True
 
@@ -442,6 +464,18 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         but loaded functions are discarded. They are recreated when needed
         after deserialization.
         """
+        # Check for captured device arrays that cannot be safely cached.
+        if self.referenced_objects:
+            if any(
+                getattr(obj, "__cuda_array_interface__", None) is not None
+                for obj in self.referenced_objects.values()
+            ):
+                raise pickle.PicklingError(
+                    "Cannot serialize kernels or device functions referencing "
+                    "global device arrays. Pass the array(s) as arguments "
+                    "to the kernel instead."
+                )
+
         nrt = False
         if self._linking_files:
             if (

numba_cuda/numba/cuda/compiler.py

@@ -852,15 +852,15 @@ def kernel_fixup(kernel, debug):
     return_value = kernel.args[0]
 
     for block in kernel.blocks:
-        remove_list = []
-
         # Find all stores first
-        for inst in block.instructions:
+        remove_list = [
+            inst
+            for inst in block.instructions
             if (
                 isinstance(inst, ir.StoreInstr)
                 and inst.operands[1] == return_value
-            ):
-                remove_list.append(inst)
+            )
+        ]
 
         # Remove all stores
         for to_remove in remove_list:
@@ -1023,10 +1023,9 @@ def compile_all(
     )
 
     if lto:
-        code = lib.get_ltoir(cc=cc)
+        codes = [lib.get_ltoir(cc=cc)]
     else:
-        code = lib.get_asm_str(cc=cc)
-    codes = [code]
+        codes = lib.get_asm_strs(cc=cc)
 
     # linking_files
     is_ltoir = output == "ltoir"
@@ -1241,7 +1240,14 @@ def compile(
     if lto:
         code = lib.get_ltoir(cc=cc)
     else:
-        code = lib.get_asm_str(cc=cc)
+        codes = lib.get_asm_strs(cc=cc)
+        if len(codes) == 1:
+            code = codes[0]
+        else:
+            raise RuntimeError(
+                "Compiling this function results in multiple "
+                "PTX files. Use compile_all() instead"
+            )
     return code, resty