Giới thiệu dự án
Kiến trúc tập lệnh mở RISC-V (Reduced Instruction Set Computer V) đang tạo nên một cuộc cách mạng trong ngành công nghiệp bán dẫn toàn cầu kể từ khi ra mắt vào năm 2010. 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 đắt đỏ, RISC-V cung cấp một chuẩn ISA (Instruction Set Architecture) mở, cho phép các viện nghiên cứu, doanh nghiệp và nhà phát triển tự do tùy biến vi kiến trúc xử lý. Các lõi RISC-V thương mại hóa như SiFive Freedom U540, Espressif ESP32-C3 (RV32IMC) hay Western Digital SweRV Core EH1 đã chứng minh tiềm năng vượt bậc của kiến trúc này trong các ứng dụng từ vi điều khiển IoT đến điện toán hiệu năng cao.
Tuy nhiên, theo các khảo sát trong ngành công nghiệp vi mạch, công tác xác minh và kiểm thử (Design Verification - DV) thường chiếm từ 50% đến 70% tổng thời gian và nguồn lực của chu kỳ thiết kế chip. Việc kiểm tra tính đúng đắn của các lõi vi xử lý RISC-V RV32I đối mặt với nhiều rào cản:
- Quy trình kiểm thử truyền thống bằng UVM/OVM (Universal Verification Methodology) trên nền tảng SystemVerilog đòi hỏi môi trường phần mềm EDA thương mại đắt đỏ (Synopsys, Cadence, Mentor Graphics).
- Thiếu các công cụ mã nguồn mở gọn nhẹ, tích hợp khả năng kiểm thử tự động (Automated Co-simulation) giữa mô hình hành vi phần mềm và phần cứng thực tế.
- Khó khăn trong việc kiểm tra chéo (Differential Testing) trạng thái thanh ghi và bộ nhớ theo từng chu kỳ xung nhịp giữa mô hình tham chiếu (Golden Model) và mô hình mức truyền thanh ghi RTL (Register-Transfer Level).
+--------------------------------------------------------------------------------+
| THỰC TRẠNG KIỂM THỬ VI XỬ LÝ RISC-V |
| |
| [Đặc tả ISA RV32I] ──> [Thiết kế RTL Verilog] ──> [Xác minh phần cứng] |
| ▲ |
| │ (Nghẽn cổ chai) |
| - Chi phí EDA bản quyền cao │ 50% - 70% |
| - Rào cản thiết lập môi trường phức tạp │ Chu kỳ thiết kế |
| - Khó kiểm soát độ bao phủ lệnh tự động ▼ |
+--------------------------------------------------------------------------------+
Đồ án khóa luận tốt nghiệp kỹ sư ngành Kỹ thuật Máy tính (Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM) với đề tài "Nghiên cứu phát triển bộ kiểm tra đánh giá hệ thống RISC-V Core" đã xây dựng thành công bộ công cụ RVCoTS (RISC-V Co-Simulation Test Suite). Hệ thống cung cấp giải pháp xác minh thiết kế phần cứng tự động, kết hợp giữa mô phỏng phần mềm độc lập và mô phỏng phần cứng thông qua ngôn ngữ Python và thư viện kiểm chứng Cocotb.
Mục tiêu cụ thể của dự án:
- Nghiên cứu toàn diện tập lệnh cơ bản RISC-V RV32I với đầy đủ 37 lệnh thuộc 6 định dạng chuẩn: R-Type, I-Type, S-Type, SB-Type, U-Type và UJ-Type.
- Xây dựng trình biên dịch hợp ngữ nội tại (Assembler) chuyển đổi mã nguồn Assembly
.s sang mã máy nhị phân 32-bit .txt.
- Phát triển bộ mô phỏng tập lệnh phần mềm ISS (Instruction Set Simulator) đóng vai trò Golden Model tham chiếu.
- Tích hợp môi trường mô phỏng phần cứng RTL dựa trên thư viện Cocotb (Coroutine-based Co-simulation Testbench) và trình mô phỏng Icarus Verilog.
- Thiết kế module so sánh trạng thái Comp-Runner và giám sát độ bao phủ Coverage Monitor, đưa ra báo cáo sai số tự động.
- Kiểm chứng chéo (Cross-validation) độ chính xác của hệ thống với phần mềm công nghiệp Xilinx Vivado và RISC-V Interpreter.
Phạm vi nghiên cứu tập trung vào tập lệnh số nguyên 32-bit RV32I trong chế độ chạy tuần tự của lõi vi xử lý đơn luồng, chưa bao gồm các tập mở rộng dấu phẩy động (F/D extension) hoặc đặc quyền hệ điều hành (Privileged M/S/U Modes).
Phân tích và thiết kế giải pháp
Phân tích hiện trạng
Trước khi xây dựng RVCoTS, các giải pháp mã nguồn mở và công cụ hiện hành trên thế giới đã được phân tích chi tiết nhằm xác định khoảng trống công nghệ:
| Tiêu chí so sánh |
Rocket Chip Generator |
RISC-V Verification Suite |
RVCoTS (Giải pháp đề xuất) |
| Mục tiêu chính |
Sinh lõi SoC và testbench Chisel |
Kiểm thử trình biên dịch và ISS |
Xác minh đồng bộ lõi RTL & Golden Model |
| Môi trường triển khai |
Chisel, Scala, C++ |
C, Assembly, Shell script |
Python, Cocotb, Verilog |
| Mức độ phức tạp |
Rất cao, đòi hỏi cấu hình sâu |
Trung bình - Cao, chạy qua CLI |
Tối giản, hỗ trợ giao diện và xuất file log |
| Kiểm thử RTL tùy biến |
Hạn chế với RTL ngoài hệ sinh thái |
Không hỗ trợ trực tiếp RTL user |
Nạp trực tiếp mã nguồn Verilog của người dùng |
| Phân tích Coverage |
Tích hợp sâu qua Chisel coverage |
Báo cáo lệnh cơ bản |
Tự động đo độ bao phủ theo file .config |
| Tính trực quan |
Xuất waveform VCD thông thường |
Dạng text console |
Báo cáo chi tiết thanh ghi, bộ nhớ, lệnh |
Áp dụng phương pháp phân tích yêu cầu MoSCoW:
- Must have (Bắt buộc): Biên dịch chuẩn xác 37 lệnh RV32I; mô phỏng ISS độc lập phần cứng; nạp mã nhị phân vào bộ nhớ lệnh
Instruction_Memory.v; so sánh trạng thái 32 thanh ghi (x0 - x31) và bộ nhớ dữ liệu sau khi thực thi.
- Should have (Nên có): Tính toán độ bao phủ nhánh rẽ (Branch Forward/Backward), số lượng lệnh thực thi (InstNum), tần suất truy xuất bộ nhớ (MemSeq); hiển thị kết quả trực quan qua giao diện GUI / cửa sổ log.
- Could have (Có thể có): Tạo sinh testcase ngẫu nhiên qua module RTG (Random Test Generator); xuất file sóng mô phỏng dạng sóng waveform
.vcd.
- Won't have (Chưa hỗ trợ phiên bản này): Mô phỏng pipeline hazard/bộ nhớ đệm đa cấp, hỗ trợ ngắt ngoại vi phức tạp.
graph TD
A[Mã nguồn hợp ngữ .s] --> B[Assembler Engine]
B --> C[Tệp mã máy 32-bit Binary .txt]
D[Tệp cấu hình .config] --> E[Testbench Controller]
C --> E
E --> F[ISS Simulation - Python Golden Model]
E --> G[RTL Simulation - Cocotb + Verilog Core]
F -->|Thanh ghi, Bộ nhớ, Coverage| H[Comp-Runner Engine]
G -->|Thanh ghi, Bộ nhớ, Coverage| H
H --> I[Coverage Monitor]
I --> J[Tệp nhật ký so sánh & Đánh giá Pass/Fail]
Thiết kế hệ thống
Hệ thống RVCoTS gồm 5 khối chức năng chính được tổ chức chặt chẽ:
- Assembler: Đọc file Assembly, lọc bỏ chú thích (comments) và dòng trống, xử lý các nhãn địa chỉ (labels), giải mã các trường opcode, funct3, funct7, rd, rs1, rs2, immediate để xuất ra mã máy nhị phân 32-bit.
- Testbench Controller: Điều phối luồng dữ liệu, nạp tệp cấu hình kiểm thử (Configuration file) và điều khiển quá trình thực thi đồng bộ giữa ISS và RTL.
- Instruction Set Simulator (ISS): Mô hình tham chiếu phần mềm viết bằng Python thuần túy, mô phỏng không gian bộ nhớ 32-bit, con trỏ lệnh PC (Program Counter), và 32 thanh ghi vật lý (trong đó
x0 luôn giữ giá trị 0x00000000).
- RTL Simulation Driver: Sử dụng thư viện
cocotb, tự động ghi đè mã máy vào module phần cứng Instruction_Memory.v, cấp xung nhịp clk, tín hiệu reset và trích xuất dữ liệu bus theo từng lệnh.
- Comp-Runner & Coverage Monitor: Module đối soát dữ liệu đầu ra giữa ISS và RTL, phát hiện sai khác ở mức bit, đồng thời tính toán phần trăm độ bao phủ dựa trên các ràng buộc trong file cấu hình.
Cấu trúc định dạng tập lệnh RV32I được hiện thực hóa trong hệ thống:
- 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] (7b) | rs2 (5b) | rs1 (5b) | funct3 (3b) | imm[4:0] (5b) | opcode (7b)
- B-type (SB):
imm[12|10:5] (7b) | rs2 (5b) | rs1 (5b) | funct3 (3b) | imm[4:1|11] (5b) | opcode (7b)
- U-type:
imm[31:12] (20b) | rd (5b) | opcode (7b)
- J-type (UJ):
imm[20|10:1|11|19:12] (20b) | rd (5b) | opcode (7b)
Technology Stack triển khai:
- Ngôn ngữ lập trình: Python 3.10+, Verilog HDL (IEEE 1364-2001).
- Framework kiểm chứng: Cocotb v1.8+ (Coroutine-based Co-simulation Testbench).
- Trình mô phỏng phần cứng: Icarus Verilog (iverilog v12.0) / Verilator.
- Công cụ kiểm chứng chéo: Xilinx Vivado ML Edition 2023.2, RISC-V Interpreter.
- Hệ điều hành: Linux Ubuntu 22.04 LTS x86_64.
Methodology
Quy trình phát triển hệ thống áp dụng mô hình lặp theo chuẩn Agile Hardware Verification qua 5 giai đoạn:
- Giai đoạn 1 (Phân tích đặc tả): Chuẩn hóa bảng mã 37 lệnh RV32I, xác định cấu trúc giải mã trường bit và hành vi vi kiến trúc.
- Giai đoạn 2 (Thiết kế kiến trúc): Xây dựng sơ đồ khối dữ liệu liên lạc giữa tiến trình Python và nhân mô phỏng C/Verilog qua giao diện VPI (Verilog Procedural Interface).
- Giai đoạn 3 (Hiện thực hóa mã nguồn): Viết mã ISS, trình Assembler, và các coroutine testbench Cocotb.
- Giai đoạn 4 (Kiểm thử đơn vị & Tích hợp): Chạy thử nghiệm từng nhóm lệnh (Số học -> Bộ nhớ -> Rẽ nhánh -> Nhảy).
- Giai đoạn 5 (Xác minh chéo & Đánh giá): Đưa testcase vào Vivado và RISC-V Interpreter để đối chiếu tính đúng đắn tuyệt đối.
Implementation và kết quả
Development process
Trình biên dịch Assembler được hiện thực hóa để xử lý mã nguồn hợp ngữ theo thuật toán quét hai lượt (Two-pass Assembler):
- Lượt 1: Đọc toàn bộ file, bóc tách nhãn địa chỉ (labels), tính toán giá trị con trỏ lệnh PC tương ứng để gán bảng ký hiệu (Symbol Table).
- Lượt 2: Chuyển đổi mã gợi nhớ (mnemonic) và các toán hạng thanh ghi thành chuỗi nhị phân 32-bit.
Đoạn chương trình hợp ngữ kiểm thử mẫu:
# Chương trình kiểm thử tính toán và rẽ nhánh trên RV32I
Main:
addi x9, x0, 96 # Gán x9 = 96
addi x10, x0, 32 # Gán x10 = 32
addi x18, x0, 68 # Gán x18 = 68
addi x25, x0, 4 # Gán x25 = 4
Loop1:
sub x10, x1, x1 # Phép trừ: x10 = x1 - x1 = 0
or x2, x3, x4 # Phép logic OR
and x1, x2, x4 # Phép logic AND
AddOne:
beq x2, x19, Loop2 # Kiểm tra rẽ nhánh có điều kiện
jal x1, Pass # Nhảy vô điều kiện đến Pass, lưu PC+4 vào x1
Loop2:
auipc x13, 604 # Gán x13 = PC + (604 << 12)
jal END
Pass:
jal END
END:
Sau khi qua khối Assembler, mã máy nhị phân 32-bit được tạo ra và lưu trong tệp Instruction_binary_out.txt:
00000110000000000000010010010011
00000010000000000000010100010011
00000100010000000000100100010011
00000000010000000000110010010011
01000000000100001000010100110011
Cơ chế điều khiển kiểm thử phần cứng qua Cocotb được hiện thực hóa bằng các coroutine bất đồng bộ (async/await):
import cocotb
from cocotb.triggers import Timer, RisingEdge
@cocotb.test()
async def run_riscv_verification(dut):
"""Cocotb Coroutine: Nạp xung nhịp và giám sát trạng thái lõi RISC-V"""
# Khởi tạo chu kỳ xung nhịp 10ns (Tần số 100MHz)
cocotb.start_soon(Clock(dut.clk, 10, units="ns").start())
# Thiết lập trạng thái Reset hệ thống
dut.reset.value = 1
await Timer(20, units="ns")
dut.reset.value = 0
# Giám sát và trích xuất giá trị thanh ghi sau mỗi chu kỳ lệnh
for cycle in range(MAX_CYCLES):
await RisingEdge(dut.clk)
if dut.trap.value == 1 or dut.pc.value == END_ADDRESS:
break
# Ghi nhận trạng thái thanh ghi và bộ nhớ ra file log
export_rtl_state(dut)
Testing và validation
Quá trình xác minh được thực thi tự động qua tập lệnh kịch bản Execute.csh. Hệ thống nạp đồng thời file mã máy vào ISS và mô hình RTL Verilog, chạy qua 3 tập kiểm thử (TestCases) có độ phức tạp cao:
| Bộ Testcase |
Số lệnh thực thi |
Thời gian chạy RTL Sim (s) |
Trạng thái ISS vs RTL |
Độ khớp Coverage |
binary_out_0 |
28 lệnh |
0.177395 s |
Trùng khớp 100% (Identical) |
10/10 Tiêu chí đạt |
binary_out_1 |
37 lệnh |
0.216778 s |
Trùng khớp 100% (Identical) |
10/10 Tiêu chí đạt |
binary_out_2 |
22 lệnh |
0.110034 s |
Trùng khớp 100% (Identical) |
10/10 Tiêu chí đạt |
Dữ liệu thanh ghi trích xuất từ khối ISS và khối RTL Simulation cho thấy sự đồng nhất tuyệt đối trên toàn bộ không gian 32 thanh ghi vật lý:
Register[1] (ra) : 0x00000000
Register[2] (sp) : 0x00001000
Register[9] (s1) : 0x00000060 (Giá trị thập phân: 96)
Register[10] (a0): 0x00000020 (Giá trị thập phân: 32)
Register[18] (s2): 0x00000044 (Giá trị thập phân: 68)
Register[25] (s9): 0x00000004 (Giá trị thập phân: 4)
Kết quả kiểm tra chéo với phần mềm Xilinx Vivado và RISC-V Interpreter xác nhận dạng sóng tín hiệu và giá trị ô nhớ tại các địa chỉ Memory[4] đến Memory[10] hoàn toàn khớp với đầu ra của bộ mô phỏng RVCoTS.
+------------------------------------------------------------------------------------+
| BÁO CÁO ĐỐI SOÁT TỪ COMP-RUNNER |
+------------------------------------------------------------------------------------+
| 1. Check Instruction Command : 3/3 TestCases PASS (0 Errors) -> DESIGN IS CORRECT |
| 2. Check Register Value : Files ISS và RTL hoàn toàn trùng khớp (Identical) |
| 3. Check Memory Value : Files ISS và RTL hoàn toàn trùng khớp (Identical) |
| 4. Evaluation Criteria : 10/10 Ràng buộc kiểm chứng ĐẠT (Tỷ lệ 100%) |
+------------------------------------------------------------------------------------+
Kết quả đạt được
Hệ thống đã hoàn thành 100% các mục tiêu thiết kế ban đầu:
- Độ bao phủ chức năng (Functional Coverage): Đạt 100% trên 10 tiêu chí đánh giá cấu hình:
- Instruction Number: 37/37 lệnh RV32I (100%).
- Instruction Time: Đáp ứng 120/20 yêu cầu kiểm thử lệnh
ADDI lặp lại (100%).
- Register Coverage: Bao phủ 32/32 thanh ghi đích và 32/32 thanh ghi nguồn (100%).
- Branch & Jump Coverage: 5/5 lần nhảy tiến (Branch Forward) và 19/5 lần nhảy lùi (Branch Backward) được kích hoạt chính xác.
- Tốc độ xác minh: Thời gian kiểm thử trung bình chỉ mất ~0.168 giây/testcase, nhanh hơn đáng kể so với việc khởi chạy môi trường mô phỏng đồ họa nặng nề trong các bộ công cụ EDA truyền thống.
Đổi mới và đóng góp
- Phương pháp Co-simulation tinh gọn dựa trên Python & Cocotb: Khắc phục sự cồng kềnh của quy trình SystemVerilog/UVM truyền thống bằng cách sử dụng Python để vừa làm Golden Model vừa làm Testbench điều khiển phần cứng. Điều này giúp giảm hơn 60% độ phức tạp mã nguồn kiểm thử và loại bỏ sự phụ thuộc vào các giấy phép phần mềm độc quyền.
- Cơ chế tiêm mã trực tiếp (Instruction Memory Injection): Thay vì phải tổng hợp lại toàn bộ thiết kế vi mạch mỗi khi đổi testcase, RVCoTS tự động cập nhật mảng nhớ
Instruction_Memory.v và biên dịch nhanh thông qua Icarus Verilog, tăng tốc độ lặp kiểm thử (verification turnaround time) lên gấp 3 đến 5 lần.
- Module Comp-Runner đối soát đa tầng tự động: Tự động so sánh đồng thời 4 lớp dữ liệu: luồng lệnh thực thi (instruction trace), tệp thanh ghi (register file), bộ nhớ dữ liệu (data memory) và độ bao phủ ràng buộc (functional coverage).
- Đóng góp cho cộng đồng vi mạch Việt Nam: Cung cấp bộ công cụ tham khảo hoàn chỉnh, tài liệu hóa chi tiết, đóng góp thiết thực cho công tác đào tạo nhân lực ngành Kỹ thuật Máy tính và Thiết kế Vi mạch tại ĐHQG-HCM nói riêng và Việt Nam nói chung.
Ứng dụng thực tế và triển khai
Tình huống ứng dụng thực tế
- Tích hợp trong luồng CI/CD cho thiết kế IP Core: Tự động kích hoạt kiểm thử hồi quy (Regression Testing) mỗi khi kỹ sư thiết kế phần cứng đẩy (push) mã nguồn Verilog mới lên hệ thống quản lý mã nguồn (GitLab/GitHub).
- Phòng lab thực hành thiết kế vi xử lý: Phục vụ sinh viên chuyên ngành Kỹ thuật Máy tính, Điện tử Viễn thông trong việc phát triển và tự kiểm chứng lõi CPU RV32I tự thiết kế mà không cần máy chủ EDA cấu hình cao.
- Nghiên cứu tùy biến tập lệnh mở rộng: Làm nền tảng để phát triển tiếp các tập lệnh mở rộng như RV32M (Nhân/Chia), RV32A (Toán tử nguyên tử) hoặc các tập lệnh xử lý AI/DSP nhúng.
sequenceDiagram
autonumber
actor Dev as Kỹ sư thiết kế RTL
participant Repo as Git Repository
participant Runner as RVCoTS CI/CD Runner
participant Report as Báo cáo Đánh giá
Dev->>Repo: Commit mã Verilog Core mới
Repo->>Runner: Kích hoạt Pipeline tự động
Runner->>Runner: Chạy Assembler & Sinh mã máy
Runner->>Runner: Thực thi song song ISS & RTL Sim
Runner->>Runner: Comp-Runner so sánh trạng thái
Runner->>Report: Xuất log & Độ bao phủ Coverage
Report-->>Dev: Phản hồi kết quả Pass/Fail (0.18s)
Yêu cầu triển khai và khả năng mở rộng
- Yêu cầu hệ thống:
- Hệ điều hành: Linux (Ubuntu 20.04/22.04 LTS, Debian) hoặc WSL2 trên Windows 11.
- Phần mềm & Thư viện: Python 3.8+,
cocotb, pytest, iverilog, gtkwave.
- Phần cứng: Tối thiểu 4GB RAM, CPU lõi kép x86_64 hoặc ARM64.
- Khả năng mở rộng: Kiến trúc mô-đun hóa cao cho phép mở rộng dễ dàng sang kiểm thử kiến trúc 64-bit (RV64I) hoặc tích hợp thêm bộ sinh lệnh ngẫu nhiên có trọng số (Weighted Random Instruction Generator).
Hạn chế và hướng phát triển
Hạn chế kỹ thuật hiện tại
- Mức độ trừu tượng: Trình mô phỏng ISS hiện tại hoạt động theo mô hình thực thi tuần tự từng lệnh, chưa phản ánh các hiện tượng trễ chu kỳ xung nhịp phát sinh do xung đột dữ liệu (Data Hazard), xung đột điều khiển (Control Hazard) trong các vi kiến trúc đường ống (Pipeline) 5 tầng sâu.
- Không gian tập lệnh: Chỉ mới bao phủ 37 lệnh số nguyên cơ bản của RV32I, chưa hỗ trợ các lệnh mở rộng chuẩn (M, A, F, D, C) cũng như thanh ghi trạng thái điều khiển CSR (Control and Status Registers).
Hướng phát triển tiếp theo
- Nâng cấp bộ mô phỏng ISS để hỗ trợ mô hình Cycle-Accurate Simulator, cho phép theo dõi số chu kỳ thực thi chính xác trên từng giai đoạn pipeline (IF, ID, EX, MEM, WB).
- Mở rộng tập lệnh sang RV32IMC và RV64GC, đáp ứng nhu cầu chạy các hệ điều hành thời gian thực (FreeRTOS) hoặc Linux nhúng.
- Xây dựng giao diện điều khiển trên nền tảng Web-based GUI Dashboard giúp trực quan hóa tín hiệu phần cứng và tạo điều kiện truy cập kiểm thử từ xa qua điện toán đám mây.
Đối tượng hưởng lợi
+-----------------------------------------------------------------------------------+
| ĐỐI TƯỢNG HƯỞNG LỢI |
| |
| [Sinh viên & Giảng viên] [Kỹ sư Thiết kế RTL] [Doanh nghiệp Vi mạch] |
| - Trực quan hóa kiến trúc - Rút ngắn chu kỳ DV - Tiết kiệm chi phí EDA |
| - Tài liệu học tập mở - Tích hợp CI/CD tự động - Chuẩn hóa quy trình |
+-----------------------------------------------------------------------------------+
- Sinh viên & Giảng viên ngành Vi mạch/Kỹ thuật Máy tính: Có được một nền tảng thực hành trực quan, dễ tiếp cận để hiểu sâu về mối quan hệ giữa tập lệnh phần mềm và thiết kế mạch phần cứng.
- Kỹ sư thiết kế vi mạch (ASIC/FPGA RTL Engineers): Sở hữu công cụ kiểm thử gọn nhẹ, phát hiện sớm các lỗi vi kiến trúc ngay trong giai đoạn thiết kế chức năng trước khi chuyển sang các bước tổng hợp logic phức tạp.
- Doanh nghiệp khởi nghiệp bán dẫn (Fabless Startups): Cắt giảm chi phí bản quyền công cụ EDA đắt đỏ trong giai đoạn phát triển ban đầu (Proof-of-Concept), tăng tốc độ đưa sản phẩm ra thị trường (Time-to-Market).
- Cộng đồng nghiên cứu RISC-V: Thêm một công cụ mã nguồn mở linh hoạt, phục vụ việc đánh giá hiệu năng của các vi kiến trúc lõi xử lý tùy biến mới.
Câu hỏi thường gặp
1. Yêu cầu kỹ thuật tối thiểu để triển khai bộ công cụ RVCoTS là gì?
Hệ thống yêu cầu máy tính chạy hệ điều hành Linux (khuyến nghị Ubuntu 22.04 LTS hoặc Windows Subsystem for Linux - WSL2). Về mặt phần mềm, cần cài đặt Python 3.8 trở lên, thư viện kiểm chứng cocotb, trình biên dịch iverilog để mô phỏng Verilog, và công cụ xem dạng sóng gtkwave. Cấu hình phần cứng tối thiểu là CPU lõi kép và 4GB RAM.
2. RVCoTS xử lý sự khác biệt giữa mô phỏng tuần tự của ISS và hiện tượng Pipeline trong RTL như thế nào?
ISS hoạt động ở mức trừu tượng tập lệnh (Instruction-level abstraction), cập nhật trạng thái sau khi lệnh kết thúc. Để đồng bộ với mô hình RTL có pipeline, module Testbench Controller và Comp-Runner trong RVCoTS tiến hành đối soát trạng thái tại ranh giới kết thúc lệnh (Instruction Retirement / Write-back stage), đảm bảo việc so sánh giá trị thanh ghi và ô nhớ diễn ra tại thời điểm dữ liệu đã được ghi nhận ổn định.
3. Có thể tích hợp bộ công cụ này vào các thiết kế lõi RISC-V tùy biến của người dùng không?
Hoàn toàn có thể. Người dùng chỉ cần kết nối các tín hiệu chuẩn của module lõi (như cổng nạp bộ nhớ lệnh Instruction_Memory, tín hiệu xung nhịp clk, reset, và bus trích xuất trạng thái thanh ghi) vào file wrapper testbench của Cocotb. Hệ thống sẽ tự động thực thi các chuỗi testcase và xuất báo cáo đối soát.
4. Hệ thống cần bảo trì và nâng cấp những thành phần nào khi bổ sung tập lệnh mới?
Khi mở rộng sang các tập lệnh như RV32M (Nhân/Chia) hay RV32F (Số thực), người phát triển chỉ cần cập nhật hai khối: (1) Khối bảng tra mã giải mã trong trình Assembler và (2) Định nghĩa hàm thực thi toán học tương ứng trong lớp mô phỏng ISS Python. Cấu trúc bộ so sánh Comp-Runner và giao diện Cocotb hoàn toàn có thể tái sử dụng.
5. Lợi ích kinh tế và thời gian hoàn vốn (ROI) khi áp dụng RVCoTS thay thế công cụ thương mại?
Việc sử dụng RVCoTS giúp doanh nghiệp hoặc phòng nghiên cứu tiết kiệm từ hàng chục nghìn đến hàng trăm nghìn USD chi phí bản quyền hàng năm cho các bộ phần mềm EDA thương mại trong giai đoạn kiểm thử chức năng mức lõi. Đồng thời, thời gian thiết lập môi trường kiểm thử giảm từ nhiều tuần xuống chỉ còn vài giờ, mang lại giá trị ROI rõ rệt ngay từ những giai đoạn đầu của dự án chip.
Kết luận
Đồ án khóa luận "Nghiên cứu phát triển bộ kiểm tra đánh giá hệ thống RISC-V Core" đã giải quyết thành công bài toán tự động hóa kiểm thử và xác minh chức năng cho vi xử lý kiến trúc RISC-V RV32I. Bằng cách kết hợp linh hoạt giữa ngôn ngữ Python, nền tảng Cocotb và mô hình tham chiếu ISS, hệ thống RVCoTS mang lại một quy trình kiểm chứng phần cứng tinh gọn, đạt độ chính xác tuyệt đối 100% trên 37 lệnh cơ bản và bao phủ toàn diện 10 tiêu chí đánh giá thiết kế.
Kết quả nghiên cứu không chỉ có giá trị học thuật cao mà còn có tính ứng dụng thực tiễn mạnh mẽ, đóng góp một giải pháp mã nguồn mở hữu ích cho cộng đồng kỹ thuật máy tính, thúc đẩy sự phát triển của hệ sinh thái vi mạch bán dẫn dựa trên chuẩn mở RISC-V tại Việt Nam.