Giới thiệu dự án

Trong kỷ nguyên phát triển bùng nổ của Internet of Things (IoT), trí tuệ nhân tạo tại biên (Edge AI) và các hệ thống nhúng thông minh, nhu cầu về các bộ xử lý hiệu năng cao, tối ưu năng lượng và có khả năng tùy biến sâu ngày càng trở nên cấp thiết. Sự thống trị lâu năm của các kiến trúc tập lệnh độc quyền (như ARM, x86) tạo ra rào cản lớn về chi phí bản quyền và tính linh hoạt. Ngược lại, kiến trúc tập lệnh mở RISC-V (Reduced Instruction Set Computer V) đã và đang trở thành tiêu chuẩn công nghiệp mới, nhận được sự đầu tư chiến lược từ các tập đoàn hàng đầu thế giới như Google, Western Digital, NVIDIA, SiFive và Microchip.

Tuy nhiên, khi nâng cấp lõi vi xử lý lên kiến trúc 64-bit có hỗ trợ tính toán số thực (Floating-Point Unit - FPU), hệ thống phải đối mặt với các nút thắt cổ chai phần cứng nghiêm trọng:

  • Hiện tượng "Bức tường bộ nhớ" (Memory Wall): Tốc độ xử lý của CPU nhanh hơn tốc độ truy xuất của bộ nhớ chính (DRAM/SRAM ngoài) nhiều bậc độ lớn. Việc nạp lệnh và đọc/ghi dữ liệu liên tục gây nghẽn đường truyền, đẩy CPI (Cycles Per Instruction) tăng vọt.
  • Tổn thất hiệu năng do rẽ nhánh (Control Hazard Penalty): Trong các chương trình có nhiều câu lệnh điều kiện (if-else, vòng lặp for/while), pipeline phải dừng (stall) hoặc hủy lệnh (flush) nhiều chu kỳ nếu không có cơ chế dự đoán rẽ nhánh thông minh.
  • Độ trễ và tài nguyên phần cứng lớn của phép toán số thực: Các phép toán phức tạp như chia số thực (FDIV.S) và căn bậc hai (FSQRT.S) chiếm diện tích silicon lớn và tiêu tốn hàng chục chu kỳ clock nếu sử dụng kiến trúc bộ chia lặp truyền thống.
+-------------------------------------------------------------------------------+
|                            TỔNG THỂ HỆ THỐNG RV64IF                           |
+-------------------------------------------------------------------------------+
|   [ 4-Way Set Associative I-Cache ]            [ Two-Level Adaptive BPU ]     |
|        [ Hazard Detection Unit ]     [ Forwarding Unit ]   [ D-Cache (LRU) ]  |
+-------------------------------------------------------------------------------+

Vấn đề kỹ thuật cốt lõi (Problem Statement)

Đề tài giải quyết bài toán thiết kế một lõi vi xử lý RISC-V 64-bit hoàn chỉnh (hỗ trợ tập lệnh RV64I và RV64F), giải quyết triệt để vấn đề xung đột pipeline, tối ưu hóa tốc độ truy xuất dữ liệu thông qua hệ thống bộ nhớ đệm phân cấp và triệt tiêu chu kỳ chết của lệnh rẽ nhánh bằng bộ dự đoán thích nghi hai lớp, sau đó hiện thực và kiểm định trực tiếp trên phần cứng FPGA.

Mục tiêu dự án

  1. Nghiên cứu và hiện thực hóa tập lệnh RV64IF: Xây dựng khối thực thi số nguyên 64-bit (RV64I) và khối tính toán số thực dấu chấm động 32-bit (RV64F theo chuẩn IEEE 754).
  2. Thiết kế vi kiến trúc Pipeline 5 tầng (5-stage Pipeline): Tối ưu hóa các tầng Fetch (IF), Decode (ID), Execute (EX), Memory (MEM) và Write-Back (WB).
  3. Phát triển hệ thống bộ nhớ đệm L1 Cache 4-Way Set Associative: Tách biệt I-Cache và D-Cache (kiến trúc Harvard) với thuật toán thay thế trang Least Recently Used (LRU) dựa trên mảng đếm phần cứng 2-bit.
  4. Phát triển bộ dự đoán rẽ nhánh thích nghi hai lớp (Two-Level Adaptive BPU): Sử dụng thanh ghi lịch sử rẽ nhánh 4-bit (BHSR) kết hợp bảng đếm bão hòa 2-bit (Saturating Counter Array), tích hợp bộ so sánh rẽ nhánh ngay tại tầng ID để giảm thiểu chu kỳ phạt (penalty cycle).
  5. Tối ưu hóa bộ xử lý FPU: Ứng dụng thuật toán xấp xỉ nghịch đảo nhanh (Fast Inverse Square Root / Quake III method) kết hợp chuỗi lặp Newton-Raphson để thực hiện phép chia và khai căn số thực hiệu năng cao.
  6. Tích hợp giao thức bus AXI4 tiêu chuẩn công nghiệp và kiểm định FPGA: Đóng gói IP core, kết nối với bộ nhớ cục bộ và UART qua bus AXI4, tổng hợp và thực thi trên kit FPGA Xilinx ở tần số hoạt động 100 MHz.

Phạm vi và giới hạn kỹ thuật

  • Tập lệnh hỗ trợ: Đầy đủ các lệnh tính toán số nguyên RV64I cơ sở và lệnh số thực độ chính xác đơn RV64F (32-bit floating point).
  • Giới hạn loại trừ: Không hỗ trợ thanh ghi điều khiển và trạng thái (CSR - Control and Status Register), các lệnh gọi môi trường hệ thống (ECALL, EBREAK), các chế độ làm tròn động trong số thực (áp dụng chế độ làm tròn mặc định Round to Nearest, ties to Even) và chưa tích hợp bảng dịch địa chỉ trang MMU/TLB.

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

Phân tích hiện trạng kiến trúc Cache và BPU

Tiêu chí Direct Mapped Cache Fully Associative Cache 4-Way Set Associative Cache (Đề tài)
Tỷ lệ xung đột (Conflict Miss) Rất cao khi các địa chỉ ánh xạ cùng Index Thấp nhất (không có xung đột set) Rất thấp, cân bằng tối ưu
Độ phức tạp phần cứng Thấp nhất (1 bộ so sánh Tag) Cực cao (so sánh song song mọi dòng) Trung bình (4 bộ so sánh Tag song song)
Thời gian trễ truy xuất (Hit Time) Rất nhanh Chậm do logic so sánh lớn Nhanh, đáp ứng 1 chu kỳ clock
Chi phí diện tích Logic (LUT/FF) Tối thiểu Rất lớn Tối ưu trên FPGA
Chính sách thay thế Không cần LRU phức tạp LRU mảng đếm 2-bit hiệu quả

Về mặt dự đoán rẽ nhánh, phương pháp dự đoán tĩnh (Static Prediction) hoặc dự đoán động 1-bit dễ dàng bị bão hòa sai khi gặp các vòng lặp lồng nhau. Bộ dự đoán thích nghi 2 lớp (Two-Level Adaptive Branch Predictor) sử dụng lịch sử rẽ nhánh toàn cục (Global Branch History) giúp vi xử lý nhận diện chính xác các mẫu rẽ nhánh lặp lại phức tạp.

                    MÁY TRẠNG THÁI BỘ ĐẾM BÃO HÒA 2-BIT
                             Taken (1)

Phân loại yêu cầu hệ thống (Ma trận MoSCoW)

  • Must Have (Bắt buộc): Lõi RV64I + RV64F 5 tầng pipeline; Đơn vị Forwarding Unit và Hazard Detection Unit xử lý Data/Control Hazard; Bộ nhớ đệm 4-Way Set Associative (32 sets, 4 lines/set); Bộ dự đoán BPU 2 lớp; Giao tiếp bus AXI4.
  • Should Have (Nên có): Bộ so sánh rẽ nhánh tại tầng ID để giảm penalty từ 2 chu kỳ xuống 1 chu kỳ; Bộ chia và khai căn số thực dùng thuật toán Newton-Raphson 3 vòng lặp.
  • Could Have (Có thể có): Hỗ trợ tập mở rộng nhân chia phần cứng M (RV64M) hoặc độ chính xác kép RV64D.
  • Won't Have (Chưa thực hiện): MMU (Memory Management Unit) hỗ trợ đánh địa chỉ ảo Sv39/Sv48 cho hệ điều hành Linux đầy đủ.

Thiết kế kiến trúc chi tiết

                        SƠ ĐỒ CẤU TRÚC ĐỊA CHỈ CACHE 32-BIT
 31                                                  5 4          0
+-----------------------------------------------------+------------+
|                     Tag (27 bits)                   | Index (5b) |
+-----------------------------------------------------+------------+
  So sánh đồng thời 4 Way                               32 Sets
  (Tag Way 0, Tag Way 1, Tag Way 2, Tag Way 3)          (Set 0..31)

                 SƠ ĐỒ BỘ DỰ ĐOÁN THÍCH NGHI 2 LỚP (BPU)
              Branch History Shift Register (4 bits)
             +-------+-------+-------+-------+
             | Bit 3 | Bit 2 | Bit 1 | Bit 0 |
             +-------+-------+-------+-------+
             +---------------------------------------+
             | Saturating Counter Array (16 x 2-bit) |
             |   Set 0: [00] Strong Not Taken        |
             |   Set 1: [11] Strong Taken            |
             |   ...                                 |
             |   Set 15:[10] Weak Taken              |
             +---------------------------------------+
                            Prediction

1. Bộ nhớ đệm L1 (Cache Subsystem)

  • Cấu trúc ánh xạ: 4-way Set Associative, gồm 32 set. Mỗi set chứa 4 cache line, mỗi line chứa 64-bit dữ liệu kèm 27-bit Tag và 1-bit Valid.
  • Giải mã địa chỉ (32-bit):
    • Index [4:0]: 5 bit định vị chính xác 1 trong 32 set ($2^5 = 32$).
    • Tag [31:5]: 27 bit nhận dạng khối dữ liệu trong bộ nhớ chính.
  • Thuật toán thay thế LRU: Quản lý bởi mảng bộ đếm $32 \times 4$ với độ rộng 2 bit. Mỗi khi một way trong set được truy xuất, bộ đếm của way đó được gán giá trị cao nhất (3), các bộ đếm khác bị giảm tương ứng. Khi xảy ra Cache Miss và cả 4 way đều chứa dữ liệu hợp lệ, way có giá trị đếm bằng 0 sẽ bị thay thế.

2. Bộ dự đoán rẽ nhánh (BPU Subsystem)

  • Cấu trúc: Sử dụng thanh ghi dịch lịch sử rẽ nhánh BHSR (Branch History Shift Register) 4 bit.
  • Bảng đếm bão hòa (sat_counter_array): Chứa 16 bộ đếm 2 bit (tương ứng $2^4 = 16$ trạng thái lịch sử).
  • Cơ chế chuyển trạng thái:
    • 00 (Strongly Not Taken) $\leftrightarrow$ 01 (Weakly Not Taken) $\leftrightarrow$ 10 (Weakly Taken) $\leftrightarrow$ 11 (Strongly Taken).
    • Bit trọng số cao nhất (MSB) quyết định tín hiệu dự đoán: 1 là nhảy, 0 là không nhảy.
  • Tối ưu hóa đường truyền (Branch Compare tại tầng ID): Thông thường, nhánh rẽ được tính toán ở tầng Execute (EX), khiến lỗi dự đoán làm mất 2 chu kỳ nạp lệnh (flush 2 lệnh ở IF và ID). Đề tài đưa bộ BranchCompare về ngay tầng Decode (ID). Khi BPU tại IF dự đoán sai, CPU phát hiện ngay tại tầng ID và chỉ cần xóa 1 lệnh ở tầng IF (penalty giảm 50%).

3. Bộ tính toán số thực FPU (Floating Point Unit)

  • Định dạng chuẩn IEEE 754 Single Precision: 1 bit Sign ($S$), 8 bit Biased Exponent ($E$, bias = 127), 23 bit Mantissa ($M$).
  • Thuật toán chuyển đổi phép chia $A / B = A \times (1/B)$ và căn bậc hai $\sqrt{A} = A \times (1/\sqrt{A})$:
    • Khởi tạo giá trị xấp xỉ ban đầu bằng phương pháp ma thuật Quake III (Fast Inverse Square Root) dựa trên hàm logarit: $$\log_2(1 + x) \approx x + \mu \quad (\text{với } \mu \approx 0.04504656791)$$
    • Tinh chỉnh nghiệm bằng phương pháp lặp Newton-Raphson:
      • Đối với phép chia $C = 1/B$: $$C_{new} = C(2 - B \cdot C)$$
      • Đối với phép căn bậc hai $C = 1/\sqrt{A}$: $$C_{new} = C\left(1.5 - 0.5 \cdot A \cdot C^2\right)$$
    • Số vòng lặp được cấu hình cố định $N = 3$ vòng, đảm bảo cân bằng hoàn hảo giữa độ chính xác số thực dấu chấm động và số chu kỳ trễ phần cứng.

Technology Stack và Thông số công cụ

  • Ngôn ngữ mô tả phần cứng: Verilog HDL (IEEE 1364-2001 Standard).
  • Môi trường tổng hợp & mô phỏng: AMD Xilinx Vivado Design Suite v2022.2 / ModelSim SE.
  • Giao thức kết nối hệ thống: ARM AMBA AXI4 (Full-duplex, AXI4-Lite cho thanh ghi ngoại vi).
  • Nền tảng phần cứng đích: Xilinx Artix-7 FPGA (XC7A100T) / Xilinx Kintex-7.
  • IP ngoại vi tích hợp: AXI UART Lite, Xilinx Block RAM Memory Generator, MicroBlaze Interconnect.

Implementation và kết quả

Chi tiết thuật toán và mã nguồn Verilog

1. Mô tả logic bộ đếm bão hòa 2-bit trong BPU

Khối sat_counter_array cập nhật trạng thái đếm dựa trên kết quả rẽ nhánh thực tế (actual) từ khối BranchCompare:

module sat_counter_array (
    input  wire        clk,
    input  wire        rst_n,
    input  wire        en,          // Kích hoạt khi có lệnh rẽ nhánh có điều kiện
    input  wire [3:0]  addr,        // Lấy từ thanh ghi BHSR 4-bit
    input  wire        actual,      // Kết quả rẽ nhánh thực tế tại ID (1: Taken, 0: Not Taken)
    output wire        prediction   // Dự đoán cho lần nạp lệnh tiếp theo
);
    reg [1:0] counters [15:0];
    integer i;

    // Dự đoán dựa trên bit MSB của bộ đếm tại địa chỉ lịch sử
    assign prediction = counters[addr][1];

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            for (i = 0; i < 16; i = i + 1)
                counters[i] <= 2'b01; // Mặc định Weakly Not Taken
        end else if (en) begin
            case (counters[addr])
                2'b00: counters[addr] <= (actual) ? 2'b01 : 2'b00;
                2'b01: counters[addr] <= (actual) ? 2'b10 : 2'b00;
                2'b10: counters[addr] <= (actual) ? 2'b11 : 2'b01;
                2'b11: counters[addr] <= (actual) ? 2'b11 : 2'b10;
            endcase
        end
    end
endmodule

2. Logic kiểm tra Hit/Miss và giải mã Way trong 4-Way Cache

Khối CacheMem thực hiện so sánh song song 4 tag trong set được chọn:

module CacheMem (
    input  wire        clk,
    input  wire        rst_n,
    input  wire [4:0]  index,
    input  wire [26:0] tag_bit,
    input  wire [63:0] in_data,
    input  wire        write,
    input  wire [1:0]  way_LRU,     // Way được chỉ định thay thế bởi khối LRU
    output reg  [63:0] block_data,
    output wire [3:0]  hit          // Tín hiệu hit tương ứng cho từng way [3:0]
);
    reg [63:0] data_array [31:0][3:0];
    reg [26:0] tag_array  [31:0][3:0];
    reg        valid_array[31:0][3:0];

    // So sánh Tag song song 4 way trong 1 chu kỳ clock
    assign hit[0] = valid_array[index][0] && (tag_array[index][0] == tag_bit);
    assign hit[1] = valid_array[index][1] && (tag_array[index][1] == tag_bit);
    assign hit[2] = valid_array[index][2] && (tag_array[index][2] == tag_bit);
    assign hit[3] = valid_array[index][3] && (tag_array[index][3] == tag_bit);

    always @(*) begin
        case (1'b1)
            hit[0]: block_data = data_array[index][0];
            hit[1]: block_data = data_array[index][1];
            hit[2]: block_data = data_array[index][2];
            hit[3]: block_data = data_array[index][3];
            default: block_data = 64'h0;
        endcase
    end

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            // Xóa cờ valid của toàn bộ cache
            integer s, w;
            for (s = 0; s < 32; s = s + 1)
                for (w = 0; w < 4; w = w + 1)
                    valid_array[s][w] <= 1'b0;
        end else if (write) begin
            // Ghi dữ liệu vào way được chỉ định bởi LRU
            data_array[index][way_LRU]  <= in_data;
            tag_array[index][way_LRU]   <= tag_bit;
            valid_array[index][way_LRU] <= 1'b1;
        end
    end
endmodule

Kết quả kiểm thử và mô phỏng thực thi (Simulation & Verification)

Hệ thống đã trải qua quy trình kiểm thử toàn diện với tập lệnh mẫu (Assembly Testbench) xác thực đầy đủ các chức năng tính toán số nguyên, nạp/lưu bộ nhớ, rẽ nhánh và tính toán số thực:

Mã lệnh Hex Câu lệnh Hợp ngữ Phân loại Giá trị Thanh ghi / Trạng thái đạt được Đánh giá
0x00100093 addi x1, x0, 1 I-type x1 = 0x0000000000000001 Pass
0x00200113 addi x2, x0, 2 I-type x2 = 0x0000000000000002 Pass
0x00520333 add x6, x4, x5 R-type x6 = 0x000000000000000C (5 + 7 = 12) Pass
0x405183B3 sub x7, x3, x5 R-type x7 = 0xFFFFFFFFFFFFFFFD (4 - 7 = -3) Pass
0x00918423 sb x9, 8(x3) S-type Lưu byte 0x05 vào ô nhớ địa chỉ x3 + 8 Pass
0x00818403 lb x8, 8(x3) I-type x8 = 0x0000000000000005 (Đọc D-Cache Hit) Pass
0x02440063 beq x8, x4, 32 B-type So sánh đúng (x8 == x4 == 5), BPU chuyển nhánh Pass
0x0100056F jal x10, 16 J-type x10 = PC + 4, nhảy không điều kiện Pass
0x40880000 fmv.w f2, x22 R-type Chuyển dữ liệu từ thanh ghi nguyên sang số thực Pass
0x1A2086C3 fmadd.s f13, f1, f2, f3 R-type $f_{13} = (f_1 \times f_2) + f_3 = \text{0x42B2C000}$ Pass
0x2A968747 fmsub.s f14, f13, f9, f5 R-type $f_{14} = (f_{13} \times f_9) - f_5 = \text{0x4388BC00}$ Pass 
                       DẠNG SÓNG KIỂM THỬ PIPELINE (SIMULATION)
Clock Cycle:   1      2      3      4      5      6      7
addi x1,x0,1 [ IF ] [ ID ] [ EX ] [MEM ] [ WB ] (x1=1)
addi x2,x0,2        [ IF ] [ ID ] [ EX ] [MEM ] [ WB ] (x2=2)
add  x6,x4,x5              [ IF ] [ ID ] [ EX ] [MEM ] [ WB ] (x6=12)
                                    (Flush 1 cycle only on miss instead of 2)

Đánh giá hiệu năng và tổng hợp phần cứng trên FPGA

  • Tần số xung nhịp tối đa ($F_{max}$): Đạt 100 MHz ổn định trên kiến trúc FPGA Xilinx sau khi tối ưu định tuyến (Place & Route) và thỏa mãn toàn bộ ràng buộc thời gian (Timing Constraints - Setup/Hold Time Slack > 0).
  • Hiệu suất truy xuất Cache: Thời gian đọc khi Cache Hit chỉ mất 1 chu kỳ clock. Khi Cache Miss, tín hiệu ihit hạ mức thấp, kích hoạt giao thức nạp dòng từ bộ nhớ chính thông qua bus AXI4 và cập nhật dữ liệu vào Cache mất thêm 1 chu kỳ clock.
  • Tổn thất rẽ nhánh (Branch Penalty): Nhờ bố trí khối BranchCompare tại tầng ID, khi xảy ra dự đoán sai, số chu kỳ bị mất giảm từ 2 chu kỳ xuống còn 1 chu kỳ duy nhất, giúp tăng tốc độ thực thi tổng thể các chương trình lặp từ 18% đến 25%.

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

                  SO SÁNH CÁC KIẾN TRÚC VI XỬ LÝ RISC-V
+-------------------------------+-------------------------------+-------------------------------+
|     Single-Cycle RV32I        |   5-Stage Pipeline RV64I      |   Lõi RV64IF Đề Tài           |
+-------------------------------+-------------------------------+-------------------------------+
| - Tần số thấp (<25 MHz)       | - Tần số ~60-70 MHz           | - Tần số: 100 MHz             |
| - Không có Cache              | - Direct-Mapped Cache         | - 4-Way Set Associative Cache |
| - Không có BPU                | - Static Branch Prediction    | - Two-Level Adaptive BPU      |
| - Không hỗ trợ số thực        | - Xung đột rẽ nhánh: 2 chu kỳ | - Xung đột rẽ nhánh: 1 chu kỳ |
| - Không có bus chuẩn hóa      | - Không hỗ trợ số thực        | - Đơn vị FPU IEEE 754 đầy đủ  |
+-------------------------------+-------------------------------+-------------------------------+

Các đóng góp kỹ thuật nổi bật

                              BẢNG SO SÁNH ĐỔI MỚI KỸ THUẬT
+------------------------------------+------------------------------------+------------------------------------+
|            Đặc điểm                |          Giải pháp cũ              |       Cải tiến của đề tài          |
+------------------------------------+------------------------------------+------------------------------------+
|  Vị trí so sánh rẽ nhánh           |  Tầng Execute (EX)                 |  Tầng Instruction Decode (ID)      |
|  Penalty khi dự đoán sai           |  Mất 2 chu kỳ clock (Flush IF, ID) |  Mất 1 chu kỳ clock (Flush IF)     |
|  Thuật toán chia / căn bậc 2       |  Bộ chia mảng lặp (Restoring Div)  |  Quake III Seed + 3x Newton-Raphson|
|  Cơ chế lưu trữ Cache L1           |  Direct Mapped (dễ xung đột)       |  4-Way Set Associative + HW LRU    |
+------------------------------------+------------------------------------+------------------------------------+
  1. Kiến trúc giải quyết rẽ nhánh sớm tại tầng ID: Việc tái cấu trúc đường truyền dữ liệu để đưa bộ giải mã điều kiện rẽ nhánh về tầng Decode giúp giảm 50% thời gian chết của đường ống so với kiến trúc 5 tầng tiêu chuẩn của Patterson & Hennessy.
  2. Triển khai đơn vị FPU xấp xỉ phần cứng tốc độ cao: Thay vì sử dụng bộ chia phần cứng kiểu phục hồi/không phục hồi (Restoring/Non-Restoring Division) tốn từ 32 đến 64 chu kỳ, thiết kế áp dụng thuật toán xấp xỉ hạt nhân Quake III và lặp Newton-Raphson 3 bước bằng mạch nhân song song, giảm độ trễ tính toán phép chia và khai căn số thực xuống mức tối ưu.
  3. Bộ nhớ đệm 4-Way Set Associative với quản lý LRU phần cứng: Cung cấp tỷ lệ trúng bộ nhớ đệm (Hit Rate) vượt trội so với Direct Mapped Cache, triệt tiêu hiện tượng thrashing khi các luồng lệnh liên tục truy xuất các vùng nhớ có cùng chỉ số index.

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

Kịch bản ứng dụng trong công nghiệp (Use Cases)

  • Thiết bị xử lý tín hiệu số tại biên (Edge DSP & Sensor Fusion): Lõi RV64IF có khả năng xử lý mượt mà các thuật toán lọc số (Kalman Filter, FFT), xử lý cảm biến quán tính (IMU) và các bài toán điều khiển tự động đòi hỏi tính toán số thực 32-bit với độ trễ thấp.
  • Bộ điều khiển trung tâm trong hệ thống IoT thông minh: Khả năng giao tiếp chuẩn bus AXI4 cho phép vi xử lý dễ dàng tích hợp vào các hệ thống SoC (System-on-Chip) phức tạp, kết nối với các bộ điều khiển DMA, Ethernet, SPI, I2C và bộ nhớ ngoài DDR3/DDR4.
                           SƠ ĐỒ HỆ THỐNG SOC TRÊN FPGA
+-------------------------------------------------------------------------------+
|                              XILINX FPGA FABRIC                               |
|                                                                               |
|  +------------------------+                    +---------------------------+  |
|  |   LÕI XỬ LÝ RV64IF     |                    |   AXI BRAM Controller     |  |
|  |  - 5-Stage Core        |    AXI4 Interconnect    - Dual-port Block RAM  |  |
|  |  - Two-Level BPU       |     (100 MHz Bus)  +---------------------------+  |
|  +------------------------+                    |       AXI UART Lite       |  |
|  |  MicroBlaze Debug Port |                    |   (Giao tiếp PC qua RS232)|  |
|  +------------------------+                    +---------------------------+  |
+-------------------------------------------------------------------------------+

Quy trình triển khai phần cứng trên FPGA

  1. Thiết kế Block Design trên Vivado: Đóng gói lõi Verilog RV64IF thành một IP Block tùy biến (Custom IP Core).
  2. Tích hợp AXI Interconnect: Nối bus Master AXI4 của lõi vi xử lý với các IP Slave: AXI UART Lite (giao tiếp máy tính với tốc độ Baud 115200) và AXI BRAM Controller (quản lý Local Memory).
  3. Ràng buộc chân và thời gian (XDC Constraints): Gán chân xung clock vi sai 100 MHz, chân Reset và các chân I/O giao tiếp UART.
  4. Tổng hợp, Thực thi và Nạp Bitstream: Biên dịch thiết kế, kiểm tra báo cáo Timing, sinh file bitstream (.bit) và nạp trực tiếp lên kit FPGA.
  5. Kiểm tra tương thích với KitsuneOS: Chạy thử nghiệm các tập lệnh kiểm tra thông qua cổng console nối tiếp.

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

Các hạn chế kỹ thuật hiện tại

  • Chưa hỗ trợ tập lệnh RV64D: Chưa có đơn vị tính toán số thực độ chính xác kép (64-bit Floating-Point).
  • Chế độ làm tròn FPU cố định: Chưa hỗ trợ đầy đủ 5 chế độ làm tròn động theo chuẩn IEEE 754 (RNE, RTZ, RDN, RUP, RMM) thông qua trường rm trong lệnh.
  • Chưa hỗ trợ hệ thống ngắt và đặc quyền (Privilege Architecture): Thiếu tập thanh ghi CSR để xử lý ngắt phần cứng (Interrupts), bẫy lỗi (Traps) và ngoại lệ (Exceptions).
  • Chưa có MMU (Memory Management Unit): Chưa hỗ trợ phân trang bộ nhớ ảo, hạn chế khả năng chạy các hệ điều hành đầy đủ như Linux/Debian RISC-V.

Lộ trình nâng cấp và mở rộng (Future Roadmap)

                            LỘ TRÌNH PHÁT TRIỂN HỆ THỐNG
|         GIAI ĐOẠN 1       |         GIAI ĐOẠN 2       |         GIAI ĐOẠN 3       |
|      (Hiện tại - Hoàn tất)|     (Ngắn hạn 6-12 tháng) |     (Dài hạn 1-2 năm)     |
| - Lõi RV64IF 5-stage      | - Bổ sung CSR & Trap/Int  | - Nâng cấp OoO Execution  |
| - Cache 4-Way + BPU 2 lớp | - Hỗ trợ FPU 64-bit RV64D | - Thiết kế MMU (Sv39/48)  |
| - AXI4 Bus @ 100MHz FPGA  | - Bộ làm tròn IEEE 754    | - Boot hệ điều hành Linux |

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

|                          ĐỐI TƯỢNG HƯỞNG LỢI DỰ ÁN                            |
|                              kiến trúc máy tính nâng cao (Pipeline/Cache/FPU) |
|                                                                               |
|                              AXI4, dễ dàng tích hợp và mở rộng trên FPGA      |
|                                                                               |
|                              bản quyền kiến trúc, tùy biến theo ứng dụng riêng |
|                                                                               |
|                              Cache và vi kiến trúc tăng tốc phần cứng mới     |
  • Sinh viên và Giảng viên ngành Kỹ thuật Máy tính / Điện tử: Cung cấp tài liệu tham khảo thực tế về thiết kế vi kiến trúc pipeline 64-bit, cách xử lý xung đột dữ liệu, xung đột điều khiển và hiện thực hóa bộ nhớ đệm trên phần cứng thực.
  • Kỹ sư thiết kế vi mạch (ASIC/FPGA Designers): Sở hữu một lõi IP hoàn chỉnh, chuẩn hóa giao tiếp AXI4, có thể tái sử dụng ngay trong các dự án SoC tùy biến mà không mất chi phí bản quyền IP.
  • Doanh nghiệp phát triển thiết bị nhúng thông minh: Sở hữu giải pháp tự chủ công nghệ vi xử lý 64-bit hiệu năng cao, giảm giá thành sản xuất phần cứng và dễ dàng bổ sung các module tăng tốc phần cứng chuyên dụng.

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

1. Yêu cầu phần cứng và công cụ để tổng hợp và nạp thiết kế lên FPGA là gì?

Hệ thống yêu cầu máy tính cài đặt phần mềm AMD Xilinx Vivado Design Suite (phiên bản 2019.1 trở lên, khuyến nghị 2022.2). Thiết kế tương thích với các dòng FPGA Xilinx Artix-7 (tối thiểu XC7A35T, khuyến nghị XC7A100T như kit Digilent Nexys 4 / Nexys A7), Kintex-7 hoặc Zynq-7000. Cần trang bị cáp nạp JTAG và cổng giao tiếp UART-to-USB để truyền nhận dữ liệu với máy tính.

2. Bộ nhớ đệm 4-way Set Associative trong thiết kế xử lý Cache Miss như thế nào?

Khi địa chỉ truy xuất không khớp với bất kỳ Tag nào trong 4 way của set tương ứng (tín hiệu hit = 4'b0000), khối điều khiển Cache sẽ sinh tín hiệu tạm dừng vi xử lý (Stall), tạo transaction đọc dữ liệu trên bus AXI4 để nạp khối dữ liệu 64-bit từ bộ nhớ chính. Khối LRU sẽ xác định way có thời gian truy cập lâu nhất để ghi đè dữ liệu mới, cập nhật lại Tag và bật cờ Valid, toàn bộ quá trình mất thêm 1 chu kỳ clock trước khi CPU tiếp tục thực thi.

3. Tại sao việc đặt bộ so sánh rẽ nhánh tại tầng ID lại tối ưu hơn tầng EX?

Thông thường trong pipeline 5 tầng, kết quả so sánh rẽ nhánh được tính toán tại tầng Execute (EX). Nếu dự đoán sai, hai lệnh đã được nạp ở tầng Fetch (IF) và Decode (ID) đều bị hủy (tốn 2 chu kỳ penalty). Bằng cách so sánh dữ liệu ngay tại tầng ID (kết hợp mạch Forwarding để lấy sớm giá trị thanh ghi), nếu phát hiện sai lệch so với dự đoán của BPU, hệ thống chỉ cần xóa duy nhất 1 lệnh đang nạp tại tầng IF, tiết kiệm được 1 chu kỳ clock cho mỗi lần rẽ nhánh sai.

4. Thuật toán Newton-Raphson 3 vòng lặp cho FPU có đảm bảo độ chính xác không?

Thuật toán lấy giá trị khởi tạo ma thuật theo phương pháp Quake III đưa sai số ban đầu về dưới vài phần trăm. Khi áp dụng 3 vòng lặp Newton-Raphson liên tiếp, sai số giảm theo cấp số nhân (hàm bậc hai). Kết quả tính toán trên định dạng số thực 32-bit Single Precision (23 bit định trị) hoàn toàn tương thích và đạt độ chính xác tương đương với các phép tính số thực tiêu chuẩn trong các bài toán đo đạc cảm biến và điều khiển nhúng.

5. Lõi vi xử lý này có khả năng chạy hệ điều hành nhúng không?

Lõi RV64IF hiện tại hoàn toàn có thể thực thi các phần mềm Bare-metal phức tạp và các hệ điều hành thời gian thực (RTOS) như FreeRTOS (khi cấu hình chạy ở chế độ Machine Mode đơn giản). Để chạy các hệ điều hành phân chia bộ nhớ phức tạp như Linux, thiết kế cần được phát triển thêm khối quản lý bộ nhớ MMU hỗ trợ chuẩn Sv39/Sv48 và bổ sung các thanh ghi CSR đặc quyền (Privilege Modes: M, S, U).

Kết luận

Khóa luận tốt nghiệp "Thiết kế và hiện thực lõi vi xử lý RISC-V RV64IF hỗ trợ 4-Way Set Associative Cache và Branch Prediction trên FPGA" của nhóm tác giả Cao Tài và Lê Hoài Ân (Khoa Kỹ thuật Máy tính, Trường Đại học Công nghệ Thông tin - ĐHQG-HCM) đã giải quyết trọn vẹn và chuyên sâu bài toán thiết kế vi kiến trúc vi xử lý 64-bit hiệu năng cao.

Thành tựu cốt lõi của đề tài

  • Hiện thực thành công vi kiến trúc RV64IF Pipeline 5 tầng bằng ngôn ngữ Verilog HDL, hỗ trợ tập lệnh số nguyên 64-bit và số thực 32-bit IEEE 754.
  • Tối ưu hóa hệ thống nhớ với L1 Cache 4-Way Set Associative tích hợp thuật toán thay thế LRU phần cứng mảng đếm 2-bit, đạt tốc độ truy xuất đọc 1 chu kỳ clock.
  • Tích hợp bộ dự đoán rẽ nhánh 2 lớp (Two-Level Adaptive BPU) với bộ đếm bão hòa 2-bit và cơ chế so sánh rẽ nhánh sớm tại tầng ID, giảm 50% tổn thất chu kỳ rẽ nhánh.
  • Tăng tốc tính toán số thực FPU bằng giải thuật kết hợp Quake III và Newton-Raphson 3 chu kỳ lặp.
  • Đóng gói chuẩn bus công nghiệp AXI4, tổng hợp và thực thi thành công trên phần cứng FPGA Xilinx ở tần số hoạt động 100 MHz.

Đề tài là minh chứng rõ nét cho năng lực nghiên cứu, làm chủ công nghệ thiết kế vi mạch và hệ thống nhúng tiên tiến, mở ra nền tảng vững chắc cho các nghiên cứu phát triển SoC kiến trúc mở tại Việt Nam. Quý độc giả, kỹ sư và nhà nghiên cứu quan tâm có thể khai thác mô hình kiến trúc này làm nền tảng phát triển các bộ tăng tốc tính toán AI chuyên dụng và các vi điều khiển IoT thế hệ mới.