Skip to content

profiling.sampling: --blocking sample-read error rate ~33% on AMD EPYC 9V45 (Windows), ~0.5% on other CPUs #158552

Description

@hitoshic1982

Bug report

Bug description

On Windows, python -m profiling.sampling run --blocking ... reports a sample-read
error rate of roughly 31–35% when the host CPU is an AMD EPYC 9V45, while the
same command on other CPUs reports about 0.5%. The high rate matches what we see
without --blocking on other machines (about 36–39%), so it looks as if the
blocking (suspend-then-read) path is not effective on that CPU.

Command (wall mode, 1 kHz, 40 s duration cap; the target finishes on its own):

python -m profiling.sampling run --native --opcodes --mode wall --sampling-rate 1khz \
    --binary --compression none --output out.bin --blocking --duration 40 target.py

target.py is a CPU-bound, single-threaded workload (many short Python calls)
that runs for about 4 s on the slower CPUs and about 2 s on the EPYC 9V45.

Observed on GitHub-hosted Windows runners (image windows-2025-vs2026,
version 20260922.246.2), same commit, same command, six consecutive runs:

Runner CPU Error rate (3 attempts each where failing) Capture length
AMD EPYC 9V45 96-Core 33.20 / 31.48 / 35.29 % ~2.1 s
AMD EPYC 9V45 96-Core 33.78 / 34.93 / 34.05 % ~2.1 s
AMD EPYC 9V74 80-Core 0.46 % ~4.1 s
AMD EPYC 7763 64-Core 0.50 % ~4.1 s
AMD EPYC 7763 64-Core 0.46 % ~4.1 s
Intel Xeon 6973P-C 0.71 % ~4.1 s

Two other targets profiled in the same jobs without --blocking (but with
--all-threads) stay at about 2 % on every CPU, including the EPYC 9V45.

Locally (AMD Ryzen 5 5600X, Windows 11), 10 runs each of the same target:
--blocking 0.36–0.51 %; without --blocking 36.38–38.79 %. Without blocking,
the dominant read error was Failed to parse initial frame in chain.

We do not have access to an EPYC 9V45 machine to bisect further, and we have not
yet reduced this to a standalone script; happy to run diagnostics on GitHub
runners if that helps.

CPython versions tested on:

3.15 (3.15.0rc1)

Operating systems tested on:

Windows

Linked PRs

Activity

  1. picnixz commented on Oct 1, 2026

    @picnixz
    Member

    cc @pablogsal but I'm not sure we can do something on our end. It could be a mix of Windows and that kind of CPU.

  2. pablogsal commented on Oct 1, 2026

    @pablogsal
    Member

    There may be a race in our Windows blocking path. We call NtSuspendProcess and immediately start reading memory, without checking that the target threads have finished suspending.

    Could you run the diagnostic script below (save it as diagnose.py) with the same interpreter and target on a failing EPYC 9V45 runner, and ideally one unaffected runner?

    python diagnose.py --target target.py
    python diagnose.py --target target.py --no-cache
    

    Please paste the full output, CPU model, and exact CPython build or commit. The script records the exception chains and compares normal suspension with a delay and with GetThreadContext, which should synchronize suspension.

    In particular, we need to establish whether the failing blocking runs produce the same Failed to parse initial frame in chain error you observed locally without blocking.

    Your original target is fine for this check; no need to reduce it yet.

    diagnose.py
    """Compare sampling failures on a single-threaded target, using Python 3.15.
    
    Run: python diagnose.py [--target target.py] [--seconds 3] [--no-cache]
    Windows x64 also tests GetThreadContext after pause_threads().
    """
    
    import argparse
    from collections import Counter
    import contextlib
    import ctypes
    import os
    import platform
    import runpy
    import subprocess
    import sys
    import threading
    import time
    
    
    def leaf(x):
        return x + 1
    
    
    def calls():
        x = 0
        while True:
            x = leaf(leaf(leaf(x)))
    
    
    def worker(target):
        print(threading.get_native_id(), flush=True)
        sys.stdin.readline()
        with open(os.devnull, "w") as output, contextlib.redirect_stdout(output):
            if target:
                sys.argv = [target]
                sys.path.insert(0, os.path.dirname(os.path.abspath(target)))
                runpy.run_path(target, run_name="__main__")
            else:
                calls()
    
    
    @contextlib.contextmanager
    def windows_context(tid):
        # Only the main thread of the explicitly single-threaded target is checked.
        # CONTEXT layout: https://learn.microsoft.com/windows/win32/api/winnt/ns-winnt-context
        from ctypes import wintypes
    
        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
        kernel32.OpenThread.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
        kernel32.OpenThread.restype = wintypes.HANDLE
        kernel32.GetThreadContext.argtypes = (wintypes.HANDLE, ctypes.c_void_p)
        kernel32.GetThreadContext.restype = wintypes.BOOL
        kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
        kernel32.CloseHandle.restype = wintypes.BOOL
        handle = kernel32.OpenThread(0x0008, False, tid)  # THREAD_GET_CONTEXT
        if not handle:
            raise ctypes.WinError(ctypes.get_last_error())
        try:
            # AMD64 CONTEXT is 1232 bytes, aligned to 16 bytes. ContextFlags follows
            # six 64-bit home slots. Only control registers are requested.
            storage = ctypes.create_string_buffer(1232 + 15)
            address = (ctypes.addressof(storage) + 15) & ~15
            ctypes.c_uint32.from_address(address + 48).value = 0x00100001
    
            def synchronize():
                if not kernel32.GetThreadContext(handle, address):
                    raise ctypes.WinError(ctypes.get_last_error())
    
            yield synchronize
        finally:
            kernel32.CloseHandle(handle)
    
    
    def error_chain(exc):
        parts = []
        while exc is not None:
            parts.append(f"{type(exc).__name__}: {exc}")
            exc = exc.__cause__
        return " <- ".join(parts)
    
    
    def measure(args, mode):
        from _remote_debugging import RemoteUnwinder
    
        command = [sys.executable, os.path.abspath(__file__), "--worker"]
        if args.target:
            command += ["--target", args.target]
        errors = Counter()
        retries = Counter()
        count = 0
        with subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                              text=True) as child:
            try:
                tid = int(child.stdout.readline())
                unwinder = RemoteUnwinder(child.pid, native=True, opcodes=True, gc=True,
                                          cache_frames=not args.no_cache, debug=True)
                manager = windows_context(tid) if mode == "context" else contextlib.nullcontext()
                with manager as synchronize:
                    child.stdin.write("go\n")
                    child.stdin.flush()
                    time.sleep(0.1)
                    start = deadline = time.perf_counter()
                    while time.perf_counter() - start < args.seconds and child.poll() is None:
                        paused = False
                        try:
                            if mode != "live":
                                unwinder.pause_threads()
                                paused = True
                            if mode == "delay":
                                time.sleep(0.001)
                            elif mode == "context":
                                synchronize()
                            try:
                                unwinder.get_stack_trace()
                            except (RuntimeError, OSError, UnicodeError, MemoryError) as exc:
                                errors[error_chain(exc)] += 1
                                # Check a few failures again without resuming the target.
                                if paused and sum(retries.values()) < 10:
                                    time.sleep(0.001)
                                    try:
                                        unwinder.get_stack_trace()
                                    except (RuntimeError, OSError, UnicodeError, MemoryError) as again:
                                        retries[error_chain(again)] += 1
                                    else:
                                        retries["retry succeeded while still paused"] += 1
                        finally:
                            if paused:
                                unwinder.resume_threads()
                        count += 1
                        deadline += 0.001
                        remaining = deadline - time.perf_counter()
                        if remaining > 0:
                            time.sleep(remaining)
                    elapsed = time.perf_counter() - start
            finally:
                if child.poll() is None:
                    child.terminate()
                child.wait()
        failed = sum(errors.values())
        rate = 100 * failed / count if count else 0
        print(f"{mode}: {failed}/{count} failed ({rate:.2f}%), {elapsed:.3f}s", flush=True)
        for message, frequency in errors.most_common(5):
            print(f"  {frequency}: {message}", flush=True)
        for message, frequency in retries.most_common(5):
            print(f"  same-pause retry {frequency}: {message}", flush=True)
    
    
    def main():
        parser = argparse.ArgumentParser(description=__doc__)
        parser.add_argument("--target", help="Optional single-threaded Python script")
        parser.add_argument("--seconds", type=float, default=3)
        parser.add_argument("--no-cache", action="store_true")
        parser.add_argument("--worker", action="store_true", help=argparse.SUPPRESS)
        args = parser.parse_args()
        if args.worker:
            worker(args.target)
            return
        print(sys.version)
        print(platform.platform(), platform.processor(), f"cache={not args.no_cache}", flush=True)
        modes = ["live", "pause", "delay"]
        if sys.platform == "win32" and platform.machine().lower() in ("amd64", "x86_64") and ctypes.sizeof(ctypes.c_void_p) == 8:
            modes.append("context")
        for mode in modes:
            measure(args, mode)
    
    
    if __name__ == "__main__":
        main()
  3. hitoshic1982 commented on Oct 1, 2026

    @hitoshic1982
    Author

    Thanks, @pablogsal. I ran diagnose.py on 12 GitHub-hosted Windows runners (image windows-2025-vs2026), three of which landed on an AMD EPYC 9V45. Build on every runner: 3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug 4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)].

    Your race hypothesis matches the data. On the EPYC 9V45 runners, pause fails about as often as live; a 1 ms delay mostly fixes it, and GetThreadContext brings it to 0. On every other CPU, pause is already 0.

    Failure rates with the built-in single-threaded loop (3 s each):

    Runner CPU live pause delay context live (no-cache) pause (no-cache) delay (no-cache) context (no-cache)
    0 Intel(R) Xeon(R) 6973P-C 16.03% 0.00% 0.00% 0.00% 11.57% 0.00% 0.00% 0.00%
    1 AMD EPYC 7763 64-Core Processor 12.83% 0.00% 0.00% 0.00% 12.90% 0.00% 0.00% 0.00%
    2 AMD EPYC 7763 64-Core Processor 13.93% 0.00% 0.00% 0.00% 11.97% 0.00% 0.00% 0.00%
    3 AMD EPYC 9V74 80-Core Processor 12.40% 0.00% 0.00% 0.00% 12.00% 0.00% 0.00% 0.00%
    4 AMD EPYC 9V74 80-Core Processor 12.53% 0.00% 0.00% 0.00% 12.47% 0.00% 0.00% 0.00%
    5 AMD EPYC 9V74 80-Core Processor 13.07% 0.00% 0.00% 0.00% 13.53% 0.00% 0.00% 0.00%
    6 AMD EPYC 9V74 80-Core Processor 12.90% 0.00% 0.00% 0.00% 12.80% 0.00% 0.00% 0.00%
    7 AMD EPYC 9V45 96-Core Processor 11.10% 10.93% 0.56% 0.00% 11.27% 11.30% 0.44% 0.00%
    8 AMD EPYC 9V74 80-Core Processor 12.27% 0.00% 0.00% 0.00% 15.53% 0.00% 0.00% 0.00%
    9 AMD EPYC 7763 64-Core Processor 12.67% 0.00% 0.00% 0.00% 12.43% 0.00% 0.00% 0.00%
    10 AMD EPYC 9V45 96-Core Processor 10.90% 10.27% 0.56% 0.00% 11.17% 10.77% 0.26% 0.00%
    11 AMD EPYC 9V45 96-Core Processor 14.03% 16.60% 0.32% 0.00% 14.47% 13.80% 0.94% 0.00%

    The failing blocking (pause) runs on the 9V45 produce the same chain we saw locally without blocking:

    RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
    

    and the same-pause retries after 1 ms reported retry succeeded while still paused.

    One caveat: our original target (tests/test_expression_arbiter.py) finishes in under 0.2 s under diagnose.py, so for that target only the live mode has meaningful samples (33-48 % on all CPUs); on one 9V45 runner the script then hit ProcessLookupError from pause_threads() because the target had already exited. The built-in loop results above are the reliable comparison.

    Full output: AMD EPYC 9V45 (runner 10)
    CPU: AMD EPYC 9V45 96-Core Processor
    BUILD: 3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)] ('CPython', 'tags/v3.15.0rc1', '37e98da')
    === builtin target 
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 26 Model 2 Stepping 1, AuthenticAMD cache=True
    live: 327/2999 failed (10.90%), 3.001s
      327: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
    pause: 308/3000 failed (10.27%), 3.001s
      308: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
      same-pause retry 10: retry succeeded while still paused
    delay: 9/1614 failed (0.56%), 3.001s
      9: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
      same-pause retry 9: retry succeeded while still paused
    context: 0/1741 failed (0.00%), 3.001s
    === target tests/test_expression_arbiter.py 
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 26 Model 2 Stepping 1, AuthenticAMD cache=True
    live: 23/53 failed (43.40%), 0.053s
      16: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
      2: RuntimeError: Failed to read interpreter state buffer <- ProcessLookupError: [Errno 3] No such process
      1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner 112.
    
      1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner 104.
    
      1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner 103.
    
    Traceback (most recent call last):
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 168, in <module>
        main()
        ~~~~^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 164, in main
        measure(args, mode)
        ~~~~~~~^^^^^^^^^^^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 107, in measure
        unwinder.pause_threads()
        ~~~~~~~~~~~~~~~~~~~~~~^^
    ProcessLookupError: Process 6892 has terminated
    === builtin target --no-cache
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 26 Model 2 Stepping 1, AuthenticAMD cache=False
    live: 335/3000 failed (11.17%), 3.000s
      335: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
    pause: 323/2999 failed (10.77%), 3.000s
      323: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
      same-pause retry 9: retry succeeded while still paused
      same-pause retry 1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
    delay: 4/1559 failed (0.26%), 3.002s
      4: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
      same-pause retry 4: retry succeeded while still paused
    context: 0/1713 failed (0.00%), 3.002s
    === target tests/test_expression_arbiter.py --no-cache
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 26 Model 2 Stepping 1, AuthenticAMD cache=False
    live: 22/50 failed (44.00%), 0.051s
      15: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Failed to read function name from code object <- RuntimeError: Failed to read PyUnicodeObject <- OSError: ReadProcessMemory failed for PID 2132 at address 0x1 (size 64, partial read 0 bytes): Windows error 299 <- OSError: [WinError 299] Only part of a ReadProcessMemory or WriteProcessMemory request was completed
      1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner 38.
    
      1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner 104.
    
      1: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Failed to read function name from code object <- RuntimeError: Failed to read PyUnicodeObject <- OSError: ReadProcessMemory failed for PID 2132 at address 0xc0000000 (size 64, partial read 0 bytes): Windows error 998 <- OSError: [WinError 998] Invalid access to memory location
    Traceback (most recent call last):
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 168, in <module>
        main()
        ~~~~^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 164, in main
        measure(args, mode)
        ~~~~~~~^^^^^^^^^^^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 107, in measure
        unwinder.pause_threads()
        ~~~~~~~~~~~~~~~~~~~~~~^^
    ProcessLookupError: Process 4276 has terminated
    
    Full output: AMD EPYC 7763 (runner 1, unaffected)
    CPU: AMD EPYC 7763 64-Core Processor
    BUILD: 3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)] ('CPython', 'tags/v3.15.0rc1', '37e98da')
    === builtin target 
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 25 Model 1 Stepping 1, AuthenticAMD cache=True
    live: 385/3000 failed (12.83%), 3.000s
      385: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
    pause: 0/3000 failed (0.00%), 3.001s
    delay: 0/1887 failed (0.00%), 3.001s
    context: 0/3000 failed (0.00%), 3.000s
    === target tests/test_expression_arbiter.py 
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 25 Model 1 Stepping 1, AuthenticAMD cache=True
    live: 64/190 failed (33.68%), 0.190s
      46: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse initial frame in chain
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner -87.
    
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Failed to read function name from code object <- RuntimeError: Failed to read PyUnicodeObject <- OSError: ReadProcessMemory failed for PID 892 at address 0xc0000000 (size 64, partial read 0 bytes): Windows error 998 <- OSError: [WinError 998] Invalid access to memory location
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Failed to read function name from code object <- RuntimeError: Failed to read PyUnicodeObject <- OSError: ReadProcessMemory failed for PID 892 at address 0x26262626 (size 64, partial read 0 bytes): Windows error 998 <- OSError: [WinError 998] Invalid access to memory location
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to collect frames <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner -98.
    
    Traceback (most recent call last):
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 168, in <module>
        main()
        ~~~~^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 164, in main
        measure(args, mode)
        ~~~~~~~^^^^^^^^^^^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 107, in measure
        unwinder.pause_threads()
        ~~~~~~~~~~~~~~~~~~~~~~^^
    ProcessLookupError: Process 7808 has terminated
    === builtin target --no-cache
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 25 Model 1 Stepping 1, AuthenticAMD cache=False
    live: 387/3000 failed (12.90%), 3.000s
      387: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
    pause: 0/3000 failed (0.00%), 3.001s
    delay: 0/1872 failed (0.00%), 3.001s
    context: 0/3000 failed (0.00%), 3.001s
    === target tests/test_expression_arbiter.py --no-cache
    3.15.0rc1 (tags/v3.15.0rc1:37e98da, Aug  4 2026, 11:37:18) [MSC v.1951 64 bit (AMD64)]
    Windows-2025Server-10.0.26100-SP0 AMD64 Family 25 Model 1 Stepping 1, AuthenticAMD cache=False
    live: 56/155 failed (36.13%), 0.155s
      34: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse initial frame in chain
      5: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner -87.
    
      3: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Unhandled frame owner type in async frame <- RuntimeError: Unhandled frame owner 10.
    
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Failed to read function name from code object <- RuntimeError: Failed to read PyUnicodeObject <- OSError: ReadProcessMemory failed for PID 3708 at address 0x202626 (size 64, partial read 0 bytes): Windows error 299 <- OSError: [WinError 299] Only part of a ReadProcessMemory or WriteProcessMemory request was completed
      2: RuntimeError: Failed to unwind stack for thread <- RuntimeError: Failed to process frame chain <- RuntimeError: Failed to parse frame object in chain <- RuntimeError: Failed to read function name from code object <- RuntimeError: Failed to read PyUnicodeObject <- OSError: ReadProcessMemory failed for PID 3708 at address 0xc0000000 (size 64, partial read 0 bytes): Windows error 998 <- OSError: [WinError 998] Invalid access to memory location
    Traceback (most recent call last):
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 168, in <module>
        main()
        ~~~~^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 164, in main
        measure(args, mode)
        ~~~~~~~^^^^^^^^^^^^
      File "D:\a\MoHan-PC-Desktop-Assistant\MoHan-PC-Desktop-Assistant\cpython-158552\diagnose.py", line 107, in measure
        unwinder.pause_threads()
        ~~~~~~~~~~~~~~~~~~~~~~^^
    ProcessLookupError: Process 6224 has terminated
    
  4. added a commit that references this issue on Oct 5, 2026
  5. added 2 commits that reference this issue on Oct 5, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions