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

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

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

• ដើម៖ pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• ដើម៖ github.com/remzi-arpacidusseau/ostep-code
• ការសម្របខ្លួនផ្ទាល់ខ្លួនរបស់ខ្ញុំ៖ github.com/bykvaadm/OS/tree/master/ostep

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

• ផ្នែកទី 1: ការណែនាំ

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

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

នេះលើកឡើងពីបញ្ហា៖ របៀបផ្តល់ការបំភាន់នៃ CPU ជាច្រើន? តើ OS អាចបង្កើតការបំភាន់នៃចំនួន CPU ស្ទើរតែគ្មានកំណត់បានដោយរបៀបណា បើទោះបីជាអ្នកមាន CPU តែមួយក៏ដោយ?

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

អរូបី៖ ដំណើរការ

អរូបីនៃកម្មវិធីដែលកំពុងដំណើរការដែលដំណើរការដោយប្រព័ន្ធប្រតិបត្តិការគឺជាអ្វីដែលយើងហៅថា ដំណើរការ. ដូចដែលបានរៀបរាប់ខាងលើ ដំណើរការគឺគ្រាន់តែជាកម្មវិធីដែលកំពុងដំណើរការ នៅគ្រប់ពេលភ្លាមៗ។ កម្មវិធី​ដែល​យើង​អាច​ទទួល​បាន​ព័ត៌មាន​សង្ខេប​ពី​ធនធាន​ប្រព័ន្ធ​ផ្សេងៗ​ដែល​កម្មវិធី​នេះ​ចូល​ប្រើ​ ឬ​ប៉ះពាល់​ក្នុង​អំឡុង​ពេល​ប្រតិបត្តិ​របស់វា។
ដើម្បីយល់ពីធាតុផ្សំនៃដំណើរការ អ្នកត្រូវយល់ពីស្ថានភាពនៃប្រព័ន្ធ៖ អ្វីដែលកម្មវិធីអាចអាន ឬផ្លាស់ប្តូរកំឡុងពេលប្រតិបត្តិការរបស់វា។ នៅពេលណាមួយ អ្នកត្រូវយល់ថាធាតុណាមួយនៃប្រព័ន្ធមានសារៈសំខាន់សម្រាប់ការប្រតិបត្តិនៃកម្មវិធី។
ធាតុជាក់ស្តែងមួយនៃប្រព័ន្ធបញ្ជាក់ថាដំណើរការរួមមាន ការចងចាំ. ការណែនាំមានទីតាំងនៅក្នុងការចងចាំ។ ទិន្នន័យដែលកម្មវិធីអាន ឬសរសេរក៏ស្ថិតនៅក្នុងអង្គចងចាំផងដែរ។ ដូច្នេះអង្គចងចាំដែលដំណើរការអាចដោះស្រាយបាន (ហៅថាលំហអាសយដ្ឋាន) គឺជាផ្នែកមួយនៃដំណើរការ។
ផ្នែកមួយនៃស្ថានភាពប្រព័ន្ធគឺជាការចុះឈ្មោះ។ ការណែនាំជាច្រើនមានគោលបំណងផ្លាស់ប្តូរតម្លៃនៃការចុះឈ្មោះ ឬការអានតម្លៃរបស់ពួកគេ ហើយដូច្នេះការចុះឈ្មោះក៏ក្លាយជាផ្នែកសំខាន់នៃប្រតិបត្តិការនៃដំណើរការនេះ។
គួរកត់សម្គាល់ថាស្ថានភាពម៉ាស៊ីនក៏ត្រូវបានបង្កើតឡើងពីការចុះឈ្មោះពិសេសមួយចំនួនផងដែរ។ ឧទាហរណ៍, IP - ទ្រនិចការណែនាំ - ចង្អុលទៅការណែនាំដែលកម្មវិធីកំពុងដំណើរការ។ ក៏មានដែរ។ ទ្រនិចទ្រនិច និងទាក់ទងនឹងវា។ ទ្រនិចស៊ុមដែលត្រូវបានប្រើដើម្បីគ្រប់គ្រង៖ ប៉ារ៉ាម៉ែត្រមុខងារ អថេរមូលដ្ឋាន និងអាសយដ្ឋានត្រឡប់។
ជាចុងក្រោយ កម្មវិធីតែងតែចូលប្រើ ROM (អង្គចងចាំបានតែអាន)។ ព័ត៌មាន “I/O” (បញ្ចូល/លទ្ធផល) នេះគួរតែរួមបញ្ចូលបញ្ជីឯកសារដែលបើកដោយដំណើរការ។

API ដំណើរការ

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

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

ដំណើរការបង្កើត៖ ព័ត៌មានលម្អិត

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

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

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

ប្រព័ន្ធប្រតិបត្តិការក៏អាចបែងចែកអង្គចងចាំមួយចំនួនទៅហ៊ាកម្មវិធីផងដែរ។ heap ត្រូវបានប្រើដោយកម្មវិធីដើម្បីស្នើសុំយ៉ាងច្បាស់លាស់នូវទិន្នន័យដែលបានបែងចែកថាមវន្ត. កម្មវិធីស្នើសុំកន្លែងនេះដោយហៅមុខងារ malloc () ហើយជម្រះវាយ៉ាងច្បាស់ដោយហៅមុខងារ ឥតគិតថ្លៃ (). heap ត្រូវការសម្រាប់រចនាសម្ព័ន្ធទិន្នន័យ ដូចជាសន្លឹកដែលបានភ្ជាប់ តារាងសញ្ញា ដើមឈើ និងផ្សេងៗទៀត។ ដំបូង អង្គចងចាំមួយចំនួនតូចត្រូវបានបែងចែកទៅហ៊ា ប៉ុន្តែយូរៗទៅ នៅពេលដែលកម្មវិធីដំណើរការ ហេបអាចស្នើសុំអង្គចងចាំបន្ថែមតាមរយៈបណ្ណាល័យ API call malloc()។ ប្រព័ន្ធប្រតិបត្តិការត្រូវបានចូលរួមនៅក្នុងដំណើរការនៃការបែងចែកអង្គចងចាំបន្ថែមទៀតដើម្បីជួយបំពេញការហៅទូរស័ព្ទទាំងនេះ។

ប្រព័ន្ធប្រតិបត្តិការក៏នឹងអនុវត្តការងារចាប់ផ្តើមផងដែរ ជាពិសេសការងារដែលទាក់ទងនឹង I/O ។ ឧទាហរណ៍ នៅលើប្រព័ន្ធយូនីក ដំណើរការនីមួយៗតាមលំនាំដើមមានកម្មវិធីពណ៌នាឯកសារបើកចំហចំនួន 3 សម្រាប់បញ្ចូល លទ្ធផល និងកំហុសស្តង់ដារ។ ចំណុចទាញទាំងនេះអនុញ្ញាតឱ្យកម្មវិធីអានការបញ្ចូលពីស្ថានីយ ក៏ដូចជាបង្ហាញព័ត៌មាននៅលើអេក្រង់។

ដូច្នេះដោយការផ្ទុកកូដ និងទិន្នន័យឋិតិវន្តទៅក្នុងអង្គចងចាំ បង្កើត និងចាប់ផ្តើមជង់ និងធ្វើការងារផ្សេងទៀតដែលទាក់ទងនឹងការអនុវត្តភារកិច្ច I/O OS រៀបចំដំណាក់កាលសម្រាប់ដំណើរការដើម្បីប្រតិបត្តិ។ ទីបំផុត មានកិច្ចការចុងក្រោយមួយដែលនៅសល់៖ ដំណើរការកម្មវិធីតាមរយៈចំណុចចូលរបស់វា ដែលហៅថាមុខងារ main()។ ដោយការប្រតិបត្តិមុខងារ main() OS ផ្ទេរការគ្រប់គ្រង CPU ទៅដំណើរការដែលបានបង្កើតថ្មី ដូច្នេះកម្មវិធីចាប់ផ្តើមប្រតិបត្តិ។

ស្ថានភាពដំណើរការ

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

អ្នកអាចស្រមៃមើលរដ្ឋទាំងនេះក្នុងទម្រង់ជាក្រាហ្វ។ ដូចដែលយើងឃើញក្នុងរូបភាព ស្ថានភាពដំណើរការអាចផ្លាស់ប្តូររវាង RUNNING និង READY តាមការសម្រេចចិត្តរបស់ OS។ នៅពេលដែលស្ថានភាពនៃដំណើរការផ្លាស់ប្តូរពី READY ទៅ RUNNING វាមានន័យថាដំណើរការត្រូវបានកំណត់ពេលហើយ។ ក្នុងទិសដៅផ្ទុយ - ដកចេញពីប្លង់។ នៅពេលនេះនៅពេលដែលដំណើរការមួយត្រូវបានរារាំង ជាឧទាហរណ៍ ខ្ញុំចាប់ផ្តើមប្រតិបត្តិការ IO នោះ OS នឹងរក្សាវានៅក្នុងស្ថានភាពនេះរហូតដល់ព្រឹត្តិការណ៍មួយចំនួនកើតឡើង ឧទាហរណ៍ការបញ្ចប់ IO ។ នៅពេលនេះ ការផ្លាស់ប្តូរទៅស្ថានភាព READY ហើយអាចភ្លាមៗទៅកាន់ស្ថានភាព RUNNING ប្រសិនបើ OS សម្រេចចិត្តដូច្នេះ។
សូមក្រឡេកមើលឧទាហរណ៍អំពីរបៀបដែលដំណើរការពីរឆ្លងកាត់រដ្ឋទាំងនេះ។ ដើម្បីចាប់ផ្តើម សូមស្រមៃថាដំណើរការទាំងពីរកំពុងដំណើរការ ហើយនីមួយៗគឺប្រើតែ CPU ប៉ុណ្ណោះ។ ក្នុងករណីនេះរដ្ឋរបស់ពួកគេនឹងមើលទៅដូចនេះ។

ក្នុងឧទាហរណ៍ខាងក្រោម ដំណើរការដំបូង បន្ទាប់ពីដំណើរការមួយរយៈ ស្នើសុំ IO ហើយចូលទៅក្នុងស្ថានភាព BLOCKED ដែលអនុញ្ញាតឱ្យដំណើរការផ្សេងទៀតដំណើរការ (រូបភាព 1.4) ។ OS មើលឃើញថាដំណើរការ 0 មិនប្រើស៊ីភីយូ ហើយចាប់ផ្តើមដំណើរការ 1។ ខណៈពេលដែលដំណើរការ 1 កំពុងដំណើរការ IO ត្រូវបានបញ្ចប់ ហើយស្ថានភាពនៃដំណើរការ 0 ផ្លាស់ប្តូរទៅជា READY ។ ជាចុងក្រោយ ដំណើរការ 1 បានបញ្ចប់ ហើយនៅពេលបញ្ចប់ ដំណើរការ 0 ចាប់ផ្តើម ប្រតិបត្តិ និងបញ្ចប់ការងាររបស់វា។

រចនាសម្ព័ន្ធទិន្នន័យ

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

ឧទាហរណ៍ OS ត្រូវតែរក្សាស្ថានភាពនៃការចុះឈ្មោះរបស់ processor ។ នៅពេលដំណើរការឈប់ ស្ថានភាពនៃការចុះឈ្មោះត្រូវបានរក្សាទុកក្នុងចន្លោះអាសយដ្ឋាននៃដំណើរការ ហើយនៅពេលនេះប្រតិបត្តិការរបស់វាបន្ត តម្លៃនៃការចុះឈ្មោះត្រូវបានស្ដារឡើងវិញ ហើយដូច្នេះបន្តការប្រតិបត្តិនៃដំណើរការនេះ។

បន្ថែមពីលើស្ថានភាពដែលត្រៀមរួចជាស្រេច ទប់ស្កាត់ និងកំពុងដំណើរការ មានរដ្ឋមួយចំនួនទៀត។ ពេលខ្លះនៅពេលបង្កើត ដំណើរការមួយអាចស្ថិតក្នុងស្ថានភាព INIT។ ជាចុងក្រោយ ដំណើរការមួយអាចត្រូវបានដាក់ក្នុងស្ថានភាព FINAL នៅពេលដែលវាបានបញ្ចប់រួចហើយ ប៉ុន្តែព័ត៌មានរបស់វាមិនទាន់ត្រូវបានជម្រះនៅឡើយ។ នៅលើប្រព័ន្ធយូនីក រដ្ឋនេះត្រូវបានគេហៅថា ដំណើរការ zombie. ស្ថានភាពនេះមានប្រយោជន៍សម្រាប់ករណីដែលដំណើរការមាតាបិតាចង់ដឹងអំពីលេខកូដត្រឡប់មកវិញរបស់កូន ជាឧទាហរណ៍ ជាធម្មតា 0 ផ្តល់សញ្ញាថាជោគជ័យ និង 1 កំហុស ប៉ុន្តែអ្នកសរសេរកម្មវិធីអាចចេញលេខកូដលទ្ធផលបន្ថែមដើម្បីបង្ហាញបញ្ហាផ្សេងៗ។ នៅពេលដែលដំណើរការមេត្រូវបានបញ្ចប់ វាធ្វើការហៅជាប្រព័ន្ធចុងក្រោយដូចជា wait() ដើម្បីរង់ចាំដំណើរការកូនត្រូវបញ្ចប់ ហើយផ្តល់សញ្ញាទៅ OS ថាវាអាចសម្អាតទិន្នន័យណាមួយដែលទាក់ទងនឹងដំណើរការដែលត្រូវបានបញ្ចប់។

ចំណុចសំខាន់ៗនៃមេរៀន៖

● ដំណើរការ - អរូបីសំខាន់នៃកម្មវិធីដែលកំពុងដំណើរការនៅក្នុង OS ។ នៅពេលណាមួយ ដំណើរការអាចត្រូវបានពិពណ៌នាដោយស្ថានភាពរបស់វា៖ ខ្លឹមសារនៃអង្គចងចាំក្នុងទំហំអាសយដ្ឋានរបស់វា មាតិកានៃដំណើរការចុះឈ្មោះ រួមទាំងទ្រនិចការណែនាំ និងទ្រនិចជង់ និងព័ត៌មាន IO ដូចជាឯកសារបើកដែលកំពុងអាន ឬសរសេរ។
● API ដំណើរការ រួមមានការហៅទូរសព្ទដែលកម្មវិធីអាចដំណើរការបាន។ ជាធម្មតា ទាំងនេះគឺជាការបង្កើត លុប ឬការហៅទូរសព្ទផ្សេងទៀត។
● ដំណើរការស្ថិតនៅក្នុងរដ្ឋមួយក្នុងចំណោមរដ្ឋជាច្រើន រួមទាំងការដំណើរការ រួចរាល់ ដែលត្រូវបានរារាំង។ ព្រឹត្តិការណ៍ផ្សេងៗដូចជាកាលវិភាគ ការលើកលែងពីការកំណត់ពេល ឬការរង់ចាំអាចផ្លាស់ប្តូរស្ថានភាពនៃដំណើរការពីមួយទៅមួយទៀត។
● បញ្ជីដំណើរការ មានព័ត៌មានអំពីដំណើរការទាំងអស់នៅក្នុងប្រព័ន្ធ។ ធាតុនីមួយៗនៅក្នុងវាត្រូវបានគេហៅថាប្លុកត្រួតពិនិត្យដំណើរការ ដែលតាមពិតគឺជារចនាសម្ព័ន្ធដែលមានព័ត៌មានចាំបាច់ទាំងអស់អំពីដំណើរការជាក់លាក់មួយ។ 

ប្រភព: www.habr.com