Chegam menos bytes à unidade

O VDO é a camada de deduplicação e compressão do kernel Linux. Fica por baixo de um grupo de volumes e trabalha em blocos de 4 KiB. Cada bloco que já viu antes, guarda-o uma só vez.

O que isso significa para o hardware é simples. Chegam menos bytes à unidade. Escrevi através do VDO uma mistura que era 75% duplicada e 50% compressível, 30 segundos de cada vez, e os contadores da própria unidade disseram que ela recebeu 23 a 28% do que o convidado escreveu. Seis clones completos de um disco de modelo acrescentaram 8 blocos de dados entre todos. Trinta e dois kilobytes.

Bytes que chegaram à unidadeSem VDO, quaisquer dados100%VDO, 4k aleatório, 75% dup28%VDO, 128k, 75% dup23%VDO, 128k, dados aleatórios100%Fatia dos bytes do convidado que chegou à unidade, execuções de 30 s, média de duas. Mistura: 75% duplicada, 50% compressível.
Bytes escritos pelo convidado face aos bytes que a unidade recebeu, 30 segundos de cada carga, média de duas execuções. Sem VDO, a unidade recebe tudo. Com VDO, recebe cerca de um quarto de uma mistura realista, e a totalidade dos dados completamente aleatórios.

Menos bytes é menos desgaste, e menos trabalho para qualquer cache na unidade ou no controlador à frente dela. Para lá chegar custa CPU e latência, e numa unidade rápida esse custo é medido mais abaixo face ao mesmo Optane sem VDO nenhum. Em discos rotativos lentos, o mesmo custo desaparece nos tempos de procura, e é aí que isto fica interessante.

Há duas regras que moldam tudo o que se segue. A pilha é espesso sobre espesso: nada por cima do VDO, nem o próprio VDO, pode prometer mais espaço do que a unidade tem. E os metadados do próprio VDO, o índice e os diários, podem viver em NVMe enquanto os dados vivem num sítio mais lento.

Todos os números aqui vêm de um único anfitrião Proxmox VE 9.2, um Ryzen 7 5700G com 16 CPUs, kernel 7.0.14-25-pve, LVM 2.03.31 e as ferramentas vdo 8.3.1.1 da Debian, em duas unidades Intel Optane que foram apagadas no fim.

O que é o VDO e onde fica

O kernel descreve o dm-vdo como um alvo device-mapper que «provides block-level deduplication, compression, and thin provisioning»1. Cada bloco de 4 KiB que entra é passado por uma função de hash. Se um bloco idêntico já estiver guardado, o VDO regista uma referência em vez de uma cópia. Os blocos que não são duplicados passam pelo LZ4 e são empacotados vários num bloco físico, e os blocos só com zeros nem sequer são guardados2.

É o LVM que conduz tudo. O lvcreate --type vdo cria um pool VDO, que guarda os blocos reais, e um LV VDO por cima dele com o tamanho virtual que pedires2. Um grupo de volumes espesso vai para cima do LV VDO, e o Proxmox usa-o como armazenamento lvm normal.

Espesso sobre espesso: LVM sobre VDODiscos VM: LVs espessoso que os convidados veemGrupo de volumes vdovg, 35 GiBo que o Proxmox lê: armazenamento lvmO Proxmox não vê nada abaixo desta linhaLV VDO vdolv, 35 GiB virtuaisdedup, LZ4, blocos de zeros descartadosPool VDO vdopool, 40 GiBos blocos reais: o vdostats lê istoA unidade: nvme8n135 GiB virtuais, nunca mais do que guarda
O Proxmox vê um grupo de volumes espesso normal. O VDO fica por baixo do seu volume físico, dimensionado para nunca poder prometer mais do que a unidade guarda.
CamadaNome no laboratórioO que faz
Discos das VMsvm-9901-disk-0 e por aí foraLVs espessos, criados pelo Proxmox
Grupo de volumesvdovg, 35 GiBLVM simples, o que o armazenamento lvm do Proxmox lê
LV VDOvdolab/vdolv, 35 GiB virtuaisdeduplicação, LZ4, blocos de zeros descartados
Pool VDOvdolab/vdopool, 40 GiBos blocos reais, os metadados e o índice do VDO
Físiconvme8n1VG vdolab

Espesso sobre espesso, ou nada

O VDO é ele próprio um aprovisionador fino: ao LV VDO pode ser dado qualquer tamanho virtual. Torna-o maior do que o pool consegue guardar e o grupo de volumes por cima fica espesso sobre uma promessa, o que é fino sobre fino descido uma camada. Fiz exatamente isso na primeira construção, um LV VDO de 120 GiB num pool de 40 GiB, e o Proxmox mostrava um terço do armazenamento livre enquanto o VDO estava cheio.

Por isso dimensiona o LV VDO para o que o pool consegue realmente endereçar, nada mais. O lvcreate imprime esse número, «can address 36.00 GB» neste pool de 40 GiB, e o mapa de blocos do VDO para o espaço lógico sai do mesmo espaço, por isso dei-lhe 35 GiB.

Depois provei-o da maneira difícil. Um disco de VM a ocupar todas as extensões que o Proxmox lhe deu, 34 GiB, cheio de ponta a ponta com dados aleatórios com os quais o VDO não pode fazer nada:

# vdostats --human-readable
Device                    Size      Used Available Use% Space saving%
vdolab-vdopool-vpool     40.0G     38.1G      1.9G  95%            0%

O disco esgotou-se no seu próprio fim, como um disco espesso deve. O VDO ainda tinha 1,9 GiB livres, mais do que o 1 GiB que o Proxmox ainda tinha para atribuir. O número do Proxmox é o limite real, e o VDO não pode esgotar-se primeiro.

O que perdes é o sobrecompromisso: o espaço que a deduplicação poupa aparece como unidade que nunca chega a ser escrita, não como discos extra para o Proxmox. É a troca certa para este artigo, que é sobre o hardware. E também não ponhas um pool lvmthin por cima. Duas camadas finas são dois livros de contas3.

Quanto custa antes de guardares um byte

O VDO mantém um índice de deduplicação, o índice UDS, no próprio pool. Um pool vazio de 40 GiB reportava 4,0 GiB usados e 36,0 GiB disponíveis. O vdolistmetadata, do mesmo pacote vdo, lista todos os blocos de metadados do dispositivo, e explica quase tudo:

RegiãoBlocos de 4 KiBTamanho
Índice UDS679 1272,59 GiB
Diário de recuperação32 768128 MiB
Contagens de referências e diários, 18 slabs637225 MiB
Espaço pequeno demais para um décimo nono slab336 5551,28 GiB
Totalcerca de 4,0 GiB

Vale a pena saber a linha das sobras: os slabs têm 2 GiB, por isso dimensiona o pool em slabs inteiros mais a sobrecarga, ou o resto fica simplesmente por usar.

A RAM é a outra fatura. Paga-se esteja o pool ocupado ou parado:

CustoRegra do lvmvdo(7)Este pool de 40 GiB
Fixo38 MiB38 MiB
Cache do mapa de blocos1,15 MiB por MiB de cache, mínimo 150 MiB150 MiB (128 MiB por omissão)
Espaço físico268 MiB por TiB11 MiB
Índice UDS (denso)mínimo 250 MiB, o valor por omissão256 MiB
Totalcerca de 455 MiB

O índice denso por omissão cobre uma janela de deduplicação de cerca de 256 GiB, já que um índice denso com 1 GiB de RAM «maintains a 1 TiB deduplication window»2. A cache de 128 MiB do mapa de blocos está dimensionada para «efficient access to 100 GB of logical space at a time», e a documentação do kernel aponta-a como o valor mais importante a ajustar à medida que o conjunto de trabalho cresce1.

Construir a pilha

Deixar o LVM ver um PV num LV

O grupo de volumes fica num LV, e por omissão o LVM ignora LVs como volumes físicos. O devices/scan_lvs liga isso, e a referência do LVM traz o aviso que vem com ele: «Caution is required to avoid using PVs that belong to guest images stored on LVs»4. Um convidado que use LVM dentro do seu próprio disco veria, de outra forma, os seus grupos de volumes aparecerem no anfitrião.

Por isso o filtro também muda. Na mesma edição. O filtro de origem neste anfitrião só rejeitava zvols ZFS e dispositivos RBD. Acrescentei uma rejeição para todos os discos de VM do Proxmox:

# lvmconfig devices/global_filter devices/scan_lvs
global_filter=["r|/dev/zd.*|","r|/dev/rbd.*|","r|/dev/mapper/.*-(vm|base)--[0-9]+--disk--[0-9]+|"]
scan_lvs=1

A mesma referência diz que o scan_lvs «does not enable autoactivation of layered VGs»4. O Proxmox não precisa disso. O seu plugin LVM ativa cada disco com lvchange -aey quando a VM arranca5. Testei-o da forma como um arranque deixa as coisas, tudo desativado e depois as mesmas execuções udev do pvscan: o VG por baixo do VDO subiu, e o qm start ativou ele próprio o disco da VM. O senão está por baixo. Com o VG por baixo do VDO incompleto, o mesmo qm start falhou com «Volume group “vdovg” not found».

O pool VDO, espesso, com as definições na linha de criação

O formatador está no pacote vdo da Debian6:

# apt install vdo

Depois o pool. O -L é o espaço real, o -V o tamanho virtual, mantido dentro do que o pool consegue endereçar. A disposição das threads e o tamanho do discard vão na mesma linha, porque nenhum dos dois pode ser mudado depois sem parar todas as VMs do pool:

# pvcreate /dev/nvme8n1
  Physical volume "/dev/nvme8n1" successfully created.
# vgcreate vdolab /dev/nvme8n1
  Volume group "vdolab" successfully created
# lvcreate -y --type vdo -L 40G -V 35G -n vdolv vdolab/vdopool /dev/nvme8n1 --vdosettings "logical_threads=4 physical_threads=4 hash_zone_threads=2 cpu_threads=3 bio_threads=2 ack_threads=1 max_discard=4096"
  Wiping vdo signature on /dev/vdolab/vdopool.
    The VDO volume can address 36.00 GB in 18 data slabs, each 2.00 GB.
    It can grow to address at most 16.00 TB of physical storage in 8192 slabs.
    If a larger maximum size might be needed, use bigger slabs.
  Logical volume "vdolv" created.
# dmsetup table vdolab-vdopool-vpool
0 73402368 vdo V4 /dev/dm-7 10485760 4096 32768 16380 deduplication on compression on maxDiscard 4096 ack 1 bio 2 bioRotationInterval 64 cpu 3 hash 2 logical 4 physical 4

A disposição das threads é a que é medida mais abaixo para um anfitrião de 16 CPUs; o max_discard=4096 tem a sua própria secção.

O grupo de volumes e o armazenamento do Proxmox

# pvcreate /dev/vdolab/vdolv
  Physical volume "/dev/vdolab/vdolv" successfully created.
# vgcreate vdovg /dev/vdolab/vdolv
  Volume group "vdovg" successfully created
# pvesm add lvm vdo-lvm --vgname vdovg --content images,rootdir --on-volume-remove discard=1
# pvesm status | grep -E "Name|vdo-lvm"
Name             Type     Status     Total (KiB)      Used (KiB) Available (KiB)        %
vdo-lvm           lvm     active        36696064               0        36696064    0.00%

O on-volume-remove discard=1 importa, e é tratado mais abaixo.

O que a deduplicação poupou

Escrevi coisas que um anfitrião Proxmox guarda de facto e li os contadores de blocos do VDO depois de cada uma. logical blocks used é o que as camadas de cima escreveram; data blocks used é o que o VDO guardou. Ambos em blocos de 4 KiB.

O que foi escritoBlocos lógicos acrescentadosBlocos de dados acrescentadosPoupado
Rootfs do Rocky Linux 10, ext4 num disco de 4 GiB114 50560 53747%
Seis clones completos dele (qm clone --full, cerca de 4 s cada)6 291 456899,9999%
ISO do Proxmox Datacenter Manager 1.1, 1,36 GiB356 172351 9651,2%
A sua reconstrução -auto, praticamente os mesmos bytes356 3994099,99%
4 GiB de zeros1 048 5750100%
1 GiB de dados aleatórios262 143262 1440%

Cada clone escreveu os 4 GiB todos, zeros incluídos, porque um clone completo para um LV espesso copia todos os blocos. O VDO guardou os zeros como nada e o resto como referências.

O VDO é muito bom com dados que já viu antes. E com o nada. É inútil com dados que já estão comprimidos ou cifrados, e é por isso que a primeira ISO, sobretudo squashfs, poupou 1,2%.

Com o modelo e os seus seis clones no lugar, o Proxmox mostrava o armazenamento 80,01% usado, 28 GiB de discos espessos em 35. A unidade tinha 4,3 GiB, e a maior parte disso era o índice. Em armazenamento espesso é esse o ponto: o Proxmox conta o que foi atribuído, e a unidade carrega o que é realmente diferente.

O que a unidade recebe realmente

As poupanças em disco são uma fotografia. O hardware importa-se com o fluxo. Por isso medi os bytes que chegam à unidade durante a escrita: fio durante 30 segundos, o contador de escritas da unidade em /sys/block antes e depois, o mesmo Optane com e sem VDO, duas vezes cada.

O que foi comparado no OptaneOptane, sem VDOVDO, 16 threadsfio, 30 sLV simplesnvme8n1: contador de escritas lido aquifio, 30 sLV no vdovgLV VDO: dedup, LZ4pool VDOnvme8n1: contador de escritas lido aqui
As duas pilhas por trás de cada número com e sem VDO no Optane: os mesmos trabalhos fio, a mesma unidade, o contador de escritas lido em baixo.

O contador é honesto. Ao longo de toda a execução somou 794 GB, e o «Data Units Written» do SMART da própria unidade também se moveu 794 GB.

Carga, 30 sSem VDOCom VDO, 16 threadsBytes que chegam à unidade
Escrita aleatória 4k, QD32, 4 trabalhos, 75% dup, 50% compress582 013 IOPS, p99 244 µs460 887 IOPS, p99 1,05 ms28%
Escrita 128k, QD8, 75% dup, 50% compress2345 MiB/s, p99 490 µs2179 MiB/s, p99 1,02 ms23%
Escrita aleatória 4k, QD32, 4 trabalhos, dados aleatórios571 721 IOPS272 366 a 381 005 IOPS59 a 100%
Escrita 128k, QD8, dados aleatórios2346 MiB/s1051 a 1854 MiB/s100%

Numa mistura realista, o VDO manteve 79 a 93% do débito da unidade nua e enviou-lhe um quarto dos bytes. Com dados completamente aleatórios não poupa nada e custa muito, e as duas execuções discordaram tanto que só dou o intervalo.

A latência de cauda é o processamento do próprio VDO, não a unidade. Um p99 de cerca de um milissegundo, contra um quarto disso sem VDO.

O Optane não tem cache para aliviar

Estas unidades dizem-no elas próprias: vwc 0 no nvme id-ctrl, write through em /sys/block. Um Optane escreve no lugar sem área de passagem em DRAM ou SLC, por isso neste hardware o ganho são os bytes e o desgaste, não uma cache da unidade que enche mais devagar. Um SSD NAND com cache SLC, ou um controlador RAID com cache write-back, é onde menos bytes também compram capacidade de resposta. É a secção de RAID6 mais abaixo.

Ajustar as threads do VDO às CPUs

De origem, o LVM dá ao VDO dez threads: uma lógica, uma física, uma de zona de hash, duas de CPU, quatro de submissão bio, uma de confirmação. Num anfitrião de 16 CPUs isso deixa a maior parte da máquina parada enquanto o trabalho do mapa de blocos do VDO fica em fila atrás de uma única thread lógica.

A documentação do kernel explica os botões1. As threads lógicas são cada uma dona de «a disjoint section of the block map», as físicas de «a disjoint section of the data blocks», e ambas «can increase throughput», enquanto threads a mais «can waste resources and increase contention». As threads lógicas vão até 60, as físicas até 16, e o pool precisa de pelo menos um slab por thread física. Com 18 slabs, este tem espaço.

DisposiçãologicalphysicalhashcpubioackTotal
Valores por omissão do LVM11124110
Ajustada a 16 CPUs44232116
O dobro disso88462230

Cada disposição correu os mesmos trabalhos fio duas vezes, intercalados, com dados aleatórios, mais os sete discos clone lidos ao mesmo tempo, da forma como sete VMs arrancam juntas:

Teste, média de duas execuçõesPor omissãoAjustada a 16 CPUsO dobro disso
Escrita aleatória 4k, QD32, 4 trabalhos292 466 IOPS365 314 IOPS302 461 IOPS
p99 da escrita aleatória 4k, 4 trabalhos2,1 a 3,7 ms1,5 a 1,6 ms2,1 a 2,2 ms
Escrita sequencial 1M1153 MiB/s1729 MiB/s1507 MiB/s
Leitura aleatória 4k, QD32, 4 trabalhos507 450 IOPS503 827 IOPS485 263 IOPS
Sete discos clone lidos ao mesmo tempo7,5 s3,1 s3,4 s

A disposição ajustada ao número de CPUs ganha quase tudo: mais um quarto de escritas paralelas, mais metade nas escritas sequenciais, sete discos lidos 2,4 vezes mais depressa, e uma cauda mais apertada. Duplicar outra vez é pior em toda a linha. É a contenção de que a documentação avisa. Os valores por omissão foram também os menos estáveis, com a leitura dos sete discos a oscilar entre 6,1 e 8,8 s de uma execução para a outra.

Como tal, a regra é uma thread do VDO por CPU, distribuídas pelos tipos como acima, com as threads físicas limitadas pelo número de slabs.

Quanto custa o VDO em hardware rápido

O mesmo Optane sem VDO, contra o VDO com as threads ajustadas, dados aleatórios, média de duas execuções:

TesteOptane, sem VDOVDO, 16 threads
Escrita aleatória 4k, QD142 294 IOPS, 19,4 µs55 806 IOPS, 12,1 µs
Escrita aleatória 4k, QD32142 416 IOPS144 292 IOPS
Escrita aleatória 4k, QD32, 4 trabalhos572 293 IOPS365 314 IOPS
Leitura aleatória 4k, QD155 276 IOPS, 14,4 µs27 988 IOPS, 31,4 µs
Leitura aleatória 4k, QD32, 4 trabalhos586 463 IOPS503 827 IOPS
Escrita sequencial 1M, QD82348 MiB/s1729 MiB/s
Sete discos de modelo lidos ao mesmo tempo11,1 s3,1 s

Lê-o sem rodeios. Uma única leitura aleatória demora mais do dobro através do VDO. As escritas aleatórias paralelas perdem mais de um terço, as escritas sequenciais um quarto. Numa unidade tão rápida, os 17 µs de trabalho extra do VDO por leitura são a maior parte da leitura.

A escrita QD1 ser mais rápida através do VDO não é um almoço grátis. Longe disso. O VDO confirma uma escrita antes de ela estar na unidade, e a documentação do kernel diz claramente que «unflushed writes may or may not persist after a crash»1. Esse número mede uma confirmação. Um convidado que faça flush, e todos os sistemas de ficheiros fazem, recebe a durabilidade que pede.

A linha dos sete discos é a que o VDO ganha sem discussão, e vale a pena perceber porquê. Sete cópias simples têm de ler 28 GiB de bytes reais, zeros incluídos. O VDO lê um conjunto de blocos partilhados e salta os zeros.

Portanto, em flash rápido, o VDO troca latência por bytes. Cada um desses microssegundos é custo fixo, porém, e não cresce quando a unidade por baixo fica mais lenta.

Pôr os metadados do VDO em NVMe

O VDO não tem um dispositivo de metadados separado. Tudo vive no único LV do pool. Mas o código-fonte do dm-vdo mostra que a disposição é fixa, e um LV pode ser construído a partir de pedaços em unidades diferentes.

O código de formatação coloca as raízes do mapa de blocos a partir do início da região de dados, depois o resumo dos slabs e o diário de recuperação a partir do fim, e enche o meio com slabs7. O índice UDS fica antes de tudo isso, logo a seguir ao bloco de geometria. O vdolistmetadata confirmou-o no pool do laboratório:

BlocosO quêOnde fica
0 a 679 188geometria, índice UDS, superbloco, raízes do mapa de blocosos primeiros 2,59 GiB
dentro de cada slab de 2 GiBdados, folhas do mapa de blocos, 130 blocos de referências e um diário de slab de 224 blocosespalhados pelo pool
10 452 928 a 10 485 695diário de recuperaçãoos últimos 128 MiB, quase
10 485 696 a 10 485 759resumo dos slabsos últimos 256 KiB de todos

Por isso constrói o LV do pool em três pedaços: a cabeça em NVMe, o meio na unidade lenta, a cauda em NVMe.

VDO com os metadados em NVMeDiscos VM: LVs espessoso que os convidados veemGrupo de volumes vdovgo que o Proxmox lêLV VDO, 35 GiB virtuaisdedup, LZ4, zeros descartadoscabeçameio: os slabscaudaLV do pool VDO, três segmentosUnidade lenta: nvme8n1dados, contagens de referênciasNVMe: nvme6n1índice, raízes, diário de recuperação
A pilha completa com os metadados separados. O Proxmox vê o mesmo grupo de volumes; por baixo, o LV do pool são três segmentos em duas unidades.

Depois converte-o num pool VDO, o que o lvmvdo(7) documenta para um LV existente2. Aqui o nvme6n1 faz de NVMe e o nvme8n1 de unidade lenta:

# lvcreate -y -L 3G -n splitpool vdolab /dev/nvme6n1
  Logical volume "splitpool" created.
# lvextend -l +9408 vdolab/splitpool /dev/nvme8n1
  Size of logical volume vdolab/splitpool changed from 3.00 GiB (768 extents) to 39.75 GiB (10176 extents).
  Logical volume vdolab/splitpool successfully resized.
# lvextend -l +64 vdolab/splitpool /dev/nvme6n1
  Size of logical volume vdolab/splitpool changed from 39.75 GiB (10176 extents) to 40.00 GiB (10240 extents).
  Logical volume vdolab/splitpool successfully resized.
# lvconvert -y --type vdo-pool -n splitlv -V 35G vdolab/splitpool --vdosettings "logical_threads=4 physical_threads=4 hash_zone_threads=2 cpu_threads=3 bio_threads=2 ack_threads=1 max_discard=4096"
  WARNING: Converting logical volume vdolab/splitpool to VDO pool volume with formatting.
  THIS WILL DESTROY CONTENT OF LOGICAL VOLUME (filesystem etc.)
    The VDO volume can address 36.00 GB in 18 data slabs, each 2.00 GB.
    It can grow to address at most 16.00 TB of physical storage in 8192 slabs.
    If a larger maximum size might be needed, use bigger slabs.
  Logical volume "splitlv" created.
  Converted vdolab/splitpool to VDO pool volume and created virtual vdolab/splitlv VDO volume.

Depois confirma que o VDO pôs os metadados onde estão as extensões:

# vdolistmetadata /dev/mapper/vdolab-splitpool_vdata | grep -v "slab [0-9]* \(reference\|journal\)"
0 .. 0: geometry block
1 .. 679127: index
679128 .. 679128: super block
679129 .. 679188: block map tree roots
10452928 .. 10485695: recovery journal
10485696 .. 10485759: slab summary

Uma extensão são 1024 blocos. A cabeça em NVMe são as extensões 0 a 767, blocos 0 a 786 431, o que cobre o índice e as raízes, com cerca de 420 MiB dos dados do primeiro slab à boleia. A cauda em NVMe são as extensões 10 176 a 10 239, blocos 10 420 224 em diante, o que cobre o diário de recuperação e o resumo dos slabs.

Os metadados do VDO nas pontas, em NVMeextensões 0 a 767extensões 768 a 10 17510 176 a 10 239NVMe (nvme6n1)unidade lenta (nvme8n1)NVMe (nvme6n1)índice UDS, superbloco,raízes do mapa de blocos18 slabs: dados, folhas do mapa,contagens de refs, diários de slabdiário de recuperação,resumo dos slabsFora de escala: a cabeça tem 3 GiB, o meio 36,75 GiB, a cauda 256 MiB.
O LV do pool em três segmentos. Os metadados fixos do VDO ficam nas duas pontas, por isso as duas pontas vão para NVMe e os slabs vão para a unidade lenta.

Quanto do trabalho do VDO vai com eles, por execução de 30 segundos, contado por dispositivo:

CargaI/Os de escrita no NVMeI/Os de escrita na unidade de dadosFatia do NVMe
Escrita aleatória 4k, 75% dup, 50% compress388 430 a 538 2233,42 a 3,63 milhões10 a 13%
Escrita 128k, 75% dup, 50% compress458 214 a 634 1673,30 a 3,53 milhões12 a 15%
Escrita aleatória 4k, dados aleatórios181 457 a 384 5073,25 a 8,49 milhões4 a 5%
Leitura aleatória 4k0 escritas, 2% das leituras0

Mais ou menos um décimo das operações de escrita: o diário de recuperação, as atualizações do índice, e aquela fatia do slab 0 na cabeça em NVMe. São escritas de metadados pequenas e dispersas, o tipo que um disco rotativo pior aguenta. Em NVMe não são nada.

Dois limites. Os metadados por slab, contagens de referências, diários de slab e folhas do mapa de blocos, vivem dentro dos slabs, e ficam com os dados. E não testei aumentar um pool dividido. O diário é colocado a partir do fim, por isso depois de qualquer lvextend corre o vdolistmetadata outra vez e vê para onde foi antes de confiares nele.

VDO sobre bcache: um NVMe, dois trabalhos

O bcache é a outra maneira de pôr flash à frente de discos lentos. É o que já uso por baixo do Ceph em unidades rotativas, com todas as definições explicadas no artigo sobre o bcache. Por isso a pergunta é o que o VDO faz a uma cache bcache quando fica por cima dela.

Um NVMe faz os dois trabalhos de flash, dividido em duas partições:

DispositivoTamanhoTrabalho
nvme8n1p132 GiBcache do bcache, writeback
nvme8n1p28 GiBcabeça e cauda do VDO: índice, raízes, diário de recuperação, resumo dos slabs
nvme6n1349 GiBdispositivo de suporte do bcache, onde vivem os dados
/dev/bcache0349 GiBo meio do pool VDO, os slabs

As duas unidades são outra vez Optanes, por isso o nvme6n1 está a fazer de disco rotativo. Tem isso em mente em todos os números abaixo. O dispositivo de suporte aqui é rápido, por isso isto mede o que chega à cache, não quanto tempo um disco demora a esvaziá-la.

VDO sobre bcache: um NVMe, dois trabalhosDiscos VM: LVs espessoso que os convidados veemGrupo de volumes vdovgo que o Proxmox lêLV VDO, 35 GiB virtuaisdedup, LZ4, zeros descartadoscabeçameio: os slabscaudaLV do pool VDO, três segmentosbcache0, writebackum quarto dos bytes do convidadop1: a cachenvme6n1: dadoscache de 32 GiB, suporte de 349 GiBp2: metadados do VDOp1 e p2: um só Optane,nvme8n1
VDO sobre bcache. As pontas do pool vão para a partição de metadados, os slabs passam pelo bcache, e as duas partições partilham um Optane.

As partições e o conjunto de cache, com as definições desse artigo:

# sgdisk --zap-all /dev/nvme8n1
# sgdisk -n 1:0:+32G -c 1:bcache-cache -n 2:0:+8G -c 2:vdo-meta /dev/nvme8n1
# blockdev --rereadpt /dev/nvme8n1
# apt install bcache-tools
# make-bcache -C /dev/nvme8n1p1 -B /dev/nvme6n1 --writeback
# B=/sys/block/bcache0/bcache
# echo 0 > $B/sequential_cutoff
# echo 40 > $B/writeback_percent
# echo 81920 > $B/writeback_rate
# echo 20480 > $B/writeback_rate_minimum
# CS=/sys/fs/bcache/47bac36f-a1d5-4e8e-8695-2e7ff944172d
# echo 0 > $CS/congested_read_threshold_us
# echo 0 > $CS/congested_write_threshold_us

Essas linhas echo duram até ao próximo arranque. A regra udev do artigo sobre o bcache é o que as faz ficar.

Depois o pool, dividido da mesma forma que acima, com o nvme8n1p2 para as duas pontas e o bcache0 para o meio:

# pvcreate /dev/bcache0 /dev/nvme8n1p2
# vgcreate vdolab /dev/bcache0 /dev/nvme8n1p2
# lvcreate -y -L 3G -n vdopool vdolab /dev/nvme8n1p2
# lvextend -l +9408 vdolab/vdopool /dev/bcache0
# lvextend -l +64 vdolab/vdopool /dev/nvme8n1p2
# lvconvert -y --type vdo-pool -n vdolv -V 35G vdolab/vdopool --vdosettings "logical_threads=4 physical_threads=4 hash_zone_threads=2 cpu_threads=3 bio_threads=2 ack_threads=1 max_discard=4096"
# lvs -a --segments -o lv_name,lv_size,segtype,seg_start_pe,seg_size_pe,devices vdolab
  LV              LSize  Type     Start SSize Devices
  vdolv           35.00g vdo          0  8960 vdopool(0)
  vdopool         40.00g vdo-pool     0 10240 vdopool_vdata(0)
  [vdopool_vdata] 40.00g linear       0   768 /dev/nvme8n1p2(0)
  [vdopool_vdata] 40.00g linear     768  9408 /dev/bcache0(0)
  [vdopool_vdata] 40.00g linear   10176    64 /dev/nvme8n1p2(768)

O vdolistmetadata imprimiu os mesmos intervalos de blocos que a construção dividida, por isso o índice e os dois diários ficam no nvme8n1p2. O vdovg e o armazenamento do Proxmox vão para cima exatamente como antes.

O que chega à cache

A comparação é um LV de 8 GiB diretamente no bcache0 contra um LV de 8 GiB no vdovg, os mesmos trabalhos fio durante 30 segundos, duas vezes, com a cache esvaziada e limpa entre cada execução. Os contadores dos dispositivos em /sys/class/block dizem para onde foram os bytes.

O que foi comparado no bcachesó bcacheVDO sobre bcachefio, 30 sLV de 8 GiB no bcache0bcache0, writebackp1: a cachenvme6n1: dadosfio, 30 sLV de 8 GiB no vdovgLV e pool VDO, 16 threadsbcache0, writebackp2: metap1: a cachenvme6n1: dados
As duas pilhas por trás dos números do bcache. A mesma cache, a mesma unidade de suporte; a única diferença é o VDO por cima.
75% dup, 50% compress, 30 sSó bcacheVDO sobre bcache
Escrita aleatória 4k, QD32, 4 trabalhos212 222 e 205 585 IOPS390 206 e 304 757 IOPS
p991,89 e 2,04 ms1,45 e 2,54 ms
O convidado escreveu24,29 e 23,53 GiB44,67 e 34,88 GiB
Escrito na cache do bcache25,00 e 24,26 GiB11,48 e 10,44 GiB
Escrito na partição de metadados do VDO1,18 e 0,59 GiB
Escritas na cache por byte do convidado103%26 e 30%
Deixado sujo na cache no fim6,0 e 6,5 GiB5,5 e 5,2 GiB
Escrita 128k, QD82001 e 1985 MiB/s1878 e 1416 MiB/s
Escritas na cache por byte do convidado, 128k101%24 e 27%

O bcache sozinho chegou ao máximo de cerca de 210 000 escritas pequenas por segundo, e escreveu cada byte na cache mais 3% seus. Põe o VDO à frente e a cache recebeu um quarto dos bytes. Na primeira execução, a mesma cache aguentou então 390 206 escritas por segundo, quase o dobro, e mesmo assim acabou com menos dados sujos à espera da unidade lenta. A cache era o limite. O VDO mudou-o de sítio.

A segunda execução é a honesta para um pool que já está em uso. O fio semeia os seus geradores da mesma maneira em todas as execuções, por omissão8, por isso a segunda execução escreveu dados que o índice já tinha visto, a apontar para blocos que entretanto tinham sido descartados. O VDO trata o índice como pistas e lê cada bloco candidato para verificar que é mesmo um duplicado antes de o partilhar9. Durante um teste só de escrita, essa segunda execução leu 7,11 GiB de volta da cache e 1,20 GiB da unidade de dados. A primeira leu 0,12 GiB. Um conselho desatualizado não é de graça, e num pool onde as VMs vêm e vão vai haver sempre algum.

Os dados aleatórios são o outro lado da questão:

Dados aleatórios, 30 sSó bcacheVDO sobre bcache
Escrita aleatória 4k, QD32, 4 trabalhos205 984 e 203 066 IOPS203 186 e 85 882 IOPS
p992,04 e 2,15 ms5,7 e 17,7 ms
Escrita 128k, QD82038 e 2017 MiB/s878 e 357 MiB/s
Leitura aleatória 4k, QD136 609 e 36 639 IOPS, 21,6 µs26 345 e 26 202 IOPS, 33,6 e 33,7 µs
Leitura aleatória 4k, QD32, 4 trabalhos471 585 e 471 730 IOPS335 461 e 336 941 IOPS

Nada para poupar, por isso o VDO é pura sobrecarga, e na execução com o índice desatualizado mais do que reduziu para metade as escritas pequenas. Todas as leituras nas duas colunas vieram da cache. Os 12 µs a mais do VDO são o mesmo custo fixo que acrescenta no Optane nu.

Portanto, onde os dados se repetem, os dois empilham-se bem. A cache recebe um quarto dos bytes, aguenta uma rajada durante mais tempo, e tem menos para escrever de volta para os discos. Onde não se repetem, o bcache fica melhor sozinho.

Em RAID6 de hardware com HDD: raciocinado, não medido

Não tenho nenhum anfitrião com RAID6 em HDD onde testar, por isso esta secção é raciocínio construído sobre as medições acima. Mede o teu próprio array antes de confiares nela.

VDO em RAID6 com HDD, raciocinadoDiscos VM: LVs espessoso que os convidados veemGrupo de volumes vdovgo que o Proxmox lêLV VDO, espessodedup, LZ4, zeros descartadoscabeçameio: os slabscaudaLV do pool VDO, três segmentosDisco virtual RAID6um quarto dos bytes do convidadoCache write-back do controladorquatro vezes a folgaHDDsuma procura engole os 17 µs do VDONVMeíndice e diários fora dos discos
A pilha sobre a qual esta secção raciocina, não uma que eu tenha medido: slabs no disco virtual RAID6 atrás da cache do controlador, índice e diários num NVMe.
Em RAID6 com HDDO que o VDO muda
Escritas que chegam ao arraycerca de um quarto, numa mistura como a que foi medida
Cache write-back do controladorenche a um quarto do ritmo, por isso aguenta uma rajada cerca de quatro vezes mais tempo
Custo de CPU do VDO17 µs por leitura, perdidos dentro de uma procura de 5 a 10 ms
Escritas do diário de recuperaçãomais ou menos um décimo dos I/Os de escrita, pequenas e com flush: põe-nas em NVMe
Consultas ao índicevigia o dedupe advice timeouts no vdostats; em armazenamento lento o VDO pode desistir de procurar e escrever o duplicado na mesma
Ler um clone do princípio ao fimmais lento: os seus blocos apontam para os do modelo, espalhados pelo array

As duas primeiras linhas são a resposta do hardware. Enquanto a cache do controlador, com bateria ou com flash, tem espaço, o convidado vê a latência da cache. Quando enche, o convidado vê os discos. Manda-lhe um quarto dos bytes e a mesma cache dá cerca de quatro vezes a folga, e tem um quarto para esvaziar. A secção do bcache acima é isso medido com uma cache em software no lugar da do controlador.

A terceira é a razão pela qual o VDO pertence mais aos discos lentos do que aos rápidos. No Optane, o VDO duplicou a latência de leitura. Em unidades de 7200 rpm, o mesmo custo fixo desaparece numa procura.

As três últimas são os custos. Uma tempestade de arranque de clones idênticos fica mais rápida, mas um clone lido de ponta a ponta fica mais lento, porque a deduplicação o espalha. E as pequenas escritas do próprio VDO também caem no array, que é o argumento a favor da disposição dividida acima: índice e diário em NVMe, slabs no RAID6.

Apagar um disco: fazer o Proxmox descartá-lo

Remover um LV liberta as suas extensões no LVM. Não diz ao VDO que os blocos estão por usar, por isso o VDO fica com eles. A documentação do kernel diz porque é que isso importa: «If the vdo is thinly provisioned, discarding unused blocks is essential to prevent the target from running out of space»1. Em armazenamento espesso não se pode esgotar, mas os blocos não descartados continuam a ser espaço de unidade reservado para dados que não são de ninguém.

A opção on-volume-remove discard=1 no armazenamento é a solução. O Proxmox descreve-a como emitir «discard (TRIM) requests before removal»5:

ApagarBlocos VDO libertados
armazenamento lvm simples, um disco com 1 GiB0
com on-volume-remove discard=1, o mesmo262 140, o 1 GiB todo

Mas é lento num disco grande. Apagar o disco de 34 GiB do teste de enchimento levou 262,6 s ao Proxmox, enquanto o blkdiscard no mesmo tipo de dados despachou 15 GiB em 2,25 s. Por isso, para tudo o que for grande, faz blkdiscard ao disco primeiro e depois apaga-o.

O tamanho do discard também importa. O max_discard por omissão do VDO é um bloco de 4 KiB por pedido1:

Discard de 15 GiB de dados aleatóriosTempo decorridoCPU (sys)
max_discard=1, o valor por omissão8,06 s8,06 s
max_discard=4096, 16 MiB2,25 s0,00 s

Dentro dos convidados, liga a opção Discard da unidade para que o TRIM deles chegue ao armazenamento10, e corre o fstrim de forma agendada.

Onde merece o seu lugar

ServeNão serve
muitas VMs a partir dos mesmos poucos modelosbases de dados e trabalho limitado pela latência em profundidade
RAID6 em HDD atrás de uma cache write-back do controladorum anfitrião todo NVMe que precisa de cada microssegundo
dados em discos rotativos com um NVMe para os metadados do VDOdados já comprimidos: multimédia, cópias de segurança, ISO
bcache à frente de dados rotativos, onde os dados se repetembcache à frente de dados que não se repetem
unidades em que a resistência à escrita é o limitediscos de convidados cifrados, que nunca deduplicam
um anfitrião com meio gigabyte de RAM de sobra por poolum pool pequeno, onde o índice come um décimo
DefiniçãoPor omissãoDefine-a comoMudá-la depois
Tamanho virtual do VDO -Vo que pediresnão mais do que o pool consegue endereçarsó aumentar, nunca encolher
Threads do VDO10, uma lógicauma por CPU, distribuídas como acimasó com as VMs do pool paradas
max_discard1, que são 4 KiB4096, que são 16 MiBsó com as VMs do pool paradas
on-volume-remove no armazenamentonão definidodiscard=1sim, pvesm set
Discard em cada disco virtualdesligadoligadosim, por disco
scan_lvs e o filtro0, sem rejeição de discos de VM1, discos de VM rejeitadossim, no lvm.conf

Nada disto é difícil. Nada disto é o valor por omissão.

A escrita mais barata é a que nunca envias

O que me impressiona no VDO é quão mal ele é vendido. Aparece como uma maneira de pôr num disco mais do que o disco guarda, e essa é a coisa menos útil que faz. Fi-lo sem querer na primeira construção, e o Proxmox mostrava um terço do armazenamento livre enquanto o VDO estava cheio. O sobrecompromisso é um empréstimo, e a unidade cobra-o à velocidade máxima de escrita.

O valor real está na linha que a maior parte das pessoas nunca mede. Um quarto dos bytes a chegar à unidade é um quarto do desgaste e uma cache do controlador que dura quatro vezes mais. Isso não é capacidade. É o hardware a fazer menos trabalho para o mesmo resultado, que é o único tipo de poupança que não volta para te morder.

Custa CPU, e em flash rápido custa latência, e ambos são fixos. É essa a troca, dita sem rodeios: tempo de processador gasto para que a parte lenta e cara da máquina faça menos. Em discos rotativos atrás de um controlador RAID ou de um bcache, com o índice e o diário num NVMe, essa conta sai bem. Num anfitrião todo Optane, na maior parte dos casos não sai.

E não toma conta de si próprio. Todos os valores por omissão que importam estão errados para este trabalho: dez threads em dezasseis CPUs, um tamanho de discard que queima um núcleo, um tamanho virtual que se pode pôr em qualquer coisa, e nada na configuração do armazenamento a dizer ao Proxmox para devolver espaço. Nada disso está escondido. Está tudo na documentação.

Por isso constrói-o espesso, uma vez, como deve ser, com as definições na linha de criação e os metadados onde pertencem. Faz isso e a unidade faz um quarto do trabalho. Salta isso e compraste mais uma camada que promete mais do que tem.


  1. Linux kernel documentation — dm-vdo — o alvo «provides block-level deduplication, compression, and thin provisioning»; «If the vdo is thinly provisioned, discarding unused blocks is essential to prevent the target from running out of space»; «unflushed writes may or may not persist after a crash»; a cache de 128 MB do mapa de blocos permite «efficient access to 100 GB of logical space at a time»; os parâmetros das threads, os seus limites e as orientações de afinação; maxDiscard «in 4096-byte blocks». ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. lvmvdo(7) — Support for Virtual Data Optimizer in LVM — pool VDO e LV VDO, a conversão de um LV existente com lvconvert --type vdo-pool, o uso de memória, o índice denso e a sua janela de 1 TiB por GiB de RAM, e «You cannot reduce the size of a VDOPoolLV». ↩︎ ↩︎ ↩︎ ↩︎

  3. Linux kernel source — drivers/md/dm-thin.c — o disable_discard_passdown_if_not_supported() desliga a passagem do discard quando o dispositivo de dados não consegue receber um bloco fino inteiro, que é o que o valor por omissão do VDO faz por baixo de um thin pool. ↩︎

  4. LVM2 — conf/example.conf.in — devices/scan_lvs: «Caution is required to avoid using PVs that belong to guest images stored on LVs» e «This option does not enable autoactivation of layered VGs». ↩︎ ↩︎

  5. Proxmox pve-storage — LVMPlugin.pm — a propriedade on-volume-remove, «Use ‘discard=1’ to issue discard (TRIM) requests before removal»; os volumes são ativados individualmente com lvchange -aey em vez de vgchange -aly. ↩︎ ↩︎

  6. Debian trixie — package vdo — «Management tools for Virtual Data Optimizer», versão 8.3.1.1-1, que fornece o vdoformat, o vdostats e o vdolistmetadata. ↩︎

  7. Linux kernel source — drivers/md/dm-vdo/encodings.c — o vdo_initialize_layout() cria a partição do mapa de blocos no início, as partições do resumo dos slabs e do diário de recuperação no fim, e o depósito de slabs com o que sobra. ↩︎

  8. fio documentation — randrepeat — «Seed all random number generators in a predictable way so the pattern is repeatable across runs. Default: true.» ↩︎

  9. Linux kernel documentation — Design of dm-vdo — «vdo treats the locations in the index as hints, and reads each indicated block to verify that it is indeed a duplicate before sharing the existing block with a new one.» ↩︎

  10. Proxmox VE documentation — Qemu/KVM Virtual Machines, Trim/Discard — «For the guest to be able to issue TRIM commands, you must enable the Discard option on the drive.» ↩︎