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

numba_cuda/numba/cuda/core/postproc.py

@@ -7,8 +7,8 @@ from numba.cuda.core import ir_utils, transforms
 
 class YieldPoint(object):
     def __init__(self, block, inst):
-        assert isinstance(block, ir.Block)
-        assert isinstance(inst, ir.Yield)
+        assert isinstance(block, ir.block_types)
+        assert isinstance(inst, ir.yield_types)
         self.block = block
         self.inst = inst
         self.live_vars = None
@@ -111,9 +111,9 @@ class PostProcessor(object):
         assert not dct, "rerunning _populate_generator_info"
         for block in self.func_ir.blocks.values():
             for inst in block.body:
-                if isinstance(inst, ir.Assign):
+                if isinstance(inst, ir.assign_types):
                     yieldinst = inst.value
-                    if isinstance(yieldinst, ir.Yield):
+                    if isinstance(yieldinst, ir.yield_types):
                         index = len(dct) + 1
                         yieldinst.index = index
                         yp = YieldPoint(block, yieldinst)
@@ -133,18 +133,18 @@ class PostProcessor(object):
             weak_live_vars = set()
             stmts = iter(yp.block.body)
             for stmt in stmts:
-                if isinstance(stmt, ir.Assign):
+                if isinstance(stmt, ir.assign_types):
                     if stmt.value is yp.inst:
                         break
                     live_vars.add(stmt.target.name)
-                elif isinstance(stmt, ir.Del):
+                elif isinstance(stmt, ir.del_types):
                     live_vars.remove(stmt.value)
             else:
                 assert 0, "couldn't find yield point"
             # Try to optimize out any live vars that are deleted immediately
             # after the yield point.
             for stmt in stmts:
-                if isinstance(stmt, ir.Del):
+                if isinstance(stmt, ir.del_types):
                     name = stmt.value
                     if name in live_vars:
                         live_vars.remove(name)
@@ -222,7 +222,7 @@ class PostProcessor(object):
                 else:
                     lastloc = stmt.loc
                 # Ignore dels (assuming no user inserted deletes)
-                if not isinstance(stmt, ir.Del):
+                if not isinstance(stmt, ir.del_types):
                     body.append(stmt)
                 # note: the reverse sort is not necessary for correctness
                 #       it is just to minimize changes to test for now

numba_cuda/numba/cuda/core/pythonapi.py

@@ -875,6 +875,9 @@ class PythonAPI(object):
                 self.py_hash_t.as_pointer(),
             ],
         )
+        # `_PySet_NextEntry` returns a borrowed reference to the key, which is
+        # generally not expected for iterators--which is the place where this
+        # is used internally. Perhaps we should revisit this at some point
         fn = self._get_function(fnty, name="_PySet_NextEntry")
         return self.builder.call(fn, (set, posptr, keyptr, hashptr))
 

numba_cuda/numba/cuda/core/rewrites/ir_print.py

@@ -16,8 +16,11 @@ class RewritePrintCalls(Rewrite):
         self.prints = prints = {}
         self.block = block
         # Find all assignments with a right-hand print() call
-        for inst in block.find_insts(ir.Assign):
-            if isinstance(inst.value, ir.Expr) and inst.value.op == "call":
+        for inst in block.find_insts(ir.assign_types):
+            if (
+                isinstance(inst.value, ir.expr_types)
+                and inst.value.op == "call"
+            ):
                 expr = inst.value
                 try:
                     callee = func_ir.infer_constant(expr.func)
@@ -68,7 +71,7 @@ class DetectConstPrintArguments(Rewrite):
     def match(self, func_ir, block, typemap, calltypes):
         self.consts = consts = {}
         self.block = block
-        for inst in block.find_insts(ir.Print):
+        for inst in block.find_insts(ir.print_types):
             if inst.consts:
                 # Already rewritten
                 continue

numba_cuda/numba/cuda/core/rewrites/static_binop.py

@@ -27,7 +27,7 @@ class DetectStaticBinops(Rewrite):
                     and expr.static_rhs is ir.UNDEFINED
                 ):
                     self.static_rhs[expr] = func_ir.infer_constant(expr.rhs)
-            except errors.ConstantInferenceError:
+            except errors.ConstantInferenceError:  # noqa: PERF203
                 continue
 
         return len(self.static_lhs) > 0 or len(self.static_rhs) > 0

numba_cuda/numba/cuda/core/rewrites/static_getitem.py

@@ -37,7 +37,7 @@ class RewriteConstGetitems(Rewrite):
         new_block = self.block.copy()
         new_block.clear()
         for inst in self.block.body:
-            if isinstance(inst, ir.Assign):
+            if isinstance(inst, ir.assign_types):
                 expr = inst.value
                 if expr in self.getitems:
                     const = self.getitems[expr]
@@ -85,7 +85,7 @@ class RewriteStringLiteralGetitems(Rewrite):
         """
         new_block = ir.Block(self.block.scope, self.block.loc)
         for inst in self.block.body:
-            if isinstance(inst, ir.Assign):
+            if isinstance(inst, ir.assign_types):
                 expr = inst.value
                 if expr in self.getitems:
                     const, lit_val = self.getitems[expr]
@@ -119,7 +119,7 @@ class RewriteStringLiteralSetitems(Rewrite):
         self.setitems = setitems = {}
         self.block = block
         self.calltypes = calltypes
-        for inst in block.find_insts(ir.SetItem):
+        for inst in block.find_insts(ir.setitem_types):
             index_ty = typemap[inst.index.name]
             if isinstance(index_ty, types.StringLiteral):
                 setitems[inst] = (inst.index, index_ty.literal_value)
@@ -133,7 +133,7 @@ class RewriteStringLiteralSetitems(Rewrite):
         """
         new_block = ir.Block(self.block.scope, self.block.loc)
         for inst in self.block.body:
-            if isinstance(inst, ir.SetItem):
+            if isinstance(inst, ir.setitem_types):
                 if inst in self.setitems:
                     const, lit_val = self.setitems[inst]
                     new_inst = ir.StaticSetItem(
@@ -162,7 +162,7 @@ class RewriteConstSetitems(Rewrite):
         self.block = block
         # Detect all setitem statements and find which ones can be
         # rewritten
-        for inst in block.find_insts(ir.SetItem):
+        for inst in block.find_insts(ir.setitem_types):
             try:
                 const = func_ir.infer_constant(inst.index)
             except errors.ConstantInferenceError:

numba_cuda/numba/cuda/core/rewrites/static_raise.py

@@ -56,7 +56,7 @@ class RewriteConstRaises(Rewrite):
         self.block = block
         # Detect all raise statements and find which ones can be
         # rewritten
-        for inst in block.find_insts((ir.Raise, ir.TryRaise)):
+        for inst in block.find_insts(ir.raise_types + ir.tryraise_types):
             if inst.exception is None:
                 # re-reraise
                 exc_type, exc_args = None, None
@@ -72,9 +72,9 @@ class RewriteConstRaises(Rewrite):
                 loc = inst.exception.loc
                 exc_type, exc_args = self._break_constant(const, loc)
 
-            if isinstance(inst, ir.Raise):
+            if isinstance(inst, ir.raise_types):
                 raises[inst] = exc_type, exc_args
-            elif isinstance(inst, ir.TryRaise):
+            elif isinstance(inst, ir.tryraise_types):
                 tryraises[inst] = exc_type, exc_args
             else:
                 raise ValueError("unexpected: {}".format(type(inst)))

numba_cuda/numba/cuda/core/ssa.py

@@ -113,8 +113,8 @@ def _iterated_domfronts(cfg):
     keep_going = True
     while keep_going:
         keep_going = False
-        for k, vs in domfronts.items():
-            inner = reduce(operator.or_, [domfronts[v] for v in vs], set())
+        for vs in domfronts.values():
+            inner = reduce(operator.or_, map(domfronts.__getitem__, vs), set())
             if inner.difference(vs):
                 vs |= inner
                 keep_going = True
@@ -211,7 +211,7 @@ def _run_ssa_block_pass(states, blk, handler):
     _logger.debug("Running %s", handler)
     for stmt in blk.body:
         _logger.debug("on stmt: %s", stmt)
-        if isinstance(stmt, ir.Assign):
+        if isinstance(stmt, ir.assign_types):
             ret = handler.on_assign(states, stmt)
         else:
             ret = handler.on_other(states, stmt)
@@ -335,7 +335,7 @@ class _FixSSAVars(_BaseHandler):
 
     def on_assign(self, states, assign):
         rhs = assign.value
-        if isinstance(rhs, ir.Inst):
+        if isinstance(rhs, ir.inst_types):
             newdef = self._fix_var(
                 states,
                 assign,
@@ -353,7 +353,7 @@ class _FixSSAVars(_BaseHandler):
                         value=rhs,
                         loc=assign.loc,
                     )
-        elif isinstance(rhs, ir.Var):
+        elif isinstance(rhs, ir.var_types):
             newdef = self._fix_var(states, assign, [rhs])
             # Has a replacement that is not the current variable
             if newdef is not None and newdef.target is not ir.UNDEFINED:

numba_cuda/numba/cuda/core/transforms.py

@@ -55,8 +55,8 @@ def _extract_loop_lifting_candidates(cfg, blocks):
         insiders = set(loop.body) | set(loop.entries) | set(loop.exits)
         for blk in map(blocks.__getitem__, insiders):
             for inst in blk.body:
-                if isinstance(inst, ir.Assign):
-                    if isinstance(inst.value, ir.Yield):
+                if isinstance(inst, ir.assign_types):
+                    if isinstance(inst.value, ir.yield_types):
                         _logger.debug("has yield")
                         return False
         _logger.debug("no yield")
@@ -347,14 +347,14 @@ def canonicalize_cfg_single_backedge(blocks):
         def replace(target):
             return dst if target == src else target
 
-        if isinstance(term, ir.Branch):
+        if isinstance(term, ir.branch_types):
             return ir.Branch(
                 cond=term.cond,
                 truebr=replace(term.truebr),
                 falsebr=replace(term.falsebr),
                 loc=term.loc,
             )
-        elif isinstance(term, ir.Jump):
+        elif isinstance(term, ir.jump_types):
             return ir.Jump(target=replace(term.target), loc=term.loc)
         else:
             assert not term.get_targets()
@@ -436,9 +436,7 @@ def with_lifting(func_ir, typingctx, targetctx, flags, locals):
     # the kind of contextmanager
     sub_irs = []
     for blk_start, blk_end in withs:
-        body_blocks = []
-        for node in _cfg_nodes_in_region(cfg, blk_start, blk_end):
-            body_blocks.append(node)
+        body_blocks = _cfg_nodes_in_region(cfg, blk_start, blk_end).copy()
         _legalize_with_head(blocks[blk_start])
         # Find the contextmanager
         cmkind, extra = _get_with_contextmanager(func_ir, blocks, blk_start)
@@ -477,7 +475,7 @@ def _get_with_contextmanager(func_ir, blocks, blk_start):
         """
         # If the contextmanager used as a Call
         dfn = func_ir.get_definition(var_ref)
-        if isinstance(dfn, ir.Expr) and dfn.op == "call":
+        if isinstance(dfn, ir.expr_types) and dfn.op == "call":
             args = [get_var_dfn(x) for x in dfn.args]
             kws = {k: get_var_dfn(v) for k, v in dfn.kws}
             extra = {"args": args, "kwargs": kws}
@@ -501,7 +499,7 @@ def _get_with_contextmanager(func_ir, blocks, blk_start):
 
     # Scan the start of the with-region for the contextmanager
     for stmt in blocks[blk_start].body:
-        if isinstance(stmt, ir.EnterWith):
+        if isinstance(stmt, ir.enterwith_types):
             var_ref = stmt.contextmanager
             ctxobj, extra = get_ctxmgr_obj(var_ref)
             if not hasattr(ctxobj, "mutate_with_body"):
@@ -523,7 +521,22 @@ def _legalize_with_head(blk):
     """
     counters = defaultdict(int)
     for stmt in blk.body:
-        counters[type(stmt)] += 1
+        # The counters dict is keyed on the IR node type. As the rest of the
+        # function pops out specific node types, we normalize these node types
+        # to be the Numba-CUDA versions of them so that we don't have to have
+        # more complicated logic looking for both Numba and Numba-CUDA IR nodes
+        # of the same kind.
+        if isinstance(stmt, ir.enterwith_types):
+            stmt_type = ir.EnterWith
+        elif isinstance(stmt, ir.jump_types):
+            stmt_type = ir.Jump
+        elif isinstance(stmt, ir.del_types):
+            stmt_type = ir.Del
+        else:
+            stmt_type = type(stmt)
+
+        counters[stmt_type] += 1
+
     if counters.pop(ir.EnterWith) != 1:
         raise errors.CompilerError(
             "with's head-block must have exactly 1 ENTER_WITH",
@@ -616,9 +629,9 @@ def find_setupwiths(func_ir):
                     # add all its targets to the to_visit stack, unless we
                     # have seen them already
                     if ir_utils.is_terminator(stmt):
-                        for t in stmt.get_targets():
-                            if t not in seen:
-                                to_visit.append(t)
+                        to_visit.extend(
+                            t for t in stmt.get_targets() if t not in seen
+                        )
 
         return setup_with_to_pop_blocks_map
 
@@ -744,10 +757,10 @@ def _rewrite_return(func_ir, target_block_label):
     # JUMP
     # -----------------
     top_body, bottom_body = [], []
-    pop_blocks = [*target_block.find_insts(ir.PopBlock)]
+    pop_blocks = [*target_block.find_insts(ir.popblock_types)]
     assert len(pop_blocks) == 1
-    assert len([*target_block.find_insts(ir.Jump)]) == 1
-    assert isinstance(target_block.body[-1], ir.Jump)
+    assert len([*target_block.find_insts(ir.jump_types)]) == 1
+    assert isinstance(target_block.body[-1], ir.jump_types)
     pb_marker = pop_blocks[0]
     pb_is = target_block.body.index(pb_marker)
     top_body.extend(target_block.body[:pb_is])

numba_cuda/numba/cuda/core/typed_passes.py

@@ -164,17 +164,17 @@ class BaseTypeInference(FunctionPass):
                 retstmts = []
                 caststmts = {}
                 argvars = set()
-                for bid, blk in interp.blocks.items():
+                for blk in interp.blocks.values():
                     for inst in blk.body:
-                        if isinstance(inst, ir.Return):
+                        if isinstance(inst, ir.return_types):
                             retstmts.append(inst.value.name)
-                        elif isinstance(inst, ir.Assign):
+                        elif isinstance(inst, ir.assign_types):
                             if (
-                                isinstance(inst.value, ir.Expr)
+                                isinstance(inst.value, ir.expr_types)
                                 and inst.value.op == "cast"
                             ):
                                 caststmts[inst.target.name] = inst.value
-                            elif isinstance(inst.value, ir.Arg):
+                            elif isinstance(inst.value, ir.arg_types):
                                 argvars.add(inst.target.name)
 
                 assert retstmts, "No return statements?"
@@ -518,9 +518,9 @@ class InlineOverloads(FunctionPass):
             label, block = work_list.pop()
             for i, instr in enumerate(block.body):
                 # TO-DO: other statements (setitem)
-                if isinstance(instr, ir.Assign):
+                if isinstance(instr, ir.assign_types):
                     expr = instr.value
-                    if isinstance(expr, ir.Expr):
+                    if isinstance(expr, ir.expr_types):
                         workfn = self._do_work_expr
 
                         if guard(
@@ -822,8 +822,8 @@ class PreLowerStripPhis(FunctionPass):
         phis = set()
         # Find all variables that needs to be exported
         for label, block in func_ir.blocks.items():
-            for assign in block.find_insts(ir.Assign):
-                if isinstance(assign.value, ir.Expr):
+            for assign in block.find_insts(ir.assign_types):
+                if isinstance(assign.value, ir.expr_types):
                     if assign.value.op == "phi":
                         phis.add(assign)
                         phi = assign.value
@@ -854,7 +854,7 @@ class PreLowerStripPhis(FunctionPass):
                 # last assignment to rhs
                 assignments = [
                     stmt
-                    for stmt in newblk.find_insts(ir.Assign)
+                    for stmt in newblk.find_insts(ir.assign_types)
                     if stmt.target == rhs
                 ]
                 if assignments:

numba_cuda/numba/cuda/core/typeinfer.py

@@ -653,7 +653,7 @@ class CallConstraint(object):
             unsatisfied = set()
             for idx in e.requested_args:
                 maybe_arg = typeinfer.func_ir.get_definition(folded[idx])
-                if isinstance(maybe_arg, ir.Arg):
+                if isinstance(maybe_arg, ir.arg_types):
                     requested.add(maybe_arg.index)
                 else:
                     unsatisfied.add(idx)
@@ -1081,7 +1081,7 @@ class TypeInferer(object):
         rets = []
         for blk in self.blocks.values():
             inst = blk.terminator
-            if isinstance(inst, ir.Return):
+            if isinstance(inst, ir.return_types):
                 rets.append(inst.value)
         return rets
 
@@ -1241,7 +1241,7 @@ https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-has-an-unt
                                 call_name = offender.value.func.name
                                 # find the offender based on the call name
                                 offender = find_offender(call_name)
-                                if isinstance(offender.value, ir.Global):
+                                if isinstance(offender.value, ir.global_types):
                                     if offender.value.name == "list":
                                         return list_msg
                             except (AttributeError, KeyError):
@@ -1447,9 +1447,9 @@ https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-has-an-unt
                     returns = {}
                     for x in reversed(lst):
                         for block in self.func_ir.blocks.values():
-                            for instr in block.find_insts(ir.Return):
+                            for instr in block.find_insts(ir.return_types):
                                 value = instr.value
-                                if isinstance(value, ir.Var):
+                                if isinstance(value, ir.var_types):
                                     name = value.name
                                 else:
                                     pass
@@ -1464,9 +1464,9 @@ https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-has-an-unt
                         interped = msg % (name, atype, loc.strformat())
                     return interped
 
-                problem_str = []
-                for xtype in rettypes:
-                    problem_str.append(_termcolor.errmsg(check_type(xtype)))
+                problem_str = [
+                    _termcolor.errmsg(check_type(xtype)) for xtype in rettypes
+                ]
 
                 raise TypingError(
                     "Can't unify return type from the "
@@ -1497,27 +1497,37 @@ https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-has-an-unt
         return [tv.type for name, tv in sorted(self.typevars.items())]
 
     def constrain_statement(self, inst):
-        if isinstance(inst, ir.Assign):
+        if isinstance(inst, ir.assign_types):
             self.typeof_assign(inst)
-        elif isinstance(inst, ir.SetItem):
+        elif isinstance(inst, ir.setitem_types):
             self.typeof_setitem(inst)
-        elif isinstance(inst, ir.StaticSetItem):
+        elif isinstance(inst, ir.staticsetitem_types):
             self.typeof_static_setitem(inst)
-        elif isinstance(inst, ir.DelItem):
+        elif isinstance(inst, ir.delitem_types):
             self.typeof_delitem(inst)
-        elif isinstance(inst, ir.SetAttr):
+        elif isinstance(inst, ir.setattr_types):
             self.typeof_setattr(inst)
-        elif isinstance(inst, ir.Print):
+        elif isinstance(inst, ir.print_types):
             self.typeof_print(inst)
-        elif isinstance(inst, ir.StoreMap):
+        elif isinstance(inst, ir.storemap_types):
             self.typeof_storemap(inst)
-        elif isinstance(inst, (ir.Jump, ir.Branch, ir.Return, ir.Del)):
+        elif isinstance(inst, ir.jump_types):
+            pass
+        elif isinstance(inst, ir.branch_types):
+            pass
+        elif isinstance(inst, ir.return_types):
+            pass
+        elif isinstance(inst, ir.del_types):
             pass
-        elif isinstance(inst, (ir.DynamicRaise, ir.DynamicTryRaise)):
+        elif isinstance(inst, ir.dynamicraise_types):
             pass
-        elif isinstance(inst, (ir.StaticRaise, ir.StaticTryRaise)):
+        elif isinstance(inst, ir.dynamictryraise_types):
             pass
-        elif isinstance(inst, ir.PopBlock):
+        elif isinstance(inst, ir.staticraise_types):
+            pass
+        elif isinstance(inst, ir.statictryraise_types):
+            pass
+        elif isinstance(inst, ir.popblock_types):
             pass  # It's a marker statement
         elif type(inst) in typeinfer_extensions:
             # let external calls handle stmt if type matches
@@ -1575,19 +1585,21 @@ https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-has-an-unt
 
     def typeof_assign(self, inst):
         value = inst.value
-        if isinstance(value, ir.Const):
+        if isinstance(value, ir.const_types):
             self.typeof_const(inst, inst.target, value.value)
-        elif isinstance(value, ir.Var):
+        elif isinstance(value, ir.var_types):
             self.constraints.append(
                 Propagate(dst=inst.target.name, src=value.name, loc=inst.loc)
             )
-        elif isinstance(value, (ir.Global, ir.FreeVar)):
+        elif isinstance(value, ir.global_types) or isinstance(
+            value, ir.freevar_types
+        ):
             self.typeof_global(inst, inst.target, value)
-        elif isinstance(value, ir.Arg):
+        elif isinstance(value, ir.arg_types):
             self.typeof_arg(inst, inst.target, value)
-        elif isinstance(value, ir.Expr):
+        elif isinstance(value, ir.expr_types):
             self.typeof_expr(inst, inst.target, value)
-        elif isinstance(value, ir.Yield):
+        elif isinstance(value, ir.yield_types):
             self.typeof_yield(inst, inst.target, value)
         else:
             msg = "Unsupported assignment encountered: %s %s" % (
@@ -1738,8 +1750,11 @@ https://numba.readthedocs.io/en/stable/user/troubleshoot.html#my-code-has-an-unt
                 )
 
         if isinstance(typ, types.Array):
-            # Global array in nopython mode is constant
-            typ = typ.copy(readonly=True)
+            # Global array in nopython mode is constant, except for device
+            # arrays implementing __cuda_array_interface__ which are references
+            # to mutable device memory
+            if not hasattr(gvar.value, "__cuda_array_interface__"):
+                typ = typ.copy(readonly=True)
 
         if isinstance(typ, types.BaseAnonymousTuple):
             # if it's a tuple of literal types, swap the type for the more