ការបកប្រែអត្ថបទដែលបានរៀបចំសម្រាប់និស្សិតវគ្គសិក្សា "អ្នកគ្រប់គ្រងលីនុច".

ពីមុនខ្ញុំបាននិយាយអំពីរបៀបសាកល្បង និងបើកដំណើរការ Hugepages នៅលើលីនុច។
អត្ថបទនេះនឹងមានប្រយោជន៍តែប្រសិនបើអ្នកពិតជាមានកន្លែងសម្រាប់ប្រើ Hugepages។ ខ្ញុំបានជួបមនុស្សជាច្រើនដែលចាញ់បោកការរំពឹងទុកថា Hugepages នឹងធ្វើអោយប្រសើរឡើងនូវផលិតភាពដ៏អស្ចារ្យ។ ទោះយ៉ាងណាក៏ដោយ ទំព័រដ៏ធំគឺជាប្រធានបទដ៏ស្មុគស្មាញមួយ ហើយអាចបន្ថយការអនុវត្ត ប្រសិនបើប្រើមិនត្រឹមត្រូវ។

ផ្នែកទី 1៖ ការផ្ទៀងផ្ទាត់ថាទំព័រដ៏ធំត្រូវបានបើកនៅលើលីនុច (ដើម នៅទីនេះ)

បញ្ហា:
អ្នកត្រូវពិនិត្យមើលថាតើ HugePages ត្រូវបានបើកនៅលើប្រព័ន្ធរបស់អ្នក។

ជាដំណោះស្រាយ:
វាសាមញ្ញណាស់៖

cat /sys/kernel/mm/transparent_hugepage/enabled

អ្នកនឹងទទួលបានអ្វីមួយដូចនេះ៖

always [madvise] never

អ្នកនឹងឃើញបញ្ជីជម្រើសដែលមាន (តែងតែ, madvise, មិនដែល) ហើយជម្រើសដែលសកម្មបច្ចុប្បន្ននឹងត្រូវបានរុំព័ទ្ធក្នុងវង់ក្រចក (តាមលំនាំដើម ម៉ាឌីវីស).

ម៉ាឌីវីស មានន័យថា transparent hugepages បានបើកសម្រាប់តែតំបន់អង្គចងចាំដែលស្នើសុំទំព័រធំយ៉ាងច្បាស់លាស់ដោយប្រើ Madvise (2).

តែងតែ មានន័យថា transparent hugepages តែងតែបើកដំណើរការសម្រាប់ដំណើរការទាំងអស់។ វាជាធម្មតាធ្វើអោយប្រសើរឡើងនូវដំណើរការ ប៉ុន្តែប្រសិនបើអ្នកមានករណីប្រើប្រាស់ដែលដំណើរការជាច្រើនកំពុងប្រើប្រាស់អង្គចងចាំតិចតួច នោះការផ្ទុកអង្គចងចាំទាំងមូលអាចកើនឡើងយ៉ាងខ្លាំង។

មិនដែល មានន័យថា transparent hugepages នឹងមិនត្រូវបានរាប់បញ្ចូលសូម្បីតែនៅពេលស្នើសុំដោយប្រើប្រាស់ madvise។ ដើម្បីស្វែងយល់បន្ថែម សូមទាក់ទង ឯកសារ ខឺណែលលីនុច។

របៀបផ្លាស់ប្តូរតម្លៃលំនាំដើម

ជម្រើស 1៖ ផ្លាស់ប្តូរដោយផ្ទាល់ sysfs (បន្ទាប់ពីចាប់ផ្តើមឡើងវិញ ប៉ារ៉ាម៉ែត្រនឹងត្រឡប់ទៅតម្លៃលំនាំដើមរបស់វាវិញ)៖

echo always >/sys/kernel/mm/transparent_hugepage/enabled
echo madvise >/sys/kernel/mm/transparent_hugepage/enabled
echo never >/sys/kernel/mm/transparent_hugepage/enabled

ជម្រើស 2៖ ផ្លាស់ប្តូរលំនាំដើមរបស់ប្រព័ន្ធដោយការចងក្រងខឺណែលឡើងវិញជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធដែលបានកែប្រែ (ជម្រើសនេះត្រូវបានណែនាំតែក្នុងករណីដែលអ្នកកំពុងប្រើខឺណែលផ្ទាល់ខ្លួនប៉ុណ្ណោះ)៖

ដើម្បីកំណត់ជានិច្ចតាមលំនាំដើម សូមប្រើ៖
```
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
# Comment out CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y
```
ដើម្បីកំណត់ madvise ជាលំនាំដើម សូមប្រើ៖
```
CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y
# Comment out CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
```

ផ្នែកទី 2: គុណសម្បត្តិ និងគុណវិបត្តិនៃ HugePages

យើងនឹងព្យាយាមពន្យល់ដោយជ្រើសរើសពីគុណសម្បត្តិ គុណវិបត្តិ និងបញ្ហាដែលអាចកើតមាននៃការប្រើប្រាស់ Hugepages។ ដោយសារអត្ថបទដែលមានលក្ខណៈស្មុគស្មាញខាងបច្ចេកវិជ្ជានិងជាភាសាដើមទំនងជាពិបាកយល់សម្រាប់មនុស្សដែលវង្វេងក្នុងការគិតថាHugepagesគឺជាថ្នាំងងុយគេង ខ្ញុំនឹងលះបង់ភាពត្រឹមត្រូវដើម្បីភាពសាមញ្ញ។ វាគ្រាន់តែមានតម្លៃក្នុងចិត្តថា ប្រធានបទជាច្រើនពិតជាស្មុគ្រស្មាញ ដូច្នេះហើយបានធ្វើឱ្យសាមញ្ញយ៉ាងខ្លាំង។

សូមចំណាំថាយើងកំពុងនិយាយអំពីប្រព័ន្ធ 64 ប៊ីត x86 ដែលដំណើរការលើលីនុច ហើយខ្ញុំគ្រាន់តែសន្មត់ថាប្រព័ន្ធនេះគាំទ្រទំព័រធំដែលមានតម្លាភាព (ព្រោះវាមិនមែនជាគុណវិបត្តិដែលទំព័រធំមិនត្រូវបានសរសេរជាន់លើទេ) ដូចករណីស្ទើរតែគ្រប់លីនុចទំនើបដែរ។ បរិស្ថាន។

ខ្ញុំនឹងភ្ជាប់ការពិពណ៌នាបច្ចេកទេសបន្ថែមទៀតនៅក្នុងតំណភ្ជាប់ខាងក្រោម។

អង្គចងចាំនិម្មិត

ប្រសិនបើអ្នកជាអ្នកសរសេរកម្មវិធី C++ អ្នកដឹងថាវត្ថុក្នុងអង្គចងចាំមានអាសយដ្ឋានជាក់លាក់ (តម្លៃទ្រនិច)។

ទោះយ៉ាងណាក៏ដោយ អាសយដ្ឋានទាំងនេះមិនចាំបាច់ឆ្លុះបញ្ចាំងពីអាសយដ្ឋានជាក់ស្តែងនៅក្នុងអង្គចងចាំ (អាសយដ្ឋាន RAM) នោះទេ។ ពួកគេតំណាងឱ្យអាសយដ្ឋាននៅក្នុងសតិនិម្មិត។ ខួរក្បាលមានម៉ូឌុល MMU ពិសេស (អង្គភាពគ្រប់គ្រងអង្គចងចាំ) ដែលជួយខឺណែលធ្វើផែនទីអង្គចងចាំនិម្មិតទៅទីតាំងជាក់ស្តែង។

វិធីសាស្រ្តនេះមានអត្ថប្រយោជន៍ជាច្រើន ប៉ុន្តែអ្វីដែលសំខាន់បំផុតនោះគឺ៖

ការអនុវត្ត (សម្រាប់ហេតុផលផ្សេងៗ);
ភាពឯកោកម្មវិធី មានន័យថា គ្មានកម្មវិធីណាអាចអានពីសតិនៃកម្មវិធីផ្សេងបានទេ។

តើទំព័រអ្វីខ្លះ?

អង្គចងចាំនិម្មិតត្រូវបានបែងចែកទៅជាទំព័រ។ ទំព័រនីមួយៗចង្អុលទៅអង្គចងចាំជាក់ស្តែង វាអាចចង្អុលទៅតំបន់មួយនៅក្នុង RAM ឬវាអាចចង្អុលទៅអាសយដ្ឋានដែលបានកំណត់ទៅឧបករណ៍ជាក់ស្តែង ដូចជាកាតវីដេអូជាដើម។

ភាគច្រើននៃទំព័រដែលអ្នកដោះស្រាយជាមួយនឹងចំនុចមួយទៅកាន់ RAM ឬត្រូវបានប្តូរ មានន័យថាពួកវាត្រូវបានរក្សាទុកនៅលើ hard drive ឬ SSD របស់អ្នក។ ខឺណែលគ្រប់គ្រងប្លង់រូបវន្តនៃទំព័រនីមួយៗ។ ប្រសិនបើទំព័រក្លែងបន្លំត្រូវបានចូលប្រើ ខឺណែលបញ្ឈប់ខ្សែស្រឡាយដែលកំពុងព្យាយាមចូលប្រើអង្គចងចាំ អានទំព័រពីថាសរឹង/SSD ទៅក្នុង RAM ហើយបន្ទាប់មកបន្តដំណើរការខ្សែស្រឡាយ។

ដំណើរការនេះមានតម្លាភាព មានន័យថាវាមិនចាំបាច់អានដោយផ្ទាល់ពី HDD/SSD ទេ។ ទំហំនៃទំព័រធម្មតាគឺ 4096 បៃ។ ទំហំទំព័រដ៏ធំគឺ 2 មេកាបៃ។

Translation-associative buffer (TLB)

នៅពេលដែលកម្មវិធីចូលប្រើទំព័រនៃអង្គចងចាំ CPU ត្រូវតែដឹងថាទំព័ររូបវន្តណាមួយដែលត្រូវអានទិន្នន័យពី (នោះគឺមានផែនទីអាសយដ្ឋាននិម្មិត)។

ខឺណែលមានរចនាសម្ព័ន្ធទិន្នន័យ (តារាងទំព័រ) ដែលមានព័ត៌មានទាំងអស់អំពីទំព័រដែលកំពុងប្រើ។ ដោយប្រើរចនាសម្ព័ន្ធទិន្នន័យនេះ អ្នកអាចផ្គូផ្គងអាសយដ្ឋាននិម្មិតទៅអាសយដ្ឋានរូបវន្ត។

ទោះជាយ៉ាងណាក៏ដោយ តារាងទំព័រគឺស្មុគស្មាញ និងយឺត ដូច្នេះយើងមិនអាចវិភាគរចនាសម្ព័ន្ធទិន្នន័យទាំងមូលបានទេ រាល់ពេលដែលដំណើរការណាមួយចូលប្រើអង្គចងចាំ។

ជាសំណាងល្អ ខួរក្បាលរបស់យើងមាន TLB ដែលរក្សាទុកការគូសផែនទីរវាងអាសយដ្ឋាននិម្មិត និងរូបវន្ត។ នេះមានន័យថា ទោះបីជាយើងត្រូវញែកតារាងទំព័រនៅលើការប៉ុនប៉ងចូលប្រើលើកដំបូងក៏ដោយ ការចូលប្រើជាបន្តបន្ទាប់ទាំងអស់ទៅកាន់ទំព័រអាចត្រូវបានគ្រប់គ្រងនៅក្នុង TLB ដែលអនុញ្ញាតឱ្យមានប្រតិបត្តិការលឿន។

ដោយសារតែវាត្រូវបានអនុវត្តជាឧបករណ៍រាងកាយ (ដែលធ្វើឱ្យវាលឿននៅក្នុងកន្លែងដំបូង) សមត្ថភាពរបស់វាត្រូវបានកំណត់។ ដូច្នេះប្រសិនបើអ្នកចង់ចូលប្រើទំព័របន្ថែមទៀត TLB នឹងមិនអាចរក្សាទុកផែនទីសម្រាប់ពួកវាទាំងអស់បានទេ ដែលបណ្តាលឱ្យកម្មវិធីរបស់អ្នកដំណើរការយឺតជាង។

ទំព័រដ៏ធំមកជួយសង្គ្រោះ

ដូច្នេះ តើយើងអាចធ្វើយ៉ាងណាដើម្បីជៀសវាងការហៀររបស់ TLB? (យើងសន្មត់ថាកម្មវិធីនៅតែត្រូវការចំនួនអង្គចងចាំដដែល)។

នេះគឺជាកន្លែងដែល Hugepages ចូលមក។ ជំនួសឱ្យ 4096 បៃដែលទាមទារធាតុ TLB មួយ ធាតុ TLB មួយឥឡូវនេះអាចចង្អុលទៅ 2 មេកាបៃ។ ឧបមាថា TLB មានធាតុ 512 នៅទីនេះដោយគ្មាន Hugepages យើងអាចផ្គូផ្គងបាន៖

4096 b⋅512=2 MB

ដូច្នេះតើយើងអាចប្រៀបធៀបជាមួយពួកគេដោយរបៀបណា៖

2 MB⋅512=1 GB

នេះជាមូលហេតុដែល Hugepages អស្ចារ្យ។ ពួកគេអាចបង្កើនផលិតភាពដោយមិនចាំបាច់ប្រឹងប្រែងច្រើន។ ប៉ុន្តែមានការព្រមានសំខាន់ៗនៅទីនេះ។

ការក្លែងបន្លំទំព័រដ៏ធំ

ខឺណែលត្រួតពិនិត្យដោយស្វ័យប្រវត្តិអំពីចំនួនទំព័រអង្គចងចាំនីមួយៗត្រូវបានប្រើ។ ប្រសិនបើមិនមានអង្គចងចាំរូបវ័ន្តគ្រប់គ្រាន់ (RAM) ខឺណែលនឹងផ្លាស់ទីទំព័រដែលមិនសូវសំខាន់ (មិនសូវប្រើញឹកញាប់) ទៅកាន់ថាសរឹង ដើម្បីរំដោះ RAM មួយចំនួនសម្រាប់ទំព័រសំខាន់ៗបន្ថែមទៀត។
ជាគោលការណ៍ ដូចគ្នានេះដែរអនុវត្តចំពោះទំព័រធំ។ ទោះយ៉ាងណាក៏ដោយ ខឺណែលអាចប្តូរបានតែទំព័រទាំងមូល មិនមែនបៃនីមួយៗទេ។

ឧបមាថាយើងមានកម្មវិធីដូចនេះ៖

char* mymemory = malloc(2*1024*1024); // Возьмем это за одну Hugepage!
// Заполним mymemory какими-либо данными
// Сделаем много других вещей,
// которые приведут к подмене страницы mymemory
// ...
// Запросим доступ только к первому байту
putchar(mymemory[0]);

ក្នុងករណីនេះ ខឺណែលនឹងត្រូវការជំនួស (អាន) ច្រើនដូចជា 2 មេកាបៃនៃព័ត៌មានពី hard drive/SSD សម្រាប់តែអ្នកអានមួយបៃ។ សម្រាប់ទំព័រធម្មតា មានតែ 4096 បៃប៉ុណ្ណោះដែលត្រូវអានពី hard drive/SSD ។

ដូច្នេះ ប្រសិនបើទំព័រធំត្រូវបានបដិសេធ វាកាន់តែលឿនក្នុងការអាន ប្រសិនបើអ្នកត្រូវការចូលទៅកាន់ទំព័រទាំងមូល។ នេះមានន័យថា ប្រសិនបើអ្នកកំពុងព្យាយាមចូលប្រើផ្នែកផ្សេងៗនៃអង្គចងចាំដោយចៃដន្យ ហើយគ្រាន់តែអានពីរបីគីឡូបៃ អ្នកគួរតែប្រើទំព័រធម្មតា ហើយកុំបារម្ភអំពីអ្វីផ្សេងទៀត។

ម្យ៉ាងវិញទៀត ប្រសិនបើអ្នកត្រូវការចូលទៅកាន់ផ្នែកធំនៃអង្គចងចាំជាបន្តបន្ទាប់ ទំព័រដ៏ធំនឹងធ្វើអោយដំណើរការរបស់អ្នកប្រសើរឡើង។ ទោះយ៉ាងណាក៏ដោយ អ្នកត្រូវសាកល្បងវាដោយខ្លួនឯង (មិនមែនជាមួយកម្មវិធី abstract) ហើយមើលថាអ្វីដែលដំណើរការលឿនជាងមុន។

ការបែងចែកនៅក្នុងការចងចាំ

ប្រសិនបើអ្នកសរសេរ C អ្នកដឹងថាអ្នកអាចស្នើសុំបរិមាណអង្គចងចាំតូច (ឬស្ទើរតែច្រើនតាមអំពើចិត្ត) ពី heap ដោយប្រើ malloc(). ឧបមាថាអ្នកត្រូវការអង្គចងចាំ 30 បៃ៖

char* mymemory = malloc(30);

ចំពោះអ្នកសរសេរកម្មវិធី វាអាចបង្ហាញថាអ្នកកំពុង "ស្នើសុំ" អង្គចងចាំ 30 បៃពីប្រព័ន្ធប្រតិបត្តិការ ហើយត្រឡប់ទ្រនិចទៅអង្គចងចាំនិម្មិតមួយចំនួន។ ប៉ុន្តែតាមពិត malloc () គ្រាន់តែជាមុខងារ C ដែលហៅចេញពីក្នុងមុខងារ brk និង sbrk ដើម្បីស្នើសុំ ឬដោះលែងអង្គចងចាំពីប្រព័ន្ធប្រតិបត្តិការ។

ទោះជាយ៉ាងណាក៏ដោយ ការស្នើសុំអង្គចងចាំកាន់តែច្រើនឡើងៗសម្រាប់ការបែងចែកនីមួយៗគឺមិនមានប្រសិទ្ធភាពទេ។ វាទំនងជាថាផ្នែកអង្គចងចាំមួយចំនួនត្រូវបានដោះលែងរួចហើយ (free())ហើយយើងអាចប្រើវាឡើងវិញបាន។ malloc() អនុវត្តក្បួនដោះស្រាយដ៏ស្មុគស្មាញសម្រាប់ការប្រើប្រាស់អង្គចងចាំដែលបានដោះលែងឡើងវិញ

ក្នុងពេលជាមួយគ្នានេះ អ្វីៗកើតឡើងដោយមិនបានកត់សម្គាល់សម្រាប់អ្នក ដូច្នេះហេតុអ្វីបានជាវាគួរព្រួយបារម្ភដល់អ្នក? ប៉ុន្តែដោយសារតែបញ្ហាប្រឈម free() មិនមានន័យនោះទេ។ អង្គចងចាំចាំបាច់ត្រូវបានត្រឡប់ភ្លាមៗទៅប្រព័ន្ធប្រតិបត្តិការ.

មានរឿងដូចជាការបែងចែកការចងចាំ។ ក្នុងករណីធ្ងន់ធ្ងរ មានផ្នែក heap ដែលប្រើតែប៉ុន្មានបៃប៉ុណ្ណោះ ខណៈពេលដែលអ្វីៗទាំងអស់នៅចន្លោះត្រូវបានដោះលែង (free()).

សូមចំណាំថាការបែងចែកអង្គចងចាំគឺជាប្រធានបទដ៏ស្មុគស្មាញមួយ ហើយសូម្បីតែការផ្លាស់ប្តូរបន្តិចបន្តួចចំពោះកម្មវិធីក៏អាចមានផលប៉ះពាល់យ៉ាងខ្លាំងផងដែរ។ ក្នុងករណីភាគច្រើន កម្មវិធីនឹងមិនបណ្តាលឱ្យមានការបែកខ្ញែកនៃការចងចាំដ៏សំខាន់នោះទេ ប៉ុន្តែអ្នកគួរតែដឹងថា ប្រសិនបើមានបញ្ហាជាមួយនឹងការបែកខ្ញែកនៅក្នុងតំបន់មួយចំនួន នោះទំព័រដ៏ធំអាចធ្វើឱ្យស្ថានភាពកាន់តែធ្ងន់ធ្ងរ។

ការជ្រើសរើសនៃទំព័រដ៏ធំ

បន្ទាប់ពីអានអត្ថបទនេះ អ្នកបានកំណត់ថាតើផ្នែកណាមួយនៃកម្មវិធីរបស់អ្នកអាចទទួលបានអត្ថប្រយោជន៍ពីការប្រើប្រាស់ទំព័រដ៏ធំ និងមួយណាមិនអាច។ ដូច្នេះ តើទំព័រធំគួរត្រូវបានបើកទាំងអស់ឬ?

សំណាងល្អអ្នកអាចប្រើបាន។ madvise()ដើម្បីបើកទំព័រដ៏ធំសម្រាប់តែតំបន់អង្គចងចាំទាំងនោះ ដែលវានឹងមានប្រយោជន៍។

ជាដំបូង សូមពិនិត្យមើលថាគេហទំព័រដ៏ធំកំពុងដំណើរការក្នុងរបៀប madvise() ដោយប្រើ ការណែនាំ នៅដើមអត្ថបទ។

បន្ទាប់មកប្រើ madvise()ដើម្បីប្រាប់ខឺណែលឱ្យច្បាស់កន្លែងដែលត្រូវប្រើទំព័រធំ។

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

ចំណាំថាវិធីសាស្ត្រនេះគ្រាន់តែជាដំបូន្មានដល់ខឺណែលអំពីរបៀបគ្រប់គ្រងអង្គចងចាំប៉ុណ្ណោះ។ នេះមិនមានន័យថាខឺណែលនឹងប្រើទំព័រដ៏ធំដោយស្វ័យប្រវត្តិសម្រាប់អង្គចងចាំដែលបានផ្តល់ឱ្យនោះទេ។

យោងទៅឯកសារ (manpage)madviseដើម្បីស្វែងយល់បន្ថែមអំពីការគ្រប់គ្រងការចងចាំ និង madvise()ប្រធានបទនេះមានខ្សែកោងការរៀនសូត្រដ៏ចោតមិនគួរឱ្យជឿ។ ដូច្នេះប្រសិនបើអ្នកមានបំណងចង់ទទួលបានវាពិតប្រាកដ សូមត្រៀមខ្លួនដើម្បីអាន និងសាកល្បងពីរបីសប្តាហ៍មុនពេលអ្នករំពឹងថានឹងមានលទ្ធផលវិជ្ជមានណាមួយ។

តើត្រូវអានអ្វី?

មានសំណួរទេ? សរសេរនៅក្នុងមតិយោបល់!

ប្រភព: www.habr.com

គុណសម្បត្តិ និងគុណវិបត្តិនៃទំព័រ HugePages