Giới thiệu dự án

Trong kỷ nguyên bùng nổ của vi mạch bán dẫn và các kiến trúc tính toán chuyên dụng, kiến trúc tập lệnh mở RISC-V (Reduced Instruction Set Computer V) đã nổi lên như một cuộc cách mạng trong thiết kế vi xử lý. Khác với kiến trúc độc quyền x86 (Intel/AMD) hay ARM với chi phí bản quyền lên đến hàng triệu USD, RISC-V được chuẩn hóa bởi RISC-V International, cung cấp một tiêu chuẩn mở, miễn phí và có tính tùy biến mở rộng cực cao. Tuy nhiên, quy trình thiết kế và xác minh vi xử lý phần cứng (ASIC/FPGA) đòi hỏi một mô hình tham chiếu chuẩn (Golden Reference Model) để đối soát tính đúng đắn của logic RTL (Register Transfer Level).

Khóa luận tốt nghiệp chuyên ngành Kỹ thuật Máy tính tại Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM đã nghiên cứu và phát triển thành công Bộ mô phỏng tập lệnh RISC-V (Instruction Set Simulator - ISS) độc lập phần cứng, tích hợp mô-đun giám sát độ bao phủ (Coverage Monitor) và công cụ gỡ lỗi (Debugger) phục vụ quy trình xác minh tự động.

+---------------------------------------------------------------------------------+
|                       HỆ THỐNG XÁC MINH CHỨC NĂNG BỘ XỬ LÝ                     |
+---------------------------------------------------------------------------------+
                                         |
                                         v
                      +-------------------------------------+
                      |  Bộ phát sinh kiểm thử ngẫu nhiên   |
                      |            (RISC-V RTG)             |
                      +-------------------------------------+
                                         |
                        [Chương trình hợp ngữ .s]
                                         |
                                         v
                      +-------------------------------------+
                      |       Trình biên dịch hợp ngữ       |
                      |             (Assembler)             |
                      +-------------------------------------+
                                         |
                        [Chương trình mã máy .bin/.txt]
                                         |
                   +---------------------+---------------------+
                   |                                           |
                   v                                           v
+-------------------------------------+     +-------------------------------------+
|   Bộ mô phỏng tập lệnh RISC-V ISS   |     |       Mô phỏng phần cứng RTL        |
|      (Golden Reference Model)       |     |          (RTL Simulation)           |
+-------------------------------------+     +-------------------------------------+
                   |                                           |
         [Dữ liệu thanh ghi/Memory]                 [Dữ liệu thanh ghi/Dạng sóng]
                   |                                           |
                   +---------------------+---------------------+
                                         |
                                         v
                      +-------------------------------------+
                      |     Bộ so sánh trạng thái logic     |
                      |            (Comp-runner)            |
                      +-------------------------------------+
                                         |
                                         v
                      +-------------------------------------+
                      |    Bộ thống kê độ bao phủ kiểm thử  |
                      |         (Coverage Monitor)          |
                      +-------------------------------------+

Vấn đề thực tiễn và bài toán đặt ra

Trong quy trình kiểm tra chức năng vi xử lý truyền thống, kỹ sư phần cứng thường gặp các trở ngại lớn:

  1. Thiếu mô hình kiểm thử độc lập: Việc mô phỏng dạng sóng RTL bằng các công cụ như ModelSim, QuestaSim hay VCS tiêu tốn nhiều thời gian và khó cô lập chính xác lỗi bắt nguồn từ logic giải mã lệnh hay đường ống dữ liệu (datapath).
  2. Độ phức tạp trong đánh giá độ bao phủ: Các mô hình kiểm tra tĩnh không thể đo lường chính xác hành vi rẽ nhánh động (dynamic branching), luồng nhảy lặp và truy xuất bộ nhớ đa tầng.
  3. Chi phí công cụ đắt đỏ: Các bộ mô phỏng công nghiệp yêu cầu bản quyền phức tạp, không linh hoạt trong việc tùy chỉnh bộ tiêu chí kiểm thử cho các nhóm nghiên cứu vi xử lý tùy biến.

Mục tiêu của đề tài

  1. Nghiên cứu kiến trúc RV32I: Hiện thực hóa bộ giải mã và thực thi đầy đủ cho 37 lệnh cơ sở thuộc kiến trúc tập lệnh số nguyên 32-bit (RV32I) và hỗ trợ các lệnh đồng bộ hóa như LR.W.
  2. Xây dựng Assembler chuyên dụng: Phát triển trình biên dịch hợp ngữ hai bước (Two-pass Assembler) chuyển đổi mã nguồn Assembly RISC-V thành mã máy nhị phân.
  3. Phát triển lõi mô phỏng ISS: Thiết kế mô hình trạng thái gồm con trỏ lệnh (Program Counter - PC), 32 thanh ghi đa dụng (x0–x31) và không gian bộ nhớ mô phỏng (Emulated Memory).
  4. Tích hợp Coverage Monitor theo cấu hình: Xây dựng thuật toán tính toán độ bao phủ dựa trên tệp cấu hình động (configuration file) để định lượng chất lượng bộ kiểm thử từ RTG (Random Test Generator).
  5. Cung cấp chế độ gỡ lỗi tương tác: Hỗ trợ chế độ thực thi toàn bộ (Run Program) và gỡ lỗi có điểm dừng (Breakpoint) hoặc từng bước (Step-by-step).

Phương pháp tiếp cận và phạm vi đề tài

  • Phương pháp tiếp cận: Ứng dụng lập trình hướng đối tượng (OOP) bằng Python 3 để trừu tượng hóa các khối phần cứng (ALU, Register File, Memory, Decoder). Mô hình hoạt động độc lập ở mức trừu tượng chức năng (Functional Level), không phụ thuộc vào chu kỳ xung nhịp phần cứng (Cycle-agnostic).
  • Phạm vi nghiên cứu: Kiến trúc tập lệnh RV32I (Base Integer 32-bit), hỗ trợ 6 định dạng lệnh chuẩn (R-type, I-type, S-type, SB-type, U-type, UJ-type). Không gian đánh địa chỉ bộ nhớ dạng Byte-addressable.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng và các công cụ liên quan

Tiêu chí kỹ thuật FireSim (UC Berkeley) Vulcan Simulator MARS 4.5 (Missouri Univ.) RISC-V ISS (Đề tài đề xuất)
Kiến trúc mục tiêu RISC-V (RV64G/Rocket) RISC-V (RV32IMAF) MIPS32 RISC-V (RV32I Base)
Nền tảng thực thi FPGA Cloud (AWS EC2 F1) Web Browser (JS) Java Desktop Application Cross-platform (Python 3)
Mục đích chính Mô phỏng Cycle-accurate Giáo dục, trực quan hóa Giảng dạy hợp ngữ MIPS Xác minh vi xử lý (Verification)
Coverage Monitor Hỗ trợ cấp độ phần cứng Không hỗ trợ Không hỗ trợ Hỗ trợ tệp cấu hình động
Độc lập phần cứng Phụ thuộc AWS FPGA Độc lập Độc lập Độc lập hoàn toàn
Chi phí triển khai Rất cao (Cloud Compute) Miễn phí Miễn phí Mã nguồn mở, 0 USD

Phân loại yêu cầu hệ thống (MoSCoW)

  • Must have (Bắt buộc có):
    • Giải mã và thực thi chính xác 37 lệnh RV32I thuộc 6 nhóm định dạng chuẩn.
    • Quản lý trạng thái 32 thanh ghi 32-bit với thanh ghi x0 luôn giữ giá trị 0.
    • Bộ nhớ mô phỏng hỗ trợ các thao tác Load/Store byte (LB, LBU, SB), half-word (LH, LHU, SH) và word (LW, SW).
    • Trình biên dịch Assembler chuyển đổi nhãn (labels), loại bỏ comment và tạo mã máy chính xác.
  • Should have (Nên có):
    • Bộ thống kê Coverage tính toán tỷ lệ thực thi thanh ghi nguồn/đích, phạm vi hằng số tức thời (Immediate Range), chuỗi truy cập bộ nhớ và phân nhánh tiến/lùi.
    • Giao diện Debug dòng lệnh hỗ trợ đặt đa điểm dừng (multiple breakpoints).
  • Could have (Có thể mở rộng):
    • Giao diện người dùng đồ họa (GUI).
    • Tích hợp chuẩn giao tiếp đồng mô phỏng SystemVerilog DPI-C.
  • Won't have (Chưa thực hiện trong phiên bản này):
    • Mô phỏng chính xác chu kỳ đường ống (Pipeline cycle-accurate timing).
    • Các tập lệnh mở rộng số thực (F/D extensions) và Vector.

Thiết kế kiến trúc hệ thống

+---------------------------------------------------------------------------------+
|                    KIẾN TRÚC CHI TIẾT LÕI MÔ PHỎNG ISS                         |
+---------------------------------------------------------------------------------+

                      +-------------------------------------+
                      |      Tệp hợp ngữ RISC-V (.s)        |
                      +-------------------------------------+
                                         |
                                         v
                      +-------------------------------------+
                      |       Assembler (2-Pass Engine)     |
                      |  - Pass 1: Bóc tách nhãn (Labels)   |
                      |  - Pass 2: Mã hóa Opcode & Imms     |
                      +-------------------------------------+
                                         |
                                         v
                      +-------------------------------------+
                      |   Tệp mã máy nhị phân (.bin/.txt)   |
                      +-------------------------------------+
                                         |
                                         v
+---------------------------------------------------------------------------------+
|                         Instruction Set Simulator Engine                        |
|                                                                                 |
|   +-------------------------------------------------------------------------+   |
|   |                       Fetch & Decode Unit                               |   |
|   |  - Trích xuất: Opcode [6:0], Funct3 [14:12], Funct7 [31:25]             |   |
|   |  - Giải mã thanh ghi: rd [11:7], rs1 [19:15], rs2 [24:20]               |   |
|   |  - Bộ sinh toán hạng tức thời: ImmGen (I, S, SB, U, UJ Format)          |   |
|   +-------------------------------------------------------------------------+   |
|                                        |                                        |
|                                        v                                        |
|   +-------------------------------------------------------------------------+   |
|   |                       Execution Unit (ALU & Control)                    |   |
|   |  - Số học/Luận lý: ADD, SUB, XOR, OR, AND, SLL, SRL, SRA, SLT, SLTU...  |   |
|   |  - Rẽ nhánh & Nhảy: BEQ, BNE, BLT, BGE, BLTU, BGEU, JAL, JALR           |   |
|   +-------------------------------------------------------------------------+   |
|                          |                             |                        |
|                          v                             v                        |
|   +-------------------------------+   +---------------------------------+       |
|   |         Register File         |   |         Memory Subsystem        |       |
|   |  - 32 thanh ghi x0 - x31      |   |  - Byte-addressable Hex Storage |       |
|   |  - PC (Program Counter)       |   |  - Load/Store Data Management   |       |
|   +-------------------------------+   +---------------------------------+       |
+---------------------------------------------------------------------------------+
                                         |
                                         v
                      +-------------------------------------+
                      |      Coverage Monitor Engine        |
                      |  - So khớp tệp cấu hình config.txt  |
                      |  - Tính toán % độ bao phủ thực thi  |
                      |  - Xuất báo cáo coverage_total.txt  |
                      +-------------------------------------+

Cấu trúc dữ liệu và định dạng lệnh RV32I

Kiến trúc RV32I quy định độ dài lệnh cố định 32-bit. Việc bóc tách các trường bit trong lõi mô phỏng được phân bổ nghiêm ngặt:

R-type:  | funct7 (7b) | rs2 (5b) | rs1 (5b) | funct3 (3b) | rd (5b) | opcode (7b) |
I-type:  |    imm[11:0] (12b)     | rs1 (5b) | funct3 (3b) | rd (5b) | opcode (7b) |
S-type:  | imm[11:5]   | rs2 (5b) | rs1 (5b) | funct3 (3b) | imm[4:0]| opcode (7b) |
SB-type: | imm[12|10:5]| rs2 (5b) | rs1 (5b) | funct3 (3b) | imm[4:1|11] | opcode  |
U-type:  |              imm[31:12] (20b)                   | rd (5b) | opcode (7b) |
UJ-type: | imm[20|10:1|11|19:12] (20b)                     | rd (5b) | opcode (7b) |

Implementation và kết quả

Quy trình phát triển phần mềm và kiến trúc mã nguồn

Lõi mô phỏng được xây dựng trên nền tảng Python 3.8+, tận dụng khả năng thao tác chuỗi bit linh hoạt và thư viện cấu trúc dữ liệu mạnh mẽ.

1. Thuật toán xử lý của Assembler

Trình biên dịch hợp ngữ thực hiện quy trình chuẩn hóa và biên dịch qua 2 giai đoạn:

  • Giai đoạn 1 (Pass 1 - Label Resolution): Quét toàn bộ tệp .s, loại bỏ khoảng trắng dư thừa, lọc các dòng chú thích #, phát hiện và lưu bảng địa chỉ nhãn (Symbol Table) dựa trên con trỏ dòng lệnh hiện tại.
  • Giai đoạn 2 (Pass 2 - Code Generation): Ánh xạ mã gợi nhớ (Mnemonic) sang Opcode, Funct3, Funct7; tính toán độ lệch địa chỉ tức thời (Offset calculation) cho các lệnh rẽ nhánh (BEQ, BNE, BLT...) và ghi file mã máy .txt.
# Trích đoạn giải thuật biên dịch lệnh loại I (ADDI) trong Assembler
def encode_i_type(mnemonic, rd, rs1, imm_val, opcode="0010011", funct3="000"):
    # Chuyển đổi số nguyên sang bù 2 (12-bit)
    if imm_val < 0:
        imm_bin = format((1 << 12) + imm_val, '012b')
    else:
        imm_bin = format(imm_val, '012b')
        
    rd_bin = format(int(rd.replace('x', '')), '05b')
    rs1_bin = format(int(rs1.replace('x', '')), '05b')
    
    # Ghép chuỗi 32-bit theo định dạng I-type
    machine_code = imm_bin + rs1_bin + funct3 + rd_bin + opcode
    return hex(int(machine_code, 2))

2. Thuật toán thực thi của Lõi mô phỏng ISS

Lõi ISS duy trì một vòng lặp nạp - giải mã - thực thi (Fetch-Decode-Execute Loop). Dưới đây là kiến trúc xử lý của bộ giải mã tập lệnh:

class RISCV_ISS:
    def __init__(self):
        self.registers = [0] * 32  # x0 - x31
        self.pc = 0x0              # Program Counter
        self.memory = {}          # Emulated Byte-Addressable Memory
        self.coverage_stats = {
            "executed_insts": set(),
            "reg_write_count": [0] * 32,
            "reg_read_count": [0] * 32,
            "branch_forward": 0,
            "branch_back": 0
        }

    def step(self, instruction_32bit):
        # Đảm bảo x0 luôn bằng 0
        self.registers[0] = 0
        
        # Bóc tách Opcode
        opcode = instruction_32bit & 0x7F
        rd = (instruction_32bit >> 7) & 0x1F
        funct3 = (instruction_32bit >> 12) & 0x07
        rs1 = (instruction_32bit >> 15) & 0x1F
        rs2 = (instruction_32bit >> 20) & 0x1F
        funct7 = (instruction_32bit >> 25) & 0x7F

        if opcode == 0x13:  # Nhóm lệnh số học tức thời I-Type (ADDI, SLTI, XORI...)
            imm = (instruction_32bit >> 20)
            if imm & 0x800:  # Sign extension 12-bit to 32-bit
                imm -= 0x1000
            
            if funct3 == 0x0:  # ADDI
                if rd != 0:
                    self.registers[rd] = (self.registers[rs1] + imm) & 0xFFFFFFFF
                self.pc += 4
                self.coverage_stats["executed_insts"].add("ADDI")
                self.coverage_stats["reg_write_count"][rd] += 1
                self.coverage_stats["reg_read_count"][rs1] += 1

        elif opcode == 0x63:  # Nhóm lệnh rẽ nhánh SB-Type (BEQ, BNE, BLT...)
            # Tái tạo immediate 13-bit phân tán
            imm12 = (instruction_32bit >> 31) & 0x1
            imm11 = (instruction_32bit >> 7) & 0x1
            imm10_5 = (instruction_32bit >> 25) & 0x3F
            imm4_1 = (instruction_32bit >> 8) & 0xF
            imm = (imm12 << 12) | (imm11 << 11) | (imm10_5 << 5) | (imm4_1 << 1)
            if imm & 0x1000:
                imm -= 0x2000
                
            condition = False
            if funct3 == 0x0:    # BEQ
                condition = (self.registers[rs1] == self.registers[rs2])
            elif funct3 == 0x1:  # BNE
                condition = (self.registers[rs1] != self.registers[rs2])

            if condition:
                if imm > 0: self.coverage_stats["branch_forward"] += 1
                else: self.coverage_stats["branch_back"] += 1
                self.pc += imm
            else:
                self.pc += 4

Kiểm thử và đánh giá độ bao phủ (Coverage Monitor)

Để xác minh tính bao phủ của bộ kiểm tra ngẫu nhiên, hệ thống cho phép cấu hình kiểm thử thông qua tệp config.txt:

.Instnum(37)                    # Kiểm tra bộ kiểm thử có kích hoạt đủ 37 lệnh
.InstImmRange(-100, 100, 10)    # Dải giá trị tức thời từ -100 đến 100
.RegDest(32)                    # Kích hoạt đủ 32 thanh ghi đích
.RegSource(32)                  # Kích hoạt đủ 32 thanh ghi nguồn
.RegDuplication(32)             # Tần suất thanh ghi nguồn trùng thanh ghi đích
.JumpForwardTime(20)            # Số lần nhảy tiến tới trước
.JumpBackwardTime(20)           # Số lần nhảy lùi về sau
.BranchForward(1)               # Rẽ nhánh tiến
.BranchBack(1)                  # Rẽ nhánh lùi
.MemSeq(5)                      # Truy xuất bộ nhớ liên tiếp 5 lần

Kết quả tính toán độ bao phủ (coverage_total.txt): Khi nạp bộ kiểm thử phức tạp từ RTG, kết quả ghi nhận:

  • Tỷ lệ bao phủ thanh ghi đích (.RegDest): $100%$ (32/32 thanh ghi được ghi giá trị).
  • Tỷ lệ bao phủ thanh ghi nguồn (.RegSource): $100%$ (32/32 thanh ghi được đọc).
  • Tỷ lệ phân nhánh nhảy (.Jump / .Branch): $100%$ theo tiêu chí thiết lập.
  • Tổng độ bao phủ trung bình (Medium Coverage): $92.4%$, đáp ứng tiêu chuẩn kiểm thử khắt khe của hệ thống xác minh vi xử lý.
+---------------------------------------------------------------------------------+
|              KẾT QUẢ ĐỐI SOÁT TRẠNG THÁI THANH GHI GIỮA ISS VÀ RTL             |
+---------------------------------------------------------------------------------+
 Thanh ghi | Giá trị ISS (Hex) | Giá trị RTL Multi-Core | Giá trị RTL Multi-Thread 
-----------+-------------------+------------------------+--------------------------
    x0     |    0x00000000     |       0x00000000       |        0x00000000        
    x1     |    0x00000060     |       0x00000060       |        0x00000060        
    x2     |    0x00000004     |       0x00000004       |        0x00000004        
    x3     |    0x00000025     |       0x00000025       |        0x00000025        
    x4     |    0x000000a4     |       0x000000a4       |        0x000000a4        
    x5     |    0x00000058     |       0x00000058       |        0x00000058        
   ...     |       ...         |          ...           |           ...            
   x31     |    0x00000012     |       0x00000012       |        0x00000012        
-----------+-------------------+------------------------+--------------------------
 KẾT LUẬN  |    HOÀN TOÀN KHỚP |         100% MATCH     |        100% MATCH        
+---------------------------------------------------------------------------------+

Đổi mới và đóng góp

Các điểm cải tiến kỹ thuật nổi bật

  1. Khả năng giám sát độ bao phủ theo ngữ cảnh động (Dynamic Coverage Monitor): Khác với các trình mô phỏng truyền thống chỉ kiểm tra tĩnh số dòng lệnh xuất hiện, ISS của đề tài đếm chính xác số lần lệnh và thanh ghi được kích hoạt trong luồng thực thi động, tính toán chính xác hành vi pipeline delay và rẽ nhánh.
  2. Khả năng đối soát chéo độc lập phần cứng (Hardware-Agnostic Verification): Bộ mô phỏng đã được kiểm chứng đối chiếu với 3 thiết kế vi xử lý RTL phần cứng độc lập:
    • Vi xử lý RISC-V theo vi kiến trúc Multi-thread.
    • Vi xử lý RISC-V kiến trúc Đa lõi (Multi-core).
    • Vi xử lý RISC-V hỗ trợ Chế độ giám sát (Supervisor Mode). Toàn bộ kết quả thanh ghi (Register Dump) sau hàng trăm chuỗi lệnh phức tạp đều khớp chính xác tuyệt đối ($100%$).

So sánh định lượng hiệu quả

+-----------------------------------------------------------------------------+
|                SO SÁNH TÍNH NĂNG VỚI CÁC BỘ MÔ PHỎNG HIỆN HÀNH              |
+-----------------------------------------------------------------------------+
| Đặc tính kỹ thuật     | MARS 4.5       | RISC-V Interpreter | ISS Đề tài   |
+-----------------------+----------------+--------------------+---------------+
| Kiến trúc hỗ trợ      | MIPS32         | RISC-V (RV32I)     | RISC-V (RV32I)|
| Số lệnh hỗ trợ        | 39 lệnh MIPS   | 37 lệnh RV32I      | 37 lệnh RV32I |
| Chế độ Step-by-Step   | Có             | Có                 | Có            |
| Đặt Breakpoint động   | Có (GUI)       | Không              | Có (CLI Array)|
| Coverage Engine       | Không hỗ trợ   | Không hỗ trợ       | Tích hợp sẵn  |
| Độc lập phần cứng     | Có             | Có                 | Đã thực nghiệm|
+-----------------------------------------------------------------------------+

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng thực tế

  1. Xác minh lõi IP SoC (System-on-Chip): Hoạt động như một Golden Model trong môi trường Universal Verification Methodology (UVM), giúp tự động phát hiện lỗi sai lệch dữ liệu thanh ghi và bộ nhớ ngay trong quá trình chạy RTL testbench.
  2. Phát triển phần mềm nhúng sớm (Pre-silicon Software Development): Cho phép các kỹ sư phần mềm nhúng biên dịch và gỡ lỗi chương trình hợp ngữ, firmware hoặc driver trước khi có chip vật lý (silicon chip).
  3. Giảng dạy Kiến trúc Máy tính: Cung cấp công cụ trực quan giúp sinh viên theo dõi quá trình thay đổi trạng thái của từng thanh ghi và ô nhớ sau mỗi chu kỳ lệnh.

Hướng dẫn cài đặt và thực thi

# 1. Khởi tạo môi trường thực thi (Yêu cầu Python 3.8+)
python3 -m venv riscv_env
source riscv_env/bin/activate

# 2. Biên dịch tệp hợp ngữ sang mã máy
python3 assembler.py --input test_program.s --output binary_out.txt

# 3. Chạy mô phỏng toàn bộ và xuất độ bao phủ
python3 iss.py --mode run --binary binary_out.txt --config config.txt

# 4. Chạy chế độ gỡ lỗi tương tác với Breakpoint
python3 iss.py --mode debug --binary binary_out.txt --breakpoints 0x10,0x28

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Giao diện người dùng: Hiện tại công cụ chỉ tương tác qua giao diện dòng lệnh (Command Line Interface - CLI), chưa tích hợp giao diện đồ họa GUI để trực quan hóa sơ đồ đường dẫn dữ liệu.
  • Tốc độ mô phỏng: Do được xây dựng trên nền tảng thông dịch Python thuần túy, tốc độ mô phỏng đạt khoảng $10^5$ lệnh/giây, chậm hơn so với các bộ mô phỏng viết bằng C/C++ tích hợp JIT (Just-In-Time Compilation).
  • Mở rộng tập lệnh: Chưa bao gồm các tập mở rộng như RV32M (Nhân/Chia số nguyên), RV32F/D (Toán số thực dấu phẩy động) hay RV32C (Nén lệnh).

Hướng phát triển tiếp theo

  • Tích hợp GUI (PyQt/Web-based): Xây dựng bảng điều khiển trực quan hiển thị song song mã hợp ngữ, mã máy, bảng 32 thanh ghi và sơ đồ không gian bộ nhớ.
  • Hỗ trợ tập lệnh RV64G và Vector Extensions (RVV): Mở rộng khả năng xử lý cho các hệ thống máy tính 64-bit và tính toán trí tuệ nhân tạo (AI/ML).
  • Đồng mô phỏng SystemVerilog qua DPI-C: Kết nối trực tiếp ISS với các trình mô phỏng phần cứng chuyên nghiệp như Synopsys VCS hoặc Cadence Xcelium.

Đối tượng hưởng lợi

  • Sinh viên ngành Kỹ thuật Máy tính / Điện tử Viễn thông: Có được công cụ trực quan, mã nguồn mở dễ tiếp cận để học tập về vi kiến trúc RISC-V, nguyên lý giải mã lệnh và kiến trúc CPU.
  • Kỹ sư thiết kế vi mạch (ASIC/FPGA Design Engineers): Sở hữu một Golden Reference Model gọn nhẹ, độc lập để nhanh chóng tích hợp vào luồng xác minh chức năng RTL.
  • Các nhóm nghiên cứu phát triển vi xử lý mã nguồn mở: Tiết kiệm $100%$ chi phí phần mềm thương mại đắt đỏ, dễ dàng tùy chỉnh tệp cấu hình độ bao phủ để kiểm thử các kiến trúc vi xử lý tự thiết kế.

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

1. Yêu cầu cấu hình hệ thống để triển khai bộ mô phỏng ISS là gì?

Hệ thống hoàn toàn nhẹ và chạy đa nền tảng (Linux, Windows, macOS). Yêu cầu tối thiểu chỉ cần môi trường Python 3.8+ mà không cần bất kỳ phần cứng chuyên dụng hay card đồ họa/FPGA nào.

2. Bộ mô phỏng có hỗ trợ các vi xử lý có kiến trúc Pipeline không?

ISS là bộ mô phỏng chức năng mức tập lệnh (Functional Level ISS), tập trung xác minh tính đúng đắn của logic tính toán và thay đổi trạng thái bộ nhớ/thanh ghi. Mặc dù không mô phỏng độ trễ từng stage của pipeline, ISS đóng vai trò đối soát chuẩn với mô hình RTL có pipeline thông qua module Comp-runner.

3. Làm thế nào để tích hợp ISS vào quy trình kiểm thử vi xử lý tự động?

ISS có thể được gọi tự động qua CLI script (Bash/Python). Đầu vào là tệp nhị phân sinh ra từ Assembler/RTG, đầu ra là tệp log trạng thái thanh ghi và báo cáo coverage_total.txt. Bộ so sánh Comp-runner sẽ tự động phân tích diff giữa log của ISS và log của RTL Simulation để phát hiện bug.

4. Chi phí bản quyền khi sử dụng công cụ này trong doanh nghiệp là bao nhiêu?

Toàn bộ mã nguồn được xây dựng dựa trên tiêu chuẩn kiến trúc mở RISC-V, hoàn toàn miễn phí ($0) cho cả mục đích học thuật, nghiên cứu và thương mại hóa.

5. Khả năng mở rộng thêm các tập lệnh tùy biến (Custom Instructions) như thế nào?

Nhờ kiến trúc module hóa hướng đối tượng bằng Python, kỹ sư chỉ cần bổ sung định nghĩa opcode mới trong tệp Decoder và định nghĩa hàm xử lý toán học/luận lý tương ứng trong lớp ExecutionUnit chỉ với vài dòng code.

Kết luận

Khóa luận tốt nghiệp "Nghiên cứu thiết kế bộ mô phỏng tập lệnh RISC-V" của sinh viên Nguyễn Văn Hạnh (Khoa Kỹ thuật Máy tính, Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM) đã giải quyết trọn vẹn bài toán xây dựng mô hình tham chiếu chuẩn phục vụ quy trình xác minh vi xử lý. Với việc hiện thực hóa thành công 37 lệnh cơ bản RV32I, phát triển Assembler chuyên dụng, tích hợp Coverage Monitor động đạt 92.4% và kiểm chứng đối soát chính xác $100%$ trên 3 kiến trúc vi xử lý phần cứng thực tế (Multi-thread, Multi-core, Supervisor), công cụ đã đóng góp thiết thực cho cộng đồng nghiên cứu vi mạch bán dẫn và hệ sinh thái mã nguồn mở RISC-V tại Việt Nam.