Disk qanday ishlaydi?
Dastur yozishda xotiraga baytma-bayt murojaat qilish uchun arr[57] deb yozishga o'rganganmiz, bu usulda kerakli qiymat
bir zumda keladi. Shu sababli disk ham shunday ishlaydi, ya'ni fayldan istalgan bitta baytni olish mumkin deb o'ylaymiz.
Aslida bunday emas. Disk ham, operatsion tizim ham ma'lumotni bayt-bayt emas, belgilangan o'lchamdagi bo'laklar bilan
o'qiydi va yozadi. Bu bo'lak block (blok) deyiladi. Ma'lumotlar bazalari, fayl tizimlari, log yozuvchi servislar
hammasi shu asos ustiga quriladi.
Nega baytma-bayt o'qib/yozib bo'lmaydi?
Diskdagi har bir baytga alohida murojaat qilish mumkin bo'lganida nima bo'lardi, deb tasavvur qilaylik. Ikki jiddiy muammo darhol yuzaga chiqadi.
Birinchi muammo: har bir murojaatning "yo'l haqi" bor. Diskdan biror narsa olish uchun ma'lumot uzatilishidan oldin tayyorgarlik kerak. Aylanuvchi diskda (HDD) o'qish boshchasi kerakli joyga jismonan siljishi va disk kerakli nuqtani boshcha ostiga aylantirib kelishi kerak, bu millisekundlar. SSD'da mexanik qism yo'q, lekin buyruqni qabul qilish, flash xotira chipidan ma'lumotni "ko'tarish" va natijani qaytarish o'nlab mikrosekund oladi. Shundan keyingi uzatishning o'zi esa juda tez. Agar har bir bayt uchun bu yo'l haqini alohida to'lasak, 1 MB faylni o'qish soatlab davom etardi.
Ikkinchi muammo: har bir baytni boshqarish juda qimmat. Disk ma'lumotni shunchaki "yozib qo'ymaydi". U har bir saqlangan bo'lak uchun manzil, xatolarni aniqlash va tuzatish kodi (ECC, Error Correcting Code), sinxronizatsiya belgilari kabi xizmat ma'lumotlarini ham saqlaydi. Agar bularni har bir bayt uchun saqlasak, xizmat ma'lumoti foydali ma'lumotdan ko'p joy egallagan bo'lardi.
Shu sababli uskuna dizaynerlari tabiiy yechimga kelishdi: diskni belgilangan o'lchamdagi bo'laklarga bo'lish, har bir bo'lakka bitta manzil va bitta ECC berish, va faqat butun bo'laklar bilan ishlash.
Kundalik o'xshatish
Arxivchiga borib, "menga shu kitobning 57-betidagi uchinchi so'zni bering" desangiz, u so'zni qaychi bilan kesib bermaydi. U butun kitobni (yoki hech bo'lmaganda o'sha betning nusxasini) olib chiqadi. Arxivga borish, javonni topish, kitobni tushirish: vaqtning asosiy qismi shularga ketadi. Bitta so'z yoki butun bet: farqi deyarli yo'q. Arxivchi uchun "bitta so'z" degan tushuncha umuman mavjud emas, uning eng kichik birligi bet.
Asosiy g'oya
- Saqlash qurilmasi ma'lumotni faqat belgilangan o'lchamdagi bloklar bilan o'qiydi va yozadi. Undan kichik birlik uning uchun mavjud emas.
- Har bir murojaatning narxi asosan "borish" xarajatiga bog'liq, olib kelinadigan ma'lumot miqdoriga emas. Shuning uchun 1 bayt va bitta butun blok o'qish deyarli bir xil vaqt oladi.
- Bu qoida bitta qatlamda emas, kompyuterning barcha qatlamlarida takrorlanadi: protsessor keshida, operativ xotirada, operatsion tizimda va diskda.
Bir g'oya, ko'p qatlam
"Blok" g'oyasi kompyuterning turli qatlamlarida turli nom va o'lchamda uchraydi. Pastdan yuqoriga qarab:
| Qatlam | Birlik nomi | Odatiy o'lcham | Kim belgilaydi |
|---|---|---|---|
| HDD | sector (sektor) | 512 bayt yoki 4 KB | disk ishlab chiqaruvchisi |
| SSD | NAND page (o'qish/yozish) | 4–16 KB | flash chip |
| SSD | erase block (o'chirish) | yuzlab KB dan bir necha MB gacha | flash chip |
| Disk interfeysi | logical block (mantiqiy blok) | 512 bayt yoki 4 KB | qurilma OS'ga e'lon qiladi |
| Fayl tizimi (ext4, XFS, NTFS, APFS) | block / cluster | odatda 4 KB | fayl tizimi yaratilganda |
| Operatsion tizim xotirasi | page | odatda 4 KB (x86-64) | protsessor arxitekturasi va OS |
| Protsessor keshi | cache line | 64 bayt | protsessor |
Dastur so'raydi: [1 bayt]
│
Protsessor keshi: [ 64 B cache line ]
│
OS xotirasi (page): [ 4 KB page ]
│
Fayl tizimi: [ 4 KB block ]
│
Disk: [ 512 B ][ 512 B ]... yoki [ 4 KB sector ]
Har bir qatlam o'zidan pastdagi qatlamning birligini yig'ib, o'zining birligini quradi. Va har bir qatlamda bir xil hikoya: "sizga 1 bayt kerakmi? Men butun birlikni olib kelaman".
Atamalar haqida
"Page" va "block" so'zlari turli kontekstlarda turlicha ishlatiladi va ko'pincha aralashib ketadi. OS xotirasi haqida gapirganda odatda "page", disk va fayl tizimi haqida "block" yoki "sector" deyiladi. SSD'da esa "page" flash chipning o'qish birligi. Maqolani o'qiyotganda qaysi qatlam haqida gap ketayotganiga e'tibor bering.
Qatlamlarni yaqinroqdan ko'ramiz
HDD: sektor
Aylanuvchi disk ichida magnit qoplamali plastinkalar (platters) bor. Har bir plastinka konsentrik halqalarga, ya'ni tracklarga (yo'laklarga), har bir track esa sectorlarga bo'lingan. Sektor diskning eng kichik o'qish va yozish birligi.
┌──────── track (yo'lak) ────────┐
│ │
╭────┴────┬─────────┬─────────┬───────┴─╮
│ sector │ sector │ sector │ sector │ ...
╰─────────┴─────────┴─────────┴─────────╯
Bitta sektor ichida:
┌──────┬────────────┬─────────────────────────┬───────┬──────┐
│ gap │ sync/manzil│ ma'lumot (512 B / 4 KB)│ ECC │ gap │
└──────┴────────────┴─────────────────────────┴───────┴──────┘
Har bir sektorda foydali ma'lumotdan tashqari oraliq (gap), sinxronizatsiya va manzil belgilari hamda ECC bor. Uzoq yillar davomida sektor 512 bayt edi. Disklar kattalashgani sari xizmat ma'lumotining ulushi ham, ECC talabi ham oshdi. Shu sababli 2010-yillardan boshlab Advanced Format disklari 4 KB'lik sektorlarga o'tdi: sakkizta kichik sektor o'rniga bitta katta sektor xizmat ma'lumotini kamaytiradi va kuchliroq ECC ishlatishga imkon beradi.
Eski dasturiy ta'minot bilan moslik uchun ko'p disklar "ikki yuzli" ishlaydi:
| Format | Fizik sektor | OS'ga e'lon qilinadigan mantiqiy sektor |
|---|---|---|
| 512n (native) | 512 B | 512 B |
| 512e (emulation) | 4 KB | 512 B |
| 4Kn (native) | 4 KB | 4 KB |
512e diskda OS 512 baytlik blok yozsa, disk ichkarida butun 4 KB sektorni o'qib, 512 baytini almashtirib, qayta yozishga majbur bo'ladi. Bu pastda ko'radigan read-modify-write muammosining apparat darajasidagi ko'rinishi.
Zamonaviy disklar OS'ga track va sektor raqamlarini ko'rsatmaydi. Ular diskni oddiy raqamlangan bloklar ketma-ketligi sifatida taqdim etadi: 0, 1, 2, ... N. Bu LBA (Logical Block Addressing, mantiqiy blok manzillash) deyiladi. Qaysi LBA qaysi fizik joyda ekanini diskning o'zi biladi.
SSD: o'qish birligi va o'chirish birligi
SSD ma'lumotni NAND flash chiplarida saqlaydi. Bu yerda birlik tushunchasi yanada qiziqroq, chunki o'qish, yozish va o'chirish turli birliklarda ishlaydi:
| Amal | Birlik | Odatiy o'lcham |
|---|---|---|
| O'qish | NAND page | 4–16 KB |
| Yozish | NAND page | 4–16 KB, faqat bo'sh (o'chirilgan) sahifaga |
| O'chirish | erase block | o'nlab-yuzlab sahifa (yuzlab KB dan bir necha MB gacha) |
Erase block (masalan, 256 ta page)
┌──────┬──────┬──────┬──────┬──────┬─────┬──────┐
│ page │ page │ page │ page │ page │ ... │ page │
│ 16KB │ 16KB │ 16KB │ 16KB │ 16KB │ │ 16KB │
└──────┴──────┴──────┴──────┴──────┴─────┴──────┘
O'qish va yozish: bitta page
O'chirish: faqat butun blok bir yo'la
Eng muhim cheklov: flash xotirada mavjud sahifaning ustidan yozib bo'lmaydi. Avval u o'chirilishi kerak, o'chirish esa faqat butun erase block bilan mumkin. Shu sababli SSD ichida FTL (Flash Translation Layer, flash tarjima qatlami) deb ataladigan dasturiy qatlam ishlaydi. Siz bir blokni "o'zgartirganingizda", FTL uni aslida boshqa bo'sh sahifaga yozadi, manzil jadvalini yangilaydi, eski sahifani esa "eskirgan" deb belgilaydi. Eskirgan sahifalar ko'payganda, fonda garbage collection (axlat yig'ish) ishlab, bloklarni tozalaydi.
Bundan bir muhim oqibat kelib chiqadi: SSD'da kichik tartibsiz yozishlar ichkarida ancha ko'p ish keltirib chiqarishi mumkin. Bu write amplification (yozishning kuchayishi) deyiladi: siz 4 KB yozasiz, qurilma ichkarida esa ko'proq yozadi.
Shunga qaramay, SSD ham OS'ga oddiy LBA bloklari (512 B yoki 4 KB) ko'rinishida ko'rinadi. Barcha murakkablik FTL ichida yashiringan.
Fayl tizimi: blok
Fayl tizimi (ext4, XFS, NTFS, APFS) diskni o'zining bloklariga bo'ladi va har bir faylni shu bloklar zanjiri sifatida saqlaydi. Linux'dagi ext4 va XFS'da standart blok odatda 4 KB. (Windows'dagi NTFS'da u cluster, ya'ni allocation unit deyiladi va standart 4 KB.)
Bundan bir qiziq fakt kelib chiqadi: 1 baytlik fayl ham diskda kamida bitta to'liq blok egallaydi.
1 baytlik fayl: [■...............................] 4 KB blok
5000 baytlik fayl: [████████████████████████████████][████████.......................]
↑ 1-blok to'la ↑ 2-blokning bir qismi
Operatsion tizim: page va page cache
Operatsion tizim operativ xotirani pagelarga bo'ladi, x86-64 protsessorlarda odatda 4 KB. (ARM64 tizimlarida 16 KB yoki 64 KB ham bo'lishi mumkin, masalan Apple Silicon Mac'larda 16 KB.) OS diskdan o'qigan fayl bloklarini xotiradagi maxsus keshda, ya'ni page cacheda saqlaydi. Keyingi safar o'sha qism kerak bo'lsa, diskka borilmaydi.
Protsessor: cache line
Xuddi shu g'oya eng yuqori qatlamda ham ishlaydi. Protsessor operativ xotiradan bitta baytni ham o'qimaydi: u cache line deb ataladigan 64 baytlik bo'lakni o'z keshiga olib keladi. Massivni ketma-ket aylanib chiqish bog'langan ro'yxatni (linked list) aylanishdan tezroq bo'lishining sabablaridan biri shu: massivning qo'shni elementlari bitta cache line'da bo'ladi.
Umumiy qonuniyat
Kompyuterning har bir qatlamida bir xil savdo bor: tezroq va kichikroq xotira sekinroq va kattaroq xotiradan ma'lumotni bo'lak-bo'lak olib keladi, chunki har bir murojaatning belgilangan xarajati bor. Bo'lak o'lchami pastga tushgan sari kattalashadi: protsessorda 64 bayt, xotira va disk orasida 4 KB, SSD ichida esa megabaytlar.
Ichki ishlashi: siz 1 bayt so'raganingizda nima bo'ladi
Faraz qiling, dastur fayldan bitta baytni o'qiyapti: Linux'da bu read(fd, buf, 1) tizim chaqiruvi (system call). Ichkarida taxminan quyidagilar sodir bo'ladi:
Dastur: read(fd, buf, 1) — "10 000-baytdan 1 bayt ber"
│
OS (VFS): 10 000 / 4096 = 2 → faylning 2-sahifasi kerak
│
Page cache: 2-sahifa xotirada bormi?
├── ha → 1 baytni nusxalab, darhol qaytar (diskka borilmaydi)
└── yo'q ↓
Fayl tizimi: faylning 2-bloki diskning qaysi LBA'sida?
│
Block layer: "LBA 81 920 dan 4 KB o'qi" degan so'rov tuziladi
│
Drayver → disk: disk butun blokni (yoki sektorlarni) o'qib beradi
│
Page cache: 4 KB sahifa xotiraga joylanadi
│
Dastur: buf ichiga 1 bayt nusxalanadi
- Dastur OS'ga "faylning 10 000-baytidan 1 bayt ber" deb murojaat qiladi.
- OS bu bayt faylning qaysi sahifasiga tegishli ekanini hisoblaydi: 10 000 / 4096 = 2 (0 dan sanaganda).
- OS avval page cache'ga qaraydi.
- Sahifa keshda bo'lsa, bayt darhol qaytariladi. Bu cache hit.
- Sahifa keshda bo'lmasa (cache miss), fayl tizimi shu sahifaning diskdagi manzilini (LBA) aniqlaydi, OS diskdan butun 4 KB'ni o'qiydi va keshga joylaydi.
- Dasturga faqat 1 bayt beriladi, qolgan 4095 bayt keshda qoladi. Keyingi so'rov qo'shni baytni so'rasa, u diskka bormasdan keladi.
Amalda OS ko'pincha bundan ham ko'proq o'qiydi: dastur faylni ketma-ket o'qiyotganini sezsa, keyingi bloklarni oldindan o'qib qo'yadi (readahead).
Yozish: read-modify-write
Yozish o'qishdan ham qiziqroq. Siz fayl o'rtasidagi bitta baytni o'zgartirmoqchisiz. Lekin disk bitta baytni yoza olmaydi, faqat butun blokni. Demak:
- OS shu bayt joylashgan butun sahifani xotiraga olib keladi (agar u keshda bo'lmasa, avval diskdan o'qiydi).
- Xotirada bitta baytni o'zgartiradi. Endi sahifa dirty (iflos), ya'ni diskdagi nusxadan farq qiladi.
- Keyinroq, OS o'zi tanlagan vaqtda (yoki dastur
fsyncchaqirganda), butun sahifa diskka qayta yoziladi.
1. O'qish: disk ──► [ A B C D E F G H ... ] (4 KB)
2. O'zgartirish: [ A B X D E F G H ... ] (1 bayt o'zgardi)
3. Yozish: disk ◄── [ A B X D E F G H ... ] (yana 4 KB)
Bu read-modify-write (o'qi-o'zgartir-yoz) deyiladi. Bitta baytlik o'zgarish 4 KB o'qish va 4 KB yozishni talab qiladi.
Ikkinchi muhim tafsilot: write() chaqiruvi muvaffaqiyatli qaytgani ma'lumot diskka yozildi degani emas. Ma'lumot hozircha faqat page cache'da, ya'ni operativ xotirada. Agar shu paytda elektr o'chsa, u yo'qoladi. Ma'lumot haqiqatan diskka yetib borishini kafolatlash uchun dastur fsync() chaqirishi kerak. Ma'lumot saqlashi muhim bo'lgan har qanday dastur (ma'lumotlar bazalari, xabar navbatlari) aynan shu chaqiruvga tayanadi, va u qimmat.
Bloklar va ishonchlilik: yarim yozilgan ma'lumot
Blok tushunchasining yana bir muhim tomoni bor: atomiklik (bo'linmaslik). Disk odatda bitta sektorni yozishni "yoki to'liq, yoki umuman yo'q" tarzida bajarishga harakat qiladi. Lekin agar dastur bir yo'la bir nechta blokni (masalan, 16 KB) yozsa-yu, shu payt elektr o'chsa, ularning bir qismi yangi, bir qismi eski bo'lib qolishi mumkin.
Dastur yozmoqchi: [ 4 KB yangi ][ 4 KB yangi ][ 4 KB yangi ][ 4 KB yangi ]
Elektr o'chdi: [ 4 KB YANGI ][ 4 KB YANGI ][ 4 KB eski ][ 4 KB eski ]
└──────────── 16 KB: yarim yangi, yarim eski ───────────┘
Bu holat torn write (yirtilgan yozish) deyiladi. Dastur o'z ma'lumotini qurilmaning atomik yozish birligidan kattaroq bo'laklar bilan saqlasa, bu xavfni o'zi hisobga olishi kerak: masalan, nazorat summasi (checksum) bilan buzilishni aniqlash yoki o'zgarishni avval alohida jurnalga yozish. Ma'lumotlar bazalari va jurnalli fayl tizimlari (journaling file systems) aynan shunday qiladi.
Kafolatlar uskunaga bog'liq
Qaysi o'lchamdagi yozish atomik bo'lishi qurilma va uning keshiga bog'liq. Ko'p dasturiy ta'minot faqat bitta sektor yozilishi atomik deb faraz qiladi va undan kattasiga ishonmaydi. Linux yangi versiyalarida (6.11+) qo'llab-quvvatlaydigan qurilmalar uchun maxsus atomik yozish imkoniyati qo'shilgan, lekin bu hali hamma joyda yo'q.
Nega 1 bayt va 4 KB deyarli bir xil narx?
Raqamlarga qaraylik. Quyidagilar taxminiy qiymatlar, aniq raqam uskunaga bog'liq:
| Bosqich | HDD (7200 RPM) | SSD (NVMe) |
|---|---|---|
| "Borish" (seek + aylanish / buyruq va flash o'qish) | ~5–10 ms | ~20–100 µs |
| 4 KB'ni uzatish | ~0.02–0.03 ms | ~1–2 µs |
| Jami: 4 KB o'qish | ~5–10 ms | ~20–100 µs |
| Agar faqat 1 bayt o'qish mumkin bo'lganda | baribir ~5–10 ms | baribir ~20–100 µs |
Vaqtning deyarli hammasi "borish"ga ketadi, uzatish esa arzimas ulush. Shu sababli bitta murojaatda 1 bayt yoki 4 KB olishning deyarli farqi yo'q. Biroq bir xil 4 KB'ni ikkita alohida murojaatda olish ikki baravar qimmat.
Bu yerdan chiqadigan asosiy qoida:
Asosiy qoida
I/O narxini o'qilgan baytlar emas, murojaatlar soni belgilaydi. Tez dastur diskka kam marta boradi va har borishda iloji boricha ko'p foydali ma'lumot olib keladi.
Ko'p kompyuter mutaxassislari eslab yuradigan taxminiy raqamlar jadvali ham bor. U qatlamlar orasidagi farqni yaxshi ko'rsatadi:
| Amal | Taxminiy vaqt | Agar 1 ns = 1 soniya bo'lsa |
|---|---|---|
| Protsessor keshidan o'qish (L1) | ~1 ns | 1 soniya |
| Operativ xotiradan o'qish | ~100 ns | ~1.5 daqiqa |
| SSD'dan 4 KB tasodifiy o'qish | ~20–100 µs | ~6–28 soat |
| HDD'dan tasodifiy o'qish | ~5–10 ms | ~2–4 oy |
Dastur yozuvchi uchun oqibatlar
Blok tushunchasidan har qanday dasturga tegishli bir nechta amaliy xulosa chiqadi.
1. Kichik o'qishlarni birlashtiring. Faylni bayt-bayt yoki qator-qator read() bilan o'qish har safar tizim chaqiruvi xarajatini to'laydi. Shuning uchun dasturlash tillarining standart kutubxonalari bufer bilan ishlaydi: Python'ning open(), Java'ning BufferedReaderi, C'ning fread funksiyasi ichkarida odatda bir necha KB'lik bo'laklarni o'qiydi. Ular ham aynan blok g'oyasini dastur darajasida takrorlaydi.
2. Birga kerak bo'ladigan ma'lumotni yonma-yon saqlang. Bitta blokka sig'adigan 100 ta yozuv bitta murojaatda keladi. Diskning 100 xil joyiga sochilgan 100 ta yozuv esa 100 ta murojaat talab qiladi. Bu data locality (ma'lumot yaqinligi) deyiladi, va u ma'lumotlarni saqlaydigan har qanday tizim dizaynining markazida turadi.
3. Tuzilmalarni blok o'lchamiga moslang. Diskda saqlanadigan ma'lumot tuzilmalari (daraxtlar, indekslar, jadvallar) odatda bitta tugun bitta blokka teng bo'ladigan qilib quriladi. Shunda bitta tugunni o'qish bitta murojaat bo'ladi, va bitta tugunga yuzlab element sig'adi.
4. Kichik yozishlar qimmat. Read-modify-write tufayli bitta baytlik o'zgarish butun blokni o'qish va yozishni talab qiladi. Ko'p mayda yozishlarni yig'ib, bir yo'la yozish ancha samarali.
5. Hizalash (alignment) muhim. Agar dasturning yozish birligi blok chegarasiga to'g'ri kelmasa, bitta mantiqiy yozuv ikki blokka "siljib" qoladi va har bir yozish ikki blokni o'zgartiradi. Disk bo'limlari (partitions) ham shu sababli 1 MB chegarasidan boshlanadigan qilib yaratiladi.
Hizalangan: | 4 KB blok | 4 KB blok | 4 KB blok |
Yozuvlar: [ yozuv 1 ][ yozuv 2 ][ yozuv 3 ] → har yozuv = 1 blok
Hizalanmagan: | 4 KB blok | 4 KB blok | 4 KB blok |
Yozuvlar: [ yozuv 1 ][ yozuv 2 ] → har yozuv = 2 blok
Amaliy misol
Quyidagi buyruqlar Linux uchun. Docker konteyneri ichida ham ishlaydi (docker run -it --rm ubuntu bash), lekin ayrim buyruqlar root huquqi yoki haqiqiy diskka kirishni talab qiladi.
macOS va Windows'da Docker
Docker Desktop konteynerlarni virtual mashina ichida ishga tushiradi. Shu sababli konteyner ichida ko'rgan disk va keshingiz virtual mashinaniki, sizning haqiqiy diskingizniki emas. Tushunchani ko'rish uchun bu yetarli, lekin aniq tezlik o'lchovlari uchun Linux mashina afzal.
1. Turli qatlamlardagi blok o'lchamlarini ko'rish
# Operatsion tizim sahifa o'lchami
getconf PAGESIZE
# 4096
# Fayl tizimi bloki
stat -f -c "Fayl tizimi bloki: %S bayt" /
# Fayl tizimi bloki: 4096 bayt
# Disklar: fizik va mantiqiy sektor, aylanuvchi (1) yoki yo'q (0)
lsblk -o NAME,PHY-SEC,LOG-SEC,ROTA
# NAME PHY-SEC LOG-SEC ROTA
# nvme0n1 4096 512 0
PHY-SEC = 4096 va LOG-SEC = 512 bo'lsa, bu yuqorida ko'rgan 512e qurilma: ichkarida 4 KB, tashqarida 512 bayt deb e'lon qiladi. Protsessor cache line o'lchamini ham ko'rish mumkin:
2. 1 baytlik fayl qancha joy egallaydi
echo -n "A" > bir_bayt.txt
ls -l bir_bayt.txt # mantiqiy hajm
# -rw-r--r-- 1 user user 1 ... bir_bayt.txt
du -h bir_bayt.txt # diskda egallagan joy
# 4.0K bir_bayt.txt
stat -c "Hajm: %s bayt, ajratilgan bloklar: %b x %B bayt" bir_bayt.txt
# Hajm: 1 bayt, ajratilgan bloklar: 8 x 512 bayt
ls 1 bayt deydi, du esa 4 KB: fayl tizimi bitta to'liq blok ajratgan. (stat bloklarni an'anaviy 512 baytlik birliklarda sanaydi: 8 × 512 = 4096.)
3. Disk 1 baytni "qabul qilmaydi": O_DIRECT tajribasi
Odatda OS page cache orqali ishlaydi va blok qoidasini sizdan yashiradi. Lekin O_DIRECT rejimida dastur keshni chetlab, to'g'ridan-to'g'ri qurilma bilan ishlaydi. Shunda blok qoidasi ochiq ko'rinadi.
# 100 MB'lik test fayli
dd if=/dev/urandom of=test.bin bs=1M count=100
# Keshni chetlab, 1 bayt o'qishga urinish
dd if=test.bin of=/dev/null bs=1 count=1 iflag=direct
# dd: error reading 'test.bin': Invalid argument
# Keshni chetlab, 4 KB o'qish
dd if=test.bin of=/dev/null bs=4096 count=1 iflag=direct
# 1+0 records in ... 4096 bytes copied
Qurilmaga to'g'ridan-to'g'ri murojaat qilganda 1 baytlik so'rov rad etildi: Invalid argument. Bu blokdan kichik birlik qurilma uchun umuman mavjud emasligining eng yaqqol isboti. Oddiy rejimda 1 bayt o'qish ishlaydi, chunki OS so'rovni o'zi butun blokka aylantirib beradi.
Fayl tizimiga bog'liq
Ba'zi fayl tizimlari (masalan, tmpfs yoki ayrim overlay fayl tizimlari) O_DIRECTni qo'llab-quvvatlamaydi va har ikki holatda xato berishi mumkin. Bunday holatda test faylni oddiy diskdagi papkada yarating.
4. 1 bayt so'radik, kesh qancha oldi?
fincore buyrug'i (util-linux paketida) faylning qaysi qismi page cache'da ekanini ko'rsatadi.
# Keshni tozalash (root kerak; Docker'da odatda ruxsat yo'q)
sync; echo 3 | sudo tee /proc/sys/vm/drop_caches
fincore test.bin
# RES PAGES SIZE FILE
# 0B 0 100M test.bin ← keshda hech narsa yo'q
# Fayl o'rtasidan 1 bayt o'qish (oddiy, keshli rejim)
dd if=test.bin of=/dev/null bs=1 count=1 skip=50000000
fincore test.bin
# RES PAGES SIZE FILE
# 16K 4 100M test.bin ← masalan: 1 bayt so'raldi, bir necha sahifa keldi
1 bayt so'radik, lekin keshga kamida bitta to'liq 4 KB sahifa, ko'pincha esa readahead tufayli bir nechta sahifa keldi. Aniq son yadro versiyasi va sozlamalarga bog'liq.
5. Tizim chaqiruvlarini kuzatish
strace dastur OS'dan aslida nimani so'rayotganini ko'rsatadi:
# Python'da 1 bayt o'qish
strace -e trace=read python3 -c "f = open('test.bin', 'rb'); f.read(1)" 2>&1 | tail -3
# read(3, "...", 4096) = 4096 ← misol: 1 bayt so'raldi, kutubxona butun blokni o'qidi
Dastur 1 bayt so'radi, lekin Python kutubxonasi OS'dan butun bir bo'lakni so'radi. Bufer o'lchamini Python odatda fayl tizimi blokidan oladi, aniq qiymat esa versiya va tizimga bog'liq. Ya'ni blok g'oyasi dasturlash tili kutubxonasida ham takrorlanadi.
Trade-off: katta yoki kichik blok?
Blok o'lchamini tanlash har doim muvozanat masalasi:
| Kichik blok (masalan, 512 B – 4 KB) | Katta blok (masalan, 64 KB – 1 MB) | |
|---|---|---|
| Kichik tasodifiy o'qishlar | kam ortiqcha ma'lumot o'qiladi | ko'p keraksiz ma'lumot o'qiladi |
| Katta ketma-ket o'qishlar | ko'proq murojaat | kamroq murojaat |
| Mayda fayllar uchun joy | kam isrof | ko'p isrof (1 baytlik fayl ham butun blok) |
| Boshqaruv ma'lumoti (manzillar, ECC) | ko'proq | kamroq |
| Xotira keshi samaradorligi | aniqroq | bitta "issiq" bayt uchun butun katta blok xotirada turadi |
| Yarim yozilish xavfi | kamroq | ko'proq |
Shuning uchun turli tizimlar turli o'lcham tanlaydi: umumiy fayl tizimlari 4 KB'da to'xtaydi, katta fayllar bilan ishlaydigan tizimlar (video saqlash, katta hajmli tahliliy tizimlar) esa ancha katta bo'laklardan foydalanadi.
Tipik xatolar va noto'g'ri tushunchalar
- "Fayldan 1 bayt o'qisam, diskdan 1 bayt o'qiladi." Yo'q. Kamida bitta butun blok, ko'pincha readahead tufayli undan ham ko'proq o'qiladi.
- "
write()qaytdi, demak ma'lumot diskda." Yo'q. U hozircha faqat page cache'da. Diskka yetib borishini faqatfsync()kafolatlaydi. - "SSD'da bloklar ahamiyatsiz, u xotiraga o'xshaydi." SSD tezroq, lekin u ham blok bilan ishlaydi, ustiga-ustak, ustidan yozib bo'lmaydi va o'chirish ancha katta birlikda bo'ladi.
- "1 baytlik fayl 1 bayt joy egallaydi." Diskda u kamida bitta to'liq blok egallaydi. Millionlab mayda fayllarda bu gigabaytlar isrof demak.
- "Bitta katta yozish atomik." Faqat qurilmaning atomik birligidan kichik yozishlar xavfsiz. Kattaroq yozish elektr o'chishida yarmi bilan qolishi mumkin.
O'ziz uchun shu savollarga javob berishga harakat qiling
- Nega disklar ma'lumotni baytlar emas, sektorlar yoki bloklar bilan saqlaydi?
- Page cache nima va u
read()vawrite()xatti-harakatiga qanday ta'sir qiladi? - Read-modify-write nima va qachon yuzaga keladi?
write()vafsync()farqi nima? Nega ma'lumot saqlovchi tizimlarfsyncga tayanadi?- Torn write nima va dastur undan qanday himoyalanishi mumkin?
- Sizda 10 million mayda (o'rtacha 100 baytlik) fayl bor. Ular jami qancha "foydali" ma'lumot saqlaydi va diskda taxminan qancha joy egallaydi? Bu muammoni qanday hal qilardingiz?
- Dastur log faylga har bir hodisani alohida
write()vafsync()bilan yozyapti. Nega bu sekin, va ishonchlilikni yo'qotmasdan qanday tezlashtirish mumkin? - Nega SSD'da flash xotira ustidan to'g'ridan-to'g'ri yozib bo'lmasligi FTL va garbage collection kabi murakkab mexanizmlarni talab qiladi? Bu kichik tasodifiy yozishlarga qanday ta'sir qiladi?
- Protsessor cache line (64 bayt) va disk bloki (4 KB) bir xil qonuniyatga bo'ysunadi. Massiv va bog'langan ro'yxatni aylanib chiqish tezligidagi farqni shu qonuniyat orqali tushuntiring.
Xulosa
- Saqlash qurilmalari ma'lumotni faqat bloklar bilan o'qiydi va yozadi: HDD'da sektor (512 B yoki 4 KB), SSD'da NAND page (4–16 KB) va undan katta erase block.
- Bu g'oya kompyuterning barcha qatlamlarida takrorlanadi: protsessorda cache line (64 B), OS'da page (4 KB), fayl tizimida block (4 KB).
- Har bir murojaatning narxi asosan "borish" xarajatiga bog'liq, shuning uchun 1 bayt va 4 KB o'qish deyarli bir xil narx. I/O narxini baytlar emas, murojaatlar soni belgilaydi.
- Bitta baytni o'zgartirish read-modify-writeni talab qiladi,
write()esa ma'lumotni faqat keshga qo'yadi; diskka yetib borishinifsync()kafolatlaydi. - Blokdan katta yozishlar elektr o'chishida yarmi bilan qolishi (torn write) mumkin, buni ishonchli dasturlar alohida hal qiladi.
- Tez dastur: kichik o'qish va yozishlarni birlashtiradi, birga kerak bo'ladigan ma'lumotni yonma-yon saqlaydi va tuzilmalarini blok o'lchamiga moslaydi.
Manbalar: