ប្រព័ន្ធប្រតិបត្តិការ

មាតិកា

1. អ្នកគ្រប់គ្រងអ្វីៗទាំងអស់
2. ការងារធំៗទាំងបួន
3. Kernel
4. Driver
5. User Mode និង Kernel Mode
6. System Call៖ ការសុំជំនួយពី OS
7. អ្វីកើតឡើងនៅពេលអ្នកបើកកុំព្យូទ័រ
8. Windows, macOS និង Linux
9. សាកល្បងដោយខ្លួនឯង

1. អ្នកគ្រប់គ្រងអ្វីៗទាំងអស់

ឥឡូវនេះ កុំព្យូទ័ររបស់អ្នកកំពុងដំណើរការកម្មវិធីរាប់សិប — ប្រហែលជារាប់រយ — ក្នុងពេលតែមួយ៖ browser កម្មវិធីចាក់តន្ត្រី កម្មវិធីជជែក កម្មវិធី update នៅផ្ទៃខាងក្រោយ និងកម្មវិធីជាច្រើនទៀតដែលអ្នកមិនធ្លាប់ឮឈ្មោះ។ ពួកវាទាំងអស់ត្រូវការ CPU ដូចគ្នា RAM ដូចគ្នា disk ដូចគ្នា និងអេក្រង់ដូចគ្នា។

បើគ្មាននរណាម្នាក់ទទួលបន្ទុកទេ វានឹងវឹកវរ៖ កម្មវិធីពីរសរសេរទៅផ្នែកដូចគ្នានៃ RAM កម្មវិធីមួយកាន់ CPU រហូត កម្មវិធីណាក៏អាចអានពាក្យសម្ងាត់របស់កម្មវិធីផ្សេងបាន។

ប្រព័ន្ធប្រតិបត្តិការ (OS) គឺជាអ្នកទទួលបន្ទុក។ វាជាស្រទាប់ software នៅចន្លោះ hardware និងកម្មវិធីនីមួយៗ (ចាំដ្យាក្រាមស្រទាប់ពីជំពូកទី 1)។ ការងាររបស់វាគឺ គ្រប់គ្រង hardware ហើយចែករំលែកវាដោយសុវត្ថិភាព និងយុត្តិធម៌រវាងកម្មវិធីនានា។

2. ការងារធំៗទាំងបួន

អ្វីដែលប្រព័ន្ធប្រតិបត្តិការធ្វើភាគច្រើន ធ្លាក់ក្នុងបួនផ្នែក៖

បន្ថែមពីលើនោះ ប្រព័ន្ធប្រតិបត្តិការភាគច្រើនមកជាមួយ ផ្ទាំងអ្នកប្រើប្រាស់ (user interface) — desktop, window និង taskbar លើ laptop ឬអេក្រង់ដើមលើទូរស័ព្ទ — និងកម្មវិធីដែលភ្ជាប់មកស្រាប់មួយចំនួន។ ប៉ុន្តែទាំងនោះគ្រាន់តែជាផ្នែកដែលមើលឃើញ ការងារពិតប្រាកដកើតឡើងនៅខាងក្រោម។

3. Kernel

ស្នូលនៃប្រព័ន្ធប្រតិបត្តិការត្រូវបានហៅថា kernel។ វាជាផ្នែកដំបូងនៃ OS ដែល load នៅពេលកុំព្យូទ័រចាប់ផ្តើម ហើយវានៅក្នុង memory ពេញមួយរយៈពេលដែលកុំព្យូទ័របើក។

Kernel គឺជា software តែមួយគត់ដែលត្រូវបានអនុញ្ញាតឲ្យគ្រប់គ្រង hardware ដោយផ្ទាល់។ អ្វីៗផ្សេងទៀតទាំងអស់ — រួមទាំងផ្នែកនៃ OS ដែលអ្នកមើលឃើញ ដូចជា desktop ឬ file manager — គឺជាកម្មវិធីធម្មតាដែលត្រូវសុំ kernel នូវអ្វីដែលវាត្រូវការ។

OS ធំៗនីមួយៗមាន kernel ផ្ទាល់ខ្លួន៖

• Windows — Windows NT kernel
• macOS និង iOS — XNU
• Linux distribution (Ubuntu, Debian, Fedora…) និង Android — Linux kernel

ចំណុចចុងក្រោយនោះធ្វើឲ្យមនុស្សភ្ញាក់ផ្អើល៖ ទូរស័ព្ទ Android គ្រប់គ្រឿងដំណើរការ Linux kernel។ Cloud server ស្ទើរតែទាំងអស់ក៏ដូច្នោះដែរ — ហើយ Docker container គ្រប់ៗនៅលើម៉ាស៊ីនរបស់អ្នក ក៏ចែករំលែក Linux kernel មួយដែរ។

4. Driver

មានម៉ាស៊ីនបោះពុម្ព graphics card, Wi-Fi chip និង webcam ខុសៗគ្នារាប់ពាន់ ហើយនីមួយៗត្រូវបានគ្រប់គ្រងខុសគ្នា។ Kernel មិនអាចដឹងពីពួកវាទាំងអស់ជាមុនបានទេ។

Driver គឺជា software តូចមួយដែលបង្រៀនប្រព័ន្ធប្រតិបត្តិការពីរបៀបនិយាយជាមួយឧបករណ៍ជាក់លាក់មួយ។ ក្រុមហ៊ុនផលិត graphics card សរសេរ graphics driver ក្រុមហ៊ុនម៉ាស៊ីនបោះពុម្ពសរសេរ printer driver។

នេះហើយជាអ្វីដែលធ្វើឲ្យការរចនាជាស្រទាប់ដំណើរការ។ កម្មវិធីមួយនិយាយថា «បោះពុម្ពទំព័រនេះ» OS បញ្ជូន request ទៅកាន់ printer driver ណាដែលបានដំឡើង driver និយាយភាសាជាក់លាក់របស់ម៉ាស៊ីនបោះពុម្ពនោះ។ កម្មវិធីមិនចាំបាច់ដឹងថាអ្នកមានម៉ាស៊ីនបោះពុម្ពប្រភេទណាទេ។

នៅពេលឧបករណ៍មួយ «មិនដំណើរការ» បន្ទាប់ពីអ្នកដោតវាចូល ផ្នែកដែលបាត់ជាញឹកញាប់គឺ driver។

5. User Mode និង Kernel Mode

CPU ខ្លួនវាផ្ទាល់ជួយឲ្យ OS រក្សាអំណាចគ្រប់គ្រង។ វាអាចដំណើរការក្នុងពីរ mode៖

• Kernel mode — សិទ្ធិចូលប្រើ memory ទាំងអស់ និង hardware ទាំងអស់ពេញលេញ។ មានតែ kernel ប៉ុណ្ណោះដែលដំណើរការបែបនេះ។
• User mode — មានកម្រិត។ កម្មវិធីអាចប្រើ memory ផ្ទាល់ខ្លួន និងគណនាបាន ប៉ុន្តែពួកវា មិនអាច ប៉ះ hardware ឬ memory របស់កម្មវិធីផ្សេងដោយផ្ទាល់បានទេ។

គ្រប់កម្មវិធីដែលអ្នកដំណើរការ — browser, editor, កូដរបស់អ្នកផ្ទាល់ — ដំណើរការក្នុង user mode។ បើកម្មវិធី user-mode មួយព្យាយាមធ្វើអ្វីដែលហាមឃាត់ CPU បញ្ឈប់វា ហើយប្រគល់ការគ្រប់គ្រងទៅ kernel ដែលជាធម្មតាបញ្ចប់កម្មវិធីនោះ។ នោះហើយជាមូលហេតុដែលកម្មវិធីមួយ crash ស្ទើរតែមិនដែលធ្វើឲ្យកុំព្យូទ័រទាំងមូលគាំងទេ។

នៅពេលអ្វីមួយ ពិតជា crash ក្នុង kernel mode — ជាញឹកញាប់គឺ driver ដែលមាន bug — គ្មានអ្វីនៅខាងលើវាដើម្បីចាប់បញ្ហានោះទេ។ នោះគឺជា «អេក្រង់ខៀវ (blue screen)» ដ៏ល្បីរបស់ Windows ឬ «kernel panic» លើ macOS និង Linux។

6. System Call៖ ការសុំជំនួយពី OS

បើកម្មវិធីមិនអាចប៉ះ hardware បាន តើអ្វីៗត្រូវបានធ្វើដោយរបៀបណា? តើ text editor របស់អ្នករក្សាទុក file ដោយរបៀបណា ឬ browser របស់អ្នកបើកការតភ្ជាប់បណ្តាញដោយរបៀបណា?

ពួកវាសុំ kernel តាមរយៈ system call (ឬ syscall) — សំណើផ្លូវការមួយទៅកាន់ប្រព័ន្ធប្រតិបត្តិការ។ មាន system call សម្រាប់រឿងដូចជា៖

• open, read និង write file មួយ
• ចាប់ផ្តើម កម្មវិធីថ្មីមួយ ឬ exit
• allocate memory បន្ថែម
• បើក ការតភ្ជាប់បណ្តាញ ហើយ ផ្ញើ ឬ ទទួល ទិន្នន័យ

ដូច្នេះ នៅពេលកូដ JavaScript របស់អ្នកធ្វើដូចនេះ៖

fs.readFileSync("notes.txt");

Node.js បំលែងវាទៅជា system call៖ open file, read byte របស់វា, close វា។ Kernel ពិនិត្យ permission របស់អ្នក ឲ្យ file system និង disk driver ទៅយកទិន្នន័យ ចម្លងវាចូលទៅក្នុង memory របស់កម្មវិធីអ្នក ហើយប្រគល់ការគ្រប់គ្រងត្រឡប់ទៅកូដរបស់អ្នកវិញ។ អ្នកសរសេរតែមួយបន្ទាត់ តែ OS បានធ្វើការងារយ៉ាងយកចិត្តទុកដាក់ជាច្រើនជំនួសអ្នក។

គ្រប់រឿងដែលមានប្រយោជន៍ដែលកម្មវិធីមួយធ្វើ — បង្ហាញអក្សរ រក្សាទុក file និយាយជាមួយបណ្តាញ — នៅទីបំផុតឆ្លងកាត់ system call។

7. អ្វីកើតឡើងនៅពេលអ្នកបើកកុំព្យូទ័រ

ការចាប់ផ្តើមកុំព្យូទ័រត្រូវបានហៅថា booting (មកពីឃ្លា «pulling yourself up by your bootstraps» — កុំព្យូទ័រត្រូវ load software ដែល load software)។ ក្នុងទម្រង់សាមញ្ញ៖

1. បើកភ្លើង។ CPU ចាប់ផ្តើមដំណើរការកម្មវិធីតូចមួយដែលរក្សាទុកក្នុង chip មួយលើ motherboard ហៅថា firmware (UEFI ឬ BIOS លើម៉ាស៊ីនចាស់ៗ)។
2. ពិនិត្យ hardware។ Firmware ពិនិត្យរបស់មូលដ្ឋាន — មាន RAM ទេ មាន disk ទេ — ហើយរក drive ដើម្បី boot ពីវា។
3. Bootloader។ Firmware load កម្មវិធីតូចមួយពី disk ហៅថា bootloader ដែលការងារតែមួយគត់របស់វាគឺស្វែងរក និង load ប្រព័ន្ធប្រតិបត្តិការ។
4. Kernel ចាប់ផ្តើម។ Bootloader load kernel ចូល RAM ហើយប្រគល់ការគ្រប់គ្រង។ Kernel រៀបចំការគ្រប់គ្រង memory, load driver និង mount file system។
5. Process ដំបូង។ Kernel ចាប់ផ្តើមកម្មវិធី user-mode ដំបូងបង្អស់ (លើ Linux ជាធម្មតាគឺ systemd) ដែលបន្ទាប់មកចាប់ផ្តើម service ផ្ទៃខាងក្រោយទាំងអស់។
6. Login។ ចុងក្រោយ អេក្រង់ login លេចឡើង ហើយបន្ទាប់ពីអ្នកចូល desktop និងកម្មវិធីចាប់ផ្តើមរបស់អ្នក load។

ទាំងអស់នេះជាធម្មតាចំណាយពេលតែពីរបីវិនាទីលើ SSD សម័យថ្មី — hard drive ធ្វើឲ្យវាយឺតជាងនេះច្រើន ហេតុនេះហើយការ upgrade laptop ចាស់ទៅ SSD ធ្វើឲ្យមានភាពខុសគ្នាខ្លាំង។

8. Windows, macOS និង Linux

ប្រព័ន្ធប្រតិបត្តិការ desktop ទាំងបីដែលអ្នកនឹងជួបក្នុងនាមជាអ្នកអភិវឌ្ឍន៍៖

macOS និង Linux មានដើមកំណើតរួមគ្នាពី Unix ដូច្នេះពួកវាមានឥរិយាបថស្រដៀងគ្នាខ្លាំងក្នុង terminal — command ដូចគ្នា path ប្រើ slash និង permission model ដូចគ្នា។ Windows ខុសគ្នា ប៉ុន្តែឧបករណ៍ដូចជា WSL (Windows Subsystem for Linux) អនុញ្ញាតឲ្យអ្នកដំណើរការបរិស្ថាន Linux ពិតប្រាកដនៅខាងក្នុង Windows។

ហេតុអ្វីរឿងនេះសំខាន់សម្រាប់អ្នក៖ server ភាគច្រើនដំណើរការ Linux។ ទោះបីអ្នកអភិវឌ្ឍលើ Windows ឬ macOS ក៏ដោយ កូដដែលអ្នក deploy ទំនងជានឹងដំណើរការលើ Linux kernel — ដោយផ្ទាល់ ឬនៅខាងក្នុង Docker container។

9. សាកល្បងដោយខ្លួនឯង

1. ស្វែងរកឈ្មោះ និង version OS របស់អ្នក៖
   • Windows៖ Settings → System → About
   • macOS៖ ម៉ឺនុយ Apple → About This Mac
   • Linux៖ រត់ uname -a ក្នុង terminal — លទ្ធផលរួមមាន version របស់ kernel
2. មើល driver របស់អ្នក៖
   • Windows៖ ចុចស្តាំលើប៊ូតុង Start → Device Manager។ ពង្រីកប្រភេទមួយចំនួន — ឧបករណ៍នីមួយៗដែលបានរាយមាន driver មួយ។
   • macOS៖ ម៉ឺនុយ Apple → About This Mac → More Info → System Report។
3. វាស់ពេលវេលានៃការ boot លើកក្រោយរបស់អ្នក ចាប់ពីការចុចប៊ូតុងថាមពល រហូតដល់ឃើញអេក្រង់ login។ ឥឡូវអ្នកដឹងពីជំហានទាំងប្រាំមួយដែលកើតឡើងក្នុងវិនាទីទាំងនោះហើយ។

ប្រព័ន្ធប្រតិបត្តិការដំណើរការកម្មវិធី — ប៉ុន្តែតើកម្មវិធីដែល កំពុងដំណើរការ ពិតជាអ្វី? នោះគឺជាជំពូកបន្ទាប់។