ड्राइव तक कम bytes पहुँचते हैं

VDO Linux kernel की deduplication और compression layer है। यह एक volume group के नीचे बैठता है और 4 KiB blocks में काम करता है। जो भी block यह पहले देख चुका है, उसे एक बार ही रखता है।

हार्डवेयर के लिए इसका मतलब सीधा है। ड्राइव तक कम bytes पहुँचते हैं। मैंने VDO से होकर एक बार में 30 सेकंड तक ऐसा mix लिखा जो 75% duplicate और 50% compressible था, और ड्राइव के अपने counters ने बताया कि guest ने जितना लिखा, उसका उसे 23 से 28% मिला। एक template disk के छह full clones ने मिलकर 8 data blocks जोड़े। बत्तीस किलोबाइट।

ड्राइव तक पहुँचे bytesबिना VDO, कोई भी डेटा100%VDO, 4k random, 75% dup28%VDO, 128k, 75% dup23%VDO, 128k, random डेटा100%guest के bytes का ड्राइव तक पहुँचा हिस्सा, 30 s runs, दो का औसत। Mix: 75% duplicate, 50% compressible।
guest के लिखे bytes बनाम ड्राइव को मिले bytes, हर workload के 30 सेकंड, दो runs का औसत। बिना VDO के ड्राइव को सब कुछ मिलता है। VDO के साथ उसे एक असल जैसे mix का लगभग एक चौथाई मिलता है, और पूरी तरह random डेटा का सब कुछ।

कम bytes का मतलब है कम घिसाव, और ड्राइव पर या उसके आगे के controller पर किसी भी cache के लिए कम काम। वहाँ तक पहुँचने में CPU और latency लगती है, और तेज़ ड्राइव पर वह क़ीमत नीचे बिना VDO वाले उसी Optane के मुक़ाबले नापी गई है। धीमी घूमती disks पर वही क़ीमत seek times में घुल जाती है, और यहीं बात दिलचस्प होती है।

दो नियम आगे की हर चीज़ को आकार देते हैं। stack thick on thick है: VDO के ऊपर कुछ भी, और ख़ुद VDO भी, ड्राइव से ज़्यादा जगह का वादा नहीं कर सकता। और VDO का अपना metadata, उसका index और उसके journals, NVMe पर रह सकते हैं जबकि डेटा कहीं धीमी जगह पर रहे।

यहाँ का हर आँकड़ा एक ही Proxmox VE 9.2 host से आता है: 16 CPUs वाला Ryzen 7 5700G, kernel 7.0.14-25-pve, LVM 2.03.31 और Debian के vdo 8.3.1.1 tools, दो Intel Optane ड्राइव पर, जिन्हें बाद में मिटा दिया गया।

VDO क्या है और कहाँ बैठता है

kernel dm-vdo को एक device-mapper target बताता है जो “provides block-level deduplication, compression, and thin provisioning”1। हर आने वाले 4 KiB block का hash बनाया जाता है। अगर वैसा ही block पहले से रखा है, तो VDO copy की जगह एक reference दर्ज करता है। जो blocks duplicate नहीं हैं, वे LZ4 से गुज़रते हैं और एक physical block में कई ठूँसे जाते हैं, और जिन blocks में सिर्फ़ zeros हैं, वे रखे ही नहीं जाते2।

पूरी चीज़ LVM चलाता है। lvcreate --type vdo एक VDO pool बनाता है, जिसमें असली blocks रहते हैं, और उसके ऊपर एक VDO LV, जिसका वर्चुअल आकार जो आप माँगें2। VDO LV पर एक thick volume group जाता है, और Proxmox उसे आम lvm स्टोरेज की तरह इस्तेमाल करता है।

Thick on thick: VDO पर LVMVM disks: thick LVsguests को यही दिखता हैVolume group vdovg, 35 GiBProxmox यह पढ़ता है: lvm स्टोरेजइस line के नीचे Proxmox को कुछ नहीं दिखताVDO LV vdolv, 35 GiB वर्चुअलdedup, LZ4, zero blocks छोड़ेVDO pool vdopool, 40 GiBअसली blocks: vdostats यह पढ़ता हैड्राइव: nvme8n1वर्चुअल 35 GiB, क्षमता से कभी ज़्यादा नहीं
Proxmox को एक आम thick volume group दिखता है। VDO उसके physical volume के नीचे बैठता है, इतने आकार का कि वह कभी ड्राइव में समाने से ज़्यादा का वादा न कर सके।
Layerlab में नामयह क्या करता है
VM disksvm-9901-disk-0 वग़ैरहthick LVs, Proxmox द्वारा बनाए गए
Volume groupvdovg, 35 GiBसादा LVM, जिसे Proxmox का lvm स्टोरेज पढ़ता है
VDO LVvdolab/vdolv, 35 GiB वर्चुअलdedup, LZ4, zero blocks छोड़ दिए जाते हैं
VDO poolvdolab/vdopool, 40 GiBअसली blocks, VDO का metadata और index
Physicalnvme8n1VG vdolab

Thick on thick, वरना बिल्कुल नहीं

VDO अपने आप में एक thin provisioner है: VDO LV को कोई भी वर्चुअल आकार दिया जा सकता है। उसे pool की क्षमता से बड़ा बनाएँ, तो ऊपर वाला volume group एक वादे पर thick है, जो एक layer नीचे खिसका हुआ thin on thin ही है। पहली बार बनाते समय मैंने ठीक यही किया था, 40 GiB pool पर 120 GiB VDO LV, और Proxmox एक तिहाई स्टोरेज ख़ाली दिखा रहा था जबकि VDO भरा हुआ था।

इसलिए VDO LV का आकार उतना रखें जितना pool सच में संभाल सकता है, उससे ज़्यादा नहीं। lvcreate यह आँकड़ा छापता है, इस 40 GiB pool पर “can address 36.00 GB”, और logical space के लिए VDO का block map भी उसी जगह से आता है, इसलिए मैंने इसे 35 GiB दिया।

फिर मैंने इसे कठिन तरीक़े से साबित किया। एक VM disk, जिसने Proxmox द्वारा दिया जा सकने वाला हर extent ले लिया, 34 GiB, और शुरू से आख़िर तक ऐसे random डेटा से भरी गई जिसके साथ VDO कुछ नहीं कर सकता:

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

disk अपने ही अंत पर ख़त्म हुई, जैसा thick disk को होना चाहिए। VDO के पास तब भी 1.9 GiB ख़ाली था, जो Proxmox के पास बाँटने को बचे 1 GiB से ज़्यादा था। Proxmox का आँकड़ा ही असली सीमा है, और VDO पहले ख़त्म नहीं हो सकता।

आप जो छोड़ते हैं वह overcommit है: deduplication जो जगह बचाता है, वह ऐसी ड्राइव के रूप में दिखती है जिस पर कभी लिखा नहीं जाता, Proxmox के लिए अतिरिक्त disks के रूप में नहीं। इस पोस्ट के लिए यही सही सौदा है, क्योंकि यह हार्डवेयर के बारे में है। और इस पर lvmthin pool भी न रखें। दो thin layers यानी हिसाब की दो किताबें3।

एक byte रखने से पहले की क़ीमत

VDO एक deduplication index, UDS index, pool पर ही रखता है। एक ख़ाली 40 GiB pool ने 4.0 GiB इस्तेमाल और 36.0 GiB उपलब्ध बताया। उसी vdo package का vdolistmetadata डिवाइस के हर metadata block की सूची देता है, और लगभग पूरे हिस्से का हिसाब देता है:

हिस्सा4 KiB blocksआकार
UDS index679,1272.59 GiB
Recovery journal32,768128 MiB
Reference counts और journals, 18 slabs6,37225 MiB
उन्नीसवें slab के लिए बहुत छोटी जगह336,5551.28 GiB
कुललगभग 4.0 GiB

बचे हुए हिस्से वाली line जानने लायक़ है: slabs 2 GiB के होते हैं, इसलिए pool का आकार पूरे slabs और overhead के हिसाब से रखें, वरना बचा हुआ हिस्सा बस बेकार पड़ा रहता है।

RAM दूसरा बिल है। pool व्यस्त हो या ख़ाली, यह चुकाना पड़ता है:

क़ीमतlvmvdo(7) का नियमयह 40 GiB pool
स्थिर38 MiB38 MiB
Block map cacheहर MiB cache पर 1.15 MiB, कम से कम 150 MiB150 MiB (128 MiB default)
Physical spaceहर TiB पर 268 MiB11 MiB
UDS index (dense)कम से कम 250 MiB, default256 MiB
कुललगभग 455 MiB

default dense index लगभग 256 GiB की deduplication window कवर करता है, क्योंकि 1 GiB RAM वाला dense index “maintains a 1 TiB deduplication window”2। 128 MiB block map cache का आकार “efficient access to 100 GB of logical space at a time” के लिए है, और kernel डॉक्यूमेंटेशन इसे वह सबसे ज़रूरी value बताता है जिसे working set बढ़ने के साथ बदलना चाहिए1।

Stack बनाना

LVM को LV पर PV देखने दें

volume group एक LV पर बैठता है, और LVM default रूप से LVs को physical volumes के रूप में नज़रअंदाज़ करता है। devices/scan_lvs इसे चालू करता है, और LVM के reference में इसके साथ आने वाली चेतावनी है: “Caution is required to avoid using PVs that belong to guest images stored on LVs”4। वरना अपनी disk के अंदर LVM इस्तेमाल करने वाले guest के volume groups host पर दिखने लगेंगे।

इसलिए filter भी बदलता है। वही edit। इस host का stock filter सिर्फ़ ZFS zvols और RBD डिवाइसों को अस्वीकार करता था। मैंने हर Proxmox VM disk के लिए एक reject जोड़ा:

# 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

वही reference कहता है कि scan_lvs “does not enable autoactivation of layered VGs”4। Proxmox को इसकी ज़रूरत नहीं है। उसका LVM plugin VM शुरू होने पर हर disk को lvchange -aey से activate करता है5। मैंने इसे उसी हालत में test किया जिसमें boot चीज़ें छोड़ता है, सब कुछ deactivated और फिर वही pvscan udev runs: VDO के नीचे वाला VG ऊपर आ गया, और qm start ने VM की disk ख़ुद activate कर दी। पेच नीचे है। VDO के नीचे वाला VG अधूरा होने पर वही qm start “Volume group “vdovg” not found” के साथ फ़ेल हुआ।

VDO pool, thick, settings उसी creation line पर

formatter Debian के vdo package में है6:

# apt install vdo

फिर pool। -L असली जगह है, -V वर्चुअल आकार, जो pool की संभाल-सीमा के अंदर रखा गया है। thread layout और discard size उसी line पर जाते हैं, क्योंकि इनमें से कोई भी बाद में pool के हर VM को रोके बिना बदला नहीं जा सकता:

# 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

thread layout वही है जो आगे 16-CPU host के लिए नापा गया है; max_discard=4096 का अपना section है।

Volume group और 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 मायने रखता है, और इसे नीचे कवर किया गया है।

Deduplication ने क्या बचाया

मैंने वे चीज़ें लिखीं जो एक Proxmox host सच में रखता है और हर एक के बाद VDO के block counters पढ़े। logical blocks used वह है जो ऊपर की layers ने लिखा; data blocks used वह है जो VDO ने रखा। दोनों 4 KiB blocks हैं।

क्या लिखा गयाLogical blocks जुड़ेData blocks जुड़ेबचत
Rocky Linux 10 rootfs, 4 GiB disk पर ext4114,50560,53747%
उसके छह full clones (qm clone --full, हर एक लगभग 4 s)6,291,456899.9999%
Proxmox Datacenter Manager 1.1 ISO, 1.36 GiB356,172351,9651.2%
उसका -auto rebuild, लगभग वही bytes356,3994099.99%
4 GiB zeros1,048,5750100%
1 GiB random डेटा262,143262,1440%

हर clone ने पूरे 4 GiB लिखे, zeros समेत, क्योंकि thick LV पर full clone हर block copy करता है। VDO ने zeros को कुछ नहीं के रूप में रखा और बाक़ी को references के रूप में।

VDO उस डेटा में बहुत अच्छा है जो वह पहले देख चुका है। और कुछ-नहीं में भी। जो डेटा पहले से compressed या encrypted है, उस पर यह बेकार है, इसीलिए पहला ISO, जो ज़्यादातर squashfs है, सिर्फ़ 1.2% बचा पाया।

template और उसके छह clones रखे जाने पर Proxmox ने स्टोरेज 80.01% इस्तेमाल दिखाया, 35 में से 28 GiB thick disks। ड्राइव पर 4.3 GiB था, और उसमें से ज़्यादातर index था। thick स्टोरेज पर बात यही है: Proxmox वह गिनता है जो बाँटा गया है, और ड्राइव वह ढोती है जो सच में अलग है।

ड्राइव को असल में क्या मिलता है

disk पर बचत एक तस्वीर है। हार्डवेयर को धारा की परवाह है। इसलिए मैंने लिखते समय ड्राइव तक पहुँचने वाले bytes नापे: 30 सेकंड के लिए fio, पहले और बाद में /sys/block से ड्राइव का write counter, उसी Optane पर VDO के साथ और बिना, हर एक दो बार।

Optane पर किसकी तुलना हुईOptane, बिना VDOVDO, 16 threadsfio, 30 sसादा LVnvme8n1: write counter यहाँ पढ़ाfio, 30 svdovg में LVVDO LV: dedup, LZ4VDO poolnvme8n1: write counter यहाँ पढ़ा
Optane पर हर साथ-और-बिना आँकड़े के पीछे के दो stacks: वही fio jobs, वही ड्राइव, write counter सबसे नीचे पढ़ा गया।

counter ईमानदार है। पूरे run में इसका जोड़ 794 GB रहा, और ड्राइव का अपना SMART “Data Units Written” भी 794 GB ही बढ़ा।

Workload, 30 sबिना VDOVDO के साथ, 16 threadsड्राइव तक पहुँचे bytes
4k random write, QD32, 4 jobs, 75% dup, 50% compress582,013 IOPS, p99 244 µs460,887 IOPS, p99 1.05 ms28%
128k write, QD8, 75% dup, 50% compress2,345 MiB/s, p99 490 µs2,179 MiB/s, p99 1.02 ms23%
4k random write, QD32, 4 jobs, random डेटा571,721 IOPS272,366 से 381,005 IOPS59 से 100%
128k write, QD8, random डेटा2,346 MiB/s1,051 से 1,854 MiB/s100%

एक असल जैसे mix पर VDO ने नंगी ड्राइव के throughput का 79 से 93% बनाए रखा और उसे एक चौथाई bytes भेजे। पूरी तरह random डेटा पर यह कुछ नहीं बचाता और बहुत ख़र्च करता है, और दोनों runs इतने अलग थे कि मैं सिर्फ़ दायरा दे रहा हूँ।

tail latency VDO की अपनी processing है, ड्राइव नहीं। लगभग एक millisecond का p99, नंगी ड्राइव के एक चौथाई के मुक़ाबले।

Optane के पास राहत देने को कोई cache नहीं

ये ड्राइव ख़ुद ऐसा कहती हैं: nvme id-ctrl से vwc 0, /sys/block में write through। Optane बिना DRAM या SLC staging के अपनी जगह पर लिखता है, इसलिए इस हार्डवेयर पर फ़ायदा bytes और घिसाव में है, किसी ड्राइव cache के धीरे भरने में नहीं। SLC cache वाला NAND SSD, या write-back cache वाला RAID controller, वह जगह है जहाँ कम bytes से तेज़ जवाब भी मिलता है। वह नीचे का RAID6 section है।

VDO के threads को CPUs से मिलाना

बिना कुछ बदले LVM VDO को दस threads देता है: एक logical, एक physical, एक hash zone, दो CPU, चार bio submission, एक acknowledgement। 16-CPU host पर इससे मशीन का ज़्यादातर हिस्सा बेकार बैठा रहता है, जबकि VDO का block map काम एक अकेले logical thread के पीछे क़तार में लगा रहता है।

kernel डॉक्यूमेंटेशन इन knobs को समझाता है1। logical threads में से हर एक “a disjoint section of the block map” का मालिक है, physical threads “a disjoint section of the data blocks” के, और दोनों “can increase throughput”, जबकि ज़रूरत से ज़्यादा threads “can waste resources and increase contention”। logical threads 60 तक जाते हैं, physical 16 तक, और pool को हर physical thread के लिए कम से कम एक slab चाहिए। 18 slabs पर इसमें जगह है।

Layoutlogicalphysicalhashcpubioackकुल
LVM defaults11124110
16 CPUs से मिलाया44232116
उसका दोगुना88462230

हर layout ने वही fio jobs दो बार चलाए, बारी-बारी से, random डेटा के साथ, और साथ में सातों clone disks एक साथ पढ़ी गईं, वैसे ही जैसे सात VMs एक साथ boot होते हैं:

Test, दो runs का औसतDefaults16 CPUs से मिलायाउसका दोगुना
4k random write, QD32, 4 jobs292,466 IOPS365,314 IOPS302,461 IOPS
4k random write p99, 4 jobs2.1 से 3.7 ms1.5 से 1.6 ms2.1 से 2.2 ms
1M sequential write1,153 MiB/s1,729 MiB/s1,507 MiB/s
4k random read, QD32, 4 jobs507,450 IOPS503,827 IOPS485,263 IOPS
सात clone disks एक साथ पढ़ी गईं7.5 s3.1 s3.4 s

CPU गिनती से मिलाया layout लगभग सब कुछ जीतता है: एक चौथाई ज़्यादा parallel writes, sequential writes पर आधा और, सात disks 2.4 गुना तेज़ पढ़ी गईं, और tail ज़्यादा कसी हुई। फिर से दोगुना करना हर जगह बुरा है। यही वह contention है जिसकी डॉक्यूमेंटेशन चेतावनी देता है। defaults सबसे कम स्थिर भी थे, सात-disk read runs के बीच 6.1 से 8.8 s तक झूलता रहा।

इसलिए नियम है हर CPU पर एक VDO thread, ऊपर की तरह types में बाँटा हुआ, और physical threads slab गिनती से सीमित।

तेज़ हार्डवेयर पर VDO की क़ीमत

बिना VDO वाला वही Optane, threads मिलाए हुए VDO के मुक़ाबले, random डेटा, दो runs का औसत:

TestOptane, बिना VDOVDO, 16 threads
4k random write, QD142,294 IOPS, 19.4 µs55,806 IOPS, 12.1 µs
4k random write, QD32142,416 IOPS144,292 IOPS
4k random write, QD32, 4 jobs572,293 IOPS365,314 IOPS
4k random read, QD155,276 IOPS, 14.4 µs27,988 IOPS, 31.4 µs
4k random read, QD32, 4 jobs586,463 IOPS503,827 IOPS
1M sequential write, QD82,348 MiB/s1,729 MiB/s
सात template disks एक साथ पढ़ी गईं11.1 s3.1 s

इसे सीधे पढ़ें। एक अकेला random read VDO से होकर दोगुने से ज़्यादा समय लेता है। parallel random writes एक तिहाई से ज़्यादा खोते हैं, sequential writes एक चौथाई। इतनी तेज़ ड्राइव पर हर read पर VDO का 17 µs का अतिरिक्त काम ही read का ज़्यादातर हिस्सा है।

VDO से होकर QD1 write का तेज़ होना कोई मुफ़्त का खाना नहीं है। बिल्कुल नहीं। VDO write को ड्राइव पर पहुँचने से पहले acknowledge कर देता है, और kernel डॉक्यूमेंटेशन साफ़ कहता है कि “unflushed writes may or may not persist after a crash”1। वह आँकड़ा एक acknowledgement नापता है। जो guest flush करता है, और हर filesystem करता है, उसे वही durability मिलती है जो वह माँगता है।

सात-disk वाली line वह है जिसे VDO सीधे जीतता है, और साफ़ होना ज़रूरी है कि क्यों। सात सादी copies को 28 GiB असली bytes पढ़ने पड़ते हैं, zeros समेत। VDO साझा blocks का एक सेट पढ़ता है और zeros छोड़ देता है।

तो तेज़ flash पर VDO latency के बदले bytes का सौदा करता है। फिर भी उनमें से हर microsecond स्थिर क़ीमत है, और नीचे की ड्राइव धीमी होने पर यह नहीं बढ़ती।

VDO का metadata NVMe पर रखना

VDO में कोई अलग metadata डिवाइस नहीं है। सब कुछ एक ही pool LV पर रहता है। लेकिन dm-vdo source दिखाता है कि layout तय है, और एक LV अलग-अलग ड्राइव के टुकड़ों से बनाया जा सकता है।

format code block map roots को data region की शुरुआत से रखता है, फिर slab summary और recovery journal को अंत से, और बीच को slabs से भरता है7। UDS index इन सबसे पहले बैठता है, geometry block के ठीक बाद। vdolistmetadata ने lab pool पर इसकी पुष्टि की:

Blocksक्याकहाँ बैठता है
0 से 679,188geometry, UDS index, super block, block map rootsपहले 2.59 GiB
हर 2 GiB slab के अंदरdata, block map leaves, 130 reference blocks और 224-block slab journalपूरे pool में फैले हुए
10,452,928 से 10,485,695recovery journalआख़िरी 128 MiB, लगभग
10,485,696 से 10,485,759slab summaryबिल्कुल आख़िरी 256 KiB

तो pool LV को तीन टुकड़ों में बनाएँ: सिरा NVMe पर, बीच धीमी ड्राइव पर, पूँछ NVMe पर।

NVMe पर metadata के साथ VDOVM disks: thick LVsguests को यही दिखता हैVolume group vdovgProxmox यह पढ़ता हैVDO LV, 35 GiB वर्चुअलdedup, LZ4, zeros छोड़ेसिराबीच: slabsपूँछVDO pool LV, तीन segmentsधीमी ड्राइव: nvme8n1डेटा, reference countsNVMe: nvme6n1index, roots, recovery journal
metadata को अलग करके पूरा stack। Proxmox को वही volume group दिखता है; नीचे pool LV दो ड्राइव पर तीन segments है।

फिर उसे VDO pool में बदलें, जिसे 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 ने अपना metadata वहीं रखा जहाँ extents हैं:

# 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 blocks का है। NVMe का सिरा extents 0 से 767 है, blocks 0 से 786,431, जो index और roots को कवर करता है, साथ में पहले slab के डेटा का लगभग 420 MiB भी चला आता है। NVMe की पूँछ extents 10,176 से 10,239 है, blocks 10,420,224 से आगे, जो recovery journal और slab summary को कवर करती है।

VDO का metadata सिरों पर, NVMe परextents 0 से 767extents 768 से 10,17510,176 से 10,239NVMe (nvme6n1)धीमी ड्राइव (nvme8n1)NVMe (nvme6n1)UDS index, super block,block map roots18 slabs: डेटा, block map leaves,reference counts, slab journalsrecovery journal,slab summaryपैमाने पर नहीं: सिरा 3 GiB, बीच 36.75 GiB, पूँछ 256 MiB।
pool LV तीन segments में। VDO का तय metadata दोनों सिरों पर बैठता है, इसलिए दोनों सिरे NVMe पर जाते हैं और slabs धीमी ड्राइव पर।

VDO का कितना काम इसके साथ चला जाता है, हर 30-सेकंड run में, हर डिवाइस पर गिना हुआ:

WorkloadNVMe write I/OsData ड्राइव write I/OsNVMe का हिस्सा
4k random write, 75% dup, 50% compress388,430 से 538,2233.42 से 3.63 million10 से 13%
128k write, 75% dup, 50% compress458,214 से 634,1673.30 से 3.53 million12 से 15%
4k random write, random डेटा181,457 से 384,5073.25 से 8.49 million4 से 5%
4k random read0 writes, 2% reads0

write operations का लगभग दसवाँ हिस्सा: recovery journal, index updates, और NVMe सिरे पर slab 0 का वह टुकड़ा। ये छोटे, बिखरे metadata writes हैं, ठीक वैसे जिन्हें घूमती disk सबसे बुरी तरह संभालती है। NVMe पर ये कुछ भी नहीं।

दो सीमाएँ। per-slab metadata, यानी reference counts, slab journals और block map leaves, slabs के अंदर रहता है और डेटा के साथ ही रहता है। और मैंने split pool को बढ़ाकर test नहीं किया। journal अंत से रखा जाता है, इसलिए किसी भी lvextend के बाद भरोसा करने से पहले फिर से vdolistmetadata चलाकर देखें कि वह कहाँ गया।

bcache पर VDO: एक NVMe, दो काम

bcache धीमी disks के आगे flash रखने का दूसरा तरीक़ा है। मैं इसे पहले से घूमती ड्राइव पर Ceph के नीचे चलाता हूँ, जिसकी हर setting bcache वाली पोस्ट में समझाई गई है। तो सवाल यह है कि जब VDO bcache cache के ऊपर बैठता है तो वह उस cache के साथ क्या करता है।

एक NVMe दोनों flash काम करता है, दो partitions में बँटा हुआ:

डिवाइसआकारकाम
nvme8n1p132 GiBbcache cache, writeback
nvme8n1p28 GiBVDO का सिरा और पूँछ: index, roots, recovery journal, slab summary
nvme6n1349 GiBbcache backing डिवाइस, जहाँ डेटा रहता है
/dev/bcache0349 GiBVDO pool का बीच, slabs

दोनों ड्राइव फिर से Optane हैं, इसलिए nvme6n1 घूमती disk की जगह खड़ी है। नीचे के हर आँकड़े के लिए यह याद रखें। यहाँ backing डिवाइस तेज़ है, इसलिए यह नापता है कि cache तक क्या पहुँचता है, यह नहीं कि spindle को उसे ख़ाली करने में कितना समय लगता है।

bcache पर VDO: एक NVMe, दो कामVM disks: thick LVsguests को यही दिखता हैVolume group vdovgProxmox यह पढ़ता हैVDO LV, 35 GiB वर्चुअलdedup, LZ4, zeros छोड़ेसिराबीच: slabsपूँछVDO pool LV, तीन segmentsbcache0, writebackguest bytes का एक चौथाईp1: cachenvme6n1: डेटा32 GiB cache, 349 GiB backingp2: VDO का metadatap1 और p2: एक Optane,nvme8n1
bcache पर VDO। pool के सिरे metadata partition पर जाते हैं, slabs bcache से होकर जाते हैं, और दोनों partitions एक Optane साझा करते हैं।

partitions और cache set, उस पोस्ट की settings के साथ:

# 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 lines अगले reboot तक चलती हैं। bcache पोस्ट का udev rule उन्हें स्थायी बनाता है।

फिर pool, ऊपर की तरह ही बँटा हुआ, दोनों सिरों के लिए 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 ने split build जैसी ही block ranges छापीं, इसलिए index और दोनों journals nvme8n1p2 पर बैठते हैं। vdovg और Proxmox स्टोरेज ऊपर ठीक पहले की तरह जाते हैं।

Cache तक क्या पहुँचता है

तुलना है सीधे bcache0 पर एक 8 GiB LV बनाम vdovg में एक 8 GiB LV, वही fio jobs 30 सेकंड के लिए, दो बार, हर run के बीच cache को flush करके साफ़ किया गया। /sys/class/block के device counters बताते हैं कि bytes कहाँ गए।

bcache पर किसकी तुलना हुईसिर्फ़ bcachebcache पर VDOfio, 30 sbcache0 पर 8 GiB LVbcache0, writebackp1: cachenvme6n1: डेटाfio, 30 svdovg में 8 GiB LVVDO LV और pool, 16 threadsbcache0, writebackp2: metap1: cachenvme6n1: डेटा
bcache आँकड़ों के पीछे के दो stacks। वही cache, वही backing ड्राइव; फ़र्क सिर्फ़ ऊपर VDO का है।
75% dup, 50% compress, 30 sसिर्फ़ bcachebcache पर VDO
4k random write, QD32, 4 jobs212,222 और 205,585 IOPS390,206 और 304,757 IOPS
p991.89 और 2.04 ms1.45 और 2.54 ms
guest ने लिखा24.29 और 23.53 GiB44.67 और 34.88 GiB
bcache cache में लिखा गया25.00 और 24.26 GiB11.48 और 10.44 GiB
VDO के metadata partition पर लिखा गया1.18 और 0.59 GiB
हर guest byte पर cache writes103%26 और 30%
अंत में cache में dirty बचा6.0 और 6.5 GiB5.5 और 5.2 GiB
128k write, QD82,001 और 1,985 MiB/s1,878 और 1,416 MiB/s
हर guest byte पर cache writes, 128k101%24 और 27%

अकेला bcache लगभग 210,000 छोटे writes प्रति सेकंड पर रुक गया, और उसने हर byte cache में लिखा, ऊपर से 3% अपना। आगे VDO रखें तो cache ने एक चौथाई bytes लिए। पहले run में उसी cache ने फिर 390,206 writes प्रति सेकंड उठाए, लगभग दोगुने, और फिर भी धीमी ड्राइव के इंतज़ार में कम dirty डेटा के साथ ख़त्म हुआ। cache ही सीमा था। VDO ने उसे खिसका दिया।

दूसरा run उस pool के लिए ईमानदार है जो इस्तेमाल में रहा है। fio default रूप से हर run में अपने generators को एक ही तरह seed करता है8, इसलिए दूसरे run ने वह डेटा लिखा जिसे index पहले देख चुका था, और जो उन blocks की ओर इशारा करता था जो तब तक discard हो चुके थे। VDO index को सिर्फ़ संकेत मानता है और साझा करने से पहले हर उम्मीदवार block को पढ़कर जाँचता है कि वह सच में duplicate है9। सिर्फ़-write वाले test के दौरान उस दूसरे run ने 7.11 GiB cache से और 1.20 GiB data ड्राइव से वापस पढ़ा। पहले ने 0.12 GiB पढ़ा था। बासी सलाह मुफ़्त नहीं है, और जिस pool पर VMs आते-जाते रहते हैं, वहाँ यह हमेशा कुछ न कुछ रहेगी।

random डेटा इसका दूसरा पहलू है:

Random डेटा, 30 sसिर्फ़ bcachebcache पर VDO
4k random write, QD32, 4 jobs205,984 और 203,066 IOPS203,186 और 85,882 IOPS
p992.04 और 2.15 ms5.7 और 17.7 ms
128k write, QD82,038 और 2,017 MiB/s878 और 357 MiB/s
4k random read, QD136,609 और 36,639 IOPS, 21.6 µs26,345 और 26,202 IOPS, 33.6 और 33.7 µs
4k random read, QD32, 4 jobs471,585 और 471,730 IOPS335,461 और 336,941 IOPS

बचाने को कुछ नहीं, इसलिए VDO सिर्फ़ overhead है, और बासी-index वाले run पर इसने छोटे writes को आधे से भी कम कर दिया। दोनों columns में हर read cache से आया। ऊपर VDO का 12 µs वही स्थिर क़ीमत है जो यह नंगे Optane पर जोड़ता है।

तो जहाँ डेटा दोहराता है, वहाँ दोनों अच्छी तरह साथ चलते हैं। cache को एक चौथाई bytes मिलते हैं, वह किसी burst को ज़्यादा देर झेलता है, और spindles पर वापस लिखने को कम होता है। जहाँ दोहराता नहीं, वहाँ bcache अकेले बेहतर है।

HDD Hardware RAID6 पर: सोचा हुआ, नापा नहीं

मेरे पास test करने को कोई HDD RAID6 host नहीं है, इसलिए यह section ऊपर के नापों पर बनाया गया तर्क है। इस पर भरोसा करने से पहले अपना array नापें।

HDD RAID6 पर VDO, तर्क सेVM disks: thick LVsguests को यही दिखता हैVolume group vdovgProxmox यह पढ़ता हैVDO LV, thickdedup, LZ4, zeros छोड़ेसिराबीच: slabsपूँछVDO pool LV, तीन segmentsRAID6 virtual diskguest bytes का एक चौथाईController write-back cacheचार गुना गुंजाइशHDDsएक seek VDO के 17 µs निगल जाता हैNVMeindex और journals spindles से दूर
वह stack जिस पर यह section तर्क करता है, जिसे मैंने नापा नहीं: controller cache के पीछे RAID6 virtual disk पर slabs, index और journals एक NVMe पर।
HDD RAID6 परVDO क्या बदलता है
array तक पहुँचने वाले writesलगभग एक चौथाई, नापे गए mix जैसे mix पर
Controller write-back cacheएक चौथाई दर से भरता है, इसलिए burst को लगभग चार गुना देर झेलता है
VDO की CPU क़ीमतहर read पर 17 µs, 5 से 10 ms के seek में खो जाती है
Recovery journal writeswrite I/Os का लगभग दसवाँ हिस्सा, छोटे और flushed: इन्हें NVMe पर रखें
Index lookupsvdostats में dedupe advice timeouts पर नज़र रखें; धीमे स्टोरेज पर VDO खोजना छोड़कर duplicate फिर भी लिख सकता है
एक clone को शुरू से आख़िर तक पढ़नाधीमा: उसके blocks template के blocks की ओर इशारा करते हैं, जो array पर बिखरे हैं

पहली दो lines हार्डवेयर वाला जवाब हैं। जब तक controller के battery या flash-backed cache में जगह है, guest को cache की latency दिखती है। जब वह भर जाता है, guest को spindles दिखते हैं। उसे एक चौथाई bytes भेजें, तो वही cache लगभग चार गुना गुंजाइश देता है, और उसे ख़ाली करने को एक चौथाई ही होता है। ऊपर का bcache section यही है, controller के cache की जगह software cache के साथ नापा हुआ।

तीसरी वजह है कि VDO तेज़ disks से ज़्यादा धीमी disks पर जँचता है। Optane पर VDO ने read latency दोगुनी कर दी। 7,200 rpm ड्राइव पर वही स्थिर क़ीमत एक seek में घुल जाती है।

आख़िरी तीन क़ीमतें हैं। एक जैसे clones का boot storm तेज़ होता है, लेकिन एक clone को शुरू से आख़िर तक पढ़ना धीमा होता है, क्योंकि deduplication उसे बिखेर देता है। और VDO के अपने छोटे writes भी array पर ही उतरते हैं, जो ऊपर के split layout का आधार है: index और journal NVMe पर, slabs RAID6 पर।

Disk delete करना: Proxmox से उसे discard करवाएँ

LV हटाने से LVM में उसके extents ख़ाली हो जाते हैं। यह VDO को नहीं बताता कि blocks अब इस्तेमाल में नहीं हैं, इसलिए VDO उन्हें रखे रहता है। kernel डॉक्यूमेंटेशन बताता है कि यह क्यों मायने रखता है: “If the vdo is thinly provisioned, discarding unused blocks is essential to prevent the target from running out of space”1। thick स्टोरेज पर यह ख़त्म नहीं हो सकता, लेकिन जो blocks discard नहीं हुए, वे फिर भी उस डेटा के लिए रोकी गई ड्राइव जगह हैं जिसका कोई मालिक नहीं।

स्टोरेज पर on-volume-remove discard=1 option इसका इलाज है। Proxmox इसे “discard (TRIM) requests before removal” भेजना बताता है5:

DeleteVDO blocks ख़ाली हुए
सादा lvm स्टोरेज, 1 GiB रखने वाली disk0
on-volume-remove discard=1 के साथ, वही262,140, पूरा 1 GiB

फिर भी बड़ी disk पर यह धीमा है। fill test वाली 34 GiB disk delete करने में Proxmox को 262.6 s लगे, जबकि उसी तरह के डेटा पर blkdiscard ने 15 GiB 2.25 s में कर दिया। इसलिए किसी भी बड़ी चीज़ के लिए पहले disk को blkdiscard करें और फिर delete करें।

discard का आकार भी मायने रखता है। VDO का default max_discard हर request पर एक 4 KiB block है1:

15 GiB random डेटा का discardबीता समयCPU (sys)
max_discard=1, default8.06 s8.06 s
max_discard=4096, 16 MiB2.25 s0.00 s

guests के अंदर, ड्राइव का Discard option चालू करें ताकि उनका TRIM स्टोरेज तक पहुँचे10, और fstrim को schedule पर चलाएँ।

यह कहाँ अपनी जगह कमाता है

जँचता हैनहीं जँचता
एक जैसे कुछ templates से बने बहुत से VMsdatabases और गहराई पर latency से बँधा काम
write-back controller cache के पीछे HDD RAID6all-NVMe host जिसे हर microsecond चाहिए
VDO के metadata के लिए NVMe के साथ घूमता डेटापहले से compressed डेटा: media, backups, ISOs
घूमते डेटा के आगे bcache, जहाँ डेटा दोहराता हैऐसे डेटा के आगे bcache जो दोहराता नहीं
ड्राइव जहाँ write endurance ही सीमा हैencrypted guest disks, जो कभी deduplicate नहीं होतीं
ऐसा host जिसके पास हर pool के लिए आधा गीगाबाइट RAM फ़ालतू हैछोटा pool, जहाँ index दसवाँ हिस्सा खा जाता है
SettingDefaultइस पर रखेंबाद में बदलना
VDO वर्चुअल आकार -Vजो आप माँगेंpool की संभाल-सीमा से ज़्यादा नहींसिर्फ़ बढ़ा सकते हैं, कभी घटा नहीं सकते
VDO threads10, एक logicalहर CPU पर एक, ऊपर की तरह बँटे हुएसिर्फ़ pool के VMs रोककर
max_discard1, यानी 4 KiB4096, यानी 16 MiBसिर्फ़ pool के VMs रोककर
स्टोरेज पर on-volume-removeसेट नहींdiscard=1हाँ, pvesm set
हर वर्चुअल disk पर Discardबंदचालूहाँ, हर disk पर
scan_lvs और filter0, VM-disk reject नहीं1, VM disks अस्वीकारहाँ, lvm.conf में

इनमें से कुछ भी कठिन नहीं है। इनमें से कुछ भी default नहीं है।

सबसे सस्ता write वह है जो आप कभी भेजते ही नहीं

VDO के बारे में मुझे जो बात खटकती है, वह यह है कि इसे कितनी बुरी तरह बेचा जाता है। यह disk में उसकी क्षमता से ज़्यादा भरने के तरीक़े के रूप में सामने आता है, और यह इसका सबसे कम काम का पहलू है। पहली बार बनाते समय मैंने अनजाने में यही किया, और Proxmox एक तिहाई स्टोरेज ख़ाली दिखा रहा था जबकि VDO भरा हुआ था। Overcommit एक क़र्ज़ है, और ड्राइव उसे पूरी write speed पर वसूलती है।

असली क़ीमत उस line में है जिसे ज़्यादातर लोग कभी नापते ही नहीं। ड्राइव तक एक चौथाई bytes पहुँचने का मतलब है एक चौथाई घिसाव और ऐसा controller cache जो चार गुना देर चलता है। यह क्षमता नहीं है। यह हार्डवेयर का उसी नतीजे के लिए कम काम करना है, और यही अकेली ऐसी बचत है जो बाद में पलटकर नहीं काटती।

इसमें CPU लगता है, और तेज़ flash पर latency लगती है, और दोनों स्थिर हैं। यही सौदा है, सीधे शब्दों में: processor का समय ख़र्च किया जाता है ताकि डिब्बे का धीमा, महँगा हिस्सा कम काम करे। RAID controller या bcache के पीछे घूमती disks पर, index और journal एक NVMe पर रखकर, यह हिसाब अच्छा बैठता है। all-Optane host पर ज़्यादातर नहीं बैठता।

और यह अपना ख़याल ख़ुद नहीं रखेगा। इस काम के लिए हर ज़रूरी default ग़लत है: सोलह CPUs पर दस threads, ऐसा discard size जो एक core जला देता है, ऐसा वर्चुअल आकार जिसे आप कुछ भी रख सकते हैं, और स्टोरेज config में कुछ भी नहीं जो Proxmox से जगह वापस देने को कहे। इसमें से कुछ भी छिपा नहीं है। सब डॉक्यूमेंटेशन में है।

तो इसे thick बनाएँ, एक बार, ठीक से, settings creation line पर और metadata वहाँ जहाँ उसे होना चाहिए। ऐसा करें और ड्राइव एक चौथाई काम करती है। इसे छोड़ दें, तो आपने एक और ऐसी layer ख़रीद ली है जो अपनी क्षमता से ज़्यादा का वादा करती है।


  1. Linux kernel documentation — dm-vdo — target “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 block map cache “efficient access to 100 GB of logical space at a time” सपोर्ट करता है; thread parameters, उनकी सीमाएँ और tuning की सलाह; maxDiscard “in 4096-byte blocks”। ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. lvmvdo(7) — Support for Virtual Data Optimizer in LVM — VDO pool और VDO LV, lvconvert --type vdo-pool से मौजूदा LV को बदलना, memory इस्तेमाल, dense index और RAM के हर GiB पर उसकी 1 TiB window, और “You cannot reduce the size of a VDOPoolLV”। ↩︎ ↩︎ ↩︎ ↩︎

  3. Linux kernel source — drivers/md/dm-thin.c — disable_discard_passdown_if_not_supported() तब discard passdown बंद कर देता है जब data डिवाइस पूरा thin chunk नहीं ले सकता, और thin pool के नीचे VDO का default यही करता है। ↩︎

  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 property, “Use ‘discard=1’ to issue discard (TRIM) requests before removal”; volumes vgchange -aly से नहीं, बल्कि अलग-अलग lvchange -aey से activate किए जाते हैं। ↩︎ ↩︎

  6. Debian trixie — package vdo — “Management tools for Virtual Data Optimizer”, version 8.3.1.1-1, जो vdoformat, vdostats और vdolistmetadata देता है। ↩︎

  7. Linux kernel source — drivers/md/dm-vdo/encodings.c — vdo_initialize_layout() block map partition शुरुआत में, slab summary और recovery journal partitions अंत में, और 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.” ↩︎