លួច៖ អ្នកណាលួចពេលវេលាស៊ីភីយូពីម៉ាស៊ីននិម្មិត

សួស្តី! ខ្ញុំចង់ប្រាប់អ្នកដោយពាក្យសាមញ្ញអំពីមេកានិចនៃការលួចនៅក្នុងម៉ាស៊ីននិម្មិត និងអំពីវត្ថុបុរាណដែលមិនច្បាស់លាស់មួយចំនួនដែលយើងអាចរកឃើញក្នុងអំឡុងពេលនៃការស្រាវជ្រាវរបស់វា ដែលខ្ញុំត្រូវចូលជានាយកបច្ចេកទេសនៃវេទិកាពពក។ ដំណោះស្រាយពពក Mail.ru. វេទិកាដំណើរការលើ KVM ។

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

1. តើអ្វីទៅជាការលួច

ដូច្នេះ ការលួចគឺជាម៉ែត្រដែលបង្ហាញពីកង្វះពេលវេលាដំណើរការសម្រាប់ដំណើរការនៅក្នុងម៉ាស៊ីននិម្មិត។ ដូចដែលបានពិពណ៌នា នៅក្នុងបំណះខឺណែល KVMលាក់លៀមគឺជាពេលវេលាដែល hypervisor កំពុងដំណើរការដំណើរការផ្សេងទៀតនៅលើ host OS ទោះបីជាវាបានតម្រង់ជួរដំណើរការម៉ាស៊ីននិម្មិតសម្រាប់ការប្រតិបត្តិក៏ដោយ។ នោះគឺការលួចត្រូវបានគណនាជាភាពខុសគ្នារវាងពេលវេលាដែលដំណើរការរួចរាល់ដើម្បីប្រតិបត្តិ និងពេលវេលាដែលដំណើរការត្រូវបានបែងចែកពេលវេលាដំណើរការ។

ខឺណែលរបស់ម៉ាស៊ីននិម្មិត ទទួលបានម៉ែត្រការលួចពី hypervisor ។ ក្នុងពេលជាមួយគ្នានេះ អ្នកត្រួតពិនិត្យខ្ពស់មិនបានបញ្ជាក់ច្បាស់អំពីដំណើរការផ្សេងទៀតដែលវាកំពុងដំណើរការនោះទេ វាគ្រាន់តែនិយាយថា "ខណៈពេលដែលខ្ញុំរវល់ ខ្ញុំមិនអាចផ្តល់ពេលវេលាឱ្យអ្នកបានទេ។" នៅលើ KVM ការគាំទ្រសម្រាប់ការគណនាលួចត្រូវបានបន្ថែមទៅ បំណះ. មានចំណុចសំខាន់ពីរនៅទីនេះ៖

• ម៉ាស៊ីននិម្មិតរៀនអំពីការលួចពី hypervisor ។ នោះគឺតាមទស្សនៈនៃការបាត់បង់សម្រាប់ដំណើរការនៅលើម៉ាស៊ីននិម្មិតខ្លួនវាគឺជាការវាស់វែងដោយប្រយោលដែលអាចទទួលរងការបង្ខូចទ្រង់ទ្រាយផ្សេងៗ។
• Hypervisor មិនចែករំលែកព័ត៌មានជាមួយម៉ាស៊ីននិម្មិតអំពីអ្វីផ្សេងទៀតដែលវាកំពុងធ្វើនោះទេ - រឿងសំខាន់គឺថាវាមិនលះបង់ពេលវេលាសម្រាប់វា។ ដោយសារតែនេះ ម៉ាស៊ីននិម្មិតខ្លួនឯងមិនអាចរកឃើញការបង្ខូចទ្រង់ទ្រាយនៅក្នុងសូចនាករលួច ដែលអាចត្រូវបានវាយតម្លៃដោយធម្មជាតិនៃដំណើរការប្រកួតប្រជែង។

2. អ្វីដែលប៉ះពាល់ដល់ការលួច

២.១. ការគណនាការលួច

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

• ខួរក្បាលឡើងកំដៅខ្លាំង ដែលបណ្តាលឱ្យវដ្តមិនដំណើរការ។
• បើក/បិទដំណើរការ turbo boost ដែលផ្លាស់ប្តូរប្រេកង់នាឡិកាខួរក្បាល។
• ការផ្លាស់ប្តូររយៈពេលនៃពេលវេលាដែលកើតឡើងនៅពេលប្រើបច្ចេកវិទ្យាសន្សំថាមពលរបស់ខួរក្បាលដូចជា SpeedStep ។
• បញ្ហាក្នុងការគណនាជាមធ្យម៖ ការប៉ាន់ប្រមាណការប្រើប្រាស់មួយនាទីនៅ 80% អាចលាក់ការផ្ទុះរយៈពេលខ្លី 100%។
• ការចាក់សោរបង្វិលធ្វើឱ្យខួរក្បាលត្រូវបានទាមទារមកវិញ ប៉ុន្តែដំណើរការរបស់អ្នកប្រើមិនឃើញមានវឌ្ឍនភាពក្នុងការប្រតិបត្តិរបស់វាទេ។ ជាលទ្ធផល ការប្រើប្រាស់ខួរក្បាលដែលបានគណនាដោយដំណើរការនេះនឹងមានមួយរយភាគរយ ទោះបីជាដំណើរការនេះនឹងមិនប្រើប្រាស់ពេលវេលាដំណើរការក៏ដោយ។

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

ដំណើរការរាប់ការលួចគឺមានបញ្ហាដូចគ្នាទៅនឹងការរាប់ការកែឆ្នៃធម្មតាដែរ។ មិន​មែន​និយាយ​ថា​បញ្ហា​បែប​នេះ​តែង​កើត​ឡើង​ជា​ញឹក​ញាប់​ទេ ប៉ុន្តែ​មើល​ទៅ​មាន​ការ​ធ្លាក់​ទឹក​ចិត្ត។

២.២. ប្រភេទនៃនិម្មិតនៅលើ KVM

និយាយឱ្យទូលំទូលាយ មាននិម្មិតបីប្រភេទ ដែលទាំងអស់នេះត្រូវបានគាំទ្រដោយ KVM ។ យន្តការនៃការលួចកើតឡើងអាចអាស្រ័យលើប្រភេទនៃនិម្មិត។

ផ្សាយ. ក្នុងករណីនេះ ប្រតិបត្តិការនៃប្រព័ន្ធប្រតិបត្តិការម៉ាស៊ីននិម្មិតជាមួយឧបករណ៍ hypervisor រាងកាយកើតឡើងដូចនេះ៖

1. ប្រព័ន្ធប្រតិបត្តិការភ្ញៀវផ្ញើពាក្យបញ្ជាទៅឧបករណ៍ភ្ញៀវរបស់វា។
2. កម្មវិធីបញ្ជាឧបករណ៍ភ្ញៀវទទួលបានពាក្យបញ្ជា បង្កើតសំណើសម្រាប់ BIOS ឧបករណ៍ ហើយផ្ញើវាទៅអ្នកត្រួតពិនិត្យ។
3. ដំណើរការ hypervisor បកប្រែពាក្យបញ្ជាទៅពាក្យបញ្ជាសម្រាប់ឧបករណ៍រូបវន្ត ដែលធ្វើឱ្យវា ក្នុងចំណោមរបស់ផ្សេងទៀតមានសុវត្ថិភាពជាងមុន។
4. កម្មវិធីបញ្ជាឧបករណ៍រូបវន្តទទួលយកពាក្យបញ្ជាដែលបានកែប្រែ ហើយបញ្ជូនវាទៅឧបករណ៍រូបវន្តខ្លួនឯង។
5. លទ្ធផល​នៃ​ការ​ប្រតិបត្តិ​ពាក្យ​បញ្ជា​ត្រឡប់​ទៅ​តាម​ផ្លូវ​ដដែល។

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

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

Paravirtualization. ជម្រើសទូទៅបំផុតសម្រាប់និម្មិតឧបករណ៍នៅលើ KVM និងជាទូទៅរបៀបនិម្មិតទូទៅបំផុតសម្រាប់ប្រព័ន្ធប្រតិបត្តិការភ្ញៀវ។ ភាពពិសេសរបស់វាគឺថាធ្វើការជាមួយប្រព័ន្ធរង hypervisor មួយចំនួន (ឧទាហរណ៍ជាមួយបណ្តាញ ឬថាសជង់) ឬការបែងចែកទំព័រអង្គចងចាំកើតឡើងដោយប្រើ hypervisor API ដោយមិនបកប្រែពាក្យបញ្ជាកម្រិតទាប។ គុណវិបត្តិនៃវិធីសាស្ត្រនិម្មិតនេះគឺថា ខឺណែលប្រព័ន្ធប្រតិបត្តិការភ្ញៀវត្រូវតែត្រូវបានកែប្រែ ដូច្នេះវាអាចទាក់ទងជាមួយ hypervisor ដោយប្រើ API នេះ។ ប៉ុន្តែជាធម្មតាវាត្រូវបានដោះស្រាយដោយការដំឡើងកម្មវិធីបញ្ជាពិសេសនៅលើប្រព័ន្ធប្រតិបត្តិការភ្ញៀវ។ នៅក្នុង KVM API នេះត្រូវបានគេហៅថា virtio API.

ជាមួយនឹង paravirtualization បើប្រៀបធៀបទៅនឹងការផ្សាយ ផ្លូវទៅកាន់ឧបករណ៍រូបវន្តត្រូវបានកាត់បន្ថយយ៉ាងខ្លាំងដោយការផ្ញើពាក្យបញ្ជាដោយផ្ទាល់ពីម៉ាស៊ីននិម្មិតទៅកាន់ដំណើរការ hypervisor នៅលើម៉ាស៊ីន។ វាអនុញ្ញាតឱ្យអ្នកបង្កើនល្បឿនការប្រតិបត្តិនៃការណែនាំទាំងអស់នៅក្នុងម៉ាស៊ីននិម្មិត។ នៅក្នុង KVM នេះត្រូវបានធ្វើដោយ virtio API ដែលដំណើរការសម្រាប់តែឧបករណ៍មួយចំនួន ដូចជាបណ្តាញ ឬអាដាប់ទ័រថាស។ នេះជាមូលហេតុដែលកម្មវិធីបញ្ជា virtio ត្រូវបានដំឡើងនៅខាងក្នុងម៉ាស៊ីននិម្មិត។

គុណវិបត្តិនៃការបង្កើនល្បឿននេះគឺថាមិនមែនដំណើរការទាំងអស់ដែលដំណើរការនៅក្នុងម៉ាស៊ីននិម្មិតនៅតែមាននៅក្នុងវានោះទេ។ នេះបង្កើតឥទ្ធិពលពិសេសមួយចំនួនដែលអាចបណ្តាលឱ្យមានពងនៅលើការលួច។ ខ្ញុំសូមផ្តល់អនុសាសន៍ឱ្យចាប់ផ្តើមការសិក្សាលម្អិតនៃបញ្ហានេះជាមួយ API សម្រាប់ I/O និម្មិត៖ virtio.

២.៣. កាលវិភាគ "យុត្តិធម៌"

តាមពិតម៉ាស៊ីននិម្មិតនៅលើ hypervisor គឺជាដំណើរការធម្មតាដែលគោរពតាមច្បាប់នៃការកំណត់ពេល (ការចែកចាយធនធានរវាងដំណើរការ) នៅក្នុងខឺណែលលីនុច ដូច្នេះសូមពិនិត្យមើលឱ្យកាន់តែដិតដល់។

លីនុចប្រើអ្វីដែលគេហៅថា CFS, Completely Fairly Fair Scheduler ដែលបានក្លាយជាកម្មវិធីកំណត់ពេលលំនាំដើមតាំងពីខឺណែល 2.6.23។ ដើម្បីយល់ពីក្បួនដោះស្រាយនេះ អ្នកអាចអាន Linux Kernel Architecture ឬកូដប្រភព។ ខ្លឹមសារនៃ CFS គឺដើម្បីចែកចាយពេលវេលាដំណើរការរវាងដំណើរការ អាស្រ័យលើរយៈពេលនៃការប្រតិបត្តិរបស់ពួកគេ។ ពេលដំណើរការស៊ីភីយូកាន់តែច្រើន ពេលវេលាស៊ីភីយូកាន់តែតិចដែលវាទទួលបាន។ នេះធានាថាដំណើរការទាំងអស់ត្រូវបានប្រតិបត្តិ "ដោយយុត្តិធម៌" - ដូច្នេះដំណើរការមួយមិនតែងតែកាន់កាប់ processors ទាំងអស់ ហើយដំណើរការផ្សេងទៀតក៏អាចប្រតិបត្តិផងដែរ។

ជួនកាលគំរូនេះនាំឱ្យមានវត្ថុបុរាណគួរឱ្យចាប់អារម្មណ៍។ អ្នក​ប្រើ​លីនុច​យូរ​មក​ហើយ​ប្រហែល​ជា​ចងចាំ​ការ​បង្កក​កម្មវិធី​កែ​អត្ថបទ​ធម្មតា​នៅ​លើ​កុំព្យូទ័រ​ខណៈ​ពេល​កំពុង​ដំណើរការ​កម្មវិធី​ដែល​ពឹងផ្អែក​លើ​ធនធាន​ដូចជា​កម្មវិធី​ចងក្រង។​ វាបានកើតឡើងដោយសារតែកិច្ចការដែលមិនពឹងផ្អែកលើធនធាននៅក្នុងកម្មវិធីកុំព្យូទ័របានប្រកួតប្រជែងជាមួយនឹងកិច្ចការដែលពឹងផ្អែកលើធនធាន ដូចជាកម្មវិធីចងក្រងជាដើម។ CFS គិតថានេះជារឿងអយុត្តិធម៌ ដូច្នេះវាបញ្ឈប់កម្មវិធីនិពន្ធអត្ថបទជាទៀងទាត់ និងអនុញ្ញាតឱ្យខួរក្បាលគ្រប់គ្រងភារកិច្ចរបស់អ្នកចងក្រង។ នេះត្រូវបានកែតម្រូវដោយប្រើយន្តការ sched_autogroupប៉ុន្តែលក្ខណៈពិសេសជាច្រើនទៀតនៃការបែងចែកពេលវេលាដំណើរការរវាងកិច្ចការនៅតែមាន។ តាមពិតទៅ នេះមិនមែនជារឿងដែលនិយាយអំពីអ្វីដែលអាក្រក់នៅក្នុង CFS នោះទេ ប៉ុន្តែការប៉ុនប៉ងដើម្បីទាក់ទាញការយកចិត្តទុកដាក់ចំពោះការពិតដែលថាការចែកចាយពេលវេលាដំណើរការដោយ "យុត្តិធម៌" មិនមែនជាកិច្ចការតូចតាចបំផុតនោះទេ។

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

រឿងវែងឆ្ងាយបែបនេះគឺចាំបាច់ដើម្បីពន្យល់ការពិតមួយ៖ ធនធានខួរក្បាលកាន់តែច្រើនដែលដំណើរការព្យាយាមប្រើប្រាស់ក្នុងកម្មវិធីកំណត់ពេលវេលាលីនុចដ៏ស្មោះត្រង់ វាកាន់តែលឿនវានឹងត្រូវបានបញ្ឈប់ ដូច្នេះដំណើរការផ្សេងទៀតក៏អាចដំណើរការផងដែរ។ ថាតើនេះត្រឹមត្រូវឬអត់គឺជាសំណួរស្មុគ្រស្មាញដែលអាចត្រូវបានដោះស្រាយខុសគ្នានៅក្រោមបន្ទុកផ្សេងៗគ្នា។ នៅក្នុង Windows រហូតមកដល់ពេលថ្មីៗនេះ កម្មវិធីកំណត់ពេលត្រូវបានផ្តោតលើដំណើរការអាទិភាពនៃកម្មវិធីកុំព្យូទ័រដែលអាចបណ្តាលឱ្យដំណើរការផ្ទៃខាងក្រោយបង្កក។ ស៊ុន សូឡារីស មានកម្មវិធីកំណត់ម៉ោងចំនួនប្រាំផ្សេងគ្នា។ នៅពេលយើងបើកដំណើរការនិម្មិត យើងបន្ថែមលេខប្រាំមួយ កម្មវិធីកំណត់ពេលចែករំលែកដោយយុត្តិធម៌ពីព្រោះប្រាំមុនមិនដំណើរការបានគ្រប់គ្រាន់ជាមួយ Solaris Zones virtualization ។ ខ្ញុំសូមណែនាំឱ្យចាប់ផ្តើមការសិក្សាលម្អិតអំពីបញ្ហានេះជាមួយនឹងសៀវភៅដូចជា Solaris Internals៖ Solaris 10 និង OpenSolaris Kernel Architecture ឬ ការយល់ដឹងអំពីខឺណែលលីនុច.

២.៤. តើធ្វើដូចម្តេចដើម្បីតាមដានការលួច?

ការត្រួតពិនិត្យការលួចនៅក្នុងម៉ាស៊ីននិម្មិត ដូចជាឧបករណ៍វាស់ស្ទង់ដំណើរការផ្សេងទៀតគឺសាមញ្ញ៖ អ្នកអាចប្រើឧបករណ៍វាស់ស្ទង់ដំណើរការណាមួយ។ រឿងចំបងគឺថាម៉ាស៊ីននិម្មិតគឺនៅលើលីនុច។ សម្រាប់ហេតុផលមួយចំនួន Windows មិនផ្តល់ព័ត៌មាននេះដល់អ្នកប្រើប្រាស់របស់វា។ 🙁

លទ្ធផលនៃពាក្យបញ្ជាកំពូល៖ ព័ត៌មានលម្អិតនៃដំណើរការដំណើរការនៅក្នុងជួរឈរខាងស្តាំបំផុត - លួច

ការលំបាកកើតឡើងនៅពេលព្យាយាមទទួលបានព័ត៌មាននេះពីអ្នកត្រួតពិនិត្យខ្ពស់។ អ្នកអាចព្យាយាមទស្សន៍ទាយការលួចនៅលើម៉ាស៊ីនមេ ឧទាហរណ៍ ដោយប្រើប៉ារ៉ាម៉ែត្រ Load Average (LA) - តម្លៃមធ្យមនៃចំនួនដំណើរការដែលកំពុងរង់ចាំនៅក្នុងជួរប្រតិបត្តិ។ វិធីសាស្រ្តសម្រាប់ការគណនាប៉ារ៉ាម៉ែត្រនេះគឺមិនសាមញ្ញទេ ប៉ុន្តែជាទូទៅប្រសិនបើ LA ធម្មតាដោយចំនួននៃ processor threads គឺច្រើនជាង 1 នោះបង្ហាញថាម៉ាស៊ីនមេលីនុចត្រូវបានផ្ទុកលើសទម្ងន់។

តើដំណើរការទាំងអស់នេះកំពុងរង់ចាំអ្វី? ចំលើយជាក់ស្តែងគឺខួរក្បាល។ ប៉ុន្តែ​ចម្លើយ​គឺ​មិន​ត្រឹមត្រូវ​ទាំង​ស្រុង​ទេ ព្រោះ​ពេល​ខ្លះ​ប្រព័ន្ធ​ដំណើរការ​មិន​គិត​ថ្លៃ ប៉ុន្តែ LA បាន​បិទ​ខ្នាត។ ចងចាំ របៀបដែល NFS ធ្លាក់ចុះ និងរបៀបដែល LA រីកចម្រើន. ដូចគ្នានេះដែរអាចកើតឡើងជាមួយឌីស និងឧបករណ៍បញ្ចូល/ទិន្នផលផ្សេងទៀត។ ប៉ុន្តែតាមពិត ដំណើរការអាចរង់ចាំដល់ការបញ្ចប់នៃការចាក់សោណាមួយ ទាំងរូបវន្ត ដែលភ្ជាប់ជាមួយឧបករណ៍ I/O ឬឡូជីខល ដូចជា mutex ជាដើម។ នេះក៏រាប់បញ្ចូលទាំងការចាក់សោរនៅកម្រិតនៃផ្នែករឹង (ការឆ្លើយតបដូចគ្នាពីឌីស) ឬតក្កវិជ្ជា (អ្វីដែលហៅថាការចាក់សោបឋម ដែលរួមមានអង្គធាតុជាច្រើន ការសម្របសម្រួល mutex និងការបង្វិល semaphores អថេរលក្ខខណ្ឌ ការចាក់សោរ rw ការចាក់សោ ipc ...)

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

ដោយសារតែជាមធ្យមនេះ (ហើយក្នុងរយៈពេលមិនតិចជាងមួយនាទី) ការកំណត់អ្វីមួយដោយសូចនាករ LA មិនមែនជាកិច្ចការដែលផ្តល់រង្វាន់បំផុតនោះទេ ជាមួយនឹងលទ្ធផលមិនច្បាស់លាស់នៅក្នុងករណីជាក់លាក់។ ប្រសិនបើអ្នកព្យាយាមស្វែងយល់ អ្នកនឹងឃើញថាអត្ថបទនៅលើវិគីភីឌា និងធនធានដែលមានផ្សេងទៀតពិពណ៌នាតែករណីសាមញ្ញបំផុត ដោយគ្មានការពន្យល់ស៊ីជម្រៅអំពីដំណើរការនេះ។ ខ្ញុំផ្ញើជូនអ្នកដែលចាប់អារម្មណ៍ម្តងទៀត។ នៅទីនេះសម្រាប់ Brendan Gregg  - ធ្វើតាមតំណខាងក្រោម។ អ្នកណាខ្ជិលនិយាយភាសាអង់គ្លេស - ការបកប្រែអត្ថបទដ៏ពេញនិយមរបស់គាត់អំពី LA.

3. ផលប៉ះពាល់ពិសេស

ឥឡូវនេះសូមក្រឡេកមើលករណីសំខាន់ៗនៃការលួចដែលយើងជួបប្រទះ។ ខ្ញុំ​នឹង​ប្រាប់​អ្នក​ពី​របៀប​ដែល​ពួក​គេ​ធ្វើ​តាម​ពី​ចំណុច​ទាំង​អស់​ខាង​លើ និង​របៀប​ដែល​វា​ទាក់ទង​នឹង​សូចនាករ​នៅ​លើ​អ្នក​ត្រួត​ពិនិត្យ។

ការកែច្នៃឡើងវិញ. សាមញ្ញបំផុត និងសាមញ្ញបំផុត៖ អាំងវឺតទ័រត្រូវបានប្រើប្រាស់ឡើងវិញ។ ជាការពិតណាស់ មានម៉ាស៊ីននិម្មិតជាច្រើនដែលកំពុងដំណើរការ ការប្រើប្រាស់ខួរក្បាលខ្ពស់នៅក្នុងពួកវា ការប្រកួតប្រជែងជាច្រើន ការប្រើប្រាស់ LA គឺច្រើនជាង 1 (ធម្មតាដោយខ្សែស្រឡាយដំណើរការ)។ អ្វីគ្រប់យ៉ាងនៅក្នុងម៉ាស៊ីននិម្មិតទាំងអស់ថយចុះ។ ការលួចចម្លងពី hypervisor ក៏កំពុងកើនឡើងដែរ វាចាំបាច់ក្នុងការចែកចាយបន្ទុកឡើងវិញ ឬបិទនរណាម្នាក់។ ជាទូទៅអ្វីគ្រប់យ៉ាងគឺឡូជីខលនិងអាចយល់បាន។

Paravirtualization ធៀបនឹងករណីតែមួយ. មានម៉ាស៊ីននិម្មិតតែមួយនៅលើ hypervisor វាប្រើប្រាស់ផ្នែកតូចមួយរបស់វា ប៉ុន្តែបង្កើតការផ្ទុក I/O ដ៏ធំមួយ ឧទាហរណ៍នៅលើថាស។ ហើយពីកន្លែងណាមួយការលួចតូចមួយលេចឡើងនៅក្នុងវារហូតដល់ 10% (ដូចបានបង្ហាញដោយការពិសោធន៍ជាច្រើន) ។

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

វាកើតឡើងនៅពេលដែលសតិបណ្ដោះអាសន្នត្រូវបានផ្ញើ វាចូលទៅក្នុងចន្លោះខឺណែលរបស់ hypervisor ហើយយើងចាប់ផ្តើមរង់ចាំវា។ ទោះបីជាតាមទស្សនៈរបស់ម៉ាស៊ីននិម្មិតក៏ដោយ គាត់គួរតែត្រលប់មកវិញភ្លាមៗ។ ដូច្នេះ​បើ​តាម​ក្បួន​ដោះស្រាយ​ការ​លួច​ពេល​នេះ​ត្រូវ​បាន​គេ​ចាត់​ទុក​ថា​លួច។ ភាគច្រើនទំនងជានៅក្នុងស្ថានភាពនេះអាចមានយន្តការផ្សេងទៀត (ឧទាហរណ៍ ដំណើរការការហៅ sys ផ្សេងទៀត) ប៉ុន្តែពួកវាមិនគួរខុសគ្នាច្រើនទេ។

កម្មវិធីកំណត់ពេលធៀបនឹងម៉ាស៊ីននិម្មិតដែលផ្ទុកខ្លាំង. នៅពេលដែលម៉ាស៊ីននិម្មិតមួយទទួលរងពីការលួចច្រើនជាងអ្នកដទៃ នេះគឺដោយសារតែអ្នកកំណត់ពេល។ កាលណាដំណើរការផ្ទុក processor កាន់តែច្រើន នោះកម្មវិធីកំណត់ពេលឆាប់នឹងបណ្តេញវាចេញ ដើម្បីឱ្យអ្នកផ្សេងទៀតអាចដំណើរការបាន។ ប្រសិនបើម៉ាស៊ីននិម្មិតប្រើប្រាស់តិចតួច វាស្ទើរតែមិនឃើញការលួចទេ៖ ដំណើរការរបស់វាអង្គុយ និងរង់ចាំដោយស្មោះត្រង់ យើងត្រូវផ្តល់ពេលវេលាបន្ថែមទៀត។ ប្រសិនបើម៉ាស៊ីននិម្មិតផលិតបន្ទុកអតិបរមានៅលើស្នូលទាំងអស់របស់វា ជារឿយៗវាត្រូវបានបណ្តេញចេញពីខួរក្បាល ហើយពួកគេព្យាយាមមិនឱ្យវាច្រើនពេល។

វាកាន់តែអាក្រក់ទៅទៀត នៅពេលដែលដំណើរការនៅក្នុងម៉ាស៊ីននិម្មិតព្យាយាមយក processor កាន់តែច្រើន ព្រោះវាមិនអាចទប់ទល់នឹងដំណើរការទិន្នន័យបានទេ។ បន្ទាប់មកប្រព័ន្ធប្រតិបត្តិការនៅលើ hypervisor ដោយសារតែការបង្កើនប្រសិទ្ធភាពដោយស្មោះត្រង់នឹងផ្តល់ពេលវេលាដំណើរការតិចទៅៗ។ ដំណើរ​ការ​នេះ​កើត​ឡើង​ដូច​ជា​ការ​ធ្លាក់​ព្រិល ហើយ​លួច​លោត​ទៅ​លើ​មេឃ បើ​ទោះ​ជា​ម៉ាស៊ីន​និម្មិត​ផ្សេង​ទៀត​ប្រហែល​ជា​មិន​សូវ​កត់​សម្គាល់​វា​ក៏​ដោយ។ ហើយស្នូលកាន់តែច្រើនម៉ាស៊ីនដែលរងផលប៉ះពាល់កាន់តែអាក្រក់។ និយាយឱ្យខ្លី ម៉ាស៊ីននិម្មិតដែលផ្ទុកខ្ពស់ជាមួយនឹងស្នូលជាច្រើនទទួលរងការឈឺចាប់បំផុត។

LA ទាប ប៉ុន្តែមានការលួច. ប្រសិនបើ LA មានចំនួនប្រហែល 0,7 (នោះគឺថា hypervisor ហាក់បីដូចជាកំពុងផ្ទុកលើសទម្ងន់) ប៉ុន្តែការលួចត្រូវបានគេសង្កេតឃើញនៅក្នុងម៉ាស៊ីននិម្មិតនីមួយៗ៖

• ជម្រើសជាមួយ paravirtualization ដែលបានពិពណ៌នាខាងលើរួចហើយ។ ម៉ាស៊ីននិម្មិតអាចទទួលបានម៉ែត្រដែលបង្ហាញពីការលួច ទោះបីជាអ្នកត្រួតពិនិត្យខ្ពស់មិនអីក៏ដោយ។ យោងតាមលទ្ធផលនៃការពិសោធន៍របស់យើង ជម្រើសលួចនេះមិនលើសពី 10% ហើយមិនគួរមានផលប៉ះពាល់ខ្លាំងដល់ដំណើរការនៃកម្មវិធីនៅក្នុងម៉ាស៊ីននិម្មិតនោះទេ។
• ប៉ារ៉ាម៉ែត្រ LA ត្រូវបានគណនាមិនត្រឹមត្រូវ។ ច្បាស់ជាងនេះទៅទៀត នៅពេលជាក់លាក់នីមួយៗ វាត្រូវបានគណនាយ៉ាងត្រឹមត្រូវ ប៉ុន្តែនៅពេលជាមធ្យមលើសពីមួយនាទី វាប្រែជាប៉ាន់ស្មានមិនដល់។ ឧទាហរណ៍ ប្រសិនបើម៉ាស៊ីននិម្មិតមួយក្នុងមួយភាគបីនៃ hypervisor ប្រើប្រាស់ processors ទាំងអស់របស់វាក្នុងរយៈពេលកន្លះនាទី នោះ LA ក្នុងមួយនាទីនៅលើ hypervisor នឹងមាន 0,15; ម៉ាស៊ីននិម្មិតចំនួនបួនដែលធ្វើការក្នុងពេលដំណាលគ្នានឹងផ្តល់ឱ្យ 0,6 ។ ហើយការពិតដែលថាសម្រាប់ពាក់កណ្តាលនាទីនៅលើពួកគេម្នាក់ៗមានការលួចព្រៃនៅ 25% យោងតាមសូចនាករ LA មិនអាចដកចេញបានទេ។
• ជាថ្មីម្តងទៀត ដោយសារតែអ្នករៀបចំកាលវិភាគដែលបានសម្រេចចិត្តថានរណាម្នាក់កំពុងញ៉ាំច្រើនពេក ហើយទុកឱ្យនរណាម្នាក់រង់ចាំ។ ក្នុងពេលនេះ ខ្ញុំនឹងប្តូរបរិបទ ដោះស្រាយការរំខាន និងថែរក្សាប្រព័ន្ធសំខាន់ៗផ្សេងទៀត។ ជាលទ្ធផល ម៉ាស៊ីននិម្មិតមួយចំនួនមិនឃើញមានបញ្ហាអ្វីទេ ខណៈពេលដែលអ្នកផ្សេងទៀតជួបប្រទះនឹងការថយចុះដំណើរការធ្ងន់ធ្ងរ។

4. ការបង្ខូចទ្រង់ទ្រាយផ្សេងទៀត។

មានហេតុផលរាប់លានបន្ថែមទៀតសម្រាប់ការបង្ខូចទ្រង់ទ្រាយពេលវេលាដំណើរការត្រឹមត្រូវនៅលើម៉ាស៊ីននិម្មិត។ ឧទាហរណ៍ hyperthreading និង NUMA ណែនាំការលំបាកទៅក្នុងការគណនា។ ពួកគេច្រឡំទាំងស្រុងនូវជម្រើសនៃខឺណែលសម្រាប់ដំណើរការដំណើរការ ពីព្រោះកម្មវិធីកំណត់ពេលប្រើមេគុណ - ទម្ងន់ ដែលធ្វើឲ្យការគណនាកាន់តែពិបាកនៅពេលប្តូរបរិបទ។

មានការបង្ខូចទ្រង់ទ្រាយដោយសារតែបច្ចេកវិទ្យាដូចជា turbo boost ឬផ្ទុយទៅវិញ របៀបសន្សំថាមពល ដែលនៅពេលគណនាការប្រើប្រាស់ អាចបង្កើន ឬបន្ថយប្រេកង់ដោយសិប្បនិម្មិត ឬសូម្បីតែពេលវេលានៅលើម៉ាស៊ីនមេ។ ការបើកដំណើរការ turbo boost កាត់បន្ថយដំណើរការនៃ processor thread មួយ ដោយសារការកើនឡើងនៃដំណើរការរបស់ processor ផ្សេងទៀត។ នៅពេលនេះ ព័ត៌មានអំពីប្រេកង់ដំណើរការបច្ចុប្បន្នមិនត្រូវបានបញ្ជូនទៅម៉ាស៊ីននិម្មិតទេ ហើយវាជឿថាមាននរណាម្នាក់កំពុងលួចពេលវេលារបស់វា (ឧទាហរណ៍ វាបានស្នើសុំ 2 GHz ប៉ុន្តែបានទទួលពាក់កណ្តាលនោះ)។

ជាទូទៅវាអាចមានហេតុផលជាច្រើនសម្រាប់ការបង្ខូចទ្រង់ទ្រាយ។ អ្នកអាចរកឃើញអ្វីផ្សេងទៀតនៅលើប្រព័ន្ធជាក់លាក់មួយ។ វាជាការប្រសើរក្នុងការចាប់ផ្តើមជាមួយនឹងសៀវភៅដែលខ្ញុំបានផ្តល់តំណខាងលើ ហើយទាញយកស្ថិតិពីអ្នកត្រួតពិនិត្យខ្ពស់ដោយប្រើឧបករណ៍ប្រើប្រាស់ដូចជា perf, sysdig, systemtap ដែលក្នុងនោះ ដប់.

5 - សេចក្តី​សន្និដ្ឋាន

1. ចំនួននៃការលួចមួយចំនួនអាចកើតឡើងដោយសារតែ paravirtualization ហើយវាអាចចាត់ទុកថាជារឿងធម្មតា។ ពួកគេសរសេរនៅលើអ៊ីនធឺណិតថាតម្លៃនេះអាចមាន 5-10% ។ អាស្រ័យលើកម្មវិធីនៅក្នុងម៉ាស៊ីននិម្មិត និងនៅលើបន្ទុកដែលវាដាក់នៅលើឧបករណ៍រូបវ័ន្តរបស់វា។ នៅទីនេះវាសំខាន់ណាស់ក្នុងការយកចិត្តទុកដាក់លើរបៀបដែលកម្មវិធីមានអារម្មណ៍នៅក្នុងម៉ាស៊ីននិម្មិត។
2. សមាមាត្រនៃការផ្ទុកនៅលើឧបករណ៍ត្រួតពិនិត្យខ្ពស់ និងការលួចនៅក្នុងម៉ាស៊ីននិម្មិតមិនតែងតែទាក់ទងគ្នាយ៉ាងច្បាស់នោះទេ ការប៉ាន់ស្មានទាំងពីរនៃការលួចអាចមានកំហុសក្នុងស្ថានភាពជាក់លាក់ក្រោមបន្ទុកផ្សេងៗគ្នា។
3. អ្នករៀបចំកាលវិភាគមានអាកប្បកិរិយាមិនល្អចំពោះដំណើរការដែលសួរច្រើន។ គាត់​ព្យាយាម​ឲ្យ​តិច​ទៅ​អ្នក​ដែល​សុំ​ច្រើន។ ម៉ាស៊ីននិម្មិតធំគឺអាក្រក់។
4. ការលួចបន្តិចបន្តួចអាចជាបទដ្ឋាន ទោះបីជាមិនមានការចម្លងតាមនិម្មិតក៏ដោយ (ដោយគិតគូរពីបន្ទុកនៅក្នុងម៉ាស៊ីននិម្មិត លក្ខណៈនៃបន្ទុកអ្នកជិតខាង ការចែកចាយបន្ទុកឆ្លងកាត់ខ្សែស្រលាយ និងកត្តាផ្សេងទៀត)។
5. ប្រសិនបើអ្នកចង់ស្វែងយល់ពីការលួចនៅក្នុងប្រព័ន្ធជាក់លាក់មួយ អ្នកត្រូវស្វែងរកជម្រើសផ្សេងៗ ប្រមូលម៉ែត្រ វិភាគដោយប្រុងប្រយ័ត្ន ហើយគិតពីរបៀបចែកចាយបន្ទុកឱ្យស្មើៗគ្នា។ គម្លាតពីករណីណាមួយគឺអាចធ្វើទៅបាន ដែលត្រូវតែបញ្ជាក់ដោយពិសោធន៍ ឬមើលនៅក្នុងកម្មវិធីកែកំហុសខឺណែល។

ប្រភព: www.habr.com