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

numba_cuda/numba/cuda/deviceufunc.py

@@ -10,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

@@ -10,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",
@@ -211,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):
         """
@@ -835,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,
@@ -1345,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/flags.py

@@ -1,6 +1,146 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
-from numba.core.compiler import Flags, Option
+
+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

@@ -73,7 +73,6 @@ from numba.cuda._internal.cuda_fp16 import (
     __hadd,
     __hadd_rn,
     __hadd_sat,
-    __hcmadd,
     __hdiv as hdiv,
     __hdiv,
     __heq as heq,
@@ -287,7 +286,6 @@ __all__ = [
     "__hadd",
     "__hadd_rn",
     "__hadd_sat",
-    "__hcmadd",
     "hdiv",
     "__hdiv",
     "heq",