Benchmark e ottimizzazione: misurare le prestazioni e ridurre il consumo

Una volta che ds4 è funzionante, potresti voler misurare le prestazioni della tua configurazione o ottimizzare il sistema per bilanciare velocità e consumo energetico. ds4 include due strumenti principali: ds4-bench per il benchmarking e il flag --power per limitare l’uso della GPU.

Misurare le prestazioni con ds4-bench

ds4-bench è uno strumento che misura la velocità di prefill (elaborazione del prompt) e di generazione (produzione di nuovi token) a diverse lunghezze di contesto. A differenza di altri benchmark che danno una media su tutta la run, ds4-bench calcola metriche istantanee a frontiere specifiche (es. 2048, 4096, 6144 token).

Utilizzo base

./ds4-bench \
  -m ds4flash.gguf \
  --prompt-file speed-bench/promessi_sposi.txt \
  --ctx-start 2048 \
  --ctx-max 65536 \
  --step-incr 2048 \
  --gen-tokens 128

Parametri principali:

Parametro	Esempio	Spiegazione
-m	ds4flash.gguf	Percorso del modello
--prompt-file	speed-bench/promessi_sposi.txt	File di testo usato come prompt (deve essere più lungo di --ctx-max)
--ctx-start	2048	Prima lunghezza di contesto da misurare
--ctx-max	65536	Ultima lunghezza di contesto
--step-incr	2048	Incremento lineare tra le misurazioni
--step-mul	2.0	In alternativa, incremento esponenziale (es. 2048, 4096, 8192…)
--gen-tokens	128	Numero di token da generare a ciascuna frontiera per misurare la velocità di generazione
--power	70	Limita la potenza GPU (vedi sezione ottimizzazione)

Output di esempio

ctx,prefill_tokens,prefill_t/s,gen_tokens,gen_t/s,kvcache_bytes
2048,2048,1250.32,128,32.45,123456789
4096,2048,1180.45,128,31.98,246913578
6144,2048,1120.78,128,31.21,370370367
...

Cosa significano le colonne:

• ctx: lunghezza totale del contesto (token già processati)
• prefill_tokens: numero di token aggiunti in questo step (di solito step-incr o ctx - ctx_previous)
• prefill_t/s: velocità di prefill per questo intervallo (token al secondo)
• gen_tokens: numero di token generati per la misura (fisso, es. 128)
• gen_t/s: velocità di generazione a questo livello di contesto
• kvcache_bytes: memoria occupata dalla KV cache in questo momento

Interpretazione dei risultati

Prefill:
Diminuisce leggermente all’aumentare del contesto perché la cache diventa più grande e la computazione dei layer compressi diventa più pesante. Su Metal, valori tipici per Flash q2 su M5 Max: 400-500 t/s.

Generazione:
Rimane grossomodo costante con la lunghezza del contesto, perché ogni token richiede lo stesso calcolo (solo l’ultimo token, più il recupero della KV cache). Su Metal, valori tipici per Flash q2 su M5 Max: 25-35 t/s.

Caso SSD streaming (capitolo 5):
La generazione degrada significativamente se la cache esperti è piccola. Puoi usare ds4-bench --ssd-streaming --ssd-streaming-cache-experts 32GB per misurare l’impatto.

File di prompt di esempio

Il repository include speed-bench/promessi_sposi.txt, un estratto del romanzo I Promessi Sposi di Alessandro Manzoni (dominio pubblico, circa 100k token). Puoi usare qualsiasi file di testo lungo; assicurati solo che superi --ctx-max token.

Per generare un file di prompt personalizzato:

# Crea un file di testo di almeno 100k token (circa 75k parole in inglese, 60k in italiano)
cat /path/to/large/text.txt > my_prompt.txt

# Controlla la lunghezza in token con ds4
./ds4 --dump-tokens --prompt-file my_prompt.txt | grep "total tokens"

Ottimizzazione energetica: flag --power

L’inferenza di modelli grandi può tenere la GPU occupata al 100% per lunghi periodi, causando:

• Riscaldamento della macchina
• Ventole rumorose (soprattutto su MacBook Pro)
• Consumo elevato della batteria (su portatili)
• Stress termico sui componenti

Il flag --power N (dove N è una percentuale da 1 a 100) riduce l’uso della GPU inserendo pause strategiche.

Come funziona

• --power 100 (default): nessuna pausa, massima velocità.
• --power 70: ds4 misura il tempo di computazione di ogni layer (prefill) o di ogni token (generazione) e inserisce una pausa proporzionale per ridurre l’uso medio della GPU al 70%.
• Valori più bassi (es. --power 30) rendono la macchina molto più silenziosa ma anche molto più lenta.

Utilizzo

# Limita al 70% della potenza
./ds4 --power 70 -p "Ciao"

# Nel server
./ds4-server --power 50 --ctx 100000

# Nel benchmark
./ds4-bench --power 40 ...

Impatto sulle prestazioni

Su un MacBook Pro M5 Max, Flash q2:

--power	Prefill (t/s)	Generazione (t/s)	Rumore ventole	Temperatura (~°C)
100	463	25.9	Alto (6000 rpm)	95
70	320	18.1	Medio (4500 rpm)	85
50	230	12.9	Basso (3000 rpm)	75
30	138	7.8	Molto basso (2000 rpm)	65

Nota: I numeri sono indicativi. L’efficacia dipende dal workload e dal sistema di raffreddamento.

Quando usare --power

• Ambiente silenzioso (biblioteca, casa di notte) → --power 40 o 50
• Batteria scarica e vuoi prolungare l’autonomia → --power 50 (riduce il consumo energetico circa del 40%)
• Carichi prolungati (es. generazione di molti token o server sempre attivo) → --power 70 bilancia velocità e usura
• Benchmark o massime prestazioni → --power 100

Ottimizzazione della memoria

Oltre al --power, puoi ottimizzare l’uso della memoria per evitare swap o crash.

Ridurre la dimensione del contesto

La KV cache è il principale consumatore di memoria oltre al modello. Per contesti enormi, la cache compressa (4:1) richiede comunque circa 22 GB per 1 milione di token su Flash. Riduci --ctx se vedi errori di memoria.

# Per Mac con 128 GB, modello q2 (81 GB), sicuro fino a ~300k token
./ds4 --ctx 300000

# Per Mac con 64 GB in streaming, contesto più piccolo
./ds4 --ssd-streaming --ctx 32768

Monitorare l’uso della memoria

Su macOS, usa Activity Monitor (colonna “Memoria”). Su Linux, htop o nvidia-smi per la memoria GPU.

ds4 stampa un report all’avvio:

Model size: 81.2 GB (2-bit quant)
KV cache: 5.2 GB for 32768 tokens (compressed)
Workspace: 2.1 GB
Total estimated memory: 88.5 GB

Se il totale supera la RAM fisica, abilita SSD streaming o riduci il contesto.

Ottimizzazione per backend specifici

Metal (macOS)

Prefill chunk size: La variabile d’ambiente DS4_METAL_PREFILL_CHUNK controlla quanti token processare per volta. Default: 4096. Valori più bassi (es. 2048) riducono l’uso di memoria a scapito della velocità. Valori più alti (es. 8192) possono migliorare la velocità ma aumentare la memoria.

export DS4_METAL_PREFILL_CHUNK=2048
./ds4 -p "Ciao"

Cache degli shader: La prima esecuzione compila gli shader Metal (può richiedere 10-20 secondi). Le esecuzioni successive sono più veloci. Se sposti il modello o cambi versione di ds4, la cache viene rigenerata.

CUDA (NVIDIA)

Architettura specifica: Per DGX Spark, usa make cuda-spark. Per altre GPU, specifica l’architettura con CUDA_ARCH:

make cuda CUDA_ARCH=sm_89   # RTX 4090 / 4080
make cuda CUDA_ARCH=sm_90   # H100 / DGX H100

Memoria GPU: Se la memoria GPU è limitata, ds4 può utilizzare la RAM di sistema come swap (lento). Meglio ridurre il contesto o passare a Metal/CPU.

ROCm (Strix Halo)

Il supporto ROCm è recente. Per ottimizzare, consulta STRIXHALO.md nel repository.

Benchmark comparativi (dal README ufficiale)

Ecco alcuni dati di riferimento pubblicati da antirez (single run, --ctx 32768, --nothink):

Macchina	Quant	Prompt	Prefill	Generazione
MacBook Pro M3 Max 128 GB	q2	short	58.52 t/s	26.68 t/s
MacBook Pro M3 Max 128 GB	q2	11709 token	250.11 t/s	21.47 t/s
MacBook Pro M3 Max 128 GB	q4	short	N/A	N/A
MacBook Pro M5 Max 128 GB	q2	short	87.25 t/s	34.27 t/s
MacBook Pro M5 Max 128 GB	q2	11707 token	463.44 t/s	25.90 t/s
Mac Studio M3 Ultra 512 GB	q2	short	84.43 t/s	36.86 t/s
Mac Studio M3 Ultra 512 GB	q2	11709 token	468.03 t/s	27.39 t/s
Mac Studio M3 Ultra 512 GB	q4	short	78.95 t/s	35.50 t/s
Mac Studio M3 Ultra 512 GB	q4	12018 token	448.82 t/s	26.62 t/s
Mac Studio M3 Ultra 512 GB	PRO q2	32768 token	138.82 t/s	9.56 t/s
DGX Spark GB10 128 GB	q2	7047 token	343.81 t/s	13.75 t/s

Nota: La DGX Spark è molto veloce nel prefill grazie alla memoria HBM, ma la generazione è più lenta perché il modello è in RAM (non in HBM) su quella configurazione.

Conclusione

Misurare le prestazioni con ds4-bench ti aiuta a capire se la tua configurazione è ottimale e a confrontare diversi quant o hardware. Il flag --power ti dà il controllo sul compromesso velocità/rumore/calore, ed è essenziale per l’uso prolungato su portatili.

Consiglio pratico: Esegui un benchmark di base con --ctx-start 2048 --ctx-max 32768 --step-incr 2048 --gen-tokens 128 e salva i risultati. Dopo modifiche (cambio quant, abilitazione streaming, aggiornamento di ds4), ripeti il benchmark per vedere l’impatto.

💡 Automatizzare il benchmark
Puoi creare uno script che esegue ds4-bench con diverse configurazioni (es. con e senza streaming, con diverse cache expert) e salva i CSV. Poi importali in un foglio di calcolo per fare grafici comparativi.

⚠️ Il benchmark è distruttivo?
No, ds4-bench non modifica il modello né i file di cache. Carica il modello una volta e fa tutte le misurazioni in memoria. Puoi eseguirlo anche mentre il server è in funzione (ma le prestazioni saranno influenzate).