Appearance

Benchmark de I/O com FIO ​

Guia completo de instalação, execução, leitura de resultados e parsing de saída.

PROPÓSITO

Medir o desempenho real de um disco ou pool de armazenamento com cargas controladas e reproduzíveis, em vez de depender de impressão.

Quando usar: Antes de colocar um storage em produção, ao comparar discos ou configurações, e quando uma reclamação de lentidão precisa virar número.

Pré-requisitos: Acesso root, o pacote fio instalado e espaço livre para o arquivo de teste.

1. O que é o FIO ​

O FIO (Flexible I/O Tester) é a ferramenta padrão de benchmarking de I/O em ambientes Linux. Permite simular padrões reais de acesso a disco com controle preciso sobre block size, profundidade de fila, número de threads, modo de I/O (síncrono/assíncrono) e mix de leitura/escrita.

É utilizado para:

  • Avaliar a performance bruta de HDDs, SSDs SATA e NVMe

  • Simular cargas de bancos de dados, filesystems e aplicações

  • Comparar configurações de storage antes e depois de mudanças

  • Validar SLAs de performance em ambientes de produção

2. Instalação ​

bash
# Debian / Ubuntu
apt install fio

# RHEL / CentOS / Rocky
dnf install fio

# Verificar versão instalada
fio --version

3. Conceitos Fundamentais ​

3.1 Parâmetros Essenciais ​

ParâmetroO que controla
--rwPadrão de acesso: leitura, escrita, aleatório, misto
--bsBlock size — tamanho de cada operação de I/O
--ioengineMotor de I/O: libaio (assíncrono) ou sync (síncrono)
--direct1 = bypassa page cache; 0 = usa cache do SO
--iodepthNúmero de operações em voo simultaneamente (fila)
--numjobsNúmero de processos/threads paralelos
--sizeVolume total de dados a ser processado por job
--runtimeDuração máxima do teste em segundos
--rwmixreadPercentual de leitura no modo misto (padrão: 50)

3.2 Regra do /tmp ​

Sempre verifique antes de apontar o arquivo de teste para /tmp:

bash
df -hT /tmp

Se a coluna Type mostrar tmpfs, o /tmp está montado em RAM. Nesse caso, o FIO medirá a velocidade da memória, não do disco. Use um caminho explícito em disco:

text
# Caminho seguro
--filename=/home/$USER/fio_test.tmp

# Ou aponte para o disco que deseja testar
--filename=/data/fio_test.tmp

3.3 --direct=1 vs --direct=0 ​

ModoQuando usar
--direct=1Benchmarks de hardware — mede o dispositivo real sem interferência do cache
--direct=0Simulação de aplicações reais que se beneficiam do page cache do SO

Para avaliar o disco em si, sempre use --direct=1.

4. Modos de Operação ​

4.1 Sequencial ​

Lê ou escreve blocos em ordem no dispositivo. Maximiza throughput (MB/s). Ideal para medir largura de banda bruta.

--rwQuando usar
readAvaliar throughput de leitura — cópias de arquivos grandes, streaming, restore de backup
writeAvaliar throughput de escrita — ingestão de dados, gravação de logs, backup
readwriteSimular cargas que leem e escrevem ao mesmo tempo — use --rwmixread para ajustar o percentual

Block size recomendado:--bs=1M

4.2 Aleatório ​

Acessa posições aleatórias no dispositivo. Maximiza IOPS. Ideal para simular bancos de dados, filesystems e cargas transacionais.

--rwQuando usar
randreadSimular queries de leitura em banco de dados, cache miss, acesso a índices
randwriteSimular alto volume de inserções, updates, journaling de filesystem
randrwSimular carga OLTP mista — use --rwmixread=70 para o padrão típico de 70% leitura

Block size recomendado:--bs=4k

5. Cenários de Teste ​

Substitua /home/$USER/fio_test.tmp pelo caminho desejado em todos os comandos.

Todos os exemplos usam pipe direto para jq — o resultado aparece limpo no terminal ao fim do teste.

Legenda dos campos de saída ​

CampoO que é
bw_MbitThroughput médio em Mbit/s durante o teste — unidade padrão de NICs, switches e TrueNAS (1 MiB/s = 8,39 Mbit/s)
iopsNúmero de operações de I/O completadas por segundo
lat_p50_msLatência em ms abaixo da qual estão 50% das operações — representa o caso típico
lat_p99_msLatência em ms abaixo da qual estão 99% das operações — revela stalls eventuais
lat_p999_msLatência em ms abaixo da qual estão 99,9% das operações — revela os piores casos isolados

Dois modos de teste nos cenários aleatórios: o modo throughput (iodepth=32+, numjobs=4) mede IOPS e banda máxima sob carga — latências serão maiores que a latência real do disco. O modo latência pura (iodepth=1, numjobs=1) mede o tempo de resposta mínimo do dispositivo, compatível com datasheets de fabricantes. As tabelas de referência indicam qual modo usam.

Por que p99 importa mais que a média? A média esconde picos. Um disco que responde em 1 ms na média mas tem p99 de 500 ms vai causar timeouts em produção. Sempre avalie p99 e p99,9 antes de concluir que o dispositivo está saudável.

5.1 Leitura Sequencial Pura ​

Mede o throughput máximo de leitura sequencial. Métrica principal: bw_Mbit.

bash
fio --name=seq_read \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=1M --rw=read \
    --ioengine=libaio --direct=1 \
    --iodepth=16 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      bw_Mbit:     (.read.bw / 1024 * 8.388608 | round),
      iops:        (.read.iops | round),
      lat_p50_ms:  (.read.clat_ns.percentile["50.000000"] / 1000000 | round),
      lat_p99_ms:  (.read.clat_ns.percentile["99.000000"] / 1000000 | round),
      lat_p999_ms: (.read.clat_ns.percentile["99.900000"] / 1000000 | round)
    }'

Referência — bw_Mbit esperado (Mbit/s):

Dispositivo / ConfiguraçãoMínimoMáximo
— Local —
HDD 7200 RPM839 Mbit/s1.590 Mbit/s
SSD SATA III3.190 Mbit/s4.490 Mbit/s
NVMe Gen315.940 Mbit/s28.020 Mbit/s
NVMe Gen440.010 Mbit/s55.990 Mbit/s
NVMe Gen580.030 Mbit/s111.990 Mbit/s
— NFS 1 GbE —
NFS 1 GbE + HDD backend587 Mbit/s839 Mbit/s
NFS 1 GbE + SSD backend671 Mbit/s923 Mbit/s
— VM + NFS (Proxmox) —
NFS 1 GbE + NVMe backend713 Mbit/s940 Mbit/s
— NFS 10 GbE —
VM + NFS + HDD backend419 Mbit/s1.090 Mbit/s
VM + NFS + SSD backend671 Mbit/s2.350 Mbit/s
NFS 10 GbE + HDD backend755 Mbit/s1.590 Mbit/s
NFS 10 GbE + SSD backend2.940 Mbit/s4.450 Mbit/s
VM + NFS + NVMe backend839 Mbit/s2.940 Mbit/s
NFS 10 GbE + NVMe backend3.360 Mbit/s7.550 Mbit/s
— iSCSI 1 GbE —
iSCSI 1 GbE + HDD backend629 Mbit/s881 Mbit/s
iSCSI 1 GbE + SSD backend713 Mbit/s940 Mbit/s
iSCSI 1 GbE + NVMe backend755 Mbit/s965 Mbit/s
— iSCSI 10 GbE —
iSCSI 10 GbE + HDD backend797 Mbit/s1.590 Mbit/s
iSCSI 10 GbE + SSD backend3.360 Mbit/s4.610 Mbit/s
iSCSI 10 GbE + NVMe backend4.190 Mbit/s9.230 Mbit/s
— Ceph RBD (iSCSI-like block) —
Ceph RBD + HDD (3x rep)503 Mbit/s1.260 Mbit/s
Ceph RBD + SSD (3x rep)2.100 Mbit/s4.190 Mbit/s
Ceph RBD + NVMe (3x rep)3.360 Mbit/s7.550 Mbit/s
Ceph RBD + NVMe (EC 4+2)4.190 Mbit/s10.070 Mbit/s
— CephFS (NFS-like filesystem) —
CephFS + HDD (3x rep)419 Mbit/s1.090 Mbit/s
CephFS + SSD (3x rep)1.680 Mbit/s3.770 Mbit/s
CephFS + NVMe (3x rep)2.940 Mbit/s6.710 Mbit/s
— Hiperconvergência (Proxmox + Ceph) —
HCI + HDD (3x rep)336 Mbit/s1.010 Mbit/s
HCI + SSD (3x rep)1.510 Mbit/s3.360 Mbit/s
HCI + NVMe (3x rep)2.520 Mbit/s6.290 Mbit/s

Em sequencial com bs=1M, o link de rede é o principal limitante — HDD, SSD e NVMe como backend entregam valores próximos em 1 GbE porque o teto do link (~998 Mbit/s) é atingido antes do disco. A diferença aparece em 10 GbE.

Referência — lat_p99_ms esperado (bs=1M, iodepth=16):

Dispositivo / Configuraçãop99 típico
— Local —
HDD 7200 RPM150–500 ms
SSD SATA III30–80 ms
NVMe Gen35–20 ms
NVMe Gen4/52–10 ms
— NFS (1/10 GbE) —
NFS + HDD backend200–600 ms
NFS + SSD backend60–200 ms
NFS + NVMe backend30–120 ms
— iSCSI (1/10 GbE) —
iSCSI + HDD backend150–500 ms
iSCSI + SSD backend40–150 ms
iSCSI + NVMe backend20–80 ms
— Ceph RBD —
Ceph RBD + HDD (3x rep)200–700 ms
Ceph RBD + SSD (3x rep)40–150 ms
Ceph RBD + NVMe (3x rep)15–60 ms
— CephFS —
CephFS + HDD (3x rep)250–800 ms
CephFS + SSD (3x rep)60–200 ms
CephFS + NVMe (3x rep)20–80 ms
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)300–1.000 ms
HCI + SSD (3x rep)80–250 ms
HCI + NVMe (3x rep)25–100 ms
— VM + NFS (Proxmox) —
VM + NFS + HDD backend250–800 ms
VM + NFS + SSD backend80–300 ms
VM + NFS + NVMe backend50–200 ms

Em I/O sequencial com iodepth=16, a latência é naturalmente mais alta que no aleatório com fila rasa — isso é esperado e não indica problema.

5.2 Escrita Sequencial Pura ​

Mede o throughput máximo de escrita sequencial. Métrica principal: bw_Mbit.

bash
fio --name=seq_write \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=1M --rw=write \
    --ioengine=libaio --direct=1 \
    --iodepth=16 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      bw_Mbit:     (.write.bw / 1024 * 8.388608 | round),
      iops:        (.write.iops | round),
      lat_p50_ms:  (.write.clat_ns.percentile["50.000000"] / 1000000 | round),
      lat_p99_ms:  (.write.clat_ns.percentile["99.000000"] / 1000000 | round),
      lat_p999_ms: (.write.clat_ns.percentile["99.900000"] / 1000000 | round)
    }'

Referência — bw_Mbit esperado (Mbit/s):

Dispositivo / ConfiguraçãoMínimoMáximo
— Local —
HDD 7200 RPM638 Mbit/s1.440 Mbit/s
SSD SATA III2.800 Mbit/s4.240 Mbit/s
NVMe Gen312.000 Mbit/s23.990 Mbit/s
NVMe Gen432.000 Mbit/s52.010 Mbit/s
NVMe Gen571.970 Mbit/s96.010 Mbit/s
— NFS 1 GbE —
NFS 1 GbE + HDD backend461 Mbit/s755 Mbit/s
NFS 1 GbE + SSD backend545 Mbit/s839 Mbit/s
— VM + NFS (Proxmox) —
NFS 1 GbE + NVMe backend587 Mbit/s906 Mbit/s
VM + NFS + HDD backend336 Mbit/s839 Mbit/s
— NFS 10 GbE —
NFS 10 GbE + HDD backend587 Mbit/s1.430 Mbit/s
VM + NFS + SSD backend503 Mbit/s1.850 Mbit/s
VM + NFS + NVMe backend671 Mbit/s2.350 Mbit/s
NFS 10 GbE + SSD backend2.350 Mbit/s4.190 Mbit/s
NFS 10 GbE + NVMe backend2.940 Mbit/s6.710 Mbit/s
— iSCSI 1 GbE —
iSCSI 1 GbE + HDD backend545 Mbit/s839 Mbit/s
iSCSI 1 GbE + SSD backend629 Mbit/s906 Mbit/s
iSCSI 1 GbE + NVMe backend671 Mbit/s940 Mbit/s
— iSCSI 10 GbE —
iSCSI 10 GbE + HDD backend671 Mbit/s1.440 Mbit/s
iSCSI 10 GbE + SSD backend2.770 Mbit/s4.240 Mbit/s
iSCSI 10 GbE + NVMe backend3.610 Mbit/s8.390 Mbit/s
— Ceph RBD (iSCSI-like block) —
Ceph RBD + HDD (3x rep)252 Mbit/s671 Mbit/s
Ceph RBD + SSD (3x rep)839 Mbit/s2.520 Mbit/s
Ceph RBD + NVMe (3x rep)1.510 Mbit/s4.190 Mbit/s
Ceph RBD + NVMe (EC 4+2)2.520 Mbit/s6.710 Mbit/s
— CephFS (NFS-like filesystem) —
CephFS + HDD (3x rep)210 Mbit/s587 Mbit/s
CephFS + SSD (3x rep)671 Mbit/s2.100 Mbit/s
CephFS + NVMe (3x rep)1.260 Mbit/s3.770 Mbit/s
— Hiperconvergência (Proxmox + Ceph) —
HCI + HDD (3x rep)168 Mbit/s503 Mbit/s
HCI + SSD (3x rep)587 Mbit/s1.680 Mbit/s
HCI + NVMe (3x rep)1.010 Mbit/s3.190 Mbit/s

Escrita sequencial em NFS com mount sync pode ser drasticamente mais lenta que async — o servidor confirma cada write no disco antes de responder. Verifique as opções de mount com nfsstat -m.

Referência — lat_p99_ms esperado (bs=1M, iodepth=16):

Dispositivo / Configuraçãop99 típico
— Local —
HDD 7200 RPM150–600 ms
SSD SATA III30–100 ms
NVMe Gen35–25 ms
NVMe Gen4/52–12 ms
— NFS (1/10 GbE) —
NFS + HDD backend250–800 ms
NFS + SSD backend80–250 ms
NFS + NVMe backend40–150 ms
— iSCSI (1/10 GbE) —
iSCSI + HDD backend180–600 ms
iSCSI + SSD backend50–180 ms
iSCSI + NVMe backend25–100 ms
— Ceph RBD —
Ceph RBD + HDD (3x rep)300–900 ms
Ceph RBD + SSD (3x rep)60–200 ms
Ceph RBD + NVMe (3x rep)20–80 ms
— CephFS —
CephFS + HDD (3x rep)400–1.200 ms
CephFS + SSD (3x rep)80–280 ms
CephFS + NVMe (3x rep)30–120 ms
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)500–1.500 ms
HCI + SSD (3x rep)100–350 ms
HCI + NVMe (3x rep)40–160 ms
— VM + NFS (Proxmox) —
VM + NFS + HDD backend300–1.000 ms
VM + NFS + SSD backend100–400 ms
VM + NFS + NVMe backend60–250 ms

5.3 Mixed Read/Write Sequencial ​

Simula cargas que leem e escrevem ao mesmo tempo. O resultado traz read e write separados.

Ajuste --rwmixread conforme o perfil: 70 = 70% leitura / 30% escrita; 30 = inverso.

bash
fio --name=seq_mixed \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=1M --rw=readwrite \
    --rwmixread=50 --ioengine=libaio \
    --direct=1 --iodepth=16 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      read: {
        bw_Mbit:    (.read.bw / 1024 * 8.388608 | round),
        iops:       (.read.iops | round),
        lat_p99_ms: (.read.clat_ns.percentile["99.000000"] / 1000000 | round)
      },
      write: {
        bw_Mbit:    (.write.bw / 1024 * 8.388608 | round),
        iops:       (.write.iops | round),
        lat_p99_ms: (.write.clat_ns.percentile["99.000000"] / 1000000 | round)
      }
    }'

Referência — cada direção recebe ~50% da banda total do dispositivo:

Dispositivo / ConfiguraçãoRead bw_MbitWrite bw_Mbitlat_p99_ms (cada)
— Local —
HDD 7200 RPM419–797 Mbit/s419–797 Mbit/s200–700 ms
SSD SATA III1.590–2.220 Mbit/s1.590–2.220 Mbit/s40–120 ms
NVMe Gen3950–14.010 Mbit/s950–14.010 Mbit/s8–30 ms
NVMe Gen420.010–27.990 Mbit/s20.010–27.990 Mbit/s3–15 ms
— NFS 1 GbE —
NFS 1 GbE + HDD backend2.470–3.510 Mbit/s2.470–3.510 Mbit/s250–800 ms
NFS 1 GbE + SSD backend2.820–3.870 Mbit/s2.820–3.870 Mbit/s80–300 ms
NFS 1 GbE + NVMe backend2.950–3.940 Mbit/s2.950–3.940 Mbit/s50–200 ms
VM + NFS + SSD backend336–1.170 Mbit/s336–1.170 Mbit/s100–400 ms
— NFS 10 GbE —
NFS 10 GbE + HDD backend377–797 Mbit/s377–797 Mbit/s200–600 ms
VM + NFS + NVMe backend419–1.470 Mbit/s419–1.470 Mbit/s60–250 ms
NFS 10 GbE + SSD backend1.430–2.220 Mbit/s1.430–2.220 Mbit/s40–150 ms
NFS 10 GbE + NVMe backend1.680–3.770 Mbit/s1.680–3.770 Mbit/s20–100 ms
— iSCSI 1 GbE —
iSCSI 1 GbE + HDD backend2.680–3.730 Mbit/s2.680–3.730 Mbit/s200–600 ms
iSCSI 1 GbE + SSD backend3.030–3.940 Mbit/s3.030–3.940 Mbit/s60–200 ms
iSCSI 1 GbE + NVMe backend3.160–4.010 Mbit/s3.160–4.010 Mbit/s40–150 ms
— iSCSI 10 GbE —
iSCSI 10 GbE + HDD backend403–721 Mbit/s403–721 Mbit/s180–550 ms
iSCSI 10 GbE + SSD backend1.380–2.110 Mbit/s1.380–2.110 Mbit/s35–120 ms
iSCSI 10 GbE + NVMe backend250–4.610 Mbit/s250–4.610 Mbit/s15–80 ms
— Ceph RBD —
Ceph RBD + HDD (3x rep)252–629 Mbit/s252–629 Mbit/s300–1.000 ms
Ceph RBD + SSD (3x rep)839–2.100 Mbit/s839–2.100 Mbit/s60–200 ms
Ceph RBD + NVMe (3x rep)1.510–3.770 Mbit/s1.510–3.770 Mbit/s20–80 ms
— CephFS —
CephFS + HDD (3x rep)210–545 Mbit/s210–545 Mbit/s400–1.200 ms
CephFS + SSD (3x rep)671–1.890 Mbit/s671–1.890 Mbit/s80–250 ms
CephFS + NVMe (3x rep)1.260–3.360 Mbit/s1.260–3.360 Mbit/s25–100 ms
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)168–503 Mbit/s168–503 Mbit/s500–1.500 ms
HCI + SSD (3x rep)587–1.680 Mbit/s587–1.680 Mbit/s100–350 ms
HCI + NVMe (3x rep)1.010–3.150 Mbit/s1.010–3.150 Mbit/s40–160 ms
— VM + NFS (Proxmox) —
VM + NFS + HDD backend210–545 Mbit/s210–545 Mbit/s300–1.000 ms

5.4 Leitura Aleatória (IOPS) ​

Simula queries de leitura em banco de dados, acesso a índices, cache miss. Métrica principal: iops.

Modo throughput — mede IOPS e banda máxima com fila profunda (iodepth=32 numjobs=4 = 128 I/Os simultâneos). Latências serão maiores que a latência pura do dispositivo — é o trade-off esperado.

bash
fio --name=rand_read_throughput \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=4k --rw=randread \
    --ioengine=libaio --direct=1 \
    --iodepth=32 --numjobs=4 \
    --group_reporting \
    --output-format=json \
  | jq '.jobs[0] | {
      iops:        (.read.iops | round),
      bw_Mbit:     (.read.bw / 1024 * 8.388608 | round),
      lat_p50_ms:  (.read.clat_ns.percentile["50.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p99_ms:  (.read.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p999_ms: (.read.clat_ns.percentile["99.900000"] / 1000000 | (. * 100 | round) / 100)
    }'

Modo leitura latência pura — mede a latência mínima real do dispositivo sem concorrência (iodepth=1 numjobs=1). Use para comparar com datasheets de fabricantes e com as tabelas abaixo.

bash
fio --name=rand_read_latency \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=4k --rw=randread \
    --ioengine=libaio --direct=1 \
    --iodepth=1 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      iops:        (.read.iops | round),
      bw_Mbit:     (.read.bw / 1024 * 8.388608 | round),
      lat_p50_ms:  (.read.clat_ns.percentile["50.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p99_ms:  (.read.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p999_ms: (.read.clat_ns.percentile["99.900000"] / 1000000 | (. * 100 | round) / 100)
    }'

As tabelas de IOPS/throughput abaixo refletem o modo throughput (iodepth=32, numjobs=4). As tabelas de latência refletem o modo latência pura (iodepth=1, numjobs=1). Compare cada resultado com a tabela correspondente ao modo que você rodou.

Referência — iops e throughput esperados (bs=4k, randread, iodepth=32, numjobs=4 — modo throughput):

Dispositivo / ConfiguraçãoIOPS mínIOPS máxbw_Mbit mínbw_Mbit máx
— Local —
HDD 7200 RPM752002.5 Mbit/s6.7 Mbit/s
SSD SATA III50.000100.0001.640 Mbit/s3.280 Mbit/s
NVMe Gen3300.000700.0009.830 Mbit/s22.930 Mbit/s
NVMe Gen4800.0001.200.00026.210 Mbit/s39.330 Mbit/s
NVMe Gen51.500.0002.500.00049.150 Mbit/s81.920 Mbit/s
— NFS 1 GbE —
NFS 1 GbE + HDD backend1.0005.00034 Mbit/s168 Mbit/s
NFS 1 GbE + SSD backend5.00015.000168 Mbit/s495 Mbit/s
— VM + NFS (Proxmox) —
NFS 1 GbE + NVMe backend8.00020.000260 Mbit/s654 Mbit/s
— NFS 10 GbE —
VM + NFS + HDD backend8003.00025 Mbit/s101 Mbit/s
NFS 10 GbE + HDD backend2.0008.00067 Mbit/s260 Mbit/s
VM + NFS + SSD backend5.00020.000168 Mbit/s654 Mbit/s
NFS 10 GbE + SSD backend20.00060.000654 Mbit/s1.960 Mbit/s
VM + NFS + NVMe backend10.00040.000327 Mbit/s1.310 Mbit/s
NFS 10 GbE + NVMe backend40.000150.0001.310 Mbit/s4.920 Mbit/s
— iSCSI 1 GbE —
iSCSI 1 GbE + HDD backend1.5006.00050 Mbit/s193 Mbit/s
iSCSI 1 GbE + SSD backend8.00020.000260 Mbit/s654 Mbit/s
iSCSI 1 GbE + NVMe backend10.00025.000327 Mbit/s822 Mbit/s
— iSCSI 10 GbE —
iSCSI 10 GbE + HDD backend3.00010.000101 Mbit/s327 Mbit/s
iSCSI 10 GbE + SSD backend30.000100.000981 Mbit/s3.280 Mbit/s
iSCSI 10 GbE + NVMe backend80.000300.0002.630 Mbit/s9.830 Mbit/s
— Ceph RBD —
Ceph RBD + HDD (3x rep)5003.00017 Mbit/s101 Mbit/s
Ceph RBD + SSD (3x rep)10.00050.000327 Mbit/s1.640 Mbit/s
Ceph RBD + NVMe (3x rep)30.000150.000981 Mbit/s4.920 Mbit/s
Ceph RBD + NVMe (EC 4+2)50.000250.0001.640 Mbit/s8.200 Mbit/s
— CephFS —
CephFS + HDD (3x rep)3002.0008.4 Mbit/s67 Mbit/s
CephFS + SSD (3x rep)8.00035.000260 Mbit/s1.150 Mbit/s
CephFS + NVMe (3x rep)20.000100.000654 Mbit/s3.280 Mbit/s
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)2001.5008.4 Mbit/s50 Mbit/s
HCI + SSD (3x rep)5.00025.000168 Mbit/s822 Mbit/s
HCI + NVMe (3x rep)15.00080.000495 Mbit/s2.630 Mbit/s

bw_Mbit em I/O aleatório 4k é derivado do IOPS: iops × 4096 ÷ 1.048.576 × 8,39. Para HDDs o valor é baixíssimo — o gargalo é a latência mecânica, não a banda.

Em storage de rede, o backend define o teto de IOPS; o link define o teto de throughput. Com NVMe backend em 1 GbE, o link satura antes do disco.

Referência — lat_p99_ms esperado (bs=4k, randread, iodepth=1, numjobs=1 — latência pura):

Dispositivo / Configuraçãop50 típicop99 típicop99,9 típico
— Local —
HDD 7200 RPM8–15 ms10–20 ms15–40 ms
SSD SATA III0,05–0,15 ms0,10–0,30 ms0,20–0,80 ms
NVMe Gen30,02–0,08 ms0,05–0,15 ms0,10–0,40 ms
NVMe Gen4/50,01–0,04 ms0,02–0,08 ms0,05–0,20 ms
— NFS (1/10 GbE) —
NFS + HDD backend5,0–15,0 ms12,0–30,0 ms20,0–60,0 ms
NFS + SSD backend1,0–3,0 ms3,0–10,0 ms6,0–20,0 ms
NFS + NVMe backend0,3–1,5 ms1,0–5,0 ms2,0–12,0 ms
— iSCSI (1/10 GbE) —
iSCSI + HDD backend3,0–10,0 ms8,0–20,0 ms15,0–40,0 ms
iSCSI + SSD backend0,5–2,0 ms1,5–6,0 ms3,0–15,0 ms
iSCSI + NVMe backend0,2–0,8 ms0,5–2,5 ms1,0–6,0 ms
— Ceph RBD —
Ceph RBD + HDD (3x rep)10,0–25,0 ms20,0–60,0 ms40,0–120,0 ms
Ceph RBD + SSD (3x rep)1,0–4,0 ms3,0–12,0 ms6,0–25,0 ms
Ceph RBD + NVMe (3x rep)0,3–1,5 ms1,0–5,0 ms2,0–12,0 ms
— CephFS —
CephFS + HDD (3x rep)15,0–35,0 ms25,0–80,0 ms50,0–150,0 ms
CephFS + SSD (3x rep)2,0–6,0 ms5,0–18,0 ms10,0–35,0 ms
CephFS + NVMe (3x rep)0,5–2,0 ms1,5–6,0 ms3,0–15,0 ms
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)20,0–50,0 ms35,0–100,0 ms60,0–200,0 ms
HCI + SSD (3x rep)3,0–8,0 ms6,0–20,0 ms12,0–40,0 ms
HCI + NVMe (3x rep)1,0–3,0 ms2,0–8,0 ms4,0–18,0 ms
— VM + NFS (Proxmox) —
VM + NFS + HDD backend8,0–20,0 ms15,0–40,0 ms25,0–80,0 ms
VM + NFS + SSD backend3,0–7,0 ms5,0–15,0 ms8,0–25,0 ms
VM + NFS + NVMe backend2,0–5,0 ms4,0–12,0 ms6,0–20,0 ms

5.5 Escrita Aleatória (IOPS) ​

Simula alto volume de inserções, updates e journaling de filesystem. Métrica principal: iops.

Modo throughput — mede IOPS e banda máxima com fila profunda.

bash
fio --name=rand_write_throughput \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=4k --rw=randwrite \
    --ioengine=libaio --direct=1 \
    --iodepth=32 --numjobs=4 \
    --group_reporting \
    --output-format=json \
  | jq '.jobs[0] | {
      iops:        (.write.iops | round),
      bw_Mbit:     (.write.bw / 1024 * 8.388608 | round),
      lat_p50_ms:  (.write.clat_ns.percentile["50.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p99_ms:  (.write.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p999_ms: (.write.clat_ns.percentile["99.900000"] / 1000000 | (. * 100 | round) / 100)
    }'

Modo latência pura — mede a latência mínima de escrita sem concorrência.

bash
fio --name=rand_write_latency \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=4k --rw=randwrite \
    --ioengine=libaio --direct=1 \
    --iodepth=1 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      iops:        (.write.iops | round),
      bw_Mbit:     (.write.bw / 1024 * 8.388608 | round),
      lat_p50_ms:  (.write.clat_ns.percentile["50.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p99_ms:  (.write.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100),
      lat_p999_ms: (.write.clat_ns.percentile["99.900000"] / 1000000 | (. * 100 | round) / 100)
    }'

As tabelas de IOPS/throughput abaixo refletem o modo throughput (iodepth=32, numjobs=4). As tabelas de latência refletem o modo latência pura (iodepth=1, numjobs=1).

Referência — iops e throughput esperados (bs=4k, randwrite, iodepth=32, numjobs=4 — modo throughput):

Dispositivo / ConfiguraçãoIOPS mínIOPS máxbw_Mbit mínbw_Mbit máx
— Local —
HDD 7200 RPM751502.5 Mbit/s5.0 Mbit/s
SSD SATA III40.00090.0001.310 Mbit/s2.950 Mbit/s
NVMe Gen3200.000600.0006.550 Mbit/s19.660 Mbit/s
NVMe Gen4600.0001.000.00019.660 Mbit/s32.770 Mbit/s
NVMe Gen51.200.0002.000.00039.330 Mbit/s65.540 Mbit/s
— NFS 1 GbE —
NFS 1 GbE + HDD backend5003.00017 Mbit/s101 Mbit/s
NFS 1 GbE + SSD backend3.00010.000101 Mbit/s327 Mbit/s
— VM + NFS (Proxmox) —
NFS 1 GbE + NVMe backend5.00015.000168 Mbit/s495 Mbit/s
— NFS 10 GbE —
VM + NFS + HDD backend4002.00017 Mbit/s67 Mbit/s
NFS 10 GbE + HDD backend1.0005.00034 Mbit/s168 Mbit/s
VM + NFS + SSD backend3.00012.000101 Mbit/s394 Mbit/s
VM + NFS + NVMe backend5.00025.000168 Mbit/s822 Mbit/s
NFS 10 GbE + SSD backend10.00040.000327 Mbit/s1.310 Mbit/s
NFS 10 GbE + NVMe backend20.00080.000654 Mbit/s2.630 Mbit/s
— iSCSI 1 GbE —
iSCSI 1 GbE + HDD backend8004.00025 Mbit/s134 Mbit/s
iSCSI 1 GbE + SSD backend5.00015.000168 Mbit/s495 Mbit/s
iSCSI 1 GbE + NVMe backend8.00020.000260 Mbit/s654 Mbit/s
— iSCSI 10 GbE —
iSCSI 10 GbE + HDD backend2.0008.00067 Mbit/s260 Mbit/s
iSCSI 10 GbE + SSD backend20.00070.000654 Mbit/s2.290 Mbit/s
iSCSI 10 GbE + NVMe backend50.000200.0001.640 Mbit/s6.550 Mbit/s
— Ceph RBD —
Ceph RBD + HDD (3x rep)2001.5008.4 Mbit/s50 Mbit/s
Ceph RBD + SSD (3x rep)5.00025.000168 Mbit/s822 Mbit/s
Ceph RBD + NVMe (3x rep)15.00080.000495 Mbit/s2.630 Mbit/s
Ceph RBD + NVMe (EC 4+2)8.00040.000260 Mbit/s1.310 Mbit/s
— CephFS —
CephFS + HDD (3x rep)1501.0008.4 Mbit/s34 Mbit/s
CephFS + SSD (3x rep)3.00015.000101 Mbit/s495 Mbit/s
CephFS + NVMe (3x rep)8.00050.000260 Mbit/s1.640 Mbit/s
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)100800<8.4 Mbit/s25 Mbit/s
HCI + SSD (3x rep)2.00010.00067 Mbit/s327 Mbit/s
HCI + NVMe (3x rep)5.00030.000168 Mbit/s981 Mbit/s

Referência — lat_p99_ms esperado (bs=4k, randwrite, iodepth=1, numjobs=1 — latência pura):

Dispositivo / Configuraçãop50 típicop99 típicop99,9 típico
— Local —
HDD 7200 RPM8–15 ms12–25 ms20–60 ms
SSD SATA III0,05–0,20 ms0,15–0,50 ms0,50–2,00 ms
NVMe Gen30,02–0,10 ms0,08–0,25 ms0,20–1,00 ms
NVMe Gen4/50,01–0,05 ms0,03–0,12 ms0,10–0,50 ms
— NFS (1/10 GbE) —
NFS + HDD backend8,0–20,0 ms15,0–40,0 ms30,0–100,0 ms
NFS + SSD backend2,0–6,0 ms5,0–18,0 ms10,0–40,0 ms
NFS + NVMe backend0,5–2,0 ms2,0–8,0 ms4,0–18,0 ms
— iSCSI (1/10 GbE) —
iSCSI + HDD backend5,0–15,0 ms10,0–30,0 ms20,0–70,0 ms
iSCSI + SSD backend0,8–3,0 ms2,5–10,0 ms5,0–25,0 ms
iSCSI + NVMe backend0,3–1,0 ms1,0–4,0 ms2,0–10,0 ms
— Ceph RBD —
Ceph RBD + HDD (3x rep)15,0–40,0 ms30,0–80,0 ms60,0–180,0 ms
Ceph RBD + SSD (3x rep)2,0–6,0 ms5,0–20,0 ms10,0–50,0 ms
Ceph RBD + NVMe (3x rep)0,5–2,0 ms2,0–8,0 ms4,0–20,0 ms
— CephFS —
CephFS + HDD (3x rep)20,0–60,0 ms40,0–120,0 ms80,0–250,0 ms
CephFS + SSD (3x rep)3,0–10,0 ms8,0–30,0 ms15,0–70,0 ms
CephFS + NVMe (3x rep)1,0–4,0 ms3,0–12,0 ms6,0–30,0 ms
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)30,0–80,0 ms60,0–180,0 ms120,0–400,0 ms
HCI + SSD (3x rep)5,0–15,0 ms10,0–40,0 ms20,0–90,0 ms
HCI + NVMe (3x rep)2,0–6,0 ms4,0–15,0 ms8,0–35,0 ms
— VM + NFS (Proxmox) —
VM + NFS + HDD backend10,0–25,0 ms20,0–60,0 ms40,0–120,0 ms
VM + NFS + SSD backend4,0–9,0 ms7,0–20,0 ms12,0–45,0 ms
VM + NFS + NVMe backend3,0–6,0 ms5,0–15,0 ms8,0–30,0 ms

Escrita aleatória tende a ter latência p99 e p99,9 mais alta que leitura no mesmo dispositivo — SSDs executam operações internas de garbage collection e wear leveling que podem causar stalls pontuais. Em NFS, escrita também pode ser afetada por flush de cache do servidor.

5.6 Mixed Aleatório — OLTP (70/30) ​

Simula carga típica de banco de dados OLTP: 70% leitura / 30% escrita aleatória. Resultado traz read e write separados.

Modo throughput — simula carga OLTP real com fila profunda (iodepth=64, numjobs=4). As latências refletidas aqui são as de produção sob carga, não a latência pura do dispositivo.

bash
fio --name=oltp_throughput \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=4k --rw=randrw \
    --rwmixread=70 --ioengine=libaio \
    --direct=1 --iodepth=64 --numjobs=4 \
    --group_reporting \
    --output-format=json \
  | jq '.jobs[0] | {
      read: {
        iops:       (.read.iops | round),
        bw_Mbit:    (.read.bw / 1024 * 8.388608 | round),
        lat_p99_ms: (.read.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100)
      },
      write: {
        iops:       (.write.iops | round),
        bw_Mbit:    (.write.bw / 1024 * 8.388608 | round),
        lat_p99_ms: (.write.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100)
      }
    }'

Modo latência pura — mede a latência de acesso OLTP sem concorrência, para comparar com os valores das tabelas abaixo.

bash
fio --name=oltp_latency \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=4k --rw=randrw \
    --rwmixread=70 --ioengine=libaio \
    --direct=1 --iodepth=1 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      read: {
        iops:       (.read.iops | round),
        lat_p99_ms: (.read.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100)
      },
      write: {
        iops:       (.write.iops | round),
        lat_p99_ms: (.write.clat_ns.percentile["99.000000"] / 1000000 | (. * 100 | round) / 100)
      }
    }'

Referência — IOPS total (read + write combinados), bs=4k, mix 70/30, iodepth=64, numjobs=4 — modo throughput:

Dispositivo / ConfiguraçãoIOPS totalbw_Mbit readbw_Mbit writelat_p99_ms
— Local —
HDD 7200 RPM100–250<8.4 Mbit/s<8.4 Mbit/s10–25 ms
SSD SATA III60.000–130.000839–1.640 Mbit/s361–705 Mbit/s0,15–0,40 ms
NVMe Gen3350.000–900.000950–20.640 Mbit/s408–8.850 Mbit/s0,08–0,20 ms
NVMe Gen4900.000–1.500.0002.461–34.410 Mbit/s1.055–14.750 Mbit/s0,03–0,10 ms
— NFS 1 GbE —
NFS 1 GbE + HDD backend1.000–5.0003–117 Mbit/s1–50 Mbit/s8,0–25,0 ms
NFS 1 GbE + SSD backend4.000–14.00011–319 Mbit/s5–134 Mbit/s4,0–15,0 ms
NFS 1 GbE + NVMe backend6.000–18.000134–411 Mbit/s7–176 Mbit/s3,0–12,0 ms
— NFS 10 GbE —
VM + NFS + SSD backend4.000–15.00011–344 Mbit/s5–151 Mbit/s5,0–18,0 ms
NFS 10 GbE + HDD backend2.000–8.0005–185 Mbit/s2–75 Mbit/s6,0–20,0 ms
VM + NFS + NVMe backend8.000–35.000185–805 Mbit/s9–344 Mbit/s4,0–14,0 ms
NFS 10 GbE + SSD backend15.000–55.000344–1.260 Mbit/s151–537 Mbit/s2,0–8,0 ms
NFS 10 GbE + NVMe backend30.000–120.000688–2.750 Mbit/s294–1.180 Mbit/s1,0–5,0 ms
— iSCSI 1 GbE —
iSCSI 1 GbE + HDD backend1.500–6.0004–134 Mbit/s2–59 Mbit/s6,0–20,0 ms
iSCSI 1 GbE + SSD backend6.000–18.000134–411 Mbit/s7–176 Mbit/s3,0–10,0 ms
iSCSI 1 GbE + NVMe backend8.000–22.000185–503 Mbit/s9–218 Mbit/s2,0–8,0 ms
— iSCSI 10 GbE —
iSCSI 10 GbE + HDD backend3.000–10.0008–226 Mbit/s3–101 Mbit/s5,0–18,0 ms
iSCSI 10 GbE + SSD backend25.000–80.000570–1.840 Mbit/s243–789 Mbit/s1,5–6,0 ms
iSCSI 10 GbE + NVMe backend60.000–220.0001.380–5.050 Mbit/s587–2.160 Mbit/s0,5–3,0 ms
— Ceph RBD —
Ceph RBD + HDD (3x rep)300–2.0001–42 Mbit/s<1–17 Mbit/s20,0–60,0 ms
Ceph RBD + SSD (3x rep)8.000–40.000185–914 Mbit/s9–394 Mbit/s4,0–15,0 ms
Ceph RBD + NVMe (3x rep)20.000–120.000461–2.750 Mbit/s193–1.180 Mbit/s1,5–6,0 ms
— CephFS —
CephFS + HDD (3x rep)200–1.2001–25 Mbit/s<8.4 Mbit/s30,0–90,0 ms
CephFS + SSD (3x rep)5.000–25.000117–570 Mbit/s6–243 Mbit/s6,0–20,0 ms
CephFS + NVMe (3x rep)12.000–80.000277–1.840 Mbit/s117–789 Mbit/s2,0–8,0 ms
— HCI (Proxmox + Ceph) —
HCI + HDD (3x rep)100–800<8.4 Mbit/s<8.4 Mbit/s40,0–120,0 ms
HCI + SSD (3x rep)3.000–15.0008–344 Mbit/s3–151 Mbit/s8,0–25,0 ms
HCI + NVMe (3x rep)8.000–40.000185–914 Mbit/s9–394 Mbit/s3,0–12,0 ms
— VM + NFS (Proxmox) —
VM + NFS + HDD backend800–3.0002–67 Mbit/s1–25 Mbit/s12,0–35,0 ms

bw_Mbit read e write no mix 70/30 refletem a proporção: read recebe ~70% das operações, write ~30%.

5.7 Storage em Rede (NFS, iSCSI, SAN, Ceph, HCI) ​

Quando o --filename aponta para um mount de rede, o FIO mede toda a cadeia: disco remoto + protocolo + stack de rede + latência do switch. Os valores serão sistematicamente piores que os de disco local — isso é esperado.

Ceph e Hiperconvergência — pontos específicos ​

O Ceph adiciona camadas além do protocolo de rede:

FatorImpacto
Replicação 3xCada escrita precisa ser confirmada em 3 OSDs antes de retornar ACK — latência de escrita é dominada pelo OSD mais lento
Erasure Coding (EC 4+2)Melhor throughput de leitura que 3x rep; escrita mais lenta por overhead de codificação
CRUSH map / PG placementOperações podem cruzar nós e racks — latência depende da topologia
OSD journal/WALCom WAL em NVMe e dados em HDD, escrita é rápida mas leitura ainda acessa HDD
Rede de cluster CephTráfego de replicação e rebalanceamento compete com I/O de cliente — recomendado rede dedicada
HCI (hiperconvergência)VM e OSDs Ceph no mesmo host competem por CPU, rede e cache — latência mais alta e menos previsível que Ceph dedicado

OSD WAL em NVMe: uma configuração comum é usar NVMe como WAL/DB e HDD como dados. O FIO verá latência de escrita próxima ao NVMe, mas leitura aleatória ainda será limitada pelo HDD — os valores de "HDD backend" nas tabelas representam esse cenário.

Antes de rodar, identifique o mount:

bash
# Ver tipo e opções do mount
mount | grep /mnt/storage

# Ver latência base da rede para o storage server
ping -c 20 <ip-do-storage-server>

A latência do ping é o piso absoluto de qualquer operação de I/O no storage. Se o ping já é 2 ms, nenhuma operação será mais rápida que isso — independente do disco remoto.

Referência — throughput sequencial (bs=1M) por tipo de storage em rede:

Protocolo / TecnologiaThroughput típicoCondição
NFS v3/v4 — 1 GbE5.630–7.740 Mbit/sLimitado pelo link (teto ~998 Mbit/s)
NFS v3/v4 — 10 GbE400–7.550 Mbit/sDepende do storage backend e CPU do servidor
NFS v4.2 — 25/100 GbE1.000–41.940 Mbit/sAlta performance; requer tuning de rsize/wsize
CIFS/SMB3 — 1 GbE503–839 Mbit/sOverhead de protocolo maior que NFS
CIFS/SMB3 — 10 GbE300–5.870 Mbit/sSMB Multichannel pode ajudar
iSCSI — 1 GbE671–965 Mbit/sMais próximo do disco local que NFS
iSCSI — 10 GbE500–9.230 Mbit/sBlock-level; menor overhead de protocolo
Fibre Channel (FC) 8G5.870–7.550 Mbit/s~6.710 Mbit/s teórico por porta
Fibre Channel (FC) 16G11.740–14.260 Mbit/sMuito comum em SANs corporativas
Fibre Channel (FC) 32G23.490–28.520 Mbit/sTipicamente com multipathing

Referência — latência por protocolo em rede (bs=4k, randread):

Protocololat_p50_ms típicolat_p99_ms típico
NFS — 1/10 GbE (LAN local)0,3–1,5 ms2–10 ms
NFS — WAN ou alta carga5–50 ms50–200 ms
iSCSI — 1/10 GbE0,2–1,0 ms1–8 ms
Fibre Channel0,1–0,5 ms0,5–3 ms
NVMe-oF (RDMA/RoCE)0,05–0,2 ms0,2–1 ms

Pontos de atenção específicos para storage em rede:

Sintoma no FIOCausa provável
bw_Mbit próximo de 998 Mbit/s e não sobeLink saturado em 1 GbE
lat_p999_ms muito acima do p99Retransmissões TCP ou congestionamento de switch
IOPS muito abaixo do esperado com bs=4kOpções rsize/wsize do NFS pequenas (padrão 4k–64k)
Throughput cai com numjobs > 1Storage server com CPU saturada ou lock contention
bw_Mbit inconsistente entre runsQoS ou throttling ativo no storage

Opções de mount NFS recomendadas para benchmarks:

bash
# Montar com rsize/wsize altos para maximizar throughput
mount -t nfs -o rsize=1048576,wsize=1048576,hard,timeo=600 \
  <servidor>:/export /mnt/storage

# Verificar opções ativas após o mount
nfsstat -m

rsize e wsize controlam o tamanho dos blocos de transferência NFS. O padrão costuma ser 64k–256k, o que limita o throughput mesmo em links de 10 GbE. Alinhe com o --bs do FIO para resultados representativos.

5.8 iodepth e numjobs por Tipo de Dispositivo ​

Dispositivoiodepth recomendadonumjobs recomendado
HDD8–161–2
SSD SATA16–321–4
NVMe Gen332–644–8
NVMe Gen4/564–1284–16
NFS / iSCSI32–644–8
FC / NVMe-oF64–1284–16

5.9 Limpeza Após os Testes ​

text
rm -f /home/$USER/fio_test.tmp

6. Interpretação da Saída ​

6.1 Saída no Formato Normal (--output-format=normal) ​

Exemplo de saída para leitura sequencial:

text
seq_read: (g=0): rw=read, bs=(R) 1024KiB-1024KiB, ioengine=libaio, iodepth=16
fio-3.33
Starting 1 process

seq_read: (groupid=0, jobs=1): err= 0: pid=12345: ...
  read: IOPS=512, BW=4.290 Mbit/s (537MB/s)(2048MiB/4000msec)
    slat (usec): min=5, max=320, avg=12.50, stdev=8.20
    clat (msec): min=1, max=85, avg=31.2, stdev=4.8
     lat (msec): min=1, max=85, avg=31.3
    clat percentiles (msec):
     |  1.00th=[   26],  5.00th=[   28], 10.00th=[   29], 20.00th=[   29],
     | 50.00th=[   31], 75.00th=[   33], 90.00th=[   36], 95.00th=[   38],
     | 99.00th=[   46], 99.50th=[   51], 99.90th=[   64], 99.99th=[   85]
  cpu          : usr=0.50%, sys=2.00%, ctx=2048, majf=0, minf=16399
  IO depths    : 1=0.1%, 2=0.1%, 4=0.1%, 8=0.1%, 16=99.5%, 32=0.0%

Run status group 0 (all jobs):
   READ: bw=4.290 Mbit/s (537MB/s), 4.290 Mbit/s-4.290 Mbit/s, io=2048MiB, run=4000-4000msec

6.2 O que cada linha significa ​

CampoSignificado
IOPS=512512 operações de I/O por segundo
BW=4.290 Mbit/sThroughput em mebibytes por segundo
(537MB/s)Mesmo valor em megabytes decimais (1 MiB = 1.048 MB)
slatSubmission latency — tempo para submeter a operação ao kernel
clatCompletion latency — tempo do kernel até completar a operação
latLatência total: slat + clat
clat percentilesDistribuição estatística das latências — p99 é o mais crítico
cpu usr/sysUso de CPU em userspace e kernel durante o teste
IO depthsDistribuição real das operações em fila

6.3 Sinais de Alerta na Saída ​

SituaçãoO que pode indicar
BW muito acima do esperado para o hardware/tmp é tmpfs — testando RAM
clat p99 muito maior que a médiaStalls periódicos (GC de SSD, throttling térmico)
cpu sys acima de 20%Saturação do driver ou limite de IRQ
IO depths: 1=99% com iodepth=16Device não suporta filas profundas (HDD ou driver limitado)

7. Parsing da Saída ​

A saída padrão do FIO (--output-format=normal) é verbosa e difícil de processar. O melhor fluxo é usar --output-format=json e pipar diretamente para jq, sem salvar arquivo intermediário — o resultado aparece limpo no terminal assim que o teste termina.

Unidades no JSON:bw vem em KiB/s (dividir por 1024 para MiB/s). Latências vêm em nanossegundos (dividir por 1.000.000 para ms).

7.1 Resumo Direto no Terminal ​

Pipe do FIO para jq em uma única linha — sem arquivo intermediário:

bash
fio --name=seq_read \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=1M --rw=read \
    --ioengine=libaio --direct=1 \
    --iodepth=16 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      job:          .jobname,
      bw_Mbit:      (.read.bw / 1024 * 8.388608 | round),
      iops:         (.read.iops | round),
      lat_p50_ms:   (.read.clat_ns.percentile["50.000000"] / 1000000 | round),
      lat_p99_ms:   (.read.clat_ns.percentile["99.000000"] / 1000000 | round),
      lat_p999_ms:  (.read.clat_ns.percentile["99.900000"] / 1000000 | round)
    }'

Saída:

json
{
  "job": "seq_read",
  "bw_Mbit": 4295,
  "iops": 512,
  "lat_p50_ms": 31,
  "lat_p99_ms": 46,
  "lat_p999_ms": 64
}

7.2 Resumo para Testes Mixed (Leitura + Escrita) ​

Quando o teste tem --rw=readwrite ou --rw=randrw, o JSON separa as métricas em .read e .write:

bash
fio --name=seq_mixed \
    --filename=/home/$USER/fio_test.tmp \
    --size=2G --bs=1M --rw=readwrite \
    --rwmixread=50 --ioengine=libaio \
    --direct=1 --iodepth=16 --numjobs=1 \
    --output-format=json \
  | jq '.jobs[0] | {
      job: .jobname,
      read: {
        bw_Mbit:     (.read.bw / 1024 * 8.388608 | round),
        iops:        (.read.iops | round),
        lat_p99_ms:  (.read.clat_ns.percentile["99.000000"] / 1000000 | round)
      },
      write: {
        bw_Mbit:     (.write.bw / 1024 * 8.388608 | round),
        iops:        (.write.iops | round),
        lat_p99_ms:  (.write.clat_ns.percentile["99.000000"] / 1000000 | round)
      }
    }'

7.3 Múltiplos Jobs com --numjobs > 1 ​

Com --numjobs=4 --group_reporting, o FIO agrega os resultados em um único job. O pipe funciona da mesma forma — basta trocar .jobs[0] pelo nome do job ou usar .jobs[] | select(.jobname == "nome"):

bash
fio ... --numjobs=4 --group_reporting --output-format=json \
  | jq '.jobs[] | select(.jobname == "rand_read") | {
      bw_Mbit:     (.read.bw / 1024 * 8.388608 | round),
      iops:        (.read.iops | round),
      lat_p99_ms:  (.read.clat_ns.percentile["99.000000"] / 1000000 | round)
    }'

7.4 Salvar JSON e Consultar Depois ​

Se preferir guardar o resultado para análise posterior:

bash
# Salvar
fio ... --output-format=json --output=resultado.json

# Consultar depois com jq
jq '.jobs[0] | {
  bw_Mbit:    (.read.bw / 1024 * 8.388608 | round),
  iops:       (.read.iops | round),
  lat_p99_ms: (.read.clat_ns.percentile["99.000000"] / 1000000 | round)
}' resultado.json

7.5 Exportar Múltiplos Resultados para CSV ​

Útil para consolidar uma bateria de testes em planilha:

bash
#!/bin/bash
# fio_to_csv.sh — agrega múltiplos JSONs do FIO em CSV
# Uso: bash fio_to_csv.sh resultado_*.json > resultados.csv

echo "arquivo,job,read_bw_Mbit,read_iops,read_p99_ms,write_bw_Mbit,write_iops,write_p99_ms"

for f in "$@"; do
  jq -r '.jobs[0] | [
    "'$f'",
    .jobname,
    (.read.bw  / 1024 | round),
    (.read.iops        | round),
    (.read.clat_ns.percentile["99.000000"]  / 1000000 | round),
    (.write.bw / 1024 | round),
    (.write.iops       | round),
    (.write.clat_ns.percentile["99.000000"] / 1000000 | round)
  ] | @csv' "$f"
done
text
bash fio_to_csv.sh resultado_*.json > resultados.csv

8. Referências de Performance ​

8.1 Throughput Sequencial (bs=1M) ​

DispositivoLeituraEscrita
HDD 7200 RPM100–200 MB/s80–180 MB/s
SSD SATA III400–560 MB/s350–530 MB/s
NVMe PCIe Gen32.000–3.500 MB/s1.500–3.000 MB/s
NVMe PCIe Gen45.000–7.000 MB/s4.000–6.500 MB/s
NVMe PCIe Gen510.000–14.000 MB/s9.000–12.000 MB/s

8.2 IOPS Aleatório (bs=4k) ​

DispositivoLeituraEscrita
HDD 7200 RPM75–200 IOPS75–150 IOPS
SSD SATA III50.000–100.000 IOPS40.000–90.000 IOPS
NVMe PCIe Gen3300.000–700.000 IOPS200.000–600.000 IOPS
NVMe PCIe Gen4800.000–1.200.000 IOPS600.000–1.000.000 IOPS
NVMe PCIe Gen51.500.000–2.500.000 IOPS1.200.000–2.000.000 IOPS

8.3 Latência Aleatória (bs=4k, iodepth=1) ​

DispositivoLatência média
HDD 7200 RPM5–15 ms
SSD SATA III0,05–0,1 ms
NVMe PCIe Gen30,02–0,05 ms
NVMe PCIe Gen4/50,01–0,03 ms

Latências acima de 2x o valor de referência indicam possível throttling térmico, fila saturada ou problema de driver.

9. Checklist de Execução ​

  • [ ] Verificar se /tmp é tmpfs com df -hT /tmp

  • [ ] Confirmar espaço livre ≥ 2× o valor de --size

  • [ ] Encerrar outras cargas de I/O durante o teste

  • [ ] Anotar o tipo do dispositivo testado (HDD / SSD SATA / NVMe Gen)

  • [ ] Usar --output-format=json para resultados parseáveis

  • [ ] Remover o arquivo de teste ao concluir

  • [ ] Comparar resultados com as referências embutidas em cada cenário (seção 5)

  • [ ] Verificar p99 de latência — médias podem esconder stalls pontuais

© 2026 Demainfra