Bỏ qua tới nội dung chính

Trước khi có "kiến trúc"

Kiến trúc máy tính: vì sao cùng một chương trình lại chạy nhanh gấp mười

Môn Kiến trúc máy tính nhìn bộ xử lý từ góc hiệu năng: phân cấp bộ nhớ và bộ nhớ đệm, đường ống và dự đoán rẽ nhánh, bức tường công suất, song song, kiến trúc tập lệnh như một hợp đồng — và nên bắt đầu học từ đâu.

Ban biên tập OpenER

Cập nhật 09/11/2026 · 20 phút đọc · CC BY 4.0

Hai bạn cùng lớp được giao một bài: cộng tất cả điểm ảnh của một bức ảnh lớn. Cả hai viết đúng, cùng ngôn ngữ, cùng thư viện, chạy trên cùng một máy, ra cùng một kết quả. Chỉ khác một chỗ: bạn thứ nhất duyệt ảnh theo hàng, bạn thứ hai duyệt theo cột. Bài của bạn thứ hai chạy chậm hơn gần bảy lần.

Không có lỗi nào trong code. Số phép cộng y hệt nhau. Sự khác biệt nằm ở tầng mà phần lớn lập trình viên không bao giờ nhìn tới: cách bộ xử lý lấy dữ liệu từ bộ nhớ. Môn học giải thích chuyện này là Kiến trúc máy tính (computer architecture) — ở Berkeley có tên đầy đủ là Computer Architecture and Engineering, đúng như tên chủ đề trên OpenER.

Nếu bài Cấu trúc tính toán dạy bạn xây một bộ xử lý từ cổng logic, thì môn này hỏi câu tiếp theo: bộ xử lý thật ngày nay làm gì để chạy nhanh — và vì sao có lúc nó chạy chậm đến khó tin?

Trước khi có "kiến trúc"

Trong thập niên 1950, mỗi máy tính là một thế giới riêng. Hãng ra máy mới mạnh hơn thì máy mới cũng có bộ lệnh mới, và mọi chương trình viết cho máy cũ phải viết lại — thường bằng hợp ngữ, từng dòng một. Khách hàng muốn nâng cấp máy phải trả hai lần: một lần cho phần cứng, một lần cho việc viết lại phần mềm.

Ý tưởng tách "máy hứa làm gì" ra khỏi "máy được chế tạo thế nào" ra đời từng bước:

  1. Vi chương trình (microprogramming) — Maurice Wilkes, Đại học Cambridge, năm 1951: phần điều khiển của bộ xử lý có thể được viết như một chương trình nhỏ bên trong. Về sau, chính ý này cho phép một máy rẻ, chậm và một máy đắt, nhanh có thể trông giống hệt nhau từ phía phần mềm.
  2. IBM System/360 — công bố năm 1964. Lần đầu tiên một hãng bán cả một họ máy từ nhỏ tới lớn, giá chênh nhau nhiều lần, nhưng chạy chung một bộ lệnh. Gene Amdahl, Gerrit Blaauw và Fred Brooks gọi phần "hợp đồng" chung đó là kiến trúc (architecture), phân biệt với cách cài đặt cụ thể của từng máy. Chữ "kiến trúc máy tính" theo nghĩa ngày nay bắt đầu từ đây.
  3. Bộ nhớ đệm (cache) — IBM System/360 Model 85, cuối thập niên 1960, là một trong những máy thương mại đầu tiên có một bộ nhớ nhỏ, nhanh đứng giữa bộ xử lý và bộ nhớ chính. Phần mềm không cần biết nó tồn tại — đúng tinh thần của hợp đồng.
  4. RISC — cuối thập niên 1970 và đầu thập niên 1980: nhóm IBM 801 của John Cocke, dự án RISC của David Patterson ở Berkeley và MIPS của John Hennessy ở Stanford cho thấy một bộ lệnh đơn giản lại chạy nhanh hơn, vì dễ đưa vào đường ống.
  5. Cách tiếp cận định lượng — năm 1990, Hennessy và Patterson viết Computer Architecture: A Quantitative Approach: mọi quyết định thiết kế phải đo được bằng hiệu năng trên chương trình thật, không bằng cảm giác. Hai ông nhận giải Turing năm 2017 cho công trình này.

Đặt cạnh nhau:

Mỗi máy một bộ lệnh riêng
Có kiến trúc tập lệnh chung
Mua máy mới
Viết lại toàn bộ phần mềm
Phần mềm cũ chạy ngay, thường nhanh hơn
Người thiết kế chip
Bị trói vào bộ lệnh cũ, hoặc phá vỡ mọi thứ
Tự do đổi cách cài đặt bên trong, miễn giữ hợp đồng
Trình biên dịch, hệ điều hành
Viết lại cho từng máy
Viết một lần cho cả họ máy
Đánh giá máy nào tốt hơn
So số liệu quảng cáo
Chạy cùng chương trình chuẩn, đo thời gian
Thị trường phần mềm
Nhỏ, gắn với từng máy
Lớn, sống qua nhiều thế hệ phần cứng

Ngày nay vẫn có một loại bộ xử lý rất mạnh không hứa một bộ lệnh ổn định cho người lập trình: card đồ họa (GPU). Bộ lệnh thật của GPU NVIDIA đổi theo từng thế hệ chip. Trình biên dịch CUDA không nhắm thẳng vào bộ lệnh đó, mà vào một "bộ lệnh ảo" tên là PTX; tới lúc chạy, trình điều khiển (driver) có thể dịch PTX sang lệnh thật của đúng con chip đang cắm trong máy. Đó vẫn là ý tưởng của System/360 — tách lời hứa khỏi cách làm — chỉ là lời hứa được dời lên cao hơn một tầng.

Môn này trả lời câu hỏi gì

Môn Kiến trúc máy tính trả lời câu hỏi: với số transistor và lượng điện năng có hạn, làm sao để chương trình thật chạy nhanh nhất — mà không bắt phần mềm phải viết lại?

Câu hỏi đó tách thành mấy câu nhỏ: bộ nhớ chậm hơn bộ xử lý hàng trăm lần thì làm sao để bộ xử lý không phải ngồi chờ; làm sao cho nhiều lệnh chạy chồng lên nhau; vì sao tần số ngừng tăng và tốc độ còn tìm ở đâu; và hợp đồng giữa phần cứng với phần mềm nên trông thế nào.

Vì sao cần học, khi ít ai trong chúng ta thiết kế bộ xử lý? Vì như ví dụ mở đầu, hiệu năng của phần mềm phụ thuộc vào những thứ mà ngôn ngữ lập trình không cho bạn thấy. Người hiểu kiến trúc biết vì sao đoạn code này nhanh, đoạn kia chậm, và biết nên tối ưu ở đâu trước.

Năm ý tưởng cốt lõi

1. Phân cấp bộ nhớ: gần thì nhanh, xa thì chậm

Hãy nghĩ tới một người nấu ăn. Muối, nước mắm, dầu ăn để ngay cạnh bếp — với tay là có. Gia vị ít dùng hơn để trong tủ bếp — mất vài bước. Thứ không có trong nhà thì phải ra chợ — mất nửa tiếng. Không ai đặt cả cái chợ cạnh bếp, nhưng nếu xếp khéo, gần như mọi lần với tay đều trúng thứ ở gần.

Máy tính làm đúng như vậy, gọi là phân cấp bộ nhớ (memory hierarchy): vài chục thanh ghi (register) ngay trong bộ xử lý; vài tầng bộ nhớ đệm (cache) nhỏ và nhanh, gọi là L1, L2, L3; rồi tới bộ nhớ chính (DRAM) lớn nhưng chậm hơn hàng trăm lần; rồi ổ đĩa. Bộ nhớ đệm hoạt động nhờ hai thói quen của hầu hết chương trình, gọi là tính cục bộ (locality):

  • Cục bộ thời gian: thứ vừa dùng thì sắp dùng lại — như lọ nước mắm.
  • Cục bộ không gian: thứ nằm cạnh thứ vừa dùng cũng sắp được dùng. Vì thế, mỗi lần phải xuống bộ nhớ chính, máy không lấy một số mà lấy cả một dòng bộ nhớ đệm (cache line), thường 64 byte — tám số thực một lúc.

Giờ quay lại bức ảnh. Thư viện NumPy xếp một mảng hai chiều theo hàng: các số của một hàng nằm sát nhau trong bộ nhớ. Duyệt theo hàng thì mỗi dòng 64 byte lấy về dùng trọn cả tám số. Duyệt theo cột thì mỗi số nằm cách số trước cả một hàng — 40.000 byte — nên mỗi lần đọc gần như phải lấy một dòng mới, dùng một số rồi bỏ bảy số còn lại:

python
import time
import numpy as np

anh = np.ones((5000, 5000))      # 25 triệu số, mỗi số 8 byte: khoảng 200 MB

def do(ten, ham):
    bat_dau = time.perf_counter()
    ket_qua = ham()
    print(f"{ten}: {time.perf_counter() - bat_dau:.2f} giây, tổng = {ket_qua:.0f}")

# NumPy xếp mảng theo hàng: các số của một hàng nằm sát nhau trong bộ nhớ
do("Đi theo hàng", lambda: sum(anh[i, :].sum() for i in range(5000)))
do("Đi theo cột", lambda: sum(anh[:, j].sum() for j in range(5000)))

Trên máy chúng tôi chạy thử, đi theo hàng mất khoảng 0,05 giây, đi theo cột khoảng 0,3 giây — cùng tổng 25.000.000, chậm hơn khoảng bảy lần. Con số trên máy bạn sẽ khác, nhưng chiều chênh lệch thì gần như chắc chắn giống. Bài Cấu trúc dữ liệu và giải thuật có nói mảng nhanh vì phần tử nằm sát nhau; đây là lý do ở tầng phần cứng.

Bài học cho người viết phần mềm: hai chương trình cùng độ phức tạp O(n) có thể chênh nhau gấp mười chỉ vì thứ tự đi qua dữ liệu. Các thư viện tính toán nhanh nhất — nhân ma trận, xử lý ảnh, cơ sở dữ liệu — đều được viết để dữ liệu "nằm sẵn cạnh bếp".

2. Đường ống và dự đoán rẽ nhánh: đoán trước để không phải chờ

Bài Cấu trúc tính toán đã giới thiệu đường ống (pipeline): chia việc thực hiện một lệnh thành các công đoạn và cho nhiều lệnh chạy chồng lên nhau. Môn Kiến trúc máy tính đi vào chỗ khó: chuyện gì xảy ra khi dây chuyền không biết làm gì tiếp theo.

Hãy hình dung một xe bánh mì đông khách với ba người đứng thành dây chuyền: người thứ nhất xẻ bánh và phết pate, người thứ hai cho chả và thịt, người thứ ba cho rau, nước sốt rồi gói. Khi người thứ ba đang gói ổ của khách trước, người thứ nhất đã xẻ ổ cho khách sau. Nhưng có một câu hỏi phải chờ tới cuối mới biết: "Có lấy ớt không?" Nếu cả dây chuyền dừng lại chờ câu trả lời, mất hết lợi thế.

Bộ xử lý gặp đúng tình huống đó ở mỗi câu lệnh if và mỗi vòng lặp — gọi là lệnh rẽ nhánh (branch): chưa tính xong điều kiện thì chưa biết lệnh tiếp theo là lệnh nào. Bộ xử lý hiện đại có đường ống dài tới mười mấy công đoạn, nên chờ là mất cả chục nhịp đồng hồ (clock cycle) cho mỗi lần rẽ. Lời giải là dự đoán rẽ nhánh (branch prediction): phần cứng ghi nhớ lần trước nhánh này đi đường nào và đoán lần này cũng vậy, rồi cứ thế chạy tiếp. Đoán đúng — không mất gì. Đoán sai — bỏ các ổ bánh làm dở, làm lại từ đầu. Như cô bán bánh mì nhớ mặt khách quen: "anh này lần nào cũng lấy ớt".

Bộ dự đoán của bộ xử lý ngày nay đoán đúng với phần lớn các nhánh trong chương trình thông thường. Cái giá chỉ lộ ra khi dữ liệu ngẫu nhiên: một vòng lặp đếm các số lớn hơn 128 trong một mảng ngẫu nhiên có thể chạy chậm hơn hẳn chính vòng lặp đó trên mảng đã sắp xếp — vì trên mảng đã sắp xếp, nhánh if đi một hướng suốt nửa đầu rồi đổi hướng suốt nửa sau, rất dễ đoán.

Cùng tinh thần "đừng để dây chuyền đứng", bộ xử lý hiện đại còn chạy nhiều lệnh mỗi nhịp (superscalar) và chạy lệnh không theo thứ tự (out-of-order execution): lệnh nào đã đủ dữ liệu thì chạy trước, miễn kết quả cuối cùng giống hệt như chạy đúng thứ tự. Phần mềm không thấy gì — chỉ thấy chương trình nhanh hơn.

3. Bức tường công suất: vì sao tần số ngừng tăng

Năm 1965, Gordon Moore nhận xét số transistor trên một con chip tăng gấp đôi đều đặn — sau này gọi là định luật Moore (Moore's law). Năm 1974, Robert Dennard và cộng sự ở IBM chỉ ra một điều còn quan trọng hơn: khi thu nhỏ transistor, có thể hạ điện áp theo, nên công suất trên mỗi milimét vuông chip gần như không đổi. Đó là quy luật Dennard (Dennard scaling). Suốt ba mươi năm, mỗi thế hệ chip vừa nhiều transistor hơn, vừa chạy tần số cao hơn, mà không nóng hơn.

Tới khoảng giữa thập niên 2000, điện áp không hạ thêm được nữa — dưới một ngưỡng, transistor rò điện ngay cả khi "tắt". Quy luật Dennard dừng lại, và tần số chạm vào bức tường công suất (power wall): tăng thêm tần số là chip nóng tới mức không tản nhiệt kịp. Năm 2004, Intel hủy thế hệ bộ xử lý một nhân tần số cao đang phát triển để chuyển sang thiết kế nhiều nhân (multicore).

Vì sao nhiều nhân lại có lợi? Công suất tiêu thụ khi chuyển mạch của chip tỷ lệ gần đúng với điện dung × điện áp² × tần số. Giảm tần số thì thường giảm được cả điện áp, nên công suất giảm nhanh hơn tốc độ rất nhiều:

python
# Hạ tần số và điện áp cùng 15%: công suất tỷ lệ với điện áp² × tần số
he_so = 0.85
cong_suat_1_nhan = he_so**2 * he_so
print(round(cong_suat_1_nhan, 3))       # 0.614 — còn khoảng 61% công suất
print(round(2 * cong_suat_1_nhan, 3))   # 1.228 — hai nhân chậm như thế
print(2 * he_so)                        # 1.7  — nhưng làm được 1,7 lần việc

Một nhân chậm đi 15% chỉ tốn khoảng 61% điện. Đặt hai nhân như vậy cạnh nhau: tốn khoảng 1,23 lần điện của một nhân nhanh, nhưng — nếu chương trình chia đôi được — làm được 1,7 lần việc. Chữ "nếu" đó là gánh nặng mà ngành phần cứng đã chuyển sang vai người viết phần mềm từ giữa thập niên 2000. Điện thoại của bạn có tám nhân không phải vì tám là con số đẹp, mà vì đó là cách chính còn lại để nhanh hơn mà không nóng hơn.

4. Song song ở mọi cỡ, và giới hạn của nó

Khi không tăng được tần số, tốc độ phải đến từ làm nhiều việc cùng lúc. Môn học chia song song thành vài cỡ:

  • Song song mức lệnh (instruction-level parallelism): đường ống, chạy nhiều lệnh mỗi nhịp — ý tưởng 2, phần cứng tự lo.
  • Song song dữ liệu (SIMD — single instruction, multiple data): một lệnh cộng tám, mười sáu số cùng lúc. Giống cô giáo chấm cả xấp bài trắc nghiệm bằng một tấm đáp án đục lỗ, thay vì đọc từng câu.
  • Song song mức luồng (thread-level parallelism): nhiều nhân, mỗi nhân chạy một phần việc.
  • GPU: hàng nghìn đơn vị tính đơn giản chạy cùng một chương trình trên các mảnh dữ liệu khác nhau — sinh ra để vẽ hàng triệu điểm ảnh, nay là cỗ máy chính để huấn luyện AI (bài Đại số tuyến tính nói vì sao AI cần nhân ma trận nhiều đến vậy).

Có thể cảm nhận khoảng cách này ngay trong Python:

python
import time
import numpy as np

x = np.random.default_rng(0).random(10_000_000)

t = time.perf_counter()
tong = 0.0
for v in x:                     # từng số một, mỗi vòng qua trình thông dịch
    tong += v
print(f"Vòng lặp Python: {time.perf_counter() - t:.2f} giây")

t = time.perf_counter()
tong2 = x.sum()                 # một vòng lặp đã biên dịch, dùng lệnh SIMD
print(f"NumPy:           {time.perf_counter() - t:.4f} giây")

Trên máy chạy thử, vòng lặp Python mất khoảng 3,3 giây, NumPy khoảng 0,013 giây — nhanh hơn vài trăm lần. Cần nói cho công bằng: phần lớn khoảng cách này đến từ việc bỏ được trình thông dịch Python, chỉ một phần nhờ SIMD. Nhưng bài học vẫn đúng: muốn nhanh, hãy đưa dữ liệu cho phần cứng theo từng khối lớn, đều đặn.

Và có một giới hạn mà mọi kỹ sư hiệu năng phải thuộc: định luật Amdahl (Amdahl's law). Tăng tốc một phần chỉ có ích theo tỷ lệ thời gian phần đó chiếm. Ví dụ, một chương trình chạy 100 giây, trong đó 60 giây là nhân ma trận. Đưa phần đó lên GPU nhanh gấp 50 lần:

python
truoc = 100
sau = 40 + 60 / 50            # 40 giây phần còn lại không đổi
print(sau, round(truoc / sau, 2))   # 41.2 2.43

GPU nhanh gấp 50 lần, nhưng cả chương trình chỉ nhanh gấp 2,4 lần — vì 40 giây còn lại không hề nhúc nhích. Muốn đi tiếp, phải quay sang tối ưu 40 giây đó. Đây là lý do câu đầu tiên của mọi kỹ sư hiệu năng giỏi là: "Đã đo chưa? Thời gian thật sự đi đâu?"

5. Kiến trúc tập lệnh: một hợp đồng sống qua nhiều thế hệ

Kiến trúc tập lệnh (instruction set architecture — ISA) là lời hứa của phần cứng với phần mềm: những lệnh nào tồn tại, có bao nhiêu thanh ghi, bộ nhớ được đánh địa chỉ ra sao. Mọi thứ ở bốn ý trên — bộ nhớ đệm, dự đoán rẽ nhánh, chạy không theo thứ tự, nhiều nhân — đều nằm bên dưới lời hứa đó, nên đổi được mà phần mềm không phải biết. Tách biệt này gọi là kiến trúc (lời hứa) và vi kiến trúc (microarchitecture) (cách thực hiện).

Ngày nay có ba họ ISA mà người học nên biết tên:

  • x86 — của Intel và AMD, ra đời từ năm 1978 với chip 8086 và vẫn tương thích ngược tới hôm nay. Bộ lệnh phức tạp; bên trong, chip x86 hiện đại dịch lệnh thành các thao tác nhỏ kiểu RISC trước khi chạy. Thống trị máy tính để bàn và máy chủ.
  • ARM — bộ lệnh kiểu RISC, gốc từ hãng Acorn ở Anh giữa thập niên 1980. Công ty ARM không bán chip mà bán quyền dùng thiết kế. Gần như mọi điện thoại thông minh chạy ARM.
  • RISC-V — bắt đầu ở Berkeley năm 2010, là ISA mở: ai cũng được thiết kế chip RISC-V mà không phải trả phí bản quyền. Nhiều khóa học, kể cả CS 61C của Berkeley, dùng RISC-V để dạy vì nó gọn và sạch.

Sức mạnh của hợp đồng thấy rõ nhất khi có người đổi nó. Năm 2020, Apple chuyển máy Mac từ chip x86 của Intel sang chip ARM do Apple tự thiết kế. Để phần mềm cũ vẫn chạy, Apple dùng một lớp dịch tên Rosetta 2, chuyển lệnh x86 sang lệnh ARM. Một cuộc chuyển đổi tốn nhiều năm chuẩn bị — cho thấy ISA là thứ đắt nhất, khó đổi nhất trong cả chồng tầng, và vì sao System/360 năm 1964 quan trọng đến thế.

Kiến trúc máy tính nằm ở đâu trong chồng tầng

Trong chồng tầng của bài Từ electron đến ứng dụng, môn này nằm quanh ranh giới giữa kiến trúc tập lệnh và vi kiến trúc: nó nhận mạch số từ tầng dưới — thứ mà Cấu trúc tính toán dạy bạn xây — và trả lên trên một bộ lệnh mà hệ điều hành và trình biên dịch dựa vào.

Đưa lên

Một kiến trúc tập lệnh ổn định — lệnh, thanh ghi, mô hình bộ nhớ — chạy nhanh nhất có thể, với nhiều nhân và lệnh SIMD cho phần mềm biết cách dùng.

Giấu đi

Bộ nhớ đệm, đường ống, dự đoán rẽ nhánh, chạy không theo thứ tự. Phần mềm không cần biết chúng để chạy đúng — nhưng phải hiểu chúng để chạy nhanh, như ví dụ bức ảnh cho thấy.

Chữ "giấu" ở đây không kín hoàn toàn: thời gian chạy để lộ những gì bên dưới. Năm 2018, lỗ hổng Spectre và Meltdown cho thấy chính việc đoán trước và chạy trước có thể làm rò dữ liệu — chuyện kể kỹ hơn trong bài Từ electron đến ứng dụng và bài An toàn máy tính.

Học trước và học sau

· 6 môn

Cấu trúc tính toán

Computation Structures

Mạch số, máy trạng thái, một bộ xử lý đơn giản và hợp ngữ. Nên học trước: môn Kiến trúc máy tính bắt đầu từ chỗ môn này dừng lại.

Xem chủ đề trên OpenER: Computation Structures

Lập trình

Programming

Đọc được C và con trỏ giúp rất nhiều — phần lớn bài tập về bộ nhớ đệm và hiệu năng viết bằng C.

Xem chủ đề trên OpenER: Programming

Hệ điều hành

Operating Systems

Bộ nhớ ảo, ngắt, chế độ đặc quyền là chỗ phần cứng và hệ điều hành bắt tay nhau. Học song song hoặc ngay sau.

Xem chủ đề trên OpenER: Operating Systems

Tính toán song song

Parallel Computing

Đi tiếp ý tưởng 3 và 4: viết chương trình thật sự dùng được nhiều nhân và GPU, đo tốc độ tăng và hiểu vì sao nó không tăng.

Xem chủ đề trên OpenER: Parallel Computing

Ngôn ngữ lập trình và trình biên dịch

Programming Languages and Compilers

Trình biên dịch là người dịch giữa code của bạn và ISA, và là người sắp lệnh sao cho đường ống, bộ nhớ đệm làm việc tốt nhất.

Xem chủ đề trên OpenER: Programming Languages and Compilers

Hệ thống nhúng

Embedded Systems

Phía bên kia của kiến trúc: bộ xử lý nhỏ, rẻ, tiết kiệm điện, nơi mỗi milliwatt và mỗi kilobyte đều được tính.

Xem chủ đề trên OpenER: Embedded Systems

Ứng dụng thật và nghề nghiệp

  • Thiết kế bộ xử lý và chip AI: kiến trúc sư vi xử lý, kỹ sư kiểm chứng, kỹ sư mô hình hiệu năng ở các công ty chip và các nhóm làm chip riêng của các công ty công nghệ lớn.
  • Kỹ sư hiệu năng: tối ưu thư viện tính toán, game engine, cơ sở dữ liệu, hệ thống giao dịch tần suất cao — nơi bộ nhớ đệm và dự đoán rẽ nhánh quyết định thắng thua.
  • Hạ tầng AI và GPU: viết và tối ưu chương trình chạy trên GPU, chọn phần cứng cho trung tâm dữ liệu.
  • Bảo mật phần cứng: tìm và vá các lỗ hổng kiểu Spectre, nơi tối ưu hiệu năng vô tình mở cửa rò rỉ dữ liệu.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • giải thích vì sao hai đoạn code cùng độ phức tạp lại chênh nhau nhiều lần về tốc độ, và sửa được đoạn chậm;
  • ước lượng hiệu năng của bộ nhớ đệm theo kích thước, cách tổ chức và cách chương trình truy cập dữ liệu;
  • vẽ được đường ống của một bộ xử lý, chỉ ra xung đột dữ liệu và cái giá của một lần đoán sai nhánh;
  • dùng định luật Amdahl để quyết định nên tối ưu phần nào trước, và biết khi nào song song hóa không đáng công;
  • đọc bảng thông số một con chip — số nhân, bộ nhớ đệm, tập lệnh — và hiểu nó nói gì về chương trình của bạn.

Nên biết trước: chủ đề Computation Structures (hợp ngữ, đường dữ liệu đơn giản) và lập trình C cơ bản. Nếu chưa học, đọc bài Cấu trúc tính toán và Từ electron đến ứng dụng trước.

Bắt đầu trên OpenER: trang chủ đề Computer Architecture and Engineering có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Khóa chính là Computer Architecture của Đại học Princeton trên Coursera, đi theo mạch sách Hennessy và Patterson; khóa tiếng Việt Kiến trúc máy tính trên OpenER giúp nắm thuật ngữ trước hoặc song song. Khi đã vững, môn sau đại học MIT 6.823 và khóa Computer Architecture của ETH Zürich đưa bạn vào sâu hệ thống bộ nhớ và các hướng nghiên cứu. Lời khuyên cho môn này: đo, đừng đoán. Mỗi khi đọc về một kỹ thuật, viết một đoạn code nhỏ để thấy nó trên máy mình — như ví dụ bức ảnh ở trên.

Tài liệu tham khảo

  • John L. Hennessy, David A. Patterson — Computer Architecture: A Quantitative Approach: giáo trình chuẩn của môn.
  • David A. Patterson, John L. Hennessy — Computer Organization and Design: The Hardware/Software Interface, RISC-V Edition: nhập môn, đọc trước cuốn trên.
  • Randal E. Bryant, David R. O'Hallaron — Computer Systems: A Programmer's Perspective, chương phân cấp bộ nhớ: kiến trúc nhìn từ phía người lập trình.
  • John L. Hennessy, David A. Patterson — "A New Golden Age for Computer Architecture", Communications of the ACM, 2019: bài giảng giải Turing, kể lại lịch sử từ System/360 tới RISC-V và bức tường công suất.
  • UC Berkeley CS 61C Great Ideas in Computer Architecture (Machine Structures) và CS 152 Computer Architecture and Engineering.
  • Princeton University — Computer Architecture (David Wentzlaff) trên Coursera.
  • MIT 6.823 Computer System Architecture — MIT OpenCourseWare.
  • ETH Zürich — Computer Architecture (Onur Mutlu), trang khóa học và video từng buổi.
  • RISC-V International — đặc tả tập lệnh RISC-V tại riscv.org.

Ban biên tập OpenER, “Kiến trúc máy tính: vì sao cùng một chương trình lại chạy nhanh gấp mười”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.