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

numba_cuda/numba/cuda/debuginfo.py

@@ -1,12 +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

@@ -1,8 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# 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
@@ -196,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,5 +1,7 @@
-from numba.core.descriptors import TargetDescriptor
-from numba.core.options import TargetOptions
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from numba.cuda.core.options import TargetOptions
 from .target import CUDATargetContext, CUDATypingContext
 
 
@@ -7,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 -
@@ -15,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):

numba_cuda/numba/cuda/device_init.py

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

numba_cuda/numba/cuda/deviceufunc.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 Implements custom ufunc dispatch mechanism for non-CPU devices.
 """
@@ -7,14 +10,78 @@ from collections import OrderedDict
 import operator
 import warnings
 from functools import reduce
+import tokenize
+import string
 
 import numpy as np
 
-from numba.np.ufunc.ufuncbuilder import _BaseUFuncBuilder, parse_identity
+from numba.cuda.np.ufunc.ufuncbuilder import _BaseUFuncBuilder, parse_identity
 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
+
+
+def parse_signature(sig):
+    """Parse generalized ufunc signature.
+
+    NOTE: ',' (COMMA) is a delimiter; not separator.
+          This means trailing comma is legal.
+    """
+
+    def stripws(s):
+        return "".join(c for c in s if c not in string.whitespace)
+
+    def tokenizer(src):
+        def readline():
+            yield src
+
+        gen = readline()
+        return tokenize.generate_tokens(lambda: next(gen))
+
+    def parse(src):
+        tokgen = tokenizer(src)
+        while True:
+            tok = next(tokgen)
+            if tok[1] == "(":
+                symbols = []
+                while True:
+                    tok = next(tokgen)
+                    if tok[1] == ")":
+                        break
+                    elif tok[0] == tokenize.NAME:
+                        symbols.append(tok[1])
+                    elif tok[1] == ",":
+                        continue
+                    else:
+                        raise ValueError('bad token in signature "%s"' % tok[1])
+                yield tuple(symbols)
+                tok = next(tokgen)
+                if tok[1] == ",":
+                    continue
+                elif tokenize.ISEOF(tok[0]):
+                    break
+            elif tokenize.ISEOF(tok[0]):
+                break
+            else:
+                raise ValueError('bad token in signature "%s"' % tok[1])
+
+    ins, _, outs = stripws(sig).partition("->")
+    inputs = list(parse(ins))
+    outputs = list(parse(outs))
+
+    # check that all output symbols are defined in the inputs
+    isym = set()
+    osym = set()
+    for grp in inputs:
+        isym |= set(grp)
+    for grp in outputs:
+        osym |= set(grp)
+
+    diff = osym.difference(isym)
+    if diff:
+        raise NameError("undefined output symbols: %s" % ",".join(sorted(diff)))
+
+    return inputs, outputs
 
 
 def _broadcast_axis(a, b):

numba_cuda/numba/cuda/dispatcher.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
 import os
 import sys
@@ -7,40 +10,42 @@ import functools
 import types as pytypes
 import weakref
 import uuid
+import re
+from warnings import warn
 
-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 import cuda, _dispatcher
+
+from numba.core import types
 from numba.core.compiler_lock import global_compiler_lock
 from numba.core.dispatcher import _DispatcherBase
 from numba.core.errors import NumbaPerformanceWarning, TypingError
-from numba.cuda.typing.templates import fold_arguments
 from numba.core.typing.typeof import Purpose, typeof
+
+from numba.cuda import serialize, utils, typing
+from numba.cuda import types as cuda_types
 from numba.cuda.api import get_current_device
 from numba.cuda.args import wrap_arg
 from numba.cuda.compiler import (
     compile_cuda,
     CUDACompiler,
     kernel_fixup,
+    compile_extra,
 )
-from numba.cuda.core import sigutils
-import re
+from numba.cuda.core import sigutils, config
+from numba.cuda.flags import Flags
 from numba.cuda.cudadrv import driver, nvvm
-from numba.cuda.cudadrv.linkable_code import LinkableCode
-from numba.cuda.cudadrv.devices import get_context
+from numba.cuda.locks import module_init_lock
+from numba.cuda.core.caching import Cache, CacheImpl, NullCache
 from numba.cuda.descriptor import cuda_target
 from numba.cuda.errors import (
     missing_launch_config_msg,
     normalize_kernel_dimensions,
 )
-from numba.cuda import types as cuda_types
-from numba.cuda.locks import module_init_lock
+from numba.cuda.typing.templates import fold_arguments
+from numba.cuda.cudadrv.linkable_code import LinkableCode
+from numba.cuda.cudadrv.devices import get_context
 from numba.cuda.memory_management.nrt import rtsys, NRT_LIBRARY
 
-from numba import cuda
-from numba import _dispatcher
-
-from warnings import warn
 
 cuda_fp16_math_funcs = [
     "hsin",
@@ -208,13 +213,11 @@ class _Kernel(serialize.ReduceMixin):
         # The following are referred to by the cache implementation. Note:
         # - There are no referenced environments in CUDA.
         # - Kernels don't have lifted code.
-        # - reload_init is only for parfors.
         self.target_context = tgt_ctx
         self.fndesc = cres.fndesc
         self.environment = cres.environment
         self._referenced_environments = []
         self.lifted = []
-        self.reload_init = []
 
     def maybe_link_nrt(self, link, tgt_ctx, asm):
         """
@@ -832,12 +835,12 @@ class _FunctionCompiler(object):
             return True, retval
 
     def _compile_core(self, args, return_type):
-        flags = compiler.Flags()
+        flags = Flags()
         self.targetdescr.options.parse_as_flags(flags, self.targetoptions)
         flags = self._customize_flags(flags)
 
         impl = self._get_implementation(args, {})
-        cres = compiler.compile_extra(
+        cres = compile_extra(
             self.targetdescr.typing_context,
             self.targetdescr.target_context,
             impl,
@@ -1342,27 +1345,6 @@ class CUDADispatcher(serialize.ReduceMixin, _MemoMixin, _DispatcherBase):
             cache_misses=self._cache_misses,
         )
 
-    def parallel_diagnostics(self, signature=None, level=1):
-        """
-        Print parallel diagnostic information for the given signature. If no
-        signature is present it is printed for all known signatures. level is
-        used to adjust the verbosity, level=1 (default) is minimal verbosity,
-        and 2, 3, and 4 provide increasing levels of verbosity.
-        """
-
-        def dump(sig):
-            ol = self.overloads[sig]
-            pfdiag = ol.metadata.get("parfor_diagnostics", None)
-            if pfdiag is None:
-                msg = "No parfors diagnostic available, is 'parallel=True' set?"
-                raise ValueError(msg)
-            pfdiag.dump(level)
-
-        if signature is not None:
-            dump(signature)
-        else:
-            [dump(sig) for sig in self.signatures]
-
     def get_metadata(self, signature=None):
         """
         Obtain the compilation metadata for a given signature.

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
 """

numba_cuda/numba/cuda/flags.py

@@ -1,4 +1,146 @@
-from numba.core.compiler import Flags, Option
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from numba.cuda.core.targetconfig import TargetConfig, Option
+
+from numba.cuda.core.options import (
+    ParallelOptions,
+    FastMathOptions,
+    InlineOptions,
+)
+
+
+class Flags(TargetConfig):
+    __slots__ = ()
+
+    enable_looplift = Option(
+        type=bool,
+        default=False,
+        doc="Enable loop-lifting",
+    )
+    enable_pyobject = Option(
+        type=bool,
+        default=False,
+        doc="Enable pyobject mode (in general)",
+    )
+    enable_pyobject_looplift = Option(
+        type=bool,
+        default=False,
+        doc="Enable pyobject mode inside lifted loops",
+    )
+    enable_ssa = Option(
+        type=bool,
+        default=True,
+        doc="Enable SSA",
+    )
+    force_pyobject = Option(
+        type=bool,
+        default=False,
+        doc="Force pyobject mode inside the whole function",
+    )
+    release_gil = Option(
+        type=bool,
+        default=False,
+        doc="Release GIL inside the native function",
+    )
+    no_compile = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    debuginfo = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    boundscheck = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    forceinline = Option(
+        type=bool,
+        default=False,
+        doc="Force inlining of the function. Overrides _dbg_optnone.",
+    )
+    no_cpython_wrapper = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    no_cfunc_wrapper = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    auto_parallel = Option(
+        type=ParallelOptions,
+        default=ParallelOptions(False),
+        doc="""Enable automatic parallel optimization, can be fine-tuned by
+taking a dictionary of sub-options instead of a boolean, see parfor.py for
+detail""",
+    )
+    nrt = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    no_rewrites = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    error_model = Option(
+        type=str,
+        default="python",
+        doc="TODO",
+    )
+    fastmath = Option(
+        type=FastMathOptions,
+        default=FastMathOptions(False),
+        doc="TODO",
+    )
+    noalias = Option(
+        type=bool,
+        default=False,
+        doc="TODO",
+    )
+    inline = Option(
+        type=InlineOptions,
+        default=InlineOptions("never"),
+        doc="TODO",
+    )
+
+    dbg_extend_lifetimes = Option(
+        type=bool,
+        default=False,
+        doc=(
+            "Extend variable lifetime for debugging. "
+            "This automatically turns on with debug=True."
+        ),
+    )
+
+    dbg_optnone = Option(
+        type=bool,
+        default=False,
+        doc=(
+            "Disable optimization for debug. "
+            "Equivalent to adding optnone attribute in the LLVM Function."
+        ),
+    )
+
+    dbg_directives_only = Option(
+        type=bool,
+        default=False,
+        doc=(
+            "Make debug emissions directives-only. "
+            "Used when generating lineinfo."
+        ),
+    )
+
+
+DEFAULT_FLAGS = Flags()
+DEFAULT_FLAGS.nrt = True
 
 
 def _nvvm_options_type(x):

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,
@@ -70,7 +73,6 @@ from numba.cuda._internal.cuda_fp16 import (
     __hadd,
     __hadd_rn,
     __hadd_sat,
-    __hcmadd,
     __hdiv as hdiv,
     __hdiv,
     __heq as heq,
@@ -284,7 +286,6 @@ __all__ = [
     "__hadd",
     "__hadd_rn",
     "__hadd_sat",
-    "__hcmadd",
     "hdiv",
     "__hdiv",
     "heq",