CPU

មាតិកា

1. ខួរក្បាលដែលមិនសូវឆ្លាត
2. តើ Instruction មើលទៅដូចម្តេច
3. វដ្ត Fetch–Decode–Execute
4. Register៖ ដៃរបស់ CPU
5. ល្បឿន Clock
6. Core
7. ពីកូដរបស់អ្នក ទៅជា Machine Code
8. ស្ថាបត្យកម្ម CPU៖ x86 និង ARM
9. សាកល្បងដោយខ្លួនឯង

1. ខួរក្បាលដែលមិនសូវឆ្លាត

CPU (Central Processing Unit) ឬ processor ត្រូវបានគេហៅជាញឹកញាប់ថាជា «ខួរក្បាល» របស់កុំព្យូទ័រ។ វាជាផ្នែកដែលពិតជាដំណើរការ instruction។

ប៉ុន្តែវាជាខួរក្បាលប្លែកមួយ។ វាមិនយល់ពីកម្មវិធីរបស់អ្នក ភាសារបស់អ្នក ឬចេតនារបស់អ្នកទេ។ វាស្គាល់តែប្រតិបត្តិការមូលដ្ឋានមួយចំនួនតូចដែលថេរ — ហៅថា instruction set របស់វា — ហើយវាធ្វើពួកវាម្តងមួយៗក្នុងល្បឿនមិនគួរឲ្យជឿ។

CPU សម័យថ្មីគឺជា chip មួយប៉ុនតែតែមប្រៃសណីយ៍ ដែលមាន transistor រាប់ពាន់លាន — កុងតាក់បើក/បិទតូចៗពីជំពូកមុន — ដែលត្រូវបានរៀបចំជាសៀគ្វីដែលអាចបូក ប្រៀបធៀប និងផ្លាស់ទីលេខ។

2. តើ Instruction មើលទៅដូចម្តេច

Instruction របស់ CPU គឺសាមញ្ញបំផុត។ ឧទាហរណ៍ទូទៅ៖

• Load — ចម្លងលេខមួយពី memory ចូលទៅក្នុង CPU
• Store — ចម្លងលេខមួយពី CPU ត្រឡប់ទៅ memory វិញ
• Add / subtract / multiply — គណនាលើលេខពីរ
• Compare — ពិនិត្យថាលេខពីរស្មើគ្នាឬអត់ ឬមួយណាធំជាង
• Jump — បន្តពី instruction មួយផ្សេងទៀត (អាចធ្វើបានតែនៅពេលការប្រៀបធៀបមួយពិតប៉ុណ្ណោះ)

នោះហើយប្រហែលជាទាំងអស់។ គ្រប់មុខងារនៃគ្រប់កម្មវិធី — if statement, loop, ការហៅ function, ការគូរប៊ូតុង — ត្រូវបានសាងសង់ឡើងពីការផ្សំគ្នានៃ instruction ទាំងនេះ។

ឧទាហរណ៍ កូដមួយបន្ទាត់ដូចនេះ៖

total = price + tax;

ប្រែក្លាយទៅជាលំដាប់ instruction របស់ CPU ប្រហាក់ប្រហែលនេះ៖

LOAD  register1, [price]     ; copy price from memory into the CPU
LOAD  register2, [tax]       ; copy tax from memory into the CPU
ADD   register1, register2   ; add them together
STORE [total], register1     ; copy the result back to memory

មួយបន្ទាត់សម្រាប់អ្នក តែបួនជំហានសម្រាប់ CPU។ Instruction «jump» គឺជាអ្វីដែលធ្វើឲ្យ loop អាចកើតឡើងបាន — «ត្រឡប់ទៅជំហានទី 1 វិញ ដរាបណា counter នៅតិចជាង 10»។

3. វដ្ត Fetch–Decode–Execute

CPU ចំណាយពេលពេញមួយជីវិតរបស់វា ធ្វើជំហានបីដដែលៗ៖

1. Fetch — យក instruction បន្ទាប់ពី memory។
2. Decode — ស្វែងយល់ថា instruction នោះមានន័យដូចម្តេច («នេះគឺជា ADD»)។
3. Execute — ធ្វើវា។

បន្ទាប់មក វាបន្តទៅ instruction បន្ទាប់ ហើយធ្វើម្តងទៀត។ Register ពិសេសមួយដែលហៅថា program counter តាមដានថា CPU កំពុងនៅត្រង់ណាក្នុងបញ្ជី — ដូចជាចំណាំទំព័រសៀវភៅ (bookmark)។ Instruction jump គ្រាន់តែផ្លាស់ប្តូរ bookmark នោះ។

នោះហើយគឺជាអ្វីទាំងអស់នៃកម្មវិធីដែលកំពុងដំណើរការ តាមទស្សនៈរបស់ CPU៖ bookmark មួយដែលផ្លាស់ទីកាត់បញ្ជី instruction ហើយពេលខ្លះលោតទៅមក។

CPU សម័យថ្មីប្រើល្បិចដើម្បីឲ្យលឿនជាងមុន — ពួកវាធ្វើការលើ instruction ច្រើនក្នុងពេលតែមួយនៅក្នុង pipeline ហើយថែមទាំងទាយថា if មួយនឹងទៅផ្លូវណា មុនពេលពួកវាដឹងពិតប្រាកដ។ ប៉ុន្តែលទ្ធផលតែងតែដូចគ្នានឹងការដំណើរការ instruction ម្តងមួយៗតាមលំដាប់។

4. Register៖ ដៃរបស់ CPU

CPU មិនអាចគណនាផ្ទាល់លើទិន្នន័យដែលនៅក្នុង RAM បានទេ។ ដំបូងវាត្រូវ load តម្លៃចូលទៅក្នុង register — កន្លែងផ្ទុកតូចៗមួយចំនួនដែលត្រូវបានសាងសង់ផ្ទាល់នៅក្នុង CPU។

សូមគិតដល់ចុងភៅម្នាក់៖ RAM គឺជាទូទឹកកក ហើយ register គឺជាដៃរបស់ចុងភៅ។ អ្នកអាចហាន់បានតែអ្វីដែលអ្នកកំពុងកាន់ប៉ុណ្ណោះ។ CPU ធម្មតាមាន register ទូទៅតែប៉ុន្មានដប់ប៉ុណ្ណោះ ដែលនីមួយៗផ្ទុកលេខតែមួយ (ជាធម្មតា 64 bit) ប៉ុន្តែពួកវាជាកន្លែងផ្ទុកដែលលឿនបំផុតក្នុងកុំព្យូទ័រទាំងមូល។

នេះជាតម្រុយដំបូងនៃគំនិតមួយដែលរត់កាត់ស៊េរីទាំងមូល៖ ទិន្នន័យដែលនៅជិត CPU គឺលឿន ហើយទិន្នន័យដែលនៅឆ្ងាយគឺយឺត។ យើងនឹងស្វែងយល់វាឲ្យបានច្បាស់នៅជំពូកបន្ទាប់។

5. ល្បឿន Clock

CPU ធ្វើការតាមចង្វាក់នៃ clock ខាងក្នុង — ជីពចរអេឡិចត្រូនិកមួយដែលលោតក្នុងអត្រាថេរ។ ការលោតនីមួយៗ (tick) គឺជាឱកាសមួយសម្រាប់ CPU ដើម្បីធ្វើជំហានមួយ។

ល្បឿន clock ត្រូវបានវាស់ជា hertz (ចំនួន tick ក្នុងមួយវិនាទី)៖

• 1 GHz (gigahertz) = 1 ពាន់លាន tick ក្នុងមួយវិនាទី
• CPU របស់ laptop សម័យថ្មីដំណើរការប្រហែល 2–5 GHz

ដូច្នេះក្នុងរយៈពេលដែលអ្នកព្រិចភ្នែកម្តង (ប្រហែលមួយភាគបីវិនាទី) CPU 3 GHz លោតប្រហែលមួយពាន់លានដង។

លេខ GHz ខ្ពស់ជាង មិនមែន ជារឿងទាំងអស់នោះទេ។ បរិមាណការងារដែលធ្វើបានក្នុងមួយ tick ក៏សំខាន់ដូចគ្នាដែរ — CPU ថ្មីៗធ្វើការបានច្រើនជាងក្នុងមួយ tick ធៀបនឹង CPU ចាស់ៗ។ Chip 3 GHz សព្វថ្ងៃ អាចឈ្នះ chip 4 GHz កាលពីដប់ឆ្នាំមុនយ៉ាងងាយ។ នោះហើយជាមូលហេតុដែលការប្រៀបធៀប CPU ដោយមើលតែ GHz គឺនាំឲ្យយល់ខុស។

6. Core

អស់រយៈពេលជាយូរ CPU លឿនជាងមុនភាគច្រើនដោយការបង្កើនល្បឿន clock។ ប៉ុន្តែ clock ដែលលឿនជាងបង្កើតកម្តៅច្រើនជាង ហើយប្រហែលពាក់កណ្តាលទសវត្សរ៍ 2000 ក្រុមហ៊ុនផលិត chip បានប៉ះនឹងជញ្ជាំង។

ដំណោះស្រាយគឺ ដាក់ CPU ច្រើននៅលើ chip តែមួយ។ នីមួយៗត្រូវបានហៅថា core ហើយ core នីមួយៗអាចដំណើរការខ្សែ instruction ផ្ទាល់ខ្លួនដោយឯករាជ្យ។

• CPU 4-core អាចធ្វើរឿងបួនក្នុងពេលតែមួយពិតប្រាកដ។
• ទូរស័ព្ទជាទូទៅមាន 6–8 core, laptop 4–16 core, server 64 core ឬច្រើនជាងនេះ។
• ទូរស័ព្ទ និង laptop ជាច្រើនលាយបញ្ចូល performance core (លឿន ស៊ីថាមពលច្រើន) និង efficiency core (យឺតជាង សន្សំថ្ម)។

Core ច្រើនជួយបានតែនៅពេលការងារអាចបែងចែកបានប៉ុណ្ណោះ។ Core ប្រាំបីធ្វើឲ្យការដំណើរការកម្មវិធីប្រាំបីក្នុងពេលតែមួយលឿនជាង ឬកម្មវិធីមួយដែលត្រូវបានរចនាឡើងដើម្បីបែងចែកការងាររបស់វាជាផ្នែកៗ។ កម្មវិធីដែលធ្វើការងាររបស់វាម្តងមួយជំហាន ប្រើតែ core មួយប៉ុណ្ណោះ ទោះបីអ្នកមាន core ប៉ុន្មានក៏ដោយ។ យើងនឹងត្រឡប់មកលើរឿងនេះវិញនៅជំពូកស្តីពី thread។

7. ពីកូដរបស់អ្នក ទៅជា Machine Code

CPU យល់តែ machine code ប៉ុណ្ណោះ — instruction ដែលត្រូវបានរក្សាទុកជាលេខ binary។ លែងមាននរណាសរសេរវាដោយដៃទៀតហើយ។ ផ្ទុយទៅវិញ យើងសរសេរជាភាសាសរសេរកម្មវិធីដូចជា JavaScript, Python, Go ឬ C ហើយឧបករណ៍មួយបកប្រែវា។ មានវិធីសំខាន់ពីរ៖

ភាសាដែលត្រូវ Compile (C, C++, Go, Rust) — compiler បកប្រែកម្មវិធីទាំងមូលរបស់អ្នកទៅជា machine code មុនពេល វាដំណើរការ ដោយបង្កើតបានជា executable file (ដូចជា .exe លើ Windows)។ ការដំណើរការវាគឺលឿន ព្រោះការបកប្រែត្រូវបានធ្វើរួចហើយ។

ភាសាដែលត្រូវ Interpret (Python និង JavaScript ដើមឡើយ) — interpreter ខ្លួនវាផ្ទាល់គឺជាកម្មវិធីមួយដែលអានកូដរបស់អ្នក ហើយអនុវត្តវា ខណៈពេលដែលវាកំពុងដំណើរការ។ វិធីនេះមានភាពបត់បែនជាង ប៉ុន្តែតាមប្រវត្តិសាស្ត្រវាយឺតជាង។

តាមការអនុវត្តជាក់ស្តែង បន្ទាត់ចែកនេះមិនច្បាស់ទេ។ JavaScript engine សម័យថ្មីដូចជា V8 (ដែល Chrome និង Node.js ប្រើ) ប្រើ just-in-time (JIT) compilation៖ ពួកវាចាប់ផ្តើមដោយ interpret កូដរបស់អ្នក សម្គាល់ថាផ្នែកណាដំណើរការញឹកញាប់ ហើយ compile ផ្នែកទាំងនោះទៅជា machine code ភ្លាមៗ។

មិនថាវិធីណាក៏ដោយ លទ្ធផលចុងក្រោយគឺដូចគ្នា៖ machine code ដែលដំណើរការលើ CPU ម្តងមួយ instruction។

8. ស្ថាបត្យកម្ម CPU៖ x86 និង ARM

ក្រុម CPU ផ្សេងៗគ្នាយល់ instruction set ផ្សេងៗគ្នា។ ពីរដែលអ្នកនឹងឮជារៀងរហូតគឺ៖

Machine code សម្រាប់មួយ មិនដំណើរការលើមួយទៀតទេ។ នោះហើយជាមូលហេតុដែលការទាញយក software ពេលខ្លះសុំឲ្យអ្នកជ្រើសរើស «Intel» ឬ «Apple Silicon» ហើយហេតុអ្វី Docker image ត្រូវបាន build សម្រាប់ platform ជាក់លាក់មួយដូចជា linux/amd64 ឬ linux/arm64។ បើអ្នកធ្លាប់ឃើញ error «exec format error» ភាពមិនត្រូវគ្នានេះជាធម្មតាគឺជាមូលហេតុ។

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

ស្វែងរកថាកុំព្យូទ័ររបស់អ្នកមាន CPU អ្វី៖

• Windows៖ បើក Task Manager (Ctrl + Shift + Esc) → Performance → CPU។ អ្នកនឹងឃើញម៉ូដែល ល្បឿន និងចំនួន core។
• macOS៖ ម៉ឺនុយ Apple → About This Mac។ សម្រាប់ព័ត៌មានលម្អិតបន្ថែម បើក Activity Monitor → Window → CPU History ដើម្បីមើលក្រាហ្វមួយសម្រាប់ core នីមួយៗ។
• Linux៖ បើក terminal ហើយរត់ lscpu។

ខណៈពេលដែលផ្ទាំង CPU កំពុងបើក សូមចាក់វីដេអូ ឬបើកគេហទំព័រធ្ងន់ៗ ហើយមើលក្រាហ្វការប្រើប្រាស់លោតឡើង។ ការលោតឡើងនីមួយៗគឺជាវដ្ត fetch–decode–execute រាប់ពាន់លានដង។

ឥឡូវអ្នកដឹងហើយថាអ្វីជាអ្នកធ្វើការងារ។ បន្ទាប់៖ កន្លែងដែលទិន្នន័យដែលវាធ្វើការជាមួយពិតជាស្ថិតនៅ។