From 3452ba8ffd9b9969db45254fe0ef5eaacd760de1 Mon Sep 17 00:00:00 2001 From: baldurk Date: Fri, 11 Sep 2026 17:52:09 +0100 Subject: [PATCH] Use context helpers for thread debugging --- util/test/rdtest/shared/Groupshared.py | 48 ++-- util/test/rdtest/shared/Subgroup_Zoo.py | 46 ++-- .../D3D11/D3D11_AMD_Shader_Extensions.py | 9 +- .../D3D12/D3D12_AMD_Shader_Extensions.py | 11 +- .../tests/D3D12/D3D12_Shader_DebugData_Zoo.py | 207 +++++++++--------- .../tests/D3D12/D3D12_Shader_Debug_Zoo.py | 90 ++++---- util/test/tests/Iter_Test.py | 17 +- util/test/tests/Vulkan/VK_Shader_Debug_Zoo.py | 63 +++--- 8 files changed, 236 insertions(+), 255 deletions(-) diff --git a/util/test/rdtest/shared/Groupshared.py b/util/test/rdtest/shared/Groupshared.py index 49432a8f4..6eb9d329b 100644 --- a/util/test/rdtest/shared/Groupshared.py +++ b/util/test/rdtest/shared/Groupshared.py @@ -8,34 +8,34 @@ class Groupshared(rdtest.TestCase): demos_test_name = None def check_compute_thread_result(self, test: int, action: rd.ActionDescription, x: int, y: int, z: int, expected: rdtest.VectorValue): - workgroup = (0, 0, 0) - trace = self.controller.DebugThread(workgroup, (x, y, z)) try: - _, variables = self.process_trace(trace) + with self.debug_thread((0, 0, 0), (x, y, z)) as debug: + _, variables = self.process_trace(debug.trace) - # Find the source variable 'outval' at the highest instruction index - name = 'outval' - debugged = None - countInst = len(trace.instInfo) - for inst in range(countInst): - sourceVars = trace.instInfo[countInst-1-inst].sourceVars - try: - dataVars = [v for v in sourceVars if v.name == name] - if len(dataVars) == 0: + + # Find the source variable 'outval' at the highest instruction index + name = 'outval' + debugged = None + countInst = len(debug.trace.instInfo) + for inst in range(countInst): + sourceVars = debug.trace.instInfo[countInst-1-inst].sourceVars + try: + dataVars = [v for v in sourceVars if v.name == name] + if len(dataVars) == 0: + continue + debugged = self.evaluate_source_var(dataVars[0], variables) + except KeyError as ex: continue - debugged = self.evaluate_source_var(dataVars[0], variables) - except KeyError as ex: - continue - except rdtest.TestFailureException as ex: - continue - break - if debugged is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {x},{y},{z}") + except rdtest.TestFailureException as ex: + continue + break + if debugged is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {x},{y},{z}") - debuggedValue = list(debugged.value.f32v[0:4]) + debuggedValue = list(debugged.value.f32v[0:4]) - if not rdtest.value_compare(expected, debuggedValue, eps=5.0E-06): - raise rdtest.TestFailureException(f"EID:{action.eventId} TID:{x},{y},{z} debugged thread value {debuggedValue} does not match output {expected}") + if not rdtest.value_compare(expected, debuggedValue, eps=5.0E-06): + raise rdtest.TestFailureException(f"EID:{action.eventId} TID:{x},{y},{z} debugged thread value {debuggedValue} does not match output {expected}") except rdtest.TestFailureException as ex: rdtest.log.error(f"Test {test} failed {ex}") @@ -43,8 +43,6 @@ class Groupshared(rdtest.TestCase): except Exception as ex: rdtest.log.error(f"Test {test} exception {ex}") return False - finally: - self.controller.FreeTrace(trace) return True diff --git a/util/test/rdtest/shared/Subgroup_Zoo.py b/util/test/rdtest/shared/Subgroup_Zoo.py index d7eac2533..2c2768e89 100644 --- a/util/test/rdtest/shared/Subgroup_Zoo.py +++ b/util/test/rdtest/shared/Subgroup_Zoo.py @@ -19,39 +19,37 @@ class Subgroup_Zoo(rdtest.TestCase): rdtest.log.error(f"Exception Test {test} failed {ex}") return False - trace = self.controller.DebugThread(self.workgroup, (x, y, z)) try: - _, variables = self.process_trace(trace) + with self.debug_thread(self.workgroup, (x, y, z)) as debug: + _, variables = self.process_trace(debug.trace) - # Find the source variable 'testResult' at the highest instruction index - name = 'testResult' - debugged = None - countInst = len(trace.instInfo) - for inst in range(countInst): - sourceVars = trace.instInfo[countInst-1-inst].sourceVars - try: - dataVars = [v for v in sourceVars if v.name == name] - if len(dataVars) == 0: + # Find the source variable 'testResult' at the highest instruction index + name = 'testResult' + debugged = None + countInst = len(debug.trace.instInfo) + for inst in range(countInst): + sourceVars = debug.trace.instInfo[countInst-1-inst].sourceVars + try: + dataVars = [v for v in sourceVars if v.name == name] + if len(dataVars) == 0: + continue + debugged = self.evaluate_source_var(dataVars[0], variables) + except KeyError as ex: continue - debugged = self.evaluate_source_var(dataVars[0], variables) - except KeyError as ex: - continue - except rdtest.TestFailureException as ex: - continue - break - if debugged is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {x},{y},{z}") + except rdtest.TestFailureException as ex: + continue + break + if debugged is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {x},{y},{z}") - debuggedValue = list(debugged.value.f32v[0:4]) + debuggedValue = list(debugged.value.f32v[0:4]) - if not rdtest.value_compare(real, debuggedValue, eps=5.0E-06): - raise rdtest.TestFailureException(f"EID:{action.eventId} TID:{x},{y},{z} debugged thread value {debuggedValue} does not match output {real}") + if not rdtest.value_compare(real, debuggedValue, eps=5.0E-06): + raise rdtest.TestFailureException(f"EID:{action.eventId} TID:{x},{y},{z} debugged thread value {debuggedValue} does not match output {real}") except rdtest.TestFailureException as ex: rdtest.log.error(f"Test {test} failed {ex}") return False - finally: - self.controller.FreeTrace(trace) return True diff --git a/util/test/tests/D3D11/D3D11_AMD_Shader_Extensions.py b/util/test/tests/D3D11/D3D11_AMD_Shader_Extensions.py index ca2844415..c84345ccd 100644 --- a/util/test/tests/D3D11/D3D11_AMD_Shader_Extensions.py +++ b/util/test/tests/D3D11/D3D11_AMD_Shader_Extensions.py @@ -82,11 +82,10 @@ class D3D11_AMD_Shader_Extensions(rdtest.TestCase): self.set_event(self.find_action("Dispatch").eventId, False) - trace = self.controller.DebugThread((0, 0, 0), (0, 0, 0)) + with self.debug_thread((0, 0, 0), (0, 0, 0)) as debug: + cycles, variables = self.process_trace(debug.trace) - cycles, variables = self.process_trace(trace) - - if cycles < 3: - raise rdtest.TestFailureException(f"Compute shader has too few cycles {cycles}") + if cycles < 3: + raise rdtest.TestFailureException(f"Compute shader has too few cycles {cycles}") rdtest.log.success("compute shader debugged successfully") diff --git a/util/test/tests/D3D12/D3D12_AMD_Shader_Extensions.py b/util/test/tests/D3D12/D3D12_AMD_Shader_Extensions.py index 6210250da..e78e02a60 100644 --- a/util/test/tests/D3D12/D3D12_AMD_Shader_Extensions.py +++ b/util/test/tests/D3D12/D3D12_AMD_Shader_Extensions.py @@ -105,17 +105,16 @@ class D3D12_AMD_Shader_Extensions(rdtest.TestCase): if "amd_u64_atomic" not in disasm: raise rdtest.TestFailureException( - f"Didn't find expected AMD opcode in disassembly: {disasm}") + f"Didn't find expected AMD opcode in disasse1mbly: {disasm}") rdtest.log.success("compute shader disassembly is as expected") self.set_event(self.find_action("Dispatch").eventId, False) - trace = self.controller.DebugThread((0, 0, 0), (0, 0, 0)) + with self.debug_thread((0, 0, 0), (0, 0, 0)) as debug: + cycles, variables = self.process_trace(debug.trace) - cycles, variables = self.process_trace(trace) - - if cycles < 3: - raise rdtest.TestFailureException(f"Compute shader has too few cycles {cycles}") + if cycles < 3: + raise rdtest.TestFailureException(f"Compute shader has too few cycles {cycles}") rdtest.log.success("compute shader debugged successfully") diff --git a/util/test/tests/D3D12/D3D12_Shader_DebugData_Zoo.py b/util/test/tests/D3D12/D3D12_Shader_DebugData_Zoo.py index f05591bc7..1cb9f7e0e 100644 --- a/util/test/tests/D3D12/D3D12_Shader_DebugData_Zoo.py +++ b/util/test/tests/D3D12/D3D12_Shader_DebugData_Zoo.py @@ -140,86 +140,85 @@ class D3D12_Shader_DebugData_Zoo(rdtest.TestCase): # Loop over every test for test in range(action.numInstances): # Debug the shader - trace = self.controller.DebugPixel(4 * test, 0, rd.DebugPixelInputs()) - cycles, variables = self.process_trace(trace) - output = self.find_output_source_var(trace, rd.ShaderBuiltin.ColorOutput, 0) + with self.debug_pixel(4 * test, 0, rd.DebugPixelInputs()) as debug: + trace = debug.trace + cycles, variables = self.process_trace(debug.trace) + output = self.find_output_source_var(debug.trace, rd.ShaderBuiltin.ColorOutput, 0) - debugged = self.evaluate_source_var(output, variables) + debugged = self.evaluate_source_var(output, variables) - try: - tex = pipe.GetOutputTargets()[0].resource - x = 4 * test - y = 0 - self.check_pixel_value(tex, x, y, debugged.value.f32v[0:4]) - picked = rd.PixelValue = self.controller.PickPixel(tex, x, y, rd.Subresource(0,0,0), rd.CompType.Typeless) - realTestResult = picked.floatValue - debugInfo = pipe.GetShaderReflection(rd.ShaderStage.Pixel).debugInfo - shaderSrcRaw = debugInfo.files[0].contents - varsToCheck = self.parse_shader_source(shaderSrcRaw, realTestResult, test) - for name, varType, expectedValue in varsToCheck: - debuggedValue = None - countInst = len(trace.instInfo) - for inst in range(countInst): - sourceVars = trace.instInfo[countInst-1-inst].sourceVars - try: - debuggedValue = self.get_source_shader_var_value(sourceVars, name, varType, variables) - except KeyError as ex: - continue - except rdtest.TestFailureException as ex: - continue - break - if debuggedValue is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} type:{varType}") - if not rdtest.value_compare(expectedValue, debuggedValue): - raise rdtest.TestFailureException(f"'{name}' {varType} debugger {debuggedValue} doesn't match expected {expectedValue}") - - rdtest.log.success(f"{len(varsToCheck)} source variables matched as expected") - - # Look for _IN.MAT0 variable in the trace input variables - name = "_IN" - inVar = [v for v in trace.inputs if v.name == name] - if len(inVar) != 1: - raise rdtest.TestFailureException(f"Couldn't find source input variable {name}") - name = "MAT0" - inVar = [v for v in inVar[0].members if v.name == name] - if len(inVar) != 1: - raise rdtest.TestFailureException(f"Couldn't find source input member {name}") - - matched = True - varsToCheck = [] - varsToCheck.append((f"[0]", "float4", [1.0, 2.0, 3.0, 4.0])) - varsToCheck.append((f"[1]", "float4", [5.0, 6.0, 7.0, 8.0])) - varsToCheck.append((f"[2]", "float4", [9.0, 10.0, 11.0, 12.0])) - for name, varType, expectedValue in varsToCheck: - assert isinstance(expectedValue, list) - debuggedValue = None - for v in inVar[0].members: - if v.name == name: + try: + tex = pipe.GetOutputTargets()[0].resource + x = 4 * test + y = 0 + self.check_pixel_value(tex, x, y, debugged.value.f32v[0:4]) + picked = rd.PixelValue = self.controller.PickPixel(tex, x, y, rd.Subresource(0,0,0), rd.CompType.Typeless) + realTestResult = picked.floatValue + debugInfo = pipe.GetShaderReflection(rd.ShaderStage.Pixel).debugInfo + shaderSrcRaw = debugInfo.files[0].contents + varsToCheck = self.parse_shader_source(shaderSrcRaw, realTestResult, test) + for name, varType, expectedValue in varsToCheck: + debuggedValue = None + countInst = len(debug.trace.instInfo) + for inst in range(countInst): + sourceVars = debug.trace.instInfo[countInst-1-inst].sourceVars try: - debuggedValue = v.value.f32v[0:len(expectedValue)] + debuggedValue = self.get_source_shader_var_value(sourceVars, name, varType, variables) + except KeyError as ex: + continue except rdtest.TestFailureException as ex: - matched = False - failed = True + continue break + if debuggedValue is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} type:{varType}") + if not rdtest.value_compare(expectedValue, debuggedValue): + raise rdtest.TestFailureException(f"'{name}' {varType} debugger {debuggedValue} doesn't match expected {expectedValue}") - if debuggedValue is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} type:{varType}") - if not rdtest.value_compare(expectedValue, debuggedValue): - matched = False - failed = True - rdtest.log.error(f"'{name}' {varType} debugger {debuggedValue} doesn't match expected {expectedValue}") + rdtest.log.success(f"{len(varsToCheck)} source variables matched as expected") - if matched: - rdtest.log.success("PS MAT0 input source variable matched as expected") + # Look for _IN.MAT0 variable in the trace input variables + name = "_IN" + inVar = [v for v in debug.trace.inputs if v.name == name] + if len(inVar) != 1: + raise rdtest.TestFailureException(f"Couldn't find source input variable {name}") + name = "MAT0" + inVar = [v for v in inVar[0].members if v.name == name] + if len(inVar) != 1: + raise rdtest.TestFailureException(f"Couldn't find source input member {name}") - except rdtest.TestFailureException as ex: - rdtest.log.error(f"Test {test} failed {ex}") - failed = True - continue - finally: - self.controller.FreeTrace(trace) + matched = True + varsToCheck = [] + varsToCheck.append((f"[0]", "float4", [1.0, 2.0, 3.0, 4.0])) + varsToCheck.append((f"[1]", "float4", [5.0, 6.0, 7.0, 8.0])) + varsToCheck.append((f"[2]", "float4", [9.0, 10.0, 11.0, 12.0])) + for name, varType, expectedValue in varsToCheck: + assert isinstance(expectedValue, list) + debuggedValue = None + for v in inVar[0].members: + if v.name == name: + try: + debuggedValue = v.value.f32v[0:len(expectedValue)] + except rdtest.TestFailureException as ex: + matched = False + failed = True + break + + if debuggedValue is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} type:{varType}") + if not rdtest.value_compare(expectedValue, debuggedValue): + matched = False + failed = True + rdtest.log.error(f"'{name}' {varType} debugger {debuggedValue} doesn't match expected {expectedValue}") - rdtest.log.success(f"Test {test} matched as expected") + if matched: + rdtest.log.success("PS MAT0 input source variable matched as expected") + + except rdtest.TestFailureException as ex: + rdtest.log.error(f"Test {test} failed {ex}") + failed = True + continue + + rdtest.log.success(f"Test {test} matched as expected") rdtest.log.end_section(shaderModels[sm] + " tests") @@ -244,43 +243,41 @@ class D3D12_Shader_DebugData_Zoo(rdtest.TestCase): # Debug the shader groupid = (test,0,0) threadid = (0,0,0) - trace = self.controller.DebugThread(groupid, threadid) - cycles, variables = self.process_trace(trace) + with self.debug_thread(groupid, threadid) as debug: + cycles, variables = self.process_trace(debug.trace) - # Result is stored in RWStructuredBuffer bufOut : register(u0); - bufOut = pipe.GetReadWriteResources(rd.ShaderStage.Compute)[0].descriptor.resource - bufdata = self.controller.GetBufferData(bufOut, test*16, 16) - realTestResult = struct.unpack_from("4f", bufdata, 0) - debugInfo = pipe.GetShaderReflection(rd.ShaderStage.Compute).debugInfo - shaderSrcRaw = debugInfo.files[0].contents - varsToCheck = self.parse_shader_source(shaderSrcRaw, realTestResult, test) - try: - for name, varType, expectedValue in varsToCheck: - debuggedValue = None - countInst = len(trace.instInfo) - for inst in range(countInst): - sourceVars = trace.instInfo[countInst-1-inst].sourceVars - try: - debuggedValue = self.get_source_shader_var_value(sourceVars, name, varType, variables) - except KeyError as ex: - continue - except rdtest.TestFailureException as ex: - continue - break - if debuggedValue is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} type:{varType}") - if not rdtest.value_compare(expectedValue, debuggedValue): - raise rdtest.TestFailureException(f"'{name}' {varType} debugger {debuggedValue} doesn't match expected {expectedValue}") - rdtest.log.success(f"{len(varsToCheck)} source variables matched as expected") + # Result is stored in RWStructuredBuffer bufOut : register(u0); + bufOut = pipe.GetReadWriteResources(rd.ShaderStage.Compute)[0].descriptor.resource + bufdata = self.controller.GetBufferData(bufOut, test*16, 16) + realTestResult = struct.unpack_from("4f", bufdata, 0) + debugInfo = pipe.GetShaderReflection(rd.ShaderStage.Compute).debugInfo + shaderSrcRaw = debugInfo.files[0].contents + varsToCheck = self.parse_shader_source(shaderSrcRaw, realTestResult, test) + try: + for name, varType, expectedValue in varsToCheck: + debuggedValue = None + countInst = len(debug.trace.instInfo) + for inst in range(countInst): + sourceVars = debug.trace.instInfo[countInst-1-inst].sourceVars + try: + debuggedValue = self.get_source_shader_var_value(sourceVars, name, varType, variables) + except KeyError as ex: + continue + except rdtest.TestFailureException as ex: + continue + break + if debuggedValue is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} type:{varType}") + if not rdtest.value_compare(expectedValue, debuggedValue): + raise rdtest.TestFailureException(f"'{name}' {varType} debugger {debuggedValue} doesn't match expected {expectedValue}") + rdtest.log.success(f"{len(varsToCheck)} source variables matched as expected") - except rdtest.TestFailureException as ex: - rdtest.log.error(f"Test {test} failed {ex}") - failed = True - continue - finally: - self.controller.FreeTrace(trace) + except rdtest.TestFailureException as ex: + rdtest.log.error(f"Test {test} failed {ex}") + failed = True + continue - rdtest.log.success(f"Test {test} matched as expected") + rdtest.log.success(f"Test {test} matched as expected") rdtest.log.end_section(section) diff --git a/util/test/tests/D3D12/D3D12_Shader_Debug_Zoo.py b/util/test/tests/D3D12/D3D12_Shader_Debug_Zoo.py index e7e1823eb..c3c2bd635 100644 --- a/util/test/tests/D3D12/D3D12_Shader_Debug_Zoo.py +++ b/util/test/tests/D3D12/D3D12_Shader_Debug_Zoo.py @@ -57,37 +57,35 @@ class D3D12_Shader_Debug_Zoo(rdtest.TestCase): continue # Debug the shader - trace = self.controller.DebugThread(groupid, tid) - cycles, variables = self.process_trace(trace) + with self.debug_thread(groupid, tid) as debug: + cycles, variables = self.process_trace(debug.trace) - # Find the source variable 'testResult' at the highest instruction index - name = 'testResult' - debugged = None - countInst = len(trace.instInfo) - for inst in range(countInst): - sourceVars = trace.instInfo[countInst-1-inst].sourceVars - try: - dataVars = [v for v in sourceVars if v.name == name] - if len(dataVars) == 0: + # Find the source variable 'testResult' at the highest instruction index + name = 'testResult' + debugged = None + countInst = len(debug.trace.instInfo) + for inst in range(countInst): + sourceVars = debug.trace.instInfo[countInst-1-inst].sourceVars + try: + dataVars = [v for v in sourceVars if v.name == name] + if len(dataVars) == 0: + continue + debugged = self.evaluate_source_var(dataVars[0], variables) + except KeyError as ex: continue - debugged = self.evaluate_source_var(dataVars[0], variables) - except KeyError as ex: - continue - except rdtest.TestFailureException as ex: - continue - break - if debugged is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {test}") - debuggedValue = list(debugged.value.f32v[0:4]) + except rdtest.TestFailureException as ex: + continue + break + if debugged is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {test}") + debuggedValue = list(debugged.value.f32v[0:4]) - if not rdtest.value_compare(expectedValue, debuggedValue, eps=5.0E-06): - rdtest.log.error(f"Test {test} Group:{groupid} Thread:{tid} EID:{action.eventId} failed {name} debugger {debuggedValue} doesn't match expected {expectedValue}") - self.controller.FreeTrace(trace) - failed = True - continue + if not rdtest.value_compare(expectedValue, debuggedValue, eps=5.0E-06): + rdtest.log.error(f"Test {test} Group:{groupid} Thread:{tid} EID:{action.eventId} failed {name} debugger {debuggedValue} doesn't match expected {expectedValue}") + failed = True + continue - self.controller.FreeTrace(trace) - rdtest.log.success(f"Test {test} Group:{groupid} Thread:{tid} as expected") + rdtest.log.success(f"Test {test} Group:{groupid} Thread:{tid} as expected") rdtest.log.end_section(section) return failed @@ -300,29 +298,27 @@ class D3D12_Shader_Debug_Zoo(rdtest.TestCase): groupid = (groupX, 1, 0) threadid = (0, 0, 0) testIndex = groupX - trace = self.controller.DebugThread(groupid, threadid) - cycles, variables = self.process_trace(trace) + with self.debug_thread(groupid, threadid) as debug: + cycles, variables = self.process_trace(debug.trace) - # Result is stored in RWStructuredBuffer bufOut : register(u1); - bufOut = pipe.GetReadWriteResources(rd.ShaderStage.Compute)[1].descriptor.resource - bufdata = self.controller.GetBufferData(bufOut, testIndex*16, 16) - expectedValue = struct.unpack_from("4i", bufdata, 0) - # Test result is in variable called "int4 testResult" - name = 'testResult' - varType = 'int4' - try: - debuggedValue = self.get_source_shader_var_value(trace.instInfo[-1].sourceVars, name, varType, variables) - if not rdtest.value_compare(expectedValue, debuggedValue): - raise rdtest.TestFailureException(f"'{name}' debugger {debuggedValue} doesn't match expected {expectedValue}") + # Result is stored in RWStructuredBuffer bufOut : register(u1); + bufOut = pipe.GetReadWriteResources(rd.ShaderStage.Compute)[1].descriptor.resource + bufdata = self.controller.GetBufferData(bufOut, testIndex*16, 16) + expectedValue = struct.unpack_from("4i", bufdata, 0) + # Test result is in variable called "int4 testResult" + name = 'testResult' + varType = 'int4' + try: + debuggedValue = self.get_source_shader_var_value(debug.trace.instInfo[-1].sourceVars, name, varType, variables) + if not rdtest.value_compare(expectedValue, debuggedValue): + raise rdtest.TestFailureException(f"'{name}' debugger {debuggedValue} doesn't match expected {expectedValue}") - except rdtest.TestFailureException as ex: - rdtest.log.error(f"Test {test} Group:{groupid} Thread:{threadid} Index:{testIndex} failed {ex}") - failed = True - continue - finally: - self.controller.FreeTrace(trace) + except rdtest.TestFailureException as ex: + rdtest.log.error(f"Test {test} Group:{groupid} Thread:{threadid} Index:{testIndex} failed {ex}") + failed = True + continue - rdtest.log.success(f"Test {test} Group:{groupid} Thread:{threadid} as expected") + rdtest.log.success(f"Test {test} Group:{groupid} Thread:{threadid} as expected") rdtest.log.end_section(section) if self.check_compute_derivative_tests(): diff --git a/util/test/tests/Iter_Test.py b/util/test/tests/Iter_Test.py index 10f2dead9..306c14009 100644 --- a/util/test/tests/Iter_Test.py +++ b/util/test/tests/Iter_Test.py @@ -85,17 +85,14 @@ class Iter_Test(rdtest.TestCase): threadid = (threadid[0], threadid[1], threadid[2]) rdtest.log.print(f"Debug Thread Workgroup:{wgSize} groupid:{groupid} threadid:{threadid}") - trace = self.controller.DebugThread(groupid, threadid) + with self.debug_thread(groupid, threadid) as debug: + try: + cycles, variables = self.process_trace(debug.trace) + except rdtest.TestFailureException as err: + rdtest.log.error(f"Error debugging: {err.message}") + return - try: - cycles, variables = self.process_trace(trace) - except rdtest.TestFailureException as err: - rdtest.log.error(f"Error debugging: {err.message}") - return - - rdtest.log.success(f'Successfully debugged compute shader in {cycles} cycles {len(refl.outputSignature)}') - - self.controller.FreeTrace(trace) + rdtest.log.success(f'Successfully debugged compute shader in {cycles} cycles {len(refl.outputSignature)}') def vert_debug(self, action: rd.ActionDescription): assert self.controller is not None diff --git a/util/test/tests/Vulkan/VK_Shader_Debug_Zoo.py b/util/test/tests/Vulkan/VK_Shader_Debug_Zoo.py index 070267ca9..77fa28236 100644 --- a/util/test/tests/Vulkan/VK_Shader_Debug_Zoo.py +++ b/util/test/tests/Vulkan/VK_Shader_Debug_Zoo.py @@ -121,43 +121,40 @@ class VK_Shader_Debug_Zoo(rdtest.TestCase): continue # Debug the shader - trace = self.controller.DebugThread(groupid, threadid) - cycles, variables = self.process_trace(trace) - # Check for non-zero cycles - if cycles == 0: - rdtest.log.success(f"Test {test} Group:{groupid} Thread:{threadid} : Shader debug cycle count was zero") - self.controller.FreeTrace(trace) - failed = True - continue + with self.debug_thread(groupid, threadid) as debug: + cycles, variables = self.process_trace(debug.trace) + # Check for non-zero cycles + if cycles == 0: + rdtest.log.success(f"Test {test} Group:{groupid} Thread:{threadid} : Shader debug cycle count was zero") + failed = True + continue - # Find the source variable 'testResult' at the highest instruction index - name = 'testResult' - debugged = None - countInst = len(trace.instInfo) - for inst in range(countInst): - sourceVars = trace.instInfo[countInst-1-inst].sourceVars - try: - dataVars = [v for v in sourceVars if v.name == name] - if len(dataVars) == 0: + # Find the source variable 'testResult' at the highest instruction index + name = 'testResult' + debugged = None + countInst = len(debug.trace.instInfo) + for inst in range(countInst): + sourceVars = debug.trace.instInfo[countInst-1-inst].sourceVars + try: + dataVars = [v for v in sourceVars if v.name == name] + if len(dataVars) == 0: + continue + debugged = self.evaluate_source_var(dataVars[0], variables) + except KeyError as ex: continue - debugged = self.evaluate_source_var(dataVars[0], variables) - except KeyError as ex: - continue - except rdtest.TestFailureException as ex: - continue - break - if debugged is None: - raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {test}") - debuggedValue = list(debugged.value.f32v[0:4]) + except rdtest.TestFailureException as ex: + continue + break + if debugged is None: + raise rdtest.TestFailureException(f"Couldn't find source variable {name} at {test}") + debuggedValue = list(debugged.value.f32v[0:4]) - if not rdtest.value_compare(expectedValue, debuggedValue, eps=5.0E-06): - rdtest.log.error(f"Test {test} Group:{groupid} Thread:{threadid} EID:{action.eventId} failed {name} debugger {debuggedValue} doesn't match expected {expectedValue}") - self.controller.FreeTrace(trace) - failed = True - continue + if not rdtest.value_compare(expectedValue, debuggedValue, eps=5.0E-06): + rdtest.log.error(f"Test {test} Group:{groupid} Thread:{threadid} EID:{action.eventId} failed {name} debugger {debuggedValue} doesn't match expected {expectedValue}") + failed = True + continue - self.controller.FreeTrace(trace) - rdtest.log.success(f"Test {test} Group:{groupid} Thread:{threadid} as expected") + rdtest.log.success(f"Test {test} Group:{groupid} Thread:{threadid} as expected") rdtest.log.end_section(section)