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

numba_cuda/numba/cuda/core/untyped_passes.py

@@ -350,9 +350,9 @@ class InlineInlinables(FunctionPass):
         while work_list:
             label, block = work_list.pop()
             for i, instr in enumerate(block.body):
-                if isinstance(instr, ir.Assign):
+                if isinstance(instr, ir.assign_types):
                     expr = instr.value
-                    if isinstance(expr, ir.Expr) and expr.op == "call":
+                    if isinstance(expr, ir.expr_types) and expr.op == "call":
                         if guard(
                             self._do_work,
                             state,
@@ -561,14 +561,14 @@ class CanonicalizeLoopEntry(FunctionPass):
 
         # Find the start of loop entry statement that needs to be included.
         startpt = None
-        list_of_insts = list(entry_block.find_insts(ir.Assign))
+        list_of_insts = list(entry_block.find_insts(ir.assign_types))
         for assign in reversed(list_of_insts):
             if assign.target in deps:
                 rhs = assign.value
-                if isinstance(rhs, ir.Var):
+                if isinstance(rhs, ir.var_types):
                     if rhs.is_temp:
                         deps.add(rhs)
-                elif isinstance(rhs, ir.Expr):
+                elif isinstance(rhs, ir.expr_types):
                     expr = rhs
                     if expr.op == "getiter":
                         startpt = assign
@@ -576,11 +576,11 @@ class CanonicalizeLoopEntry(FunctionPass):
                             deps.add(expr.value)
                     elif expr.op == "call":
                         defn = guard(get_definition, fir, expr.func)
-                        if isinstance(defn, ir.Global):
+                        if isinstance(defn, ir.global_types):
                             if expr.func.is_temp:
                                 deps.add(expr.func)
                 elif (
-                    isinstance(rhs, ir.Global)
+                    isinstance(rhs, ir.global_types)
                     and rhs.value in self._supported_globals
                 ):
                     startpt = assign
@@ -634,30 +634,30 @@ class MakeFunctionToJitFunction(FunctionPass):
         mutated = False
         for idx, blk in func_ir.blocks.items():
             for stmt in blk.body:
-                if isinstance(stmt, ir.Assign):
-                    if isinstance(stmt.value, ir.Expr):
+                if isinstance(stmt, ir.assign_types):
+                    if isinstance(stmt.value, ir.expr_types):
                         if stmt.value.op == "make_function":
                             node = stmt.value
                             getdef = func_ir.get_definition
                             kw_default = getdef(node.defaults)
                             ok = False
                             if kw_default is None or isinstance(
-                                kw_default, ir.Const
+                                kw_default, ir.const_types
                             ):
                                 ok = True
                             elif isinstance(kw_default, tuple):
                                 ok = all(
                                     [
-                                        isinstance(getdef(x), ir.Const)
+                                        isinstance(getdef(x), ir.const_types)
                                         for x in kw_default
                                     ]
                                 )
-                            elif isinstance(kw_default, ir.Expr):
+                            elif isinstance(kw_default, ir.expr_types):
                                 if kw_default.op != "build_tuple":
                                     continue
                                 ok = all(
                                     [
-                                        isinstance(getdef(x), ir.Const)
+                                        isinstance(getdef(x), ir.const_types)
                                         for x in kw_default.items
                                     ]
                                 )
@@ -700,7 +700,10 @@ class TransformLiteralUnrollConstListToTuple(FunctionPass):
             calls = [_ for _ in blk.find_exprs("call")]
             for call in calls:
                 glbl = guard(get_definition, func_ir, call.func)
-                if glbl and isinstance(glbl, (ir.Global, ir.FreeVar)):
+                if glbl and (
+                    isinstance(glbl, ir.global_types)
+                    or isinstance(glbl, ir.freevar_types)
+                ):
                     # find a literal_unroll
                     if glbl.value is literal_unroll:
                         if len(call.args) > 1:
@@ -712,7 +715,7 @@ class TransformLiteralUnrollConstListToTuple(FunctionPass):
                         unroll_var = call.args[0]
                         to_unroll = guard(get_definition, func_ir, unroll_var)
                         if (
-                            isinstance(to_unroll, ir.Expr)
+                            isinstance(to_unroll, ir.expr_types)
                             and to_unroll.op == "build_list"
                         ):
                             # make sure they are all const items in the list
@@ -726,7 +729,7 @@ class TransformLiteralUnrollConstListToTuple(FunctionPass):
                                     raise errors.UnsupportedError(
                                         msg % item, to_unroll.loc
                                     )
-                                if not isinstance(val, ir.Const):
+                                if not isinstance(val, ir.const_types):
                                     msg = (
                                         "Found non-constant value at "
                                         "position %s in a list argument to "
@@ -777,17 +780,18 @@ class TransformLiteralUnrollConstListToTuple(FunctionPass):
                             asgn.value = tup
                             mutated = True
                         elif (
-                            isinstance(to_unroll, ir.Expr)
+                            isinstance(to_unroll, ir.expr_types)
                             and to_unroll.op == "build_tuple"
                         ):
                             # this is fine, do nothing
                             pass
-                        elif isinstance(
-                            to_unroll, (ir.Global, ir.FreeVar)
+                        elif (
+                            isinstance(to_unroll, ir.global_types)
+                            or isinstance(to_unroll, ir.freevar_types)
                         ) and isinstance(to_unroll.value, tuple):
                             # this is fine, do nothing
                             pass
-                        elif isinstance(to_unroll, ir.Arg):
+                        elif isinstance(to_unroll, ir.arg_types):
                             # this is only fine if the arg is a tuple
                             ty = state.typemap[to_unroll.name]
                             if not isinstance(ty, self._accepted_types):
@@ -802,7 +806,7 @@ class TransformLiteralUnrollConstListToTuple(FunctionPass):
                                 )
                         else:
                             extra = None
-                            if isinstance(to_unroll, ir.Expr):
+                            if isinstance(to_unroll, ir.expr_types):
                                 # probably a slice
                                 if to_unroll.op == "getitem":
                                     ty = state.typemap[to_unroll.value.name]
@@ -810,7 +814,7 @@ class TransformLiteralUnrollConstListToTuple(FunctionPass):
                                     if not isinstance(ty, self._accepted_types):
                                         extra = "operation %s" % to_unroll.op
                                         loc = to_unroll.loc
-                            elif isinstance(to_unroll, ir.Arg):
+                            elif isinstance(to_unroll, ir.arg_types):
                                 extra = "non-const argument %s" % to_unroll.name
                                 loc = to_unroll.loc
                             else:
@@ -868,10 +872,10 @@ class MixedContainerUnroller(FunctionPass):
             term = None
             if b.body:
                 term = b.body[-1]
-            if isinstance(term, ir.Jump):
+            if isinstance(term, ir.jump_types):
                 if term.target not in ignore:
                     b.body[-1] = ir.Jump(term.target + offset, term.loc)
-            if isinstance(term, ir.Branch):
+            if isinstance(term, ir.branch_types):
                 if term.truebr not in ignore:
                     new_true = term.truebr + offset
                 else:
@@ -925,7 +929,7 @@ class MixedContainerUnroller(FunctionPass):
         sentinel_blocks = []
         for lbl, blk in switch_ir.blocks.items():
             for i, stmt in enumerate(blk.body):
-                if isinstance(stmt, ir.Assign):
+                if isinstance(stmt, ir.assign_types):
                     if "SENTINEL" in stmt.target.name:
                         sentinel_blocks.append(lbl)
                         sentinel_exits.add(blk.body[-1].target)
@@ -939,10 +943,10 @@ class MixedContainerUnroller(FunctionPass):
         local_lbl = [x for x in loop_ir.blocks.keys()]
         for lbl, blk in loop_ir.blocks.items():
             for i, stmt in enumerate(blk.body):
-                if isinstance(stmt, ir.Jump):
+                if isinstance(stmt, ir.jump_types):
                     if stmt.target not in local_lbl:
                         ignore_set.add(stmt.target)
-                if isinstance(stmt, ir.Branch):
+                if isinstance(stmt, ir.branch_types):
                     if stmt.truebr not in local_lbl:
                         ignore_set.add(stmt.truebr)
                     if stmt.falsebr not in local_lbl:
@@ -968,9 +972,9 @@ class MixedContainerUnroller(FunctionPass):
             for blk in loop_blocks.values():
                 new_body = []
                 for stmt in blk.body:
-                    if isinstance(stmt, ir.Assign):
+                    if isinstance(stmt, ir.assign_types):
                         if (
-                            isinstance(stmt.value, ir.Expr)
+                            isinstance(stmt.value, ir.expr_types)
                             and stmt.value.op == "typed_getitem"
                         ):
                             if isinstance(branch_ty, types.Literal):
@@ -1130,8 +1134,8 @@ class MixedContainerUnroller(FunctionPass):
         branches = compile_to_numba_ir(bfunc, {})
         for lbl, blk in branches.blocks.items():
             for stmt in blk.body:
-                if isinstance(stmt, ir.Assign):
-                    if isinstance(stmt.value, ir.Global):
+                if isinstance(stmt, ir.assign_types):
+                    if isinstance(stmt.value, ir.global_types):
                         if stmt.value.name == "PLACEHOLDER_INDEX":
                             stmt.value = index
         return branches
@@ -1154,12 +1158,12 @@ class MixedContainerUnroller(FunctionPass):
             # call to a global function "want" and returns the arguments
             # supplied to that function's call
             some_call = get_definition(func_ir, init_arg)
-            if not isinstance(some_call, ir.Expr):
+            if not isinstance(some_call, ir.expr_types):
                 raise GuardException
             if not some_call.op == "call":
                 raise GuardException
             the_global = get_definition(func_ir, some_call.func)
-            if not isinstance(the_global, ir.Global):
+            if not isinstance(the_global, ir.global_types):
                 raise GuardException
             if the_global.value is not want:
                 raise GuardException
@@ -1206,7 +1210,7 @@ class MixedContainerUnroller(FunctionPass):
                     )
                     if literal_unroll_call is None:
                         continue
-                    if not isinstance(literal_unroll_call, ir.Expr):
+                    if not isinstance(literal_unroll_call, ir.expr_types):
                         continue
                     if literal_unroll_call.op != "call":
                         continue
@@ -1263,9 +1267,9 @@ class MixedContainerUnroller(FunctionPass):
                 for lbli in loop.body:
                     blk = func_ir.blocks[lbli]
                     for stmt in blk.body:
-                        if isinstance(stmt, ir.Assign):
+                        if isinstance(stmt, ir.assign_types):
                             if (
-                                isinstance(stmt.value, ir.Expr)
+                                isinstance(stmt.value, ir.expr_types)
                                 and stmt.value.op == "getitem"
                             ):
                                 # check for something like a[i]
@@ -1346,9 +1350,9 @@ class MixedContainerUnroller(FunctionPass):
         for lbl in loop_info.loop.body:
             blk = func_ir.blocks[lbl]
             for stmt in blk.body:
-                if isinstance(stmt, ir.Assign):
+                if isinstance(stmt, ir.assign_types):
                     if (
-                        isinstance(stmt.value, ir.Expr)
+                        isinstance(stmt.value, ir.expr_types)
                         and stmt.value.op == "getitem"
                     ):
                         # try a couple of spellings... a[i] and ref(a)[i]
@@ -1508,7 +1512,7 @@ class IterLoopCanonicalization(FunctionPass):
                     # confident that tuple unrolling is behaving require opt-in
                     # guard of `literal_unroll`, remove this later!
                     phi_val_defn = guard(get_definition, func_ir, phi.value)
-                    if not isinstance(phi_val_defn, ir.Expr):
+                    if not isinstance(phi_val_defn, ir.expr_types):
                         return False
                     if not phi_val_defn.op == "call":
                         return False
@@ -1518,7 +1522,7 @@ class IterLoopCanonicalization(FunctionPass):
                     func_var = guard(get_definition, func_ir, call.func)
                     func = guard(get_definition, func_ir, func_var)
                     if func is None or not isinstance(
-                        func, (ir.Global, ir.FreeVar)
+                        func, ir.global_types + ir.freevar_types
                     ):
                         return False
                     if (
@@ -1558,9 +1562,9 @@ class IterLoopCanonicalization(FunctionPass):
         # look for iternext
         idx = 0
         for stmt in entry_block.body:
-            if isinstance(stmt, ir.Assign):
+            if isinstance(stmt, ir.assign_types):
                 if (
-                    isinstance(stmt.value, ir.Expr)
+                    isinstance(stmt.value, ir.expr_types)
                     and stmt.value.op == "getiter"
                 ):
                     break
@@ -1615,7 +1619,7 @@ class IterLoopCanonicalization(FunctionPass):
         # replace RHS use of induction var with getitem
         for lbl in check_blocks:
             for stmt in func_ir.blocks[lbl].body:
-                if isinstance(stmt, ir.Assign):
+                if isinstance(stmt, ir.assign_types):
                     # check for aliases
                     try:
                         lookup = getattr(stmt.value, "name", None)
@@ -1675,15 +1679,20 @@ class PropagateLiterals(FunctionPass):
         changed = False
 
         for block in func_ir.blocks.values():
-            for assign in block.find_insts(ir.Assign):
+            for assign in block.find_insts(ir.assign_types):
                 value = assign.value
-                if isinstance(value, (ir.Arg, ir.Const, ir.FreeVar, ir.Global)):
+                if (
+                    isinstance(value, ir.arg_types)
+                    or isinstance(value, ir.const_types)
+                    or isinstance(value, ir.freevar_types)
+                    or isinstance(value, ir.global_types)
+                ):
                     continue
 
                 # 1) Don't change return stmt in the form
                 # $return_xyz = cast(value=ABC)
                 # 2) Don't propagate literal values that are not primitives
-                if isinstance(value, ir.Expr) and value.op in (
+                if isinstance(value, ir.expr_types) and value.op in (
                     "cast",
                     "build_map",
                     "build_list",
@@ -1716,13 +1725,13 @@ class PropagateLiterals(FunctionPass):
                 # At the moment, one avoid propagating the literal
                 # value if the argument is a PHI node
 
-                if isinstance(value, ir.Expr) and value.op == "call":
+                if isinstance(value, ir.expr_types) and value.op == "call":
                     fn = guard(get_definition, func_ir, value.func.name)
                     if fn is None:
                         continue
 
                     if not (
-                        isinstance(fn, ir.Global)
+                        isinstance(fn, ir.global_types)
                         and fn.name in accepted_functions
                     ):
                         continue
@@ -1731,7 +1740,10 @@ class PropagateLiterals(FunctionPass):
                         # check if any of the args to isinstance is a PHI node
                         iv = func_ir._definitions[arg.name]
                         assert len(iv) == 1  # SSA!
-                        if isinstance(iv[0], ir.Expr) and iv[0].op == "phi":
+                        if (
+                            isinstance(iv[0], ir.expr_types)
+                            and iv[0].op == "phi"
+                        ):
                             msg = (
                                 f"{fn.name}() cannot determine the "
                                 f'type of variable "{arg.unversioned_name}" '
@@ -1741,7 +1753,7 @@ class PropagateLiterals(FunctionPass):
 
                 # Only propagate a PHI node if all arguments are the same
                 # constant
-                if isinstance(value, ir.Expr) and value.op == "phi":
+                if isinstance(value, ir.expr_types) and value.op == "phi":
                     # typemap will return None in case `inc.name` not in typemap
                     v = [typemap.get(inc.name) for inc in value.incoming_values]
                     # stop if the elements in `v` do not hold the same value
@@ -1788,8 +1800,10 @@ class LiteralPropagationSubPipelinePass(FunctionPass):
         found = False
         func_ir = state.func_ir
         for blk in func_ir.blocks.values():
-            for asgn in blk.find_insts(ir.Assign):
-                if isinstance(asgn.value, (ir.Global, ir.FreeVar)):
+            for asgn in blk.find_insts(ir.assign_types):
+                if isinstance(asgn.value, ir.global_types) or isinstance(
+                    asgn.value, ir.freevar_types
+                ):
                     value = asgn.value.value
                     if value is isinstance or value is hasattr:
                         found = True
@@ -1835,8 +1849,10 @@ class LiteralUnroll(FunctionPass):
         found = False
         func_ir = state.func_ir
         for blk in func_ir.blocks.values():
-            for asgn in blk.find_insts(ir.Assign):
-                if isinstance(asgn.value, (ir.Global, ir.FreeVar)):
+            for asgn in blk.find_insts(ir.assign_types):
+                if isinstance(asgn.value, ir.global_types) or isinstance(
+                    asgn.value, ir.freevar_types
+                ):
                     if asgn.value.value is literal_unroll:
                         found = True
                         break
@@ -1953,7 +1969,7 @@ class RewriteDynamicRaises(FunctionPass):
         changed = False
 
         for block in func_ir.blocks.values():
-            for raise_ in block.find_insts((ir.Raise, ir.TryRaise)):
+            for raise_ in block.find_insts(ir.raise_types + ir.tryraise_types):
                 call_inst = guard(get_definition, func_ir, raise_.exception)
                 if call_inst is None:
                     continue

numba_cuda/numba/cuda/cudadecl.py

@@ -103,16 +103,6 @@ class Cuda_syncwarp(ConcreteTemplate):
     cases = [signature(types.none), signature(types.none, types.i4)]
 
 
-@register
-class Cuda_vote_sync_intrinsic(ConcreteTemplate):
-    key = cuda.vote_sync_intrinsic
-    cases = [
-        signature(
-            types.Tuple((types.i4, types.b1)), types.i4, types.i4, types.b1
-        )
-    ]
-
-
 @register
 class Cuda_match_any_sync(ConcreteTemplate):
     key = cuda.match_any_sync
@@ -522,9 +512,6 @@ class CudaModuleTemplate(AttributeTemplate):
     def resolve_syncwarp(self, mod):
         return types.Function(Cuda_syncwarp)
 
-    def resolve_vote_sync_intrinsic(self, mod):
-        return types.Function(Cuda_vote_sync_intrinsic)
-
     def resolve_match_any_sync(self, mod):
         return types.Function(Cuda_match_any_sync)
 

numba_cuda/numba/cuda/cudadrv/devicearray.py

@@ -15,7 +15,6 @@ from ctypes import c_void_p
 
 import numpy as np
 
-from numba.cuda.cext import _devicearray
 from numba.cuda.cudadrv import devices, dummyarray
 from numba.cuda.cudadrv import driver as _driver
 from numba.cuda import types
@@ -55,7 +54,7 @@ def require_cuda_ndarray(obj):
         raise ValueError("require an cuda ndarray object")
 
 
-class DeviceNDArrayBase(_devicearray.DeviceArray):
+class DeviceNDArrayBase:
     """A on GPU NDArray representation"""
 
     __cuda_memory__ = True
@@ -108,7 +107,9 @@ class DeviceNDArrayBase(_devicearray.DeviceArray):
         else:
             # Make NULL pointer for empty allocation
             null = _driver.binding.CUdeviceptr(0)
-            gpu_data = _driver.MemoryPointer(pointer=null, size=0)
+            gpu_data = _driver.MemoryPointer(
+                context=devices.get_context(), pointer=null, size=0
+            )
             self.alloc_size = 0
 
         self.gpu_data = gpu_data
@@ -158,7 +159,7 @@ class DeviceNDArrayBase(_devicearray.DeviceArray):
     def _default_stream(self, stream):
         return self.stream if not stream else stream
 
-    @property
+    @functools.cached_property
     def _numba_type_(self):
         """
         Magic attribute expected by Numba to get the numba type that
@@ -177,8 +178,8 @@ class DeviceNDArrayBase(_devicearray.DeviceArray):
         # or 'F' does not apply for broadcast arrays, because the strides, some
         # of which will be 0, will not match those hardcoded in for 'C' or 'F'
         # layouts.
+        broadcast = 0 in self.strides and (self.size != 0)
 
-        broadcast = 0 in self.strides
         if self.flags["C_CONTIGUOUS"] and not broadcast:
             layout = "C"
         elif self.flags["F_CONTIGUOUS"] and not broadcast: