bench: add fair cloud profiling controls

HachimiMT_Benchmark_Profile.ipynb

@@ -13,14 +13,19 @@
     "- Colab: cell chọn file sẽ mở upload nếu bạn chưa set `INPUT_PATH`.\n",
     "- Kaggle: thêm file `.txt` bằng **Add Input** hoặc đặt file trong `/kaggle/working`, rồi chạy cell chọn file.\n",
     "\n",
-    "Dòng cần xem nằm gần cuối output cell benchmark:\n",
-    "\n",
-    "```text\n",
-    "BENCH_PROFILE ... chunk_s=... ct2_infer_s=... decode_s=... tokenize_wait_s=...\n",
-    "BENCH_DONE ...\n",
-    "```"
-   ]
-  },
+    "Dòng cần xem nằm gần cuối output cell benchmark:\n",
+    "\n",
+    "```text\n",
+    "BENCH_RUNTIME ... ct2_cuda_devices=...\n",
+    "BENCH_PACKAGES ... ctranslate2=... sentencepiece=... torch=...\n",
+    "BENCH_ENV ... HACHIMIMT_GPU_INDICES=... HACHIMIMT_CT2_WINDOW_MULTIPLIER=...\n",
+    "BENCH_PROFILE ... chunk_s=... ct2_infer_s=... decode_s=... tokenize_wait_s=...\n",
+    "BENCH_DONE ...\n",
+    "```\n",
+    "\n",
+    "Để so Kaggle với Colab công bằng, bật `USE_SINGLE_GPU_FOR_FAIR_TEST=True`; notebook sẽ tự dùng window `16` cho lần fair test nếu bạn không override `WINDOW_MULTIPLIER`."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -116,69 +121,278 @@
     "        print(f\"{idx}. {path} ({path.stat().st_size:,} bytes)\")\n",
     "    return candidates[0]\n",
     "\n",
-    "input_path = resolve_input_path()\n",
-    "print(\"INPUT_FILE=\", input_path)\n",
-    "print(\"size_bytes=\", input_path.stat().st_size)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
+    "input_path = resolve_input_path()\n",
+    "print(\"INPUT_FILE=\", input_path)\n",
+    "print(\"size_bytes=\", input_path.stat().st_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3. Cấu hình benchmark\n",
+    "# Đổi các biến ở đây rồi chạy lại cell benchmark bên dưới.\n",
+    "import os\n",
+    "\n",
+    "MODEL = \"HachimiMT-60\"      # HachimiMT-60, HachimiMT-30, MoxhiMT-60, MoxhiMT-30, HirashibaMT-Medium, HirashibaMT-Tiny\n",
+    "BEAM = 2                    # 1 nhanh hơn, 2 thường cân bằng hơn\n",
+    "CHUNK_MODE = \"sentence\"     # sentence hoặc paragraph\n",
+    "NORMALIZE = \"auto\"          # auto, t2s, none\n",
+    "PROGRESS_SECONDS = 30\n",
+    "\n",
+    "# Bật để so Kaggle x1 T4 công bằng với Colab x1 T4.\n",
+    "# Tắt để Kaggle tự dùng toàn bộ GPU được cấp, ví dụ T4 x2.\n",
+    "USE_SINGLE_GPU_FOR_FAIR_TEST = False\n",
+    "FAIR_GPU_INDICES = \"0\"\n",
+    "\n",
+    "# Các giá trị này sẽ truyền vào subprocess benchmark trước khi app import CT2.\n",
+    "# Để \"\" nếu muốn dùng auto/default của app.\n",
+    "BATCH_SIZE = \"96\"\n",
+    "WINDOW_MULTIPLIER = \"\"      # \"\" = app default; điền 4/8/16 khi muốn ép tay\n",
+    "FAIR_WINDOW_MULTIPLIER = \"16\"\n",
+    "CT2_BATCH_TYPE = \"tokens\"\n",
+    "INTER_THREADS = \"1\"\n",
+    "TOKENIZE_WORKERS = \"\"      # Colab 2 vCPU có thể thử \"2\"; để trống = auto\n",
+    "TOKENIZE_JOB_SIZE = \"\"\n",
+    "CT2_THREADS = \"\"\n",
+    "\n",
+    "TRACKED_ENV_KEYS = [\n",
+    "    \"CUDA_VISIBLE_DEVICES\",\n",
+    "    \"HACHIMIMT_GPU_INDICES\",\n",
+    "    \"HACHIMIMT_AUTO_ALL_GPUS\",\n",
+    "    \"HACHIMIMT_BATCH_SIZE\",\n",
+    "    \"HACHIMIMT_THREADS\",\n",
+    "    \"HACHIMIMT_TOKENIZE_WORKERS\",\n",
+    "    \"HACHIMIMT_TOKENIZE_JOB_SIZE\",\n",
+    "    \"HACHIMIMT_CT2_BATCH_TYPE\",\n",
+    "    \"HACHIMIMT_CT2_WINDOW_MULTIPLIER\",\n",
+    "    \"HACHIMIMT_INTER_THREADS\",\n",
+    "]\n",
+    "\n",
+    "\n",
+    "def _set_or_unset(env, key, value):\n",
+    "    value = str(value).strip()\n",
+    "    if value:\n",
+    "        env[key] = value\n",
+    "    else:\n",
+    "        env.pop(key, None)\n",
+    "\n",
+    "\n",
+    "def build_benchmark_env(\n",
+    "    *,\n",
+    "    use_single_gpu=USE_SINGLE_GPU_FOR_FAIR_TEST,\n",
+    "    gpu_indices=FAIR_GPU_INDICES,\n",
+    "    batch_size=BATCH_SIZE,\n",
+    "    window_multiplier=WINDOW_MULTIPLIER,\n",
+    "    fair_window_multiplier=FAIR_WINDOW_MULTIPLIER,\n",
+    "    ct2_batch_type=CT2_BATCH_TYPE,\n",
+    "    inter_threads=INTER_THREADS,\n",
+    "    tokenize_workers=TOKENIZE_WORKERS,\n",
+    "    tokenize_job_size=TOKENIZE_JOB_SIZE,\n",
+    "    ct2_threads=CT2_THREADS,\n",
+    "):\n",
+    "    env = os.environ.copy()\n",
+    "    if use_single_gpu:\n",
+    "        env[\"HACHIMIMT_GPU_INDICES\"] = str(gpu_indices).strip() or \"0\"\n",
+    "        env[\"HACHIMIMT_AUTO_ALL_GPUS\"] = \"0\"\n",
+    "        if not str(window_multiplier).strip():\n",
+    "            window_multiplier = fair_window_multiplier\n",
+    "    else:\n",
+    "        env.pop(\"HACHIMIMT_GPU_INDICES\", None)\n",
+    "        env.pop(\"HACHIMIMT_AUTO_ALL_GPUS\", None)\n",
+    "\n",
+    "    _set_or_unset(env, \"HACHIMIMT_BATCH_SIZE\", batch_size)\n",
+    "    _set_or_unset(env, \"HACHIMIMT_CT2_WINDOW_MULTIPLIER\", window_multiplier)\n",
+    "    _set_or_unset(env, \"HACHIMIMT_CT2_BATCH_TYPE\", ct2_batch_type)\n",
+    "    _set_or_unset(env, \"HACHIMIMT_INTER_THREADS\", inter_threads)\n",
+    "    _set_or_unset(env, \"HACHIMIMT_TOKENIZE_WORKERS\", tokenize_workers)\n",
+    "    _set_or_unset(env, \"HACHIMIMT_TOKENIZE_JOB_SIZE\", tokenize_job_size)\n",
+    "    _set_or_unset(env, \"HACHIMIMT_THREADS\", ct2_threads)\n",
+    "    return env\n",
+    "\n",
+    "\n",
+    "preview_env = build_benchmark_env()\n",
+    "print(\"Benchmark config:\")\n",
+    "print(\"MODEL=\", MODEL, \"BEAM=\", BEAM, \"CHUNK_MODE=\", CHUNK_MODE, \"NORMALIZE=\", NORMALIZE)\n",
+    "for key in TRACKED_ENV_KEYS:\n",
+    "    if key in preview_env:\n",
+    "        print(f\"{key}={preview_env[key]}\")\n",
+    "print(\"single_gpu_fair_test=\", USE_SINGLE_GPU_FOR_FAIR_TEST)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "# 3. Chạy benchmark và in BENCH_PROFILE\n",
-    "import os\n",
-    "import subprocess\n",
-    "import sys\n",
-    "from pathlib import Path\n",
-    "\n",
-    "MODEL = \"HachimiMT-60\"      # HachimiMT-60, HachimiMT-30, MoxhiMT-60, MoxhiMT-30, HirashibaMT-Medium, HirashibaMT-Tiny\n",
-    "BEAM = 2                    # 1 nhanh hơn, 2 thường cân bằng hơn\n",
-    "CHUNK_MODE = \"sentence\"     # sentence hoặc paragraph\n",
-    "NORMALIZE = \"auto\"          # auto, t2s, none\n",
-    "PROGRESS_SECONDS = 30\n",
-    "\n",
-    "bench_script = Path(\"hachimimt/src/benchmark_file.py\")\n",
-    "if not bench_script.exists():\n",
-    "    raise FileNotFoundError(f\"Không thấy benchmark script: {bench_script}\")\n",
-    "if not Path(input_path).exists():\n",
-    "    raise FileNotFoundError(f\"Input file không tồn tại: {input_path}\")\n",
-    "\n",
-    "cmd = [\n",
-    "    sys.executable,\n",
-    "    str(bench_script),\n",
-    "    str(input_path),\n",
-    "    \"--model\", MODEL,\n",
-    "    \"--backend\", \"ct2\",\n",
-    "    \"--beam\", str(BEAM),\n",
-    "    \"--chunk-mode\", CHUNK_MODE,\n",
-    "    \"--normalize\", NORMALIZE,\n",
-    "    \"--progress-seconds\", str(PROGRESS_SECONDS),\n",
-    "]\n",
-    "\n",
-    "print(\"RUN:\", \" \".join(cmd))\n",
-    "print(\"\\n--- benchmark output ---\")\n",
-    "lines = []\n",
-    "process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)\n",
-    "assert process.stdout is not None\n",
-    "for line in process.stdout:\n",
-    "    print(line, end=\"\")\n",
-    "    lines.append(line.rstrip(\"\\n\"))\n",
-    "returncode = process.wait()\n",
-    "if returncode != 0:\n",
-    "    raise subprocess.CalledProcessError(returncode, cmd)\n",
-    "\n",
-    "profile_lines = [line for line in lines if line.startswith(\"BENCH_PROFILE\")]\n",
-    "done_lines = [line for line in lines if line.startswith(\"BENCH_DONE\")]\n",
-    "print(\"\\n--- parsed summary ---\")\n",
-    "print(profile_lines[-1] if profile_lines else \"Không thấy BENCH_PROFILE. Hãy chắc notebook đã tải zip mới từ Space.\")\n",
-    "print(done_lines[-1] if done_lines else \"Không thấy BENCH_DONE.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
+    "# 4. Chạy benchmark và in BENCH_PROFILE\n",
+    "import os\n",
+    "import subprocess\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "bench_script = Path(\"hachimimt/src/benchmark_file.py\")\n",
+    "if not bench_script.exists():\n",
+    "    raise FileNotFoundError(f\"Không thấy benchmark script: {bench_script}\")\n",
+    "if not Path(input_path).exists():\n",
+    "    raise FileNotFoundError(f\"Input file không tồn tại: {input_path}\")\n",
+    "\n",
+    "\n",
+    "def parse_kv_line(line):\n",
+    "    data = {}\n",
+    "    for part in line.split()[1:]:\n",
+    "        if \"=\" in part:\n",
+    "            key, value = part.split(\"=\", 1)\n",
+    "            data[key] = value\n",
+    "    return data\n",
+    "\n",
+    "\n",
+    "def run_benchmark_once(\n",
+    "    *,\n",
+    "    label=\"single\",\n",
+    "    model=MODEL,\n",
+    "    beam=BEAM,\n",
+    "    chunk_mode=CHUNK_MODE,\n",
+    "    normalize=NORMALIZE,\n",
+    "    progress_seconds=PROGRESS_SECONDS,\n",
+    "    use_single_gpu=USE_SINGLE_GPU_FOR_FAIR_TEST,\n",
+    "    gpu_indices=FAIR_GPU_INDICES,\n",
+    "    batch_size=BATCH_SIZE,\n",
+    "    window_multiplier=WINDOW_MULTIPLIER,\n",
+    "):\n",
+    "    env = build_benchmark_env(\n",
+    "        use_single_gpu=use_single_gpu,\n",
+    "        gpu_indices=gpu_indices,\n",
+    "        batch_size=batch_size,\n",
+    "        window_multiplier=window_multiplier,\n",
+    "    )\n",
+    "    cmd = [\n",
+    "        sys.executable,\n",
+    "        str(bench_script),\n",
+    "        str(input_path),\n",
+    "        \"--model\", model,\n",
+    "        \"--backend\", \"ct2\",\n",
+    "        \"--beam\", str(beam),\n",
+    "        \"--chunk-mode\", chunk_mode,\n",
+    "        \"--normalize\", normalize,\n",
+    "        \"--progress-seconds\", str(progress_seconds),\n",
+    "    ]\n",
+    "\n",
+    "    print(f\"RUN_LABEL={label}\")\n",
+    "    print(\"RUN:\", \" \".join(cmd))\n",
+    "    print(\"ENV:\", {key: env.get(key) for key in TRACKED_ENV_KEYS if env.get(key) is not None})\n",
+    "    print(\"\\n--- benchmark output ---\")\n",
+    "    lines = []\n",
+    "    process = subprocess.Popen(\n",
+    "        cmd,\n",
+    "        stdout=subprocess.PIPE,\n",
+    "        stderr=subprocess.STDOUT,\n",
+    "        text=True,\n",
+    "        bufsize=1,\n",
+    "        env=env,\n",
+    "    )\n",
+    "    assert process.stdout is not None\n",
+    "    for line in process.stdout:\n",
+    "        print(line, end=\"\")\n",
+    "        lines.append(line.rstrip(\"\\n\"))\n",
+    "    returncode = process.wait()\n",
+    "    if returncode != 0:\n",
+    "        raise subprocess.CalledProcessError(returncode, cmd)\n",
+    "\n",
+    "    profile_lines = [line for line in lines if line.startswith(\"BENCH_PROFILE\")]\n",
+    "    done_lines = [line for line in lines if line.startswith(\"BENCH_DONE\")]\n",
+    "    runtime_lines = [line for line in lines if line.startswith(\"BENCH_RUNTIME\")]\n",
+    "    package_lines = [line for line in lines if line.startswith(\"BENCH_PACKAGES\")]\n",
+    "    env_lines = [line for line in lines if line.startswith(\"BENCH_ENV\")]\n",
+    "    summary = {\n",
+    "        \"label\": label,\n",
+    "        \"profile_line\": profile_lines[-1] if profile_lines else \"\",\n",
+    "        \"done_line\": done_lines[-1] if done_lines else \"\",\n",
+    "        \"runtime_line\": runtime_lines[-1] if runtime_lines else \"\",\n",
+    "        \"package_line\": package_lines[-1] if package_lines else \"\",\n",
+    "        \"env_line\": env_lines[-1] if env_lines else \"\",\n",
+    "        \"profile\": parse_kv_line(profile_lines[-1]) if profile_lines else {},\n",
+    "        \"done\": parse_kv_line(done_lines[-1]) if done_lines else {},\n",
+    "    }\n",
+    "    print(\"\\n--- parsed summary ---\")\n",
+    "    print(summary[\"runtime_line\"] or \"Không thấy BENCH_RUNTIME. Hãy chắc notebook đã tải zip mới từ Space.\")\n",
+    "    print(summary[\"package_line\"] or \"Không thấy BENCH_PACKAGES.\")\n",
+    "    print(summary[\"env_line\"] or \"Không thấy BENCH_ENV.\")\n",
+    "    print(summary[\"profile_line\"] or \"Không thấy BENCH_PROFILE.\")\n",
+    "    print(summary[\"done_line\"] or \"Không thấy BENCH_DONE.\")\n",
+    "    return summary\n",
+    "\n",
+    "\n",
+    "last_summary = run_benchmark_once()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 5. Sweep nhanh batch/window/beam (tắt mặc định)\n",
+    "# Bật RUN_SWEEP=True khi muốn tìm cấu hình tốt nhất trên runtime hiện tại.\n",
+    "RUN_SWEEP = False\n",
+    "SWEEP_SINGLE_GPU = True      # True: fair x1 T4; False: Kaggle dùng hết GPU\n",
+    "SWEEP_BEAMS = [1, 2]\n",
+    "SWEEP_BATCHES = [64, 96]\n",
+    "SWEEP_WINDOWS = [4, 8, 16]\n",
+    "SWEEP_PROGRESS_SECONDS = 999999\n",
+    "\n",
+    "def _float_or_none(value):\n",
+    "    try:\n",
+    "        return float(value)\n",
+    "    except Exception:\n",
+    "        return None\n",
+    "\n",
+    "\n",
+    "if RUN_SWEEP:\n",
+    "    sweep_rows = []\n",
+    "    for beam in SWEEP_BEAMS:\n",
+    "        for batch in SWEEP_BATCHES:\n",
+    "            for window in SWEEP_WINDOWS:\n",
+    "                label = f\"beam{beam}-batch{batch}-window{window}-{'1gpu' if SWEEP_SINGLE_GPU else 'allgpu'}\"\n",
+    "                summary = run_benchmark_once(\n",
+    "                    label=label,\n",
+    "                    beam=beam,\n",
+    "                    batch_size=str(batch),\n",
+    "                    window_multiplier=str(window),\n",
+    "                    use_single_gpu=SWEEP_SINGLE_GPU,\n",
+    "                    progress_seconds=SWEEP_PROGRESS_SECONDS,\n",
+    "                )\n",
+    "                done = summary[\"done\"]\n",
+    "                profile = summary[\"profile\"]\n",
+    "                sweep_rows.append({\n",
+    "                    \"label\": label,\n",
+    "                    \"beam\": beam,\n",
+    "                    \"batch\": batch,\n",
+    "                    \"window\": window,\n",
+    "                    \"chunks_s\": _float_or_none(done.get(\"chunks_s\")),\n",
+    "                    \"chars_s\": _float_or_none(done.get(\"chars_s\")),\n",
+    "                    \"translate_s\": _float_or_none(done.get(\"translate_s\")),\n",
+    "                    \"ct2_infer_s\": _float_or_none(profile.get(\"ct2_infer_s\")),\n",
+    "                    \"decode_s\": _float_or_none(profile.get(\"decode_s\")),\n",
+    "                })\n",
+    "\n",
+    "    sweep_rows = sorted(sweep_rows, key=lambda row: row[\"chars_s\"] or 0, reverse=True)\n",
+    "    print(\"\\n--- sweep summary (best first) ---\")\n",
+    "    for row in sweep_rows:\n",
+    "        print(\n",
+    "            f\"{row['label']} chars_s={row['chars_s']} chunks_s={row['chunks_s']} \"\n",
+    "            f\"translate_s={row['translate_s']} ct2_infer_s={row['ct2_infer_s']} decode_s={row['decode_s']}\"\n",
+    "        )\n",
+    "else:\n",
+    "    print(\"RUN_SWEEP=False. Đổi thành True để chạy sweep batch/window/beam.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "## Đọc kết quả\n",
     "\n",
@@ -186,9 +400,13 @@
     "- `chunk_s`: thời gian chia chunk và đếm token.\n",
     "- `decode_s`: thời gian decode output.\n",
     "- `tokenize_wait_s`: thời gian GPU phải chờ tokenization. Nếu cao trên Colab/Kaggle, CPU đang nghẽn.\n",
-    "- `BENCH_DONE chars_s`: tốc độ chữ Hán/giây tính trên thời gian dịch."
-   ]
-  }
+    "- `BENCH_RUNTIME`: Python/platform và số GPU CT2 nhìn thấy.\n",
+    "- `BENCH_PACKAGES`: version package quan trọng; khác version CT2/SentencePiece có thể làm lệch tốc độ.\n",
+    "- `BENCH_ENV`: cấu hình hiệu năng thật được truyền vào subprocess benchmark.\n",
+    "- `BENCH_DONE chars_s`: tốc độ chữ Hán/giây tính trên thời gian dịch.\n",
+    "- Fair test Kaggle vs Colab: đặt `USE_SINGLE_GPU_FOR_FAIR_TEST=True`, `FAIR_GPU_INDICES=\"0\"`; nếu `WINDOW_MULTIPLIER=\"\"`, notebook tự dùng `FAIR_WINDOW_MULTIPLIER=\"16\"`."
+   ]
+  }
  ],
  "metadata": {
   "kernelspec": {
@@ -203,4 +421,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

hachimimt-local.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9c6bbd4c77e606287b84fbcfbe99d6a47288cb7135f1fe650af8c6fdc0f2cc0f
-size 102609
+oid sha256:ccf2a1d7a24a9226c257f5fe5c45b68a2bfd7a38333f6e75dcc537dbf2feb102
+size 105893

src/benchmark_file.py

@@ -3,6 +3,9 @@
 from __future__ import annotations
 
 import argparse
+import importlib.metadata
+import os
+import platform
 import time
 from pathlib import Path
 
@@ -17,6 +20,69 @@ from text_preprocess import (
 from translator import Backend, HachimiTranslator
 
 
+TRACKED_ENV_KEYS = (
+    "CUDA_VISIBLE_DEVICES",
+    "HACHIMIMT_GPU_INDICES",
+    "HACHIMIMT_AUTO_ALL_GPUS",
+    "HACHIMIMT_BATCH_SIZE",
+    "HACHIMIMT_THREADS",
+    "HACHIMIMT_TOKENIZE_WORKERS",
+    "HACHIMIMT_TOKENIZE_JOB_SIZE",
+    "HACHIMIMT_CT2_BATCH_TYPE",
+    "HACHIMIMT_CT2_WINDOW_MULTIPLIER",
+    "HACHIMIMT_INTER_THREADS",
+    "HACHIMIMT_COMPUTE_TYPE",
+)
+
+
+TRACKED_PACKAGES = (
+    "ctranslate2",
+    "sentencepiece",
+    "tokenizers",
+    "huggingface_hub",
+    "torch",
+    "transformers",
+    "gradio",
+)
+
+
+def _safe_field(value: object) -> str:
+    text = str(value)
+    return text.replace("\\", "/").replace(" ", "_").replace("\n", "_")
+
+
+def _package_version(name: str) -> str:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return "missing"
+
+
+def _ct2_cuda_device_count() -> int | str:
+    try:
+        import ctranslate2
+
+        return ctranslate2.get_cuda_device_count()
+    except Exception as exc:
+        return f"error:{type(exc).__name__}"
+
+
+def _print_runtime_context() -> None:
+    runtime_parts = [
+        f"python={_safe_field(platform.python_version())}",
+        f"platform={_safe_field(platform.platform())}",
+        f"processor={_safe_field(platform.processor() or 'unknown')}",
+        f"ct2_cuda_devices={_ct2_cuda_device_count()}",
+    ]
+    print("BENCH_RUNTIME " + " ".join(runtime_parts), flush=True)
+
+    package_parts = [f"{name}={_safe_field(_package_version(name))}" for name in TRACKED_PACKAGES]
+    print("BENCH_PACKAGES " + " ".join(package_parts), flush=True)
+
+    env_parts = [f"{key}={_safe_field(os.environ.get(key, '<unset>'))}" for key in TRACKED_ENV_KEYS]
+    print("BENCH_ENV " + " ".join(env_parts), flush=True)
+
+
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("path", type=Path, help="Input .txt file")
@@ -36,6 +102,7 @@ def main() -> None:
     profile = detect_hardware_profile()
     print(f"BENCH_START file={args.path}", flush=True)
     print(f"PROFILE {profile.summary}", flush=True)
+    _print_runtime_context()
 
     read_start = time.perf_counter()
     text = read_text_file(args.path)