#!/usr/bin/env bash
# ModelArts entrypoint:v3 机制家族的 Cycles/OptiX 渲染分片。
# 不用 BlenderProc —— cmp_render_rollout_v3.py 走的是纯 bpy,少一层依赖少一处失败点。
set -euo pipefail

# ---- bundle 从哪来
# 默认:脚本自己就住在 bundle 里(bundle 由 ModelArts 的 code_dir 从 OBS 下发)。
# ⚠️ 但**本地往 OBS 直传这条路实测走不通**:2026-08-06 传 0.38GB 的渲染 bundle,
#    40 分钟只上去 21MB(整池共享的出口带宽),照这速度要 10 小时。
#    同一个包推 HuggingFace 只用了 **17 秒**。
# 所以给出第二条路:RENDER_BUNDLE_REPO 一给,就从 HF 拉 tar.gz 解到 /cache。
# 这和生成/探针那两条链路的做法一致(容器没有 OBS 凭据,只能拉公开 HF)。
if [[ -n "${RENDER_BUNDLE_REPO:-}" ]]; then
  BUNDLE="${RENDER_BUNDLE_DIR:-/cache/render_bundle}"
  if [[ ! -f "$BUNDLE/plan.json" ]]; then
    mkdir -p "$BUNDLE"
    export HF_ENDPOINT="${HF_ENDPOINT:-https://hf-mirror.com}"
    export HF_HUB_DISABLE_XET=1
    echo "[entry] 从 HF 拉渲染 bundle:${RENDER_BUNDLE_REPO}"
    python3 - <<PY
import os, random, tarfile, time
from huggingface_hub import hf_hub_download

# ⚠️ 所有分片是**同时**起的,会在同一秒去抓同一个 374MB 文件,
# hf-mirror 直接回 429 Too Many Requests。2026-08-15 实测:4 个分片里
# shard3 当场 Failed,而且原来这里没有任何重试 —— 一次 429 就报废一张卡的整批活。
# 分片一多只会更糟(5k 那批是 16 片)。两手都要:错开起跑 + 指数退避重试。
idx = int(os.environ.get("SHARD_INDEX", "0"))
stagger = idx * 25 + random.uniform(0, 10)
print("[entry] 错开起跑:分片 %d 等 %.0fs 再拉包" % (idx, stagger), flush=True)
time.sleep(stagger)

path, last = None, None
for attempt in range(8):
    try:
        path = hf_hub_download(repo_id="${RENDER_BUNDLE_REPO}", repo_type="dataset",
                               filename="render_bundle.tar.gz", local_dir="/tmp/rbundle")
        break
    except Exception as exc:
        last = exc
        wait = min(20 * (2 ** attempt), 480) + random.uniform(0, 20)
        print("[entry] 第 %d/8 次拉包失败(%s),%.0fs 后重试:%s"
              % (attempt + 1, type(exc).__name__, wait, str(exc)[:200]), flush=True)
        time.sleep(wait)
if path is None:
    raise SystemExit("[entry] FATAL 拉包 8 次全失败,最后一次:%s" % last)

# 大小自检:hf_hub_download 断线时会把残缺文件当成功返回(权重那边吃过这个亏)
size = os.path.getsize(path)
print("[entry] 拉到 %.0f MB -> %s" % (size / 1e6, path), flush=True)
if size < 1e6:
    raise SystemExit("[entry] FATAL 包只有 %d 字节,明显是残缺文件" % size)
with tarfile.open(path) as t:
    t.extractall("${BUNDLE}")
print("[entry] 渲染 bundle 解包完成", flush=True)
PY
  fi
  # 大小核对:hf_hub_download 断线时会把残缺文件当成功返回(权重那边吃过这个亏)
  if [[ ! -f "$BUNDLE/plan.json" ]]; then
    echo "[entry] FATAL 解包后没有 plan.json,bundle 不完整"; exit 21
  fi
  NB=$(find "$BUNDLE" -name '*.npz' | wc -l)
  echo "[entry] bundle 就位:$(du -sh "$BUNDLE" | cut -f1),轨迹 $NB 条"
else
  BUNDLE="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
fi
OUT="${RENDER_OUT_DIR:-/home/ma-user/modelarts/outputs/result_0}"
RT="${RENDER_RUNTIME_ROOT:-/home/ma-user/render_rt}"
mkdir -p "$OUT" "$RT"

echo "[entry] bundle=$BUNDLE out=$OUT shard=${SHARD_INDEX:-0}/${SHARD_COUNT:-1}"
# 驱动版本要打出来:OptiX 需要足够新的驱动,拿不到 OptiX 时这是第一个要看的数。
nvidia-smi --query-gpu=index,name,memory.total,driver_version --format=csv,noheader || true
# CPU 核数同样要记:万一真退回了 CPU,能不能算得动全看这个数。
# 上一次云上 7 小时零产物,单帧摊 208 秒,比本地 CPU 还慢 —— 就得靠这个数来判断
# 到底是"退回 CPU"还是"卡住不动",两者的处置完全不同。
echo "[entry] CPU: nproc=$(nproc) 可用核=$(python3 -c 'import os;print(len(os.sched_getaffinity(0)))' 2>/dev/null || echo '?')"
free -g 2>/dev/null | sed -n 's/^Mem:/[entry] 内存(GB) 总,已用,可用:/p' || true

# ---- 解包 Blender(离线,归档在 bundle 里;不走网络)
BL="$RT/blender-4.2.1-linux-x64"
if [[ ! -x "$BL/blender" ]]; then
  ARCH="$BUNDLE/third_party/blender-4.2.1-linux-x64.tar.xz"
  [[ -f "$ARCH" ]] || { echo "[entry] FATAL 缺 Blender 归档: $ARCH"; exit 3; }
  echo "[entry] 解包 Blender ..."
  t0=$SECONDS; tar -xJf "$ARCH" -C "$RT"; echo "[entry] 解包用时 $((SECONDS-t0))s"
fi
# 镜像刻意做得很小,不带 Blender 官方二进制链接的 X11 客户端库(即使 --background 也要)。
# 用仓库里已验证的便携运行库闭包(固定版本 Ubuntu Jammy deb + sha256,
# 明确不含 libc/CUDA/NVIDIA 驱动库),只挂 LD_LIBRARY_PATH,不污染系统。
PORTLIB="$BUNDLE/third_party/portable-runtime-libs/lib"
if [[ -d "$PORTLIB" ]]; then
  export LD_LIBRARY_PATH="$PORTLIB${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
  echo "[entry] 便携运行库: $(ls "$PORTLIB" | wc -l) 个 so"
else
  echo "[entry] 警告:没有便携运行库,Blender 很可能起不来"
fi
"$BL/blender" --version | head -1

# ---- 转码分支:把已渲好的 PNG 序列编成 mp4,不渲染、不碰 GPU。
#
# 为什么并进渲染入口而不是单独一个脚本:转码要用 `$BUNDLE/tools/pilot/
# encode_png_to_mp4.py` 和 Blender 自带的 FFmpeg(镜像里没有 ffmpeg),
# 而"从 HF 拉 bundle 并解包"这一整套只在这个入口里被验证过。
# 单独写一个入口就得把那套逻辑抄一遍,迟早漂移。
#
# 为什么放在 OptiX 校验**之前**:转码是纯 CPU 活,没有 GPU 也该能跑通;
# 放在校验之后的话,一台没枚举到 OptiX 的机器会把转码作业也判死。
if [[ "${ENCODE_ONLY:-0}" == "1" ]]; then
  IN="${ENCODE_INPUT_DIR:-/home/ma-user/modelarts/inputs/frames_0}"
  echo "[entry] ==== 转码模式:$IN -> $OUT"
  [[ -d "$IN" ]] || { echo "[entry] FATAL 输入目录不存在:$IN"; exit 30; }
  NPNG=$(find "$IN" -name 'f0000.png' | wc -l)
  echo "[entry] 输入里有 $NPNG 条序列,$(du -sh "$IN" 2>/dev/null | cut -f1)"
  [[ "$NPNG" -gt 0 ]] || { echo "[entry] FATAL 一条 PNG 序列都没有"; exit 31; }
  if command -v ffmpeg >/dev/null 2>&1; then ENC=ffmpeg; else ENC="$BL/blender"; fi
  echo "[entry] 编码器 = $ENC"
  # ⚠️ 必须把渲染计划传进去:时长是按机制分档的(49/81/121 帧),
  # 用单一 --frames 去卡,短档的会被判"未渲完"而**静默跳过**,渲染白花。
  PLANARG=()
  if [[ -f "${RENDER_PLAN:-$BUNDLE/plan.json}" ]]; then
    PLANARG=(--plan "${RENDER_PLAN:-$BUNDLE/plan.json}")
    echo "[entry] 逐条帧数以计划为准:${RENDER_PLAN:-$BUNDLE/plan.json}"
  else
    echo "[entry] 警告:没有计划文件,全部按 ${ENCODE_FRAMES:-121} 帧卡,短档会被跳过"
  fi
  python3 "$BUNDLE/tools/pilot/encode_png_to_mp4.py" \
    --input "$IN" --out "$OUT" --encoder "$ENC" \
    --fps "${ENCODE_FPS:-24}" --crf "${ENCODE_CRF:-16}" \
    "${PLANARG[@]}" \
    --frames "${ENCODE_FRAMES:-121}" --workers "${ENCODE_WORKERS:-16}"
  NMP4=$(find "$OUT" -name '*.mp4' | wc -l)
  echo "[entry] 产物 $NMP4 个 mp4,合计 $(du -sh "$OUT" | cut -f1)"
  # 数量必须对得上,少一条都要报 —— 静默少产是最难查的那种失败
  [[ "$NMP4" -eq "$NPNG" ]] || { echo "[entry] FATAL 应有 $NPNG 个 mp4,只有 $NMP4"; exit 32; }
  echo "[entry] DONE"
  exit 0
fi

# ---- OptiX 硬校验:不允许静默退回 CPU
"$BL/blender" --background --python-expr "
import bpy, sys
p = bpy.context.preferences.addons['cycles'].preferences
# 每个后端都要把**完整设备表**打出来,而不只是命中的那个。
# 上一轮冒烟只打了命中项,结果 '[probe] backend=CUDA' 一行看过去像成功,
# 其实它说明的是 OptiX 一个设备都没枚举到 —— 这条信息当时被淹没了。
picked = None
for backend in ('OPTIX', 'CUDA'):
    p.compute_device_type = backend
    p.get_devices()
    allv = [(d.name, d.type) for d in p.devices]
    gpus = [d for d in p.devices if d.type == backend]
    print('[probe] %s: 全部设备=%s 命中=%d' % (backend, allv, len(gpus)))
    if gpus and picked is None:
        picked = backend
print('[probe] 选定后端=%s' % picked)
if picked is None:
    print('[probe] FATAL 没有可用 GPU 设备,Cycles 会退回 CPU')
    sys.exit(7)
if picked != 'OPTIX':
    print('[probe] 注意:OptiX 不可用,只能用 CUDA。A100 上 CUDA 比 OptiX 慢,'
          '产能测算要按实测的 CUDA 数来,不能沿用本地 OptiX 的数字')
" || { echo "[entry] FATAL OptiX/CUDA 自检失败"; exit 7; }

# ---- 逐条渲染本分片的任务
python3 - <<'PYPLAN'
import json, os, pathlib
plan = json.loads(pathlib.Path(os.environ["RENDER_PLAN"]).read_text())
si, sc = int(os.environ.get("SHARD_INDEX", 0)), int(os.environ.get("SHARD_COUNT", 1))
mine = plan["items"][si::sc]
pathlib.Path("/tmp/_mine.json").write_text(json.dumps(mine))
print(f"[entry] 本分片 {len(mine)}/{len(plan['items'])} 条")
PYPLAN

python3 - <<PYRUN
import json, os, subprocess, threading, time, pathlib, hashlib
BL = "$BL/blender"
BUNDLE = "$BUNDLE"
OUT = "$OUT"
mine = json.loads(pathlib.Path("/tmp/_mine.json").read_text())
recs = []
for it in mine:
    t0 = time.time()
    # 用 rollout 落下来的**实际生效规格**(逐条扰动已打进去);没有才退回基准规格
    spec_rel = it.get("spec_realized") or it["spec"]
    if not pathlib.Path(f"{BUNDLE}/{spec_rel}").exists():
        spec_rel = it["spec"]
    cmd = [BL, "--background", "--python", f"{BUNDLE}/tools/pilot/cmp_render_rollout_v3.py", "--",
           "--spec", f"{BUNDLE}/{spec_rel}", "--rollout", f"{BUNDLE}/{it['rollout']}",
           "--out", f"{OUT}/{it['name']}", "--engine", os.environ.get("RENDER_ENGINE", "CYCLES"),
           "--samples", os.environ.get("RENDER_SAMPLES", "256"), "--scale", "1.0",
           # persistent_data:静态几何跨帧不重建 BVH。本地 H100 实测省 29%(2.370 -> 1.688 s/帧)
           "--persistent", os.environ.get("RENDER_PERSISTENT", "1")]
    if os.environ.get("RENDER_MAX_FRAMES"):
        cmd += ["--max_frames", os.environ["RENDER_MAX_FRAMES"]]
    # 输出必须**边跑边流**,不能 capture_output 攒到最后。
    # 教训:云上那条渲染跑了 7 小时,日志里一个字都没有 —— 不是它没说话,
    # 是父进程把管子堵住了,任务结束才会吐。既然它没结束,就永远看不到。
    # 再配一个每条上限:超时就杀掉记 TIMEOUT,不允许一条把整个作业拖死。
    per_item_timeout = int(os.environ.get("RENDER_ITEM_TIMEOUT_S", "1800"))
    tail, timed_out = [], False
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
                            bufsize=1)
    # 超时必须由**独立看门狗**来判,不能写在读取输出的循环里。
    # 这是踩过的坑:第一版把判断放进 `for line in proc.stdout`,而子进程真挂住时
    # 恰恰一个字都不输出 —— 循环阻塞在 readline 上,超时那行代码永远轮不到执行。
    # 结果就是"给挂起加的超时,唯独对挂起无效"。实测那次跑到 41 分钟仍没被杀掉。
    def _watchdog():
        if not _finished.wait(per_item_timeout):
            timeout_flag.append(True)
            print(f"    [entry] 超过 {per_item_timeout}s 仍未结束,杀掉该条", flush=True)
            try:
                proc.kill()
            except Exception:
                pass
    _finished = threading.Event()
    timeout_flag = []
    wd = threading.Thread(target=_watchdog, daemon=True)
    wd.start()
    try:
        for line in proc.stdout:
            line = line.rstrip()
            tail.append(line)
            del tail[:-400]
            # Blender 每个采样都打一行,全转发会淹掉日志;只放行我们自己的标记和报错
            if ("[render]" in line or "[probe]" in line or "Error" in line
                    or "error" in line or "Traceback" in line or "FATAL" in line):
                print(f"    {line}", flush=True)
        proc.wait(timeout=60)
    except Exception as e:
        try:
            proc.kill()
        except Exception:
            pass
        print(f"    [entry] 读取子进程输出出错: {e}", flush=True)
    finally:
        _finished.set()
    timed_out = bool(timeout_flag)
    rc = proc.returncode
    dt = time.time() - t0
    fr = len(list(pathlib.Path(f"{OUT}/{it['name']}").rglob("f*.png")))
    ok = (rc == 0) and fr > 0 and not timed_out
    status = "TIMEOUT" if timed_out else ("OK" if ok else f"FAIL(rc={rc})")
    print(f"[render] {it['name']} {status} {fr} 帧 {dt:.0f}s ({dt/max(fr,1):.3f} s/帧)", flush=True)
    if not ok:
        print("---- 子进程输出尾部 ----", flush=True)
        for l in tail[-60:]:
            print("   ", l, flush=True)
    backend = next((l.split("后端 ")[1].split(":")[0] for l in tail if "Cycles 后端" in l), None)
    recs.append({**it, "frames": fr, "sec": round(dt, 1), "rc": rc, "timed_out": timed_out,
                 "backend": backend,
                 "s_per_frame": round(dt / max(fr, 1), 4), "ok": ok})
pathlib.Path(f"{OUT}/receipt_shard{os.environ.get('SHARD_INDEX','0')}.json").write_text(
    json.dumps({"shard": os.environ.get("SHARD_INDEX", "0"), "n": len(recs),
                "engine": os.environ.get("RENDER_ENGINE", "CYCLES"),
                "samples": os.environ.get("RENDER_SAMPLES", "128"),
                "items": recs}, indent=1, ensure_ascii=False))
bad = [r["name"] for r in recs if not r["ok"]]
print(f"[entry] 完成 {len(recs)-len(bad)}/{len(recs)}" + (f" 失败: {bad}" if bad else ""))
raise SystemExit(1 if bad else 0)
PYRUN
echo "[entry] DONE"