Tổng quan về giáo trình

Tài liệu học thuật Kiến trúc Máy tính – Chương 3: MIPS Instruction Set Architecture được biên soạn bởi tác giả Võ Tấn Phương thuộc Khoa Khoa học và Kỹ thuật Máy tính, Trường Đại học Bách Khoa – Đại học Quốc gia TP.HCM (phiên bản cập nhật Fall 2017). Trong chương trình đào tạo kỹ sư và cử nhân ngành Khoa học Máy tính và Kỹ thuật Máy tính, môn học Kiến trúc Máy tính giữ vị trí nền tảng, thiết lập mối liên kết giữa phần cứng vi xử lý và phần mềm hệ thống.

Mục tiêu đào tạo cốt lõi của tài liệu tập trung vào việc trang bị cho người học hiểu biết chi tiết về Kiến trúc tập lệnh (Instruction Set Architecture - ISA). Tài liệu đóng vai trò là giao diện trừu tượng hóa phần cứng dưới góc nhìn của lập trình viên và người thiết kế trình biên dịch. Thông qua việc phân tích kiến trúc vi xử lý MIPS (Microprocessor without Interlocked Pipelined Stages) – đại diện tiêu biểu cho trường phái tính toán tập lệnh rút gọn (RISC), người học nắm vững:

  • Cơ chế quản lý tài nguyên thanh ghi,
  • Không gian định địa chỉ bộ nhớ,
  • Định dạng lệnh máy 32-bit,
  • Kỹ thuật chuyển đổi các cấu trúc điều khiển của ngôn ngữ bậc cao sang hợp ngữ MIPS.

Tài liệu sử dụng phương pháp tiếp cận diễn dịch: đi từ các nguyên lý phân loại kiến trúc máy tính tổng quát (Stack, Accumulator, Register-Memory, Memory-Memory, Load-Store), sau đó đi sâu vào phân tích cấu trúc vi xử lý MIPS32, quy ước sử dụng tập thanh ghi, các định dạng lệnh R-Type, I-Type, J-Type và cách hiện thực logic điều khiển, rẽ nhánh tối ưu.

Nội dung kiến thức cốt lõi

+-------------------------------------------------------------------------------+
|                       MIPS INSTRUCTION SET ARCHITECTURE                       |
+-------------------------------------------------------------------------------+
         |                                |                            |
         v                                v                            v
+------------------+             +------------------+         +-----------------+
|  R-Type (32 bit) |             |  I-Type (32 bit) |         | J-Type (32 bit) |
+------------------+             +------------------+         +-----------------+
| Op6: Opcode = 0  |             | Op6: Opcode      |         | Op6: Opcode = 2 |
| Rs5: Source 1    |             | Rs5: Source      |         | Imm26: Target   |
| Rt5: Source 2    |             | Rt5: Dest/Source |         |                 |
| Rd5: Destination |             | Imm16: Immediate |         +-----------------+
| Sa5: Shift Amt   |             +------------------+
| Funct6: Function |
+------------------+

Các chương và chủ đề chính

Tài liệu Chương 3 tập trung vào 8 chuyên đề kỹ thuật có tính liên kết chặt chẽ:

  1. Khái niệm Kiến trúc Tập lệnh (ISA): Định nghĩa ISA như một giao diện giữa phần cứng và phần mềm. Trình bày các thành phần bắt buộc của một ISA gồm: tập lệnh, kiểu dữ liệu, đối tượng lưu trữ (Thanh ghi và Bộ nhớ), các chế độ định địa chỉ và cơ chế xử lý ngoại lệ (Exception handling). Giới thiệu dòng thời gian phát triển của các kiến trúc tiêu biểu: Intel x86 (1978), MIPS (1986) và PowerPC (1993).
  2. Phân loại và so sánh các mô hình kiến trúc xử lý: Phân tích 5 mô hình xử lý thông qua lệnh mẫu $C = A + B$:
    • Kiến trúc thanh ghi tích lũy (Accumulator): Toán hạng ngầm định nằm trong Accumulator (load b, add c, store a).
    • Kiến trúc ngăn xếp (Stack): Toán hạng ngầm định trên đỉnh ngăn xếp TOS (push a, push b, add, pop c).
    • Kiến trúc Register-Memory: 2 toán hạng, cho phép 1 toán hạng từ bộ nhớ (Load r1, A, Add r1, B, Store C, r1).
    • Kiến trúc Memory-Memory: 3 toán hạng đều có thể là ô nhớ (Add C, B, A).
    • Kiến trúc Register-Register (Load-Store): 3 toán hạng đều là thanh ghi, chỉ lệnh Load và Store mới được truy xuất bộ nhớ.
  3. Cấu trúc phần cứng vi xử lý MIPS32:
    • Đơn vị thực thi số nguyên (Execution & Integer Unit - EIU): ALU, bộ nhân/chia (Hi, Lo), 32 thanh ghi đa dụng 32-bit.
    • Đơn vị dấu chấm động (Floating Point Unit - FPU / Coprocessor 1): 32 thanh ghi số thực ($F0 - $F31) và FP ALU.
    • Đơn vị bẫy và quản lý bộ nhớ (Trap & Memory Unit - TMU / Coprocessor 0): Chứa các thanh ghi trạng thái BadVaddr, Status, Cause, EPC.
    • Tổ chức không gian nhớ 32-bit: Địa chỉ tối đa $2^{32}\text{ bytes} = 2^{30}\text{ words}$ (4 bytes mỗi word).
  4. Quy ước tên gọi và sử dụng 32 thanh ghi đa dụng:
Ký hiệu thanh ghi Mã số thanh ghi Mục đích sử dụng quy ước
$zero $0 Hằng số 0 cố định ở mức phần cứng
$at $1 Dành riêng cho trình hợp dịch (Assembler Temporary)
$v0 – $v1 $2 – $3 Chứa giá trị trả về của hàm
$a0 – $a3 $4 – $7 Chứa các tham số truyền vào hàm
$t0 – $t7 $8 – $15 Biến tạm thời (Temporary values)
$s0 – $s7 $16 – $23 Biến cần bảo toàn qua lời gọi hàm (Saved registers)
$t8 – $t9 $24 – $25 Các biến tạm bổ sung
$k0 – $k1 $26 – $27 Dành riêng cho nhân hệ điều hành (OS Kernel)
$gp $28 Con trỏ vùng dữ liệu toàn cục (Global Pointer)
$sp $29 Con trỏ đỉnh ngăn xếp (Stack Pointer)
$fp $30 Con trỏ khung ngăn xếp (Frame Pointer)
$ra $31 Địa chỉ trả về cho lệnh gọi hàm jal (Return Address)
  1. Định dạng lệnh và tập lệnh loại R (Register-Type): Cấu trúc 32-bit gồm 6 trường: Op (6 bit, giá trị 0), Rs (5 bit), Rt (5 bit), Rd (5 bit), sa (5 bit - Shift Amount), funct (6 bit - Function Code). Phân tích chi tiết:
    • Các lệnh số học: add, addu, sub, subu (phân biệt cơ chế bắt ngoại lệ tràn số giữa phiên bản có dấu và không dấu).
    • Các lệnh luận lý: and, or, xor, nor (ứng dụng nor để thực hiện phép not).
    • Các lệnh dịch bit: sll (dịch trái logic), srl (dịch phải logic), sra (dịch phải số học bảo toàn bit dấu), sllv, srlv, srav (dịch với số lượng bit lưu trong thanh ghi).
    • Giải thuật nhân số nguyên bằng tổ hợp phép dịch trái và phép cộng/trừ (ví dụ nhân với 36, 26, 31).
  2. Định dạng lệnh và tập lệnh loại I (Immediate-Type): Cấu trúc 32-bit gồm 4 trường: Op (6 bit), Rs (5 bit), Rt (5 bit - đóng vai trò thanh ghi đích trong lệnh tính toán), Immediate (16 bit hằng số).
    • Các lệnh số học và luận lý hằng số: addi, addiu, andi, ori, xori.
    • Lệnh nạp 16 bit cao lui (Load Upper Immediate) kết hợp với ori để khởi tạo hằng số 32-bit bất kỳ vào thanh ghi.
    • Các lệnh rẽ nhánh có điều kiện: beq, bne, bltz, bgtz, blez, bgez.
    • Các lệnh so sánh: slti, sltiu.
  3. Định dạng lệnh loại J (Jump-Type) và cơ chế cập nhật PC: Cấu trúc gồm Op (6 bit, mã 2 cho lệnh j) và Immediate (26 bit địa chỉ). Cơ chế tính toán địa chỉ Program Counter kế tiếp: $\text{Next PC} = \text{PC}{31..28} \parallel (\text{Immediate}{25..0} \ll 2)$.
  4. Kỹ thuật chuyển đổi cấu trúc điều khiển và biểu thức logic:
    • Hiện thực câu lệnh điều kiện if-else bằng bne, beq, j.
    • Tối ưu hóa kỹ thuật đánh giá ngắn mạch (Short-circuit evaluation) cho biểu thức điều kiện AND (&&) và OR (||). Phương pháp đảo ngược phép toán quan hệ (ví dụ: chuyển đổi > thành <=) giúp giảm số lượng chỉ lệnh hợp ngữ từ 5 lệnh xuống 3 lệnh.
    • Tập lệnh giả (Pseudo-Instructions) như move, not, li, sgt, blt, ble, bgt, bge và nguyên lý chuyển dịch tự động qua thanh ghi $at.

Kiến thức nền tảng được xây dựng

  • Nguyên lý thiết kế RISC: Tính đơn giản của phần cứng thông qua tập lệnh cố định chiều dài 32-bit, chuẩn hóa 3 định dạng lệnh, hạn chế việc truy xuất trực tiếp bộ nhớ trong các phép toán ALU.
  • Biểu diễn số học máy tính: Hệ thống số nguyên không dấu $n$-bit (tầm trị $0$ đến $2^n-1$) và số nguyên có dấu dạng bù 2 (tầm trị $-2^{n-1}$ đến $2^{n-1}-1$).
  • Phân biệt cờ Nhớ (Carry) và cờ Tràn (Overflow): Xác định sự độc lập giữa hai cờ trạng thái; Carry phục vụ số nguyên không dấu khi vượt quá $2^n-1$, trong khi Overflow phục vụ số nguyên có dấu khi cộng hai số cùng dấu sinh ra kết quả trái dấu.
       A, B cùng dấu (+) ------------> Kết quả (-) ===> OVERFLOW = 1
       A, B cùng dấu (-) ------------> Kết quả (+) ===> OVERFLOW = 1
       Cộng không dấu có nhớ ra ngoài bit MSB ======> CARRY = 1

Kỹ năng phát triển

  • Kỹ năng mã hóa và giải mã chỉ lệnh MIPS từ dạng mã gợi nhớ (Assembly) sang biểu diễn nhị phân/thập lục phân (Machine Code) dựa trên bảng tra mã Opcode và Funct.
  • Kỹ năng phân tích và ánh xạ các biến, biểu thức số học từ ngôn ngữ lập trình bậc cao (C/C++) sang thanh ghi MIPS.
  • Kỹ năng tái cấu trúc luồng điều khiển và tối ưu hóa số lượng lệnh thực thi khi xử lý các biểu thức logic phức tạp.

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 cấu trúc hóa theo từng tầng trừu tượng, kết hợp chặt chẽ giữa lý thuyết phần cứng và kỹ thuật lập trình hệ thống:

  • Phương pháp phân tích đối chiếu: Đưa ra các ví dụ cụ thể như câu lệnh gán $C = A + B$ hoặc $C = A + B + 5$ để so sánh trực tiếp cơ chế thực thi giữa 5 mô hình kiến trúc vi xử lý (Stack, Accumulator, Register-Memory, Memory-Memory, Load-Store), từ đó làm rõ ưu và nhược điểm của kiến trúc Load-Store của MIPS.
  • Hệ thống bài tập tính toán và chuyển dịch mã:
    • Bài tập tính toán tầm biểu diễn của số nguyên có dấu và không dấu $n$-bit (như bài toán xác định giới hạn số 20-bit: số không dấu tối đa $2^{20}-1 = 1,048,575$; số có dấu từ $-524,288$ đến $524,287$).
    • Bài tập chuyển đổi biểu thức số học phức tạp như $f = (g + h) - (i + j)$ sang chuỗi lệnh addu và subu.
    • Bài tập tối ưu hóa phép nhân thông qua phân tích thừa số thành tổng các lũy thừa của 2 (ví dụ: phân tích $26 = 2 + 8 + 16$ tương ứng với các phép dịch trái 1, 3, 4 bit kết hợp lệnh cộng; hoặc $31 = 32 - 1$ bằng phép dịch trái 5 bit kết hợp lệnh trừ).
  • Phân tích tối ưu hóa thuật toán: Hướng dẫn sinh viên phương pháp đảo ngược điều kiện biên để loại bỏ các lệnh nhảy trung gian không cần thiết trong cấu trúc rẽ nhánh if lồng biểu thức boolean AND/OR.
  • Đánh giá kết quả học tập: Người học được kiểm tra năng lực thông qua việc dịch ngược mã máy 32-bit sang hợp ngữ, viết các đoạn mã hợp ngữ xử lý mảng và cấu trúc lặp, giải thích hiện tượng ngoại lệ số học (Arithmetic Exception) khi xảy ra tràn số.

Điểm nổi bật và cập nhật

  • Tính chuẩn xác và bám sát kiến trúc phần cứng thực tế: Tài liệu mô tả chi tiết sơ đồ khối phần cứng của MIPS bao gồm Execution & Integer Unit, Floating Point Unit (Coprocessor 1), và Trap & Memory Unit (Coprocessor 0) với các thanh ghi phần cứng chuyên dụng (EPC, Cause, Status, BadVaddr).
  • Dữ liệu thực tế từ ngành công nghiệp: Trích dẫn các số liệu công nghiệp cụ thể, bao gồm việc kiến trúc MIPS được ứng dụng rộng rãi bởi các tập đoàn công nghệ như Silicon Graphics, ATI, Cisco, Sony, và đạt doanh số gần 100 triệu bộ xử lý bán ra trong năm 2002.
  • Phân định rõ ranh giới phần cứng và phần mềm: Phân biệt rõ giữa các lệnh thực thi trực tiếp trên phần cứng (Hardware Instructions) và các lệnh giả (Pseudo-Instructions như move, not, li, sgt, blt, ble) được trình hợp dịch chuyển đổi tự động thông qua việc sử dụng thanh ghi $at ($1).
+-----------------------------+
|    Pseudo-Instruction       |
|    blt $s1, $s2, label      |
+-----------------------------+
               |
               v (Trình hợp dịch chuyển đổi tự động)
+-----------------------------+
|    Hardware Instructions    |
|    slt $at, $s1, $s2        |
|    bne $at, $zero, label    |
+-----------------------------+

Đối tượng sử dụng giáo trình

  1. Sinh viên bậc Đại học: Sinh viên năm thứ hai hoặc năm thứ ba thuộc các ngành Khoa học Máy tính, Kỹ thuật Máy tính, Công nghệ Thông tin, Điện tử - Viễn thông đang học môn Kiến trúc Máy tính, Hợp ngữ hoặc Thiết kế Hệ thống Nhúng.
  2. Yêu cầu kiến thức tiên quyết:
    • Kiến thức về Hệ số đếm (Nhị phân, Bát phân, Thập lục phân) và các phép toán logic cơ bản.
    • Kiến thức nền tảng về Lập trình cấu trúc (C/C++), bao gồm con trỏ, cấu trúc rẽ nhánh, mảng và hàm.
    • Khái niệm cơ bản về mạch số (ALU, thanh ghi, bộ nhớ).
  3. Giảng viên và Cán bộ nghiên cứu: Tài liệu cung cấp cấu trúc bài giảng mẫu, bảng tra cứu tập lệnh MIPS32 chuẩn, phục vụ biên soạn giáo án, bài tập thực hành trên các công cụ mô phỏng vi xử lý MIPS (như MARS, SPIM).
  4. Kỹ sư phần mềm hệ thống: Người cần tài liệu tra cứu về quy ước gọi hàm, tổ chức thanh ghi và tối ưu hóa mã ở mức chỉ lệnh máy.

Câu hỏi thường gặp

1. Giáo trình này phù hợp với đối tượng người học nào?

Tài liệu được thiết kế cho sinh viên đại học chuyên ngành Kỹ thuật Máy tính và Khoa học Máy tính, cùng các kỹ sư cần hiểu sâu về cơ chế vận hành của bộ xử lý RISC và lập trình hợp ngữ.

2. Cần chuẩn bị những kiến thức nền tảng nào trước khi tiếp cận tài liệu?

Người học cần nắm vững kỹ thuật lập trình C cơ bản, biểu diễn số nhị phân/bù 2, và các khái niệm logic mạch số cơ bản (cổng logic, thanh ghi, ALU).

3. Điểm khác biệt cốt lõi giữa kiến trúc tập lệnh MIPS và Intel x86 là gì?

MIPS thuộc kiến trúc RISC với độ dài lệnh cố định 32-bit, sử dụng mô hình Load-Store (chỉ truy xuất bộ nhớ qua lệnh lw/sw) và có 32 thanh ghi đa dụng. Ngược lại, Intel x86 (IA-32) thuộc kiến trúc CISC với độ dài lệnh thay đổi, hỗ trợ tính toán trực tiếp trên các toán hạng bộ nhớ.

4. Tại sao MIPS không hỗ trợ trực tiếp lệnh trừ hằng số (subi)?

Trong MIPS, lệnh addi và addiu sử dụng trường hằng số tức thời 16-bit có dấu dạng bù 2. Để thực hiện phép trừ một hằng số $K$, trình biên dịch sử dụng lệnh addi hoặc addiu với giá trị âm $-K$, do đó phần cứng không cần thiết kế thêm lệnh subi.

5. Những công cụ và tài liệu nào có thể sử dụng kèm theo bài giảng này?

Người học có thể sử dụng các môi trường mô phỏng MIPS như MARS (MIPS Assembler and Runtime Simulator) hoặc SPIM, kết hợp với tài liệu tham khảo giáo trình chuẩn Computer Organization and Design của David A. Patterson và John L. Hennessy.

Kết luận

Chương 3 giáo trình Kiến trúc Máy tính: MIPS Instruction Set Architecture của tác giả Võ Tấn Phương cung cấp một hệ thống kiến thức toàn diện và có cấu trúc về kiến trúc tập lệnh RISC MIPS32. Nội dung tài liệu làm rõ cấu tạo phần cứng, phân tích chi tiết các định dạng lệnh 32-bit (R, I, J), thiết lập quy chuẩn sử dụng 32 thanh ghi đa dụng và chuẩn hóa phương pháp chuyển đổi các cấu trúc giải thuật từ ngôn ngữ bậc cao sang hợp ngữ.

Lộ trình học tập đề xuất:

  1. Nắm vững nguyên lý biểu diễn số bù 2 và các mô hình kiến trúc vi xử lý.
  2. Phân tích chi tiết 3 định dạng lệnh và bảng mã Opcode/Funct.
  3. Thực hành chuyển dịch các biểu thức số học, logic và cấu trúc điều khiển trên phần mềm mô phỏng.
  4. Nghiên cứu sâu cơ chế gọi hàm, quản lý ngăn xếp và xử lý ngoại lệ trên Coprocessor 0.