Giới thiệu dự án

Trong kỷ nguyên bùng nổ của vi điện tử và thiết kế vi mạch bán dẫn (IC Design), kiến trúc tập lệnh mã nguồn mở RISC-V (Reduced Instruction Set Computer V) đã trở thành một bước ngoặt công nghệ toàn cầu. Khác với các kiến trúc tập lệnh thương mại độc quyền như ARM hay x86, RISC-V cho phép tự do nghiên cứu, tùy biến và sản xuất phần cứng mà không phải chịu chi phí bản quyền đắt đỏ. Tuy nhiên, theo các thống kê trong ngành thiết kế bán dẫn (Semiconductor Industry), quy trình xác minh chức năng (Functional Verification) chiếm tới 60% - 70% tổng thời gian và chi phí phát triển của một vi xử lý (System on Chip - SoC). Một sai sót nhỏ (hardware bug) không được phát hiện trong giai đoạn tiền chế tạo (pre-silicon) có thể dẫn đến thiệt hại hàng triệu USD cho việc sản xuất lại mặt nạ bán dẫn (respin).

Vấn đề thực tế (Problem Statement)

Việc kiểm thử vi xử lý theo phương pháp truyền thống (viết testcase thủ công hoặc kiểm tra định hướng - directed testing) bộc lộ nhiều hạn chế nghiêm trọng:

  • Không bao quát được không gian trạng thái khổng lồ của vi xử lý với hàng triệu tổ hợp lệnh, thanh ghi và cờ điều khiển.
  • Không phát hiện được các lỗi tiềm ẩn phát sinh từ xung đột đường ống lệnh (pipeline hazards), rẽ nhánh điều kiện sai (branch misprediction) hoặc xung đột truy xuất bộ nhớ (memory load/store hazards).
  • Thiếu các công cụ tự động hóa kiểm thử ngẫu nhiên nội địa; hầu hết các giải pháp thương mại đều có bản quyền đắt đỏ hoặc công cụ mã nguồn mở quốc tế phức tạp, thiếu tính tùy biến theo trọng số lệnh mong muốn.

Mục tiêu dự án

  1. Nghiên cứu toàn diện kiến trúc tập lệnh cơ bản RV32I ISA (Base Integer Instruction Set 32-bit) bao gồm 37 chỉ lệnh và 6 định dạng lệnh chuẩn.
  2. Thiết kế và hiện thực Bộ phát sinh chương trình kiểm tra ngẫu nhiên (RISC-V Random Test Generator - RISC-V RTG) đầu tiên tại Việt Nam kết hợp phương pháp dựa trên bảng (Table-Based Generator) và ngẫu nhiên hóa có trọng số (Weighted Randomness).
  3. Xây dựng trình biên dịch hợp ngữ (Assembler) chuyên dụng để chuyển đổi mã hợp ngữ (.S) sang mã máy nhị phân thực thi (.elf / file mã máy nhị phân).
  4. Đạt độ bao phủ kiểm thử (Coverage Metric) $\ge 90%$ thông qua mô hình mô phỏng tập lệnh chuẩn (Instruction Set Simulator - ISS làm Golden Model), kiểm soát toàn diện hoạt động của 32 thanh ghi đa dụng ($x_0 - x_{31}$) và xử lý an toàn luồng nhảy, bộ nhớ.

Giải pháp tiếp cận & Kết quả kỳ vọng

Giải pháp kết hợp cơ chế phát sinh chuỗi lệnh có nghĩa logic (NumSequence) để kiểm tra luồng thực thi phức tạp (tránh lặp vô hạn và đệ quy ngoài tầm kiểm soát) cùng cơ chế phát sinh theo trọng số cấu hình (NumWeights) để kiểm thử áp lực các nhóm lệnh mục tiêu (ALU, Load, Store, Branch, Jump). Kết quả kỳ vọng là tạo ra hàng trăm testcase chuẩn hóa, tự động đo lường độ bao phủ trên ISS và làm đầu vào trực tiếp cho việc kiểm thử RTL Simulation.

Phạm vi và giới hạn (Scope & Limitations)

  • Phạm vi: Tập trung vào không gian kiến trúc vi xử lý RV32I 32-bit ở chế độ unprivileged (User-level).
  • Giới hạn: Chưa tích hợp các tập mở rộng dấu phẩy động (F/D), tập nén (C), cơ chế đồng thời (A), nhân chia (M) và hệ thống xử lý ngắt/ngoại lệ đặc quyền (Trap/Interrupt Privileged Spec).

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

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

Phương pháp Ưu điểm Nhược điểm Đánh giá ứng dụng
Directed Testing (Thủ công) Dễ bám sát thông số kỹ thuật (Spec), kiểm tra chính xác góc hẹp (Corner cases). Tốn nhiều nhân lực, độ bao phủ thấp, không sinh được các tình huống bất ngờ. Chỉ dùng cho kiểm tra khói (Smoke test) ban đầu.
Table-Based Generator Tốc độ sinh testcase nhanh, cấu trúc đơn giản, chi phí bảo trì thấp. Dễ tạo testcase không hợp lệ nếu ISA phức tạp; khó bao quát chuỗi lệnh phụ thuộc sâu. Phù hợp làm nền tảng cấu trúc lệnh.
Static RTG Sinh số lượng lớn lệnh và toán hạng ngẫu nhiên trên toàn dải dữ liệu. Thiếu ngữ cảnh thực thi, dễ gây sập chương trình do phân nhánh ngoài vùng nhớ. Kiểm thử tính toàn vẹn câu lệnh đơn.
Dynamic RTG Phân tích trạng thái mô phỏng thời gian thực, sinh chuỗi lệnh cực kỳ phức tạp. Rất phức tạp, chi phí tính toán cao, phụ thuộc chặt chẽ vào cấu trúc mô phỏng cụ thể. Dành cho các hệ thống vi xử lý quy mô lớn.

Yêu cầu hệ thống theo mô hình MoSCoW

+-------------------------------------------------------------------------------+
|                      MA TRẬN YÊU CẦU DỰ ÁN (MoSCoW)                          |
+-------------------------------------------------------------------------------+
| [M] MUST HAVE:                                                                |
| - Hỗ trợ đầy đủ 37 lệnh RV32I và 6 định dạng: R, I, S, SB, U, UJ.             |
| - Tự do cấu hình trọng số cho 5 nhóm: Branch, Load, Store, ALU, Jump.         |
| - Ngăn chặn lặp vô hạn và truy xuất ngoài dải địa chỉ bộ nhớ hợp lệ.          |
| - Tự động tạo tệp báo cáo thống kê phân phối lệnh và thanh ghi (x0 - x31).    |
+-------------------------------------------------------------------------------+
| [S] SHOULD HAVE:                                                              |
| - Tích hợp Assembler tự động chuyển đổi file .S sang file nhị phân.           |
| - Tương thích chuẩn xác thực với mô hình tham chiếu ISS (Golden Model).       |
| - Độ bao phủ kiểm thử đạt >= 90% theo tiêu chí chỉ lệnh và thanh ghi.        |
+-------------------------------------------------------------------------------+
| [C] COULD HAVE:                                                               |
| - Mở rộng kiểm thử cho các lệnh nhân chia số nguyên RV32M.                    |
| - Hỗ trợ giao diện dòng lệnh tham số hóa linh hoạt (CLI flags).              |
+-------------------------------------------------------------------------------+
| [W] WON'T HAVE (Giai đoạn này):                                              |
| - Không hỗ trợ lệnh 64-bit (RV64I) và các tập mở rộng Vector (V), Float (F).  |
| - Chưa nhúng trực tiếp Comp-runner so sánh tự động bus tín hiệu RTL.          |
+-------------------------------------------------------------------------------+

Thiết kế hệ thống

Kiến trúc tổng thể của hệ thống RISC-V RTG và luồng xác minh chức năng được thiết kế theo cấu trúc modular khép kín:

+-------------------+
| Configuration File| (NumSequence, NumWeights: Branch, Load, Store, ALU, Jump)
| (config.txt)      |
+---------+---------+
          |
          v
+---------+---------+       +-------------------------+
|    RISC-V RTG     | ----> | Report Files (*.txt)    | (Thống kê tần suất Lệnh, Thanh ghi)
| (Engine Core C++) |       +-------------------------+
+---------+---------+
          | (Tạo chuỗi hợp ngữ hợp lệ)
          v
+---------+---------+
| Assembly Program  | (*.S files)
+---------+---------+
          |
          v
+---------+---------+
|     Assembler     | (Pre-Encoding: Bỏ comment, Hash nhãn -> Mã hóa nhị phân)
|    (Perl Core)    |
+---------+---------+
          |
          v
+---------+---------+
| Binary Machine    | (*.elf / Binary hex/txt)
| Program           |
+---------+---------+
          |
          v
+---------+---------+       +-------------------------+
| Instruction Set   | ----> | Coverage Monitor        | (Đo lường độ bao phủ:
| Simulator (ISS)   |       | (Coverage >= 90%)       |  InstNum, RegUsage, Jump/Branch)
+-------------------+       +-------------------------+

Technology Stack

  • Ngôn ngữ phát triển RTG Core: C++ (Chuẩn C++11/C++17, tận dụng triệt để Thư viện mẫu chuẩn STL: std::vector, std::map, std::shuffle, std::function).
  • Môi trường phát triển: Microsoft Visual Studio 2019 / GCC Compiler trên nền tảng Linux/Windows.
  • Ngôn ngữ xử lý Assembler: Perl 5.32 (Tận dụng Regular Expressions mạnh mẽ để phân tích cú pháp chuỗi hợp ngữ và tính toán mã hex nhị phân).
  • Mô hình tham chiếu (Golden Model): ISS (Instruction Set Simulator) độc lập phần cứng cho kiến trúc RV32I.

Implementation và kết quả

Development Process & Key Algorithms

Hệ thống được phát triển qua các giai đoạn then chốt, giải quyết bài toán cốt lõi: sinh lệnh ngẫu nhiên có kiểm soát để đảm bảo tính an toàn bộ nhớ và ngăn chặn deadlock/lặp vô hạn.

1. Thuật toán phân bổ ngẫu nhiên theo trọng số (Weighted Random Selection)

Bộ sinh mã đọc các thông số từ config.txt, xây dựng vector trọng số và sử dụng giải thuật xáo trộn ngẫu nhiên:

// C++ Core: Cơ chế cấu hình và ánh xạ trọng số lệnh ngẫu nhiên
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <random>
#include <ctime>

enum InstructionGroup { GROUP_BRANCH, GROUP_LOAD, GROUP_STORE, GROUP_ALU, GROUP_JUMP };

struct GeneratorConfig {
    int numSequences;
    int numWeights;
    int weightBranch;
    int weightLoad;
    int weightStore;
    int weightALU;
    int weightJump;
};

// Thuật toán tạo pool câu lệnh dựa trên hàm phân phối xác suất trọng số
std::vector<InstructionGroup> buildInstructionPool(const GeneratorConfig& cfg) {
    std::vector<InstructionGroup> pool;
    for (int i = 0; i < cfg.weightBranch; ++i) pool.push_back(GROUP_BRANCH);
    for (int i = 0; i < cfg.weightLoad; ++i)   pool.push_back(GROUP_LOAD);
    for (int i = 0; i < cfg.weightStore; ++i)  pool.push_back(GROUP_STORE);
    for (int i = 0; i < cfg.weightALU; ++i)    pool.push_back(GROUP_ALU);
    for (int i = 0; i < cfg.weightJump; ++i)   pool.push_back(GROUP_JUMP);
    
    // Xáo trộn ngẫu nhiên các lệnh trong pool
    unsigned seed = (unsigned)std::time(nullptr);
    std::shuffle(pool.begin(), pool.end(), std::default_random_engine(seed));
    return pool;
}

2. Cơ chế sinh mã nguồn Assembly an toàn (Safe Assembly Generation)

Đối với thông số NumSequences, chương trình sinh ra các khối lệnh logic có cấu trúc vòng lặp có điều kiện hội tụ, đảm bảo PC (Program Counter) nhảy trong phạm vi an toàn:

# Minh họa Testcase chuỗi logic có nghĩa (NumSequences)
.text
Power:
    addi x12, x0, 0        # Khởi tạo biến đếm i = 0
    addi x24, x0, 1        # Khởi tạo kết quả Result = 1
    addi x2,  x0, 8        # Cơ số x = 8
    addi x13, x0, 2        # Số mũ n = 2
Loop:
    bge  x12, x13, Result  # Nếu i >= n thì thoát vòng lặp
    slli x24, x24, 3       # Nhân x24 với 8 (dịch trái 3 bit)
    addi x12, x12, 1       # Tăng biến đếm i++
    jal  x0,  Loop         # Lặp lại
Result:
    addi x30, x0, 64       # Giá trị kỳ vọng: 8^2 = 64
    bne  x24, x30, Fail    # Kiểm tra tính đúng đắn của phép tính
Pass:
    addi x1,  x0, 84       # Mã thành công (ASCII 'T')
    jal  x0,  End
Fail:
    addi x1,  x0, 70       # Mã lỗi (ASCII 'F')
End:

Đối với thông số NumWeights, hệ thống khởi tạo an toàn 31 thanh ghi ($x_1 - x_{31}$) để loại bỏ trạng thái không xác định (undefined state), đồng thời tự động chuẩn hóa các phép dịch bit và bù số tức thời:

# Minh họa Testcase ngẫu nhiên theo trọng số (NumWeights)
.text
Initialize:
    addi x1,  x0, 19
    addi x2,  x0, 5
    addi x3,  x0, 9
    addi x4,  x0, 35
    addi x27, x0, 6
    addi x28, x0, 30
    addi x29, x0, 48
    addi x30, x0, 34
    addi x31, x0, 30
Main:
    sw   x4,  336(x0)      # Ghi vào vùng nhớ dữ liệu an toàn
    bltu x30, x12, 68      # Rẽ nhánh ngẫu nhiên có bước nhảy hợp lệ
    bgeu x3,  x17, 32
    lui  x12, 90
    xor  x31, x9,  x10     # Phép toán logic ngẫu nhiên
    sll  x17, x23, x4
    jalr x10, x0,  160     # Nhảy gián tiếp có căn chỉnh offset
    lh   x29, 308(x0)
    ori  x23, x9,  45
End:

3. Thuật toán Assembler (Pre-Encoding & Binary Translation)

Trình biên dịch Perl thực hiện hai giai đoạn: Pre-Encoding (quét sạch khoảng trắng, loại bỏ chú thích #, lưu vết địa chỉ nhãn vào bảng băm Hash Table) và Binary Encoding (chuyển đổi từng lệnh thành chuỗi nhị phân 32-bit theo định dạng Opcode, Funct3, Funct7, Rd, Rs1, Rs2, Imm):

#!/usr/bin/perl
# Trích đoạn xử lý Pre-Encoding và Hash Label trong Assembler_RISC-V_CE.pl
use strict;
use warnings;

my %label_table;
my @cleaned_assembly;
my $address = 0;

# Giai đoạn 1: Pre-Encoding & Label Processing
open(my $fh_in, '<', 'testcase.S') or die "Cannot open assembly file: $!";
while (my $line = <$fh_in>) {
    chomp($line);
    $line =~ s/#.*$//;      # Loại bỏ comment
    $line =~ s/^\s+|\s+$//g; # Cắt bỏ khoảng trắng thừa
    next if ($line eq '');   # Bỏ qua dòng trống

    if ($line =~ /^([A-Za-z0-9_]+):$/) {
        $label_table{$1} = $address; # Lưu địa chỉ nhãn
    } else {
        push(@cleaned_assembly, $line);
        $address += 4; # Mỗi lệnh RISC-V chiếm đúng 4 bytes (32-bit)
    }
}
close($fh_in);

Kết quả đo lường và thống kê thực nghiệm

Quá trình thực thi kiểm thử được đo lường tự động qua mô hình ISS với các tệp báo cáo thống kê (report.txt).

======================================================================
              BÁO CÁO PHÂN PHỐI LỆNH VÀ THANH GHI (TESTCASE REPORT)
======================================================================
[INSTRUCTIONS DISTRIBUTION]
  - ADDI : 12    | SLLI : 6     | BEQ  : 4     | LB   : 6     | SB  : 3
  - ADD  : 8     | SRLI : 4     | BNE  : 5     | LH   : 5     | SH  : 4
  - SUB  : 7     | SRAI : 3     | BLT  : 3     | LW   : 8     | SW  : 5
  - XOR  : 6     | ANDI : 5     | BGE  : 3     | LBU  : 4     | JAL : 3
  - OR   : 5     | ORI  : 6     | BLTU : 4     | LHU  : 6     | JALR: 2
  - AND  : 9     | XORI : 4     | BGEU : 2     | LUI  : 4     | AUIPC: 2
----------------------------------------------------------------------
[REGISTER USAGE FREQUENCY]
  - x0 (Zero Reg) : 41 lần (Luôn giữ mức logic 0 chuẩn)
  - x1 - x10      : Trung bình 5.2 lần/thanh ghi
  - x11 - x20     : Trung bình 4.8 lần/thanh ghi
  - x21 - x31     : Trung bình 5.6 lần/thanh ghi
======================================================================
  • Tổng số testcase phát sinh: 400 testcases hoàn chỉnh (200 testcases chuỗi logic NumSequence + 200 testcases trọng số NumWeights).
  • Độ bao phủ câu lệnh (Instruction Coverage): Đạt $100%$ (toàn bộ 37/37 lệnh RV32I được kích hoạt và kiểm chứng hợp lệ).
  • Độ bao phủ thanh ghi (Register Coverage): Đạt $100%$ (32/32 thanh ghi được đọc/ghi cả ở vai trò toán hạng nguồn rs1, rs2 và toán hạng đích rd).
  • Độ bao phủ nhánh và nhảy (Branch/Jump Coverage): Đạt $94.6%$ (thực hiện đầy đủ các trường hợp rẽ nhánh thỏa điều kiện, không thỏa điều kiện, nhảy tiến và nhảy lùi).
  • Tổng độ bao phủ toàn diện đạt được: $96.2%$ (Vượt xa mục tiêu cam kết ban đầu là $90%$).

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

Bảng so sánh với các công trình nghiên cứu quốc tế

Tiêu chí so sánh Chupilko et al. (2018) [2] Herdt et al. (2020) [3] Đề tài: RISC-V RTG (2021)
Nền tảng / Công cụ Nền tảng MicroTESK Galois GRIFT Formal Tools RISC-V RTG (C++) + Custom Assembler (Perl)
Phương pháp sinh mã Mẫu thử nghiệm hình thức (Specification-based Templates) Ràng buộc ngẫu nhiên (Constraint-based Random) Table-Based kết hợp Weighted Randomness
Độ bao phủ (Coverage) Đạt bao phủ tập lệnh cơ bản, phụ thuộc template $67% - 86%$ (Hạn chế do lệnh nhảy, rẽ nhánh và Load/Store) $\ge 90%$ (Thực nghiệm đạt $96.2%$)
Kiểm soát trọng số Phức tạp, cấu hình tĩnh qua template Không hỗ trợ chỉnh định động trọng số nhóm lệnh Tùy biến linh hoạt 5 nhóm lệnh qua config file
Tính độc lập & Nhẹ Cần môi trường MicroTESK hoàn chỉnh Phụ thuộc hệ sinh thái công cụ hình thức GRIFT Độc lập, gọn nhẹ, chạy trực tiếp native binary
Báo cáo thống kê Báo cáo tích hợp môi trường Log trạng thái thử nghiệm chuẩn Xuất tệp Report chi tiết cho từng testcase

Đóng góp kỹ thuật nổi bật

  1. Khắc phục điểm nghẽn độ bao phủ của lệnh rẽ nhánh và bộ nhớ: Trong khi nghiên cứu của Herdt et al. (2020) bị giới hạn độ bao phủ ở mức 67% - 86% do các lệnh nhảy/load/store dễ gây bất hợp lệ địa chỉ, giải pháp của đề tài đã giải quyết triệt để nhờ thuật toán giới hạn biên địa chỉ offset tương đối và cơ chế khởi tạo bộ nhớ an toàn.
  2. Cơ chế cân bằng trọng số thực tế (Weighted Distribution): Cho phép kỹ sư kiểm thử tập trung nguồn lực vào nhóm lệnh nghi ngờ có lỗi (ví dụ: tăng trọng số nhóm ALU lên 74% hoặc nhóm Memory lên 50% trong các bài stress test).
  3. Tiên phong tại Việt Nam: Là công trình học thuật đầu tiên trong nước nghiên cứu và phát triển hoàn chỉnh một bộ tạo kiểm thử ngẫu nhiên cho vi xử lý RISC-V, đóng góp công cụ hữu ích cho cộng đồng thiết kế vi mạch trong nước.

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

Kịch bản ứng dụng thực tế (Real-World Use Cases)

  • Pre-silicon Functional Verification: Tích hợp trực tiếp vào hệ thống Co-simulation để so sánh từng chu kỳ xung nhịp (cycle-by-cycle) giữa mô hình phần cứng RTL (Verilog/SystemVerilog) và mô hình tham chiếu ISS.
  • Phát hiện xung đột phần cứng (Hardware Hazards): Tạo ra các chuỗi lệnh liên tục truy xuất cùng một thanh ghi hoặc ô nhớ để kiểm tra khả năng xử lý Data Forwarding, Pipeline Stalls và Branch Prediction của vi xử lý.
  • Kiểm thử hồi quy tự động (CI/CD Pipeline for ASIC/FPGA): Tự động phát sinh hàng ngàn testcase mỗi đêm (Nightly regression builds) để xác thực các bản vá thiết kế phần cứng trước khi tiến hành tape-out.

Hướng dẫn triển khai và vận hành hệ thống

# 1. Cấu hình các tham số kiểm thử trong file configuration.txt
# Định nghĩa số lượng testcases và trọng số các nhóm lệnh:
# NumSequence: 200, NumWeights: 200, Branch: 2, Load: 2, Store: 1, ALU: 4, Jump: 1

# 2. Thực thi bộ phát sinh chương trình kiểm tra ngẫu nhiên
./RTG.exe

# 3. Cấp quyền và chạy trình biên dịch Assembler để tạo mã máy
chmod +x Assembler_RISC-V_CE.pl
./Assembler_RISC-V_CE.pl

# 4. Nạp mã máy nhị phân vào bộ mô phỏng ISS và kiểm tra độ bao phủ
./iss_simulator --testcase=testcase_001.elf --monitor-coverage

Phân tích hiệu quả kinh tế & Khả năng mở rộng

  • Thời gian và chi phí: Giảm $75%$ thời gian viết testbench thủ công, rút ngắn chu kỳ xác minh chức năng từ vài tháng xuống còn vài tuần.
  • Khả năng mở rộng: Cấu trúc module C++ cho phép dễ dàng tích hợp thêm các bảng mã lệnh mới (như RV64I, RV32M với phép toán MUL/DIV, hoặc RV32F cho dấu phẩy động) bằng cách kế thừa lớp sinh lệnh và cập nhật bảng ánh xạ opcode.

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

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

  • Phạm vi kiến trúc: Mới chỉ tập trung hiện thực cho tập lệnh cơ bản RV32I, chưa hỗ trợ chế độ đặc quyền (Privileged Architecture) như Machine Mode (M-Mode) hay Supervisor Mode (S-Mode).
  • Cơ chế ngắt và ngoại lệ: Chưa mô phỏng được các tình huống sinh ngắt bất đồng bộ ngẫu nhiên (Asynchronous Interrupts) hoặc bẫy lỗi phần cứng (Hardware Traps/Exceptions).
  • Tự động hóa Co-simulation: Khâu so sánh sai lệch giữa ISS và RTL hiện vẫn cần bộ điều khiển testbench trung gian kích hoạt riêng biệt.

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

  1. Nâng cấp hỗ trợ RV64GC: Mở rộng trình phát sinh hỗ trợ tập lệnh 64-bit chuẩn công nghiệp (General Purpose: I, M, A, F, D, C).
  2. Tích hợp cơ chế ngắt và quản lý bộ nhớ ảo (MMU/Paging): Sinh ngẫu nhiên các sự kiện ngắt bộ định thời (Timer Interrupt), ngắt ngoại vi (External Interrupt) và chuyển đổi trang địa chỉ TLB.
  3. Phát triển GUI Dashboard: Xây dựng giao diện đồ họa trực quan hóa ma trận độ bao phủ, biểu đồ phân bố lệnh thời gian thực và tự động báo cáo điểm lỗi RTL.

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

+-----------------------------------------------------------------------------------+
|                        ĐỐI TƯỢNG HƯỞNG LỢI & GIÁ TRỊ MANG LẠI                     |
+-----------------------------------------------------------------------------------+
| [Sinh viên & Học viên Kỹ thuật]                                                   |
| - Tài liệu tham khảo chuẩn mực về vi kiến trúc RISC-V và kỹ thuật xác minh chip.  |
| - Nắm vững phương pháp lập trình C++/Perl ứng dụng trong công nghệ bán dẫn.       |
+-----------------------------------------------------------------------------------+
| [Kỹ sư thiết kế Vi mạch & FPGA]                                                   |
| - Nhận ngay một bộ sinh testcase tự động gọn nhẹ, dễ nhúng vào testbench UVM/OVM. |
| - Tiết kiệm hàng trăm giờ viết test pattern thủ công cho lõi CPU RV32I.           |
+-----------------------------------------------------------------------------------+
| [Doanh nghiệp & Startup Bán dẫn]                                                  |
| - Tối ưu hóa chi phí bản quyền công cụ EDA đắt đỏ.                                |
| - Rút ngắn thời gian Time-to-Market cho các dòng vi điều khiển IoT dùng lõi RISC-V.|
+-----------------------------------------------------------------------------------+
| [Nhà nghiên cứu học thuật]                                                        |
| - Nền tảng mở để phát triển các giải pháp sinh test thông minh dựa trên AI/ML.    |
+-----------------------------------------------------------------------------------+

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. Phần mềm yêu cầu trình biên dịch C++ hỗ trợ chuẩn C++11 trở lên (GCC hoặc MSVC trong Visual Studio 2019/2022) và môi trường thực thi Perl 5.26+. Bộ nhớ RAM tối thiểu 2GB và dung lượng ổ đĩa trống 500MB.

2. Làm thế nào công cụ ngăn chặn được các vòng lặp vô hạn khi sinh lệnh ngẫu nhiên?

Công cụ giải quyết vấn đề này qua hai cơ chế: (1) Với chế độ NumSequence, các cấu trúc rẽ nhánh đều có biến đếm lặp hội tụ xác định; (2) Với chế độ NumWeights, các bước nhảy tương đối của lệnh JAL/JALR và rẽ nhánh Branch bị ràng buộc biên địa chỉ cục bộ và không cho phép nhảy ngược về chính câu lệnh đó nếu không có điều kiện thoát.

3. Công cụ tích hợp vào quy trình kiểm thử vi xử lý phần cứng (RTL) như thế nào?

Mã hợp ngữ sinh ra được Assembler dịch thành file mã máy nhị phân (.elf hoặc file text chứa chuỗi bit/hex). File này được nạp đồng thời vào bộ nhớ của mô hình RTL (chạy trên Modelsim/VCS) và mô hình tham chiếu ISS (Golden Model). Khối Comp-runner sẽ so sánh trạng thái thanh ghi và bộ nhớ sau mỗi chu kỳ thực thi để phát hiện lỗi sai khác.

4. Tại sao cần kết hợp cả hai phương pháp Table-Based và Weighted Randomness?

Table-Based giúp quá trình sinh lệnh diễn ra nhanh chóng, có cấu trúc ngữ nghĩa rõ ràng nhưng dễ bị hạn chế về độ bao quát trường hợp biên. Weighted Randomness bổ trợ hoàn hảo bằng cách cho phép kỹ sư tập trung kích hoạt các tình huống hiếm gặp hoặc kiểm tra áp lực sâu vào các khối phần cứng chuyên biệt (như ALU hay Memory Controller).

5. Chi phí đầu tư và khả năng tiết kiệm ngân sách khi ứng dụng công cụ?

RISC-V RTG là giải pháp mã nguồn mở tự phát triển, hoàn toàn miễn phí bản quyền. So với việc trang bị các gói phần mềm EDA thương mại chuyên dụng (có thể tốn từ 20.000$ đến 100.000$/năm cho mỗi bản quyền kỹ sư), công cụ mang lại giá trị hoàn vốn (ROI) tức thì ngay trong giai đoạn thiết kế nguyên mẫu.

Kết luận

Đồ á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" của tác giả Trương Thị Giang (Trường Đại học Công nghệ Thông tin - ĐHQG TP.HCM) dưới sự hướng dẫn của TS. Đoàn Duy và TS. Trần Đại Dương đã giải quyết xuất sắc bài toán cốt lõi trong quy trình xác minh vi xử lý phần cứng. Bằng việc kết hợp sáng tạo giữa kỹ thuật phát sinh mã dựa trên bảng và ngẫu nhiên hóa có trọng số, nghiên cứu đã tạo ra một hệ thống hoàn chỉnh từ sinh chuỗi hợp ngữ an toàn, biên dịch nhị phân tự động đến đo lường độ bao phủ thực nghiệm.

Với kết quả thực nghiệm vượt trội — đạt độ bao phủ kiểm thử $96.2%$ (vượt chỉ tiêu $90%$), kiểm soát hoàn hảo 37 lệnh RV32I và 32 thanh ghi đa dụng, vượt qua các giới hạn thường gặp của các công trình quốc tế cùng thời kỳ — đồ án không chỉ khẳng định năng lực nghiên cứu ứng dụng chuyên sâu trong lĩnh vực Kỹ thuật Máy tính mà còn là tài liệu tham khảo và công cụ thực thi vô cùng giá trị cho cộng đồng vi mạch Việt Nam.

Khám phá và ứng dụng: Các kỹ sư thiết kế phần cứng, nhà nghiên cứu và sinh viên quan tâm đến vi kiến trúc RISC-V có thể áp dụng ngay mô hình kiểm thử ngẫu nhiên này vào các dự án thiết kế lõi SoC của mình để chuẩn hóa quy trình xác minh chức năng tiền chế tạo.