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

numba_cuda/numba/cuda/tests/cudapy/test_cooperative_groups.py

@@ -9,7 +9,8 @@ import cffi
 
 import numpy as np
 
-from numba import config, cuda, int32
+from numba import cuda, int32
+from numba.cuda import config
 from numba.types import CPointer
 from numba.cuda.testing import (
     unittest,
@@ -17,7 +18,6 @@ from numba.cuda.testing import (
     skip_on_cudasim,
     skip_unless_cc_60,
     skip_if_cudadevrt_missing,
-    skip_if_mvc_enabled,
 )
 from numba.core.typing import signature
 
@@ -63,7 +63,6 @@ def sequential_rows(M):
 
 
 @skip_if_cudadevrt_missing
-@skip_if_mvc_enabled("CG not supported with MVC")
 class TestCudaCooperativeGroups(CUDATestCase):
     @skip_unless_cc_60
     def test_this_grid(self):

numba_cuda/numba/cuda/tests/cudapy/test_copy_propagate.py

@@ -0,0 +1,130 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# Copyright (c) 2017 Intel Corporation
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+from numba.core import types, ir, config
+from numba.cuda import compiler
+from numba.cuda.core.annotations import type_annotations
+from numba.cuda.core.ir_utils import (
+    copy_propagate,
+    apply_copy_propagate,
+    get_name_var_table,
+)
+from numba.cuda.core.typed_passes import type_inference_stage
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+import unittest
+
+
+def _test_will_propagate(b, z, w):
+    x = 3
+    x1 = x
+    if b > 0:
+        y = z + w  # noqa: F821
+    else:
+        y = 0  # noqa: F841
+    a = 2 * x1
+    return a < b
+
+
+def _test_wont_propagate(b, z, w):
+    x = 3
+    if b > 0:
+        y = z + w  # noqa: F841
+        x = 1
+    else:
+        y = 0  # noqa: F841
+    a = 2 * x
+    return a < b
+
+
+def _in_list_var(list_var, var):
+    for i in list_var:
+        if i.name == var:
+            return True
+    return False
+
+
+def _find_assign(func_ir, var):
+    for label, block in func_ir.blocks.items():
+        for i, inst in enumerate(block.body):
+            if isinstance(inst, ir.Assign) and inst.target.name != var:
+                all_var = inst.list_vars()
+                if _in_list_var(all_var, var):
+                    return True
+
+    return False
+
+
+@skip_on_cudasim("cudasim doesn't support run_frontend")
+class TestCopyPropagate(CUDATestCase):
+    def test1(self):
+        from numba.cuda.descriptor import cuda_target
+
+        typingctx = cuda_target.typing_context
+        targetctx = cuda_target.target_context
+        test_ir = compiler.run_frontend(_test_will_propagate)
+        typingctx.refresh()
+        targetctx.refresh()
+        args = (types.int64, types.int64, types.int64)
+        typemap, return_type, calltypes, _ = type_inference_stage(
+            typingctx, targetctx, test_ir, args, None
+        )
+        _ = type_annotations.TypeAnnotation(
+            func_ir=test_ir,
+            typemap=typemap,
+            calltypes=calltypes,
+            lifted=(),
+            lifted_from=None,
+            args=args,
+            return_type=return_type,
+            html_output=config.HTML,
+        )
+        in_cps, out_cps = copy_propagate(test_ir.blocks, typemap)
+        _ = apply_copy_propagate(
+            test_ir.blocks,
+            in_cps,
+            get_name_var_table(test_ir.blocks),
+            typemap,
+            calltypes,
+        )
+
+        self.assertFalse(_find_assign(test_ir, "x1"))
+
+    def test2(self):
+        from numba.cuda.descriptor import cuda_target
+
+        typingctx = cuda_target.typing_context
+        targetctx = cuda_target.target_context
+        test_ir = compiler.run_frontend(_test_wont_propagate)
+        typingctx.refresh()
+        targetctx.refresh()
+        args = (types.int64, types.int64, types.int64)
+        typemap, return_type, calltypes, _ = type_inference_stage(
+            typingctx, targetctx, test_ir, args, None
+        )
+        _ = type_annotations.TypeAnnotation(
+            func_ir=test_ir,
+            typemap=typemap,
+            calltypes=calltypes,
+            lifted=(),
+            lifted_from=None,
+            args=args,
+            return_type=return_type,
+            html_output=config.HTML,
+        )
+        in_cps, out_cps = copy_propagate(test_ir.blocks, typemap)
+        _ = apply_copy_propagate(
+            test_ir.blocks,
+            in_cps,
+            get_name_var_table(test_ir.blocks),
+            typemap,
+            calltypes,
+        )
+
+        self.assertTrue(_find_assign(test_ir, "x"))
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_datetime.py

@@ -4,7 +4,7 @@
 import numpy as np
 
 from numba import cuda, vectorize, guvectorize
-from numba.np.numpy_support import from_dtype
+from numba.cuda.np.numpy_support import from_dtype
 from numba.cuda.testing import CUDATestCase, skip_on_cudasim
 import unittest
 

numba_cuda/numba/cuda/tests/cudapy/test_debug.py

@@ -3,7 +3,7 @@
 
 import numpy as np
 
-from numba.core.utils import PYVERSION
+from numba.cuda.utils import PYVERSION
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 from numba.cuda.tests.support import (
     override_config,

numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py

@@ -1,15 +1,22 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
+from collections import namedtuple
 from numba.cuda.tests.support import override_config, captured_stdout
 from numba.cuda.testing import skip_on_cudasim
 from numba import cuda
 from numba.core import types
 from numba.cuda.testing import CUDATestCase
+from textwrap import dedent
+import math
 import itertools
-import numpy as np
 import re
 import unittest
+import warnings
+from numba.core.errors import NumbaDebugInfoWarning
+from numba.cuda.tests.support import ignore_internal_warnings
+import numpy as np
+import inspect
 
 
 @skip_on_cudasim("Simulator does not produce debug dumps")
@@ -30,7 +37,7 @@ class TestCudaDebugInfo(CUDATestCase):
         assertfn(match, msg=asm)
 
     def test_no_debuginfo_in_asm(self):
-        @cuda.jit(debug=False)
+        @cuda.jit(debug=False, opt=False)
         def foo(x):
             x[0] = 1
 
@@ -426,7 +433,7 @@ class TestCudaDebugInfo(CUDATestCase):
         self.assertIn(expected, out.getvalue())
 
     def test_DW_LANG(self):
-        @cuda.jit(debug=True)
+        @cuda.jit(debug=True, opt=False)
         def foo():
             """
             CHECK: distinct !DICompileUnit
@@ -465,7 +472,7 @@ class TestCudaDebugInfo(CUDATestCase):
         """
         sig = (types.float64,)
 
-        @cuda.jit(sig, debug=True)
+        @cuda.jit(sig, debug=True, opt=False)
         def foo(a):
             """
             CHECK-LABEL: define void @{{.+}}foo
@@ -523,6 +530,288 @@ class TestCudaDebugInfo(CUDATestCase):
         ir = foo.inspect_llvm()[sig]
         self.assertFileCheckMatches(ir, foo.__doc__)
 
+    def test_missing_source(self):
+        strsrc = """
+        def foo():
+            pass
+        """
+        l = dict()
+        exec(dedent(strsrc), {}, l)
+        foo = cuda.jit(debug=True, opt=False)(l["foo"])
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always", NumbaDebugInfoWarning)
+            ignore_internal_warnings()
+            foo[1, 1]()
+
+        self.assertEqual(len(w), 1)
+        found = w[0]
+        self.assertEqual(found.category, NumbaDebugInfoWarning)
+        msg = str(found.message)
+        # make sure the warning contains the right message
+        self.assertIn("Could not find source for function", msg)
+        # and refers to the offending function
+        self.assertIn(str(foo.py_func), msg)
+
+    def test_no_if_op_bools_declared(self):
+        @cuda.jit(
+            "int64(boolean, boolean)",
+            debug=True,
+            opt=False,
+            _dbg_optnone=True,
+            device=True,
+        )
+        def choice(cond1, cond2):
+            """
+            CHECK: define void @{{.+}}choices
+            """
+            if cond1 and cond2:
+                return 1
+            else:
+                return 2
+
+        ir_content = choice.inspect_llvm()[choice.signatures[0]]
+        # We should not declare variables used as the condition in if ops.
+        # See Numba PR #9888: https://github.com/numba/numba/pull/9888
+
+        for line in ir_content.splitlines():
+            if "llvm.dbg.declare" in line:
+                self.assertNotIn("bool", line)
+
+    def test_llvm_inliner_flag_conflict(self):
+        # bar will be marked as 'alwaysinline', but when DEBUGINFO_DEFAULT is
+        # set functions are not marked as 'alwaysinline' and this results in a
+        # conflict. baz will not be marked as 'alwaysinline' as a result of
+        # DEBUGINFO_DEFAULT
+
+        @cuda.jit(forceinline=True)
+        def bar(x):
+            return math.sin(x)
+
+        @cuda.jit(forceinline=False)
+        def baz(x):
+            return math.cos(x)
+
+        @cuda.jit(opt=True)
+        def foo(x, y):
+            """
+            CHECK-LABEL: define void @{{.+}}foo
+            CHECK: call i32 @"[[BAR:.+]]"(
+            CHECK: call i32 @"[[BAZ:.+]]"(
+
+            CHECK-DAG: declare i32 @"[[BAR]]"({{.+}}alwaysinline
+            CHECK-DAG: declare i32 @"[[BAZ]]"(
+            CHECK-DAG: define linkonce_odr i32 @"[[BAR]]"({{.+}}alwaysinline
+            CHECK-DAG: define linkonce_odr i32 @"[[BAZ]]"(
+            """
+            a = bar(y)
+            b = baz(y)
+            x[0] = a + b
+
+        # check it compiles
+        with override_config("DEBUGINFO_DEFAULT", 1):
+            result = cuda.device_array(1, dtype=np.float32)
+            foo[1, 1](result, np.pi)
+            result.copy_to_host()
+
+        result_host = math.sin(np.pi) + math.cos(np.pi)
+        self.assertPreciseEqual(result[0], result_host)
+
+        ir_content = foo.inspect_llvm()[foo.signatures[0]]
+        self.assertFileCheckMatches(ir_content, foo.__doc__)
+
+        # Check that the device functions call the appropriate device
+        # math functions and have the correct attributes.
+        self.assertFileCheckMatches(
+            ir_content,
+            """
+            CHECK: define linkonce_odr i32 @{{.+}}bar
+            CHECK-SAME: alwaysinline
+            CHECK-NEXT: {
+            CHECK-NEXT: {{.*}}:
+            CHECK-NEXT: br label {{.*}}
+            CHECK-NEXT: {{.*}}:
+            CHECK-NEXT: call double @"__nv_sin"
+            CHECK-NEXT: store double {{.*}}, double* {{.*}}
+            CHECK-NEXT: ret i32 0
+            CHECK-NEXT: }
+        """,
+        )
+
+        self.assertFileCheckMatches(
+            ir_content,
+            """
+            CHECK: define linkonce_odr i32 @{{.+}}baz
+            CHECK-NOT: alwaysinline
+            CHECK-NEXT: {
+            CHECK-NEXT: {{.*}}:
+            CHECK-NEXT: br label {{.*}}
+            CHECK-NEXT: {{.*}}:
+            CHECK-NEXT: call double @"__nv_cos"
+            CHECK-NEXT: store double {{.*}}, double* {{.*}}
+            CHECK-NEXT: ret i32 0
+            CHECK-NEXT: }
+        """,
+        )
+
+    def test_DILocation_versioned_variables(self):
+        """Tests that DILocation information for versions of variables matches
+        up to their definition site."""
+
+        @cuda.jit(debug=True, opt=False)
+        def foo(dest, n):
+            """
+            CHECK: define void @{{.+}}foo
+            CHECK: store i64 5, i64* %"c{{.+}} !dbg ![[STORE5:.+]]
+            CHECK: store i64 1, i64* %"c{{.+}} !dbg ![[STORE1:.+]]
+            CHECK: [[STORE5]] = !DILocation(
+            CHECK: [[STORE1]] = !DILocation(
+            """
+            if n:
+                c = 5
+            else:
+                c = 1
+            dest[0] = c
+
+        foo_source_lines, foo_source_lineno = inspect.getsourcelines(
+            foo.py_func
+        )
+
+        result = cuda.device_array(1, dtype=np.int32)
+        foo[1, 1](result, 1)
+        result.copy_to_host()
+        self.assertEqual(result[0], 5)
+
+        ir_content = foo.inspect_llvm()[foo.signatures[0]]
+        self.assertFileCheckMatches(ir_content, foo.__doc__)
+
+        # Collect lines pertaining to the function `foo` and debuginfo
+        # metadata
+        lines = ir_content.splitlines()
+        debuginfo_equals = re.compile(r"!(\d+) = ")
+        debug_info_lines = list(
+            filter(lambda x: debuginfo_equals.search(x), lines)
+        )
+
+        function_start_regex = re.compile(r"define void @.+foo")
+        function_start_lines = list(
+            filter(
+                lambda x: function_start_regex.search(x[1]), enumerate(lines)
+            )
+        )
+        function_end_lines = list(
+            filter(lambda x: x[1] == "}", enumerate(lines))
+        )
+        foo_ir_lines = lines[
+            function_start_lines[0][0] : function_end_lines[0][0]
+        ]
+
+        # Check the if condition's debuginfo
+        cond_branch = list(filter(lambda x: "br i1" in x, foo_ir_lines))
+        self.assertEqual(len(cond_branch), 1)
+        self.assertIn("!dbg", cond_branch[0])
+        cond_branch_dbginfo_node = cond_branch[0].split("!dbg")[1].strip()
+        cond_branch_dbginfos = list(
+            filter(
+                lambda x: cond_branch_dbginfo_node + " = " in x,
+                debug_info_lines,
+            )
+        )
+        self.assertEqual(len(cond_branch_dbginfos), 1)
+        cond_branch_dbginfo = cond_branch_dbginfos[0]
+
+        # Check debuginfo for the store instructions
+        store_1_lines = list(filter(lambda x: "store i64 1" in x, foo_ir_lines))
+        store_5_lines = list(filter(lambda x: "store i64 5" in x, foo_ir_lines))
+
+        self.assertEqual(len(store_1_lines), 2)
+        self.assertEqual(len(store_5_lines), 2)
+
+        store_1_dbginfo_set = set(
+            map(lambda x: x.split("!dbg")[1].strip(), store_1_lines)
+        )
+        store_5_dbginfo_set = set(
+            map(lambda x: x.split("!dbg")[1].strip(), store_5_lines)
+        )
+        self.assertEqual(len(store_1_dbginfo_set), 1)
+        self.assertEqual(len(store_5_dbginfo_set), 1)
+        store_1_dbginfo_node = store_1_dbginfo_set.pop()
+        store_5_dbginfo_node = store_5_dbginfo_set.pop()
+        store_1_dbginfos = list(
+            filter(
+                lambda x: store_1_dbginfo_node + " = " in x, debug_info_lines
+            )
+        )
+        store_5_dbginfos = list(
+            filter(
+                lambda x: store_5_dbginfo_node + " = " in x, debug_info_lines
+            )
+        )
+        self.assertEqual(len(store_1_dbginfos), 1)
+        self.assertEqual(len(store_5_dbginfos), 1)
+        store_1_dbginfo = store_1_dbginfos[0]
+        store_5_dbginfo = store_5_dbginfos[0]
+
+        # Ensure the line numbers match what we expect based on the Python source
+        line_number_regex = re.compile(r"line: (\d+)")
+        LineNumbers = namedtuple(
+            "LineNumbers", ["cond_branch", "store_5", "store_1"]
+        )
+        line_number_matches = LineNumbers(
+            *map(
+                lambda x: line_number_regex.search(x),
+                [cond_branch_dbginfo, store_5_dbginfo, store_1_dbginfo],
+            )
+        )
+        self.assertTrue(
+            all(
+                map(
+                    lambda x: x is not None,
+                    line_number_matches,
+                )
+            )
+        )
+        line_numbers = LineNumbers(
+            *map(
+                lambda x: int(x.group(1)),
+                line_number_matches,
+            )
+        )
+        source_line_numbers = LineNumbers(
+            *map(
+                lambda x: x[0] + foo_source_lineno,
+                filter(
+                    lambda x: "c = " in x[1] or "if n:" in x[1],
+                    enumerate(foo_source_lines),
+                ),
+            )
+        )
+        self.assertEqual(line_numbers, source_line_numbers)
+
+    def test_debuginfo_asm(self):
+        def foo():
+            pass
+
+        foo_debug = cuda.jit(debug=True, opt=False)(foo)
+        foo_debug[1, 1]()
+        asm = foo_debug.inspect_asm()[foo_debug.signatures[0]]
+        self.assertFileCheckMatches(
+            asm,
+            """
+            CHECK: .section{{.+}}.debug
+        """,
+        )
+
+        foo_nodebug = cuda.jit(debug=False)(foo)
+        foo_nodebug[1, 1]()
+        asm = foo_nodebug.inspect_asm()[foo_nodebug.signatures[0]]
+        self.assertFileCheckMatches(
+            asm,
+            """
+            CHECK-NOT: .section{{.+}}.debug
+        """,
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_debuginfo_types.py

@@ -468,7 +468,7 @@ class TestCudaDebugInfoTypes(CUDATestCase):
                 f"Test DITypes for {sanitize_name(numba_type.name)}"
             ):
 
-                @cuda.jit((numba_type,), debug=True)
+                @cuda.jit((numba_type,), debug=True, opt=False)
                 def foo(a):
                     pass
 

numba_cuda/numba/cuda/tests/cudapy/test_dispatcher.py

@@ -7,7 +7,6 @@ import threading
 
 from numba import (
     boolean,
-    config,
     cuda,
     float32,
     float64,
@@ -17,6 +16,7 @@ from numba import (
     uint32,
     void,
 )
+from numba.cuda import config
 from numba.core.errors import TypingError
 from numba.cuda.testing import (
     cc_X_or_above,

numba_cuda/numba/cuda/tests/cudapy/test_errors.py

@@ -4,7 +4,7 @@
 from numba import cuda
 from numba.core.errors import TypingError
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
-from numba import config
+from numba.cuda import config
 
 
 def noop(x):

numba_cuda/numba/cuda/tests/cudapy/test_exception.py

@@ -5,7 +5,7 @@ import numpy as np
 
 from numba import cuda
 from numba.cuda.testing import unittest, xfail_unless_cudasim, CUDATestCase
-from numba.core import config
+from numba.cuda.core import config
 
 
 class TestException(CUDATestCase):

numba_cuda/numba/cuda/tests/cudapy/test_extending.py

@@ -7,7 +7,8 @@ from llvmlite import ir
 
 import numpy as np
 import os
-from numba import config, cuda, njit, types
+from numba import cuda, njit, types
+from numba.cuda import config
 from numba.extending import overload
 
 

numba_cuda/numba/cuda/tests/cudapy/test_inline.py

@@ -13,7 +13,7 @@ from numba.cuda.testing import (
 
 @skip_on_cudasim("Cudasim does not support inline and forceinline")
 class TestCudaInline(CUDATestCase):
-    def _test_call_inline(self, inline):
+    def _test_call_inline(self, inline, inline_expected):
         """Test @cuda.jit(inline=...)"""
         a = np.ones(2, dtype=np.int32)
 
@@ -36,12 +36,10 @@ class TestCudaInline(CUDATestCase):
         pat = r"call [a-zA-Z0-9]* @"
         match = re.compile(pat).search(llvm_ir)
 
-        if inline == "always" or inline is True:
+        if inline_expected:
             # check that call was inlined
             self.assertIsNone(match, msg=llvm_ir)
         else:
-            assert inline == "never" or inline is False
-
             # check that call was not inlined
             self.assertIsNotNone(match, msg=llvm_ir)
 
@@ -49,16 +47,28 @@ class TestCudaInline(CUDATestCase):
         self.assertNotIn("alwaysinline", llvm_ir)
 
     def test_call_inline_always(self):
-        self._test_call_inline("always")
+        self._test_call_inline("always", True)
 
     def test_call_inline_never(self):
-        self._test_call_inline("never")
+        self._test_call_inline("never", False)
 
     def test_call_inline_true(self):
-        self._test_call_inline(True)
+        self._test_call_inline(True, True)
 
     def test_call_inline_false(self):
-        self._test_call_inline(False)
+        self._test_call_inline(False, False)
+
+    def test_call_inline_costmodel_false(self):
+        def cost_model(expr, caller_info, callee_info):
+            return False
+
+        self._test_call_inline(cost_model, False)
+
+    def test_call_inline_costmodel_true(self):
+        def cost_model(expr, caller_info, callee_info):
+            return True
+
+        self._test_call_inline(cost_model, True)
 
     def _test_call_forceinline(self, forceinline):
         """Test @cuda.jit(forceinline=...)"""