From 2ba38ae8423fdb73d285e791700001b70cebe39d Mon Sep 17 00:00:00 2001 From: TermiNexus Date: Thu, 1 Oct 2026 00:23:16 +0800 Subject: [PATCH] =?UTF-8?q?fix(Phase2Translator):=20=E5=B9=B6=E8=A1=8C=20w?= =?UTF-8?q?orker=20=E6=95=B0=E4=B8=8D=E5=86=8D=E6=8C=89=E5=8F=AF=E7=94=A8?= =?UTF-8?q?=E5=86=85=E5=AD=98=E9=99=8D=E7=BA=A7=E4=B8=B2=E8=A1=8C=EF=BC=8C?= =?UTF-8?q?=E6=94=B9=E4=B8=BA"=E9=A2=84=E5=88=86=E9=85=8D=E6=A0=A1?= =?UTF-8?q?=E9=AA=8C=20+=20=E5=BC=BA=E5=88=B6=E9=A2=84=E7=95=99"=EF=BC=88T?= =?UTF-8?q?PC=5FJOBS=20=E5=8F=AF=E6=98=BE=E5=BC=8F=E8=A6=86=E7=9B=96?= =?UTF-8?q?=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 现象：同一条命令的编译时间在 ~400s 与 ~1180s 两档之间随机跳（PROF 目录当日 366s~2239s），用户反馈"耗时不降反增"。 根因（三份 profile 实证）： - 旧 _PickWorkerCount 用 `by_mem = max(1, avail_mb // per_worker_mb)` 按**可用** 物理内存夹 worker 数：可用稍紧（<~2.8GB）就整体降为 1 ⇒ **静默退回串行**。 其文档字符串自己就写着"76 文件逐个翻译 1180s，并行时 ~400s，波动 2-3 倍"。 - PROF/20260930_224857（438.40s）：主进程 _translate_file **0 次**、 StructGen/HandlesImports/HandlesClassDef **0 条记录**、总调用 7.28 亿 ⇒ 翻译在 worker 进程里做完了（未 profile），主进程只在等 → **并行档**。 - PROF/20260930_231916（1048.55s）与 20260930_235354（1168.15s）： _translate_file **75 次全在主进程**、_parallel_translate_worker/_batch 0 次、 总调用 19.6 亿 ⇒ **串行档**（1180s 档）。 ⇒ 拿 438s 当基线比 1168s 是"并行 vs 串行"。本次 A/B（同为串行、总调用 19.616 亿 vs 19.631 亿）里各项优化均为正收益（_RewritePlain −5.0s、 __exit__ −1.5s、re.match+_compile −1.3s、_RewriteQuoted −0.75s…）； +12% 属机器波动（同一批 C 函数在调用次数不变下变慢 25%~73%）。 改动（口径由用户定：不降级 + 预分配内存避免波动 + 强制要求预留内存）： 1. **不降级**：删掉"内存紧就退串行"。worker 数 = min(cpu_count, n_files)， 不再因可用内存抖动而变化。 2. **预分配校验 + 强制预留**：新增 _MemStatus()（读可用/总量）与 _ProbeReserveMb()——按 base×per_worker_mb（翻译 350 / 编译 400）分块**真正 提交**该预算（峰值=预算），成功后立即整体释放，紧接其后创建 worker 进程 由 OS 复用这批页。等于先向 OS 确认"这笔预算确实拿得到"，而不是只看含大量 可回收页的 ullAvailPhys。 3. **fail-fast**：可用内存 < 预算、或预分配校验提交失败 ⇒ RuntimeError 报出 "需要 X MB（N worker × M MB）/ 当前可用 Y MB / 总量 Z MB"，由使用者释放内存 或**显式** TPC_JOBS=N 重跑（N=1 即显式接受串行）。不再静默降级。 4. 新增 TPC_JOBS=N 显式覆盖（跳过校验，使用者自担内存风险）。 5. 每次决策都打日志：显式指定 / 读不到内存状态 / 预分配校验耗时 / 最终 workers。 已知取舍：内存确实不足时编译会**直接失败**（这是"不降级"的应有语义），出路是 释放内存或 TPC_JOBS=N；预分配校验会短暂占用峰值=预算的内存（约 1GB/秒级耗时）。 未动（下一步候选）：串行档的真热点 StructGen._generate_structs（151s 自身 / 480s 累计，被调 36,389 次≈每类 22 次，O(类数²)）。 --- lib/Projectrans/Phase2Translator.py | 115 ++++++++++++++++++++++++---- 1 file changed, 99 insertions(+), 16 deletions(-) diff --git a/lib/Projectrans/Phase2Translator.py b/lib/Projectrans/Phase2Translator.py index 829e94d..a62f49e 100644 --- a/lib/Projectrans/Phase2Translator.py +++ b/lib/Projectrans/Phase2Translator.py @@ -447,21 +447,18 @@ def _ParseDwarfSubprograms(dump_text: str) -> list[tuple[int, int, str]]: return result -def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int: - """按可用物理内存动态限制并行 worker 数，避免多进程编译内存峰值 OOM。 +# 显式并行度覆盖：TPC_JOBS=N（N>=1）——使用者明确指定 worker 数并**自行承担** +# 内存风险（含 N=1 即显式接受串行）。设了它就不再走内存校验/预分配。 +_JOBS_ENV: str = 'TPC_JOBS' +# 已通过"预分配校验"的预算（MB）：同一预算不重复校验（翻译/编译两阶段各查一次） +_MemProbeDone: set[int] = set() +# 预分配校验的分块大小（MB）：分块提交并**全部持有**到校验结束（峰值 = 预算）， +# 结束后立即整体释放 —— 紧接其后就创建 worker 进程，OS 直接复用这批刚释放的页。 +_MEM_PROBE_CHUNK_MB: int = 256 - 单 worker 预估 per_worker_mb（Python 解释器 + llvmlite module + 共享 - 符号表快照）；系统可用内存不足时降为单 worker 串行，内存充足时回落到 - cpu_count 并行。Windows 用 GlobalMemoryStatusEx 读 ullAvailPhys。 - per_worker_mb=350（2026-08-22 从 700 调低）：实测翻译阶段 worker 稳态 - 内存 ~110MB（tasklist 观察）、峰值 ~300MB；原 700MB 过保守——可用内存 - 稍紧（<2.8GB）就整体降级单 worker 串行，76 文件逐个翻译 1180s，并行 - 时 ~400s，时间波动 2-3 倍（用户反馈"编译时间不稳定"的根因之一）。 - """ - base = min(os.cpu_count() or 4, n_files) - if base <= 1: - return base +def _MemStatus() -> tuple[int, int]: + """(可用物理内存 MB, 物理内存总量 MB)；读取失败返回 (-1, -1)，调用方按"未知"处理""" try: import ctypes @@ -481,11 +478,97 @@ def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int: stat = _MemStat() stat.dwLength = ctypes.sizeof(_MemStat) if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat)): - avail_mb = stat.ullAvailPhys // (1024 * 1024) - by_mem = max(1, avail_mb // per_worker_mb) - return max(1, min(base, by_mem)) + return (stat.ullAvailPhys // (1024 * 1024), + stat.ullTotalPhys // (1024 * 1024)) except Exception: pass + return (-1, -1) + + +def _ProbeReserveMb(mb: int) -> bool: + """预分配校验：一次性提交 mb MB（分块持有后整体释放），成功返回 True。 + + 为什么要"预分配"而不是只读 ullAvailPhys：可用物理内存含大量**可回收**的 + 缓存页/其他进程随时会吃掉的余量，只按它决策会出现"这一秒够、真跑起来不够" + 的波动（编译时间在 400s / 1180s 两档之间随机跳的直接来源）。先真正把预算 + 拿到手（页级提交）再放掉，等于向 OS 确认过这笔预算确实可分配。 + """ + if mb <= 0: + return True + Bufs = [] + Left = mb + try: + while Left > 0: + Cur = min(_MEM_PROBE_CHUNK_MB, Left) + Bufs.append(bytearray(Cur * 1024 * 1024)) + Left -= Cur + return True + except MemoryError: + return False + finally: + del Bufs + + +def _PickWorkerCount(n_files: int, per_worker_mb: int = 350) -> int: + """并行 worker 数的**唯一**决策入口（CPU 上限 + 内存预分配双约束）。 + + 口径（用户 2026-10-01 定，取代旧"内存紧就降级串行"）： + 1. **不降级**：内存不足**绝不**静默退回单 worker 串行 —— 旧实现 `by_mem = + max(1, avail_mb // per_worker_mb)` 在可用内存稍紧时就整体降为串行， + 同一条命令 76 文件逐个翻译 1180s、并行 ~400s，时间随机跳 2-3 倍 + （profile 实证：224857 那次主进程 0 次 _translate_file＝并行，438s； + 231916/235354 两次主进程 75 次 _translate_file＝串行，1048s/1168s）。 + 2. **预分配 + 强制预留**：先按 base×per_worker_mb 做一次性提交校验 + （_ProbeReserveMb），拿到就并行、拿不到就 fail-fast 报出"可用/需要" + 数字，由使用者释放内存或**显式** TPC_JOBS=N 接受其它并行度。 + 3. 显式 TPC_JOBS=N 优先且跳过校验（使用者自行承担内存风险，N=1 即显式串行）。 + + 单 worker 预估 per_worker_mb（Python 解释器 + llvmlite module + 共享符号表 + 快照）；实测翻译阶段 worker 稳态 ~110MB、峰值 ~300MB，故取 350（编译阶段 + 调用方传 400）。Windows 用 GlobalMemoryStatusEx 读物理内存。 + """ + base = min(os.cpu_count() or 4, n_files) + if base <= 1: + return base + env_jobs: str | None = os.environ.get(_JOBS_ENV) + if env_jobs: + try: + want = int(env_jobs) + except ValueError: + want = base + want = max(1, min(want, base)) + _vlog().info( + f" [并行] {_JOBS_ENV}={env_jobs} → workers={want}" + f"（显式指定，跳过内存校验与预分配）") + return want + avail_mb, total_mb = _MemStatus() + need_mb = base * per_worker_mb + if avail_mb < 0: + # 读不到内存信息：不阻塞编译（按 CPU 上限并行），但必须显式告知 + _vlog().warning( + f" [并行] 无法读取物理内存状态，按 CPU 上限取 workers={base}" + f"（预算 {need_mb}MB）") + return base + if avail_mb < need_mb: + # 不降级：报数字 + 两条出路（释放内存 / 显式 TPC_JOBS=N） + raise RuntimeError( + f"[并行翻译] 内存不足，拒绝降级为串行（串行会让编译时间从 ~400s 掉到 ~1180s 档）：" + f"需要预留 {need_mb}MB（{base} worker × {per_worker_mb}MB），" + f"当前可用 {avail_mb}MB / 总量 {total_mb}MB。" + f"请释放内存后重跑；若确实要少开 worker（含串行），显式设 {_JOBS_ENV}=N 重跑。") + if need_mb not in _MemProbeDone: + _t0: float = _time.time() + if not _ProbeReserveMb(need_mb): + raise RuntimeError( + f"[并行翻译] 预分配校验失败：无法一次性提交 {need_mb}MB" + f"（{base} worker × {per_worker_mb}MB；可用显示 {avail_mb}MB / 总量 {total_mb}MB）。" + f"请释放内存后重跑；若确实要少开 worker（含串行），显式设 {_JOBS_ENV}=N 重跑。") + _MemProbeDone.add(need_mb) + _vlog().info( + f" [并行] 预分配校验通过：{need_mb}MB 可一次性提交" + f"（{_time.time() - _t0:.2f}s，已释放待 worker 进程复用）") + _vlog().info( + f" [并行] workers={base}（预算 {need_mb}MB ≤ 可用 {avail_mb}MB / 总量 {total_mb}MB）") return base