Giới thiệu dự án

Trong bối cảnh bùng nổ của cuộc Cách mạng Công nghiệp 4.0 và làn sóng chuyển dịch chuỗi cung ứng vi mạch bán dẫn toàn cầu, ngành công nghiệp thiết kế vi mạch (IC Design) tại Việt Nam đang trở thành một trụ cột chiến lược. Theo báo cáo từ Semiconductor Industry Association (SIA), thị trường chip bán dẫn toàn cầu dự kiến vượt mốc 1.000 tỷ USD vào năm 2030, thúc đẩy nhu cầu cấp thiết về các kiến trúc vi xử lý mở, linh hoạt và tối ưu hóa năng lượng thay thế cho các tập lệnh độc quyền đắt đỏ như x86 hay ARM.

Đề tài "Thiết kế bộ vi xử lý 32 bit" (thực hiện bởi sinh viên Nguyễn Bảo Tính và Trần Nhật Hải, dưới sự hướng dẫn của ThS. Lê Minh Thành tại Trường Đại học Sư phạm Kỹ thuật TP. Hồ Chí Minh - HCMUTE) tập trung vào việc nghiên cứu, hiện thực hóa và mô phỏng một bộ xử lý trung tâm 32-bit hoàn chỉnh dựa trên kiến trúc tập lệnh mở RISC-V (RV32I và RV32M) kết hợp cùng kiến trúc bộ nhớ Harvard và kỹ thuật xử lý đường ống 5 tầng (5-stage pipeline).

+------------------------------------------------------------------------------------+
|                                    TỔNG QUAN HỆ THỐNG                              |
|                                                                                    |
|  +-------------------+      +-------------------+      +------------------------+  |
|  |  Tập lệnh RISC-V  | ---> |  Pipeline 5 tầng  | ---> |  Kiến trúc Harvard     |  |
|  |   (RV32I/RV32M)   |      | (IF-ID-EX-MEM-WB) |      | (Tách biệt Data/Instr) |  |
|  +-------------------+      +-------------------+      +------------------------+  |
|            |                          |                             |              |
|            +--------------------------+-----------------------------+              |
|                                       v                                            |
|                      +----------------------------------+                          |
|                      |  RTL Verilog HDL + Xilinx Vivado |                          |
|                      +----------------------------------+                          |
+------------------------------------------------------------------------------------+

Vấn đề thực tiễn (Problem Statement)

Các kiến trúc vi xử lý đơn chu kỳ (Single-Cycle Processor) truyền thống tồn tại nhược điểm chí mạng: chu kỳ xung nhịp (clock cycle) bị kéo dài bởi đường trễ dài nhất (Critical Path - thường là lệnh truy xuất bộ nhớ LW mất ~800ps), khiến các khối tài nguyên như ALU hay Register File bị nhàn rỗi trong phần lớn thời gian chu kỳ. Thêm vào đó, kiến trúc Von Neumann truyền thống sử dụng chung bus dữ liệu và bus lệnh tạo ra hiện tượng "nút thắt cổ chai Von Neumann" (Von Neumann Bottleneck), gây xung đột cấu trúc khi vi xử lý đồng thời thực hiện lấy lệnh và truy xuất toán hạng từ bộ nhớ.

Mục tiêu của dự án (Project Objectives)

  1. Thiết kế vi kiến trúc RISC-V 32-bit (RV32I/RV32M): Hiện thực hóa tập lệnh cơ sở số nguyên gồm 37 lệnh tính toán, rẽ nhánh, lưu/tải bộ nhớ và mở rộng nhân/chia phần cứng.
  2. Hiện thực kỹ thuật đường ống 5 tầng (5-Stage Pipeline): Phân chia luồng thực thi thành 5 giai đoạn độc lập: Lấy lệnh (IF), Giải mã lệnh (ID), Thực thi (EX), Truy cập bộ nhớ (MEM), và Ghi lại (WB).
  3. Tích hợp giải pháp xử lý xung đột (Hazard Handling): Xây dựng khối chuyển tiếp dữ liệu (Forwarding/Bypassing Unit) và khối phát hiện ngắt đường ống (Hazard Detection Unit) nhằm giải quyết triệt để xung đột dữ liệu (RAW Hazard) và xung đột điều khiển (Branch Hazard).
  4. Áp dụng kiến trúc Harvard độc lập: Phân tách bộ nhớ lệnh (Instruction Memory) và bộ nhớ dữ liệu (Data Memory) với hệ thống bus địa chỉ và dữ liệu riêng biệt.
  5. Mô tả phần cứng và kiểm tra xác thực: Lập trình hoàn toàn bằng ngôn ngữ Verilog HDL (chuẩn IEEE 1364-2001) và mô phỏng trên nền tảng EDA Xilinx Vivado Design Suite 2023.2.

Phương pháp tiếp cận và kết quả kỳ vọng

Bằng việc triển khai kỹ thuật đường ống và phân chia giai đoạn lý tưởng (mỗi tầng ~200ps), hệ thống hướng tới cải thiện thông lượng xử lý lên tới xấp xỉ 4 lần so với kiến trúc không đường ống, đưa chỉ số xung nhịp trên mỗi lệnh (CPI - Cycles Per Instruction) tiệm cận mức lý tưởng là 1.0.

Phạm vi và giới hạn đề tài

  • Phạm vi: Thiết kế ở mức Register-Transfer Level (RTL) trên Verilog HDL, kiểm thử chức năng và phân tích công suất thông qua mô phỏng dạng sóng trên phần mềm Vivado.
  • Giới hạn: Đề tài không đi sâu vào việc đóng gói vi mạch vật lý (ASIC Tape-out) hoặc tích hợp các ngoại vi phức tạp (như DMA, PCIe, MMU phục vụ hệ điều hành Linux) mà tập trung vào vi kiến trúc lõi CPU độc lập cho hệ thống nhúng.

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

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

Tiêu chí Vi xử lý Đơn chu kỳ MIPS [6, 7] Đa chu kỳ Von Neumann [5] ARM Cortex-M0+ thương mại Lõi RISC-V Đề tài (HCMUTE)
Kiến trúc tập lệnh (ISA) MIPS 32-bit (Độc quyền) MIPS 32-bit (Độc quyền) ARMv6-M (Bản quyền cao) RISC-V RV32I/M (Mã nguồn mở)
Cấu trúc đường ống 1 chu kỳ (Không Pipeline) Đa chu kỳ tuần tự 2 tầng Pipeline 5 tầng Pipeline (IF-ID-EX-MEM-WB)
Cấu trúc bộ nhớ Von Neumann (Chung bus) Von Neumann (Chung bus) Modified Von Neumann Harvard (Tách biệt 32-bit Bus)
Xử lý xung đột RAW Không có (Do 1 chu kỳ) Trì hoãn phần mềm Không hỗ trợ Forwarding Hardware Forwarding + Hazard Unit
Tối ưu tần số hoạt động Thấp (Bị giới hạn bởi lệnh dài nhất) Trung bình Khá cao Tối ưu cao (Cân bằng độ trễ tầng)
Chi phí bản quyền IP Đóng phí bản quyền Đóng phí bản quyền Phí bản quyền hàng năm rất lớn 0 USD (Miễn phí bản quyền hoàn toàn)

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

  • Must have (Bắt buộc có): Đầy đủ 32 thanh ghi đa dụng 32-bit (x0 - x31, trong đó x0 ghim cứng giá trị 0x00000000); Bộ giải mã các định dạng lệnh R, I, S, B, U, J; Đơn vị luận lý số học ALU 32-bit; Bộ Forwarding Unit giải quyết xung đột RAW.
  • Should have (Nên có): Khối mở rộng RV32M hỗ trợ nhân/chia phần cứng 32-bit; Bộ đệm chương trình PC tự động cập nhật và xử lý rẽ nhánh có điều kiện (BEQ, BNE, BLT, BGE).
  • Could have (Có thể có): Cơ chế dự đoán rẽ nhánh tĩnh (Static Branch Prediction); Giao tiếp bộ nhớ đệm Cache L1.
  • Won't have (Chưa thực hiện đợt này): Bộ tính toán số thực dấu phẩy động (FPU - RV32F/D); Quản lý bộ nhớ ảo (MMU) cho Linux.

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

Cấu trúc vi kiến trúc 5 tầng được kết nối đồng bộ qua các thanh ghi đường ống trung gian (Pipeline Registers): IF/ID, ID/EX, EX/MEM, MEM/WB.

graph LR
    subgraph IF [Tầng IF - Instruction Fetch]
        PC[Program Counter] --> Addr[Add +4]
        PC --> IMem[Instruction Memory]
        IMem --> IF_ID[Thanh ghi IF/ID]
    end

    subgraph ID [Tầng ID - Instruction Decode]
        IF_ID --> Dec[Decoder & Control Unit]
        IF_ID --> Regs[Register File x0-x31]
        Dec --> ID_EX[Thanh ghi ID/EX]
        Regs --> ID_EX
    end

    subgraph EX [Tầng EX - Execution]
        ID_EX --> MuxFwdA[MUX Forwarding A]
        ID_EX --> MuxFwdB[MUX Forwarding B]
        MuxFwdA --> ALU[ALU 32-bit]
        MuxFwdB --> ALU
        ALU --> EX_MEM[Thanh ghi EX/MEM]
    end

    subgraph MEM [Tầng MEM - Memory Access]
        EX_MEM --> DMem[Data Memory RAM]
        EX_MEM --> MEM_WB[Thanh ghi MEM/WB]
        DMem --> MEM_WB
    end

    subgraph WB [Tầng WB - Write Back]
        MEM_WB --> MuxWB[MUX Result Select]
        MuxWB -->|Ghi dữ liệu về rd| Regs
    end

    subgraph HAZARD [Khối điều khiển xung đột]
        FwdUnit[Forwarding Unit] -.->|ForwardA / ForwardB| MuxFwdA
        FwdUnit -.->|ForwardA / ForwardB| MuxFwdB
        StallUnit[Hazard Detection Unit] -.->|Stall PC & IF/ID, Flush ID/EX| PC
    end

Ngăn xếp công nghệ sử dụng

  • Ngôn ngữ mô tả phần cứng: Verilog HDL (Chuẩn IEEE 1364-2001) với cấu trúc phân tầng Modular RTL.
  • Môi trường thiết kế & Mô phỏng EDA: AMD/Xilinx Vivado Design Suite v2023.2 (Vivado Simulator, RTL Elaborator, Logic Synthesizer).
  • Kiến trúc mục tiêu: FPGA Xilinx Artix-7 (XC7A35T-1CPG236C) / Spartan-7.
  • Tập lệnh: RISC-V RV32I Base Integer + RV32M Standard Extension.

Implementation và kết quả

Chi tiết các tầng trong đường ống (Pipeline Stages)

  1. Khối Lấy Lệnh (Instruction Fetch - IF): Chứa thanh ghi Bộ đếm chương trình (Program Counter - PC). Trong mỗi chu kỳ xung nhịp, địa chỉ PC trỏ vào Bộ nhớ lệnh để lấy mã nhị phân 32-bit InstrF. Đồng thời, mạch cộng PC + 4 chuẩn bị địa chỉ kế tiếp. Khi có tín hiệu rẽ nhánh PCSrcE = 1, địa chỉ nhảy PCTargetE sẽ được nạp qua MUX đầu vào.

  2. Khối Giải Mã Lệnh (Instruction Decode - ID): Phân tích trường opcode[6:0], funct3[14:12], và funct7[31:25]. Đồng thời đọc 2 thanh ghi nguồn rs1, rs2 từ Register File và mở rộng dấu (Sign-Extend) cho các giá trị tức thời (Immediate Generator) theo từng định dạng R, I, S, B, U, J.

  3. Khối Thực Thi (Execution - EX): Thực hiện tính toán số học (ADD, SUB, AND, OR, SLT, MUL, DIV) hoặc tính toán địa chỉ bộ nhớ hiệu dụng rs1 + Imm. MUX đầu vào của ALU kết nối trực tiếp với Khối chuyển tiếp dữ liệu (Forwarding Unit).

  4. Khối Truy Cập Bộ Nhớ (Memory Access - MEM): Thực hiện đọc (LW, LH, LB) hoặc ghi (SW, SH, SB) vào Bộ nhớ dữ liệu thông qua tín hiệu điều khiển MemWriteE và MemReadE.

  5. Khối Ghi Lại (Write Back - WB): Chọn lựa giữa kết quả đầu ra của ALU hoặc dữ liệu đọc từ RAM thông qua tín hiệu ResultSrcW để ghi trực tiếp vào thanh ghi đích rd.

Mã nguồn hiện thực Verilog cốt lõi

1. Đơn vị Luận lý Số học (ALU Module - alu.v)

Thực hiện các phép toán cơ sở của RV32I và RV32M:

module alu (
    input  wire [31:0] SrcA,
    input  wire [31:0] SrcB,
    input  wire [3:0]  ALUControl,
    output reg  [31:0] ALUResult,
    output wire        Zero
);
    always @(*) begin
        case (ALUControl)
            4'b0000: ALUResult = SrcA + SrcB;                  // ADD, ADDI, LW, SW
            4'b0001: ALUResult = SrcA - SrcB;                  // SUB, BEQ, BNE
            4'b0010: ALUResult = SrcA & SrcB;                  // AND, ANDI
            4'b0011: ALUResult = SrcA | SrcB;                  // OR, ORI
            4'b0100: ALUResult = SrcA ^ SrcB;                  // XOR, XORI
            4'b0101: ALUResult = ($signed(SrcA) < $signed(SrcB)) ? 32'd1 : 32'd0; // SLT, SLTI
            4'b0110: ALUResult = SrcA << SrcB[4:0];            // SLL, SLLI
            4'b0111: ALUResult = SrcA >> SrcB[4:0];            // SRL, SRLI
            4'b1000: ALUResult = $signed(SrcA) >>> SrcB[4:0];   // SRA, SRAI
            4'b1001: ALUResult = SrcA * SrcB;                  // MUL (RV32M)
            4'b1010: ALUResult = (SrcB != 0) ? (SrcA / SrcB) : 32'hFFFFFFFF; // DIV (RV32M)
            default: ALUResult = 32'h00000000;
        endcase
    end

    assign Zero = (ALUResult == 32'b0) ? 1'b1 : 1'b0;
endmodule

2. Khối Chuyển Tiếp Dữ Liệu (Forwarding Unit - forwarding_unit.v)

Phát hiện và loại bỏ độ trễ do phụ thuộc dữ liệu Read-After-Write (RAW) mà không cần chèn chu kỳ chết (NOP Stall):

module forwarding_unit (
    input  wire [4:0] Rs1E,
    input  wire [4:0] Rs2E,
    input  wire [4:0] RdM,
    input  wire [4:0] RdW,
    input  wire       RegWriteM,
    input  wire       RegWriteW,
    output reg  [1:0] ForwardAE,
    output reg  [1:0] ForwardBE
);
    always @(*) begin
        // --- XỬ LÝ CHUYỂN TIẾP CHO TOÁN HẠNG A (ForwardAE) ---
        // Hazard tại tầng MEM (Ưu tiên cao nhất)
        if (RegWriteM && (RdM != 5'd0) && (RdM == Rs1E))
            ForwardAE = 2'b10; // Chuyển tiếp trực tiếp từ kết quả ALU tầng EX/MEM
        // Hazard tại tầng WB
        else if (RegWriteW && (RdW != 5'd0) && (RdW == Rs1E))
            ForwardAE = 2'b01; // Chuyển tiếp từ kết quả ghi lại tầng MEM/WB
        else
            ForwardAE = 2'b00; // Không có hazard, lấy từ Register File

        // --- XỬ LÝ CHUYỂN TIẾP CHO TOÁN HẠNG B (ForwardBE) ---
        if (RegWriteM && (RdM != 5'd0) && (RdM == Rs2E))
            ForwardBE = 2'b10;
        else if (RegWriteW && (RdW != 5'd0) && (RdW == Rs2E))
            ForwardBE = 2'b01;
        else
            ForwardBE = 2'b00;
    end
endmodule

3. Khối Phát Hiện Xung Đột & Dừng Đường Ống (Hazard Detection Unit)

Xử lý trường hợp đặc biệt: Lệnh LW đi liền trước một lệnh sử dụng dữ liệu vừa nạp (Load-Use Data Hazard). Trong trường hợp này, Forwarding đơn thuần không thể bù đắp độ trễ do dữ liệu từ RAM chỉ sẵn sàng ở cuối tầng MEM:

module hazard_detection_unit (
    input  wire [4:0] Rs1D,
    input  wire [4:0] Rs2D,
    input  wire [4:0] RdE,
    input  wire       ResultSrcE0, // Tín hiệu nhận diện lệnh Load ở tầng EX
    output wire       StallF,
    output wire       StallD,
    output wire       FlushE
);
    wire lwStall;
    // Kiểm tra nếu lệnh ở tầng EX là LW và thanh ghi đích trùng với thanh ghi nguồn ở tầng ID
    assign lwStall = ResultSrcE0 && ((RdE == Rs1D) || (RdE == Rs2D)) && (RdE != 5'd0);

    // Khi phát hiện Load-Use Hazard:
    assign StallF = lwStall; // Đóng băng Program Counter (không tăng PC)
    assign StallD = lwStall; // Đóng băng thanh ghi IF/ID
    assign FlushE = lwStall; // Xóa lệnh ở tầng ID/EX (chèn bong bóng NOP)
endmodule

Kết quả kiểm tra và mô phỏng xác thực (Verification)

Hệ thống được kiểm thử bằng một chuỗi chương trình hợp ngữ (Assembly Test Program) bao gồm các trường hợp phụ thuộc dữ liệu phức tạp:

# Assembly Testbench Sequence (Vivado Simulation 0ns - 480ns)
main:
    addi x1, x0, 15      # Nạp x1 = 15
    addi x2, x0, 25      # Nạp x2 = 25
    add  x3, x1, x2      # RAW Hazard 1: x3 = 15 + 25 = 40 (Forwarding từ EX->EX)
    sw   x3, 4(x0)       # Lưu x3 (40) vào Data Memory tại địa chỉ 0x00000004
    lw   x4, 4(x0)       # Load-Use: Nạp x4 từ RAM (x4 = 40)
    sub  x5, x4, x1      # Load-Use Hazard: Cần Stall 1 chu kỳ, sau đó Forwarding (x5 = 25)
    beq  x5, x2, target  # Branch Hazard: So sánh x5 (25) == x2 (25) -> Nhánh nhảy đúng!
    addi x6, x0, 99      # Bị Flush do nhánh nhảy (Branch Taken)
target:
    addi x7, x0, 100     # x7 = 100 (Chương trình kết thúc thành công)

Bảng kết quả mô phỏng dạng sóng trên Xilinx Vivado

Mốc thời gian (ns) Tầng IF (InstrF) Tầng ID (Giải mã) Tầng EX (ALUResult) Tầng MEM (RAM Data) Tầng WB (Ghi về Reg) Trạng thái Forwarding / Hazard
0 - 40 ns addi x1, x0, 15 NOP 0x00000000 N/A Không Khởi tạo hệ thống
40 - 80 ns addi x2, x0, 25 addi x1 N/A N/A Ghi x1 = 15 Ghi giá trị vào thanh ghi x1
80 - 120 ns add x3, x1, x2 addi x2 0x0000000F N/A Ghi x2 = 25 Ghi giá trị vào thanh ghi x2
120 - 160 ns sw x3, 4(x0) add x3 0x00000028 (40) N/A N/A ForwardAE/BE = 2'b10 (Tính đúng x3=40)
160 - 200 ns lw x4, 4(x0) sw x3 0x00000004 RAM[4] = 40 Ghi x3 = 40 Ghi dữ liệu 40 vào RAM
200 - 240 ns sub x5, x4, x1 lw x4 0x00000004 Đọc RAM = 40 N/A Hazard Unit kích hoạt Stall (1 chu kỳ)
240 - 280 ns (Giữ nguyên PC) (Flush NOP) NOP Bubble N/A Ghi x4 = 40 Chèn Bubble, x4 sẵn sàng
280 - 320 ns beq x5, x2 sub x5 0x00000019 (25) N/A N/A ForwardAE = 2'b01 (Tính đúng x5=25)
320 - 360 ns addi x6, x0, 99 beq x5, x2 Zero = 1'b1 N/A Ghi x5 = 25 Phát hiện rẽ nhánh hợp lệ (PCSrcE=1)
360 - 400 ns addi x7, x0, 100 (Flush Flush) Flush lệnh x6 N/A N/A Xóa lệnh rẽ nhánh sai addi x6
400 - 480 ns NOP addi x7 0x00000064 N/A Ghi x7 = 100 Kết thúc chương trình chính xác

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

  1. Khắc phục triệt để phụ thuộc dữ liệu bằng cơ chế Forwarding tối ưu: Không phụ thuộc vào trình biên dịch chèn lệnh trễ NOP, bộ vi xử lý tự động phân tích và chuyển tiếp kết quả từ tầng EX/MEM và MEM/WB quay ngược lại lối vào ALU chỉ trong $0.12\text{ ns}$ độ trễ logic, giảm thiểu $75%$ số chu kỳ stall đối với các lệnh tính toán số học liên tiếp.
  2. Loại bỏ nút thắt cổ chai cấu trúc với Kiến trúc Harvard: Bằng việc thiết kế hai cổng giao tiếp riêng biệt cho bộ nhớ chương trình và bộ nhớ dữ liệu, xung đột cấu trúc được triệt tiêu hoàn toàn, cho phép CPU duy trì tốc độ tìm nạp lệnh liên tục trong khi các lệnh LW/SW đang truy xuất RAM.
  3. Hiệu năng cải thiện vượt bậc: So với kiến trúc Single-Cycle MIPS [6, 7], tốc độ thực thi tổng thể trên chuỗi lệnh tiêu chuẩn tăng gấp 3.85 lần nhờ rút ngắn chu kỳ xung nhịp từ $800\text{ ps}$ xuống còn $210\text{ ps}$ trên mỗi tầng.
SO SÁNH THỜI GIAN THỰC THI (LÝ THUYẾT & MÔ PHỎNG)
+-----------------------------------------------------------------------------+
| Single-Cycle MIPS (Reaz et al.)                                             |
| [==================================================] 800ps / Instruction    |
|                                                                             |
| 5-Stage Pipelined RV32I/M (HCMUTE Đề tài)                                   |
| [=============] 210ps / Pipeline Stage (Throughput CPI tiệm cận 1.0)        |
+-----------------------------------------------------------------------------+

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

Trường hợp sử dụng thực tế (Use Cases)

  • Lõi điều khiển nhúng trong các thiết bị IoT: Sử dụng làm bộ điều khiển trung tâm tiêu thụ năng lượng thấp cho các nút cảm biến thông minh, nhà thông minh và các thiết bị quan trắc môi trường.
  • Bộ xử lý tín hiệu chuyên dụng trên FPGA: Khối mở rộng RV32M cho phép thực hiện nhanh các phép toán lọc số FIR/IIR và xử lý tín hiệu viễn thông cơ bản mà không cần trang bị DSP rời.
  • Nền tảng đào tạo kỹ thuật máy tính và thiết kế vi mạch: Cung cấp mô hình vi kiến trúc trực quan, chuẩn xác để sinh viên nghiên cứu sâu về kiến trúc máy tính, kiểm thử RTL và thực hành tối ưu hóa đường ống vi xử lý.
LỘ TRÌNH TRIỂN KHAI PHẦN CỨNG (FPGA TO CHIP)
+----------------+      +----------------+      +----------------+      +----------------+
|  Giai đoạn 1   | ---> |  Giai đoạn 2   | ---> |  Giai đoạn 3   | ---> |  Giai đoạn 4   |
| RTL Simulation |      | Synthesis FPGA |      | SoC & AXI4 Bus |      | ASIC Prototype |
| (Xilinx Vivado)|      | (Artix-7 50MHz)|      | (UART/SPI/GPIO)|      | (TSMC/SkyWater)|
+----------------+      +----------------+      +----------------+      +----------------+

Hướng dẫn tổng hợp và triển khai trên FPGA Xilinx

  1. Khởi tạo Project trong Vivado: Tạo dự án RTL mới, chọn dòng chip mục tiêu xc7a35tcpg236-1 (Bo mạch Basys 3 hoặc cDone Artix-7).
  2. Import toàn bộ mã nguồn RTL: Thêm các tệp alu.v, register_file.v, datapath.v, controller.v, forwarding_unit.v, hazard_detection_unit.v và riscv_top.v.
  3. Tạo ràng buộc chân (Constraints File - .xdc): Khai báo chân Clock đầu vào $100\text{ MHz}$ và phân chia tần số xuống $50\text{ MHz}$ qua khối IP Clocking Wizard (PLL).
  4. Thực thi Synthesis và Implementation: Chạy quy trình tổng hợp logic và kiểm tra báo cáo Timing Summary để đảm bảo Worst Negative Slack (WNS) > 0.
  5. Nạp Bitstream: Tạo file .bit và nạp vào chip FPGA thông qua Vivado Hardware Manager.

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

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

  • Chưa có bộ dự đoán rẽ nhánh động (Dynamic Branch Predictor): Khi gặp lệnh rẽ nhánh có điều kiện, CPU mặc định dừng hoặc xóa 1 chu kỳ lệnh kế tiếp (Branch Penalty = 1 cycle), làm giảm nhẹ hiệu suất trong các vòng lặp lớn.
  • Bộ nhớ chưa tích hợp Cache: Hiện tại bộ nhớ được mô hình hóa dưới dạng RAM đơn khối với độ trễ 1 chu kỳ, chưa mô phỏng được độ trễ thực tế của chip DRAM ngoài (thường mất hàng chục chu kỳ).

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

  • Tích hợp bộ nhớ đệm L1 Cache (Instruction & Data Cache): Thiết kế cấu trúc Cache 2 chiều (2-way Set-Associative) với chính sách ghi Write-Back và thay thế LRU.
  • Mở rộng giao tiếp ngoại vi AXI4 / APB Bus: Đóng gói vi xử lý thành IP Core chuẩn AXI-Lite để dễ dàng kết nối với các ngoại vi UART, SPI, I2C, GPIO và Timer.
  • Nâng cấp tập lệnh nén RV32C (Compressed Instructions): Giảm dung lượng mã nhị phân từ 32-bit xuống 16-bit cho các lệnh phổ biến, giúp tiết kiệm bộ nhớ flash tới $30%$.

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

  • Sinh viên chuyên ngành Điện tử - Viễn thông & Kỹ thuật Máy tính: Nắm vững mối liên kết trực quan giữa lý thuyết tập lệnh máy tính, kiến trúc đường ống và cách hiện thực hóa phần cứng bằng ngôn ngữ Verilog HDL.
  • Kỹ sư thiết kế số (RTL Engineers): Có sẵn bộ khung mã nguồn vi xử lý RISC-V 5 tầng chuẩn mực, đã xác thực giải thuật Forwarding và Hazard Unit để tái sử dụng làm lõi nhúng tùy biến trong các dự án ASIC/FPGA.
  • Doanh nghiệp & Startup công nghệ bán dẫn: Tiết kiệm chi phí bản quyền IP (giảm thiểu hàng triệu USD chi phí cấp phép kiến trúc hàng năm so với ARM), toàn quyền làm chủ mã nguồn phần cứng phục vụ an ninh thông tin.
  • Nhóm nghiên cứu học thuật: Cung cấp nền tảng mở dễ dàng tích hợp các bộ tăng tốc tính toán trí tuệ nhân tạo (AI Accelerators) hoặc giải thuật mật mã bảo mật phần cứng.

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

1. Cấu hình phần cứng tối thiểu để tổng hợp và mô phỏng lõi RISC-V này là gì?

Hệ thống yêu cầu máy tính cài đặt hệ điều hành Linux (Ubuntu 20.04/22.04 LTS) hoặc Windows 10/11 64-bit, RAM tối thiểu 8GB (khuyến nghị 16GB), bộ nhớ trống 30GB và cài đặt phần mềm Xilinx Vivado Design Suite phiên bản từ 2020.2 trở lên. Để triển khai thực tế trên phần cứng, cần bo mạch FPGA Xilinx Artix-7, Spartan-7 hoặc Zynq-7000.

2. Sự khác biệt giữa Forwarding Unit và Hazard Detection Unit trong vi xử lý là gì?

  • Forwarding Unit (Khối chuyển tiếp): Xử lý xung đột dữ liệu tính toán (EX-EX hoặc MEM-EX Hazard) bằng cách chuyển trực tiếp kết quả từ tầng sau về lối vào ALU của tầng trước trong thời gian thực mà không làm dừng (stall) xung nhịp.
  • Hazard Detection Unit (Khối phát hiện xung đột): Xử lý xung đột tải dữ liệu (Load-Use Data Hazard) và xung đột điều khiển (Branch Hazard). Do dữ liệu từ lệnh LW chỉ sẵn sàng sau tầng MEM, khối này bắt buộc phải chèn 1 chu kỳ chết (NOP bubble) bằng cách đóng băng PC và thanh ghi IF/ID.

3. Làm thế nào để tích hợp lõi vi xử lý này với các ngoại vi như UART, GPIO?

Lõi vi xử lý cần được bổ sung một module Memory-Mapped I/O (MMIO). Khi địa chỉ truy xuất bộ nhớ vượt qua dải địa chỉ của RAM (ví dụ: 0x80000000 trở lên), bộ giải mã địa chỉ sẽ chuyển hướng bus dữ liệu sang các thanh ghi điều khiển của module ngoại vi UART hoặc GPIO.

4. Lõi vi xử lý này có thể chạy được hệ điều hành thời gian thực (RTOS) không?

Có thể. Để chạy các hệ điều hành thời gian thực như FreeRTOS, vi xử lý chỉ cần bổ sung bộ đếm thời gian hệ thống (Machine Timer - mtime/mtimecmp) và hỗ trợ xử lý ngắt cơ bản trong thanh ghi điều khiển trạng thái (CSR - Control and Status Registers) theo chuẩn RISC-V Privileged Architecture.

5. So sánh chi phí và thời gian triển khai RISC-V so với kiến trúc ARM Cortex-M?

Sử dụng kiến trúc RISC-V mã nguồn mở giúp doanh nghiệp hoàn toàn miễn phí chi phí bản quyền ban đầu (Upfront License Fee) và phí bản quyền trên từng chip xuất xưởng (Royalty Fee) vốn có thể lên tới hàng trăm nghìn USD với ARM. Thời gian phát triển lõi tùy chỉnh trên FPGA chỉ mất từ vài tuần đến vài tháng với các công cụ nguồn mở hiện đại.

Kết luận

Đề tài "Thiết kế bộ vi xử lý 32 bit" đã hiện thực hóa thành công một lõi vi xử lý hoàn chỉnh chuẩn kiến trúc RISC-V RV32I/RV32M kết hợp kiến trúc Harvard và kỹ thuật đường ống 5 tầng trên ngôn ngữ Verilog HDL. Thông qua việc phân tích và mô phỏng chi tiết trên môi trường Xilinx Vivado, hệ thống đã chứng minh được tính đúng đắn về mặt giải thuật, khả năng xử lý xung đột dữ liệu RAW và xung đột điều khiển đạt hiệu suất cao, đưa chỉ số CPI tiệm cận mức tối ưu.

Kết quả của đề tài không chỉ khẳng định năng lực làm chủ công nghệ thiết kế phần cứng của đội ngũ kỹ sư Việt Nam tại HCMUTE mà còn mở ra nền tảng vững chắc cho các nghiên cứu tiếp theo về tích hợp bộ nhớ Cache, vi kiến trúc đa lõi (Multi-core) và các bộ tăng tốc AI chuyên dụng. Bạn đọc, các bạn sinh viên và kỹ sư quan tâm có thể ứng dụng trực tiếp mô hình thiết kế này vào các dự án học tập, nghiên cứu và phát triển sản phẩm vi mạch nhúng thực tiễn.