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 2048)

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=index,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 -F',' '$1+0 == 0 {gsub(/ /,"",$2); if ($2>m) m=$2} END {print m+0}' "$TMP_VRAM")
        GPU1_PEAK=$(awk -F',' '$1+0 == 1 {gsub(/ /,"",$2); if ($2>m) m=$2} 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 2x RTX 3060 12GO

Muse Glimmer 30B (UD-Q5_K_L)

batch  ubatch  pp_tps  gpu0_peak_mib  gpu1_peak_mib  status
512    128     666.88  9321           9321           OK
512    256     715.51  9421           9421           OK
512    512     746.05  9635           9635           OK
1024   128     665.82  9321           9321           OK
1024   256     713.34  9421           9421           OK
1024   512     746.39  9635           9635           OK
1024   1024    772.92  10067          10067          OK
2048   128     665.81  9321           9321           OK
2048   256     712.31  9421           9421           OK
2048   512     745.80  9635           9635           OK
2048   1024    772.98  10067          10067          OK
2048   2048    768.27  10919          10919          OK

• 1024/512 → 2048/1024 : +3,6 % de prefill pour +432 MiB/GPU
• 1024/1024 → 2048/2048 : -0,6 % de vitesse pour +852 MiB/GPU
• le sweet spot perf pur est clairement 2048/1024
• le sweet spot perf/VRAM reste plutôt 1024/512

Gemma4 31B (UD-Q4_K_XL)

batch  ubatch  pp_tps  gpu0_peak_mib  gpu1_peak_mib  status
512    128     607.79  9463           9463           OK
512    256     647.72  9593           9593           OK
512    512     682.09  9919           9919           OK
1024   128     609.18  9463           9463           OK
1024   256     645.99  9593           9593           OK
1024   512     681.69  9919           9919           OK
1024   1024    690.55  10573          10573          OK
2048   128     610.55  9463           9463           OK
2048   256     644.71  9593           9593           OK
2048   512     681.38  9919           9919           OK
2048   1024    690.48  10573          10573          OK
2048   2048    684.43  11869          11869          OK

• 512/512 → 1024/1024 : seulement +1,24 % de prefill, pour +654 MiB/GPU.
• 1024/1024 → 2048/2048 : -0,89 % de performances, tout en ajoutant +1296 MiB/GPU.
• 512/512 → 2048/2048 : seulement +0,34 % de vitesse pour +1950 MiB/GPU (!).

Qwen 3.8 27B (UD-Q4_K_XL)

batch  ubatch  pp_tps  gpu0_peak_mib  gpu1_peak_mib  status
512    128     608.64  8491           8491           OK
512    256     666.90  8605           8605           OK
512    512     693.10  8867           8867           OK
1024   128     608.03  8491           8491           OK
1024   256     664.78  8605           8605           OK
1024   512     691.75  8867           8867           OK
1024   1024    705.04  9395           9395           OK
2048   128     607.83  8491           8491           OK
2048   256     664.38  8605           8605           OK
2048   512     692.18  8867           8867           OK
2048   1024    705.58  9395           9395           OK
2048   2048    714.92  10437          10437          OK

• 512 → 1024 : +1,7 % de PP pour +528 MiB/GPU
• 1024 → 2048 : +1,4 % de PP pour +1042 MiB/GPU
• 512 → 2048 : +3,1 % de PP pour +1570 MiB/GPU

Clairement, 2048/2048 est le plus rapide, mais le rendement mémoire est très mauvais.

Ling-3.0 Tiny (Q6_K_L)

batch  ubatch  pp_tps   gpu0_peak_mib  gpu1_peak_mib  status
512    128     2754.83  3427           3455           OK
512    256     4361.06  3447           3539           OK
512    512     5385.03  3505           3719           OK
1024   128     2511.54  3427           3455           OK
1024   256     4340.62  3447           3539           OK
1024   512     5354.56  3505           3719           OK
1024   1024    5928.85  3597           4089           OK
2048   128     2402.04  3427           3455           OK
2048   256     4320.40  3447           3539           OK
2048   512     5336.70  3505           3719           OK
2048   1024    5909.44  3597           4089           OK
2048   2048    5796.45  3815           4823           OK

passer -ub 512 → 1024 apporte encore environ +10 % de prefill

Gemma4 26B-A4B (UD-Q4_K_XL)

batch  ubatch  pp_tps   gpu0_peak_mib  gpu1_peak_mib  status
512    128     1053.40  7427           7651           OK
512    256     1448.60  7569           7793           OK
512    512     1838.16  7873           8097           OK
1024   128     1055.65  7427           7651           OK
1024   256     1446.31  7569           7793           OK
1024   512     1837.26  7873           8097           OK
1024   1024    2144.97  8487           8711           OK
2048   128     1055.99  7427           7651           OK
2048   256     1447.60  7569           7793           OK
2048   512     1838.98  7873           8097           OK
2048   1024    2148.06  8487           8711           OK
2048   2048    2263.36  9699           9923           OK

• 1024/512 → 2048/1024 : +16,9 % de prefill pour environ +614 MiB/GPU
• 2048/1024 → 2048/2048 : encore +5,4 % pour environ +1212 MiB/GPU
• 1024/512 → 2048/2048 : environ +23,2 % de PP pour ~+1,8 Go/GPU

Gemma 4 26B profite nettement plus des gros ubatch.

Quelques résultats avec 1x RTX 3060 12GO

FM2.5-2.6B (Q6_K_L)

batch  ubatch  pp_tps   gpu0_peak_mib  gpu1_peak_mib  status
512    128     4051.52  5722           0              OK
512    256     4474.83  5782           0              OK
512    512     4692.96  5914           0              OK
1024   128     3978.66  5722           0              OK
1024   256     4435.82  5782           0              OK
1024   512     4662.09  5914           0              OK
1024   1024    4771.00  6176           0              OK
2048   128     3933.95  5722           0              OK
2048   256     4420.80  5782           0              OK
2048   512     4653.68  5914           0              OK
2048   1024    4762.36  6176           0              OK
2048   2048    4758.63  6704           0              OK