#!/usr/bin/env bash
# OMEGA-Messung: Qwen3.8-27B Q8_0 — unser Produktivmodell — mit vollem
# Reasoning gegen MATH-500, mit der Vorgabe, dass KEINE Aufgabe am Token-
# Limit abbricht.
#
# Zwei Stufen, weil ein geratenes Limit genau der Fehler war, der den ersten
# Mathe-Durchgang entwertet hat:
#
#   Stufe 1  Bedarfsmessung an 12 Aufgaben mit absichtlich absurdem Budget
#            (24000 Token). Daraus ergibt sich, was Reasoning wirklich braucht.
#   Stufe 2  Hauptlauf mit dem gemessenen Bedarf plus Sicherheitsaufschlag.
#
# Kontext 40960 statt 16384: die Ausgabe allein kann 24000 Token belegen, ein
# 16K-Kontext waere vorher voll. Kostet VRAM, ist aber bei 27 GB Modell auf
# 60 GB machbar.
set -uo pipefail

# Schuetzt die Produktion: PropellerA (:8290) und gemma-de (:8270) sind
# ebenfalls llama-server. Siehe lib_testserver.sh.
. /mnt/models/qwen38-prep/lib_testserver.sh

PREP=/mnt/models/qwen38-prep
BIN=/mnt/models/bin/llama-server
MODELL=/mnt/models/PropellerA-models/qwen3.8-27b-Q8_0.gguf
DRAFT=/mnt/models/PropellerA-models/qwen3.8-27b-MTP-Q8_0.gguf
PORT=8291
CTX=${CTX:-40960}
GRENZE=${GRENZE:-150}
ERG=$PREP/omega
mkdir -p "$ERG"
echo $$ > "$PREP/.runner-omega.pid"
trap 'rm -f "$PREP/.runner-omega.pid"' EXIT

stop_server() {
for pid in $(testserver_pids); do kill -TERM "$pid" 2>/dev/null; done
for i in $(seq 1 25); do [ -n "$(testserver_pids)" ] || break; sleep 1; done
for pid in $(testserver_pids); do kill -9 "$pid" 2>/dev/null; done
sleep 3
}

starte() {
stop_server
# MIT MTP-Draft, anders als die uebrigen Vergleichslaeufe. Begruendung: hier
# wird nicht die Rate verglichen, sondern eine Quote gemessen — spekulatives
# Dekodieren aendert die Ausgabe nicht, es erzeugt sie nur schneller (Entwuerfe
# werden nur uebernommen, wenn sie mit dem Zielmodell uebereinstimmen). Bei
# Denktext liegt die Trefferquote hoch, das halbiert die Laufzeit ungefaehr.
nohup "$BIN" -m "$MODELL" --host 127.0.0.1 --port "$PORT" \
--ctx-size "$CTX" --parallel 1 --n-gpu-layers 99 --tensor-split 1,1,1 \
--cache-type-k q8_0 --cache-type-v q8_0 --flash-attn on --jinja \
-md "$DRAFT" --spec-type draft-mtp --spec-draft-n-max 3 --spec-draft-ngl 99 \
--alias omega > "$ERG/server.log" 2>&1 &
for i in $(seq 1 240); do
curl -s -m 3 "http://127.0.0.1:$PORT/health" 2>/dev/null | grep -q ok && return 0
sleep 2
done
echo "  SERVER KAM NICHT HOCH:"
grep -iE "error|failed|out of memory" "$ERG/server.log" | tail -5
return 1
}

echo "=== OMEGA: Qwen3.8-27B Q8_0, volles Reasoning, MATH-500 ==="
echo "Kontext $CTX, $GRENZE Aufgaben"
starte || exit 1
echo "  bereit, VRAM: $(nvidia-smi --query-gpu=memory.used --format=csv,noheader|tr '\n' ' ')"

echo
echo "--- Stufe 1: Bedarfsmessung (12 Aufgaben, Budget 24000) ---"
/mnt/models/skinnyJoe-venv/bin/python "$PREP/bench_mathe.py" \
--port "$PORT" --modell "Bedarfsmessung" --satz math500 --grenze 12 \
--reasoning --effort xhigh --max-tokens 24000 --timeout 2400 \
--out "$ERG/bedarf.json" 2>&1 | tail -6

# Das 90.-Perzentil des tatsaechlichen Bedarfs plus 50 Prozent Aufschlag.
# Nicht der Mittelwert: die Verteilung hat einen langen Schwanz, und genau
# der laeuft sonst wieder ins Limit.
BUDGET=$(/mnt/models/skinnyJoe-venv/bin/python - <<'PY'
import json, math
d = json.load(open("/mnt/models/qwen38-prep/omega/bedarf.json"))
t = sorted(x["tokens"] for x in d["aufgaben"] if x["tokens"] > 0)
if not t:
    print(16000)
else:
    p90 = t[min(len(t) - 1, int(len(t) * 0.9))]
    print(max(8000, min(30000, int(p90 * 1.5 / 1000) * 1000)))
PY
)
echo "  gemessener Bedarf -> Budget für den Hauptlauf: $BUDGET Token"

echo
echo "--- Stufe 2: Hauptlauf ---"
/mnt/models/skinnyJoe-venv/bin/python "$PREP/bench_mathe.py" \
--port "$PORT" --modell "Qwen3.8-27B Q8_0 · volles Reasoning" \
--satz math500 --grenze "$GRENZE" --reasoning --effort xhigh \
--max-tokens "$BUDGET" --timeout 3600 \
--out "$ERG/omega-reasoning.json" 2>&1 | tail -10

stop_server
echo
echo "=== $(date '+%T') Omega fertig ==="
/mnt/models/skinnyJoe-venv/bin/python - <<'PY'
import json, os
p = "/mnt/models/qwen38-prep/omega/omega-reasoning.json"
v = "/mnt/models/qwen38-prep/mathe-math500/q38-q8.json"
if os.path.exists(p):
    o = json.load(open(p))
    print(f"  mit Reasoning:  {o['bestanden']}/{o['n']} = {o['quote']}%  "
          f"({o['am_limit']} am Limit, {o['tokens_je_aufgabe']:.0f} Token/Aufgabe)")
    if os.path.exists(v):
        a = json.load(open(v))
        print(f"  ohne Reasoning: {a['bestanden']}/{a['n']} = {a['quote']}%  "
              f"({a['am_limit']} am Limit, {a['tokens_je_aufgabe']:.0f} Token/Aufgabe)")
        print(f"  Unterschied:    {o['quote'] - a['quote']:+.1f} Punkte bei "
              f"{o['tokens_je_aufgabe']/max(a['tokens_je_aufgabe'],1):.1f}-fachem Token-Aufwand")
PY