ដាក់អ្វីៗទាំងអស់បញ្ចូលគ្នា
មាតិកា
- ការចុចមួយដង ពីដើមដល់ចប់
- ជំហានទី 1៖ ការចុច
- ជំហានទី 2៖ ការចាប់ផ្តើមកម្មវិធី
- ជំហានទី 3៖ ការដំណើរការ
- ជំហានទី 4៖ ការ Load ទំព័រ
- ជំហានទី 5៖ Pixel លើអេក្រង់
- ជំហានទី 6៖ ការបិទកម្មវិធី
- ស៊េរីទាំងមូលក្នុងមួយទំព័រ
- ទៅណាបន្ទាប់
1. ការចុចមួយដង ពីដើមដល់ចប់
អ្នកចុចពីរដងលើ web browser របស់អ្នក ហើយមួយភ្លែតក្រោយមក គេហទំព័រមួយលេចឡើង។ វាមើលទៅដូចជាសកម្មភាពសាមញ្ញមួយ។ តាមពិត ស្ទើរតែគ្រប់ផ្នែកនៃកុំព្យូទ័រដែលអ្នកបានរៀនក្នុងស៊េរីនេះ ចូលរួមក្នុងសកម្មភាពនេះ។
សូមបន្ថយល្បឿនវា ហើយតាមដានវាពីដើមដល់ចប់។
2. ជំហានទី 1៖ ការចុច
- អ្នកចុចប៊ូតុងកណ្តុរ។ កណ្តុរផ្ញើសញ្ញាទៅកុំព្យូទ័រ — នេះគឺជា input (ជំពូកទី 1)។
- Hardware របស់កណ្តុរបង្កើត interrupt (ជំពូកទី 9)។ CPU ផ្អាកអ្វីដែលវាកំពុងធ្វើ ហើយដំណើរការ driver របស់កណ្តុរ (ជំពូកទី 6) ដែលអានព្រឹត្តិការណ៍នោះ៖ «ប៊ូតុងត្រូវបានចុចនៅទីតាំងនេះ»។
- Kernel បញ្ជូនព្រឹត្តិការណ៍នោះទៅ process ដែលគូរ desktop របស់អ្នក។ Process នោះគឺជាកម្មវិធី user-mode ធម្មតា (ជំពូកទី 6) វាដឹងថាអ្នកបានចុចពីរដងលើរូបតំណាងរបស់ browser។
3. ជំហានទី 2៖ ការចាប់ផ្តើមកម្មវិធី
- Desktop សុំ OS ឲ្យចាប់ផ្តើម browser តាមរយៈ system call (ជំពូកទី 6)។
- OS រក file កម្មវិធីរបស់ browser នៅលើ disk តាមរយៈ file system (ជំពូកទី 5) ដោយធ្វើតាម path របស់វា ហើយពិនិត្យថាអ្នកមាន permission ដើម្បីដំណើរការវា។
- OS បង្កើត process ថ្មីមួយ (ជំពូកទី 7)៖ វាផ្តល់ PID មួយ រៀបចំ virtual memory ឯកជនមួយ ហើយកត់ត្រា desktop ជា parent។
- Machine code របស់កម្មវិធី (ជំពូកទី 3) ត្រូវបានចម្លងពី storage ចូល RAM (ជំពូកទី 4)។ ជំហាននេះហើយជាមូលហេតុដែលកម្មវិធីបើកលឿនជាងលើ SSD ហើយលឿនជាងនេះទៀតនៅលើកទីពីរ នៅពេលផ្នែកខ្លះត្រូវបាន cache ក្នុង RAM រួចហើយ។
4. ជំហានទី 3៖ ការដំណើរការ
- Scheduler (ជំពូកទី 7) ផ្តល់វេនដល់ main thread របស់ process ថ្មីលើ CPU core មួយ។
- CPU ចាប់ផ្តើមវដ្ត fetch–decode–execute (ជំពូកទី 3) លើ instruction របស់ browser ដោយទាញទិន្នន័យពី RAM ចូល cache និង register នៅពេលវាដំណើរការ (ជំពូកទី 4)។
- Browser បង្កើត process បន្ថែម — មួយសម្រាប់ tab នីមួយៗ និងសម្រាប់ជំនួយការរបស់វា — និង thread បន្ថែមនៅខាងក្នុងពួកវា (ជំពូកទី 8) ដើម្បីឲ្យ core ផ្សេងៗអាចធ្វើការ ស្របគ្នា (parallel)។
- វាអានការកំណត់ bookmark និងប្រវត្តិរបស់វាពី file នៅលើ disk (ជំពូកទី 5) — ការអាននីមួយៗគឺជា I/O តាមរយៈ system call (ជំពូកទី 9)។
5. ជំហានទី 4៖ ការ Load ទំព័រ
- Browser បើកទំព័រដើមរបស់វា ដែលស្ថិតនៅលើកុំព្យូទ័រមួយផ្សេងទៀត។ វាសុំ socket បណ្តាញពី OS (ជំពូកទី 9) ហើយផ្ញើ request មួយ។
- នេះគឺជាផ្នែកយឺតបំផុតនៃដំណើរទាំងមូល — នៅកម្រិត «មួយវិនាទីក្នុងមួយ register» ពីជំពូកទី 4 វាគឺជាការរង់ចាំ ច្រើនឆ្នាំ។ ដូច្នេះ browser មិន block ទេ។ វាប្រើ non-blocking I/O និង event loop (ជំពូកទី 9) ដោយរក្សា window ឲ្យឆ្លើយតបខណៈពេលវារង់ចាំ។
- នៅពេលចម្លើយមកដល់ network card បង្កើត interrupt មួយ driver ប្រគល់ទិន្នន័យទៅ kernel ហើយ kernel បញ្ជូនវាទៅ process របស់ browser។
- ទំព័រមកដល់ជា byte (ជំពូកទី 2)៖ អក្សរត្រូវបាន decode ពី UTF-8 (ដូច្នេះអក្សរខ្មែរបង្ហាញបានត្រឹមត្រូវ) ហើយរូបភាពត្រូវបានពន្លាពី JPEG ឬ WebP ទៅជាក្រឡាចត្រង្គនៃ pixel RGB។
6. ជំហានទី 5៖ Pixel លើអេក្រង់
- Browser គណនាថាពាក្យ ប៊ូតុង និងរូបភាពនីមួយៗត្រូវនៅត្រង់ណា ហើយបង្កើតពណ៌ចុងក្រោយសម្រាប់ pixel រាប់លាន។
- តាមរយៈ OS និង graphics driver (ជំពូកទី 6) pixel ទាំងនោះត្រូវបានផ្ញើទៅ graphics hardware ហើយបន្ទាប់មកទៅអេក្រង់ — នេះគឺជា output (ជំពូកទី 1)។
- អេក្រង់ refresh ជាធម្មតា 60 ដង ឬច្រើនជាងនេះក្នុងមួយវិនាទី ហើយ loop ទាំងមូល — input, ដំណើរការ, រក្សាទុក, output — បន្តដំណើរការ ដរាបណាអ្នកនៅប្រើ browser។
ពីការចុចរបស់អ្នក រហូតដល់ទំព័រដែលមើលឃើញ ជាធម្មតាចំណាយពេលប្រហែលមួយវិនាទី។ ក្នុងរយៈពេលនោះ CPU បានដំណើរការ instruction រាប់ពាន់លាន។
7. ជំហានទី 6៖ ការបិទកម្មវិធី
- នៅពេលអ្នកបិទ window browser ទទួលបានសំណើឲ្យឈប់ — លើ Linux និង macOS ស្រដៀងនឹង SIGTERM (ជំពូកទី 7)។ វារក្សាទុក tab ដែលបើក និងប្រវត្តិរបស់អ្នកទៅក្នុង file (ជំពូកទី 5) មុនពេល exit។
- Process របស់វា exit ជាមួយ exit code 0 (ជោគជ័យ)។
- OS យក RAM គ្រប់ byte របស់ process ទាំងនោះមកវិញ បិទ file និងការតភ្ជាប់បណ្តាញរបស់ពួកវា ហើយដោះលែង PID របស់ពួកវា។
បើ browser បានគាំងជំនួសវិញ អ្នកអាច Force Quit វា — SIGKILL — ហើយ OS នៅតែសម្អាតអ្វីៗទាំងអស់ ប៉ុន្តែ tab ដែលមិនទាន់រក្សាទុករបស់អ្នក ដែលមានតែនៅក្នុង RAM (ជំពូកទី 4) នឹងបាត់។
8. ស៊េរីទាំងមូលក្នុងមួយទំព័រ
| ជំពូក | គំនិតតែមួយដែលត្រូវចងចាំ |
|---|---|
| 1. តើកុំព្យូទ័រជាអ្វី? | ម៉ាស៊ីនដែលធ្វើតាម instruction សាមញ្ញយ៉ាងលឿន ដែលសាងសង់ជាស្រទាប់៖ hardware → OS → កម្មវិធី |
| 2. Bit និង Byte | អ្វីៗទាំងអស់ — អក្សរ រូបភាព សំឡេង កម្មវិធី — ត្រូវបានរក្សាទុកជាលេខដែលបង្កើតពី bit |
| 3. CPU | Fetch, decode, execute, ធ្វើម្តងទៀត — រាប់ពាន់លានដងក្នុងមួយវិនាទី លើ core ជាច្រើន |
| 4. RAM ធៀបនឹង Storage | នៅជិត CPU គឺលឿន និងតូច នៅឆ្ងាយគឺយឺត និងធំ។ RAM ភ្លេចអ្វីៗនៅពេលបិទភ្លើង |
| 5. File និង File System | File គឺជាដុំ byte ដែលមានឈ្មោះ path គឺជាអាសយដ្ឋានរបស់វា extension គ្រាន់តែជាផ្នែកមួយនៃឈ្មោះ |
| 6. ប្រព័ន្ធប្រតិបត្តិការ | Kernel គ្រប់គ្រង hardware កម្មវិធីសុំជំនួយតាមរយៈ system call |
| 7. Process | កម្មវិធីដែលកំពុងដំណើរការ ដែលមាន PID ផ្ទាល់ខ្លួន និង memory ដាច់ដោយឡែកផ្ទាល់ខ្លួន |
| 8. Thread និង Concurrency | Thread ចែករំលែក memory នៅខាងក្នុង process មួយ — លឿន ប៉ុន្តែត្រូវប្រយ័ត្ន race condition |
| 9. Input/Output | I/O យឺត ដូច្នេះកម្មវិធីល្អមិនអង្គុយរង់ចាំវាទេ |
| 10. ដាក់បញ្ចូលគ្នា | ការចុចមួយដងប្រើគ្រប់ស្រទាប់ ហើយឥឡូវអ្នកអាចដាក់ឈ្មោះស្រទាប់នីមួយៗបាន |
9. ទៅណាបន្ទាប់
ឥឡូវអ្នកមានគំរូក្នុងចិត្តអំពីអ្វីដែលកើតឡើងនៅពីក្រោយគ្រប់កម្មវិធីដែលអ្នកនឹងសរសេរ។ នេះជារបៀបដែលវាភ្ជាប់ទៅនឹងអ្វីដែលមកបន្ទាប់នៅលើ ផែនទីការសិក្សា «ចាប់ផ្តើមនៅទីនេះ»៖
- មូលដ្ឋានគ្រឹះ Command Line — ជំហានបន្ទាប់។ អ្នកនឹងយក file, path, permission, process និង stdin/stdout មកប្រើផ្ទាល់ពី terminal។
- របៀបដែលគេហទំព័រដំណើរការ និង បណ្តាញសម្រាប់អ្នកអភិវឌ្ឍន៍ — អ្វីដែលកើតឡើងចំពោះ network request នោះ បន្ទាប់ពីវាចាកចេញពីកុំព្យូទ័ររបស់អ្នក។
- គណិតវិទ្យាសម្រាប់អ្នកសរសេរកម្មវិធី — ការគណនា binary និង hexadecimal នៅពីក្រោយជំពូកទី 2។
- មូលដ្ឋានគ្រឹះ JavaScript និង TypeScript — async code និង event loop ពីជំពូកទី 9 យ៉ាងស៊ីជម្រៅ។
- Docker CLI Tutorial — container គឺជា process ដាច់ដោយឡែកដែលចែករំលែក Linux kernel តែមួយ។ បន្ទាប់ពីស៊េរីនេះ ប្រយោគនោះគួរតែមានន័យសម្រាប់អ្នកហើយ។
លើកក្រោយដែលកម្មវិធីរបស់អ្នកយឺត crash ដោយ «out of memory» ឬគាំង អ្នកនឹងមិនទាយទៀតទេ — អ្នកនឹងដឹងថាត្រូវមើលផ្នែកណានៃម៉ាស៊ីន។
ទិញកាហ្វេជូនខ្ញុំ
ចូលចិត្តមេរៀននេះមែនទេ? សូមពិចារណាទិញកាហ្វេជូនខ្ញុំមួយកែវ ដើម្បីគាំទ្រការបង្កើតមាតិកាឥតគិតថ្លៃបន្ថែមទៀត!