# Vitrine TAKT: rav1e 0.8.0, codificação AV1 de clipes de teste da Xiph

Dois builds do codificador AV1 rav1e, versão 0.8.0: a versão oficial e o mesmo codificador após a
otimização da TAKT. Em cinco clipes de teste públicos da Xiph.org, os dois geram os mesmos arquivos
AV1, byte a byte, e o build TAKT é 1,38× mais rápido na velocidade 10 e 1,30× mais rápido na
velocidade 6 (ciclos de CPU, uma thread). Aqui você encontra os dois programas, um script que baixa
os clipes da Xiph.org, um script que executa a comparação e as nossas medições.

## O que o benchmark faz

Cada clipe é codificado com uma única linha de comando, idêntica para os dois 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
```

A velocidade 10 é o preset mais rápido do rav1e; a velocidade 6 é a configuração padrão. Os clipes
são os primeiros 64 quadros dos arquivos Y4M originais de 8 bits 4:2:0 da coleção
[Xiph.org Video Test Media](https://media.xiph.org/video/derf/), sem alterações (sem
redimensionamento, sem recodificação):

| Clipe | Resolução, taxa de quadros | Conteúdo | Arquivo de origem na Xiph.org |
|---|---|---|---|
| Elephants Dream | 1280×720, 24 fps | animação 3D | `elephants_dream_720p24.y4m.xz` |
| Park Joy | 1280×720, 50 fps | pessoas e folhagem em um parque | `park_joy_420_720p50.y4m` |
| Johnny | 1280×720, 60 fps | pessoa falando para a câmera | `Johnny_1280x720_60.y4m` |
| Bus | 352×288 (CIF), 30 fps | ônibus e trânsito na rua | `bus_cif.y4m` |
| Stefan | 352×240 (SIF), 29,97 fps | tenista | `stefan_sif.y4m` |

## Medição (bancada TAKT)

AMD Threadripper PRO 5975WX (Zen 3), Linux. Um núcleo dedicado, com o restante do seu complexo de
núcleos mantido ocioso; ciclos e instruções em modo usuário pelo `perf stat`, além do tempo
decorrido. 7 rodadas intercaladas: em cada rodada, cada clipe é codificado pelos dois programas em
sequência, o oficial primeiro nas rodadas ímpares e o TAKT primeiro nas pares; tomamos a mediana por
clipe e por programa. A aceleração de um preset é a soma das cinco medianas do oficial dividida pela
soma das cinco medianas do TAKT. Foram medidos exatamente os arquivos em `bin/`, com
`tools/run_bench.sh`.

| Preset | Oficial, bi de ciclos | TAKT, bi de ciclos | Aceleração, ciclos | Oficial, s | TAKT, s | Aceleração, tempo |
|---|---:|---:|---:|---:|---:|---:|
| velocidade 10 | 139,8 | 101,6 | **1,38×** | 32,3 | 23,7 | 1,37× |
| velocidade 6 | 446,2 | 343,2 | **1,30×** | 101,9 | 78,2 | 1,30× |

Por clipe (aceleração em ciclos; em tempo decorrido entre parênteses):

| Clipe | velocidade 10 | velocidade 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×) |

A menor aceleração por clipe é 1,28× em ciclos (Elephants Dream, velocidade 6). Todas as amostras,
as medianas e as contagens de instruções estão em `measurements.json`.

## Equivalência

Neste benchmark, o build TAKT gera exatamente o mesmo bitstream que o rav1e oficial: em cada rodada,
as dez codificações (5 clipes × 2 presets) foram comparadas byte a byte, 70 pares no total, 70
idênticos. O SHA-256 de cada arquivo de saída está em `tools/expected_ivf.sha256`;
`tools/run_bench.sh` confere as suas saídas com ele. Esta vitrine cobre a configuração acima
(entrada de 8 bits 4:2:0, uma thread, velocidades 10 e 6, quantizador 100); outras opções do rav1e
não fizeram parte desta medição.

## Execução

```sh
python3 tools/fetch_clips.py              # baixa cerca de 300 MB, grava clips/ (283 MB), verifica o SHA-256
tools/run_bench.sh                        # 5 rodadas, os dois presets, os dois programas; cerca de 20 min na nossa bancada
CPU=3 tools/run_bench.sh 3                # fixa cada codificação no núcleo 3; 3 rodadas
SPEEDS=10 tools/run_bench.sh 1            # uma olhada rápida: uma rodada na velocidade 10 (cerca de 1 min)
```

O `run_bench.sh` imprime cada codificação, uma tabela de medianas e acelerações e quantos pares de
saída são idênticos; ele termina com status 1 se algum par diferir. Os ciclos são informados quando o
`perf` consegue contar `cycles:u` (caso contrário, apenas o tempo decorrido). Os dados brutos vão para
`runs.csv` no diretório de trabalho que ele imprime. Qualquer um dos programas também pode ser
executado diretamente, como uma linha de comando comum do 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 com glibc 2.34 ou mais recente e uma CPU com x86-64-v3 (AVX2, FMA, BMI2:
Intel Haswell e mais recentes, AMD Zen e mais recentes). Python 3.8+ para `fetch_clips.py` (apenas a
biblioteca padrão); o `perf` é opcional.

## Como os programas foram compilados

Os dois da mesma forma: rustc 1.96.0, `cargo build --release --locked --bin rav1e` com o perfil de
release do próprio rav1e (thin LTO) e as features padrão (incluindo o seu assembly NASM), `-C target-cpu=x86-64-v3
-C debuginfo=0`, símbolos removidos. `bin/rav1e-0.8.0` é compilado a partir do código-fonte do rav1e
sem modificações na tag git [v0.8.0](https://github.com/xiph/rav1e/tree/v0.8.0) (commit 1fd67cd);
você mesmo pode compilá-lo e comparar. `bin/rav1e-0.8.0-takt` é compilado a partir do mesmo
código-fonte após a otimização da TAKT. O código-fonte otimizado não é publicado: entregamos builds.

## Conteúdo

- `bin/rav1e-0.8.0`: rav1e 0.8.0 oficial;
- `bin/rav1e-0.8.0-takt`: rav1e 0.8.0 após a otimização da TAKT;
- `tools/fetch_clips.py`: baixa os cinco clipes da Xiph.org e verifica o SHA-256 deles;
- `tools/run_bench.sh`: executa os dois programas, compara as saídas e imprime os tempos;
- `tools/expected_ivf.sha256`: SHA-256 dos dez arquivos de saída;
- `measurements.json`, `SHA256SUMS`, `LICENSE`, `THIRD_PARTY_LICENSES.txt`.

## Licenças e direitos dos clipes

O rav1e é distribuído sob a BSD 2-Clause License e a Alliance for Open Media Patent License 1.0; os
dois programas são distribuídos nos mesmos termos (`LICENSE`), e o código de terceiros linkado neles
está listado em `THIRD_PARTY_LICENSES.txt`. Os nossos scripts estão sob a licença MIT.

Os clipes não fazem parte deste pacote: `tools/fetch_clips.py` os baixa da Xiph.org, e eles
continuam sujeitos aos termos indicados lá. Elephants Dream é © Blender Foundation / Netherlands
Media Art Institute, licenciado sob Creative Commons Attribution 2.5
([orange.blender.org](https://orange.blender.org/)). Park Joy vem do conjunto de teste SVT
MultiFormat (Sveriges Television; termos no
[documento da SVT](https://media.xiph.org/video/derf/vqeg.its.bldrdoc.gov/HDTV/SVT_MultiFormat/SVT_MultiFormat_v10.pdf)).
Johnny está marcado como domínio público no catálogo da Xiph.org. Bus e Stefan são sequências de
teste padrão da coleção da Xiph.org, que lista as suas fontes originais.