Simplify and organize gdb tests

Author: ZzEeKkAa

numba_dpex/examples/debug/side-by-side.py

@@ -13,8 +13,8 @@
 
 
 def common_loop_body(param_a, param_b):
-    param_c = param_a + 10  # Set breakpoint here
-    param_d = param_b * 0.5
+    param_c = param_a + numba.float32(10)  # Set breakpoint here
+    param_d = param_b * numba.float32(0.5)
     result = param_c + param_d
     return result
 

numba_dpex/examples/debug/simple_sum.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import dpctl
 import dpnp as np
 
 import numba_dpex as ndpx

numba_dpex/tests/debugging/gdb.py

@@ -18,6 +18,25 @@
 else:
     import pexpect
 
+RE_DEVICE_ARRAY = (
+    r"\{nitems = [0-9]+,\s+"
+    r"itemsize = [0-9]+,\s+"
+    r"data = 0x[0-9a-f]+,\s+"
+    r"shape = \{[0-9]+\},\s+"
+    r"strides = \{[0-9]+\}}"
+)
+
+RE_DEVICE_ARRAY_TYPE = (
+    r"DpnpNdArray\("
+    r"dtype=[a-z0-9]+,\s+"
+    r"ndim=[0-9]+,\s+"
+    r"layout=[A-Z],\s+"
+    r"address_space=[0-4],\s+"
+    r"usm_type=[a-z]+,\s+"
+    r"device=[a-z:0-9]+,\s+"
+    r"sycl_queue=[A-Za-z:0-9 ]+\)"
+)
+
 
 class gdb:
     def __init__(self):
@@ -30,6 +49,7 @@ def spawn(self):
         env["NUMBA_DPEX_OPT"] = "0"
         env["NUMBA_EXTEND_VARIABLE_LIFETIMES"] = "1"
         env["NUMBA_DPEX_DEBUGINFO"] = "1"
+        env["NUMBA_DEBUGINFO"] = "1"
 
         self.child = pexpect.spawn(
             "gdb-oneapi -q python", env=env, encoding="utf-8"
@@ -38,10 +58,8 @@ def spawn(self):
             self.child.logfile = sys.stdout
 
     def setup_gdb(self):
-        self.child.expect("(gdb)", timeout=5)
-        self.child.sendline("set breakpoint pending on")
-        self.child.expect("(gdb)", timeout=5)
-        self.child.sendline("set style enabled off")  # disable colors symbols
+        self._command("set breakpoint pending on")
+        self._command("set style enabled off")  # disable colors symbols
 
     def teardown_gdb(self):
         self.child.sendintr()
@@ -59,17 +77,58 @@ def _command(self, command):
     def set_environment(self, varname, value):
         self._command(f"set environment {varname} {value}")
 
-    def breakpoint(self, breakpoint):
-        self._command("break " + breakpoint)
+    def breakpoint(
+        self,
+        location: str,
+        condition: str = None,
+        expected_location=None,
+        expected_line: int = None,
+    ):
+        cmd = f"break {location}"
+        if condition is not None:
+            cmd += f" if {condition}"
+        self._command(cmd)
+
+        if expected_location is not None:
+            self.child.expect(
+                rf"Thread .* hit Breakpoint .* at {expected_location}"
+            )
+
+        if expected_line is not None:
+            self.child.expect(f"{expected_line}")
 
     def run(self, script):
         self._command("run " + self.script_path(script))
 
+    def expect(self, pattern, with_eol=False, **kw):
+        self.child.expect(pattern, **kw)
+        if with_eol:
+            self.expect_eol()
+
+    def expect_eol(self):
+        self.child.expect(r"[^\n]*\n")
+
+    def expect_hit_breakpoint(self, expected_location=None):
+        expect = r"Thread [0-9A-Za-z \"]+ hit Breakpoint [0-9\.]+"
+        if expected_location is not None:
+            # function name + args could be long, so we have to assume that
+            # the message may be splitted in multiple lines. It potentially can
+            # cause messed up buffer reading, but it must be extremely rare.
+            expect += f".* at {expected_location}"
+        self.child.expect(expect)
+        self.expect_eol()
+
     def backtrace(self):
         self._command("backtrace")
 
-    def print(self, var):
+    def print(self, var, expected=None):
         self._command("print " + var)
+        if expected is not None:
+            self.child.expect(rf"\$[0-9]+ = {expected}")
+            self.expect_eol()
+
+    def set_variable(self, var, val):
+        self._command(f"set variable {var} = {val}")
 
     def info_args(self):
         self._command("info args")
@@ -83,6 +142,9 @@ def info_locals(self):
     def next(self):
         self._command("next")
 
+    def nexti(self):
+        self._command("nexti")
+
     def ptype(self, var):
         self._command("ptype " + var)
 
@@ -106,52 +168,3 @@ def script_path(script):
 def script_path(script):
     package_path = pathlib.Path(numba_dpex.__file__).parent
     return str(package_path / "examples/debug" / script)
-
-
-def line_number(file_path, text):
-    """Return line number of the text in the file"""
-    with open(file_path, "r") as lines:
-        for line_number, line in enumerate(lines):
-            if text in line:
-                return line_number + 1
-
-    raise RuntimeError(f"Can not find {text} in {file_path}")
-
-
-def breakpoint_by_mark(script, mark, offset=0):
-    """Return breakpoint for the mark in the script
-
-    Example: breakpoint_by_mark("script.py", "Set here") -> "script.py:25"
-    """
-    return f"{script}:{line_number(script_path(script), mark) + offset}"
-
-
-def breakpoint_by_function(script, function):
-    """Return breakpoint for the function in the script"""
-    return breakpoint_by_mark(script, f"def {function}", 1)
-
-
-def setup_breakpoint(
-    app: gdb,
-    breakpoint: str,
-    script=None,
-    expected_location=None,
-    expected_line=None,
-):
-    if not script:
-        script = breakpoint.split(" ")[0].split(":")[0]
-
-    if not expected_location:
-        expected_location = breakpoint.split(" ")[0]
-        if not expected_location.split(":")[-1].isnumeric():
-            expected_location = breakpoint_by_function(
-                script, expected_location.split(":")[-1]
-            )
-
-    app.breakpoint(breakpoint)
-    app.run(script)
-
-    app.child.expect(rf"Thread .* hit Breakpoint .* at {expected_location}")
-
-    if expected_line:
-        app.child.expect(expected_line)

numba_dpex/tests/debugging/test_backtraces.py

@@ -11,8 +11,6 @@
 
 from numba_dpex.tests._helper import skip_no_gdb
 
-from .gdb import setup_breakpoint
-
 pytestmark = skip_no_gdb
 
 
@@ -21,12 +19,13 @@ def test_backtrace(app):
 
     commands/backtrace
     """
-    setup_breakpoint(
-        app,
-        "simple_dpex_func.py:12",
-        expected_line=r"12\s+result = a_in_func \+ b_in_func",
-    )
+    app.breakpoint("simple_dpex_func.py:12")
+    app.run("simple_dpex_func.py")
+    app.expect_hit_breakpoint("simple_dpex_func.py:12")
 
     app.backtrace()
 
-    app.child.expect(r"#0.*__main__::func_sum.* at simple_dpex_func.py:12")
+    app.expect(
+        r"#0.*__main__::func_sum.* at simple_dpex_func.py:12", with_eol=True
+    )
+    app.expect(r"#1.*__main__::kernel_sum", with_eol=True)

numba_dpex/tests/debugging/test_breakpoints.py

@@ -13,37 +13,37 @@
 
 from numba_dpex.tests._helper import skip_no_gdb
 
-from .gdb import breakpoint_by_function, breakpoint_by_mark, setup_breakpoint
+from .gdb import gdb
 
 pytestmark = skip_no_gdb
 
 
-side_by_side_breakpoint = breakpoint_by_function(
-    "side-by-side.py", "common_loop_body"
+@pytest.mark.parametrize(
+    "breakpoint",
+    [
+        "side-by-side.py:16",
+        "common_loop_body",
+        "side-by-side.py:common_loop_body",
+    ],
 )
-
-simple_sum_condition_breakpoint = breakpoint_by_mark(
-    "simple_sum.py", "Condition breakpoint location"
+@pytest.mark.parametrize(
+    "api",
+    [
+        "numba",
+        "numba-ndpx-kernel",
+    ],
 )
-
-common_loop_body_native_function_name = {
-    "numba": "common_loop_body",
-    "numba-ndpx-kernel": "common_loop_body",
-}
-
-breakpoint_api_cases = [
-    (side_by_side_breakpoint, "numba"),
-    (side_by_side_breakpoint, "numba-ndpx-kernel"),
-    *((fn, api) for api, fn in common_loop_body_native_function_name.items()),
-    *(
-        (f"side-by-side.py:{fn}", api)
-        for api, fn in common_loop_body_native_function_name.items()
-    ),
-]
-
-
-@pytest.mark.parametrize("breakpoint, api", breakpoint_api_cases)
-def test_breakpoint_with_condition_by_function_argument(app, breakpoint, api):
+@pytest.mark.parametrize(
+    "condition, exp_var, exp_val",
+    [
+        ("param_a == 3", "param_a", 3),
+        ("param_a == 7", "param_a", 7),
+        (None, "param_a", r"[0-9]+"),  # No condition
+    ],
+)
+def test_device_func_breakpoint(
+    app: gdb, breakpoint, api, condition, exp_var, exp_val
+):
     """Function breakpoints and argument initializing
 
     Test that it is possible to set conditional breakpoint at the beginning
@@ -56,71 +56,40 @@ def test_breakpoint_with_condition_by_function_argument(app, breakpoint, api):
     SAT-4449
     """
 
-    if api == "numba-ndpx-kernel":
-        if (
-            breakpoint == "side-by-side.py:common_loop_body"
-            or breakpoint == "common_loop_body"
-        ):
-            pytest.xfail(
-                "Breakpoint by function name not working for numba-dpex."
-            )  # TODO: https://github.com/IntelPython/numba-dpex/issues/1242
+    if api == "numba-ndpx-kernel" and breakpoint != "side-by-side.py:16":
+        pytest.skip(
+            "Breakpoint by function name not working for numba-dpex."
+        )  # TODO: https://github.com/IntelPython/numba-dpex/issues/1242
 
-    variable_name = "param_a"
-    variable_value = "3"
-    condition = f"{variable_name} == {variable_value}"
-
-    app.breakpoint(f"{breakpoint} if {condition}")
+    app.breakpoint(breakpoint, condition=condition)
     app.run(f"side-by-side.py --api={api}")
-
-    app.child.expect(
-        rf"Thread .* hit Breakpoint .* at {side_by_side_breakpoint}"
-    )
-
-    app.print(variable_name)
-
-    app.child.expect(rf"\$1 = {variable_value}")
+    app.expect_hit_breakpoint("side-by-side.py:16")
+    if exp_var is not None:
+        app.print(exp_var, expected=exp_val)
 
 
 @pytest.mark.parametrize(
-    "breakpoint, script",
+    "condition, exp_var, exp_val",
     [
-        # location specified by file name and function name
-        # commands/break_file_func # noqa: E800
-        ("simple_sum.py:data_parallel_sum", None),
-        # location specified by function name
-        # commands/break_func # noqa: E800
-        ("data_parallel_sum", "simple_sum.py"),
-        # location specified by file name and nested function name
-        # commands/break_nested_func # noqa: E800
-        ("simple_dpex_func.py:func_sum", None),
+        ("i == 3", "i", 3),
+        (None, "i", r"[0-9]+"),  # No condition
     ],
 )
-def test_breakpoint_common(app, breakpoint, script):
-    """Set a breakpoint in the given script."""
-
-    pytest.xfail(
-        "Breakpoint by function name not working for numba-dpex."
-    )  # TODO: https://github.com/IntelPython/numba-dpex/issues/1242
-    setup_breakpoint(app, breakpoint, script=script)
-
+def test_kernel_breakpoint(app: gdb, condition, exp_var, exp_val):
+    """Function breakpoints and argument initializing
 
-@pytest.mark.parametrize(
-    "breakpoint, variable_name, variable_value",
-    [
-        # commands/break_conditional # noqa: E800
-        (f"{simple_sum_condition_breakpoint} if i == 1", "i", "1"),
-    ],
-)
-def test_breakpoint_with_condition_common(
-    app,
-    breakpoint,
-    variable_name,
-    variable_value,
-):
-    """Set a breakpoint with condition and check value of variable."""
+    Test that it is possible to set conditional breakpoint at the beginning
+    of the function and use a function argument in the condition.
 
-    setup_breakpoint(app, breakpoint)
+    It is important that breakpoint by function name hits at the first line in
+    the function body and not at the function definition line.
 
-    app.print(variable_name)
+    Test for https://github.com/numba/numba/issues/7415
+    SAT-4449
+    """
 
-    app.child.expect(rf"\$1 = {variable_value}")
+    app.breakpoint("simple_sum.py:13", condition=condition)
+    app.run("simple_sum.py")
+    app.expect_hit_breakpoint("simple_sum.py:13")
+    if exp_var is not None:
+        app.print(exp_var, expected=exp_val)