ការណែនាំអំពីប្រព័ន្ធប្រតិបត្តិការ

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

ការងារមន្ទីរពិសោធន៍លើប្រធានបទនេះអាចរកបាននៅទីនេះ៖

ផ្នែកផ្សេងទៀត៖

អ្នកក៏អាចពិនិត្យមើលឆានែលរបស់ខ្ញុំនៅ ទូរលេខ =)

ការធ្វើផែនការ៖ ជួរមតិយោបល់ពហុកម្រិត

នៅក្នុងការបង្រៀននេះ យើងនឹងនិយាយអំពីបញ្ហានៃការអភិវឌ្ឍន៍វិធីសាស្រ្តដ៏ល្បីល្បាញបំផុតមួយ។
ផែនការដែលត្រូវបានគេហៅថា ជួរមតិយោបល់ពហុកម្រិត (MLFQ) ។ កម្មវិធីកំណត់ពេល MLFQ ត្រូវបានពិពណ៌នាជាលើកដំបូងនៅឆ្នាំ 1962 ដោយ Fernando J. Corbató នៅក្នុងប្រព័ន្ធមួយដែលមានឈ្មោះថា
ប្រព័ន្ធចែករំលែកពេលវេលាដែលត្រូវគ្នា (CTSS) ។ ការងារទាំងនេះ (រួមទាំងការងារនៅពេលក្រោយ
Multics) ត្រូវបានតែងតាំងជាបន្តបន្ទាប់សម្រាប់ពានរង្វាន់ Turing ។ អ្នករៀបចំផែនការគឺ
ធ្វើឱ្យប្រសើរឡើងជាបន្តបន្ទាប់ និងទទួលបានរូបរាងដែលអាចត្រូវបានរកឃើញរួចហើយនៅក្នុង
ប្រព័ន្ធទំនើបមួយចំនួន។

ក្បួនដោះស្រាយ MLFQ ព្យាយាមដោះស្រាយបញ្ហាត្រួតស៊ីគ្នាជាមូលដ្ឋានចំនួន 2 ។
ដំបូងវាព្យាយាមបង្កើនប្រសិទ្ធភាពពេលវេលាផ្លាស់ប្តូរ ដែលដូចដែលយើងបានពិភាក្សានៅក្នុងការបង្រៀនមុន វាត្រូវបានធ្វើឱ្យប្រសើរដោយវិធីសាស្រ្តនៃការចាប់ផ្តើមនៅដើមជួរច្រើនបំផុត
កិច្ចការខ្លីៗ។ ទោះជាយ៉ាងណាក៏ដោយ OS មិនដឹងថាដំណើរការជាក់លាក់មួយនឹងដំណើរការរយៈពេលប៉ុន្មាននោះទេ ហើយរឿងនេះ
ចំណេះដឹងចាំបាច់សម្រាប់ប្រតិបត្តិការនៃក្បួនដោះស្រាយ SJF, STCF ។ ទីពីរ, MLFQ កំពុងព្យាយាម
ធ្វើឱ្យប្រព័ន្ធឆ្លើយតបសម្រាប់អ្នកប្រើប្រាស់ (ឧទាហរណ៍សម្រាប់អ្នកដែលអង្គុយ និង
សម្លឹងមើលអេក្រង់រង់ចាំឱ្យកិច្ចការបញ្ចប់) ហើយដូច្នេះកាត់បន្ថយពេលវេលា
ការឆ្លើយតប។ ជាអកុសល ក្បួនដោះស្រាយដូចជា RR ធ្វើអោយពេលវេលាឆ្លើយតបប្រសើរឡើង ប៉ុន្តែខ្លាំងបំផុត។
ជះឥទ្ធិពលអាក្រក់ទៅលើរង្វាស់ពេលវេលាវិលជុំ។ ដូច្នេះបញ្ហារបស់យើង: របៀបរចនា
កម្មវិធីកំណត់ពេលដែលនឹងបំពេញតាមតម្រូវការរបស់យើងដោយមិនដឹងពីអ្វីទាំងអស់។
ធម្មជាតិនៃដំណើរការជាទូទៅ? តើអ្នករៀបចំកាលវិភាគអាចរៀនពីលក្ខណៈនៃកិច្ចការដោយរបៀបណា?
តើវាបើកដំណើរការមួយណា ហើយធ្វើការសម្រេចចិត្តធ្វើផែនការកាន់តែប្រសើរ?

ខ្លឹមសារនៃបញ្ហា៖ របៀបរៀបចំផែនការកំណត់ភារកិច្ចដោយមិនមានចំណេះដឹងល្អឥតខ្ចោះ?
របៀបរចនាកម្មវិធីកំណត់ពេលដែលកាត់បន្ថយពេលវេលាឆ្លើយតប
សម្រាប់កិច្ចការអន្តរកម្ម និងក្នុងពេលជាមួយគ្នានេះកាត់បន្ថយពេលវេលាផ្លាស់ប្តូរដោយមិនដឹងខ្លួន
ចំណេះដឹងអំពីពេលវេលាអនុវត្តការងារ?

ចំណាំ៖ យើងរៀនពីព្រឹត្តិការណ៍មុនៗ

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

MLFQ: ច្បាប់ជាមូលដ្ឋាន

សូមក្រឡេកមើលច្បាប់ជាមូលដ្ឋាននៃក្បួនដោះស្រាយ MLFQ ។ ហើយទោះបីជាការអនុវត្តនៃក្បួនដោះស្រាយនេះ។
មានវិធីសាស្រ្តជាមូលដ្ឋានមួយចំនួនគឺស្រដៀងគ្នា។
នៅក្នុងការអនុវត្តដែលយើងនឹងពិនិត្យមើល MLFQ នឹងមានមួយចំនួន
ជួរដាច់ដោយឡែក ដែលនីមួយៗនឹងមានអាទិភាពផ្សេងគ្នា។ គ្រប់ពេលវេលា
កិច្ចការដែលត្រៀមរួចជាស្រេចសម្រាប់ការប្រតិបត្តិគឺនៅក្នុងជួរមួយ។ MLFQ ប្រើអាទិភាព
ដើម្បីសម្រេចថាតើកិច្ចការណាដែលត្រូវដំណើរការសម្រាប់ការប្រតិបត្តិ ឧ. ភារកិច្ចជាមួយខ្ពស់ជាង
អាទិភាព (កិច្ចការពីជួរដែលមានអាទិភាពខ្ពស់បំផុត) នឹងត្រូវបានដាក់ឱ្យដំណើរការមុន។
ជួរ។
ជាការពិតណាស់ អាចមានកិច្ចការច្រើនជាងមួយនៅក្នុងជួរដែលបានផ្តល់ឱ្យ ដូច្នេះ
ដូច្នេះពួកគេនឹងមានអាទិភាពដូចគ្នា។ ក្នុងករណីនេះយន្តការនឹងត្រូវបានប្រើ
RR ដើម្បីកំណត់ពេលដំណើរការក្នុងចំណោមកិច្ចការទាំងនេះ។
ដូច្នេះយើងមកដល់ក្បួនជាមូលដ្ឋានចំនួនពីរសម្រាប់ MLFQ:

ច្បាប់ទី 1៖ ប្រសិនបើអាទិភាព(A) > អាទិភាព(B) កិច្ចការ A នឹងត្រូវចាប់ផ្តើម (B នឹងមិនមាន)
ច្បាប់ទី 2៖ ប្រសិនបើអាទិភាព(A) = អាទិភាព(B), A&B ត្រូវបានចាប់ផ្តើមដោយប្រើ RR

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

នៅក្នុងគ្រោងការណ៍នេះ ដំណើរការ 2 A និង B ស្ថិតនៅក្នុងជួរអាទិភាពខ្ពស់បំផុត។ ដំណើរការ
C គឺជាកន្លែងណាមួយនៅកណ្តាល ហើយដំណើរការ D គឺនៅចុងបញ្ចប់នៃជួរ។ នេះបើតាមការលើកឡើងខាងលើ
យោងទៅតាមការពិពណ៌នានៃក្បួនដោះស្រាយ MLFQ អ្នកកំណត់ពេលនឹងប្រតិបត្តិភារកិច្ចតែជាមួយនឹងកម្រិតខ្ពស់បំផុត។
អាទិភាពយោងទៅតាម RR ហើយកិច្ចការ C, D នឹងលែងដំណើរការ។
ជាធម្មតា រូបថតឋិតិវន្តនឹងមិនផ្តល់រូបភាពពេញលេញនៃរបៀបដែល MLFQ ដំណើរការនោះទេ។
វាជាការសំខាន់ក្នុងការយល់ច្បាស់អំពីរបៀបដែលរូបភាពផ្លាស់ប្តូរតាមពេលវេលា។

ការប៉ុនប៉ង 1: របៀបផ្លាស់ប្តូរអាទិភាព

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

ច្បាប់ទី 3: នៅពេលដែលកិច្ចការមួយចូលទៅក្នុងប្រព័ន្ធ វាត្រូវបានដាក់ក្នុងជួរដែលមានកម្រិតខ្ពស់បំផុត។
អាទិភាព។
ច្បាប់ទី 4a៖ ប្រសិនបើកិច្ចការមួយប្រើវិនដូពេលវេលាទាំងមូលដែលបានបែងចែកទៅវា នោះវា។
អាទិភាពត្រូវបានកាត់បន្ថយ។
Rule4b: ប្រសិនបើ Task មួយចេញ CPU មុនពេលពេលវេលារបស់វាផុតកំណត់ នោះវានឹងចេញ
នៅតែមានអាទិភាពដដែល។

ឧទាហរណ៍ទី 1: កិច្ចការតែមួយដែលដំណើរការយូរ

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

ឧទាហរណ៍ទី 2៖ ប្រគល់កិច្ចការខ្លីមួយ។

ឥឡូវនេះសូមមើលឧទាហរណ៍អំពីរបៀបដែល MLFQ នឹងព្យាយាមចូលទៅជិត SJF ។ នៅក្នុងនោះ។
ឧទាហរណ៍ កិច្ចការពីរ៖ ក ដែលជាកិច្ចការដ៏យូរអង្វែងឥតឈប់ឈរ
ការកាន់កាប់ CPU និង B ដែលជាកិច្ចការអន្តរកម្មខ្លី។ ឧបមា
ថា A បានធ្វើការអស់មួយរយៈមកហើយ ដល់ពេលដែលកិច្ចការ B មកដល់។

ក្រាហ្វនេះបង្ហាញពីលទ្ធផលនៃសេណារីយ៉ូ។ កិច្ចការ A ដូចជាកិច្ចការណាមួយ
ការប្រើប្រាស់ស៊ីភីយូគឺនៅខាងក្រោមបំផុត។ កិច្ចការ B នឹងមកដល់នៅពេល T=100 ហើយនឹង
ត្រូវបានដាក់ក្នុងជួរអាទិភាពខ្ពស់បំផុត។ ចាប់តាំងពីពេលប្រតិបត្តិការរបស់វាគឺខ្លី
វានឹងបញ្ចប់មុនពេលឈានដល់ជួរចុងក្រោយ។

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

ឧទាហរណ៍ទី 3៖ ចុះ I/O វិញ?

ឥឡូវសូមមើលឧទាហរណ៍ I/O ។ ដូចមានចែងក្នុងច្បាប់ទី៤ ខ.
ប្រសិនបើដំណើរការមួយបញ្ចេញ processor ដោយមិនប្រើពេលវេលា processor របស់វាទាំងអស់នោះ
បន្ទាប់មកវានៅតែស្ថិតក្នុងកម្រិតអាទិភាពដដែល។ គោលបំណងនៃច្បាប់នេះគឺសាមញ្ញណាស់។
- ប្រសិនបើការងារអន្តរកម្មអនុវត្តប្រតិបត្តិការ I/O ច្រើន ឧទាហរណ៍ រង់ចាំ
ពីគ្រាប់ចុចអ្នកប្រើប្រាស់ ឬការចុចកណ្ដុរ កិច្ចការបែបនេះនឹងធ្វើឱ្យខួរក្បាលដំណើរការ
មុនពេលបង្អួចដែលបានបែងចែក។ យើងមិនចង់បន្ថយអាទិភាពនៃកិច្ចការបែបនេះទេ
ហើយដូច្នេះវានឹងនៅដដែល។

ឧទាហរណ៍នេះបង្ហាញពីរបៀបដែលក្បួនដោះស្រាយនឹងដំណើរការជាមួយដំណើរការបែបនេះ - ការងារអន្តរកម្ម B ដែលត្រូវការតែ CPU សម្រាប់ 1ms មុនពេលប្រតិបត្តិ
ដំណើរការ I/O និង Job A ដំណើរការយូរ ដែលចំណាយពេលទាំងអស់ក្នុងការប្រើប្រាស់ CPU ។
MLFQ រក្សាដំណើរការ B ជាអាទិភាពខ្ពស់បំផុត ព្រោះវានៅតែបន្ត
បញ្ចេញ CPU ។ ប្រសិនបើ B គឺជាកិច្ចការអន្តរកម្ម នោះក្បួនដោះស្រាយបានសម្រេច
គោលដៅរបស់អ្នកគឺដើម្បីដំណើរការកិច្ចការអន្តរកម្មយ៉ាងឆាប់រហ័ស។

បញ្ហាជាមួយក្បួនដោះស្រាយ MLFQ បច្ចុប្បន្ន

នៅក្នុងឧទាហរណ៍ពីមុន យើងបានបង្កើតកំណែមូលដ្ឋាននៃ MLFQ ។ ហើយវាហាក់ដូចជាគាត់
ធ្វើការងាររបស់វាបានល្អ និងស្មោះត្រង់ ដោយបែងចែកពេលវេលាស៊ីភីយូដោយស្មើភាពរវាង
កិច្ចការវែង និងអនុញ្ញាតឱ្យកិច្ចការខ្លី ឬបរិមាណខ្ពស់។
ធ្វើការលើ I/O យ៉ាងរហ័ស។ ជាអកុសល វិធីសាស្រ្តនេះមានច្រើន។
បញ្ហាធ្ងន់ធ្ងរ។
ដំបូង, បញ្ហានៃភាពអត់ឃ្លាន: ប្រសិនបើប្រព័ន្ធមានអន្តរកម្មច្រើន។
កិច្ចការ បន្ទាប់មកពួកគេនឹងប្រើប្រាស់ពេលវេលាដំណើរការទាំងអស់ ហើយដូច្នេះមិនមែនតែមួយសម្រាប់រយៈពេលយូរនោះទេ។
ភារកិច្ចនឹងមិនអាចត្រូវបានអនុវត្ត (ពួកគេកំពុងអត់ឃ្លាន) ។

ទីពីរអ្នកប្រើប្រាស់ឆ្លាតវៃអាចសរសេរកម្មវិធីរបស់ពួកគេដូច្នេះ
បញ្ឆោតអ្នកកំណត់ពេល។ ការបោកបញ្ឆោតគឺធ្វើអ្វីមួយដើម្បីបង្ខំ
កម្មវិធីកំណត់ពេលផ្តល់ឱ្យដំណើរការនូវពេលវេលា CPU កាន់តែច្រើន។ ក្បួនដោះស្រាយនោះ។
ដែលបានពិពណ៌នាខាងលើគឺពិតជាងាយរងគ្រោះចំពោះការវាយប្រហារស្រដៀងគ្នានេះ៖ មុនពេលបង្អួចពេលវេលាត្រូវបានអនុវត្ត
បានបញ្ចប់ អ្នកត្រូវអនុវត្តប្រតិបត្តិការ I/O (ចំពោះឯកសារមួយចំនួន មិនថាឯកសារអ្វីទេ)
ដូច្នេះហើយ បើកស៊ីភីយូ។ អាកប្បកិរិយាបែបនេះនឹងអនុញ្ញាតឱ្យអ្នកនៅដដែល
ជួរខ្លួនវា ហើយម្តងទៀតទទួលបានភាគរយធំនៃពេលវេលាស៊ីភីយូ។ ប្រសិនបើអ្នកធ្វើ
នេះគឺត្រឹមត្រូវ (ឧទាហរណ៍ ប្រតិបត្តិ 99% នៃពេលវេលាបង្អួចមុនពេលបញ្ចេញស៊ីភីយូ)
ភារកិច្ចបែបនេះអាចផ្តាច់មុខខួរក្បាល។

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

សំណួរសម្រាប់ទស្សនិកជន៖ តើការវាយប្រហារអ្វីលើអ្នកកំណត់ពេលអាចត្រូវបានអនុវត្តនៅក្នុងពិភពសម័យទំនើប?

ការប៉ុនប៉ង 2: បង្កើនអាទិភាព

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

វិធាន ៤៖ បន្ទាប់ពីកំឡុងពេលជាក់លាក់ S សូមផ្លាស់ទីកិច្ចការទាំងអស់នៅក្នុងប្រព័ន្ធទៅជួរខ្ពស់បំផុត។

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

ស៊ីភីយូ និងអន្តរកម្មពីរ ដំណើរការខ្លី។ នៅខាងឆ្វេងក្នុងរូប តួរលេខបង្ហាញអាកប្បកិរិយាដោយគ្មានការផ្សព្វផ្សាយជាអាទិភាព ហើយដូច្នេះកិច្ចការដែលដំណើរការយូរចាប់ផ្តើមស្រេកឃ្លាន បន្ទាប់ពីកិច្ចការអន្តរកម្មពីរមកដល់ប្រព័ន្ធ។ នៅក្នុងរូបភាពនៅខាងស្តាំ ការកើនឡើងអាទិភាពត្រូវបានអនុវត្តរៀងរាល់ 50ms ហើយដូច្នេះដំណើរការទាំងអស់ត្រូវបានធានាថានឹងទទួលបានពេលវេលាស៊ីភីយូ ហើយនឹងត្រូវបានដាក់ឱ្យដំណើរការជាទៀងទាត់។ 50ms នៅក្នុងករណីនេះត្រូវបានយកជាឧទាហរណ៍មួយ; តាមពិតចំនួននេះគឺខ្ពស់ជាងបន្តិច។
ជាក់ស្តែង ការបន្ថែមពេលវេលាកើនឡើងតាមកាលកំណត់ S នាំឱ្យ
សំណួរឡូជីខល៖ តើតម្លៃអ្វីដែលគួរកំណត់? មួយក្នុងចំណោមកិត្តិយស
វិស្វករប្រព័ន្ធ John Ousterhout បានហៅបរិមាណបែបនេះនៅក្នុងប្រព័ន្ធថា voo-doo
ឥតឈប់ឈរ ចាប់តាំងពីពួកគេតាមវិធីខ្លះទាមទារវេទមន្តខ្មៅសម្រាប់ត្រឹមត្រូវ។
ការតាំងពិព័រណ៍។ ហើយជាអកុសល S មានក្លិនក្រអូបបែបនេះ។ ប្រសិនបើអ្នកកំណត់តម្លៃផងដែរ។
កិច្ចការធំ - យូរនឹងចាប់ផ្តើមអត់ឃ្លាន។ ហើយប្រសិនបើអ្នកកំណត់តម្លៃទាបពេក។
កិច្ចការអន្តរកម្មនឹងមិនទទួលបានពេលវេលា CPU ត្រឹមត្រូវ។

ការប៉ុនប៉ងទី 3: គណនេយ្យកាន់តែប្រសើរ

ឥឡូវយើងមានបញ្ហាមួយទៀតត្រូវដោះស្រាយ៖ ធ្វើម៉េចមិនទៅ
អនុញ្ញាតឱ្យកម្មវិធីកំណត់ពេលវេលារបស់យើងបោកបញ្ឆោត? មនុស្សដែលត្រូវស្តីបន្ទោសចំពោះលទ្ធភាពនេះគឺ
ច្បាប់ 4a, 4b ដែលអនុញ្ញាតឱ្យការងាររក្សាអាទិភាព ធ្វើឱ្យដំណើរការដំណើរការឡើងវិញ
មុនពេលពេលវេលាកំណត់ផុតកំណត់។ តើធ្វើដូចម្តេចដើម្បីដោះស្រាយជាមួយនេះ?
ដំណោះស្រាយក្នុងករណីនេះអាចត្រូវបានចាត់ទុកថាជាគណនេយ្យកាន់តែប្រសើរឡើងនៃពេលវេលាស៊ីភីយូនៅលើនីមួយៗ
កម្រិត MLFQ ។ ជំនួសឱ្យការភ្លេចពេលវេលាដែលកម្មវិធីបានប្រើ
processor សម្រាប់រយៈពេលដែលបានបែងចែកវាគួរតែត្រូវបានយកទៅក្នុងគណនីនិងរក្សាទុក។ បន្ទាប់ពី
ដំណើរការបានប្រើអស់ពេលកំណត់របស់វា វាគួរតែត្រូវបានបន្ទាបបន្ថោកទៅបន្ទាប់
កម្រិតអាទិភាព។ ឥឡូវនេះវាមិនមានបញ្ហាថាតើដំណើរការនឹងប្រើពេលវេលារបស់វាយ៉ាងដូចម្តេចនោះទេ។
គណនាឥតឈប់ឈរនៅលើខួរក្បាល ឬជាចំនួននៃការហៅទូរសព្ទ។ ដូច្នេះ
ច្បាប់ទី 4 គួរតែត្រូវបានសរសេរឡើងវិញនូវទម្រង់ដូចខាងក្រោមៈ

វិធាន ៤៖ បន្ទាប់ពីកិច្ចការមួយបានប្រើពេលវេលាដែលបានបែងចែករបស់វានៅក្នុងជួរបច្ចុប្បន្ន (មិនថាវាបើកស៊ីភីយូប៉ុន្មានដងទេ) អាទិភាពនៃកិច្ចការនោះត្រូវបានបន្ទាប (វាផ្លាស់ទីចុះក្រោម)។

តោះមើលឧទាហរណ៍៖
»

តួរលេខបង្ហាញពីអ្វីដែលនឹងកើតឡើង ប្រសិនបើអ្នកព្យាយាមបន្លំភ្នែកអ្នករៀបចំកាលវិភាគ ដូចជា
ប្រសិនបើវានៅជាមួយច្បាប់មុន 4a នោះ 4b លទ្ធផលនៅខាងឆ្វេងនឹងត្រូវបានទទួល។ រីករាយថ្មី។
ក្បួនគឺជាលទ្ធផលនៅខាងស្តាំ។ មុនពេលការពារ ដំណើរការណាមួយអាចហៅទៅ I/O មុនពេលបញ្ចប់ និង
ដូច្នេះគ្រប់គ្រង CPU បន្ទាប់ពីបើកការការពារ ដោយមិនគិតពីអាកប្បកិរិយា
I/O គាត់នឹងនៅតែចុះក្នុងជួរ ហើយដូច្នេះនឹងមិនអាចមិនស្មោះត្រង់បានទេ។
កាន់កាប់ធនធាន CPU ។

ការកែលម្អ MLFQ និងបញ្ហាផ្សេងៗទៀត

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

ជាឧទាហរណ៍ ការអនុវត្ត MLFQ ភាគច្រើនអនុញ្ញាតឱ្យអ្នកកំណត់ភាពខុសគ្នា
ចន្លោះពេលសម្រាប់ជួរផ្សេងៗគ្នា។ ជាធម្មតាជួរអាទិភាពខ្ពស់។
ចន្លោះពេលខ្លីត្រូវបានចេញវេជ្ជបញ្ជា។ ជួរទាំងនេះមានភារកិច្ចអន្តរកម្ម
ការផ្លាស់ប្តូររវាងដែលមានលក្ខណៈរសើបខ្លាំង ហើយគួរតែយក 10 ឬតិចជាងនេះ។
ms ផ្ទុយទៅវិញ ជួរដែលមានអាទិភាពទាបមានកិច្ចការដែលដំណើរការយូរដែលប្រើ
ស៊ីភីយូ។ ហើយក្នុងករណីនេះ ចន្លោះពេលដ៏យូរសមល្អ (100ms)។

ក្នុងឧទាហរណ៍នេះមានកិច្ចការចំនួន 2 ដែលដំណើរការក្នុងជួរអាទិភាពខ្ពស់ 20
ms បែងចែកជា 10ms windows ។ 40ms នៅក្នុងជួរកណ្តាល (បង្អួច 20ms) និងនៅក្នុងអាទិភាពទាប
បង្អួចពេលវេលាជួរបានក្លាយជា 40ms ដែលកិច្ចការបានបញ្ចប់ការងាររបស់ពួកគេ។

ការអនុវត្ត Solaris OS នៃ MLFQ គឺជាថ្នាក់នៃកម្មវិធីកំណត់ពេលវេលាចែករំលែក។
អ្នករៀបចំផែនការនឹងផ្តល់នូវសំណុំនៃតារាងដែលកំណត់យ៉ាងពិតប្រាកដដូចដែលវាគួរតែ
អាទិភាពនៃដំណើរការផ្លាស់ប្តូរពេញមួយជីវិតរបស់វា អ្វីដែលគួរមានទំហំ
វិនដូដែលបានបែងចែក និងញឹកញាប់ប៉ុណ្ណាដែលអ្នកត្រូវការដើម្បីបង្កើនអាទិភាពការងារ។ អ្នកគ្រប់គ្រង
ប្រព័ន្ធអាចធ្វើអន្តរកម្មជាមួយតារាងនេះ និងធ្វើឱ្យកម្មវិធីកំណត់ពេលមានឥរិយាបទ
ខុសគ្នា។ តាមលំនាំដើម តារាងនេះមាន 60 ជួរជាមួយនឹងការកើនឡើងបន្តិចម្តងៗ
ទំហំបង្អួចពី 20ms (អាទិភាពខ្ពស់) ទៅជាច្រើនរយ ms (អាទិភាពទាប) និង
ផងដែរជាមួយនឹងការជំរុញនៃកិច្ចការទាំងអស់ម្តងក្នុងមួយវិនាទី។

អ្នករៀបចំផែនការ MLFQ ផ្សេងទៀតមិនប្រើតារាង ឬជាក់លាក់ណាមួយឡើយ។
ច្បាប់ដែលត្រូវបានពិពណ៌នានៅក្នុងការបង្រៀននេះ ផ្ទុយទៅវិញ ពួកគេគណនាអាទិភាពដោយប្រើ
រូបមន្តគណិតវិទ្យា។ ឧទាហរណ៍ កម្មវិធីកំណត់ពេល FreeBSD ប្រើរូបមន្តសម្រាប់
គណនាអាទិភាពបច្ចុប្បន្ននៃកិច្ចការដោយផ្អែកលើរយៈពេលដែលដំណើរការ
ស៊ីភីយូដែលប្រើ។ លើសពីនេះ ការប្រើប្រាស់ CPU ថយចុះតាមពេលវេលា ហើយដូច្នេះដែរ។
ដូច្នេះ ការបង្កើនអាទិភាពកើតឡើងខុសពីការពិពណ៌នាខាងលើ។ វាជាការពិត
ហៅថា decay algorithms។ ចាប់តាំងពីកំណែ 7.1, FreeBSD បានប្រើកម្មវិធីកំណត់ពេល ULE ។

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

MLFQ: សង្ខេប

យើងបានពណ៌នាអំពីវិធីសាស្រ្តធ្វើផែនការមួយហៅថា MLFQ ។ ឈ្មោះរបស់គាត់
រុំព័ទ្ធនៅក្នុងគោលការណ៍នៃប្រតិបត្តិការ - វាមានជួរជាច្រើននិងប្រើមតិកែលម្អ
ដើម្បីកំណត់អាទិភាពការងារ។
ទម្រង់ចុងក្រោយនៃច្បាប់នឹងមានដូចខាងក្រោម៖

វិធាន ៤៖ ប្រសិនបើអាទិភាព(A) > អាទិភាព(B) កិច្ចការ A នឹងត្រូវចាប់ផ្តើម (B នឹងមិន)
វិធាន ៤៖ ប្រសិនបើ priority(A) = Priority(B), A&B ត្រូវបានចាប់ផ្តើមដោយប្រើ RR
វិធាន ៤៖ នៅពេលដែលកិច្ចការមួយចូលទៅក្នុងប្រព័ន្ធ វាត្រូវបានដាក់ក្នុងជួរអាទិភាពខ្ពស់បំផុត។
វិធាន ៤៖ បន្ទាប់ពីកិច្ចការមួយបានប្រើពេលវេលាដែលបានបែងចែករបស់វានៅក្នុងជួរបច្ចុប្បន្ន (មិនថាវាបើកស៊ីភីយូប៉ុន្មានដងទេ) អាទិភាពនៃកិច្ចការនោះត្រូវបានបន្ទាប (វាផ្លាស់ទីចុះក្រោម)។
វិធាន ៤៖ បន្ទាប់ពីកំឡុងពេលជាក់លាក់ S សូមផ្លាស់ទីកិច្ចការទាំងអស់នៅក្នុងប្រព័ន្ធទៅជួរខ្ពស់បំផុត។

MLFQ គឺគួរឱ្យចាប់អារម្មណ៍សម្រាប់ហេតុផលខាងក្រោម - ជំនួសឱ្យការទាមទារចំណេះដឹងអំពី
ធម្មជាតិនៃកិច្ចការជាមុន ក្បួនដោះស្រាយសិក្សាពីឥរិយាបថអតីតកាលនៃភារកិច្ច និងសំណុំ
អាទិភាពតាម។ ដូច្នេះហើយ គាត់ព្យាយាមអង្គុយលើកៅអីពីរក្នុងពេលតែមួយ ដើម្បីសម្រេចបាននូវផលិតភាពសម្រាប់កិច្ចការតូចៗ (SJF, STCF) និងដើម្បីដំណើរការដោយស្មោះត្រង់។
ការងារផ្ទុកស៊ីភីយូ។ ដូច្នេះប្រព័ន្ធជាច្រើនរួមទាំង BSD និងនិស្សន្ទវត្ថុរបស់ពួកគេ
Solaris, Windows, Mac ប្រើទម្រង់មួយចំនួននៃក្បួនដោះស្រាយជាអ្នកកំណត់ពេល
MLFQ ជាមូលដ្ឋាន។

សំភារៈបន្ថែម៖

ប្រភព: www.habr.com

ប្រព័ន្ធប្រតិបត្តិការ៖ បីផ្នែកងាយស្រួល។ ផ្នែកទី 5៖ ការធ្វើផែនការ៖ ជួរមតិយោបល់ពហុកម្រិត (ការបកប្រែ)