ड्राइव तक कम 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 का मतलब है कम घिसाव, और ड्राइव पर या उसके आगे के 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 स्टोरेज की तरह इस्तेमाल करता है।
| Layer | lab में नाम | यह क्या करता है |
|---|---|---|
| VM disks | vm-9901-disk-0 वग़ैरह | thick LVs, Proxmox द्वारा बनाए गए |
| Volume group | vdovg, 35 GiB | सादा LVM, जिसे Proxmox का lvm स्टोरेज पढ़ता है |
| VDO LV | vdolab/vdolv, 35 GiB वर्चुअल | dedup, LZ4, zero blocks छोड़ दिए जाते हैं |
| VDO pool | vdolab/vdopool, 40 GiB | असली blocks, VDO का metadata और index |
| Physical | nvme8n1 | VG 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 index | 679,127 | 2.59 GiB |
| Recovery journal | 32,768 | 128 MiB |
| Reference counts और journals, 18 slabs | 6,372 | 25 MiB |
| उन्नीसवें slab के लिए बहुत छोटी जगह | 336,555 | 1.28 GiB |
| कुल | लगभग 4.0 GiB |
बचे हुए हिस्से वाली line जानने लायक़ है: slabs 2 GiB के होते हैं, इसलिए pool का आकार पूरे slabs और overhead के हिसाब से रखें, वरना बचा हुआ हिस्सा बस बेकार पड़ा रहता है।
RAM दूसरा बिल है। pool व्यस्त हो या ख़ाली, यह चुकाना पड़ता है:
| क़ीमत | lvmvdo(7) का नियम | यह 40 GiB pool |
|---|---|---|
| स्थिर | 38 MiB | 38 MiB |
| Block map cache | हर MiB cache पर 1.15 MiB, कम से कम 150 MiB | 150 MiB (128 MiB default) |
| Physical space | हर TiB पर 268 MiB | 11 MiB |
| UDS index (dense) | कम से कम 250 MiB, default | 256 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 पर ext4 | 114,505 | 60,537 | 47% |
उसके छह full clones (qm clone --full, हर एक लगभग 4 s) | 6,291,456 | 8 | 99.9999% |
| Proxmox Datacenter Manager 1.1 ISO, 1.36 GiB | 356,172 | 351,965 | 1.2% |
उसका -auto rebuild, लगभग वही bytes | 356,399 | 40 | 99.99% |
| 4 GiB zeros | 1,048,575 | 0 | 100% |
| 1 GiB random डेटा | 262,143 | 262,144 | 0% |
हर 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 के साथ और बिना, हर एक दो बार।
counter ईमानदार है। पूरे run में इसका जोड़ 794 GB रहा, और ड्राइव का अपना SMART “Data Units Written” भी 794 GB ही बढ़ा।
| Workload, 30 s | बिना VDO | VDO के साथ, 16 threads | ड्राइव तक पहुँचे bytes |
|---|---|---|---|
| 4k random write, QD32, 4 jobs, 75% dup, 50% compress | 582,013 IOPS, p99 244 µs | 460,887 IOPS, p99 1.05 ms | 28% |
| 128k write, QD8, 75% dup, 50% compress | 2,345 MiB/s, p99 490 µs | 2,179 MiB/s, p99 1.02 ms | 23% |
| 4k random write, QD32, 4 jobs, random डेटा | 571,721 IOPS | 272,366 से 381,005 IOPS | 59 से 100% |
| 128k write, QD8, random डेटा | 2,346 MiB/s | 1,051 से 1,854 MiB/s | 100% |
एक असल जैसे 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 पर इसमें जगह है।
| Layout | logical | physical | hash | cpu | bio | ack | कुल |
|---|---|---|---|---|---|---|---|
| LVM defaults | 1 | 1 | 1 | 2 | 4 | 1 | 10 |
| 16 CPUs से मिलाया | 4 | 4 | 2 | 3 | 2 | 1 | 16 |
| उसका दोगुना | 8 | 8 | 4 | 6 | 2 | 2 | 30 |
हर layout ने वही fio jobs दो बार चलाए, बारी-बारी से, random डेटा के साथ, और साथ में सातों clone disks एक साथ पढ़ी गईं, वैसे ही जैसे सात VMs एक साथ boot होते हैं:
| Test, दो runs का औसत | Defaults | 16 CPUs से मिलाया | उसका दोगुना |
|---|---|---|---|
| 4k random write, QD32, 4 jobs | 292,466 IOPS | 365,314 IOPS | 302,461 IOPS |
| 4k random write p99, 4 jobs | 2.1 से 3.7 ms | 1.5 से 1.6 ms | 2.1 से 2.2 ms |
| 1M sequential write | 1,153 MiB/s | 1,729 MiB/s | 1,507 MiB/s |
| 4k random read, QD32, 4 jobs | 507,450 IOPS | 503,827 IOPS | 485,263 IOPS |
| सात clone disks एक साथ पढ़ी गईं | 7.5 s | 3.1 s | 3.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 का औसत:
| Test | Optane, बिना VDO | VDO, 16 threads |
|---|---|---|
| 4k random write, QD1 | 42,294 IOPS, 19.4 µs | 55,806 IOPS, 12.1 µs |
| 4k random write, QD32 | 142,416 IOPS | 144,292 IOPS |
| 4k random write, QD32, 4 jobs | 572,293 IOPS | 365,314 IOPS |
| 4k random read, QD1 | 55,276 IOPS, 14.4 µs | 27,988 IOPS, 31.4 µs |
| 4k random read, QD32, 4 jobs | 586,463 IOPS | 503,827 IOPS |
| 1M sequential write, QD8 | 2,348 MiB/s | 1,729 MiB/s |
| सात template disks एक साथ पढ़ी गईं | 11.1 s | 3.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,188 | geometry, 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,695 | recovery journal | आख़िरी 128 MiB, लगभग |
| 10,485,696 से 10,485,759 | slab summary | बिल्कुल आख़िरी 256 KiB |
तो pool LV को तीन टुकड़ों में बनाएँ: सिरा NVMe पर, बीच धीमी ड्राइव पर, पूँछ NVMe पर।
फिर उसे 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 का कितना काम इसके साथ चला जाता है, हर 30-सेकंड run में, हर डिवाइस पर गिना हुआ:
| Workload | NVMe write I/Os | Data ड्राइव write I/Os | NVMe का हिस्सा |
|---|---|---|---|
| 4k random write, 75% dup, 50% compress | 388,430 से 538,223 | 3.42 से 3.63 million | 10 से 13% |
| 128k write, 75% dup, 50% compress | 458,214 से 634,167 | 3.30 से 3.53 million | 12 से 15% |
| 4k random write, random डेटा | 181,457 से 384,507 | 3.25 से 8.49 million | 4 से 5% |
| 4k random read | 0 writes, 2% reads | 0 |
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 में बँटा हुआ:
| डिवाइस | आकार | काम |
|---|---|---|
nvme8n1p1 | 32 GiB | bcache cache, writeback |
nvme8n1p2 | 8 GiB | VDO का सिरा और पूँछ: index, roots, recovery journal, slab summary |
nvme6n1 | 349 GiB | bcache backing डिवाइस, जहाँ डेटा रहता है |
/dev/bcache0 | 349 GiB | VDO pool का बीच, slabs |
दोनों ड्राइव फिर से Optane हैं, इसलिए nvme6n1 घूमती disk की जगह खड़ी है।
नीचे के हर आँकड़े के लिए यह याद रखें। यहाँ backing डिवाइस तेज़ है, इसलिए यह नापता है कि cache तक क्या पहुँचता है, यह नहीं कि spindle को उसे ख़ाली करने में कितना समय लगता है।
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 कहाँ गए।
| 75% dup, 50% compress, 30 s | सिर्फ़ bcache | bcache पर VDO |
|---|---|---|
| 4k random write, QD32, 4 jobs | 212,222 और 205,585 IOPS | 390,206 और 304,757 IOPS |
| p99 | 1.89 और 2.04 ms | 1.45 और 2.54 ms |
| guest ने लिखा | 24.29 और 23.53 GiB | 44.67 और 34.88 GiB |
| bcache cache में लिखा गया | 25.00 और 24.26 GiB | 11.48 और 10.44 GiB |
| VDO के metadata partition पर लिखा गया | 1.18 और 0.59 GiB | |
| हर guest byte पर cache writes | 103% | 26 और 30% |
| अंत में cache में dirty बचा | 6.0 और 6.5 GiB | 5.5 और 5.2 GiB |
| 128k write, QD8 | 2,001 और 1,985 MiB/s | 1,878 और 1,416 MiB/s |
| हर guest byte पर cache writes, 128k | 101% | 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 | सिर्फ़ bcache | bcache पर VDO |
|---|---|---|
| 4k random write, QD32, 4 jobs | 205,984 और 203,066 IOPS | 203,186 और 85,882 IOPS |
| p99 | 2.04 और 2.15 ms | 5.7 और 17.7 ms |
| 128k write, QD8 | 2,038 और 2,017 MiB/s | 878 और 357 MiB/s |
| 4k random read, QD1 | 36,609 और 36,639 IOPS, 21.6 µs | 26,345 और 26,202 IOPS, 33.6 और 33.7 µs |
| 4k random read, QD32, 4 jobs | 471,585 और 471,730 IOPS | 335,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 क्या बदलता है |
|---|---|
| array तक पहुँचने वाले writes | लगभग एक चौथाई, नापे गए mix जैसे mix पर |
| Controller write-back cache | एक चौथाई दर से भरता है, इसलिए burst को लगभग चार गुना देर झेलता है |
| VDO की CPU क़ीमत | हर read पर 17 µs, 5 से 10 ms के seek में खो जाती है |
| Recovery journal writes | write I/Os का लगभग दसवाँ हिस्सा, छोटे और flushed: इन्हें NVMe पर रखें |
| Index lookups | vdostats में 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:
| Delete | VDO blocks ख़ाली हुए |
|---|---|
सादा lvm स्टोरेज, 1 GiB रखने वाली disk | 0 |
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, default | 8.06 s | 8.06 s |
max_discard=4096, 16 MiB | 2.25 s | 0.00 s |
guests के अंदर, ड्राइव का Discard option चालू करें ताकि उनका TRIM स्टोरेज तक पहुँचे10, और fstrim को schedule पर चलाएँ।
यह कहाँ अपनी जगह कमाता है
| जँचता है | नहीं जँचता |
|---|---|
| एक जैसे कुछ templates से बने बहुत से VMs | databases और गहराई पर latency से बँधा काम |
| write-back controller cache के पीछे HDD RAID6 | all-NVMe host जिसे हर microsecond चाहिए |
| VDO के metadata के लिए NVMe के साथ घूमता डेटा | पहले से compressed डेटा: media, backups, ISOs |
| घूमते डेटा के आगे bcache, जहाँ डेटा दोहराता है | ऐसे डेटा के आगे bcache जो दोहराता नहीं |
| ड्राइव जहाँ write endurance ही सीमा है | encrypted guest disks, जो कभी deduplicate नहीं होतीं |
| ऐसा host जिसके पास हर pool के लिए आधा गीगाबाइट RAM फ़ालतू है | छोटा pool, जहाँ index दसवाँ हिस्सा खा जाता है |
| Setting | Default | इस पर रखें | बाद में बदलना |
|---|---|---|---|
VDO वर्चुअल आकार -V | जो आप माँगें | pool की संभाल-सीमा से ज़्यादा नहीं | सिर्फ़ बढ़ा सकते हैं, कभी घटा नहीं सकते |
| VDO threads | 10, एक logical | हर CPU पर एक, ऊपर की तरह बँटे हुए | सिर्फ़ pool के VMs रोककर |
max_discard | 1, यानी 4 KiB | 4096, यानी 16 MiB | सिर्फ़ pool के VMs रोककर |
स्टोरेज पर on-volume-remove | सेट नहीं | discard=1 | हाँ, pvesm set |
| हर वर्चुअल disk पर Discard | बंद | चालू | हाँ, हर disk पर |
scan_lvs और filter | 0, 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 ख़रीद ली है जो अपनी क्षमता से ज़्यादा का वादा करती है।
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”। ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎
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”। ↩︎ ↩︎ ↩︎ ↩︎Linux kernel source — drivers/md/dm-thin.c —
disable_discard_passdown_if_not_supported()तब discard passdown बंद कर देता है जब data डिवाइस पूरा thin chunk नहीं ले सकता, और thin pool के नीचे VDO का default यही करता है। ↩︎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”। ↩︎ ↩︎Proxmox pve-storage — LVMPlugin.pm —
on-volume-removeproperty, “Use ‘discard=1’ to issue discard (TRIM) requests before removal”; volumesvgchange -alyसे नहीं, बल्कि अलग-अलगlvchange -aeyसे activate किए जाते हैं। ↩︎ ↩︎Debian trixie — package vdo — “Management tools for Virtual Data Optimizer”, version 8.3.1.1-1, जो
vdoformat,vdostatsऔरvdolistmetadataदेता है। ↩︎Linux kernel source — drivers/md/dm-vdo/encodings.c —
vdo_initialize_layout()block map partition शुरुआत में, slab summary और recovery journal partitions अंत में, और slab depot बची हुई जगह से बनाता है। ↩︎fio documentation — randrepeat — “Seed all random number generators in a predictable way so the pattern is repeatable across runs. Default: true.” ↩︎
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.” ↩︎
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.” ↩︎