# Demostración de TAKT: rav1e 0.8.0, codificación AV1 de clips de prueba de Xiph

Dos compilaciones del codificador AV1 rav1e, versión 0.8.0: la versión original publicada y el mismo
codificador tras la optimización de TAKT. En cinco clips de prueba públicos de Xiph.org ambas
escriben los mismos archivos AV1, byte a byte, y la compilación de TAKT es 1,38× más rápida con
speed 10 y 1,30× más rápida con speed 6 (ciclos de CPU, un hilo). Aquí encontrará ambos programas,
un script que descarga los clips de Xiph.org, un script que ejecuta la comparación y nuestras
mediciones.

## Qué hace el benchmark

Cada clip se codifica con una sola línea de comandos, idéntica para ambos programas:

```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 es el preajuste más rápido de rav1e; speed 6, el predeterminado. Los clips son los primeros
64 fotogramas de archivos Y4M originales de 8 bits 4:2:0 de la colección
[Xiph.org Video Test Media](https://media.xiph.org/video/derf/), sin cambios (sin redimensionar ni
recodificar):

| Clip | Tamaño de fotograma, frecuencia | Contenido | Archivo fuente de Xiph.org |
|---|---|---|---|
| Elephants Dream | 1280×720, 24 fps | animación 3D | `elephants_dream_720p24.y4m.xz` |
| Park Joy | 1280×720, 50 fps | personas y follaje en un parque | `park_joy_420_720p50.y4m` |
| Johnny | 1280×720, 60 fps | persona hablando a cámara | `Johnny_1280x720_60.y4m` |
| Bus | 352×288 (CIF), 30 fps | autobús y tráfico urbano | `bus_cif.y4m` |
| Stefan | 352×240 (SIF), 29,97 fps | jugador de tenis | `stefan_sif.y4m` |

## Medición (banco de TAKT)

AMD Threadripper PRO 5975WX (Zen 3), Linux. Un núcleo dedicado, con el resto de su complejo de
núcleos inactivo; ciclos e instrucciones en modo usuario de `perf stat`, además del tiempo de reloj.
7 rondas intercaladas: en cada ronda, cada clip se codifica con ambos programas uno tras otro,
primero el original en las rondas impares y primero TAKT en las pares; tomamos la mediana por clip y
programa. La aceleración de un preajuste es la suma de las cinco medianas del original dividida entre
la suma de las cinco medianas de TAKT. Se midieron exactamente los archivos de `bin/`, con
`tools/run_bench.sh`.

| Preajuste | Original, G ciclos | TAKT, G ciclos | Aceleración, ciclos | Original, s | TAKT, s | Aceleración, tiempo |
|---|---:|---:|---:|---:|---:|---:|
| 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× |

Por clip (aceleración en ciclos; en tiempo de reloj, entre paréntesis):

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

La menor aceleración por clip es de 1,28× en ciclos (Elephants Dream, speed 6). Todas las muestras,
las medianas y los recuentos de instrucciones están en `measurements.json`.

## Equivalencia

En este benchmark, la compilación de TAKT escribe exactamente el mismo flujo de bits que rav1e
original: en cada ronda se compararon byte a byte las diez codificaciones (5 clips × 2 preajustes),
70 pares en total, 70 idénticos. El SHA-256 de cada archivo de salida está en
`tools/expected_ivf.sha256`; `tools/run_bench.sh` compara con él sus salidas. Esta demostración cubre
la configuración anterior (entrada de 8 bits 4:2:0, un hilo, speed 10 y 6, quantizer 100); otras
opciones de rav1e no formaron parte de esta medición.

## Ejecución

```sh
python3 tools/fetch_clips.py              # descarga unos 300 MB, escribe clips/ (283 MB) y verifica el SHA-256
tools/run_bench.sh                        # 5 rondas, ambos preajustes, ambos programas; unos 20 min en nuestro banco
CPU=3 tools/run_bench.sh 3                # fija cada codificación al núcleo 3; 3 rondas
SPEEDS=10 tools/run_bench.sh 1            # un vistazo rápido: una ronda con speed 10 (aproximadamente 1 min)
```

`run_bench.sh` imprime cada codificación, una tabla de medianas y aceleraciones, y cuántos pares de
salida son idénticos; termina con el estado 1 si algún par difiere. Los ciclos se muestran cuando
`perf` puede contar `cycles:u` (en caso contrario, solo el tiempo de reloj). Los datos sin procesar
se guardan en `runs.csv`, dentro del directorio de trabajo que el script imprime.
Cualquiera de los dos programas también puede ejecutarse directamente, como una línea de comandos
normal de 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                 # idénticos
```

Requisitos: Linux x86-64 con glibc 2.34 o posterior y una CPU con x86-64-v3 (AVX2, FMA, BMI2: Intel
Haswell y posteriores, AMD Zen y posteriores). Python 3.8+ para `fetch_clips.py` (solo la biblioteca
estándar); `perf` es opcional.

## Cómo se compilaron los programas

Ambos de la misma manera: rustc 1.96.0, `cargo build --release --locked --bin rav1e` con el perfil de
release propio de rav1e (thin LTO) y las features predeterminadas (incluido su código ensamblador
NASM), `-C target-cpu=x86-64-v3
-C debuginfo=0`, sin símbolos. `bin/rav1e-0.8.0` se compila a partir del código fuente sin modificar
de rav1e en la etiqueta git [v0.8.0](https://github.com/xiph/rav1e/tree/v0.8.0) (commit 1fd67cd);
puede compilarlo usted mismo y comparar. `bin/rav1e-0.8.0-takt` se compila a partir del mismo código
fuente tras la optimización de TAKT. El código fuente optimizado no se publica: entregamos
compilaciones.

## Contenido

- `bin/rav1e-0.8.0`: rav1e 0.8.0 original;
- `bin/rav1e-0.8.0-takt`: rav1e 0.8.0 tras la optimización de TAKT;
- `tools/fetch_clips.py`: descarga los cinco clips de Xiph.org y verifica su SHA-256;
- `tools/run_bench.sh`: ejecuta ambos programas, compara las salidas e imprime los tiempos;
- `tools/expected_ivf.sha256`: SHA-256 de los diez archivos de salida;
- `measurements.json`, `SHA256SUMS`, `LICENSE`, `THIRD_PARTY_LICENSES.txt`.

## Licencias y derechos de los clips

rav1e se distribuye bajo la BSD 2-Clause License y la Alliance for Open Media Patent License 1.0;
ambos programas se distribuyen en los mismos términos (`LICENSE`), y el código de terceros enlazado
en ellos figura en `THIRD_PARTY_LICENSES.txt`. Nuestros scripts están bajo la licencia MIT.

Los clips no forman parte de este paquete: `tools/fetch_clips.py` los descarga de Xiph.org, y siguen
sujetos a las condiciones indicadas allí. Elephants Dream es © Blender Foundation / Netherlands
Media Art Institute, con licencia Creative Commons Attribution 2.5
([orange.blender.org](https://orange.blender.org/)). Park Joy pertenece al conjunto de prueba SVT
MultiFormat (Sveriges Television; condiciones en el
[documento de SVT](https://media.xiph.org/video/derf/vqeg.its.bldrdoc.gov/HDTV/SVT_MultiFormat/SVT_MultiFormat_v10.pdf)).
Johnny figura como dominio público en el catálogo de Xiph.org. Bus y Stefan son secuencias de prueba
estándar de la colección de Xiph.org, que indica sus fuentes originales.