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

numba_cuda/numba/cuda/errors.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numbers
 from numba.core.errors import LoweringError
 
@@ -12,6 +15,13 @@ class KernelRuntimeError(RuntimeError):
         super(KernelRuntimeError, self).__init__(msg)
 
 
+class UnsupportedBytecodeError(Exception):
+    """Unsupported bytecode is non-recoverable"""
+
+    def __init__(self, msg, loc=None):
+        super().__init__(f"{msg}. Raised from {loc}")
+
+
 class CudaLoweringError(LoweringError):
     pass
 

numba_cuda/numba/cuda/extending.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 Added for symmetry with the core API
 """
@@ -18,7 +21,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

numba_cuda/numba/cuda/flags.py

@@ -1,3 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
 from numba.core.compiler import Flags, Option
 
 

numba_cuda/numba/cuda/fp16.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numba.core.types as types
 from numba.cuda._internal.cuda_fp16 import (
     typing_registry,

numba_cuda/numba/cuda/initialize.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
 def initialize_all():
     # Import models to register them with the data model manager
     import numba.cuda.models  # noqa: F401

numba_cuda/numba/cuda/intrinsic_wrapper.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from .decorators import jit
 import numba
 

numba_cuda/numba/cuda/intrinsics.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from llvmlite import ir
 
 from numba import cuda, types

numba_cuda/numba/cuda/itanium_mangler.py

@@ -0,0 +1,214 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+Itanium CXX ABI Mangler
+
+Reference: https://itanium-cxx-abi.github.io/cxx-abi/abi.html
+
+The basics of the mangling scheme.
+
+We are hijacking the CXX mangling scheme for our use.  We map Python modules
+into CXX namespace.  A `module1.submodule2.foo` is mapped to
+`module1::submodule2::foo`.   For parameterized numba types, we treat them as
+templated types; for example, `array(int64, 1d, C)` becomes an
+`array<int64, 1, C>`.
+
+All mangled names are prefixed with "_Z".  It is followed by the name of the
+entity.  A name contains one or more identifiers.  Each identifier is encoded
+as "<num of char><name>".   If the name is namespaced and, therefore,
+has multiple identifiers, the entire name is encoded as "N<name>E".
+
+For functions, arguments types follow.  There are condensed encodings for basic
+built-in types; e.g. "i" for int, "f" for float.  For other types, the
+previously mentioned name encoding should be used.
+
+For templated types, the template parameters are encoded immediately after the
+name.  If it is namespaced, it should be within the 'N' 'E' marker.  Template
+parameters are encoded in "I<params>E", where each parameter is encoded using
+the mentioned name encoding scheme.  Template parameters can contain literal
+values like the '1' in the array type shown earlier.  There is special encoding
+scheme for them to avoid leading digits.
+"""
+
+import re
+
+from numba.core import types
+
+
+# According the scheme, valid characters for mangled names are [a-zA-Z0-9_].
+# We borrow the '_' as the escape character to encode invalid char into
+# '_xx' where 'xx' is the hex codepoint.
+_re_invalid_char = re.compile(r"[^a-z0-9_]", re.I)
+
+PREFIX = "_Z"
+
+# Numba types to mangled type code. These correspond with the codes listed in
+# https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-builtin
+N2CODE = {
+    types.void: "v",
+    types.boolean: "b",
+    types.uint8: "h",
+    types.int8: "a",
+    types.uint16: "t",
+    types.int16: "s",
+    types.uint32: "j",
+    types.int32: "i",
+    types.uint64: "y",
+    types.int64: "x",
+    types.float16: "Dh",
+    types.float32: "f",
+    types.float64: "d",
+}
+
+
+def _escape_string(text):
+    """Escape the given string so that it only contains ASCII characters
+    of [a-zA-Z0-9_$].
+
+    The dollar symbol ($) and other invalid characters are escaped into
+    the string sequence of "$xx" where "xx" is the hex codepoint of the char.
+
+    Multibyte characters are encoded into utf8 and converted into the above
+    hex format.
+    """
+
+    def repl(m):
+        return "".join(("_%02x" % ch) for ch in m.group(0).encode("utf8"))
+
+    ret = re.sub(_re_invalid_char, repl, text)
+    # Return str if we got a unicode (for py2)
+    if not isinstance(ret, str):
+        return ret.encode("ascii")
+    return ret
+
+
+def _fix_lead_digit(text):
+    """
+    Fix text with leading digit
+    """
+    if text and text[0].isdigit():
+        return "_" + text
+    else:
+        return text
+
+
+def _len_encoded(string):
+    """
+    Prefix string with digit indicating the length.
+    Add underscore if string is prefixed with digits.
+    """
+    string = _fix_lead_digit(string)
+    return "%u%s" % (len(string), string)
+
+
+def mangle_abi_tag(abi_tag: str) -> str:
+    return "B" + _len_encoded(_escape_string(abi_tag))
+
+
+def mangle_identifier(ident, template_params="", *, abi_tags=(), uid=None):
+    """
+    Mangle the identifier with optional template parameters and abi_tags.
+
+    Note:
+
+    This treats '.' as '::' in C++.
+    """
+    if uid is not None:
+        # Add uid to abi-tags
+        abi_tags = (f"v{uid}", *abi_tags)
+    parts = [_len_encoded(_escape_string(x)) for x in ident.split(".")]
+    enc_abi_tags = list(map(mangle_abi_tag, abi_tags))
+    extras = template_params + "".join(enc_abi_tags)
+    if len(parts) > 1:
+        return "N%s%sE" % ("".join(parts), extras)
+    else:
+        return "%s%s" % (parts[0], extras)
+
+
+def mangle_type_or_value(typ):
+    """
+    Mangle type parameter and arbitrary value.
+    """
+    # Handle numba types
+    if isinstance(typ, types.Type):
+        if typ in N2CODE:
+            return N2CODE[typ]
+        else:
+            return mangle_templated_ident(*typ.mangling_args)
+    # Handle integer literal
+    elif isinstance(typ, int):
+        return "Li%dE" % typ
+    # Handle str as identifier
+    elif isinstance(typ, str):
+        return mangle_identifier(typ)
+    # Otherwise
+    else:
+        enc = _escape_string(str(typ))
+        return _len_encoded(enc)
+
+
+# Alias
+mangle_type = mangle_type_or_value
+mangle_value = mangle_type_or_value
+
+
+def mangle_templated_ident(identifier, parameters):
+    """
+    Mangle templated identifier.
+    """
+    template_params = (
+        "I%sE" % "".join(map(mangle_type_or_value, parameters))
+        if parameters
+        else ""
+    )
+    return mangle_identifier(identifier, template_params)
+
+
+def mangle_args(argtys):
+    """
+    Mangle sequence of Numba type objects and arbitrary values.
+    """
+    return "".join([mangle_type_or_value(t) for t in argtys])
+
+
+def mangle(ident, argtys, *, abi_tags=(), uid=None):
+    """
+    Mangle identifier with Numba type objects and abi-tags.
+    """
+    return "".join(
+        [
+            PREFIX,
+            mangle_identifier(ident, abi_tags=abi_tags, uid=uid),
+            mangle_args(argtys),
+        ]
+    )
+
+
+def prepend_namespace(mangled, ns):
+    """
+    Prepend namespace to mangled name.
+    """
+    if not mangled.startswith(PREFIX):
+        raise ValueError("input is not a mangled name")
+    elif mangled.startswith(PREFIX + "N"):
+        # nested
+        remaining = mangled[3:]
+        ret = PREFIX + "N" + mangle_identifier(ns) + remaining
+    else:
+        # non-nested
+        remaining = mangled[2:]
+        head, tail = _split_mangled_ident(remaining)
+        ret = PREFIX + "N" + mangle_identifier(ns) + head + "E" + tail
+    return ret
+
+
+def _split_mangled_ident(mangled):
+    """
+    Returns `(head, tail)` where `head` is the `<len> + <name>` encoded
+    identifier and `tail` is the remaining.
+    """
+    ct = int(mangled)
+    ctlen = len(str(ct))
+    at = ctlen + ct
+    return mangled[:at], mangled[at:]

numba_cuda/numba/cuda/kernels/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause

numba_cuda/numba/cuda/kernels/reduction.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 A library written in CUDA Python for generating reduction kernels
 """

numba_cuda/numba/cuda/kernels/transpose.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba import cuda
 from numba.cuda.cudadrv.driver import driver
 import math

numba_cuda/numba/cuda/libdevice.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
 def abs(x):
     """
     See https://docs.nvidia.com/cuda/libdevice-users-guide/__nv_abs.html

numba_cuda/numba/cuda/libdevicedecl.py

@@ -1,5 +1,8 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba.cuda import libdevice, libdevicefuncs
-from numba.core.typing.templates import ConcreteTemplate, Registry
+from numba.cuda.typing.templates import ConcreteTemplate, Registry
 
 registry = Registry()
 register_global = registry.register_global

numba_cuda/numba/cuda/libdevicefuncs.py

@@ -1,8 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from collections import namedtuple
 from textwrap import indent
 
 from numba.types import float32, float64, int16, int32, int64, void, Tuple
-from numba.core.typing.templates import signature
+from numba.cuda.typing.templates import signature
 
 arg = namedtuple("arg", ("name", "ty", "is_ptr"))
 

numba_cuda/numba/cuda/libdeviceimpl.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from llvmlite import ir
 from numba.core import types
 from numba.cuda import cgutils

numba_cuda/numba/cuda/locks.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from threading import Lock
 from functools import wraps
 

numba_cuda/numba/cuda/lowering.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from collections import namedtuple, defaultdict
 import operator
 import warnings
@@ -14,11 +17,11 @@ from numba.core import (
     funcdesc,
     generators,
     config,
-    ir_utils,
     cgutils,
     removerefctpass,
     targetconfig,
 )
+from numba.cuda.core import ir_utils
 from numba.core.errors import (
     LoweringError,
     new_error_context,
@@ -1841,8 +1844,7 @@ class CUDALower(Lower):
             int_type = (llvm_ir.IntType,)
             real_type = llvm_ir.FloatType, llvm_ir.DoubleType
             if isinstance(lltype, int_type + real_type):
-                index = name.find(".")
-                src_name = name[:index] if index > 0 else name
+                src_name = name.split(".")[0]
                 if src_name in self.poly_var_typ_map:
                     # Do not emit debug value on polymorphic type var
                     return
@@ -1869,6 +1871,9 @@ class CUDALower(Lower):
 
         self.poly_var_typ_map = {}
         self.poly_var_loc_map = {}
+        self.poly_var_set = set()
+        self.poly_cleaned = False
+        self.lastblk = max(self.blocks.keys())
 
         # When debug info is enabled, walk through function body and mark
         # variables with polymorphic types.
@@ -1880,8 +1885,7 @@ class CUDALower(Lower):
                     if x.target.name.startswith("$"):
                         continue
                     ssa_name = x.target.name
-                    index = ssa_name.find(".")
-                    src_name = ssa_name[:index] if index > 0 else ssa_name
+                    src_name = ssa_name.split(".")[0]
                     # Check all the multi-versioned targets
                     if len(x.target.versioned_names) > 0:
                         fetype = self.typeof(ssa_name)
@@ -1902,12 +1906,12 @@ class CUDALower(Lower):
         """
         # If the name is not handled yet and a store is needed
         if name not in self.varmap and self.store_var_needed(name):
-            index = name.find(".")
-            src_name = name[:index] if index > 0 else name
+            src_name = name.split(".")[0]
             if src_name in self.poly_var_typ_map:
-                dtype = types.UnionType(self.poly_var_typ_map[src_name])
-                datamodel = self.context.data_model_manager[dtype]
+                self.poly_var_set.add(name)
                 if src_name not in self.poly_var_loc_map:
+                    dtype = types.UnionType(self.poly_var_typ_map[src_name])
+                    datamodel = self.context.data_model_manager[dtype]
                     # UnionType has sorted set of types, max at last index
                     maxsizetype = dtype.types[-1]
                     # Create a single element aggregate type
@@ -1916,13 +1920,7 @@ class CUDALower(Lower):
                     ptr = self.alloca_lltype(src_name, lltype, datamodel)
                     # save the location of the union type for polymorphic var
                     self.poly_var_loc_map[src_name] = ptr
-                # Any member of this union type shoud type cast ptr to fetype
-                lltype = self.context.get_value_type(fetype)
-                castptr = self.builder.bitcast(
-                    self.poly_var_loc_map[src_name], llvm_ir.PointerType(lltype)
-                )
-                # Remember the pointer
-                self.varmap[name] = castptr
+                return
 
         super()._alloca_var(name, fetype)
 
@@ -1936,6 +1934,45 @@ class CUDALower(Lower):
             or self._disable_sroa_like_opt
         )
 
+    def delvar(self, name):
+        """
+        Delete the given variable.
+        """
+        if name in self.poly_var_set:
+            fetype = self.typeof(name)
+            src_name = name.split(".")[0]
+            ptr = self.poly_var_loc_map[src_name]
+            self.decref(fetype, self.builder.load(ptr))
+            if (
+                self._cur_ir_block == self.blocks[self.lastblk]
+                and not self.poly_cleaned
+            ):
+                # Zero-fill the debug union for polymorphic only
+                # at the last block
+                for v in self.poly_var_loc_map.values():
+                    self.builder.store(
+                        llvm_ir.Constant(v.type.pointee, None), v
+                    )
+                    self.poly_cleaned = True
+            return
+
+        super().delvar(name)
+
+    def getvar(self, name):
+        """
+        Get a pointer to the given variable's slot.
+        """
+        if name in self.poly_var_set:
+            src_name = name.split(".")[0]
+            fetype = self.typeof(name)
+            lltype = self.context.get_value_type(fetype)
+            castptr = self.builder.bitcast(
+                self.poly_var_loc_map[src_name], llvm_ir.PointerType(lltype)
+            )
+            return castptr
+        else:
+            return super().getvar(name)
+
 
 def _lit_or_omitted(value):
     """Returns a Literal instance if the type of value is supported;

numba_cuda/numba/cuda/mathimpl.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import math
 import operator
 from llvmlite import ir

numba_cuda/numba/cuda/memory_management/__init__.py

@@ -1 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba.cuda.memory_management.nrt import rtsys  # noqa: F401

numba_cuda/numba/cuda/memory_management/memsys.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 #include "memsys.cuh"
 
 __device__ size_t memsys_size = sizeof(NRT_MemSys);

numba_cuda/numba/cuda/memory_management/memsys.cuh

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 #include <cuda/atomic>
 
 // Globally needed variables

numba_cuda/numba/cuda/memory_management/nrt.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 #ifndef _NRT_H
 #define _NRT_H
 

numba_cuda/numba/cuda/memory_management/nrt.cuh

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 #include <cuda/atomic>
 
 typedef void (*NRT_dtor_function)(void* ptr, size_t size, void* info);

numba_cuda/numba/cuda/memory_management/nrt.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import ctypes
 import os
 from functools import wraps
@@ -10,6 +13,7 @@ from numba.cuda.cudadrv.driver import (
     driver,
     launch_kernel,
     USE_NV_BINDING,
+    _have_nvjitlink,
 )
 from numba.cuda.cudadrv import devices
 from numba.cuda.api import get_current_device
@@ -80,7 +84,7 @@ class _Runtime:
         cc = get_current_device().compute_capability
 
         # Create a new linker instance and add the cu file
-        linker = _Linker.new(cc=cc)
+        linker = _Linker.new(cc=cc, lto=_have_nvjitlink())
         linker.add_cu_file(memsys_mod)
 
         # Complete the linker and create a module from it

numba_cuda/numba/cuda/models.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import functools
 
 from llvmlite import ir

numba_cuda/numba/cuda/nvvmutils.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import itertools
 from llvmlite import ir
 from numba.core import targetconfig

numba_cuda/numba/cuda/printimpl.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from functools import singledispatch
 from llvmlite import ir
 from numba.core import types

numba_cuda/numba/cuda/random.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import math
 
 from numba import (

numba_cuda/numba/cuda/reshape_funcs.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 /*
  * Handle reshaping of zero-sized array.
  * See numba_attempt_nocopy_reshape() below.

numba_cuda/numba/cuda/serialize.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 Serialization support for compiled functions.
 """

numba_cuda/numba/cuda/simulator/__init__.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import sys
 
 from .api import *

numba_cuda/numba/cuda/simulator/_internal/__init__.py

@@ -1 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba.cuda.simulator._internal import cuda_bf16  # noqa: F401

numba_cuda/numba/cuda/simulator/_internal/cuda_bf16.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause

numba_cuda/numba/cuda/simulator/api.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 Contains CUDA API functions
 """
@@ -17,8 +20,8 @@ from .cudadrv.linkable_code import (
     LTOIR,  # noqa: F401
 )  # noqa: F401
 from .kernel import FakeCUDAKernel
-from numba.core.sigutils import is_signature
 from numba.core import config
+from numba.cuda.core.sigutils import is_signature
 from warnings import warn
 from ..args import In, Out, InOut  # noqa: F401
 

numba_cuda/numba/cuda/simulator/bf16.py

@@ -1 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 bfloat16 = None

numba_cuda/numba/cuda/simulator/compiler.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 The compiler is not implemented in the simulator. This module provides a stub
 to allow tests to import successfully.