到达硬盘的字节更少

VDO 是 Linux 内核里的去重和压缩层。 它坐在卷组下面,以 4 KiB 的块为单位工作。它以前见过的每一个块,都只存一次。

这对硬件意味着什么很简单。到达硬盘的字节更少。 我通过 VDO 写了一组 75% 重复、50% 可压缩的混合数据,每次 30 秒,硬盘自己的计数器说它收到的是客户机写入量的 23% 到 28%。 一个模板磁盘的六个完整克隆,加起来只多出 8 个数据块。三十二 KB。

到达硬盘的字节无 VDO,任何数据100%VDO,4k 随机,75% 重复28%VDO,128k,75% 重复23%VDO,128k,随机数据100%客户机字节中到达硬盘的比例,每次 30 秒,两次平均。混合数据:75% 重复,50% 可压缩。
客户机写入的字节与硬盘收到的字节,每种负载 30 秒,两次运行取平均。没有 VDO,硬盘收到全部。有 VDO,现实的混合数据它只收到大约四分之一,完全随机的数据则一样不少。

字节更少就是磨损更少,硬盘上或它前面控制器里的任何缓存要干的活也更少。 要做到这一点得付出 CPU 和延迟,在快硬盘上这个代价下面会和同一块完全不带 VDO 的 Optane 对比着量出来。 在慢速的机械硬盘上,同样的代价会消失在寻道时间里,这才是有意思的地方。

两条规则决定了后面的一切。 这个栈是厚上加厚:VDO 上面的任何东西,以及 VDO 自己,都不能承诺比硬盘实际容量更多的空间。 而且 VDO 自己的元数据,也就是它的索引和日志,可以放在 NVMe 上,数据则放在更慢的地方。

这里的每个数字都来自同一台 Proxmox VE 9.2 主机:Ryzen 7 5700G,16 个 CPU,内核 7.0.14-25-pve,LVM 2.03.31 和 Debian 的 vdo 8.3.1.1 工具,用的是两块事后清空了的 Intel Optane 硬盘。

VDO 是什么,放在哪里

内核把 dm-vdo 描述为一个 device-mapper 目标,它 “provides block-level deduplication, compression, and thin provisioning”1。 每个进来的 4 KiB 块都会被计算哈希。如果已经存了一个完全相同的块,VDO 只记一个引用,而不是再存一份。 不重复的块会经过 LZ4 压缩,几个打包进一个物理块;全零的块则根本不存2。

整件事由 LVM 驱动。 lvcreate --type vdo 创建一个 VDO 池,存放真正的块,并在它上面创建一个 VDO LV,虚拟大小随你指定2。 一个厚置备的卷组放在 VDO LV 上,Proxmox 把它当作普通的 lvm 存储来用。

厚上加厚:VDO 上的 LVM虚拟机磁盘:厚置备 LV客户机看到的卷组 vdovg,35 GiBProxmox 读的:lvm 存储这条线以下 Proxmox 什么都看不到VDO LV vdolv,35 GiB 虚拟去重、LZ4、丢弃全零块VDO 池 vdopool,40 GiB真实的块:vdostats 读这里硬盘:nvme8n1虚拟 35 GiB,永远不超过实际容量
Proxmox 看到的是一个普通的厚置备卷组。VDO 坐在它的物理卷下面,大小定得让它永远不会承诺超过硬盘容量的空间。
层实验里的名字作用
虚拟机磁盘vm-9901-disk-0 等厚置备 LV,由 Proxmox 创建
卷组vdovg,35 GiB普通 LVM,Proxmox 的 lvm 存储读的就是它
VDO LVvdolab/vdolv,35 GiB 虚拟去重、LZ4、丢弃全零块
VDO 池vdolab/vdopool,40 GiB真正的块、VDO 的元数据和索引
物理设备nvme8n1VG vdolab

要么厚上加厚,要么别做

VDO 本身就是一个精简置备器:VDO LV 可以给任意虚拟大小。 把它设得比池能装的更大,上面的卷组就是厚置备在一个承诺之上,那就是把精简套精简往下挪了一层。 我第一次搭的时候恰恰就这么干了:40 GiB 的池上一个 120 GiB 的 VDO LV。结果 VDO 已经满了,Proxmox 还显示有三分之一的存储空闲。

所以 VDO LV 的大小要按池实际能寻址的来定,不能多。 lvcreate 会打印这个数字,在这个 40 GiB 的池上是 “can address 36.00 GB”,而 VDO 用于逻辑空间的块映射也从同一块地方里出,所以我给了 35 GiB。

然后我用笨办法证明了它。 一块虚拟机磁盘拿走 Proxmox 肯给的全部 extent,34 GiB,从头到尾填满 VDO 完全无能为力的随机数据:

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

磁盘在它自己的尽头用完了空间,厚置备磁盘就该这样。VDO 还剩 1.9 GiB 空闲,比 Proxmox 剩下可分配的 1 GiB 还多。 Proxmox 的数字才是真正的上限,VDO 不可能先用完。

你放弃的是超配:去重省下的空间体现为硬盘上从未被写入的部分,而不是给 Proxmox 多出来的磁盘。 对这篇讲硬件的文章来说,这是正确的取舍。 也别在上面放 lvmthin 池。两层精简置备就是两本账3。

存一个字节之前就要付的代价

VDO 在池本身上维护一个去重索引,即 UDS 索引。 一个空的 40 GiB 池报告已用 4.0 GiB,可用 36.0 GiB。 同一个 vdo 软件包里的 vdolistmetadata 会列出设备上的每一个元数据块,几乎能把这些空间全部对上账:

区域4 KiB 块数大小
UDS 索引679,1272.59 GiB
恢复日志32,768128 MiB
引用计数和日志,18 个 slab6,37225 MiB
不够再放第十九个 slab 的空间336,5551.28 GiB
合计约 4.0 GiB

剩余那一行值得知道:slab 是 2 GiB,所以池的大小要按整数个 slab 加上开销来定,否则余下的部分就白白闲着。

内存是另一笔账。不管池是忙是闲,都得付:

开销lvmvdo(7) 里的规则这个 40 GiB 的池
固定38 MiB38 MiB
块映射缓存每 MiB 缓存 1.15 MiB,最少 150 MiB150 MiB(默认 128 MiB)
物理空间每 TiB 268 MiB11 MiB
UDS 索引(dense)最少 250 MiB,默认值256 MiB
合计约 455 MiB

默认的 dense 索引覆盖大约 256 GiB 的去重窗口,因为一个配 1 GiB 内存的 dense 索引 “maintains a 1 TiB deduplication window”2。 128 MiB 的块映射缓存是按 “efficient access to 100 GB of logical space at a time” 来定的,内核文档把它列为随着工作集增长最需要调整的值1。

搭建这个栈

让 LVM 看到 LV 上的 PV

卷组坐在一个 LV 上,而 LVM 默认不把 LV 当作物理卷。 devices/scan_lvs 打开这个功能,LVM 的参考文档附带了相应的警告:“Caution is required to avoid using PVs that belong to guest images stored on LVs”4。 否则,一个在自己磁盘里用 LVM 的客户机,它的卷组就会出现在宿主机上。

所以过滤器也要改。同一次修改。 这台主机上的默认过滤器只拒绝 ZFS zvol 和 RBD 设备。我加了一条,拒绝所有 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

同一份参考文档说 scan_lvs “does not enable autoactivation of layered VGs”4。 Proxmox 并不需要它。它的 LVM 插件在虚拟机启动时用 lvchange -aey 激活每块磁盘5。 我按开机后的状态测试过:所有东西都停用,然后跑同样的 pvscan udev 流程。VDO 下面的 VG 起来了,qm start 自己激活了虚拟机的磁盘。 问题在更下面一层。VDO 下面的 VG 不完整时,同样的 qm start 失败,报 “Volume group ‘vdovg’ not found”。

VDO 池,厚置备,设置写在创建命令里

格式化工具在 Debian 的 vdo 软件包里6:

# apt install vdo

然后是池。 -L 是真实空间,-V 是虚拟大小,保持在池能寻址的范围内。 线程布局和 discard 大小写在同一行,因为这两样以后要改,都得先停掉池上的所有虚拟机:

# 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

线程布局是后面为 16 个 CPU 的主机测出来的那一套;max_discard=4096 有单独一节。

卷组和 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%

on-volume-remove discard=1 很要紧,下面会讲。

去重省下了什么

我写入了 Proxmox 主机真正会存的东西,每写完一样就读一次 VDO 的块计数器。 logical blocks used 是上层写入的量;data blocks used 是 VDO 实际存下的量。两者都以 4 KiB 块计。

写入的内容新增逻辑块新增数据块节省
Rocky Linux 10 根文件系统,4 GiB 磁盘上的 ext4114,50560,53747%
它的六个完整克隆(qm clone --full,每个约 4 秒)6,291,456899.9999%
Proxmox Datacenter Manager 1.1 ISO,1.36 GiB356,172351,9651.2%
它的 -auto 重建版,字节几乎相同356,3994099.99%
4 GiB 全零1,048,5750100%
1 GiB 随机数据262,143262,1440%

每个克隆都写满了 4 GiB,连零一起,因为完整克隆到厚置备 LV 上会复制每一个块。VDO 把零存成了什么都没有,其余的存成引用。

VDO 对见过的数据非常拿手。对什么都没有的数据也一样。 对已经压缩或加密的数据它毫无用处,所以第一个 ISO 大部分是 squashfs,只省了 1.2%。

模板和六个克隆都就位后,Proxmox 显示存储已用 80.01%,35 GiB 里有 28 GiB 的厚置备磁盘。 硬盘上实际只有 4.3 GiB,其中大部分还是索引。 在厚置备存储上,这正是重点:Proxmox 数的是分配出去了多少,硬盘装的是真正不一样的东西。

硬盘实际收到了什么

盘上省下的空间只是一张快照。硬件在乎的是数据流。 所以我测量了写入时到达硬盘的字节:fio 跑 30 秒,前后各读一次 /sys/block 里硬盘的写入计数器,同一块 Optane 有 VDO 和没 VDO 各跑两遍。

在 Optane 上对比了什么Optane,无 VDOVDO,16 线程fio,30 秒普通 LVnvme8n1:在这里读写入计数器fio,30 秒vdovg 里的 LVVDO LV:去重、LZ4VDO 池nvme8n1:在这里读写入计数器
Optane 上每一组有无 VDO 数字背后的两个栈:同样的 fio 任务,同一块硬盘,在最底层读写入计数器。

这个计数器是诚实的。整个测试下来它累计了 794 GB,硬盘自己的 SMART “Data Units Written” 也正好增加了 794 GB。

负载,30 秒无 VDO有 VDO,16 线程到达硬盘的字节
4k 随机写,QD32,4 个任务,75% 重复,50% 可压缩582,013 IOPS,p99 244 µs460,887 IOPS,p99 1.05 ms28%
128k 写,QD8,75% 重复,50% 可压缩2,345 MiB/s,p99 490 µs2,179 MiB/s,p99 1.02 ms23%
4k 随机写,QD32,4 个任务,随机数据571,721 IOPS272,366 到 381,005 IOPS59% 到 100%
128k 写,QD8,随机数据2,346 MiB/s1,051 到 1,854 MiB/s100%

在现实的混合数据上,VDO 保住了裸盘吞吐量的 79% 到 93%,只给硬盘送去四分之一的字节。 在完全随机的数据上,它什么都省不了,代价还很大,两次运行的结果差得太远,我只给出范围。

尾延迟来自 VDO 自己的处理,不是硬盘。p99 大约一毫秒,裸盘则是它的四分之一。

Optane 没有缓存可以减负

这些硬盘自己就这么说:nvme id-ctrl 给出 vwc 0,/sys/block 里是 write through。 Optane 原地写入,没有 DRAM 或 SLC 暂存,所以在这种硬件上,收益是字节和磨损,而不是一个填得更慢的硬盘缓存。 带 SLC 缓存的 NAND SSD,或者带回写缓存的 RAID 控制器,才是字节更少还能换来响应更快的地方。那就是下面的 RAID6 一节。

让 VDO 的线程匹配 CPU

开箱即用时,LVM 给 VDO 十个线程:一个 logical、一个 physical、一个 hash zone、两个 CPU、四个 bio 提交、一个确认。 在一台 16 个 CPU 的主机上,这让机器的大部分闲着,而 VDO 的块映射工作排在唯一一个 logical 线程后面。

内核文档解释了这些参数1。 每个 logical 线程拥有 “a disjoint section of the block map”,physical 线程拥有 “a disjoint section of the data blocks”,两者都 “can increase throughput”,而线程过多则 “can waste resources and increase contention”。 logical 线程最多 60 个,physical 最多 16 个,而且每个 physical 线程至少要有一个 slab。这个池有 18 个 slab,够用。

布局logicalphysicalhashcpubioack合计
LVM 默认11124110
匹配 16 个 CPU44232116
再翻一倍88462230

每种布局都用随机数据把同样的 fio 任务交替跑两遍,另外像七台虚拟机一起开机那样,同时读七块克隆磁盘:

测试,两次平均默认匹配 16 个 CPU再翻一倍
4k 随机写,QD32,4 个任务292,466 IOPS365,314 IOPS302,461 IOPS
4k 随机写 p99,4 个任务2.1 到 3.7 ms1.5 到 1.6 ms2.1 到 2.2 ms
1M 顺序写1,153 MiB/s1,729 MiB/s1,507 MiB/s
4k 随机读,QD32,4 个任务507,450 IOPS503,827 IOPS485,263 IOPS
同时读七块克隆磁盘7.5 s3.1 s3.4 s

匹配 CPU 数几乎全赢:并行写多四分之一,顺序写多一半,七块盘的读取快 2.4 倍,尾延迟也更紧。 再翻一倍则全面变差。这就是文档警告的那种争用。 默认布局也是最不稳定的,七盘读取在两次运行之间从 6.1 秒摆到 8.8 秒。

因此,规则是每个 CPU 一个 VDO 线程,按上面那样分配到各类型,physical 线程数受 slab 数限制。

VDO 在快硬件上的代价

同一块 Optane 不带 VDO,对比线程匹配好的 VDO,随机数据,两次平均:

测试Optane,无 VDOVDO,16 线程
4k 随机写,QD142,294 IOPS,19.4 µs55,806 IOPS,12.1 µs
4k 随机写,QD32142,416 IOPS144,292 IOPS
4k 随机写,QD32,4 个任务572,293 IOPS365,314 IOPS
4k 随机读,QD155,276 IOPS,14.4 µs27,988 IOPS,31.4 µs
4k 随机读,QD32,4 个任务586,463 IOPS503,827 IOPS
1M 顺序写,QD82,348 MiB/s1,729 MiB/s
同时读七块模板磁盘11.1 s3.1 s

直白地读。 单个随机读经过 VDO 要花两倍多的时间。并行随机写少了三分之一以上,顺序写少了四分之一。 在这么快的硬盘上,VDO 每次读多出来的 17 µs 工作,就占了读取的大头。

QD1 写入经过 VDO 反而更快,这不是白捡的便宜。远不是。 VDO 在写入落盘之前就确认了,内核文档说得很清楚,“unflushed writes may or may not persist after a crash”1。那个数字测的是一次确认。会刷盘的客户机,而每个文件系统都会,得到的就是它要求的持久性。

七盘那一行是 VDO 完胜的一项,值得说清楚为什么。 七份普通拷贝要读 28 GiB 的真实字节,连零一起。VDO 只读一套共享的块,零直接跳过。

所以在快闪存上,VDO 是拿延迟换字节。 不过这些微秒每一个都是固定成本,下面的硬盘变慢时它不会跟着增长。

把 VDO 的元数据放到 NVMe 上

VDO 没有单独的元数据设备。所有东西都在同一个池 LV 上。 但 dm-vdo 的源码表明布局是固定的,而一个 LV 可以由不同硬盘上的片段拼成。

格式化代码从数据区开头放块映射的根,然后从末尾放 slab 摘要和恢复日志,中间填满 slab7。 UDS 索引在这一切之前,紧跟在 geometry 块后面。 vdolistmetadata 在实验池上证实了这一点:

块内容位置
0 到 679,188geometry、UDS 索引、super block、块映射根最前面 2.59 GiB
每个 2 GiB 的 slab 内部数据、块映射叶子、130 个引用块和 224 块的 slab 日志分布在整个池里
10,452,928 到 10,485,695恢复日志差不多最后 128 MiB
10,485,696 到 10,485,759slab 摘要最后的 256 KiB

所以把池 LV 分三段搭:头部在 NVMe 上,中间在慢硬盘上,尾部在 NVMe 上。

元数据放在 NVMe 上的 VDO虚拟机磁盘:厚置备 LV客户机看到的卷组 vdovgProxmox 读的VDO LV,35 GiB 虚拟去重、LZ4、丢弃全零头部中间:slab尾部VDO 池 LV,三段慢硬盘:nvme8n1数据、引用计数NVMe: nvme6n1索引、根、恢复日志
元数据拆出去之后的整个栈。Proxmox 看到的是同一个卷组;下面的池 LV 是两块硬盘上的三段。

然后把它转换成 VDO 池,lvmvdo(7) 记载了对现有 LV 的这种做法2。 这里 nvme6n1 代表 NVMe,nvme8n1 代表慢硬盘:

# 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.

再检查 VDO 是否把元数据放在了 extent 所在的地方:

# 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

一个 extent 是 1,024 个块。 NVMe 头部是 extent 0 到 767,即块 0 到 786,431,覆盖了索引和根,顺带还有第一个 slab 大约 420 MiB 的数据。 NVMe 尾部是 extent 10,176 到 10,239,即块 10,420,224 往后,覆盖了恢复日志和 slab 摘要。

VDO 的元数据在两端,放在 NVMe 上extent 0 到 767extent 768 到 10,17510,176 to 10,239NVMe (nvme6n1)慢硬盘(nvme8n1)NVMe (nvme6n1)UDS 索引、super block、块映射根18 个 slab:数据、块映射叶子、引用计数、slab 日志恢复日志、slab 摘要未按比例:头部 3 GiB,中间 36.75 GiB,尾部 256 MiB。
分成三段的池 LV。VDO 固定的元数据在两端,所以两端放 NVMe,slab 放慢硬盘。

VDO 的工作有多少跟着挪了过去,每次 30 秒运行,按设备计数:

负载NVMe 写 I/O数据盘写 I/ONVMe 占比
4k 随机写,75% 重复,50% 可压缩388,430 到 538,2233.42 到 3.63 百万10% 到 13%
128k 写,75% 重复,50% 可压缩458,214 到 634,1673.30 到 3.53 百万12% 到 15%
4k 随机写,随机数据181,457 到 384,5073.25 到 8.49 百万4% 到 5%
4k 随机读0 次写,读的 2%0

大约十分之一的写操作:恢复日志、索引更新,以及 NVMe 头部上 slab 0 的那一片。 它们是小而分散的元数据写入,正是机械硬盘最不擅长的那种。在 NVMe 上它们什么都不算。

两个限制。 每个 slab 的元数据,即引用计数、slab 日志和块映射叶子,住在 slab 里面,跟着数据走。 另外我没有测试扩大一个拆分过的池。日志是从末尾放的,所以每次 lvextend 之后,都要再跑一遍 vdolistmetadata,看看它跑到哪儿去了,再决定信不信它。

VDO 叠在 bcache 上:一块 NVMe,两份活

bcache 是把闪存放在慢盘前面的另一种办法。 我在机械硬盘上的 Ceph 下面跑的就是它,每个设置都在 bcache 那篇文章里讲过。 所以问题是:VDO 坐在 bcache 缓存上面时,会对这个缓存做什么。

一块 NVMe 干两份闪存的活,分成两个分区:

设备大小用途
nvme8n1p132 GiBbcache 缓存,writeback
nvme8n1p28 GiBVDO 的头部和尾部:索引、根、恢复日志、slab 摘要
nvme6n1349 GiBbcache 后端设备,数据住在这里
/dev/bcache0349 GiBVDO 池的中间段,即 slab

两块硬盘又都是 Optane,所以 nvme6n1 是在扮演机械硬盘。 下面每个数字都要记住这一点。这里的后端设备很快,所以测的是到达缓存的量,而不是一个主轴要花多久把它冲刷下去。

VDO 叠在 bcache 上:一块 NVMe,两份活虚拟机磁盘:厚置备 LV客户机看到的卷组 vdovgProxmox 读的VDO LV,35 GiB 虚拟去重、LZ4、丢弃全零头部中间:slab尾部VDO 池 LV,三段bcache0, writeback客户机字节的四分之一p1:缓存nvme6n1:数据32 GiB 缓存,349 GiB 后端p2:VDO 的元数据p1 和 p2:同一块 Optane,nvme8n1
叠在 bcache 上的 VDO。池的两端去元数据分区,slab 经过 bcache,两个分区共用一块 Optane。

分区和缓存集,用的是那篇文章里的设置:

# 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

这些 echo 行只管到下次重启。bcache 那篇文章里的 udev 规则才能让它们持久。

然后是池,按上面同样的方式拆分,两端用 nvme8n1p2,中间用 bcache0:

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

vdolistmetadata 打印出的块范围和拆分搭法一样,所以索引和两个日志都在 nvme8n1p2 上。 vdovg 和 Proxmox 存储照旧放在上面。

到达缓存的是什么

对比的是直接放在 bcache0 上的一个 8 GiB LV 和 vdovg 里的一个 8 GiB LV,同样的 fio 任务跑 30 秒,跑两遍,每次运行之间都把缓存冲刷干净。 /sys/class/block 里的设备计数器说明了字节去了哪里。

在 bcache 上对比了什么仅 bcacheVDO 叠在 bcache 上fio,30 秒bcache0 上的 8 GiB LVbcache0, writebackp1:缓存nvme6n1:数据fio,30 秒vdovg 里的 8 GiB LVVDO LV 和池,16 线程bcache0, writebackp2:元数据p1:缓存nvme6n1:数据
bcache 数字背后的两个栈。同一个缓存,同一块后端硬盘;唯一的区别是上面有没有 VDO。
75% 重复,50% 可压缩,30 秒仅 bcacheVDO 叠在 bcache 上
4k 随机写,QD32,4 个任务212,222 和 205,585 IOPS390,206 和 304,757 IOPS
p991.89 和 2.04 ms1.45 和 2.54 ms
客户机写入24.29 和 23.53 GiB44.67 和 34.88 GiB
写进 bcache 缓存25.00 和 24.26 GiB11.48 和 10.44 GiB
写到 VDO 的元数据分区1.18 和 0.59 GiB
每字节客户机写入对应的缓存写入103%26% 和 30%
结束时缓存里剩下的脏数据6.0 和 6.5 GiB5.5 和 5.2 GiB
128k 写,QD82,001 和 1,985 MiB/s1,878 和 1,416 MiB/s
每字节客户机写入对应的缓存写入,128k101%24% 和 27%

bcache 单独跑,顶到每秒大约 210,000 次小写入,而且把每个字节都写进了缓存,外加 3% 它自己的。 前面放上 VDO,缓存只收到四分之一的字节。第一次运行时,同一个缓存随后扛住了每秒 390,206 次写入,几乎翻倍,结束时等着写回慢盘的脏数据还更少。 瓶颈本来是缓存。VDO 把它挪开了。

第二次运行才是对一个用过一阵的池来说诚实的那次。 fio 默认每次运行都用同样的方式给随机数生成器播种8,所以第二次写入的数据,索引早就见过,指向的却是之后已经被 discard 掉的块。 VDO 把索引当作提示,在共享之前会把每个候选块读出来,核实它确实是重复的9。 在一个只写的测试里,第二次运行从缓存里读回了 7.11 GiB,从数据盘读了 1.20 GiB。第一次只读了 0.12 GiB。 过时的提示不是免费的,而在一个虚拟机来来去去的池上,总会有一些。

随机数据是另一面:

随机数据,30 秒仅 bcacheVDO 叠在 bcache 上
4k 随机写,QD32,4 个任务205,984 和 203,066 IOPS203,186 和 85,882 IOPS
p992.04 和 2.15 ms5.7 和 17.7 ms
128k 写,QD82,038 和 2,017 MiB/s878 和 357 MiB/s
4k 随机读,QD136,609 和 36,639 IOPS,21.6 µs26,345 和 26,202 IOPS,33.6 和 33.7 µs
4k 随机读,QD32,4 个任务471,585 和 471,730 IOPS335,461 和 336,941 IOPS

没东西可省,VDO 就是纯开销,在索引过时的那次运行里,它让小写入掉了一半还多。 两列里的每一次读都来自缓存。VDO 多出来的 12 µs,就是它在裸 Optane 上加的那份固定成本。

所以数据有重复的地方,两者叠得很好。 缓存只收到四分之一的字节,能扛更久的突发,要写回机械盘的也更少。数据不重复的地方,bcache 自己单干更好。

在 HDD 硬件 RAID6 上:推演,不是实测

我手上没有 HDD RAID6 的主机可以测,所以这一节是建立在上面测量之上的推理。真要依赖它之前,先测你自己的阵列。

HDD RAID6 上的 VDO,推演虚拟机磁盘:厚置备 LV客户机看到的卷组 vdovgProxmox 读的VDO LV,厚置备去重、LZ4、丢弃全零头部中间:slab尾部VDO 池 LV,三段RAID6 虚拟盘客户机字节的四分之一控制器回写缓存四倍的余量HDD一次寻道吞掉 VDO 的 17 µsNVMe索引和日志离开主轴
这一节推演的栈,不是我测过的:slab 在控制器缓存后面的 RAID6 虚拟盘上,索引和日志在一块 NVMe 上。
在 HDD RAID6 上VDO 改变了什么
到达阵列的写入大约四分之一,前提是混合数据和实测的相似
控制器回写缓存填充速度只有四分之一,所以能扛住大约四倍长的突发
VDO 的 CPU 开销每次读 17 µs,淹没在 5 到 10 ms 的寻道里
恢复日志写入约占写 I/O 的十分之一,小而且要刷盘:放到 NVMe 上
索引查找盯着 vdostats 里的 dedupe advice timeouts;在慢存储上 VDO 可能放弃查找,照样把重复数据写下去
从头到尾读一个克隆更慢:它的块指回模板的块,散落在整个阵列里

前两行就是硬件层面的答案。 控制器的电池或闪存保护缓存还有空间时,客户机看到的是缓存的延迟。缓存满了,客户机看到的就是主轴。 只给它四分之一的字节,同一个缓存就有大约四倍的余量,要冲刷的也只有四分之一。 上面 bcache 那一节,就是用软件缓存代替控制器缓存把这件事测了出来。

第三行说明了为什么 VDO 更适合慢盘而不是快盘。 在 Optane 上,VDO 让读延迟翻了一倍。在 7,200 转的硬盘上,同样的固定成本消失在一次寻道里。

最后三行是代价。 一模一样的克隆同时开机会变快,但从头到尾读一个克隆会变慢,因为去重把它打散了。 而且 VDO 自己的小写入也会落到阵列上,这就是上面拆分布局的理由:索引和日志放 NVMe,slab 放 RAID6。

删除磁盘:让 Proxmox 对它做 discard

删除一个 LV 会在 LVM 里释放它的 extent。但它不会告诉 VDO 这些块没用了,所以 VDO 留着它们。 内核文档说明了这为什么要紧:“If the vdo is thinly provisioned, discarding unused blocks is essential to prevent the target from running out of space”1。 在厚置备存储上它不会用完,但没被 discard 的块仍然是硬盘空间,为没人要的数据占着。

存储上的 on-volume-remove discard=1 选项就是解决办法。Proxmox 把它描述为发出 “discard (TRIM) requests before removal”5:

删除释放的 VDO 块
普通 lvm 存储,一块装了 1 GiB 的磁盘0
加上 on-volume-remove discard=1,同样的磁盘262,140,整整 1 GiB

不过在大磁盘上它很慢。 删除填充测试里那块 34 GiB 的磁盘,Proxmox 花了 262.6 秒,而对同类数据用 blkdiscard,2.25 秒就处理了 15 GiB。 所以对任何大的东西,先 blkdiscard 磁盘,再删除。

discard 的大小也要紧。VDO 默认的 max_discard 是每个请求一个 4 KiB 块1:

discard 15 GiB 随机数据耗时CPU(sys)
max_discard=1,默认值8.06 s8.06 s
max_discard=4096,16 MiB2.25 s0.00 s

在客户机里,打开磁盘的 Discard 选项,让它们的 TRIM 能到达存储10,并定期跑 fstrim。

它在哪里值得用

合适不合适
从同样几个模板来的大量虚拟机数据库和高队列深度下受延迟约束的工作
回写控制器缓存后面的 HDD RAID6每一微秒都要的全 NVMe 主机
机械盘放数据,一块 NVMe 放 VDO 的元数据已经压缩过的数据:媒体、备份、ISO
机械盘数据前面的 bcache,且数据有重复数据不重复时前面的 bcache
写入寿命是瓶颈的硬盘加密的客户机磁盘,永远去不了重
每个池能腾出半 GB 内存的主机小池,索引会吃掉十分之一
设置默认设为以后能改吗
VDO 虚拟大小 -V你要多少给多少不超过池能寻址的大小只能增大,不能缩小
VDO 线程10,一个 logical每个 CPU 一个,按上面分配只能在池上虚拟机都停下时改
max_discard1,即 4 KiB4096,即 16 MiB只能在池上虚拟机都停下时改
存储上的 on-volume-remove未设置discard=1可以,pvesm set
每块虚拟磁盘上的 Discard关开可以,逐块磁盘改
scan_lvs 和过滤器0,不拒绝虚拟机磁盘1,拒绝虚拟机磁盘可以,在 lvm.conf 里

这些都不难。这些也都不是默认值。

最便宜的写入,是你从没发出去的那一次

VDO 让我印象最深的,是它被推销得有多糟。 它总是以“能在磁盘上放比磁盘容量更多的东西”的面目出现,而这恰恰是它最没用的本事。我第一次搭的时候就无意中这么干了,结果 VDO 满了,Proxmox 还显示有三分之一的存储空闲。超配是一笔贷款,硬盘会以全速写入的方式来催债。

真正的价值在大多数人从来不测的那一行。 到达硬盘的字节只有四分之一,就是磨损只有四分之一,控制器缓存能撑四倍长的时间。那不是容量。那是硬件为同样的结果干更少的活,这是唯一一种不会回头咬你一口的节省。

它要花 CPU,在快闪存上还要花延迟,而且两者都是固定的。这就是这笔交易,直说:花处理器时间,让机器里又慢又贵的那部分少干活。 在 RAID 控制器或 bcache 后面的机械盘上,索引和日志放在 NVMe 上,这笔账算下来很划算。在全 Optane 的主机上,大多算不过来。

而且它不会自己照顾自己。 每一个要紧的默认值,对这份活来说都是错的:十六个 CPU 配十个线程,一个烧掉一整个核的 discard 大小,一个你想设多少就设多少的虚拟大小,存储配置里也没有任何东西告诉 Proxmox 把空间还回去。 这些都没藏着。全在文档里。

所以就搭成厚置备,一次,好好地搭,设置写在创建命令里,元数据放在它该在的地方。 这么做,硬盘只干四分之一的活。跳过这些,你就是又买了一层承诺比实际拥有更多的东西。


  1. Linux kernel documentation — dm-vdo — 该目标 “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”;128 MB 的块映射缓存支持 “efficient access to 100 GB of logical space at a time”;线程参数、其上限和调优建议;maxDiscard “in 4096-byte blocks”。 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. lvmvdo(7) — Support for Virtual Data Optimizer in LVM — VDO 池和 VDO LV,用 lvconvert --type vdo-pool 转换现有 LV,内存用量,dense 索引及其每 GiB 内存对应 1 TiB 的窗口,以及 “You cannot reduce the size of a VDOPoolLV”。 ↩︎ ↩︎ ↩︎ ↩︎

  3. Linux kernel source — drivers/md/dm-thin.c — 当数据设备容纳不了一个完整的 thin chunk 时,disable_discard_passdown_if_not_supported() 会关闭 discard 下传,VDO 的默认设置放在精简池下面时就是这样。 ↩︎

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

  5. Proxmox pve-storage — LVMPlugin.pm — on-volume-remove 属性,“Use ‘discard=1’ to issue discard (TRIM) requests before removal”;卷用 lvchange -aey 逐个激活,而不是用 vgchange -aly。 ↩︎ ↩︎

  6. Debian trixie — package vdo — “Management tools for Virtual Data Optimizer”,版本 8.3.1.1-1,提供 vdoformat、vdostats 和 vdolistmetadata。 ↩︎

  7. Linux kernel source — drivers/md/dm-vdo/encodings.c — vdo_initialize_layout() 把块映射分区放在开头,slab 摘要和恢复日志分区放在末尾,slab depot 用剩下的空间。 ↩︎

  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.” ↩︎