Scripts IA

Test de vitesse batch / ubatch via llama.cpp

#!/usr/bin/env bash

set -u

LLAMA_BENCH="/opt/llama.cpp/build/bin/llama-bench"
MODEL="/opt/models/Qwen3.8-27B/UD-Q4_K_XL/Qwen3.8-27B-UD-Q4_K_XL.gguf"

OUT="/tmp/muse_batch_bench.csv"

# Taille du prompt de benchmark.
# 8192 suffit largement pour comparer b/ub sans faire durer chaque test des minutes.
PROMPT=8192

# Nombre de répétitions par couple.
REPS=3

BATCHES=(512 1024 2048)
UBATCHES=(128 256 512 1024)

echo "batch,ubatch,pp_tps,gpu0_peak_mib,gpu1_peak_mib,status" > "$OUT"

echo
echo "============================================================"
echo " Muse-Glimmer batch / ubatch benchmark"
echo "============================================================"
echo "Model : $MODEL"
echo "Prompt: $PROMPT tokens"
echo "Runs  : $REPS"
echo


for B in "${BATCHES[@]}"; do
    for UB in "${UBATCHES[@]}"; do

        # ubatch ne doit pas être supérieur au batch.
        if (( UB > B )); then
            continue
        fi

        echo
        echo "============================================================"
        echo "b=$B  ub=$UB"
        echo "============================================================"

        TMP_JSON=$(mktemp)
        TMP_VRAM=$(mktemp)

        #
        # Surveillance VRAM pendant le benchmark
        #
        (
            while true; do
                nvidia-smi \
                    --query-gpu=memory.used \
                    --format=csv,noheader,nounits \
                    >> "$TMP_VRAM"

                sleep 0.1
            done
        ) &

        MON_PID=$!

        #
        # Benchmark
        #
        "$LLAMA_BENCH" \
            -m "$MODEL" \
            -p "$PROMPT" \
            -n 0 \
            -r "$REPS" \
            -b "$B" \
            -ub "$UB" \
            -ngl 999 \
            -sm tensor \
            -ts 1/1 \
            -ctk q8_0 \
            -ctv q8_0 \
            -fa on \
            -o json \
            > "$TMP_JSON" 2>/tmp/muse_bench_error.log

        RC=$?

        kill "$MON_PID" 2>/dev/null
        wait "$MON_PID" 2>/dev/null

        #
        # Pic VRAM
        #
        GPU0_PEAK=$(awk 'NR%2==1 {if ($1>m) m=$1} END {print m+0}' "$TMP_VRAM")
        GPU1_PEAK=$(awk 'NR%2==0 {if ($1>m) m=$1} END {print m+0}' "$TMP_VRAM")

        if (( RC != 0 )); then
            echo "ECHEC / OOM"
            cat /tmp/muse_bench_error.log

            echo "$B,$UB,0,$GPU0_PEAK,$GPU1_PEAK,FAIL" >> "$OUT"

            rm -f "$TMP_JSON" "$TMP_VRAM"
            continue
        fi

        #
        # Récupération du débit prompt processing depuis le JSON
        #
        PP=$(python3 - "$TMP_JSON" <<'PY'
import json
import sys

with open(sys.argv[1], "r") as f:
    data = json.load(f)

if isinstance(data, dict):
    data = [data]

vals = []

for x in data:
    if x.get("n_prompt", 0) > 0:
        v = x.get("avg_ts")
        if v is not None:
            vals.append(float(v))

if vals:
    print(f"{sum(vals)/len(vals):.2f}")
else:
    print("0")
PY
)

        echo
        echo "PP       : $PP tok/s"
        echo "GPU0 peak: $GPU0_PEAK MiB"
        echo "GPU1 peak: $GPU1_PEAK MiB"

        echo "$B,$UB,$PP,$GPU0_PEAK,$GPU1_PEAK,OK" >> "$OUT"

        rm -f "$TMP_JSON" "$TMP_VRAM"

        # petite pause thermique
        sleep 3
    done
done


echo
echo
echo "============================================================"
echo " RÉSULTATS"
echo "============================================================"

column -s, -t "$OUT"

echo
echo "CSV : $OUT"

Quelques résultats avec RTX 3060 12GO

Muse Glimmer 30B (UD-Q5_K_L)

batch  ubatch  pp_tps  gpu0_peak_mib  gpu1_peak_mib  status
512    128     675.29  9047           9047           OK
512    256     723.88  9147           9147           OK
512    512     755.27  9361           9361           OK
1024   128     673.84  9047           9047           OK
1024   256     719.47  9147           9147           OK
1024   512     753.19  9361           9361           OK
1024   1024    779.98  9793           9793           OK
2048   128     672.80  9047           9047           OK
2048   256     720.20  9147           9147           OK
2048   512     753.18  9361           9361           OK
2048   1024    780.41  9793           9793           OK

512 → 1024 ne donne que ~+3,5 % de vitesse, mais coûte +432 MiB par GPU.

Gemma4 31B (UD-Q4_K_XL)

batch  ubatch  pp_tps  gpu0_peak_mib  gpu1_peak_mib  status
512    128     608.10  9463           9463           OK
512    256     647.19  9593           9593           OK
512    512     682.33  9919           9919           OK
1024   128     608.80  9463           9463           OK
1024   256     645.05  9593           9593           OK
1024   512     681.17  9919           9919           OK
1024   1024    690.45  10573          10573          OK
2048   128     607.51  9463           9463           OK
2048   256     645.92  9593           9593           OK
2048   512     681.99  9919           9919           OK
2048   1024    690.91  10573          10573          OK

512 → 1024 :

• seulement ~+1,3 % de prefill
• mais +654 MiB par GPU

-> Donc sur Gemma, ub=1024 est franchement mauvais en rendement mémoire.

Qwen 3.8 27B (UD-Q4_K_XL)

batch  ubatch  pp_tps  gpu0_peak_mib  gpu1_peak_mib  status
512    128     610.36  8491           8491           OK
512    256     667.18  8605           8605           OK
512    512     692.74  8867           8867           OK
1024   128     606.86  8491           8491           OK
1024   256     665.33  8605           8605           OK
1024   512     691.93  8867           8867           OK
1024   1024    705.83  9395           9395           OK
2048   128     608.26  8491           8491           OK
2048   256     664.28  8605           8605           OK
2048   512     691.47  8867           8867           OK
2048   1024    705.31  9395           9395           OK

Donc 512 → 1024 donne seulement environ +2 % de prefill, mais coûte +528 MiB par GPU.