Terjemahan artikel sing disiapake kanggo siswa kursus .
Sadurunge aku wis ngomong babagan carane mriksa lan ngaktifake panggunaan Hugepages ing Linux.
Artikel iki mung bakal migunani yen sampeyan duwe panggonan kanggo nggunakake Hugepages. Aku wis ketemu akeh wong sing diapusi dening prospek sing Hugepages gaib bakal nambah produktivitas. Nanging, hugepaging minangka topik sing rumit lan bisa nyuda kinerja yen digunakake kanthi ora bener.
Bagean 1: Priksa manawa hugepages wis diaktifake Linux (asli )
Masalah:
Sampeyan kudu mriksa manawa HugePages diaktifake ing sistem sampeyan.
solusi:
Iku cukup prasaja:
cat /sys/kernel/mm/transparent_hugepage/enabledSampeyan bakal entuk kaya iki:
always [madvise] neverSampeyan bakal weruh dhaptar pilihan sing kasedhiya (tansah, madvise, tau), lan pilihan sing saiki aktif bakal dilampirake ing kurung (kanthi standar madvise).
madvise tegese transparent hugepages diaktifake mung kanggo wilayah memori sing kanthi tegas njaluk hugepages nggunakake .
tansah tegese transparent hugepages tansah aktif kanggo kabeh pangolahan. Iki biasane mbenakake kinerja, nanging yen sampeyan duwe kasus nggunakake ngendi akeh pangolahan nggunakake jumlah cilik saka memori, banjur beban memori sakabèhé bisa nambah dramatically.
tau tegese transparent hugepages ora bakal kalebu sanajan dijaluk nggunakake madvise. Kanggo ngerteni luwih akeh, hubungi kernel Linux.
Carane ngganti nilai standar
Opsi 1: Langsung ganti sysfs (sawise urip maneh parameter bakal bali menyang nilai standar):
echo always >/sys/kernel/mm/transparent_hugepage/enabled
echo madvise >/sys/kernel/mm/transparent_hugepage/enabled
echo never >/sys/kernel/mm/transparent_hugepage/enabledOpsi 2: Ngganti standar sistem kanthi ngumpulake maneh kernel kanthi konfigurasi sing diowahi (opsi iki mung dianjurake yen sampeyan nggunakake kernel khusus):
- Kanggo nyetel tansah kanthi gawan, gunakake:
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y # Comment out CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y - Kanggo nyetel madvise minangka standar, gunakake:
CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y # Comment out CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
Part 2: Kaluwihan lan Kekurangan HugePages
Kita bakal nyoba kanggo selektif nerangake kaluwihan, cacat lan pitfalls bisa nggunakake Hugepages. Amarga artikel teknologi sing rumit lan pedantic bakal angel dimangerteni kanggo wong sing kesasar mikir yen Hugepages minangka panacea, aku bakal ngorbanake akurasi kanggo kesederhanaan. Sampeyan mung kudu eling yen akeh topik sing rumit banget lan mulane disederhanakake.
Elinga yen kita lagi ngomong babagan sistem x86 64-bit sing mlaku ing Linux, lan aku mung nganggep yen sistem kasebut ndhukung hugepages transparan (amarga ora dadi kerugian yen hugepages ora diganti), kaya sing kedadeyan ing meh kabeh lingkungan modern. Linux.
Aku bakal masang katrangan luwih teknis ing pranala ing ngisor iki.
Memori virtual
Yen sampeyan programmer C ++, sampeyan ngerti yen obyek ing memori duwe alamat tartamtu (nilai pointer).
Nanging, alamat kasebut ora kudu nggambarake alamat fisik ing memori (alamat RAM). Padha makili alamat ing memori virtual. Prosesor duwe modul MMU (unit manajemen memori) khusus sing mbantu kernel map memori virtual menyang lokasi fisik.
Pendekatan iki nduweni akeh kaluwihan, nanging sing paling penting yaiku:
- Kinerja (kanggo macem-macem alasan);
- Isolasi program, yaiku, ora ana program sing bisa maca saka memori program liyane.
Apa iku kaca?
Memori virtual dipérang dadi kaca. Saben kaca individu nunjuk menyang memori fisik tartamtu, bisa nuding menyang area ing RAM, utawa bisa nuding menyang alamat sing ditugasake menyang piranti fisik, kayata kertu video.
Umume kaca sing sampeyan tindakake karo salah siji titik menyang RAM utawa diganti, tegese padha disimpen ing hard drive utawa SSD. Kernel ngatur tata letak fisik saben kaca. Yen kaca spoofed diakses, kernel mungkasi thread sing nyoba kanggo ngakses memori, maca kaca saka hard drive / SSD menyang RAM, banjur terus nglakokaké thread.
Proses iki stream transparent, tegese iku ora kudu maca langsung saka HDD / SSD. Ukuran kaca normal yaiku 4096 bita. Ukuran Hugpages yaiku 2 megabyte.
Buffer asosiatif terjemahan (TLB)
Nalika program ngakses kaca memori, CPU kudu ngerti saka kaca fisik kanggo maca data (yaiku, duwe peta alamat virtual).
Kernel nduweni struktur data (tabel kaca) sing ngemot kabeh informasi babagan kaca sing digunakake. Nggunakake struktur data iki, sampeyan bisa map alamat virtual menyang alamat fisik.
Nanging, tabel kaca cukup rumit lan alon, mula kita ora bisa nganalisa kabeh struktur data saben proses ngakses memori.
Untunge, prosesor kita duwe TLB sing nyimpen pemetaan ing antarane alamat virtual lan fisik. Iki tegese sanajan kita kudu ngurai tabel kaca ing upaya akses pisanan, kabeh akses sakteruse menyang kaca bisa ditangani ing TLB, ngidini kanggo operasi cepet.
Amarga wis dileksanakake minangka piranti fisik (sing ndadekake cepet ing Panggonan pisanan), kapasitas winates. Dadi yen sampeyan pengin ngakses luwih akeh kaca, TLB ora bakal bisa nyimpen pemetaan kanggo kabeh, nyebabake program sampeyan mlaku luwih alon.
Hugpages teka kanggo ngluwari
Dadi, apa sing bisa ditindakake kanggo ngindhari kebanjiran TLB? (We nganggep program isih perlu jumlah memori sing padha).
Iki ngendi Hugpages mlebu. Tinimbang 4096 bita sing mbutuhake mung siji entri TLB, siji entri TLB saiki bisa nuding 2 megabyte. Ayo nganggep TLB duwe 512 entri, ing kene tanpa Hugpages kita bisa cocog:
4096 b⋅512=2 MBBanjur kepiye kita bisa mbandhingake karo dheweke:
2 MB⋅512=1 GBMulane Hugepages apik tenan. Padha bisa nambah produktivitas tanpa akeh gaweyan. Nanging ana caveats penting ing kene.
Hugpages spoofing
Kernel kanthi otomatis ngawasi sepira kerepe saben kaca memori digunakake. Yen ora cukup memori fisik (RAM), kernel bakal mindhah kaca sing kurang penting (kurang kerep digunakake) menyang hard disk kanggo mbebasake sawetara RAM kanggo kaca sing luwih penting.
Ing asas, padha ditrapake kanggo Hugepages. Nanging, kernel mung bisa ngganti kabeh kaca, dudu bait individu.
Ayo kita duwe program kaya iki:
char* mymemory = malloc(2*1024*1024); // Возьмем это за одну Hugepage!
// Заполним mymemory какими-либо данными
// Сделаем много других вещей,
// которые приведут к подмене страницы mymemory
// ...
// Запросим доступ только к первому байту
putchar(mymemory[0]); Ing kasus iki, kernel kudu ngganti (maca) minangka akeh minangka 2 megabyte informasi saka hard drive / SSD mung kanggo maca siji bait. Kanggo kaca biasa, mung 4096 bita sing kudu diwaca saka hard drive / SSD.
Mulane, yen hugepage ditimpa, mung luwih cepet maca yen sampeyan kudu ngakses kabeh kaca. Iki tegese yen sampeyan nyoba ngakses macem-macem bagean memori kanthi acak lan mung maca sawetara kilobyte, sampeyan kudu nggunakake kaca biasa lan ora sumelang ing bab liya.
Ing tangan liyane, yen sampeyan kudu ngakses bagean gedhe saka memori sequentially, largepages bakal nambah kinerja. Nanging, sampeyan kudu nyoba dhewe (ora nganggo piranti lunak abstrak) lan ndeleng apa sing luwih cepet.
Alokasi ing memori
Yen sampeyan nulis C, sampeyan ngerti yen sampeyan bisa njaluk jumlah memori sing cilik (utawa meh sewenang-wenang) saka tumpukan nggunakake malloc(). Contone, sampeyan butuh memori 30 bita:
char* mymemory = malloc(30);Kanggo programmer, bisa uga katon yen sampeyan "njaluk" 30 bait memori saka sistem operasi lan bali pitunjuk kanggo sawetara memori virtual. Nanging nyatane malloc () iku mung fungsi C sing nelpon saka ing fungsi kanggo njaluk utawa mbebasake memori saka sistem operasi.
Nanging, njaluk memori liyane lan liyane kanggo saben alokasi ora efisien; iku paling kamungkinan sing sawetara bagean memori wis dibebaske (free()), lan kita bisa nggunakake maneh. malloc() ngleksanakake algoritma cukup Komplek kanggo nggunakake maneh memori dibebaske.
Ing wektu sing padha, kabeh kedadeyan sing ora dingerteni kanggo sampeyan, mula kenapa sampeyan kudu kuwatir? Nanging amarga tantangan free() ora ateges .
Ana bab kayata fragmentasi memori. Ing kasus sing ekstrem, ana segmen tumpukan sing mung sawetara bait sing digunakake, dene kabeh sing ana ing antarane wis dibebasake. (free()).
Wigati dimangerteni manawa fragmentasi memori minangka topik sing rumit banget, lan owah-owahan cilik ing program bisa duwe pengaruh sing signifikan. Umume kasus, program ora bakal nyebabake fragmentasi memori sing signifikan, nanging sampeyan kudu ngerti yen ana masalah karo fragmentasi ing sawetara area tumpukan, kaca gedhe bisa nggawe kahanan luwih elek.
Panganggone kaca gedhe kanthi selektif
Sawise maca artikel iki, sampeyan wis nemtokake bagean saka program sampeyan bisa entuk manfaat saka nggunakake kaca gedhe lan sing ora bisa. Dadi apa kaca gedhe kudu diaktifake?
Untunge sampeyan bisa nggunakake madvise()kanggo ngaktifake hugepaging mung kanggo wilayah memori sing bakal migunani.
Pisanan, priksa manawa hugepages mlaku ing mode madvise () nggunakake ing wiwitan artikel.
Banjur, gunakake madvise()kanggo ngandhani kernel persis ing ngendi nggunakake hugepages.
#include <sys/mman.h>
// Аллоцируйте большое количество памяти, которую будете использовать
size_t size = 256*1024*1024;
char* mymemory = malloc(size);
// Просто включите hugepages…
madvise(mymemory, size, MADV_HUGEPAGE);
// … и задайте следующее
madvise(mymemory, size, MADV_HUGEPAGE | MADV_SEQUENTIAL)Elinga yen cara iki mung saran kanggo kernel babagan carane ngatur memori. Iki ora ateges kernel bakal kanthi otomatis nggunakake kaca gedhe kanggo memori tartamtu.
Deleng dokumentasi kanggo mangerteni sing luwih lengkap babagan manajemen memori lan madvise(), topik iki duwe kurva learning luar biasa tajem. Dadi yen sampeyan pengin dadi apik, siyap maca lan nyoba sawetara minggu sadurunge ngarepake asil sing positif.
Apa sing kudu diwaca?
Duwe pitakonan? Tulis ing komentar!
Source: www.habr.com
