Tổng kết Course 1 — Dữ liệu & CPU

TL;DR: Course 1 "Dữ liệu & CPU" đi từ bit — đơn vị nhỏ nhất — đến pipeline, cơ chế giúp CPU hiện đại chạy nhiều lệnh song song. Ba module lần lượt trả lời: dữ liệu lưu như thế nào (Module 1), CPU đọc và chạy lệnh như thế nào (Module 2), rồi CPU hiện đại tối ưu tốc độ bằng cách nào (Module 3). Đây là trang để bookmark.

Hành trình Course 1

Mỗi khi bạn chạy ./program, ba lớp cơ chế diễn ra đồng thời — và cả ba đều nằm trong Course 1 này.

Module 1 — Biểu diễn dữ liệu trả lời câu hỏi đầu tiên: dữ liệu trông như thế nào trong máy? Máy tính không biết "số 42" hay "chữ A" — nó chỉ biết bit. Module 1 giải thích quy ước mã hoá: hai's complement biến bit thành số nguyên có dấu; IEEE 754 biến bit thành số thực với dấu phẩy động; UTF-8 biến bit thành văn bản Unicode. Endianness quyết định thứ tự byte khi lưu. Thao tác bit-level (mask, shift) cho phép thao túng trực tiếp từng cờ trạng thái.

Module 2 — Máy chạy thế nào trả lời: CPU lấy đống bit đó và làm gì với nó? Kiến trúc von Neumann chia máy tính thành bộ nhớ + CPU + bus; vòng lặp fetch-decode-execute là nhịp tim của mọi chương trình. Thanh ghi và ALU là nơi tính toán thực sự diễn ra. Assembly nhập môn cho thấy code bậc cao (Java, Python, C) biến thành lệnh máy qua compile pipeline như thế nào — mỗi dòng int x = a + b; tương ứng một chuỗi lệnh mov/add/store cụ thể.

Module 3 — CPU hiện đại trả lời: làm sao CPU chạy nhanh hơn mà không tăng clock mãi được? Clock tăng có giới hạn vật lý (power wall, heat). Câu trả lời là pipeline — chia lệnh thành nhiều giai đoạn chạy chồng lên nhau. Branch prediction đoán nhánh điều kiện trước khi biết kết quả. Out-of-order execution sắp xếp lại lệnh để tận dụng tài nguyên. SIMD chạy một lệnh trên nhiều phần tử dữ liệu cùng lúc. Và Spectre/Meltdown cho thấy mọi tối ưu hoá đều có tradeoff bảo mật.

Toàn bộ hành trình từ bit đến pipeline giải thích một điều thực tế: cách bạn viết code ảnh hưởng trực tiếp đến tốc độ chạy — không phải vì "compiler thích" mà vì phần cứng có cấu trúc xác định.

Toan canh Course 1: tu bit toi pipeline.

flowchart LR
  M1["Module 1<br/>Bieu dien du lieu<br/>bit -> byte -> UTF-8"] --> M2["Module 2<br/>May chay the nao<br/>von Neumann -> assembly"]
  M2 --> M3["Module 3<br/>CPU hien dai<br/>pipeline -> branch -> SIMD"]

Cheat sheet xuyên course

Glossary

Những quyết định tối ưu bạn đã học

Mỗi module trong Course 1 đóng bằng một quyết định kỹ thuật cụ thể. Tổng hợp lại:

Chọn kiểu dữ liệu theo miền giá trị:

• Số nguyên không âm dưới 255 → byte (không phải int) để giảm bộ nhớ khi có array lớn.
• Số đếm vượt 2 tỷ → long, không phải int.
• Không dùng float/double cho tiền tệ — dùng BigDecimal (Java) hoặc lưu đơn vị nhỏ nhất (cent, xu) dưới dạng số nguyên.

Encoding và văn bản:

• Luôn set encoding UTF-8 tường minh khi đọc/ghi file (StandardCharsets.UTF_8), không dựa vào platform default.
• Đọc độ dài byte của String bằng .getBytes(UTF_8).length, không phải .length() — quan trọng khi tính giới hạn HTTP header, database column size.

Bitmask thay nhiều boolean:

• Gom n cờ boolean vào 1 int/long bằng bitmask: ít bộ nhớ hơn, cache-friendly hơn khi duyệt array lớn.
• Ví dụ: quyền truy cập (READ=1, WRITE=2, EXEC=4) → permissions & READ để kiểm tra.

Bật compiler optimization:

• Dùng -O2 (GCC/Clang) hoặc javac + JIT warming: dead code bị xoá, invariant bị hoist ra khỏi vòng lặp, loop được vectorize.
• Viết code rõ ý định (không alias pointer, không side-effect ẩn) để compiler tối ưu được.

Đo trước khi tối ưu:

• Không đoán chỗ chậm — profiler (perf, JProfiler, async-profiler) chỉ đúng bottleneck.
• Benchmark đúng cách: JVM warm-up ít nhất vài nghìn iteration trước khi đo; dùng JMH cho Java.
• Amdahl's Law: nếu 80% code đã nhanh rồi, tối ưu 20% còn lại chỉ cải thiện tối đa 25% tổng thể.

Viết vòng lặp branch-friendly:

• Sắp xếp dữ liệu đầu vào để nhánh phổ biến nhất xuất hiện liên tiếp → branch predictor đạt tỉ lệ đúng cao hơn.
• Tránh if phụ thuộc giá trị ngẫu nhiên trong vòng lặp nóng — xem xét branchless alternative (min/max intrinsic, ternary đơn giản).

Viết vòng lặp vectorize-friendly:

• Vòng lặp đơn giản, không có dependency giữa iteration, không có pointer alias → compiler tự SIMD hoá.
• Ưu tiên array of structs → struct of arrays khi cần vectorize nhiều field cùng lúc.

Self-assessment

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

• Giải thích được số nguyên, số thực (IEEE 754) và văn bản (UTF-8) được biểu diễn nhị phân thế nào; dự đoán được khi nào tràn số và khi nào float bị sai — nếu chưa chắc, đọc lại Module 1 bài 02 (two's complement) và bài 03 (IEEE 754).
• Trace được chu kỳ fetch-decode-execute và vai trò của register, ALU, bus trong kiến trúc von Neumann — nếu chưa chắc, đọc lại Module 2 bài 01 (von Neumann) và bài 02 (fetch-decode-execute).
• Đọc được assembly cơ bản và ánh xạ được một đoạn code bậc cao xuống lệnh máy — nếu chưa chắc, đọc lại Module 2 bài 04 (assembly nhập môn) và bài 05 (từ code bậc cao tới lệnh máy).
• Giải thích được pipeline hoạt động thế nào và vì sao branch prediction ảnh hưởng đến tốc độ — nếu chưa chắc, đọc lại Module 3 bài 02 (pipeline & hazard) và phần branch prediction.
• Áp dụng được: viết vòng lặp branch-friendly, đo cải thiện bằng benchmark, và giải thích kết quả theo Amdahl's Law — nếu chưa chắc, đọc lại Module 3 bài đo lường và bài capstone.

Ôn lại từ đầu: Module 1 — Biểu diễn dữ liệu · Module 2 — Máy chạy thế nào · Module 3 — CPU hiện đại

Tiếp theo: Course 2 — Bộ nhớ

Bạn vừa hiểu CPU tính toán thế nào. Nhưng có một nút thắt lớn mà Module 2 đã nhắc qua: von Neumann bottleneck — CPU và RAM chia sẻ cùng một bus, và RAM chậm hơn CPU hàng trăm lần. Đây là lý do tại sao nhiều chương trình bị giới hạn không phải bởi tốc độ tính toán, mà bởi tốc độ di chuyển dữ liệu. Course 2 "Bộ nhớ" sẽ đào sâu vào stack và heap (bộ nhớ được cấp phát thế nào), hệ thống cache nhiều tầng (L1/L2/L3 là giải pháp phần cứng cho von Neumann bottleneck), và virtual memory (ảo hoá địa chỉ cho phép chạy nhiều process an toàn). Hiểu bộ nhớ là bước tiếp theo bắt buộc để giải thích vì sao cùng một thuật toán O(n) mà cache-friendly lại nhanh hơn cache-unfriendly vài chục lần. Course 2 sắp ra mắt.

Tài liệu mở rộng