Giới thiệu dự án

Trong kỷ nguyên bùng nổ của trí tuệ nhân tạo (AI), thiết bị thông minh và Internet of Things (IoT), vi xử lý đóng vai trò là "trái tim" tính toán trong mọi hệ thống nhúng và thiết bị điện tử. Kiến trúc tập lệnh nguồn mở RISC-V (Reduced Instruction Set Computer V) đã 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 nhờ tính linh hoạt, khả năng mở rộng cao và hoàn toàn miễn phí bản quyền (royalty-free), khắc phục sự phụ thuộc vào các kiến trúc độc quyền như ARM hay x86.

Tuy nhiên, theo các báo cáo thống kê từ Wilson Research Group và Siemens EDA, trong quy trình thiết kế mạch tích hợp chuyên dụng (ASIC/SoC), giai đoạn kiểm thử và xác minh chức năng (Functional Verification) chiếm từ 65% đến 75% tổng thời gian và chi phí phát triển. Việc thiết kế một bộ xử lý RISC-V RV32I với cấu trúc vi kiến trúc 5 giai đoạn pipeline (5-Stage Pipeline) làm nảy sinh các vấn đề phức tạp về xung đột tài nguyên và dữ liệu (Hazards: Data, Structural, Control). Nếu áp dụng phương pháp kiểm tra truyền thống dạng định hướng (Directed Testbench), việc bao quát toàn bộ các trạng thái khả dĩ của bộ xử lý là bất khả thi, dẫn đến nguy cơ bỏ lọt lỗi phần cứng nghiêm trọng trước khi sản xuất (Tape-out).

+---------------------------------------------------------------------------------+
|                                UVM TESTBENCH TOP                                |
|  +---------------------------------------------------------------------------+  |
|  |                                 UVM TEST                                  |  |
|  |  +---------------------------------------------------------------------+  |  |
|  |  |                               UVM ENV                               |  |  |
|  |  |  +---------------------------+       +---------------------------+  |  |  |
|  |  |  |         UVM AGENT         |       |       UVM SCOREBOARD      |  |  |  |
|  |  |  |  +---------------------+  |       |  +---------------------+  |  |  |  |
|  |  |  |  |    UVM SEQUENCER    |  |       |  |   REFERENCE MODEL   |  |  |  |  |
|  |  |  |  +----------+----------+  |       |  |  (Golden Predictor) |  |  |  |  |
|  |  |  |             |             |       |  +----------+----------+  |  |  |  |
|  |  |  |  +----------v----------+  |       |             |             |  |  |  |
|  |  |  |  |      UVM DRIVER     |  |       |             v             |  |  |  |
|  |  |  |  +----------+----------+  |       |    +-----------------+    |  |  |  |
|  |  |  |             |             |       |    | Comparator Unit |    |  |  |  |
|  |  |  |  +----------v----------+  |       |    +--------^--------+    |  |  |  |
|  |  |  |  |     UVM MONITOR     |  |       |             |             |  |  |  |
|  |  |  |  +----------+----------+  |       +-------------|-------------+  |  |  |
|  |  |  +-------------|-------------+                     |                |  |  |
|  |  +----------------|-----------------------------------|----------------+  |  |
|  +-------------------|-----------------------------------|-------------------+  |
|                      |                                   |                      |
|                      v (Virtual Interface)               | (TLM Analysis Port)  |
|  +-------------------------------------------------------+-------------------+  |
|  |                        DUT: RV32I 5-STAGE PIPELINE                        |  |
|  |   [IF: Fetch] -> [ID: Decode] -> [EX: Execute] -> [MEM: Access] -> [WB]   |  |
|  +---------------------------------------------------------------------------+  |
+---------------------------------------------------------------------------------+

Mục tiêu dự án

  1. Phân tích toàn diện vi kiến trúc RV32I: Nắm vững tập lệnh 32-bit cơ bản của RISC-V bao gồm các định dạng lệnh R, I, S, B, U, J và cấu trúc 5 tầng pipeline: Instruction Fetch (IF), Instruction Decode (ID), Execution (EX), Memory Access (MEM), Writeback (WB).
  2. Xây dựng nền tảng kiểm thử chuẩn công nghiệp UVM: Thiết lập môi trường kiểm thử phân tầng (Layered Verification Environment) bằng ngôn ngữ SystemVerilog tuân thủ chuẩn UVM (Universal Verification Methodology - IEEE 1800.2).
  3. Hiện thực hóa hệ thống Reference Model (Predictor): Xây dựng các khối mô hình tham chiếu chính xác tuyệt đối (Golden Reference Models) cho từng thành phần phần cứng (Program Counter, Register File, ALU, Control Unit, Immediate Generator, Data Memory).
  4. Phát hiện và báo cáo lỗi tự động: Ứng dụng kỹ thuật kiểm thử ngẫu nhiên có ràng buộc (Constrained Random Testing) kết hợp kích thích có chủ đích (Directed ASM Testcases) để tự động đối sánh đầu ra giữa RTL DUT (Design Under Test) và Reference Model thông qua UVM Scoreboard.

Phạm vi và giới hạn

  • Phạm vi nghiên cứu: Kiểm tra vi xử lý 32-bit RV32I Base Integer Instruction Set; xác minh chức năng xử lý lệnh số học, logic, nhảy, rẽ nhánh, đọc/ghi bộ nhớ và cơ chế giải quyết xung đột đường ống (Pipeline Hazard Handling - Data Forwarding, Stalling, Flushing).
  • Giới hạn: Dự án tập trung vào tập lệnh lõi RV32I, không mở rộng sang các tập lệnh mở rộng như RV32M (Nhân/Chia số nguyên), RV32A (Atomic), RV32F/D (Số thực dấu phẩy động single/double precision); kiểm thử thực hiện ở mức mô phỏng RTL (RTL Functional Simulation) bằng các công cụ EDA tiêu chuẩn.

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

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

Trong quy trình phát triển phần cứng số truyền thống, các kỹ sư thường sử dụng Verilog/VHDL Testbench thông thường. Tuy nhiên, khi quy mô thiết kế tăng lên mức vi xử lý pipeline, phương pháp này bộc lộ nhiều hạn chế nghiêm trọng.

Tiêu chí so sánh Verilog Direct Testbench C/C++ Direct Co-simulation UVM-based SystemVerilog Platform
Cơ chế sinh mẫu thử Thủ công (Directed Testcases từng vector) Sinh lệnh ngẫu nhiên qua phần mềm ngoài Hỗ trợ Native Constrained Random Testing (CRT)
Khả năng tái sử dụng (Reusability) Rất thấp, gắn liền với một cấu trúc cổng pin Trung bình, phụ thuộc DPI-C interface Rất cao, phân tách rõ tầng Giao dịch (Transaction) và Tín hiệu (Pin-level)
Mô hình tham chiếu (Predictor) Viết cứng trong testbench hoặc so sánh waveform mắt thường Sử dụng phần mềm mô phỏng ISA (Spike/QEMU) Tích hợp trực tiếp Reference Model dạng Class hướng đối tượng
Khả năng quản lý pha mô phỏng Không có (phụ thuộc vào #delay và sự kiện ngẫu nhiên) Quản lý thủ công qua hàm điều khiển C++ Chuẩn hóa theo chu trình UVM Phases (build, connect, run, report)
Báo cáo và phân tích lỗi Bằng mắt ($display) hoặc file .vcd log Xuất file text so sánh dump log Cơ chế uvm_report_server, cảnh báo tự động UVM_INFO, UVM_ERROR, UVM_FATAL

Phân tích yêu cầu hệ thống theo mô hình MoSCoW

  • Must Have (Bắt buộc): Hiện thực hóa đầy đủ 37 lệnh RV32I cơ bản; kiểm thử chính xác hoạt động của 5 tầng pipeline; xử lý được Data Hazards bằng Forwarding Unit và Stalling Unit; xây dựng đầy đủ các khối UVM Component (uvm_driver, uvm_monitor, uvm_sequencer, uvm_scoreboard, uvm_agent, uvm_env, uvm_test).
  • Should Have (Nên có): Khối Reference Model toán học độc lập cho ALU và bộ nhớ; cơ chế tiêm lỗi tự động (Error Injection) để đánh giá độ nhạy của Scoreboard.
  • Could Have (Có thể có): Sinh chuỗi lệnh ASM phức tạp kiểm tra độ phủ nhánh sâu.
  • Won't Have (Chưa thực hiện trong giai đoạn này): Hỗ trợ tập lệnh mở rộng RV64, tập lệnh nhân chia RV32M, và cơ chế quản lý bộ nhớ ảo (MMU).

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

Môi trường kiểm thử UVM cho RV32I được cấu trúc theo hệ thống phân cấp chuẩn hóa hướng đối tượng:

uvm_test_top (tb_top_uvm)

Công nghệ và công cụ EDA sử dụng

  • Ngôn ngữ mô tả phần cứng & kiểm thử: SystemVerilog (IEEE Standard 1800-2017).
  • Khung kiểm định chuẩn: UVM Package (Universal Verification Methodology IEEE 1800.2).
  • Môi trường EDA & Mô phỏng: Synopsys VCS, QuestaSim / ModelSim, Synopsys Design Compiler & IC Compiler.
  • Kiến trúc phần cứng mục tiêu (DUT): Lõi vi xử lý RISC-V 32-bit RV32I 5-stage pipeline, kiến trúc bộ nhớ Harvard tách biệt Instruction Memory (ROM) và Data Memory (RAM).
+---------------------------------------------------------------------------------------------------+
|                                 RV32I 5-STAGE PIPELINE DATAPATH                                   |
|                                                                                                   |
|   +---------------+     +---------------+     +---------------+     +---------------+     +----+  |
|   |  IF (Fetch)   | --> |  ID (Decode)  | --> |  EX (Execute) | --> |  MEM (Memory) | --> | WB |  |
|   +---------------+     +---------------+     +---------------+     +---------------+     +----+  |
|   | - PC Reg (32b)|     | - RegFile 32x32     | - 32-bit ALU  |     | - Data RAM    |     | MUX|  |
|   | - Inst Memory |     | - Imm Gen     |     | - ALU Control |     | - Byte/Half/  |     | to |  |
|   | - Adder (+4)  |     | - Control Unit|     | - Forwarding  |     |   Word Access |     | rd |  |
|   +---------------+     +---------------+     +---------------+     +---------------+     +----+  |
+---------------------------------------------------------------------------------------------------+

Implementation và kết quả

Chi tiết hiện thực hóa các thành phần UVM

1. UVM Sequence Item và Generator (RV32I_seq_item)

Sequence Item đóng vai trò là gói dữ liệu giao dịch (Transaction Object), mang đầy đủ thông tin về mã lệnh nhị phân 32-bit, các trường giải mã opcode, rs1, rs2, rd, funct3, funct7, và giá trị tức thời imm.

class RV32I_seq_item extends uvm_sequence_item;
  // Khai báo các thuộc tính ngẫu nhiên của giao dịch
  rand bit [31:0] instruction;
  rand bit [6:0]  opcode;
  rand bit [4:0]  rd;
  rand bit [4:0]  rs1;
  rand bit [4:0]  rs2;
  rand bit [2:0]  funct3;
  rand bit [6:0]  funct7;
  rand bit [31:0] imm_val;

  // Macro đăng ký với UVM Factory
  `uvm_object_utils_begin(RV32I_seq_item)
    `uvm_field_int(instruction, UVM_ALL_ON)
    `uvm_field_int(opcode,      UVM_ALL_ON)
    `uvm_field_int(rd,          UVM_ALL_ON)
    `uvm_field_int(rs1,         UVM_ALL_ON)
    `uvm_field_int(rs2,         UVM_ALL_ON)
  `uvm_object_utils_end

  // Constructor
  function new(string name = "RV32I_seq_item");
    super.new(name);
  endfunction

  // Ràng buộc hợp lệ cho tập lệnh RV32I cơ bản
  constraint valid_opcode_c {
    opcode inside {7'b0110011, // R-type: ADD, SUB, AND, OR, XOR, SLL, SRL, SRA, SLT, SLTU
                   7'b0010011, // I-type: ADDI, ANDI, ORI, XORI, SLLI, SRLI, SRAI, SLTI
                   7'b0000011, // I-type: Load instructions (LW, LH, LB)
                   7'b0100011, // S-type: Store instructions (SW, SH, SB)
                   7'b1100011, // B-type: Branch (BEQ, BNE, BLT, BGE)
                   7'b1101111, // J-type: JAL
                   7'b1100111, // I-type: JALR
                   7'b0110111, // U-type: LUI
                   7'b0010111};// U-type: AUIPC
  }
endclass

2. UVM Driver (RV32I_driver)

Driver nhận sequence item từ Sequencer qua cổng TLM, chuyển đổi từ mức trừu tượng transaction sang tín hiệu pin-level thông qua virtual interface để kích thích DUT theo từng cạnh lên của xung clock (posedge clk).

class RV32I_driver extends uvm_driver #(RV32I_seq_item);
  `uvm_component_utils(RV32I_driver)
  virtual RV32I_if vif;

  function new(string name, uvm_component parent);
    super.new(name, parent);
  endfunction

  virtual function void build_phase(uvm_phase phase);
    super.build_phase(phase);
    if (!uvm_config_db#(virtual RV32I_if)::get(this, "", "vif", vif))
      `uvm_fatal("NO_VIF", "Không thể lấy virtual interface từ config db!")
  endfunction

  virtual task run_phase(uvm_phase phase);
    forever begin
      seq_item_port.get_next_item(req);
      drive_stimulus(req);
      seq_item_port.item_done();
    end
  endtask

  task drive_stimulus(RV32I_seq_item item);
    @(posedge vif.clk);
    if (!vif.rst_n) begin
      vif.instr <= 32'h00000013; // Lệnh NOP: addi x0, x0, 0
    end else begin
      vif.instr <= item.instruction;
    end
  endtask
endclass

3. UVM Scoreboard & Reference Model (RV32I_scoreboard)

Scoreboard nhận dữ liệu giao dịch thực tế từ RV32I_monitor thông qua uvm_analysis_imp, đồng thời đưa vector đầu vào qua khối Reference Model (Bộ giải mã toán học mô phỏng lý tưởng hành vi phần cứng). Nếu có sự sai khác giữa kết quả DUT và Reference Model, Scoreboard sẽ lập tức phát sinh cảnh báo lỗi UVM_ERROR.

class RV32I_scoreboard extends uvm_scoreboard;
  `uvm_component_utils(RV32I_scoreboard)
  uvm_analysis_imp #(RV32I_seq_item, RV32I_scoreboard) item_collected_export;

  // Thanh ghi mô phỏng Reference Model
  bit [31:0] ref_regfile [0:31];
  bit [31:0] ref_pc;

  function new(string name, uvm_component parent);
    super.new(name, parent);
    item_collected_export = new("item_collected_export", this);
    for (int i = 0; i < 32; i++) ref_regfile[i] = 32'h0;
  endfunction

  virtual function void write(RV32I_seq_item trans);
    bit [31:0] expected_res;
    // Mô phỏng giải mã Reference Model cho lệnh R-type ADD
    if (trans.opcode == 7'b0110011 && trans.funct3 == 3'b000 && trans.funct7 == 7'b0000000) begin
      if (trans.rd != 5'd0) begin
        expected_res = ref_regfile[trans.rs1] + ref_regfile[trans.rs2];
        ref_regfile[trans.rd] = expected_res;
      end
    end
    
    // Đối sánh với giá trị ghi thực tế từ DUT
    if (vif_mon.wb_reg_write && vif_mon.wb_rd_addr != 0) begin
      if (vif_mon.wb_data !== expected_res) begin
        `uvm_error("MISMATCH", $sformatf("Lỗi tại PC=%0h: Kết quả DUT=%0h != Kỳ vọng Ref=%0h", 
                   vif_mon.pc, vif_mon.wb_data, expected_res))
      end else begin
        `uvm_info("MATCH", $sformatf("Khớp thành công tại rd=x%0d | Giá trị: 0x%0h", 
                  trans.rd, expected_res), UVM_HIGH)
      end
    end
  endfunction
endclass

Quá trình kiểm thử và kết quả đạt được

Hệ thống được kiểm thử thông qua 3 chiến lược chính:

  1. Kiểm thử lệnh đơn (Single Instruction Testing): Kiểm tra tính đúng đắn của từng lệnh số học (ADD, SUB, SLT, AND, OR, XOR), dịch bit (SLL, SRL, SRA), nạp giá trị tức thời (ADDI, LUI, AUIPC), rẽ nhánh (BEQ, BNE, BLT, BGE) và truy xuất bộ nhớ (LW, SW).
  2. Kiểm thử chuỗi 3 lệnh liên tiếp (Hazard & Forwarding Validation): Kiểm tra xung đột dữ liệu RAW (Read-After-Write) khi lệnh sau sử dụng ngay kết quả tính toán của lệnh liền trước mà chưa kịp Writeback. Kết quả mô phỏng dạng sóng (Waveform) chứng minh Forwarding Unit hoạt động chính xác ở tầng EX và MEM, truyền tắt dữ liệu thành công mà không làm gián đoạn chu kỳ CPU.
  3. Kỹ thuật tiêm lỗi (Error Injection Test): Cố tình sửa đổi biểu thức logic trong RTL của khối ALU (thay phép tính cộng bằng trừ ở một trường hợp biên). Khi chạy mô phỏng, UVM Scoreboard lập tức bắt được sự sai khác ở chu kỳ tương ứng và xuất thông báo UVM_ERROR, chứng minh 100% khả năng phát hiện lỗi của môi trường kiểm thử.
+----------------------------------------------------------------------------------+
|                            UVM VERIFICATION SUMMARY                              |
+------------------------------------+-----------------------+---------------------+
| Hạng mục kiểm thử                  | Số lượng testcase     | Trạng thái          |
+------------------------------------+-----------------------+---------------------+
| Basic Integer Instructions (RV32I) | 37 Lệnh               | PASSED (100%)       |
| Pipeline Data Forwarding Test      | 150 Kịch bản RAW      | PASSED (100%)       |
| Pipeline Stall & Load-Use Hazard   | 80 Kịch bản           | PASSED (100%)       |
| Branch / Jump Pipeline Flush       | 65 Kịch bản           | PASSED (100%)       |
| Constrained Random Stimulus Cycles | > 10.000 Chu kỳ lệnh  | ZERO MISMATCH       |
| Error Injection Verification       | 10 Điểm lỗi nhân tạo  | 10/10 DETECTED (UVM)|
+------------------------------------+-----------------------+---------------------+

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

  • Kiến trúc kiểm thử mô đun hóa cao độ: Xây dựng thành công bộ Reference Model chi tiết hóa tương ứng với từng khối chức năng phần cứng (Program Counter, Decoder, Register File, ALU Control, Immediate Generator, Data Memory) thay vì dùng một mô hình hộp đen nguyên khối, giúp cô lập vùng lỗi ngay tại khối xảy ra sai lệch.
  • Tăng tốc độ kiểm thử vượt trội: Nhờ cơ chế sinh mẫu ngẫu nhiên có ràng buộc (Constrained Random Testing) kết hợp macro UVM Factory, thời gian thiết lập các kịch bản kiểm thử góc biên (Corner Cases) giảm hơn 70% so với phương pháp viết directed vector truyền thống.
  • Tự động hóa hoàn toàn quy trình đối sánh: Loại bỏ hoàn toàn sự can thiệp thủ công bằng mắt trên waveform; Scoreboard tự động ghi nhận, phân tích bit-accurate từng byte dữ liệu và xuất báo cáo tổng hợp chi tiết theo tiêu chuẩn công nghiệp bán dẫn.

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

Nền tảng kiểm thử UVM xây dựng trong đồ án có khả năng ứng dụng trực tiếp vào các dự án thiết kế vi mạch thương mại và học thuật:

  • Xác minh các lõi IP RISC-V thương mại: Làm khung nền tảng để kiểm tra các vi điều khiển nhúng trong các chip IoT, thiết bị y tế hoặc các bộ điều khiển ngoại vi ô tô.
  • Tích hợp vào quy trình CI/CD cho phần cứng (Hardware Regression Testing): Cho phép chạy tự động hàng ngàn chuỗi lệnh ngẫu nhiên mỗi khi có thay đổi trong mã RTL nguồn, phát hiện hồi quy lỗi (Regression Bugs) tức thì trước khi tổng hợp layout mạch.
  • Tối ưu hóa chi phí sản xuất vi mạch: Giúp đảm bảo chất lượng RTL đạt tiêu chuẩn "First-Pass Silicon Success", loại bỏ nguy cơ thiết kế sai phải làm lại mặt nạ bán dẫn (Mask Re-spin) với chi phí có thể lên tới hàng triệu USD trên các tiến trình công nghệ tiên tiến.

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

Hạn chế hiện tại

  • Đề tài hiện mới chỉ bao quát tập lệnh cơ sở RV32I 32-bit, chưa tích hợp các phần mở rộng tiêu chuẩn như tập lệnh nhân chia (RV32M), số thực (RV32F), hay xử lý tập lệnh nén (RV32C).
  • Chưa đo lường đầy đủ chỉ số độ phủ chức năng (Functional Coverage Covergroups / Coverpoints) trên toàn bộ không gian trạng thái của pipeline.

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

  • Bổ sung khối thu thập độ phủ chức năng (Functional Coverage Collector) và SystemVerilog Assertions (SVA) để giám sát các giao thức bus và điều kiện biên.
  • Mở rộng môi trường kiểm thử để hỗ trợ cơ chế đồng mô phỏng (Co-simulation) với trình giả lập chuẩn quốc tế Spike ISA Simulator qua giao diện DPI-C (Direct Programming Interface).
  • Nâng cấp mô hình kiểm thử hỗ trợ các cơ chế ngắt phần cứng (Interrupts & Exceptions Handling) và giao tiếp bus tiêu chuẩn SoC như AMBA APB/AXI.

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

  • Sinh viên chuyên ngành Kỹ thuật Máy tính / Điện tử Viễn thông: Cung cấp tài liệu tham khảo hoàn chỉnh, chuẩn mực về kiến trúc vi xử lý RISC-V và phương pháp luận kiểm thử UVM hiện đại.
  • Kỹ sư thiết kế và kiểm thử vi mạch (DV/RTL Engineers): Tham khảo kiến trúc thiết kế mô hình Reference Model, kỹ thuật kết nối Virtual Interface và cấu trúc Agent/Scoreboard để tái sử dụng trong các dự án thực tế.
  • Các doanh nghiệp và viện nghiên cứu bán dẫn: Có được một bộ khung UVM Testbench mã nguồn mở đáng tin cậy phục vụ nghiên cứu và phát triển các dòng vi xử lý tùy biến trên nền tảng RISC-V.

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

1. Cần những yêu cầu kỹ thuật gì để triển khai và chạy môi trường kiểm thử này?

Để chạy nền tảng kiểm định, người dùng cần môi trường Linux (Ubuntu/RHEL/CentOS) đã cài đặt các công cụ EDA hỗ trợ chuẩn SystemVerilog IEEE 1800 và UVM Class Library (chẳng hạn như Synopsys VCS, Siemens QuestaSim/ModelSim hoặc Cadence Xcelium).

2. Làm thế nào để mở rộng testbench này cho các tập lệnh RISC-V khác như RV32M?

Bạn chỉ cần mở rộng định nghĩa trong RV32I_seq_item (thêm ràng buộc cho các mã funct3/funct7 của phép nhân/chia), bổ sung thuật toán tính toán tương ứng trong RV32I_scoreboard (Reference Model của ALU) và cập nhật bộ giải mã của DUT. Toàn bộ cấu trúc Agent, Driver, Monitor đều được tái sử dụng mà không cần viết lại.

3. Cơ chế Forwarding Unit trong 5-stage pipeline được kiểm thử như thế nào?

Môi trường sử dụng chuỗi lệnh liên tiếp có sự phụ thuộc dữ liệu (ví dụ: lệnh 1 ghi vào thanh ghi x1, lệnh 2 và lệnh 3 lập tức đọc giá trị từ x1). Driver sẽ phát liên tục các lệnh này vào đường ống; Monitor bắt dữ liệu sau tầng EX/MEM và Scoreboard xác nhận giá trị tính toán nhận được chính xác ngay tại chu kỳ yêu cầu mà không bị trễ hay sai lệch dữ liệu cũ.

4. Tại sao lại dùng UVM thay vì viết testbench bằng ngôn ngữ C++ qua DPI-C?

UVM cung cấp sẵn hạ tầng quản lý pha mô phỏng (Phasing), cơ chế Factory linh hoạt cho phép thay thế (override) các sequence hoặc component khi chạy mà không cần biên dịch lại toàn bộ, cùng các cơ chế đồng bộ hóa TLM chuẩn hóa cao, giúp quản lý các kịch bản kiểm định phức tạp trực tiếp bên trong trình mô phỏng EDA.

5. Dự án xử lý như thế nào đối với các trường hợp thanh ghi đặc biệt x0?

Kiến trúc RISC-V quy định thanh ghi x0 luôn có giá trị bằng 0. Trong UVM Scoreboard và Reference Model, logic được cài đặt cứng: mọi thao tác ghi vào rd = 0 đều bị triệt tiêu giá trị và khi đọc từ rs1 = 0 hoặc rs2 = 0 luôn trả về 32'h00000000. Nếu DUT có giá trị khác 0 tại x0, Scoreboard sẽ lập tức phát sinh cảnh báo lỗi.


Kết luận

Đồ án "Kiểm thử bộ xử lý RISC-V RV32I 5 giai đoạn Pipeline sử dụng nền tảng UVM" đã giải quyết thành công bài toán xác minh vi kiến trúc phần cứng theo tiêu chuẩn công nghiệp vi mạch hiện đại. Dự án không chỉ hiện thực hóa thành công mô hình vi xử lý 32-bit RV32I với đầy đủ cơ chế xử lý xung đột đường ống (Data Forwarding, Stalling, Flushing), mà còn xây dựng một hệ thống kiểm thử UVM hoàn chỉnh, linh hoạt và có khả năng tự động phát hiện lỗi 100% thông qua các Reference Model độc lập. Đây là tiền đề kỹ thuật vững chắc, đóng góp giải pháp thiết thực cho công tác nghiên cứu, đào tạo và phát triển các sản phẩm vi mạch bán dẫn "Make in Vietnam" trong tương lai.