Helios/_DEV2/run_bench.sh

#!/bin/bash
# =============================================================================
#  Helios Benchmark Inference Runner
#  用法: bash run_bench.sh [--gpus 5 6 7] [--prompt_range 0-50] [--num_frames 240]
#                         [--version base] [--version mid distilled]
#  默认使用所有可见 GPU；默认跑全部版本（base/mid/distilled），也可手动指定版本
#  同一时刻只跑一个版本；若有多张卡，会先扫描输出目录，只把缺失 case 均分到多张卡并行
#  低显存: LOW_VRAM=1 bash run_bench.sh
# =============================================================================
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
if [[ -n "${PYTHON:-}" ]]; then
    PYTHON_BIN="${PYTHON}"
elif command -v python3 >/dev/null 2>&1; then
    PYTHON_BIN="$(command -v python3)"
elif command -v python >/dev/null 2>&1; then
    PYTHON_BIN="$(command -v python)"
else
    echo "Python interpreter not found. Set PYTHON=/path/to/python." >&2
    exit 1
fi

GPUS=()
PROMPT_START="${PROMPT_START:-0}"
PROMPT_END="${PROMPT_END:-100}"
NUM_FRAMES="${NUM_FRAMES:-}"
VERSIONS=(base mid distilled)
OUTPUT_ROOT="${OUTPUT_ROOT:-}"
PROMPT_FILE="${PROMPT_FILE:-${SCRIPT_DIR}/demo_data/MovieGenVideoBench_extended.txt}"
LOW_VRAM="${LOW_VRAM:-0}"

discover_gpus() {
    if ! command -v nvidia-smi >/dev/null 2>&1; then
        echo "nvidia-smi not found; use --gpus to specify GPU ids explicitly." >&2
        exit 1
    fi

    mapfile -t GPUS < <(nvidia-smi --query-gpu=index --format=csv,noheader,nounits)
    if [[ ${#GPUS[@]} -eq 0 ]]; then
        echo "No GPUs found." >&2
        exit 1
    fi
}

while [[ $# -gt 0 ]]; do
    case "$1" in
        --gpus)        shift; GPUS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do GPUS+=("$1"); shift; done ;;
        --prompt_range)
            if [[ ! "$2" =~ ^([0-9]+)-([0-9]+)$ ]]; then
                echo "Invalid --prompt_range: $2 (expected START-END, e.g. 0-50)" >&2
                exit 1
            fi
            PROMPT_START="${BASH_REMATCH[1]}"
            PROMPT_END="${BASH_REMATCH[2]}"
            shift 2
            ;;
        --prompt_start) PROMPT_START="$2"; shift 2 ;;
        --prompt_end)   PROMPT_END="$2"; shift 2 ;;
        --num_frames)  NUM_FRAMES="$2";  shift 2 ;;
        --version)     shift; VERSIONS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do VERSIONS+=("$1"); shift; done ;;
        --output_root) OUTPUT_ROOT="$2"; shift 2 ;;
        --prompt_file) PROMPT_FILE="$2"; shift 2 ;;
        *) echo "Unknown option: $1"; exit 1 ;;
    esac
done

if [[ ${#GPUS[@]} -eq 0 ]]; then
    discover_gpus
fi

if [[ ${#VERSIONS[@]} -eq 0 ]]; then
    echo "No versions specified. Use --version base [mid distilled]." >&2
    exit 1
fi

if [[ ! "${PROMPT_START}" =~ ^[0-9]+$ ]] || [[ ! "${PROMPT_END}" =~ ^[0-9]+$ ]]; then
    echo "prompt_start and prompt_end must be non-negative integers." >&2
    exit 1
fi

if (( PROMPT_END <= PROMPT_START )); then
    echo "prompt_end must be greater than prompt_start." >&2
    exit 1
fi

if [[ -z "${OUTPUT_ROOT}" ]]; then
    if [[ -n "${NUM_FRAMES}" ]]; then
        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_${NUM_FRAMES}"
    else
        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_default"
    fi
fi

echo "============================================================"
echo "  Helios Benchmark Inference"
echo "  $(date '+%Y-%m-%d %H:%M:%S')"
echo "  Python: ${PYTHON_BIN}"
echo "  GPUs: ${GPUS[*]}  |  Prompt range: ${PROMPT_START}-${PROMPT_END}  |  Versions: ${VERSIONS[*]}"
[[ -n "${NUM_FRAMES}" ]] && echo "  Frames: ${NUM_FRAMES}"
echo "  Prompt file: ${PROMPT_FILE}"
echo "  Output: ${OUTPUT_ROOT}"
echo "============================================================"

mkdir -p "${OUTPUT_ROOT}"

if [[ ! -f "${PROMPT_FILE}" ]]; then
    echo "Prompt file not found: ${PROMPT_FILE}" >&2
    exit 1
fi

TOTAL_PROMPTS=$(awk 'NF {count++} END {print count + 0}' "${PROMPT_FILE}")
if (( PROMPT_START >= TOTAL_PROMPTS )); then
    echo "prompt_start (${PROMPT_START}) is out of range; prompt file has ${TOTAL_PROMPTS} non-empty prompts." >&2
    exit 1
fi

if (( PROMPT_END > TOTAL_PROMPTS )); then
    echo "prompt_end (${PROMPT_END}) exceeds total prompts (${TOTAL_PROMPTS}); clamping to ${TOTAL_PROMPTS}."
    PROMPT_END="${TOTAL_PROMPTS}"
fi

EXTRA=()
if [[ "${LOW_VRAM}" == "1" ]]; then
    EXTRA+=(--enable_low_vram_mode)
fi
if [[ -n "${NUM_FRAMES}" ]]; then
    EXTRA+=(--num_frames "${NUM_FRAMES}")
fi

EXIT_CODE=0
WORKER_PIDS=()
WORKER_GPUS=()
WORKER_SHARDS=()

prepare_missing_shards() {
    local version="$1"
    local shard_dir="${OUTPUT_ROOT}/shards/${version}_${PROMPT_START}_${PROMPT_END}_$$"
    mkdir -p "${shard_dir}"

    "${PYTHON_BIN}" - \
        "${PROMPT_FILE}" \
        "${OUTPUT_ROOT}" \
        "${version}" \
        "${PROMPT_START}" \
        "${PROMPT_END}" \
        "${#GPUS[@]}" \
        "${shard_dir}" <<'PY'
import os
import re
import sys
from pathlib import Path

prompt_file = Path(sys.argv[1])
output_root = Path(sys.argv[2])
version = sys.argv[3]
prompt_start = int(sys.argv[4])
prompt_end = int(sys.argv[5])
gpu_count = int(sys.argv[6])
shard_dir = Path(sys.argv[7])

with prompt_file.open("r", encoding="utf-8") as f:
    prompts = [line.strip() for line in f if line.strip()]

def sanitize_filename(text, max_len=80):
    text = text.strip().lower()
    text = re.sub(r"[^a-z0-9]+", "_", text)
    text = text.strip("_")
    return text[:max_len]

missing = []
existing = 0
version_dir = output_root / "by_version" / version
for idx in range(prompt_start, prompt_end):
    slug = sanitize_filename(prompts[idx])
    video_path = version_dir / f"{idx:04d}_{slug}.mp4"
    if video_path.is_file() and video_path.stat().st_size > 0:
        existing += 1
    else:
        missing.append(idx)

print(
    f"[scan] version={version} range={prompt_start}-{prompt_end} "
    f"existing={existing} missing={len(missing)} output={version_dir}",
    file=sys.stderr,
)

if not missing:
    sys.exit(0)

active_workers = min(gpu_count, len(missing))
base_chunk = len(missing) // active_workers
remainder = len(missing) % active_workers
offset = 0

for shard_idx in range(active_workers):
    shard_size = base_chunk + (1 if shard_idx < remainder else 0)
    shard_indices = missing[offset:offset + shard_size]
    offset += shard_size
    shard_path = shard_dir / f"shard_{shard_idx:02d}.txt"
    shard_path.write_text(
        "".join(f"{idx}\n" for idx in shard_indices),
        encoding="utf-8",
    )
    print(shard_path)
    print(
        f"[shard] version={version} shard={shard_idx} count={len(shard_indices)} "
        f"indices={shard_indices[0]}-{shard_indices[-1]} file={shard_path}",
        file=sys.stderr,
    )
PY
}

launch_job() {
    local version="$1"
    local gpu="$2"
    local shard_file="$3"
    local shard_id
    shard_id="$(basename "${shard_file}" .txt)"
    local timing_file="${OUTPUT_ROOT}/timing_${version}_${shard_id}.txt"

    echo "[launch] version=${version} gpu=${gpu} shard=${shard_id} indices=${shard_file} output=${OUTPUT_ROOT}"
    "${PYTHON_BIN}" "${SCRIPT_DIR}/bench_infer.py" \
        --prompt_file  "${PROMPT_FILE}" \
        --prompt_start "${PROMPT_START}" \
        --prompt_end   "${PROMPT_END}" \
        --prompt_indices_file "${shard_file}" \
        --output_root  "${OUTPUT_ROOT}" \
        --timing_file  "${timing_file}" \
        --version      "${version}" \
        --gpu          "${gpu}" \
        "${EXTRA[@]}" &

    WORKER_PIDS+=("$!")
    WORKER_GPUS+=("${gpu}")
    WORKER_SHARDS+=("${shard_id}")
}

wait_for_current_version() {
    local version="$1"
    for idx in "${!WORKER_PIDS[@]}"; do
        local pid="${WORKER_PIDS[$idx]}"
        local gpu="${WORKER_GPUS[$idx]}"
        local shard_id="${WORKER_SHARDS[$idx]}"
        if wait "${pid}"; then
            echo "[done] ${version} finished on gpu=${gpu} shard=${shard_id}"
        else
            echo "[fail] ${version} failed on gpu=${gpu} shard=${shard_id}"
            EXIT_CODE=1
        fi
    done
    WORKER_PIDS=()
    WORKER_GPUS=()
    WORKER_SHARDS=()
}

for version in "${VERSIONS[@]}"; do
    echo ""
    echo "-------------------- version=${version} --------------------"
    mapfile -t SHARD_FILES < <(prepare_missing_shards "${version}")
    if (( ${#SHARD_FILES[@]} == 0 )); then
        echo "[skip] version=${version} has no missing cases in ${PROMPT_START}-${PROMPT_END}"
        continue
    fi

    for worker_idx in "${!SHARD_FILES[@]}"; do
        launch_job "${version}" "${GPUS[$worker_idx]}" "${SHARD_FILES[$worker_idx]}"
    done
    wait_for_current_version "${version}"
done

echo ""
echo "Done. Per-shard timing reports are under ${OUTPUT_ROOT}/timing_<version>_shard_<id>.txt"

exit ${EXIT_CODE:-0}