#!/bin/bash
# Pilota GPU della correzione 2 (card t_caa8225d, BRIEF-PILOT-C2-GPU): UN blocco GPU su PC4070TI <= MAXSEC (4 h).
# Adattato da agentlongbench/scripts/gpu_block_alb_seq.sh a run_alb_v2.py (+ meter.py interno) e proxy 0.3.5.
#  1) controlli: GPU, RAM disponibile >= 20 GB, disco libero su /mnt/mneme-nvme;
#  2) ctl-k15.sh stop (Strata a 15 esperti, prova non di produzione) PRIMA del lock; poi flock del lock GPU;
#  3) per ogni finestra (nell'ordine della lista) un motore Strata 0.1.40 di produzione (strata-prod.json, 10 esperti,
#     STRATA_EXPERTS_USED tolto dall'ambiente) su :8297 con --max-context = finestra, KV int8,
#     --kv-resident = min(finestra, 32768);
#  4) lavori "<policy> <window> <file> <qid>" in ordine; result.json presente = saltato (ripresa);
#     un lavoro non parte se il tempo residuo < START_MARGIN;
#  5) dopo ogni lavoro check_c2.py (regole d'arresto del brief) e /health del motore; alla prima: STOP;
#  6) trap EXIT: chiude banco/proxy/motore del blocco, rilascia il lock, ctl-prod.sh start (PRODUZIONE a 10 esperti),
#     verifica :8095/health, :8096/health e una domanda di prova (19x21) attraverso :8096 (proxy 0.3.4 installato,
#     NON modificato).
# Uso: gpu_block_c2.sh LISTA OUTDIR     (DRY=1: a secco, non tocca k15, produzione, lock vero né GPU)
set -u
B=/mnt/mneme-nvme/proxy-ideas/alb-bench-v2
S=/mnt/mneme-nvme/strata-0140
K15=/mnt/mneme-nvme/strata-k15-run/ctl-k15.sh
LOCK=/mnt/mneme-nvme/.flash-next-gpu.lock
LIST=$1; OUT=$2
NAME=$(basename $LIST .txt)
MAXSEC=${MAXSEC:-14400}
START_MARGIN=${START_MARGIN:-900}
DRY=${DRY:-0}
EPORT=8297; PPORT=8496
P=$B/venv/bin/python
export PROXY_SRC=$B/alb/src/mnemonic-proxy-035
L=$B/logs; mkdir -p $L $OUT
LOG=$L/gpu-$NAME.log; [ "$DRY" = 1 ] && LOG=$L/gpu-$NAME-dry.log
exec >> $LOG 2>&1
echo "=== $(date -Is) blocco $NAME (DRY=$DRY, MAXSEC=$MAXSEC) -> $OUT"
echo "proxy: $(git -C $PROXY_SRC log --oneline -1)"
STATE=$OUT/.check-state.json; rm -f $STATE
cleanup() {
  rc=$?
  echo "=== $(date -Is) cleanup rc=$rc"
  pkill -f "alb-bench-v2/scripts/run_alb_v2.py" 2>/dev/null
  pkill -f "alb-bench-v2/venv/bin/mnemonic-proxy.*--port $PPORT" 2>/dev/null
  if [ -f $L/eng-$NAME.pid ]; then
    E=$(cat $L/eng-$NAME.pid); kill -- -$E 2>/dev/null
    for i in $(seq 30); do kill -0 $E 2>/dev/null || break; sleep 1; done
    kill -9 -- -$E 2>/dev/null; rm -f $L/eng-$NAME.pid
  fi
  sleep 3
  exec 9>&-
  if [ "$DRY" = 0 ]; then
    nvidia-smi --query-gpu=memory.used --format=csv,noheader
    echo "=== riavvio PRODUZIONE (10 esperti)"
    env -u STRATA_EXPERTS_USED $S/ctl-prod.sh start
    ok=0; for i in $(seq 180); do curl -s -m 2 127.0.0.1:8095/health | grep -q ok && { ok=1; break; }; sleep 5; done
    $S/ctl-prod.sh status
    echo "8095 ok=$ok"
    tr '\0' ' ' < /proc/$(pgrep -f "strata-0140/src/build-cuda/strata" | head -1)/cmdline 2>/dev/null | head -c 600; echo
    grep -c STRATA_EXPERTS_USED /proc/$(pgrep -f "strata-0140/src/build-cuda/strata" | head -1)/environ 2>/dev/null
    echo "8096 health: $(curl -s -m 5 127.0.0.1:8096/health)"
    curl -s -m 300 127.0.0.1:8096/v1/chat/completions -H 'Content-Type: application/json' \
      -d '{"messages":[{"role":"user","content":"Quanto fa 19x21? Rispondi solo con il numero."}],"max_tokens":512}' \
      > $L/prova-8096-$NAME.json
    echo "prova 8096: $(python3 -c "import json;d=json.load(open('$L/prova-8096-$NAME.json'));print(repr(d['choices'][0]['message'].get('content')))" 2>&1)"
  fi
  echo "=== $(date -Is) fine blocco $NAME"
}
trap cleanup EXIT
trap 'exit 4' INT TERM
nvidia-smi --query-gpu=memory.used,utilization.gpu,power.limit,driver_version --format=csv
MEMA=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
DISK=$(df -B1G --output=avail /mnt/mneme-nvme | tail -1 | tr -d ' ')
echo "RAM disponibile ${MEMA} GB, disco libero ${DISK} GB"
if [ "$DRY" = 1 ]; then
  LOCK=$L/dry.lock
else
  echo "=== stop Strata k15 (prima del lock)"
  $K15 stop; $K15 status
  for i in $(seq 60); do pgrep -f "strata-k15/build-cuda/strata" > /dev/null || break; sleep 1; done
  pgrep -f "strata-k15/build-cuda/strata" && { echo "k15 ANCORA VIVO"; exit 2; }
  sleep 5
  nvidia-smi --query-gpu=memory.used,utilization.gpu --format=csv,noheader
  MEMA=$(awk '/MemAvailable/ {print int($2/1048576)}' /proc/meminfo)
  echo "RAM disponibile dopo stop k15: ${MEMA} GB"
fi
[ "$MEMA" -ge 20 ] || { echo "RAM disponibile < 20 GB"; [ "$DRY" = 0 ] && exit 2; }
[ "$DISK" -ge 20 ] || { echo "disco libero < 20 GB"; exit 2; }
exec 9>$LOCK
flock -w 60 9 || { echo "LOCK OCCUPATO da $(fuser $LOCK 2>&1)"; exit 2; }
echo "lock preso"
if [ "$DRY" = 0 ]; then
  pgrep -f "build-cuda/strata" && { echo "un motore Strata e' ancora vivo"; exit 2; }
  nvidia-smi --query-gpu=memory.used --format=csv,noheader
fi
mkcfg() {
  python3 - "$1" <<'EOF'
import json, sys
w = int(sys.argv[1])
d = json.load(open("/mnt/mneme-nvme/strata-0140/strata-prod.json"))
a = d["args"]
a[a.index("--max-context") + 1] = str(w)
a[a.index("--kv") + 1] = "int8"
a[a.index("--kv-resident") + 1] = str(min(w, 32768))
d.update(port=8297, log="/mnt/mneme-nvme/proxy-ideas/alb-bench-v2/logs/strata-engine-%d.log" % w)
json.dump(d, open("/mnt/mneme-nvme/proxy-ideas/alb-bench-v2/logs/strata-%d.json" % w, "w"), indent=1)
print("engine cfg", a)
EOF
}
wait_up() { for i in $(seq $(( $2 / 5 ))); do curl -s -m 2 $1/health | grep -q ok && return 0; sleep 5; done; echo "MOTORE NON PRONTO"; return 1; }
stop_engine() {
  [ -f $L/eng-$NAME.pid ] || return 0
  E=$(cat $L/eng-$NAME.pid); kill -- -$E 2>/dev/null
  for i in $(seq 30); do kill -0 $E 2>/dev/null || break; sleep 1; done
  kill -9 -- -$E 2>/dev/null; rm -f $L/eng-$NAME.pid; sleep 3
}
start_engine() {
  local W=$1
  mkcfg $W
  if [ "$DRY" = 0 ]; then
    cd $S/src
    env -u STRATA_EXPERTS_USED setsid /mnt/mneme-nvme/strata-ab/Strata/.venv/bin/python serve/server.py --engine strata \
      --config $L/strata-$W.json --host 127.0.0.1 --port $EPORT >> $L/strata-$NAME-$W.log 2>&1 9>&- &
    echo $! > $L/eng-$NAME.pid
    wait_up http://127.0.0.1:$EPORT 900 || return 1
    curl -s 127.0.0.1:$EPORT/v1/status > $L/strata-status-$NAME-$W.json
    nvidia-smi --query-gpu=memory.used --format=csv,noheader >> $L/vram-idle-$NAME-$W.txt
    cd $B
  fi
  echo "=== $(date -Is) motore pronto W=$W"
}
work() {
  CUR=
  while read -r POL WW F Q <&3; do
    [ -z "${POL:-}" ] && continue; case "$POL" in \#*) continue;; esac
    R=$OUT/$POL/$(echo $F | cut -d/ -f1-2)/$Q/result.json
    [ -f $R ] && { echo "salto $POL $F $Q"; continue; }
    if [ $(( MAXSEC - SECONDS )) -lt $START_MARGIN ]; then
      echo "=== $(date -Is) tempo residuo $(( MAXSEC - SECONDS ))s < START_MARGIN: blocco chiuso"; return 0
    fi
    if [ "$WW" != "$CUR" ]; then
      [ "$DRY" = 0 ] && stop_engine
      start_engine $WW || return 1
      CUR=$WW
    fi
    echo "=== $(date -Is) $POL W=$WW $F $Q"
    [ "$DRY" = 1 ] && { [ -f $B/alb/data/benchmark/$F ] || { echo "FILE ASSENTE $F"; return 3; }; continue; }
    nice -n 5 $P -W ignore $B/scripts/run_alb_v2.py --file $B/alb/data/benchmark/$F --qid $Q --policy $POL \
      --engine-url http://127.0.0.1:$EPORT --window $WW --out $OUT --proxy-port $PPORT --engine-port $EPORT \
      9>&- 3<&- < /dev/null | tail -1 | tee -a $OUT/results.jsonl
    [ -f $R ] || { echo "STOP: result.json assente ($POL $Q)"; return 5; }
    python3 $B/scripts/check_c2.py $R $STATE 3<&- 9>&- || return 9
    curl -s -m 5 127.0.0.1:$EPORT/health | grep -q ok || { echo "STOP: MOTORE GIU"; return 6; }
  done 3< $LIST
  [ "$DRY" = 0 ] && stop_engine
  return 0
}
work &
WK=$!
( exec 9>&-; sleep $(( MAXSEC - SECONDS )); echo "TEMPO MASSIMO DEL BLOCCO"; kill -TERM $WK 2>/dev/null;
  pkill -f "alb-bench-v2/scripts/run_alb_v2.py" ) &
T=$!
wait $WK; rc=$?
kill $T 2>/dev/null; pkill -P $T 2>/dev/null
echo "lavoro rc=$rc"
exit $rc