Download bridge/tools/monitor/native_monitor.py from SLAI-AITP/AscendGYM: direct link, hf CLI and curl.
- Browser
- Download file 26.7 kB
-
https://huggingface.co/datasets/SLAI-AITP/AscendGYM/resolve/main/bridge/tools/monitor/native_monitor.py
- Command line
-
hf download hf://datasets/SLAI-AITP/AscendGYM/bridge/tools/monitor/native_monitor.py
-
curl -L -o native_monitor.py https://huggingface.co/datasets/SLAI-AITP/AscendGYM/resolve/main/bridge/tools/monitor/native_monitor.py
26.7 kB
| #!/usr/bin/env python3 | |
| """Native-bench progress monitor(按 --tag 监控,与 start_all_runs.py 同一语义)。 | |
| 批次定位完全复用 `start_all_runs.py` 的规则:先找 `<runs_dir>/<tag>/`(新布局), | |
| 找不到再回退 `<runs_dir>/`(历史扁平布局),并从 `.batch-<agent>-<tag>.json` 反推 agent。 | |
| 因此 `--tag` 直接用启动批次时 `start_all_runs.py --tag` 传的那个值即可。 | |
| Usage: | |
| # 单轮(默认行为):打印 + 追加日志后退出 | |
| python3 tools/monitor/native_monitor.py --tag <TAG> --single | |
| # 循环:每 120 秒一轮,Ctrl-C 退出 | |
| python3 tools/monitor/native_monitor.py --tag <TAG> --loop | |
| python3 tools/monitor/native_monitor.py --tag <TAG> --loop --interval 60 | |
| # 同时看多个批次 | |
| python3 tools/monitor/native_monitor.py --tag <TAG1> --tag <TAG2> --single | |
| # 只打印不落盘 / 自定义输出位置 | |
| python3 tools/monitor/native_monitor.py --tag <TAG> --single --no-log | |
| python3 tools/monitor/native_monitor.py --tag <TAG> --single --md /tmp/a.md --jsonl /tmp/a.jsonl | |
| 默认输出 `native_progress_<tag>.md` / `.jsonl`(多 tag 时用 `+` 连接),可用 --md/--jsonl 覆盖。 | |
| 沙盒块:给了 `--sandbox-url` 就每轮实时拉取 `/status`;否则读 `/tmp/sandbox_status.json` | |
| (该文件不存在时沙盒块留空)。两者都不涉及大模型,纯本地读取 + 一个 HTTP GET,零 token。 | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import collections | |
| import json | |
| import os | |
| import re | |
| import signal | |
| import sys | |
| import time | |
| import urllib.error | |
| import urllib.request | |
| from pathlib import Path | |
| BRIDGE_DIR = Path(__file__).resolve().parents[2] | |
| # 已知 agent kind(与 start_all_runs.py 的 --agent choices 对齐);新增 agent 时同步这里。 | |
| if str(BRIDGE_DIR) not in sys.path: | |
| sys.path.insert(0, str(BRIDGE_DIR)) | |
| import start_all_runs as S # noqa: E402 复用批次目录解析 / 状态读取 / agent 识别 | |
| MONITOR_DIR = Path(__file__).resolve().parent | |
| AGENT_KINDS = ("claude", "codex", "opencode", "bare") | |
| SANDBOX_STATUS = "/tmp/sandbox_status.json" | |
| STALE_SECONDS = 150 | |
| # --- 批次定位 --------------------------------------------------------------- # | |
| def default_runs_dir(): | |
| """默认 runs 根目录:与调度器一致,取 op_catalog.outputs.runs_dir。""" | |
| try: | |
| catalog = json.loads(S.DEFAULT_CATALOG.read_text(encoding="utf-8")) | |
| return Path(catalog["outputs"]["runs_dir"]) | |
| except (OSError, ValueError, KeyError): | |
| return None | |
| def _flat_layout_has(runs_dir, tag): | |
| """扁平布局回退前的确认:runs_dir 里必须真的有本 tag 的痕迹。 | |
| 不能直接复用 existing_batch_dir —— 它在 `<runs_dir>/<tag>` 不存在时会无条件返回 | |
| runs_dir 本身(为兼容历史扁平布局),于是任何不存在的 tag 都会被"找到", | |
| 监控会把整个 runs 根目录当成一个批次来扫。 | |
| """ | |
| try: | |
| if any(runs_dir.glob(f".batch-*-{tag}.json")): | |
| return True | |
| suffix = f"-{tag}" | |
| retry_re = re.compile(rf"-{re.escape(tag)}-r\d+$") | |
| for entry in os.listdir(runs_dir): | |
| if entry.endswith(suffix) or retry_re.search(entry): | |
| return True | |
| except OSError: | |
| return False | |
| return False | |
| def resolve_batch(runs_dir, tag): | |
| """定位单个批次的目录;找不到返回 None。""" | |
| candidate = runs_dir / tag | |
| if candidate.is_dir(): | |
| return candidate | |
| if _flat_layout_has(runs_dir, tag): | |
| return runs_dir | |
| return None | |
| def detect_agent(batch_dir, tag): | |
| """从 `.batch-<agent>-<tag>.json` 反推 agent;状态文件缺失时回退到 run 目录名。""" | |
| suffix = f"-{tag}.json" | |
| candidates = [] | |
| for path in sorted(batch_dir.glob(f".batch-*{suffix}")): | |
| agent = path.name[len(".batch-"):-len(suffix)] | |
| if agent: | |
| candidates.append(agent) | |
| if len(candidates) > 1: | |
| # 同 tag 被多个 agent 用过:取在当前目录里留下最多 run 的那个 | |
| def owned(name): | |
| pat = re.compile(rf"-{re.escape(name)}-{re.escape(tag)}(-r\d+)?$") | |
| try: | |
| return sum(1 for entry in os.listdir(batch_dir) if pat.search(entry)) | |
| except OSError: | |
| return 0 | |
| best = max(candidates, key=owned) | |
| if owned(best): | |
| return best | |
| if candidates: | |
| return candidates[0] | |
| marker = f"-{tag}" | |
| for entry in sorted(os.listdir(batch_dir)): | |
| if marker not in entry: | |
| continue | |
| head = entry.rsplit(marker, 1)[0] | |
| if "-" in head: | |
| candidate = head.rsplit("-", 1)[-1] | |
| if candidate in AGENT_KINDS: | |
| return candidate | |
| return None | |
| def run_dirs(batch_dir, tag): | |
| """批次下所有算子的 run 目录名(排除 .opencode_sessions 等非 run 目录)。""" | |
| found = [] | |
| for entry in sorted(os.listdir(batch_dir)): | |
| if not S.looks_like_run_id(entry, tag): | |
| continue | |
| if (batch_dir / entry).is_dir(): | |
| found.append(entry) | |
| return found | |
| # --- 采样 ------------------------------------------------------------------- # | |
| def read_procs(): | |
| out = {} | |
| for pid in os.listdir("/proc"): | |
| if not pid.isdigit(): | |
| continue | |
| try: | |
| with open(f"/proc/{pid}/cmdline", "rb") as handle: | |
| raw = handle.read().replace(b"\0", b" ").decode(errors="replace").strip() | |
| except OSError: | |
| continue | |
| if raw: | |
| out[int(pid)] = raw | |
| return out | |
| _SUM_RE = re.compile(r"sum of per-op mean kernel time:\s*([\d.]+)\s*us") | |
| # codex CLI 会把「长会话/多次压缩会降低准确度」当 item.type=error 发出来,不是真错误。 | |
| _BENIGN_ITEM_PREFIXES = ("Heads up:",) | |
| # BOS 退化标记:adapter 可能写成字面量,也可能被 json.dumps 转义成 \uXXXX, | |
| # 两种都要数,否则指标会静默恒为 0。 | |
| _BOS_FORMS = ("<|begin▁of▁sentence|>", # 原样 | |
| "<\\uff5cbegin\\u2581of\\u2581sentence\\uff5c>") # json.dumps(ensure_ascii=True) | |
| def _mean_of(stdout_json): | |
| """取一次评测的总 kernel 耗时(us)。 | |
| 优先用 profiling_report 里的 'sum of per-op mean kernel time' 汇总行 —— 它与 | |
| result.json / 分析脚本的口径一致,且不依赖内核名(早期实现只认 `| aclnn` 开头的行, | |
| 像 HcPreSinkhorn 这类内核名会被漏掉,导致 base 显示为 '-')。 | |
| 没有汇总行时回退为把表格里各算子行的 mean 列相加。 | |
| """ | |
| try: | |
| with open(stdout_json, encoding="utf-8", errors="replace") as handle: | |
| payload = json.load(handle) | |
| except (OSError, ValueError): | |
| return "unparsed", None | |
| status = payload.get("status") | |
| report = payload.get("profiling_report") or "" | |
| match = _SUM_RE.search(report) | |
| if match: | |
| return status, float(match.group(1)) | |
| total = 0.0 | |
| found = False | |
| for line in report.splitlines(): | |
| parts = [p.strip() for p in line.split("|")] | |
| if len(parts) < 5 or not parts[1] or parts[1] == "op" or set(parts[1]) <= {"-"}: | |
| continue | |
| try: | |
| total += float(parts[3]) | |
| except ValueError: | |
| continue | |
| found = True | |
| return status, (total if found else None) | |
| def scan_agent_stdout(path): | |
| """扫 agent stdout:BOS 退化次数 + 真实错误条目(正则只做粗筛,再解析确认)。 | |
| 返回 (bos_hits, errors, raw_type_error_hits):raw 是未过滤的 `"type":"error"` 出现次数, | |
| 保留下来便于对比,errors 是剔除 CLI 提示类噪声后的真实错误。 | |
| """ | |
| bos = 0 | |
| errors = [] | |
| raw = 0 | |
| try: | |
| with open(path, encoding="utf-8", errors="replace") as handle: | |
| for line in handle: | |
| for form in _BOS_FORMS: | |
| if form in line: | |
| bos += line.count(form) | |
| if '"type":"error"' not in line and '"type": "error"' not in line: | |
| continue | |
| raw += 1 | |
| try: | |
| row = json.loads(line) | |
| except ValueError: | |
| continue | |
| item = row.get("item") or {} | |
| if item.get("type") != "error": | |
| continue | |
| message = item.get("message") or "" | |
| if message.startswith(_BENIGN_ITEM_PREFIXES): | |
| continue | |
| errors.append({"item_id": item.get("id"), "message": message[:300]}) | |
| except OSError: | |
| pass | |
| return bos, errors, raw | |
| def bare_eval_rows(op_dir): | |
| """bare harness 的评测行:bare_client 把每次评测追加进 evaluations.jsonl。 | |
| 字段映射到与 native 相同的形状(duration_us 就是同一个口径的 | |
| "sum of per-op mean kernel time",因此 base/cand/best/gain 语义一致)。 | |
| """ | |
| # native 的 run 也写 evaluations.jsonl(但字段是 duration_ms + solution_id), | |
| # 两者共用文件名。native 布局以 evaluations/E####/ 为权威,这里必须先让路, | |
| # 否则 native run 会被按 bare 的 schema 读成 mean_us=None(base/best/gain 全空)。 | |
| if any((op_dir / "evaluations").glob("E*")): | |
| return None | |
| path = op_dir / "evaluations.jsonl" | |
| if not path.is_file(): | |
| return None | |
| rows = [] | |
| try: | |
| with path.open(encoding="utf-8", errors="replace") as handle: | |
| for line in handle: | |
| line = line.strip() | |
| if not line: | |
| continue | |
| try: | |
| row = json.loads(line) | |
| except ValueError: | |
| continue | |
| rows.append({"id": row.get("evaluation_id"), "kind": row.get("evaluation_kind"), | |
| "status": row.get("status"), "mean_us": row.get("duration_us"), | |
| "version": row.get("version")}) | |
| except OSError: | |
| return None | |
| return rows or None | |
| def eval_rows(op_dir): | |
| bare_rows = bare_eval_rows(op_dir) | |
| if bare_rows is not None: | |
| return bare_rows | |
| rows = [] | |
| for edir in sorted((op_dir / "evaluations").glob("E*")): | |
| kind = None | |
| req = edir / "evaluator_request.json" | |
| if req.exists(): | |
| try: | |
| kind = json.loads(req.read_text(encoding="utf-8", errors="replace")).get("evaluation_kind") | |
| except (OSError, ValueError): | |
| kind = "?" | |
| status, mean = _mean_of(str(edir / "stdout.json")) | |
| rows.append({"id": edir.name, "kind": kind, "status": status, "mean_us": mean}) | |
| return rows | |
| def op_name_of(run_id, tag, agent): | |
| """从 run_id = <op>-<agent>-<tag>[-rN] 反解出算子名。 | |
| 同一条 tag 可能被多个 agent 用过(批次键是 (tag, agent)),目录里会同时有 | |
| `<op>-codex-<tag>` 和 `<op>-claude-<tag>`。只剥"检测到的那个 agent"会剥不干净, | |
| 导致同一算子出现两行、done=x/N 的分母虚高。这里剥任意已知 agent。 | |
| """ | |
| base = re.sub(r"-r\d+$", "", run_id) | |
| base = base[: -len(tag) - 1] if base.endswith(f"-{tag}") else base | |
| for kind in ([agent] if agent else []) + list(AGENT_KINDS): | |
| if kind and base.endswith(f"-{kind}"): | |
| return base[: -len(kind) - 1] | |
| return base | |
| def attempt_of(run_id, tag): | |
| """run_id 的 -rN 后缀,形如 ' (r2)';非重试 run 返回空串。 | |
| run 级基础设施故障重排会留下同算子的多个目录,不标注的话表格里会出现 | |
| 多行同名算子,看不出哪行是哪次尝试。 | |
| """ | |
| match = re.search(rf"-{re.escape(tag)}-r(\d+)$", run_id) | |
| return f" (r{match.group(1)})" if match else "" | |
| def op_snapshot(op_dir, tag, agent, now): | |
| op_dir = Path(op_dir) | |
| counts = collections.Counter() | |
| last_type = None | |
| last_elapsed = None | |
| events_path = op_dir / "events.jsonl" | |
| if events_path.exists(): | |
| with open(events_path, encoding="utf-8", errors="replace") as handle: | |
| for line in handle: | |
| line = line.strip() | |
| if not line: | |
| continue | |
| try: | |
| row = json.loads(line) | |
| except ValueError: | |
| continue | |
| counts[row.get("event_type")] += 1 | |
| last_type = row.get("event_type") | |
| last_elapsed = row.get("elapsed_sec") | |
| try: | |
| age = now - events_path.stat().st_mtime | |
| except OSError: | |
| try: | |
| age = now - op_dir.stat().st_mtime | |
| except OSError: | |
| age = float("inf") | |
| stdout_path = op_dir / "agent.stdout.jsonl" | |
| if not stdout_path.is_file(): | |
| # Some harnesses write plain-text stdout; scan it best-effort. | |
| stdout_path = op_dir / "agent.stdout.txt" | |
| bos, errors, raw_errors = scan_agent_stdout(stdout_path) | |
| evals = eval_rows(op_dir) | |
| baseline = next((e["mean_us"] for e in evals if e["kind"] == "baseline" and e["mean_us"]), None) | |
| cands = [e for e in evals if e["kind"] == "candidate"] | |
| ok = [e["mean_us"] for e in cands if e["status"] == "passed" and e["mean_us"]] | |
| return { | |
| "op": op_name_of(op_dir.name, tag, agent), | |
| "attempt": attempt_of(op_dir.name, tag), | |
| "dir": str(op_dir), | |
| "events": sum(counts.values()), | |
| "native_events": counts.get("native_event", 0), | |
| "last_event": last_type, | |
| "last_elapsed_sec": last_elapsed, | |
| "age_sec": round(age, 1) if age != float("inf") else None, | |
| "done": (op_dir / "result.json").exists(), | |
| "baseline_us": baseline, | |
| "candidates": len(ok), | |
| "candidates_total": len(cands), | |
| "best_candidate_us": min(ok) if ok else None, | |
| "gain_pct": round((baseline - min(ok)) / baseline * 100, 2) if (ok and baseline) else None, | |
| "failures": collections.Counter(e["status"] for e in cands if e["status"] != "passed"), | |
| "bos_hits": bos, | |
| "type_error_hits": len(errors), | |
| "type_error_raw_hits": raw_errors, | |
| "errors": errors[:5], | |
| "evals": evals, | |
| } | |
| def fetch_sandbox(url): | |
| """实时拉取沙盒 /status;失败返回 None(不中断监控)。""" | |
| try: | |
| with urllib.request.urlopen(url.rstrip("/") + "/status", timeout=10) as resp: | |
| return json.load(resp) | |
| except (urllib.error.URLError, OSError, ValueError): | |
| return None | |
| def sandbox_summary(raw): | |
| if not raw: | |
| return None | |
| servers = raw.get("servers", []) | |
| return { | |
| "healthy": sum(1 for s in servers if s.get("is_healthy")), | |
| "servers": len(servers), | |
| "running": sum(s.get("active_tasks", 0) for s in servers), | |
| "queued": raw.get("total_tasks_queued"), | |
| "completed_total": sum(s.get("total_tasks_completed", 0) for s in servers), | |
| "completed_per_card": [s.get("total_tasks_completed") for s in servers], | |
| } | |
| def load_sandbox_raw(args): | |
| if getattr(args, "sandbox_url", None): | |
| return fetch_sandbox(args.sandbox_url) | |
| if os.path.exists(SANDBOX_STATUS): | |
| try: | |
| with open(SANDBOX_STATUS, encoding="utf-8", errors="replace") as handle: | |
| return json.load(handle) | |
| except (OSError, ValueError): | |
| return None | |
| return None | |
| def collect(runs_dir, tags, now, sandbox_raw): | |
| procs = read_procs() | |
| batches = [] | |
| for tag in tags: | |
| batch_dir = resolve_batch(runs_dir, tag) | |
| if batch_dir is None: | |
| batches.append({"tag": tag, "missing": True, | |
| "tried": [str(runs_dir / tag), str(runs_dir)]}) | |
| continue | |
| agent = detect_agent(batch_dir, tag) | |
| dirs = run_dirs(batch_dir, tag) | |
| agent_pids = [p for p, c in procs.items() if S.native_agent_kind(c)] | |
| if agent: | |
| agent_pids = [p for p in agent_pids if S.native_agent_kind(procs[p]) == agent] | |
| manager_pids = [p for p, c in procs.items() | |
| if "op_manager.py run" in c and f"--runs-dir {batch_dir}" in c] | |
| sched_pids = [p for p, c in procs.items() | |
| if "start_all_runs.py" in c and f"--tag {tag}" in c] | |
| ops = [op_snapshot(batch_dir / d, tag, agent, now) for d in dirs] | |
| # 已登记但还没建目录的算子(排队中)也列出来,否则进度会看着像"少了几个算子" | |
| state = S.load_batch_state(batch_dir, agent, tag) if agent else None | |
| planned = (state or {}).get("planned") or \ | |
| [row.get("run_id") for row in (state or {}).get("runs", [])] | |
| have = set(dirs) | |
| for run_id in planned: | |
| if not run_id or run_id in have or (batch_dir / run_id).is_dir(): | |
| continue | |
| have.add(run_id) | |
| ops.append({ | |
| "op": op_name_of(run_id, tag, agent), "attempt": attempt_of(run_id, tag), | |
| "dir": None, "queued": True, | |
| "events": 0, "native_events": 0, "last_event": None, "last_elapsed_sec": None, | |
| "age_sec": None, "done": False, "baseline_us": None, "candidates": 0, | |
| "candidates_total": 0, | |
| "best_candidate_us": None, "gain_pct": None, | |
| "failures": collections.Counter(), "bos_hits": 0, | |
| "type_error_hits": 0, "type_error_raw_hits": 0, "errors": [], "evals": [], | |
| }) | |
| # 有进展的(run/DONE/stale)排前面,queue 的排最后:否则新批次一打开满屏都是 "-" | |
| ops.sort(key=lambda o: (bool(o.get("queued")), o["op"], o.get("attempt") or "")) | |
| batches.append({ | |
| "tag": tag, | |
| "agent": agent, | |
| "root": str(batch_dir), | |
| "scheduler_pids": sched_pids, | |
| "manager_count": len(manager_pids), | |
| "agent_proc_count": len(agent_pids), | |
| "ops_total": len(ops), | |
| "ops_done": sum(1 for o in ops if o["done"]), | |
| "ops_queued": sum(1 for o in ops if o.get("queued")), | |
| "ops": ops, | |
| "bos_hits": sum(o["bos_hits"] for o in ops), | |
| "type_error_hits": sum(o["type_error_hits"] for o in ops), | |
| }) | |
| return { | |
| "ts": now, | |
| "ts_text": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(now)), | |
| "tags": list(tags), | |
| "sandbox": sandbox_summary(sandbox_raw), | |
| "batches": batches, | |
| } | |
| # --- 渲染 ------------------------------------------------------------------- # | |
| def fmt_us(value): | |
| return "-" if not value else f"{value:.3f}" | |
| def _flag_of(op): | |
| if op.get("queued"): | |
| return "queue" | |
| if op["done"]: | |
| return "DONE" | |
| age = op["age_sec"] | |
| return "stale" if (age is None or age > STALE_SECONDS) else "run" | |
| def _op_line(op): | |
| flag = _flag_of(op) | |
| age = op["age_sec"] | |
| fails = ",".join(f"{k}x{v}" for k, v in op["failures"].items()) or "-" | |
| gain = "-" if op["gain_pct"] is None else f"{op['gain_pct']:+.2f}%" | |
| label = op["op"] + (op.get("attempt") or "") | |
| return (f" {label:26} {flag:5} events={op['events']:5} base={fmt_us(op['baseline_us']):>8} " | |
| f"cand={op['candidates']}/{op.get('candidates_total', op['candidates'])}" | |
| f"{'':<3} best={fmt_us(op['best_candidate_us']):>8} " | |
| f"gain={gain:>7} age={(age if age is not None else -1):5.0f}s fails[{fails}]") | |
| def render_text(snap): | |
| lines = [f"== snapshot {snap['ts_text']}"] | |
| sb = snap.get("sandbox") | |
| if sb: | |
| lines.append( | |
| f" sandbox: healthy={sb['healthy']}/{sb['servers']} running={sb['running']} " | |
| f"queued={sb['queued']} completed_total={sb['completed_total']}" | |
| ) | |
| for b in snap["batches"]: | |
| if b.get("missing"): | |
| lines.append(f"\n-- [{b['tag']}] 批次目录不存在(已尝试 {b['tried']})") | |
| continue | |
| lines.append( | |
| f"\n-- [{b['tag']}] agent={b['agent']} {b['root']}\n" | |
| f" scheduler={b['scheduler_pids']} op_manager={b['manager_count']} " | |
| f"agent_proc={b['agent_proc_count']} done={b['ops_done']}/{b['ops_total']} " | |
| f"BOS={b['bos_hits']} type_error={b['type_error_hits']}" | |
| ) | |
| lines.extend(_op_line(o) for o in b["ops"]) | |
| return "\n".join(lines) | |
| def render_markdown(snap, round_no, note=None): | |
| out = [f"\n## 第 {round_no} 轮 — {snap['ts_text']}\n"] | |
| if note: | |
| out.append(f"> {note}\n") | |
| sb = snap.get("sandbox") | |
| if sb: | |
| out.append( | |
| f"- 沙盒:healthy {sb['healthy']}/{sb['servers']},running {sb['running']}," | |
| f"queued {sb['queued']},累计完成 {sb['completed_total']}(分卡 {sb['completed_per_card']})" | |
| ) | |
| for b in snap["batches"]: | |
| if b.get("missing"): | |
| out.append(f"\n- [{b['tag']}] 批次目录不存在(已尝试 {b['tried']})") | |
| continue | |
| out.append( | |
| f"\n### {b['tag']}({b['ops_done']}/{b['ops_total']} 完成,agent={b['agent']}," | |
| f"op_manager={b['manager_count']},agent 进程={b['agent_proc_count']}," | |
| f"scheduler PID={b['scheduler_pids']})\n" | |
| ) | |
| out.append("| 算子 | 状态 | 事件数 | 基线(us) | 候选数 | 最佳候选(us) | 较基线 | 失败明细 | 无事件时长 |") | |
| out.append("|---|---|---|---|---|---|---|---|---|") | |
| for o in b["ops"]: | |
| flag = _flag_of(o) | |
| age = o["age_sec"] | |
| gain = "-" if o["gain_pct"] is None else f"{o['gain_pct']:+.2f}%" | |
| fails = ", ".join(f"{k}×{v}" for k, v in o["failures"].items()) or "-" | |
| age_text = "?" if age is None else f"{age:.0f}s" | |
| out.append( | |
| f"| {o['op'] + (o.get('attempt') or '')} | {flag} | {o['events']} | " | |
| f"{fmt_us(o['baseline_us'])} | {o['candidates']} | " | |
| f"{fmt_us(o['best_candidate_us'])} | {gain} | {fails} | {age_text} |" | |
| ) | |
| out.append(f"\n- 异常扫描:BOS 退化 {b['bos_hits']} 次,`type=error` {b['type_error_hits']} 次") | |
| out.append(f"- 目录:`{b['root']}`") | |
| return "\n".join(out) + "\n" | |
| def next_round_no(path): | |
| if not path.exists(): | |
| return 1 | |
| with open(path, encoding="utf-8", errors="replace") as handle: | |
| return sum(1 for line in handle if line.startswith("## 第 ")) + 1 | |
| def default_log_paths(tags): | |
| stem = tags[0] if len(tags) == 1 else "+".join(tags) | |
| return MONITOR_DIR / f"native_progress_{stem}.md", MONITOR_DIR / f"native_progress_{stem}.jsonl" | |
| # --- 主流程 ----------------------------------------------------------------- # | |
| def parse_args(argv=None): | |
| parser = argparse.ArgumentParser( | |
| description="native 批次进度监控(按 --tag,与 start_all_runs.py 同一语义)", | |
| formatter_class=argparse.RawDescriptionHelpFormatter) | |
| parser.add_argument("--tag", action="append", default=None, metavar="TAG", | |
| help="批次 tag,可重复传以同时监控多批(与 start_all_runs.py --tag 一致)") | |
| parser.add_argument("--runs-dir", dest="runs_dir", | |
| help="runs 根目录(默认取 op_catalog.outputs.runs_dir)") | |
| mode = parser.add_mutually_exclusive_group() | |
| mode.add_argument("--single", action="store_true", | |
| help="只采集一轮后退出(未指定 --loop 时的默认行为)") | |
| mode.add_argument("--loop", action="store_true", | |
| help="持续循环采集,Ctrl-C 退出") | |
| parser.add_argument("--interval", type=float, default=120.0, metavar="SECONDS", | |
| help="--loop 下每轮之间的间隔秒数(默认 120)") | |
| parser.add_argument("--sandbox-url", dest="sandbox_url", metavar="URL", | |
| help="每轮实时拉取该沙盒的 /status;缺省则读 /tmp/sandbox_status.json") | |
| parser.add_argument("--no-log", action="store_true", help="只打印,不追加 md/jsonl") | |
| parser.add_argument("--md", help="markdown 输出路径(默认 native_progress_<tag>.md)") | |
| parser.add_argument("--jsonl", help="jsonl 输出路径(默认 native_progress_<tag>.jsonl)") | |
| args = parser.parse_args(argv) | |
| if not args.tag: | |
| parser.error("至少需要一个 --tag(与启动批次时 start_all_runs.py --tag 的值相同)") | |
| args.tag = list(dict.fromkeys(args.tag)) | |
| if args.interval <= 0: | |
| parser.error("--interval 必须 > 0") | |
| return args | |
| def do_round(args, runs_dir, md_path, jsonl_path, round_no, note=None): | |
| snap = collect(runs_dir, args.tag, time.time(), load_sandbox_raw(args)) | |
| print(render_text(snap)) | |
| if args.no_log: | |
| return round_no | |
| if round_no == 1: | |
| md_path.parent.mkdir(parents=True, exist_ok=True) | |
| with open(md_path, "a", encoding="utf-8") as handle: | |
| handle.write(render_markdown(snap, round_no, note)) | |
| with open(jsonl_path, "a", encoding="utf-8") as handle: | |
| handle.write(json.dumps(snap, ensure_ascii=False) + "\n") | |
| print(f"\n[logged] round {round_no} -> {md_path} / {jsonl_path}") | |
| return round_no + 1 | |
| def main(argv=None): | |
| args = parse_args(argv) | |
| runs_dir = Path(args.runs_dir) if args.runs_dir else default_runs_dir() | |
| if runs_dir is None: | |
| raise SystemExit("无法确定 runs 根目录:请用 --runs-dir 指定," | |
| "或确保 configs/op_catalog.json 里有 outputs.runs_dir") | |
| md_path = Path(args.md) if args.md else default_log_paths(args.tag)[0] | |
| jsonl_path = Path(args.jsonl) if args.jsonl else default_log_paths(args.tag)[1] | |
| missing = [tag for tag in args.tag if resolve_batch(runs_dir, tag) is None] | |
| for tag in missing: | |
| print(f"warning: 找不到 tag={tag} 的批次目录(已尝试 {runs_dir / tag} 与 {runs_dir})", | |
| file=sys.stderr) | |
| if not args.loop: | |
| do_round(args, runs_dir, md_path, jsonl_path, 1) | |
| return 0 | |
| def _stop(_signum, _frame): | |
| raise KeyboardInterrupt | |
| for sig in (signal.SIGTERM, signal.SIGINT): | |
| signal.signal(sig, _stop) | |
| print(f"loop 模式:每 {args.interval:g}s 一轮,Ctrl-C 退出;tag={', '.join(args.tag)}") | |
| round_no = 1 | |
| try: | |
| while True: | |
| round_no = do_round(args, runs_dir, md_path, jsonl_path, round_no) | |
| if args.interval > 0: | |
| time.sleep(args.interval) | |
| except KeyboardInterrupt: | |
| print(f"\n已停止(共 {round_no - 1} 轮)") | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main()) | |