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

[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

[picnixz]

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.

[pablogsal]

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()

[hitoshic1982]

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