Giới thiệu dự án

Trong bối cảnh ngành công nghiệp vi mạch bán dẫn toàn cầu đang chuyển dịch mạnh mẽ, kiến trúc tập lệnh mở RISC-V (Reduced Instruction Set Computer V) do Đại học California, Berkeley khởi xướng từ năm 2010 đã trở thành cuộc cách mạng phần cứng. Khác với các kiến trúc độc quyền như ARM hay x86 đòi hỏi chi phí bản quyền lên đến hàng triệu USD, RISC-V cung cấp một tập lệnh tiêu chuẩn mở, cho phép tùy biến linh hoạt cho các bộ vi điều khiển (MCU), thiết bị Internet of Things (IoT) và vi xử lý hiệu năng cao. Tuy nhiên, theo các số liệu thống kê trong ngành thiết kế bán dẫn, công đoạn xác minh chức năng (Functional Verification) hiện chiếm tới 60% – 70% tổng thời gian và chi phí phát triển một hệ thống trên chip (SoC). Bất kỳ một lỗi thiết kế (bug) nào sót lại sau giai đoạn tape-out đều dẫn đến thiệt hại tài chính khổng lồ và làm chậm tiến độ thương mại hóa sản phẩm.

Vấn đề cốt lõi đặt ra là: việc viết các kịch bản kiểm thử (testcases) thủ công bằng hợp ngữ không chỉ tiêu tốn nguồn nhân lực chất lượng cao mà còn không thể bao phủ hết các trường hợp biên (corner cases), các xung đột tài nguyên hoặc các tổ hợp lệnh phức tạp. Ngược lại, các công cụ sinh kiểm thử ngẫu nhiên thương mại lại có giá thành đắt đỏ và tính đóng kín cao. Khóa luận tốt nghiệp "Bộ phát sinh chương trình kiểm tra ngẫu nhiên cho thiết kế RISC-V" (RISC-V Random Test Generator - RISC-V RTG) của sinh viên Trần Thị Lan Trinh, Khoa Kỹ thuật Máy tính, Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM được thực hiện nhằm giải quyết trực tiếp bài toán này.

+---------------------+     +-----------------------+     +------------------------+
| Tệp cấu hình        | --> | RISC-V RTG Engine     | --> | Hợp ngữ Assembly (.S)  |
| (Config Parameters) |     | (Weighted + Genetic)  |     | (Chuỗi lệnh hợp lệ)   |
+---------------------+     +-----------------------+     +------------------------+
                                                                      |
                                                                      v
+---------------------+     +-----------------------+     +------------------------+
| Báo cáo & Đánh giá  | <-- | Mô phỏng ISS / RTL    | <-- | Trình biên dịch        |
| Coverage Monitor    |     | (Golden Model vs RTL) |     | Assembler (.bin/.elf)  |
+---------------------+     +-----------------------+     +------------------------+

Mục tiêu cụ thể của đề tài bao gồm:

  1. Nghiên cứu sâu về kiến trúc tập lệnh cơ sở RV32I 32-bit và quy trình xác minh chức năng vi xử lý.
  2. Thiết kế và hiện thực bộ tạo luồng lệnh kiểm thử ngẫu nhiên (Instruction Stream Generator - ISG/RTG) có khả năng sinh chuỗi lệnh tự động dựa trên trọng số nhóm lệnh và tối ưu hóa giải thuật di truyền (Genetic Algorithm).
  3. Hiện thực trình biên dịch hợp ngữ (Assembler) tích hợp cơ chế tiền mã hóa (Pre-Encoding) để chuyển đổi testcase sang mã máy thực thi.
  4. Đạt độ bao phủ chức năng (Functional Coverage) 100% trên các tiêu chí kiểm thử nghiêm ngặt.
  5. Kiểm chứng toàn diện testcase thông qua mô hình mô phỏng tập lệnh độc lập phần cứng (Instruction Set Simulator - ISS) đóng vai trò Golden Reference Model.

Phạm vi nghiên cứu tập trung vào tập lệnh số nguyên cơ bản RV32I (gồm 37 lệnh người dùng, 6 định dạng lệnh chuẩn) trên không gian địa chỉ 32-bit little-endian. Giới hạn hiện tại chưa bao gồm các tập mở rộng dấu chấm động (F/D), tập nén (C) hoặc chế độ đặc quyền (Privileged Architecture).

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

Phân tích hiện trạng

Xác minh chức năng vi xử lý bằng phương pháp sinh chương trình ngẫu nhiên hiện nay chủ yếu dựa trên ba trường phái kỹ thuật:

Phương pháp RTG Cơ chế hoạt động Ưu điểm Nhược điểm
Table-Based Generator Lưu trữ quan hệ ISA trong bảng dữ liệu để tra cứu và sinh lệnh. Tốc độ sinh rất nhanh, mã nguồn đơn giản, chi phí bảo trì thấp. Dễ sinh mã không hợp lệ trên ISA phức tạp; khó tiếp cận trạng thái sâu.
Static Generator Nhúng các ràng buộc lệnh và toán hạng trực tiếp vào mã thủ tục logic tĩnh. Sinh được số lượng testcase lớn hơn, kiểm soát luồng tốt hơn bảng tĩnh. Độ linh hoạt kém; không tối ưu được các chuỗi phụ thuộc dữ liệu phức tạp.
Dynamic Generator Phân tích trạng thái kiến trúc thời gian thực kết hợp mô hình mô phỏng. Sinh được chuỗi lệnh phức tạp, tiếp cận các corner cases khó nhất. Chi phí triển khai lớn, đòi hỏi liên kết chặt chẽ với simulator.

Trên thế giới, Chupilko và cộng sự (2018) đã phát triển bộ tạo kiểm thử trên nền tảng MicroTESK [2], tập trung vào việc tạo toán hạng biên cho từng lệnh riêng biệt nhưng chưa tối ưu cho các luồng phụ thuộc dữ liệu ngẫu nhiên dài. Năm 2020, Herdt và cộng sự giới thiệu công cụ GRIFT [3], sinh được 8.900 testcases trong 392 giây cho RV32I nhưng độ bao phủ chỉ dừng ở mức 67% đến 86% do gặp rào cản lớn tại các nhóm lệnh nhảy, rẽ nhánh và truy cập bộ nhớ. Nghiên cứu tiền nhiệm tại UIT của Trương Thị Giang (2020) [4] sử dụng Table-Based kết hợp Weighted Randomness, hỗ trợ 36/37 lệnh RV32I nhưng vẫn tồn tại điểm mù ở các lệnh hiếm xuất hiện.

Yêu cầu người dùng đối với hệ thống được xác định theo mô hình MoSCoW:

  • Must Have: Hỗ trợ đầy đủ 37 lệnh RV32I; kiểm soát 32 thanh ghi đa năng ($x_0 - x_{31}$); tránh phân nhánh vô tận (infinite loops); sinh mã nhị phân tương thích RTL.
  • Should Have: Cho phép tùy biến trọng số xuất hiện của 5 nhóm lệnh qua file cấu hình; tích hợp giải thuật di truyền để kích hoạt lệnh hiếm.
  • Could Have: Tự động xuất báo cáo thống kê tần suất thanh ghi và lệnh; đo lường độ bao phủ tự động qua ISS.
  • Won't Have (trong giai đoạn này): Hỗ trợ kiến trúc 64-bit (RV64I) và xử lý ngoại lệ/ngắt (Interrupts/Exceptions).

Thiết kế hệ thống

Kiến trúc giải pháp được thiết kế thành một pipeline khép kín gồm các module độc lập:

  1. Module Đọc Cấu hình (Configuration Parser): Tiếp nhận các tham số đầu vào từ file văn bản như tổng số câu lệnh trong một testcase (NumCommands), số lượng testcase cần sinh (NumFile), và trọng số phân bổ cho 5 nhóm lệnh: Branch, Load, Store, ALU, Jump.
  2. Lõi Sinh Lệnh RTG (RTG Core Engine): Kết hợp giữa lựa chọn ngẫu nhiên có trọng số (Weighted Randomness) và Thuật toán Di truyền (Genetic Algorithm). Mỗi lệnh được mã hóa như một nhiễm sắc thể (NST). Quá trình chọn lọc, lai ghép và đột biến nhị phân đảm bảo sinh ra các chuỗi lệnh có ngữ nghĩa hợp lệ, kiểm soát địa chỉ nhảy tương đối và hạn chế truy cập bộ nhớ ngoài biên.
  3. Trình biên dịch Hợp ngữ (Assembler with Pre-Encoding): Module hai bước (2-pass) được xây dựng bằng Python. Giai đoạn Pre-Encoding loại bỏ dòng trống, thu thập nhãn (Labels) vào bảng băm (Hash Table) để tính toán địa chỉ offset, sau đó chuyển đổi cú pháp Assembly sang mã máy nhị phân chuẩn ELF/HEX (.bin).
  4. Hệ thống Kiểm chứng (Verification Harness): Testcase được nạp đồng thời vào Golden Model (ISS - Instruction Set Simulator) và RTL Simulation. Khối Comp-runner so sánh trạng thái kiến trúc từng chu kỳ, trong khi Coverage Monitor theo dõi ma trận sự kiện để xuất báo cáo độ bao phủ.
       +-------------------------------------------------------------+
       |                     TỆP CẤU HÌNH (Config)                   |
       |  NumCommands: 54 | NumFile: 100 | Branch: 1 | Load/Store: 2 |
       +-------------------------------------------------------------+
                                      |
                                      v
       +-------------------------------------------------------------+
       |               LÕI RISC-V RTG (C/C++ Engine)                 |
       | - Khởi tạo quần thể ban đầu                                |
       | - Phép toán Di truyền: Chọn lọc -> Lai ghép -> Đột biến     |
       | - Ràng buộc: Base register, Immediate boundary, Label target|
       +-------------------------------------------------------------+
                                      |
                         +------------+------------+
                         |                         |
                         v                         v
               +-------------------+     +-------------------+
               | Assembly Files .S |     | Reports (Log/Txt) |
               +-------------------+     +-------------------+
                         |
                         v
       +-------------------------------------------------------------+
       |             ASSEMBLER MODULE (Python Pre-Encoding)          |
       | - Quét nhãn Label & Offset vào Hash Table                   |
       | - Mã hóa Định dạng: R, I, S, SB, U, UJ -> 32-bit Opcode    |
       +-------------------------------------------------------------+
                                      |
                                      v
       +-------------------------------------------------------------+
       |                BINARY / MACHINE CODE (.bin)                 |
       +-------------------------------------------------------------+

Technology Stack triển khai:

  • Ngôn ngữ lõi RTG: C (chuẩn C99/C11), tận dụng con trỏ và quản lý bộ nhớ trực tiếp để tối ưu tốc độ sinh lệnh.
  • Ngôn ngữ Assembler: Python 3.8+ xử lý chuỗi và cấu trúc dữ liệu bảng băm.
  • Môi trường phát triển: Microsoft Visual Studio & GCC Toolchain trên nền tảng Linux/Windows.
  • Công cụ mô phỏng tham chiếu: Spike ISS / Custom C ISS cho RV32I.

Methodology

Quy trình phát triển tuân theo mô hình lặp (Iterative Prototyping) kết hợp phương pháp luận Agile, chia thành 4 cột mốc chính:

  • Milestone 1 (Tuần 1 - 4): Xây dựng cấu trúc dữ liệu bảng lệnh RV32I, định dạng 6 kiểu lệnh và logic sinh ngẫu nhiên cơ sở.
  • Milestone 2 (Tuần 5 - 8): Triển khai cơ chế phân bổ trọng số (Weighted Distribution) và tích hợp giải thuật di truyền (Genetic Algorithm) nhằm triệt tiêu điểm mù tập lệnh.
  • Milestone 3 (Tuần 9 - 12): Xây dựng trình Assembler Pre-Encoding, xử lý triệt để bài toán tính toán địa chỉ nhảy của nhãn Pass, Fail, Loop.
  • Milestone 4 (Tuần 13 - 16): Kết nối ISS, đo đạc độ bao phủ thực nghiệm, tối ưu hóa hiệu năng sinh mã và hoàn thiện tài liệu kỹ thuật.

Đánh giá rủi ro: Rủi ro lớn nhất là tạo ra các vòng lặp vô tận do lệnh nhảy ngược không có điều kiện dừng hoặc truy xuất bộ nhớ không hợp lệ gây Crash Simulator. Giải pháp giảm thiểu: Khởi tạo giá trị hợp lệ cho các thanh ghi cơ sở tại khối initialization, kiểm soát biên giá trị tức thời (Immediate) và cố định địa chỉ đích của các nhánh nhảy có điều kiện.

Implementation và kết quả

Development process

Lõi RTG được hiện thực bằng ngôn ngữ C, sử dụng thư viện <stdlib.h>, <time.h> và <stdio.h>. Thuật toán sinh số ngẫu nhiên được điều khiển thông qua việc biến đổi hạt giống (seed) bằng srand(time(NULL)) và công thức chuẩn hóa khoảng giá trị: $$\text{RandomValue} = \text{min} + \text{rand}() \pmod{\text{max} - \text{min} + 1}$$

Để áp dụng Thuật toán Di truyền (Genetic Algorithm), mỗi chỉ thị lệnh được cấu trúc thành chuỗi bit tương ứng với các trường: opcode (7 bit), rd (5 bit), funct3 (3 bit), rs1 (5 bit), rs2 (5 bit), funct7 (7 bit) đối với lệnh kiểu R, hoặc trường immediate đối với các kiểu I/S/SB/U/UJ.

Thuật toán tiền mã hóa (Pre-Encoding) của Assembler được triển khai bằng Python nhằm xử lý nhãn và mã hóa lệnh:

def pre_encoding_pass(assembly_lines):
    clean_code = []
    symbol_table = {}
    current_address = 0
    
    for line in assembly_lines:
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        if ":" in line:
            label, _, instruction = line.partition(":")
            symbol_table[label.strip()] = current_address
            line = instruction.strip()
            if not line:
                continue
        clean_code.append((current_address, line))
        current_address += 4  # RV32I instructions are 4 bytes
        
    return clean_code, symbol_table

Testing và validation

Quá trình kiểm thử được tiến hành với tệp cấu hình mẫu:

NumCommands : 54
NumFile : 100
Branch : 1
Load : 2
Store : 2
ALU : 3
Jump : 1

Chương trình đã tạo ra 100 tệp testcase assembly hợp lệ trong thư mục Outputs/. Dưới đây là trích đoạn cấu trúc mã nguồn hợp ngữ thực tế từ tệp out_18.S được sinh ra tự động:

initialization:
    addi x1, x0, 9
    addi x11, x0, 77
    addi x12, x0, 72
    addi x30, x0, 149
    addi x31, x0, 188
Main:
    bne x11, x4, Loop2
    lw x29, 820(x4)
    add x26, x25, x24
Loop0:
    sb x18, 1845(x24)
    andi x12, x4, 1426
    add x23, x3, x31
Loop1:
    add x23, x14, x13
    srai x20, x5, 2
Loop2:
    srl x10, x26, x14
    and x30, x30, x11
    add x18, x19, x2
    or x12, x27, x26
    sltu x26, x5, x25
    beq x13, x3, Pass
    jal x31, Pass
Pass:
    addi x1, x0, 96
    jal x0, End
Fail:
    addi x1, x0, 76
End:

Kết quả đạt được

Hệ thống đã hoàn thành 100% các mục tiêu đề ra ban đầu khi kiểm chứng qua trình mô phỏng ISS:

  • Tập lệnh: Bao phủ toàn bộ 37/37 lệnh của RV32I ISA (BEQ, BNE, BLT, BGE, BLTU, BGEU, LB, LH, LW, LBU, LHU, LUI, SB, SH, SW, ADDI, SLTI, SLTIU, XORI, ORI, ANDI, SLLI, SRLI, SRAI, ADD, SUB, SLL, SLT, SLTU, XOR, SRL, SRA, OR, AND, AUIPC, JAL, JALR).
  • Định dạng lệnh: Đạt 100% trên 6 định dạng (R-type, I-type, S-type, SB-type, U-type, UJ-type).
  • Thanh ghi: Kích hoạt đầy đủ 32 thanh ghi đa dụng ($x_0$ đến $x_{31}$), kiểm tra được các trường hợp thanh ghi vừa là toán hạng nguồn vừa là toán hạng đích, cũng như trường hợp cả hai toán hạng nguồn đều là $x_0$.
  • Giá trị tức thời (Immediate): Sinh thành công toàn bộ các giá trị biên bao gồm số 0, số âm, số dương, giá trị cực đại ($2^{11}-1$ hoặc $2^{19}-1$) và giá trị cực tiểu ($-2^{11}$ hoặc $-2^{19}$).
  • Bộ nhớ: Xác minh thành công việc truy xuất tuần tự liên tiếp (phục vụ kiểm tra mảng) và truy xuất đọc/ghi nhiều lần trên cùng một địa chỉ bộ nhớ.

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

Khóa luận mang lại ba cải tiến kỹ thuật mang tính đột phá so với các công trình nghiên cứu trước đây trong và ngoài nước:

  1. Ứng dụng Thuật toán Di truyền (Genetic Algorithm) trong giải quyết bài toán Blind Spots: Khác với các phương pháp ngẫu nhiên thuần túy thường bỏ sót các lệnh có xác suất thấp, việc mã hóa lệnh thành nhiễm sắc thể nhị phân và thực hiện lai ghép - đột biến giúp hệ thống đạt độ bao phủ toàn diện 100% cho các lệnh phức tạp như AUIPC, SLTIU, SRAI.
  2. Cơ chế điều khiển luồng lệnh linh hoạt theo trọng số (Weighted Randomness Engine): Cho phép các kỹ sư xác minh tập trung kiểm thử chuyên sâu vào từng khối chức năng phần cứng cụ thể (ví dụ: tăng trọng số Load/Store để kiểm tra khối Data Cache/LSU, hoặc tăng Branch/Jump để kiểm tra khối Branch Prediction Unit) mà không cần viết lại mã nguồn tạo test.
  3. Quy trình Pre-Encoding khép kín tự động: Tự động tính toán độ lệch nhãn nhảy (Branch/Jump offset) và chèn đoạn mã thiết lập trạng thái ban đầu (initialization) cùng các khối xử lý kết quả Pass/Fail/End, loại bỏ 100% rủi ro vòng lặp vô hạn và truy cập địa chỉ rác.
Tiêu chí so sánh Công trình Herdt et al. (GRIFT) [3] Nghiên cứu Trương Thị Giang [4] RISC-V RTG (Khóa luận này)
Phương pháp Formal Specification + Random Table-Based + Weighted Random Table-Based + Weighted + Genetic Algorithm
Số lệnh RV32I hỗ trợ ~32 lệnh (hạn chế jump/branch) 36 / 37 lệnh 37 / 37 lệnh (100%)
Độ bao phủ (Coverage) 67% - 86% Chưa tối ưu các corner cases 100% trên mọi tiêu chí
Kiểm soát vòng lặp Hạn chế bước nhảy khác 0 Sử dụng nhãn tĩnh Nhãn động + Pre-Encoding thông minh
Khả năng cấu hình Cố định theo đặc tả Cấu hình tham số cơ bản Cấu hình trọng số 5 nhóm lệnh linh hoạt

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

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

  • Doanh nghiệp Thiết kế Vi mạch (Fabless Semiconductor): Tích hợp vào quy trình CI/CD để tự động sinh hàng triệu dòng lệnh kiểm thử hồi quy (Regression Testing) cho các lõi IP vi xử lý RISC-V trước khi tape-out.
  • Phòng Lab Nghiên cứu & Đào tạo: Cung cấp công cụ mở phục vụ giảng dạy môn Kiến trúc Máy tính, Thiết kế Vi mạch số (ASIC/FPGA Design) và Xác minh Phần cứng.

Hướng dẫn triển khai nhanh (Deployment Guide)

  1. Biên dịch mã nguồn RTG: 
    gcc -O3 -std=c11 src/riscv_rtg.c -o bin/riscv_rtg
  2. Cấu hình tham số kiểm thử trong config.txt: 
    NumCommands : 100
NumFile : 50
Branch : 2
Load : 3
Store : 3
ALU : 5
Jump : 1
  3. Thực thi sinh mã và biên dịch sang mã máy nhị phân: 
    ./bin/riscv_rtg config.txt
python3 assembler/riscv_assembler.py --input Outputs/ --output Binary/

Phân tích Hiệu quả Đầu tư (ROI) & Khả năng mở rộng

Việc ứng dụng RISC-V RTG giúp giảm thời gian tạo kịch bản kiểm thử từ nhiều tuần làm việc của kỹ sư xuống chỉ còn vài giây xử lý tự động của máy tính, tiết kiệm ước tính 40% – 50% chi phí nhân lực trong giai đoạn Functional Verification. Về khả năng mở rộng, kiến trúc module hóa cho phép bổ sung thêm các bảng tra cứu lệnh mới để hỗ trợ RV64I và các tập mở rộng một cách dễ dàng.

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

Hạn chế kỹ thuật

  • Chưa hỗ trợ sinh các lệnh thuộc tập mở rộng chuẩn như nhân chia số nguyên (M), xử lý dấu chấm động (F/D) hoặc tập lệnh nén (C).
  • Chưa mô phỏng được các trạng thái ngắt phần cứng (Hardware Interrupts), ngoại lệ (Exceptions) và các thanh ghi điều khiển trạng thái CSR (Control and Status Registers).
  • Cơ chế kiểm soát phụ thuộc dữ liệu (RAW, WAR, WAW hazards) ở mức vi kiến trúc sâu vẫn phụ thuộc vào bộ so sánh Comp-runner ngoài.

Hướng phát triển tương lai

  • Nâng cấp bộ sinh lệnh hỗ trợ kiến trúc 64-bit RV64G và chuẩn mở rộng tính toán vector (Vector Extension - V).
  • Tích hợp trực tiếp môi trường kiểm thử tiêu chuẩn công nghiệp UVM (Universal Verification Methodology) và SystemVerilog.
  • Ứng dụng Học tăng cường (Reinforcement Learning) để tối ưu hóa việc tạo testcase tự động tìm kiếm lỗi vi kiến trúc (Pipeline Hazards, Cache Misses).

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

+-----------------------------------------------------------------------------+
|                            ĐỐI TƯỢNG HƯỞNG LỢI                             |
+---------------------+-------------------------------+-----------------------+
| Sinh viên / Học viên| Kỹ sư Vi mạch (Hardware Devs) | Doanh nghiệp & Lab    |
| - Học tập trực quan | - Rút ngắn 50% thời gian test | - Tiết kiệm license   |
| - Nắm vững ISA RV32I| - Tùy biến trọng số kiểm thử  | - Tăng tốc Time-to-Mkt|
+---------------------+-------------------------------+-----------------------+
  • Sinh viên & Giảng viên ngành Kỹ thuật Máy tính/Điện tử: Có được tài liệu tham khảo chi tiết và công cụ thực hành trực quan về xác minh vi xử lý và kiến trúc RISC-V.
  • Kỹ sư Thiết kế Vi mạch & Phần mềm Nhúng: Sở hữu bộ công cụ sinh mã nguồn mở linh hoạt, hỗ trợ phát hiện lỗi logic phần cứng sớm và tối ưu hóa trình biên dịch.
  • Doanh nghiệp khởi nghiệp bán dẫn: Tiết kiệm chi phí bản quyền công cụ EDA đắt đỏ, đẩy nhanh tiến độ đưa chip ra thị trường (Time-to-Market).

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

1. Yêu cầu hệ thống phần cứng và phần mềm để triển khai RISC-V RTG là gì?

Hệ thống yêu cầu máy tính chạy hệ điều hành Linux (Ubuntu 18.04 LTS trở lên) hoặc Windows 10/11, cài đặt trình biên dịch GCC hỗ trợ chuẩn C99/C11, Python 3.8+ và tối thiểu 2GB RAM.

2. Làm thế nào để công cụ tránh được các lỗi truy cập bộ nhớ ngoài biên?

Trong quá trình sinh mã, các thanh ghi cơ sở dùng cho lệnh Load/Store được khởi tạo giá trị địa chỉ an toàn trong đoạn initialization, đồng thời giá trị độ lệch Immediate được giới hạn trong không gian địa chỉ hợp lệ đã cấp phát.

3. Công cụ có thể tích hợp vào luồng kiểm tra vi mạch RTL thực tế như thế nào?

Mã nhị phân .bin hoặc .elf tạo ra từ Assembler sẽ được nạp đồng thời vào mô hình mô phỏng RTL (viết bằng Verilog/VHDL) và mô hình tham chiếu ISS. Khối Comp-runner sẽ so sánh vết thực thi (execution trace) của các thanh ghi sau mỗi chu kỳ xung nhịp để phát hiện sai khác.

4. Chi phí bảo trì và độ phức tạp khi nâng cấp lên các tập mở rộng RISC-V khác?

Nhờ thiết kế hướng bảng (Table-Driven) kết hợp cấu trúc module, việc bổ sung tập mở rộng mới (như RV32M hoặc RV32C) chỉ đòi hỏi khai báo thêm định dạng mã hóa và opcode trong bảng cấu hình mà không cần viết lại lõi thuật toán.

5. Tại sao công cụ lại kết hợp giữa Weighted Randomness và Genetic Algorithm?

Phương pháp chọn ngẫu nhiên có trọng số (Weighted Randomness) giúp kỹ sư tập trung kiểm thử theo chủ đích, trong khi Thuật toán Di truyền (Genetic Algorithm) giúp lai ghép và kích hoạt các tổ hợp lệnh phức tạp, triệt tiêu các "vùng mù" kiểm thử mà phương pháp ngẫu nhiên thông thường dễ bỏ qua.

Kết luận

Đề tài "Bộ phát sinh chương trình kiểm tra ngẫu nhiên cho thiết kế RISC-V" của tác giả Trần Thị Lan Trinh đã giải quyết thành công bài toán tự động hóa kiểm thử chức năng cho kiến trúc vi xử lý RV32I. Bằng việc kết hợp sáng tạo giữa phương pháp ngẫu nhiên có trọng số và thuật toán di truyền, nghiên cứu đã đạt độ bao phủ tuyệt đối 100% trên tất cả 37 lệnh, 6 định dạng và toàn bộ 32 thanh ghi, vượt trội so với các công trình công bố trước đó. Đây là bước tiến ý nghĩa đóng góp vào hệ sinh thái phần cứng nguồn mở, mở ra tiềm năng ứng dụng to lớn cho các đơn vị nghiên cứu và phát triển vi mạch bán dẫn tại Việt Nam.