Module 2 — Tổng kết & cheat sheet cách máy chạy

TL;DR: Module 2 bóc 5 tầng cốt lõi giải thích điều gì xảy ra khi bạn chạy ./program: kiến trúc von Neumann đặt nền, vòng fetch-decode-execute lặp hàng tỷ lần mỗi giây, register/ALU thực thi phép tính, assembly là ngôn ngữ trung gian trực tiếp trên phần cứng, và compiler tự động ánh xạ code bậc cao xuống lệnh máy tối ưu. Đây là 1 trang để bookmark.

Đã đi qua những gì

Bài 01 đặt nền với mô hình von Neumann — kiến trúc 4 thành phần (CPU, bộ nhớ chính, bus, I/O) mà John von Neumann thiết kế năm 1945 và mọi máy tính hiện đại đều kế thừa. Ý tưởng cốt lõi là stored-program: lệnh và dữ liệu cùng nằm trong một bộ nhớ thống nhất, giúp máy tính lập trình lại bằng phần mềm thay vì nối lại dây. Von Neumann bottleneck cũng xuất hiện ở đây: CPU và bộ nhớ nói chuyện qua bus duy nhất, nên tốc độ truy cập RAM trở thành điểm nghẽn mà mọi tầng cache đều cố giải quyết.

Bài 02 đào sâu chu kỳ fetch-decode-execute — vòng lặp 3 bước mà CPU thực hiện hàng tỷ lần mỗi giây. Program Counter (PC) giữ địa chỉ lệnh tiếp theo, Instruction Register (IR) chứa lệnh đang chạy, clock đồng bộ toàn bộ CPU theo xung nhịp đều đặn. Trace tay một lệnh cộng số nguyên qua từng giai đoạn là cách duy nhất để "nhìn thấy" vòng lặp này trong đầu.

Bài 03 mổ xẻ bên trong CPU: register nhanh hơn RAM hàng trăm lần vì nằm ngay trên chip cùng ALU, ALU thực hiện phép tính nhị phân và lưu kết quả phụ vào flags (zero, carry, overflow), Control Unit giải mã opcode và điều phối tín hiệu điều khiển. Số lượng register rất hạn chế — đây là lý do compiler phải quản lý register allocation cẩn thận.

Bài 04 là assembly nhập môn — không phải để lập trình assembly, mà để đọc hiểu output của compiler. Opcode là mã lệnh số, mnemonic là cách viết người đọc được (mov, add, cmp, jmp). Vòng for trong C biến thành một cụm lệnh cmp + jne nhảy ngược lên đầu vòng lặp.

Bài 05 ghép lại toàn bộ pipeline biên dịch: preprocessor → compiler → assembler → linker. Compiler sinh assembly từ AST, tối ưu hoá nhiều pass (dead code elimination, constant folding, inlining), rồi assembler chuyển thành object file nhị phân. JIT compiler (Java HotSpot, V8) thêm tầng thú vị: compile lúc runtime dựa trên profile thực tế, kết hợp linh hoạt giữa interpret và native code.

Sơ đồ dưới tóm tắt hành trình 5 bài của Module 2 — từ kiến trúc phần cứng đến lúc code bạn viết thành lệnh máy chạy được:

flowchart LR
  A["von Neumann<br/>CPU+RAM+bus"] --> B["Fetch-Decode-Execute<br/>PC, IR, clock"]
  B --> C["Register + ALU<br/>noi tinh toan"]
  C --> D["Assembly<br/>mov/add/cmp/jmp"]
  D --> E["Compiler<br/>code -> lenh may"]

Cheat sheet

Glossary

Pitfall tổng hợp

Pitfall 1: Đếm dòng code để ước tính tốc độ

Số dòng source code không phản ánh số lệnh máy, và số lệnh máy không phản ánh thời gian chạy.

// "Vong lap ngan hon phai nhanh hon" -- SAI
for (int i = 0; i < 4; i++) arr[i] *= 2;   // 4 lan nhan

// Compiler co the sinh ra 1 lenh SIMD xu ly 4 phan tu cung luc
// Hoac inlining bien 4 vong lap thanh 4 lenh noi tiep -- nhanh hon

// Cach do dung: benchmark thuc te hoac xem assembly -O2
// Time cua CPU phu thuoc cache miss, branch prediction, IPC -- khong phu thuoc dong code

Pitfall 2: Tối ưu tay thay vì để compiler làm

Compiler hiện đại (GCC, Clang, javac + HotSpot) tối ưu tốt hơn tay trong phần lớn trường hợp với -O2/-O3.

// "Toi tu nhan bang shift cho nhanh" -- thuong vo ich
int x = n << 3;   // thay vi n * 8

// Compiler tu dong nhan ra n * 8 == n << 3 va sinh shift
// Viet n * 8 ro rang hon, compiler khong cham hon

// Thay vao do: do profile truoc, tim hotspot, roi moi toi uu dung cho
// Premature optimization la nguon goc cua moi toi te -- D. Knuth

Pitfall 3: Quên bật -O2 hoặc -O3 khi build production

Debug build (-O0) tắt mọi tối ưu để giữ thứ tự lệnh khớp source — chậm hơn production build tới 5–10x.

# SAI -- build production ma de mac dinh -O0
gcc main.c -o app

# DUNG -- production nen dung -O2 it nhat
gcc -O2 main.c -o app

# Java: HotSpot tu dong JIT; khong co flag -O tuong duong
# nhung chay du lau de HotSpot warmup la can thiet khi benchmark

Pitfall 4: Nhầm truy cập bộ nhớ rẻ như phép tính ALU

ALU hoàn thành phép cộng trong 1 clock cycle. Đọc RAM mất hàng trăm cycle. Cache L1 hit mất khoảng 4 cycle, L2 khoảng 12 cycle, L3 khoảng 40 cycle, RAM khoảng 200 cycle.

// Chuong trinh A: duyet mang tuyen tinh -- cache-friendly
for (int i = 0; i < N; i++) sum += arr[i];

// Chuong trinh B: truy cap ngau nhien -- cache miss cao
for (int i = 0; i < N; i++) sum += arr[rand_index[i]];

// B co the cham hon A 10-50x du so lenh CPU giong nhau
// Ly do: B lien tuc gap cache miss, CPU phai doi RAM

Pitfall 5: Nhầm bytecode Java là lệnh máy

Bytecode Java (.class file) là lệnh cho JVM — một máy ảo stack-based. Không phải lệnh x86-64 hay ARM64. CPU không đọc bytecode trực tiếp.

Source (.java)
   |-- javac --> Bytecode (.class)  [JVM instruction set]
                    |-- JIT (HotSpot) --> Native code  [x86-64 / ARM64]
                                              |-- CPU executes

Khi benchmark Java, phải để HotSpot warmup (chạy qua code ít nhất vài nghìn lần) trước khi đo — không thì đang đo thời gian interpret, không phải native code.

Pitfall 6: Nghĩ compiler luôn sinh assembly "giống" code gốc

Với -O2, compiler được phép sắp xếp lại lệnh, xoá biến không dùng, inline hàm, và thậm chí tính compile-time kết quả mà bạn nghĩ sẽ tính lúc runtime.

// Source:
int square(int n) { return n * n; }
int result = square(5);  // goi ham

// Assembly -O2 co the tra truc tiep:
// mov eax, 25   -- compiler da tinh 5*5 = 25 tai compile time (constant folding)
// Khong co call square gi ca

Dùng godbolt.org để quan sát assembly thực tế với từng flag tối ưu.

Self-assessment

Bạn đã đạt Module 2 nếu trả lời được:

• Explain được mô hình von Neumann: vai trò CPU, bộ nhớ chính, bus và I/O, và lý do stored-program là ý tưởng then chốt — nếu chưa chắc, đọc lại bài 01 section "Mô hình 4 thành phần" + "Stored-program".
• Trace được chu kỳ fetch-decode-execute của một lệnh cụ thể: PC trỏ đâu, IR chứa gì, ALU tính toán thế nào, PC tăng hoặc nhảy ra sao — nếu chưa chắc, đọc lại bài 02 section "Ba bước lặp" + bảng trace tay.
• Explain được vai trò register, ALU và control unit, và lý do register nhanh hơn RAM — nếu chưa chắc, đọc lại bài 03 section "Register" + "ALU và flags".
• Đọc được assembly cơ bản của một ISA đơn giản: nhận ra mov, add, cmp, jmp và hiểu chúng làm gì — nếu chưa chắc, đọc lại bài 04 section "Mnemonic phổ biến".
• Ánh xạ được một đoạn code bậc cao (vòng for, câu if) xuống các lệnh máy tương ứng và giải thích từng bước — nếu chưa chắc, đọc lại bài 05 section "Từ vòng for tới cmp + jne".

What's next

Bạn vừa hiểu CPU chạy thế nào ở mức cơ bản — von Neumann, fetch-decode-execute, register, assembly, compile pipeline. Câu hỏi tiếp theo tự nhiên là: CPU hiện đại làm thế nào để nhanh hơn hàng trăm lần so với mô hình 3 bước đơn giản?

Module 3 "CPU hiện đại" sẽ mở nắp pipeline thực sự: instruction pipelining chồng lấp nhiều lệnh, branch prediction đoán trước lệnh nhảy, out-of-order execution sắp xếp lại lệnh để tránh stall, và cách đo hiệu năng thực tế bằng perf thay vì đếm dòng code.

CPU hiện đại

Tài liệu mở rộng

Bài tiếp theo: CPU hiện đại — tổng quan