# Vetrina TAKT: rav1e 0.8.0, codifica AV1 delle clip di test Xiph

Due build dell’encoder AV1 rav1e, versione 0.8.0: la release originale e lo stesso encoder dopo
l’ottimizzazione TAKT. Su cinque clip di test pubbliche di Xiph.org entrambe scrivono gli stessi file
AV1, byte per byte, e la build TAKT è 1,38× più veloce a speed 10 e 1,30× più veloce a speed 6 (cicli
di CPU, un thread). Qui si trovano i due programmi, uno script che scarica le clip da Xiph.org, uno
script che esegue il confronto e le nostre misure.

## Che cosa fa il benchmark

Ogni clip viene codificata con una sola riga di comando, identica per entrambi i programmi:

```sh
rav1e <clip>_first64.y4m --threads 1 --speed 10 --quantizer 100 --limit 64 --output <clip>.ivf
rav1e <clip>_first64.y4m --threads 1 --speed 6  --quantizer 100 --limit 64 --output <clip>.ivf
```

Speed 10 è il preset più veloce di rav1e, speed 6 quello predefinito. Le clip sono i primi 64
fotogrammi dei file Y4M originali a 8 bit 4:2:0 della collezione
[Xiph.org Video Test Media](https://media.xiph.org/video/derf/), invariati (nessun ridimensionamento,
nessuna ricodifica):

| Clip | Risoluzione, frequenza dei fotogrammi | Contenuto | File sorgente su Xiph.org |
|---|---|---|---|
| Elephants Dream | 1280×720, 24 fps | animazione 3D | `elephants_dream_720p24.y4m.xz` |
| Park Joy | 1280×720, 50 fps | persone e vegetazione in un parco | `park_joy_420_720p50.y4m` |
| Johnny | 1280×720, 60 fps | mezzobusto parlante | `Johnny_1280x720_60.y4m` |
| Bus | 352×288 (CIF), 30 fps | autobus e traffico stradale | `bus_cif.y4m` |
| Stefan | 352×240 (SIF), 29,97 fps | tennista | `stefan_sif.y4m` |

## Misura (banco TAKT)

AMD Threadripper PRO 5975WX (Zen 3), Linux. Un core dedicato, il resto del suo core complex mantenuto
inattivo; cicli e istruzioni in modalità utente da `perf stat`, più il tempo reale. 7 round alternati:
in ogni round ciascuna clip viene codificata da entrambi i programmi uno dopo l’altro, prima
l’originale nei round dispari e prima TAKT nei round pari; si prende la mediana per clip e per
programma. L’accelerazione per un preset è la somma delle cinque mediane dell’originale divisa per la
somma delle cinque mediane di TAKT. Sono stati misurati esattamente i file in `bin/`, con
`tools/run_bench.sh`.

| Preset | Originale, mld di cicli | TAKT, mld di cicli | Accelerazione, cicli | Originale, s | TAKT, s | Accelerazione, tempo |
|---|---:|---:|---:|---:|---:|---:|
| speed 10 | 139,8 | 101,6 | **1,38×** | 32,3 | 23,7 | 1,37× |
| speed 6 | 446,2 | 343,2 | **1,30×** | 101,9 | 78,2 | 1,30× |

Per clip (accelerazione in cicli; in tempo reale tra parentesi):

| Clip | speed 10 | speed 6 |
|---|---:|---:|
| Elephants Dream | 1,31× (1,31×) | 1,28× (1,27×) |
| Park Joy | 1,38× (1,38×) | 1,29× (1,30×) |
| Johnny | 1,40× (1,38×) | 1,37× (1,36×) |
| Bus | 1,40× (1,38×) | 1,29× (1,29×) |
| Stefan | 1,45× (1,40×) | 1,33× (1,33×) |

L’accelerazione minima per clip è 1,28× in cicli (Elephants Dream, speed 6). Tutti i campioni, le
mediane e i conteggi delle istruzioni sono in `measurements.json`.

## Equivalenza

Su questo benchmark la build TAKT scrive esattamente lo stesso bitstream di rav1e originale: in ogni
round tutte e dieci le codifiche (5 clip × 2 preset) sono state confrontate byte per byte, 70 coppie
in totale, 70 identiche. Lo SHA-256 di ciascun file di output è in `tools/expected_ivf.sha256`;
`tools/run_bench.sh` verifica i suoi output rispetto a questi valori. Questa vetrina copre la
configurazione indicata sopra (input a 8 bit 4:2:0, un thread, speed 10 e 6, quantizer 100); altre
opzioni di rav1e non facevano parte di questa misura.

## Esecuzione

```sh
python3 tools/fetch_clips.py              # scarica circa 300 MB, scrive clips/ (283 MB), verifica SHA-256
tools/run_bench.sh                        # 5 round, entrambi i preset, entrambi i programmi; circa 20 min sul nostro banco
CPU=3 tools/run_bench.sh 3                # fissa ogni codifica sul core 3; 3 round
SPEEDS=10 tools/run_bench.sh 1            # uno sguardo rapido: un round a speed 10 (circa 1 min)
```

`run_bench.sh` stampa ogni codifica, una tabella di mediane e accelerazioni e quante coppie di output
sono identiche; termina con stato 1 se una qualsiasi coppia differisce. I cicli vengono riportati
quando `perf` può contare `cycles:u` (altrimenti solo il tempo reale). I dati grezzi finiscono in
`runs.csv` nella directory di lavoro che lo script stampa. Ciascun programma si può anche eseguire
direttamente, come una normale riga di comando di rav1e:

```sh
bin/rav1e-0.8.0-takt clips/bus_cif_first64.y4m --threads 1 --speed 6 --quantizer 100 --limit 64 --output bus.ivf
bin/rav1e-0.8.0      clips/bus_cif_first64.y4m --threads 1 --speed 6 --quantizer 100 --limit 64 --output bus-stock.ivf
cmp bus.ivf bus-stock.ivf                 # identici
```

Requisiti: Linux x86-64 con glibc 2.34 o successiva e una CPU con x86-64-v3 (AVX2, FMA, BMI2: Intel
Haswell e successivi, AMD Zen e successivi). Python 3.8+ per `fetch_clips.py` (solo libreria
standard); `perf` è facoltativo.

## Come sono stati compilati i programmi

Entrambi allo stesso modo: rustc 1.96.0, `cargo build --release --locked --bin rav1e` con il profilo
release di rav1e (thin LTO) e le feature predefinite (compreso il suo assembly NASM), `-C target-cpu=x86-64-v3
-C debuginfo=0`, simboli rimossi. `bin/rav1e-0.8.0` è compilato dal sorgente non modificato di rav1e
al tag git [v0.8.0](https://github.com/xiph/rav1e/tree/v0.8.0) (commit 1fd67cd); può compilarlo in
autonomia e confrontarlo. `bin/rav1e-0.8.0-takt` è compilato dallo stesso sorgente dopo
l’ottimizzazione TAKT. Il sorgente ottimizzato non è pubblicato: consegniamo build.

## Contenuto

- `bin/rav1e-0.8.0`: rav1e 0.8.0 originale;
- `bin/rav1e-0.8.0-takt`: rav1e 0.8.0 dopo l’ottimizzazione TAKT;
- `tools/fetch_clips.py`: scarica le cinque clip da Xiph.org e ne verifica lo SHA-256;
- `tools/run_bench.sh`: esegue entrambi i programmi, confronta gli output, stampa i tempi;
- `tools/expected_ivf.sha256`: SHA-256 dei dieci file di output;
- `measurements.json`, `SHA256SUMS`, `LICENSE`, `THIRD_PARTY_LICENSES.txt`.

## Licenze e diritti sulle clip

rav1e è distribuito con la BSD 2-Clause License e la Alliance for Open Media Patent License 1.0;
entrambi i programmi sono distribuiti alle stesse condizioni (`LICENSE`), e il codice di terze parti
collegato al loro interno è elencato in `THIRD_PARTY_LICENSES.txt`. I nostri script sono rilasciati
con la MIT License.

Le clip non fanno parte di questo pacchetto: `tools/fetch_clips.py` le scarica da Xiph.org e restano
soggette alle condizioni lì indicate. Elephants Dream è © Blender Foundation / Netherlands Media Art
Institute, con licenza Creative Commons Attribution 2.5
([orange.blender.org](https://orange.blender.org/)). Park Joy proviene dal set di test SVT
MultiFormat (Sveriges Television; condizioni nel
[documento SVT](https://media.xiph.org/video/derf/vqeg.its.bldrdoc.gov/HDTV/SVT_MultiFormat/SVT_MultiFormat_v10.pdf)).
Johnny è indicato come pubblico dominio nel catalogo di Xiph.org. Bus e Stefan sono sequenze di test
standard della collezione Xiph.org, che ne elenca le fonti originali.