Tổng quan về giáo trình
Tài liệu "Khám Phá Kiến Trúc MIPS 32-bit: Hướng Dẫn Cơ Bản" là tài liệu học tập thuộc học phần Kiến trúc máy tính & Hợp ngữ trong chương trình đào tạo bậc đại học khối ngành Công nghệ Thông tin và Kỹ thuật Máy tính. Tài liệu giữ vị trí cầu nối then chốt giữa kiến thức phần cứng vi xử lý (tổ chức CPU, thanh ghi, đường truyền bus, bộ nhớ) và kỹ thuật lập trình phần mềm cấp thấp.
Mục tiêu học tập của tài liệu tập trung vào các chuẩn đầu ra cụ thể:
- Hiểu rõ nguyên lý vận hành cơ bản của bộ xử lý trung tâm (CPU) trong việc tiếp nhận và thực thi tập lệnh (instruction set).
- Nắm vững 4 nguyên tắc thiết kế của kiến trúc vi xử lý rút gọn (RISC - Reduced Instruction Set Computer).
- Thành thạo cấu trúc tệp mã nguồn hợp ngữ MIPS, bao gồm phân đoạn dữ liệu (
.data) và phân đoạn mã lệnh (.text).
- Nắm vững quy cách phân bổ và sử dụng 32 thanh ghi 32-bit trong CPU MIPS.
- Hiểu và vận dụng chính xác 4 nhóm lệnh vi kiến trúc cốt lõi: số học (arithmetic), truyền dữ liệu (data transfer), luận lý (logical), và điều khiển rẽ nhánh (branching).
- Có khả năng biên dịch thủ công và ánh xạ các cấu trúc dữ liệu, biểu thức tính toán và luồng điều khiển từ ngôn ngữ bậc cao (như C/C++) sang tập lệnh hợp ngữ MIPS 32-bit.
Cấu trúc tài liệu được thiết kế theo hướng tiếp cận logic vi kiến trúc: khởi đầu từ nguyên lý vật lý của lệnh máy, tiến dần đến mô hình tổ chức thanh ghi và bộ nhớ, sau đó đi sâu vào từng nhóm chỉ thị cụ thể đi kèm các ví dụ ánh xạ mã nguồn C. Điểm đặc sắc của tài liệu là phương pháp đối chiếu trực tiếp giữa cú pháp toán tử bậc cao và chuỗi chỉ thị hợp ngữ 3 toán hạng, giúp người học nhận thức rõ các giới hạn phần cứng như kích thước từ nhớ 32-bit, số lượng cổng mạch và cơ chế quản lý bộ nhớ.
Nội dung kiến thức cốt lõi
+-------------------------------------------------------------------------+
| KIẾN TRÚC TẬP LỆNH MIPS 32-BIT (RISC) |
+-------------------------------------------------------------------------+
| 1. Số học (Arithmetic) : add, sub, addi, addu, subu, mult, div |
| 2. Truyền dữ liệu (Data) : lw, sw, lb, lbu, lh, sh (Offset/Base) |
| 3. Luận lý & Dịch bit : and, or, nor, andi, ori, sll, srl, sra |
| 4. Rẽ nhánh (Branch/Jump) : beq, bne, j |
+------------------------------------+------------------------------------+
| HỆ THỐNG THANH GHI | QUY TẮC BỘ NHỚ RAM |
| * $0 ($zero) : Hằng số 0 | * Địa chỉ byte (Byte-addressable) |
| * $s0 - $s7 : Biến lưu trữ | * Alignment Restriction (Bội số 4)|
| * $t0 - $t7 : Biến tạm | * Thứ tự byte: Big Endian |
| * $hi, $lo : Nhân / Chia | * Kỹ thuật: Spilling Register |
| * $f0 - $f31 : Số thực | * Mở rộng bit: Sign/Zero-extended |
+------------------------------------+------------------------------------+
Các chương/chủ đề chính
Nội dung tài liệu được phân chia thành 7 chủ đề trọng tâm theo trình tự từ cấu trúc hệ thống đến lập trình chi tiết:
- Tổng quan về CPU và Triết lý Kiến trúc RISC: Trình bày nhiệm vụ cơ bản của CPU là thực thi tập lệnh (instruction). Phân tích các yếu tố ảnh hưởng đến kích thước lệnh (cấu trúc bus, kích thước/tổ chức bộ nhớ, tốc độ CPU) và giải pháp tối ưu (lệnh ngắn thực thi trong 1 chu kỳ, sử dụng bộ nhớ cache). Trình bày 4 nguyên tắc thiết kế kiến trúc RISC ứng dụng trên MIPS: Càng đơn giản càng ổn định; Càng nhỏ gọn xử lý càng nhanh; Tăng tốc xử lý cho các trường hợp thường xuyên xảy ra; Thiết kế đòi hỏi sự thỏa hiệp tốt. Minh họa ứng dụng thực tế của MIPS trên PlayStation 1, PlayStation 2, PSP, Windows CE, và thiết bị định tuyến Routers.
- Cấu trúc chương trình Hợp ngữ MIPS: Định dạng khung một chương trình hợp ngữ chuẩn với hai phân đoạn:
.data: Khai báo nhãn dữ liệu (data label), kiểu lưu trữ và giá trị khởi tạo (ví dụ: str: .asciiz "Hello asm !")..text: Chứa mã lệnh thực thi, khai báo nhãn toàn cục .globl main và điểm bắt đầu thực thi tại nhãn main:.- Minh họa cơ chế gọi hệ thống (system call) để in chuỗi thông qua việc nạp mã dịch vụ vào
$v0 (addi $v0, $0, 4), nạp địa chỉ chuỗi vào $a0 (la $a0, str) và gọi lệnh syscall.
- Hệ thống Thanh ghi trong Kiến trúc MIPS 32-bit: Mô tả thanh ghi là đơn vị lưu trữ dữ liệu duy nhất bên trong CPU MIPS. Hệ thống bao gồm 32 thanh ghi đa năng có kích thước cố định 32-bit (1 từ nhớ / word), đánh số từ
$0 đến $31:
$s0 - $s7 (thanh ghi $16 - $23): Nhóm thanh ghi lưu trữ (save registers), tương ứng với các biến trong ngôn ngữ C.$t0 - $t7 (thanh ghi $8 - $15): Nhóm thanh ghi tạm thời (temporary registers), dùng lưu trữ các giá trị trung gian.$zero (thanh ghi $0): Mang giá trị hằng số 0 cố định.$at (thanh ghi $1): Dành riêng cho trình biên dịch hợp ngữ (assembler).$k0 - $k1 (thanh ghi $26 - $27): Dành riêng cho hệ điều hành (OS kernel).$f0 - $f31: 32 thanh ghi dấu phẩy động biểu diễn số thực độ chính xác đơn (single precision), có thể ghép đôi để biểu diễn số thực độ chính xác kép (double precision).
- Nhóm lệnh Phép toán Số học (Arithmetic):
- Cú pháp chuẩn 3 toán hạng:
opt opr, opr1, opr2 (Toán tử, Thanh ghi đích, Thanh ghi nguồn 1, Thanh ghi/Hằng số nguồn 2).
- Các lệnh cộng/trừ có dấu và không dấu:
add, addu, sub, subu. Xử lý toán hạng hằng số qua lệnh addi (hỗ trợ cả giá trị âm để thực hiện phép trừ).
- Biểu diễn số nguyên có dấu theo định dạng bù 2. Cơ chế bẫy lỗi tràn số (overflow):
add, addi, sub phát hiện tràn số; addu, addiu, subu không bẫy tràn số (được các trình biên dịch C ưu tiên sử dụng).
- Phép nhân (
mult) và phép chia (div): Kết quả 64-bit được lưu vào cặp thanh ghi chuyên dụng $hi (32 bit cao / số dư) và $lo (32 bit thấp / thương số). Truy xuất thông qua các lệnh mfhi, mflo, mthi, mtlo.
- Nhóm lệnh Di chuyển Dữ liệu (Data Transfer) và Mô hình Bộ nhớ:
- Cấu trúc bộ nhớ xem như mảng 1 chiều đánh địa chỉ theo từng byte (8-bit). Cú pháp lệnh:
opt opr, opr1(opr2) với opr1 là độ dời (offset) và opr2 là thanh ghi cơ sở (base register).
- Nạp/lưu từ nhớ (32-bit):
lw (Load Word) và sw (Store Word).
- Nạp/lưu byte (8-bit):
lb (Load Byte có mở rộng bit dấu - sign-extended), lbu (Load Byte Unsigned chèn các bit 0), và sb (Store Byte).
- Nạp/lưu nửa từ (16-bit):
lh (Load Halfword) và sh (Store Halfword).
- Hai nguyên tắc tổ chức bộ nhớ trong MIPS: Ràng buộc căn lề (Alignment Restriction) - từ nhớ 4-byte phải bắt đầu tại địa chỉ chia hết cho 4 (offset phải là bội số của 4); và Quy tắc Big Endian - byte có trọng số lớn nhất được lưu trữ tại địa chỉ nhỏ nhất (đối lập với Little Endian trên kiến trúc x86).
- Kỹ thuật tràn thanh ghi (spilling register): Đưa các biến ít sử dụng ra bộ nhớ chính khi số biến vượt quá số thanh ghi khả dụng.
- Nhóm lệnh Thao tác Luận lý và Dịch bit (Logical):
- Phép toán xử lý trên từng bit riêng lẻ của từ 32-bit:
and, or, nor (với thanh ghi) và andi, ori (với hằng số). MIPS không thiết kế mạch riêng cho NOT, XOR, NAND nhằm tiết kiệm cổng phần cứng, thay vào đó tạo phép phủ định qua lệnh nor (ví dụ: not(A) = A nor 0).
- Phép dịch luận lý:
sll (shift left logical) chèn bit 0 bên phải (tương đương nhân với $2^n$), srl (shift right logical) chèn bit 0 bên trái.
- Phép dịch số học:
sra (shift right arithmetic) chèn các bit bằng giá trị bit dấu bên trái để bảo toàn dấu của số âm.
- Nhóm lệnh Điều khiển Luồng và Rẽ nhánh (Branching):
- Rẽ nhánh có điều kiện:
beq opr1, opr2, label (nhảy đến nhãn nếu hai giá trị bằng nhau) và bne opr1, opr2, label (nhảy đến nhãn nếu hai giá trị khác nhau).
- Rẽ nhánh không điều kiện:
j label (hoặc sử dụng lệnh giả định beq $0, $0, label).
- Mô hình chuyển đổi cấu trúc
if-else từ ngôn ngữ C sang các khối lệnh so sánh, nhảy và thực thi tuần tự trong hợp ngữ.
Kiến thức nền tảng được xây dựng
Giáo trình định hình các khái niệm kỹ thuật nền tảng:
- Mô hình tính toán dựa trên thanh ghi: Phân định sự khác biệt cốt lõi giữa ngôn ngữ cấp cao (biến định danh lưu trong RAM, có kiểu dữ liệu rõ ràng) và hợp ngữ (dữ liệu phi kiểu, lưu trữ trực tiếp trên thanh ghi phần cứng với số lượng hữu hạn, kiểu dữ liệu do thao tác lệnh quy định).
- Nguyên tắc vi kiến trúc phần cứng: Thiết kế tối giản cổng logic thông qua việc dùng chung linh kiện (dùng thanh ghi
$zero để thực hiện phép gán giá trị mà không cần lệnh riêng, dùng nor để suy biến thành các cổng logic khác).
- Cơ chế biểu diễn và lưu trữ dữ liệu: Cấu trúc bù 2 của số nguyên có dấu, quy tắc mở rộng dấu (sign extension), cách đánh địa chỉ ô nhớ và quy chuẩn căn chỉnh ranh giới từ nhớ (Alignment Restriction).
Kỹ năng phát triển
- Kỹ năng phân bổ tài nguyên phần cứng: Quản lý và tái sử dụng hiệu quả 32 thanh ghi, phân tách rõ vai trò của nhóm thanh ghi lưu trữ
$s và thanh ghi tạm $t, áp dụng kỹ thuật spilling register khi xử lý cấu trúc dữ liệu lớn.
- Kỹ năng biên dịch thủ công mã nguồn: Chia nhỏ các biểu thức phức tạp của ngôn ngữ bậc cao thành chuỗi các chỉ thị đơn nguyên 3 toán hạng của MIPS.
- Kỹ năng tính toán bit và địa chỉ bộ nhớ: Tính toán chính xác độ dời offset theo kích thước byte/nửa từ/từ nhớ, thao tác dịch bit số học và logic phục vụ các phép tính toán nhân chia nhanh.
Phương pháp giảng dạy và học tập
Giáo trình áp dụng phương pháp sư phạm diễn tiến hai chiều: Top-Down (từ biểu thức ngôn ngữ bậc cao trừu tượng phân rã thành các lệnh máy) kết hợp với Bottom-Up (từ cơ chế vật lý của từng thanh ghi và ô nhớ xây dựng nên cấu trúc chương trình hoàn chỉnh).
MÃ NGUỒN C: HỢP NGỮ MIPS 32-BIT:
f = (g + h) - (i + j); ===> add $t0, $s1, $s2 # $t0 = g + h
add $t1, $s3, $s4 # $t1 = i + j
sub $s0, $t0, $t1 # f = $t0 - $t1
Hệ thống bài tập và nghiên cứu tình huống trong tài liệu được thiết kế bám sát các trường hợp thực thi cụ thể:
- Phân tích chương trình mẫu hoàn chỉnh: Khảo sát luồng thực thi của chương trình in chuỗi văn bản
.asciiz thông qua cơ chế ngắt hệ thống syscall.
- Ánh xạ biểu thức số học nhiều toán hạng:
- Biểu thức $a = b + c + d - e$ được phân tách tuần tự:
add $s0, $s1, $s2 # a = b + c
add $s0, $s0, $s3 # a = a + d
sub $s0, $s0, $s4 # a = a - e
- Biểu thức lồng nhau $f = (g + h) - (i + j)$ sử dụng thanh ghi tạm:
add $t0, $s1, $s2 # temp1 = g + h
add $t1, $s3, $s4 # temp2 = i + j
sub $s0, $t0, $t1 # f = temp1 - temp2
- Thao tác truy xuất mảng và cấu trúc dữ liệu:
- Thao tác $g = h + A[8]$ (với địa chỉ nền mảng $A$ trong
$s3, mỗi phần tử 4 byte):
lw $t0, 32($s3) # Offset = 8 * 4 = 32 byte. $t0 = A[8]
add $s1, $s2, $t0 # g = h + A[8]
- Thao tác $A[12] = h - A[8]$:
lw $t0, 32($s3) # Nạp A[8] vào $t0
sub $t0, $s2, $t0 # $t0 = h - A[8]
sw $t0, 48($s3) # Lưu kết quả vào A[12] (Offset = 12 * 4 = 48)
- Thực nghiệm dịch bit trên dữ liệu nhị phân: Khảo sát sự biến đổi giá trị của thanh ghi chứa số dương ($85$) và số âm ($-16$) qua các lệnh
sll, srl, và sra với độ dịch 2 bit:
sll dịch trái $85$ ($\text{0101 } \text{0101}_2$) thành $340$ ($85 \times 2^2$).srl dịch phải $85$ thành $21$ ($85 / 2^2$).sra dịch phải số học $-16$ ($\text{1111 } \text{0000}_2$) thành $-4$ ($\text{1111 } \text{1100}_2$, bảo toàn bit dấu 1).
- Biên dịch cấu trúc điều khiển rẽ nhánh: Ánh xạ cấu trúc
if (i == j) f = g + h; else f = g - h;:
beq $s3, $s4, TrueCase # Kiểm tra điều kiện (i == j)
FalseCase:
sub $s0, $s1, $s2 # Nhánh false: f = g - h
j Final # Nhảy qua nhánh true
TrueCase:
add $s0, $s1, $s2 # Nhánh true: f = g + h
Final:
...
Phương pháp đánh giá năng lực học tập dựa trên việc truy vết (tracing) trạng thái thanh ghi và bộ nhớ theo từng chu kỳ xung nhịp, tính toán chính xác chỉ số offset của mảng, và tối ưu hóa số lượng chỉ thị lệnh khi ánh xạ mã nguồn C.
Điểm nổi bật và cập nhật
Nội dung tài liệu phản ánh các đặc tính kỹ thuật thực tế của kiến trúc MIPS và nguyên lý thiết kế vi xử lý hiện đại:
- Minh họa ứng dụng công nghiệp thực tế: Kiến trúc MIPS 32-bit được trình bày gắn liền với các nền tảng phần cứng thương mại như hệ máy chơi game PlayStation 1, PlayStation 2, PlayStation Portable (PSP), hệ điều hành nhúng Windows CE và các thiết bị định tuyến mạng (routers).
- Phân tích sâu về nguyên lý tối ưu phần cứng: Tài liệu làm rõ lý do tại sao kiến trúc RISC không trang bị các lệnh phức tạp (như phép gán độc lập hay các cổng logic
NOT/XOR). Việc tận dụng thanh ghi $zero để gán giá trị (add $s0, $s1, $zero) và cổng nor (A nor 0) giúp giảm thiểu số lượng bóng bán dẫn (transistor) và diện tích vi mạch, từ đó tăng tốc độ xung nhịp CPU.
- Phân định xử lý ngoại lệ số học giữa phần cứng và trình biên dịch: Phân tích sự khác biệt giữa các lệnh kiểm tra tràn số (
add, sub) và các lệnh không kiểm tra tràn số (addu, subu, addiu). Giải thích rõ lý do các trình biên dịch ngôn ngữ C cho kiến trúc MIPS mặc định sử dụng các lệnh không bẫy tràn số (addu, subu) để tối ưu hóa hiệu năng thực thi.
- Chuẩn hóa quy cách lưu trữ dữ liệu: Làm rõ sự khác biệt giữa nguyên tắc sắp xếp byte Big Endian (byte cao ở địa chỉ thấp của MIPS) và Little Endian (trên kiến trúc x86), đồng thời giải thích bản chất vật lý của quy tắc căn lề dữ liệu 4-byte (Alignment Restriction).
Đối tượng sử dụng giáo trình
Tài liệu được biên soạn phục vụ các nhóm đối tượng cụ thể trong môi trường học thuật:
- Sinh viên đại học: Sinh viên năm thứ hai hoặc năm thứ ba thuộc các chuyên ngành Khoa học Máy tính, Kỹ thuật Máy tính, Công nghệ Thông tin, Kỹ thuật Phần mềm và Hệ thống Thông tin đang theo học học phần Kiến trúc Máy tính, Hợp ngữ, hoặc Thiết kế Vi xử lý.
- Điều kiện tiên quyết (Prerequisites):
- Đã hoàn thành học phần Nhập môn Lập trình hoặc Kỹ thuật Lập trình (yêu cầu hiểu rõ ngôn ngữ C/C++, con trỏ, biến và mảng).
- Có kiến thức về hệ thống số học máy tính (biểu diễn nhị phân, thập lục phân, số nguyên bù 2, logic Boolean).
- Giảng viên chuyên ngành: Sử dụng làm tài liệu khung để thiết kế bài giảng lý thuyết, biên soạn bài tập lập trình hợp ngữ, và xây dựng các bài thí nghiệm trên các bộ mô phỏng vi kiến trúc MIPS (như MARS hoặc SPIM).
- Người tự học và kỹ sư phát triển phần mềm hệ thống: Tài liệu tham khảo cho người cần nghiên cứu cơ chế biên dịch mã nguồn cấp thấp, lập trình hệ thống nhúng, hoặc tối ưu hóa hiệu năng ứng dụng ở mức vi kiến trúc.
Câu hỏi thường gặp
1. Giáo trình này phù hợp với ai?
Tài liệu được thiết kế cho sinh viên đại học khối ngành Công nghệ Thông tin và Kỹ thuật Máy tính đang học môn Kiến trúc máy tính & Hợp ngữ, cũng như các kỹ sư phần mềm muốn tìm hiểu sâu về nguyên lý vận hành của CPU và mã máy.
2. Cần kiến thức nền nào để học?
Người học cần nắm vững cú pháp lập trình ngôn ngữ C/C++ cơ bản (biến, mảng, cấu trúc điều khiển if-else), hệ thống biểu diễn số nhị phân, thập lục phân (hexadecimal), số nguyên bù 2 và các phép toán logic cơ bản.
3. Điểm khác biệt giữa kiến trúc MIPS trong giáo trình này và x86 là gì?
MIPS là kiến trúc RISC có kích thước lệnh cố định 32-bit, sử dụng 32 thanh ghi đa năng có tên gọi chuẩn hóa, lưu trữ theo thứ tự byte Big Endian và tuân thủ nghiêm ngặt quy tắc căn lề 4-byte (Alignment Restriction). Ngược lại, kiến trúc x86 thuộc hệ CISC, lệnh có kích thước biến đổi và sử dụng định dạng Little Endian.
4. Làm sao để tự học và nắm vững các lệnh MIPS hiệu quả?
Người học nên kết hợp đọc hiểu nguyên tắc lý thuyết với việc thực hành ánh xạ các đoạn mã C nhỏ sang hợp ngữ, vẽ lại sơ đồ thay đổi dữ liệu của 32 thanh ghi sau mỗi câu lệnh, và chú ý tính toán độ dời offset theo bội số của 4 khi thao tác trên bộ nhớ từ (lw, sw).
5. Có tài liệu bổ trợ nào kèm theo nội dung này?
Tài liệu bổ trợ bao gồm bảng tra cứu tập lệnh chuẩn MIPS32 Green Sheet, danh mục các mã gọi hệ thống syscall, và các công cụ phần mềm mô phỏng vi xử lý MIPS (như MARS Simulator hoặc SPIM) để nạp và chạy thử nghiệm các tệp mã nguồn .text và .data.
Kết luận
Tài liệu "Khám Phá Kiến Trúc MIPS 32-bit: Hướng Dẫn Cơ Bản" cung cấp hệ thống tri thức hoàn chỉnh về kiến trúc tập lệnh vi xử lý RISC, làm sáng tỏ mối liên hệ giữa các cấu trúc phần mềm cấp cao và cách thức điều khiển phần cứng vi mạch thực tế.
Lộ trình học tập khuyến nghị bắt đầu từ việc nắm vững mô hình 32 thanh ghi đa năng, thực hành các thao tác số học và logic cơ bản, tiếp cận kỹ thuật quản lý bộ nhớ và mảng thông qua cơ chế căn lề dữ liệu, và hoàn thiện kỹ năng lập trình luồng điều khiển với các lệnh rẽ nhánh. Đây là nền tảng học thuật cốt lõi giúp người học phát triển năng lực thiết kế hệ thống, lập trình nhúng và phân tích tối ưu hóa mã nguồn ở cấp độ vi kiến trúc.
