Giới thiệu dự án

Bối cảnh và thực trạng ngành

Công nghệ chuỗi khối (Blockchain) đã khẳng định vị thế là nền tảng cốt lõi cho các hệ thống phi tập trung, bảo mật và minh bạch. Trong đó, mạng lưới Ethereum (ETH) giữ vị trí nền tảng hợp đồng thông minh (Smart Contract) và ứng dụng phi tập trung (dApp) lớn nhất toàn cầu, chiếm hơn 17% tổng quy mô vốn hóa thị trường tiền mã hóa (xấp xỉ 1,2 nghìn tỷ USD tại thời điểm nghiên cứu).

Trong cơ chế đồng thuận Proof-of-Work (PoW) ban đầu của Ethereum, quá trình tạo block (Ethereum Mining) đóng vai trò quyết định đến tính toàn vẹn và an ninh mạng. Để thêm một khối mới vào chuỗi, các nút thợ đào (Miners) phải giải quyết thuật toán băm phức tạp mang tên Ethash nhằm tìm ra giá trị số tùy biến (Nonce 64-bit) thỏa mãn điều kiện độ khó (Difficulty) do giao thức quy định.

                    2^256
                  Difficulty

Vấn đề kỹ thuật và điểm nghẽn (Pain Points)

  1. Tiêu thụ điện năng khổng lồ trên GPU/CPU: Hoạt động khai thác trên GPU phổ thông (như NVIDIA GTX 1060, RTX 2080 hay AMD RX 580) tiêu tốn công suất từ 77W đến 155W cho mỗi thiết bị, dẫn đến hiệu suất năng lượng (Energy Efficiency) rất thấp (chỉ dao động từ 0.15 đến 0.54 MH/W).
  2. Độ trễ và tắc nghẽn tính toán của Ethash: Ethash tích hợp thuật toán băm Keccak (Keccak512, Keccak256) và vòng lặp Main Loop 64 chu kỳ kết hợp truy xuất mảng dữ liệu Directed Acyclic Graph (DAG) dung lượng lớn (>4GB) cùng phép biến đổi Fowler–Noll–Vo (FNV) và Modulo 32-bit.
  3. Đường truyền trễ (Critical Path) lớn trong kiến trúc phần cứng truyền thống: Các thiết kế phần cứng Keccak dạng lặp tuần tự (Iterative) trên FPGA đạt tần số giới hạn (~300 MHz), làm giảm đáng kể thông lượng (Throughput) xử lý khối.
               r × Fmax × Nmsg
                  Latency

               Throughput                Hashrate
                  Area                    Power

Mục tiêu dự án

  1. Mục tiêu 1: Nghiên cứu, mô hình hóa và kiểm chứng toàn diện thuật toán Ethash trên phần mềm bằng Python 3.8 và Go-Ethereum (Geth v1.10.15) với dữ liệu thực tế từ mạng Ethereum Mainnet.
  2. Mục tiêu 2: Thiết kế vi kiến trúc xử lý phần cứng tối ưu cho hàm băm Keccak256 theo cấu trúc đường ống 2 tầng (2-Stage Pipeline) trên FPGA Xilinx Virtex-7 VC707, đạt tần số cực đại $F_{max} > 800\text{ MHz}$ và thông lượng $>36\text{ Gbps}$.
  3. Mục tiêu 3: Hiện thực hóa hoàn chỉnh lõi phần cứng hệ thống Ethash Core (bao gồm Keccak512_2stage, Main Loop 5-stage pipeline, bộ chia Modulo 3 tầng, hàm FNV song song và Keccak256_2stage) với khả năng xử lý xen kẽ 2 luồng dữ liệu song song nhằm tối ưu hóa Hashrate và tỷ lệ Efficiency/Area.
             Frequency
              Cycles

Phương pháp tiếp cận và phạm vi nghiên cứu

  • Phương pháp tiếp cận: Phương pháp đồng thiết kế phần cứng/phần mềm (Hardware/Software Co-design). Kiểm chứng tính đúng đắn trên phần mềm trước khi phân rã vi kiến trúc và tổng hợp RTL bằng Verilog HDL.
  • Phạm vi & Giới hạn: Do bộ nhớ BRAM nội bộ của FPGA Virtex-7 VC707 không đủ chứa toàn bộ tập tin DAG >4GB của Mainnet, nghiên cứu giới hạn tập tin thực nghiệm xuống DAG_64.txt (64 dòng $\times$ 512-bit) phục vụ việc kiểm tra chu trình truy xuất và đánh giá hiệu năng logic tính toán của bộ sinh block.

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

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

Hiện nay, giải pháp khai thác và tính toán Ethash chủ yếu thực thi trên GPU thương mại hoặc một số thiết kế FPGA đơn lẻ:

Giải pháp Nền tảng Tần số / Core Hashrate Công suất tiêu thụ Hiệu suất năng lượng (Efficiency) Nhược điểm chính
GPU Mining (AMD RX 580) GPU 2304 Stream Processors 1340 MHz ~30.0 MH/s ~130W 0.23 MH/W Tiêu tốn điện năng, tỏa nhiệt cao, chi phí vận hành lớn
GPU Mining (NVIDIA P4000) GPU 1792 CUDA Cores 1202 MHz ~17.0 MH/s ~77W 0.22 MH/W Chi phí đầu tư phần cứng cao, không tối ưu cho ASIC/SoC
Iterative FPGA Keccak [2] Xilinx Virtex-5 301.0 MHz - - 14.2 Mbps/Slice Critical path dài, tần số thấp, tài nguyên chiếm dụng lớn
Pipeline Keccak [4] Xilinx Virtex-7 832.8 MHz - - 22.1 Mbps/Slice Thiết kế sửa đổi block phức tạp, tốn thêm logic gate
Hệ thống đề xuất (Nhóm) Xilinx Virtex-7 VC707 816.3 MHz 414.7 KH/s 3.2W (Est.) Ưu việt về Area & Pipelining Tối ưu triệt để critical path, xử lý kép 2-stream

Yêu cầu hệ thống theo phân loại MoSCoW

  • Must have: Lõi tính toán Keccak512, Keccak256 chuẩn SPONGE ($b=1600$, 24 vòng lặp KeccakRound), khối Main Loop thực hiện 64 chu kỳ FNV và Modulo 32-bit chính xác $100%$ so với Golden Output từ Ethereum.
  • Should have: Kiến trúc Pipeline 2 tầng cho Keccak nhằm đẩy tần số lên trên 800 MHz; xử lý 2 giá trị liên tiếp (Seed1, Seed2) song song.
  • Could have: Bộ giải thuật Modulo tối ưu không dùng khối chia DSP cồng kềnh, chuyển dịch bit logic rút gọn.
  • Won't have (in this phase): Giao tiếp bộ nhớ ngoài DDR3/DDR4 dung lượng lớn cho toàn bộ DAG file 4GB.

Thiết kế hệ thống

flowchart TB
    subgraph Ethash_Hardware_System["Kiến trúc Tổng quan Hệ thống Phần cứng Ethash (2-Stream Parallel)"]
        InSignals["Input Data: {Header (256b), Nonce (64b)} = 320b"] --> K512["Khối Keccak512_2stage<br/>(Padding -> Mapping -> 24 Rounds Pipeline -> Truncating)"]
        K512 --> Seed["Seed Output (512b)"]
        
        Seed --> RegSeed["Thanh ghi lưu trữ<br/>REG_Seed1 & REG_Seed2"]
        Seed --> MainLoop["Khối Main Loop (5-Stage Pipeline, 64 Vòng Lặp)<br/>- FNV Hash Function<br/>- Modulo 3-Stage Divider<br/>- DAG Fetch Interface (DAG_64)"]
        
        MainLoop --> Cmix["Cmix Output (256b)"]
        
        RegSeed --> JoinData["Ghép nối dữ liệu:<br/>{Seed (512b), Cmix (256b)} = 768b"]
        Cmix --> JoinData
        
        JoinData --> K256["Khối Keccak256_2stage<br/>(Pipeline 2 Tầng: Theta -> REG1 -> Rho/Pi/Chi/Iota)"]
        K256 --> OutHash["Output: ethash_value (256-bit)"]
    end

Ngăn xếp công nghệ và công cụ phát triển

  • Ngôn ngữ mô tả phần cứng: Verilog HDL (IEEE 1364-2005).
  • Môi trường mô phỏng và tổng hợp: Xilinx Vivado Design Suite 2020.2 / ISE Design Suite 14.7.
  • Nền tảng phần cứng đích: FPGA Kit Xilinx Virtex-7 XC7VX485T-2FFG1761C (VC707 Evaluation Board).
  • Phần mềm kiểm chứng & xử lý dữ liệu: Python 3.8.10, Go-Ethereum (Geth v1.10.15), RLP Serializer.

Giao tiếp tín hiệu phần cứng (Hardware Interface Signals)

module ethash_top (
    input  wire        clk,          // Xung nhịp hệ thống (Target: >150MHz cho Top, >800MHz cho Keccak)
    input  wire        rst_n,        // Tín hiệu reset tích cực mức thấp (Asynchronous Active Low)
    input  wire        start,        // Tín hiệu kích hoạt chu trình tính toán Ethash
    input  wire [255:0] header_in,   // Hash tiêu đề khối Block Header (256-bit)
    input  wire [63:0]  nonce_in,    // Giá trị Nonce thử nghiệm (64-bit)
    input  wire [31:0]  full_size,   // Kích thước thực của DAG theo epoch (Bytes)
    output reg  [255:0] ethash_out,  // Giá trị băm đầu ra (256-bit ethash_value)
    output reg         ready_out     // Báo cờ hoàn thành tính toán khối
);

Phương pháp nghiên cứu và quy trình phát triển (Methodology)

Quy trình phát triển được thực hiện tuần tự qua 4 giai đoạn chuẩn mực kỹ thuật máy tính:

  1. Trích xuất & tiền xử lý dữ liệu gốc: Sử dụng module Golang main.go liên kết thư viện Go-Ethereum để gọi hàm SealHash() và HeaderByNumber() từ node mạng Ethereum thật. Chuyển đổi Block Header và DAG sang định dạng Little-Endian 32-bit và đóng gói hex 512-bit/dòng.
  2. Xây dựng bộ kiểm chứng phần mềm (Software Golden Model): Cài đặt script Ethash.py mô phỏng chính xác logic của Keccak512, Keccak256, FNV và hashimoto(). Xuất kết quả ra file expected_out.txt và Check_software.xlsx.
  3. Mô hình hóa RTL và tối ưu đường ống: Thiết kế mạch nguyên lý Verilog, phân chia các tầng thanh ghi tối ưu hóa trễ truyền lan (Propagation Delay), loại bỏ xung đột hazard khi xử lý luồng kép.
  4. Kiểm tra mô phỏng & Đánh giá tài nguyên: Viết Testbench mô phỏng kiểm thử dạng sóng trên Vivado Simulator / ModelSim, đối chiếu bit-accurate giữa kết quả phần cứng và expected_out.txt.

Implementation và kết quả

Quá trình phát triển và chi tiết thuật toán

1. Cải tiến kiến trúc đường ống 2 tầng Keccak256 (Keccak256_2stage)

Mỗi chu trình biến đổi KeccakRound bao gồm 5 hàm chuyển đổi trạng thái: $\theta$ (Theta), $\rho$ (Rho), $\pi$ (Pi), $\chi$ (Chi), và $\iota$ (Iota). Trong kiến trúc đề xuất, hệ thống ngắt chuỗi tính toán làm 2 tầng bằng việc chèn thanh ghi REG1 vào giữa hàm Theta và Rho:

// Thuật toán băm KeccakRound cải tiến chèn thanh ghi REG1 giữa Theta và Rho
module keccak_round_2stage (
    input  wire        clk,
    input  wire        rst_n,
    input  wire [1599:0] state_in,
    input  wire [7:0]    rc_compressed, // Hằng số Round Constant 8-bit rút gọn
    output wire [1599:0] state_out
);
    wire [1599:0] theta_out;
    reg  [1599:0] reg_stage1;
    wire [1599:0] rho_out, pi_out, chi_out, iota_out;

    // Stage 1: Phép biến đổi Theta
    theta_block u_theta (.in(state_in), .out(theta_out));

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            reg_stage1 <= 1600'h0; // Tối ưu reset trực tiếp, loại bỏ cổng logic thừa
        else
            reg_stage1 <= theta_out;
    end

    // Stage 2: Phép biến đổi Rho, Pi, Chi, Iota
    rho_block   u_rho   (.in(reg_stage1), .out(rho_out));
    pi_block    u_pi    (.in(rho_out),    .out(pi_out));
    chi_block   u_chi   (.in(pi_out),     .out(chi_out));
    iota_block  u_iota  (.in(chi_out), .rc(rc_compressed), .out(iota_out));

    assign state_out = iota_out;
endmodule

Điểm đột phá thiết kế: Trong bài báo tham chiếu [4], tác giả phải chèn thêm các cổng MUX và logic biến đổi đầu vào cho block đầu tiên để xử lý bước Mapping với giá trị ngõ ra hàm Iota. Nhóm nghiên cứu đề xuất giải pháp Reset thanh ghi REG1 về giá trị mặc định được định thời chuẩn xác, giúp loại bỏ hoàn toàn các cổng logic thừa trên đường dữ liệu, vừa giảm diện tích chiếm dụng vừa triệt tiêu nguy cơ suy giảm tần số hoạt động.

2. Hiện thực phép biến đổi FNV (Fowler–Noll–Vo) và Modulo 3-Stage trong Main Loop

Trong 64 vòng lặp của Main Loop, thuật toán tính toán liên tục cập nhật giá trị Index để trích xuất phần tử DAG:

Index = FNV(i ^ Seed[0], Mix[i mod w]) mod (n / mix_hashes) * mix_hashes

Thuật toán FNV được hiện thực hóa phần cứng bằng phép nhân với hằng số nguyên tố FNV_PRIME = 32'h01000193:

// Thiết kế hàm FNV 32-bit tối ưu cho phần cứng
module fnv_32bit (
    input  wire [31:0] in1,
    input  wire [31:0] in2,
    output wire [31:0] fnv_out
);
    wire [63:0] product;
    // FNV_PRIME = 0x01000193 = 16777619
    assign product = in1 * 32'h01000193;
    assign fnv_out = (product[31:0] ^ in2);
endmodule

Khối mod_3stage được thiết kế dựa trên thuật toán trừ dịch vòng (Non-restoring Division / Bit-shift sub) chia làm 3 tầng đường ống để tính X mod Z với $X, Z$ là số nguyên không dấu 32-bit mà không gây nghẽn trễ chu kỳ.

// Thuật toán tính phần dư không dấu 32-bit theo kiến trúc 3 tầng
module mod_3stage (
    input  wire        clk,
    input  wire [31:0] dividend_X, // Số bị chia
    input  wire [31:0] divisor_Z,  // Số chia
    output reg  [31:0] remainder_out
);
    // Chia 31 bước dịch bit thành 3 giai đoạn xử lý (Stages)
    // Stage 1: Tính toán thương số phụ q30 -> q20
    // Stage 2: Tính toán thương số phụ q19 -> q10
    // Stage 3: Tính toán q9 -> q0 và suy ra số dư cuối cùng:
    // Out = X - (Z * Q)
    // ... Triển khai mạch logic pipeline đồng bộ ...
endmodule

Kiểm tra, mô phỏng và thẩm định kết quả (Testing & Validation)

       +------------------------------------+
       |  Dữ liệu thực từ Ethereum Network  |
       +-----------------+------------------+
                         |
                         v
       +------------------------------------+
       |  Go-Ethereum (Geth) & main.go      |
       +-----------------+------------------+
                         |
         +---------------+---------------+
         | (Text Files: Header, Nonce)   |
         v                               v
+-------------------+           +--------------------+
| Software Model    |           | Hardware RTL       |
| (Ethash.py)       |           | (Xilinx Vivado)    |
+---------+---------+           +---------+----------+
          |                               |
          v (expected_out.txt)            v (hardware_results.txt)
+----------------------------------------------------+
| So sánh tự động trên TCL Console / Excel:          |
| Match Rate = 100% (Khớp chính xác từng bit)       |
+----------------------------------------------------+
  • Độ chính xác logic: $100%$ các mẫu thử từ Block Mainnet thực tế (khảo sát các block chứa giao dịch thật) đều cho ra kết quả băm ethash_value trên bộ mô phỏng phần cứng trùng khớp hoàn toàn với expected_out.txt do phần mềm sinh ra.
  • Dạng sóng mô phỏng: Ghi nhận thời điểm nhận tín hiệu start, bộ đường ống xử lý trơn tru 2 giá trị liên tiếp mà không phát sinh bọt khí đường ống (Pipeline Stall), cờ ready_out kích hoạt chính xác theo đúng chu kỳ thiết kế.

Kết quả đo đạc tài nguyên và hiệu năng phần cứng

1. Đánh giá khối Keccak256_2stage trên FPGA Xilinx Virtex-7 (VC707)

Công trình nghiên cứu Kiến trúc Nền tảng FPGA Tần số tối đa ($F_{max}$) Số lát chiếm dụng (Slices) Thông lượng (Throughput) Hiệu suất diện tích (Efficiency)
Nghiên cứu [2] Iterative Virtex-5 301.0 MHz 1,142 Slices 13.6 Gbps 11.9 Mbps/Slice
Nghiên cứu [3] Tối ưu Control Virtex-5 309.6 MHz 1,028 Slices 14.0 Gbps 13.6 Mbps/Slice
Nghiên cứu [4] Pipeline 2-Stage Virtex-7 832.8 MHz 1,673 Slices 36.9 Gbps 22.1 Mbps/Slice
Nghiên cứu [5] Pipeline 2-Stage Arria 10 498.6 MHz 2,150 ALMs 22.1 Gbps 10.3 Mbps/ALM
Thiết kế của Nhóm Pipeline 2-Stage Đề xuất Virtex-7 VC707 816.3 MHz 1,245 Slices 36.2 Gbps 29.1 Mbps/Slice

Nhận xét: Thiết kế Keccak256_2stage của nhóm đạt hiệu suất diện tích (Efficiency) 29.1 Mbps/Slice, vượt trội hơn 31.6% so với công trình của tác giả trong [4] (22.1 Mbps/Slice) nhờ giải pháp tối ưu hóa thanh ghi REG1 và rút gọn bảng hằng số RC[i] từ 64-bit xuống còn 8-bit.

2. Kết quả tổng hợp toàn bộ hệ thống Ethash Core trên FPGA

Thông số thiết kế phần cứng Giá trị đạt được trên FPGA Virtex-7 VC707
Tần số hoạt động cực đại ($F_{max}$) 162.5 MHz (Toàn hệ sinh thái Ethash Top)
Tổng số chu kỳ tính toán (Cycles/Block) 392 chu kỳ (Xử lý đồng thời 2 giá trị)
Tốc độ băm khai thác (Hashrate) 414.7 KH/s
Tài nguyên Logic LUTs 18,420 / 303,600 (6.06%)
Tài nguyên thanh ghi Flip-Flops (FFs) 12,850 / 607,200 (2.11%)
Số lát cấu hình chiếm dụng (Slices) 5,432 Slices
Bộ nhớ khối BRAM (DAG Cache 64-line) 8 Block RAMs

Đổi mới và đóng góp kỹ thuật

  1. Kỹ thuật ngắt đường ống Theta–Rho và Reset đặc biệt cho REG1: Khắc phục triệt để lỗi xung đột khối băm đầu tiên trong cấu trúc SPONGE mà không tốn cổng logic ghép kênh (Multiplexer), giảm thiểu $25.5%$ lượng slice logic so với giải pháp [4].
  2. Kỹ thuật nén hằng số Round Constant ($RC$): Rút gọn biểu diễn 24 hằng số $RC$ 64-bit của chuẩn Keccak thành các tổ hợp 8-bit trích xuất trực tiếp tại các chỉ mục bit $[63, 31, 15, 7, 3:0]$, tiết kiệm $87.5%$ dung lượng ROM hằng số.
  3. Cơ chế xử lý 2 luồng liên tiếp (Dual-Stream Interleaving): Tận dụng độ trễ của các tầng đường ống trong Keccak512 và Keccak256 để nạp luồng tính toán thứ 2 (Seed2) ngay khi luồng thứ 1 (Seed1) đi vào Main Loop, tăng gần gấp đôi hiệu suất thông lượng tổng thể so với thiết kế tuần tự.
  4. Kiến trúc mạch Modulo 3 tầng không dùng bộ chia nguyên khối: Giải quyết bài toán chia lấy dư 32-bit trong $3$ chu kỳ xung nhịp ngắn, loại bỏ điểm nghẽn chu kỳ dài nhất trong vòng lặp 64 bước của Ethash.

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

Các tình huống ứng dụng thực tế

  • Bộ đồng xử lý mật mã (Hardware Crypto-Coprocessor): Tích hợp vào các hệ thống nhúng SoC/ASIC phục vụ việc xác thực giao dịch, kiểm tra tính hợp lệ của khối trong các thiết bị Node mạng Blockchain biên (Edge Blockchain Nodes).
  • Hệ thống phần cứng xác thực tốc độ cao: Ứng dụng trong các cổng thanh toán phân tán và thiết bị kiểm soát bảo mật mạng sử dụng thuật toán băm họ Keccak/SHA-3.

Chiến lược triển khai và yêu cầu phần cứng

  • Yêu cầu phần cứng tối thiểu: Bo mạch phát triển FPGA Xilinx Virtex-7 (VC707), Kintex-7 (KC705) hoặc Zynq-7000 SoC; nguồn cấp 12V/5A ổn định.
  • Yêu cầu phần mềm máy chủ điều khiển: Hệ điều hành Linux (Ubuntu 20.04 LTS), cài đặt Geth v1.10+, driver kết nối PCIe/UART để nạp Header/Nonce và đọc kết quả ethash_value.
                  +-----------------------------------+
                  |   Host PC / Controller (Linux)    |
                  |   - Geth Daemon (Ethereum Node)   |
                  |   - Python Control / C++ Driver   |
                  +-----------------+-----------------+
                                    | (PCIe Gen2 / AXI-Bus)
                                    v
                  +-----------------------------------+
                  |  FPGA Board (Xilinx Virtex-7)     |
                  |  +-----------------------------+  |
                  |  | Ethash Top Hardware Engine  |  |
                  |  | - Keccak512 / Keccak256     |  |
                  |  | - 5-Stage Pipelined Loop    |  |
                  |  +-----------------------------+  |
                  +-----------------------------------+

Phân tích chi phí và hiệu quả đầu tư (Cost-Benefit & Scalability)

  • Tiết kiệm năng lượng: Triển khai thiết kế trên vi mạch chuyên dụng ASIC (hoặc FPGA đóng gói) tiêu thụ công suất dưới $5\text{W}$, thấp hơn từ $15$ đến $30$ lần so với dàn card đồ họa GPU rời ($130\text{W}-250\text{W}$).
  • Khả năng mở rộng: Cấu trúc lõi Ethash độc lập cho phép nhân bản thành các mảng tính toán song song đa nhân (Multi-core IP) trên cùng một phiến silicon để nâng Hashrate lên mức hàng trăm MH/s mà vẫn giữ mức tiêu thụ điện năng tối ưu.

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

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

  1. Dung lượng bộ nhớ DAG: Do tài nguyên BRAM nội của chip FPGA Virtex-7 VC707 bị giới hạn, thiết kế mới chỉ tích hợp tập tin rút gọn DAG_64.txt. Hệ thống chưa giao tiếp trực tiếp với bộ nhớ ngoài DDR3/DDR4 để chứa trọn vẹn tệp DAG đầy đủ (>4GB).
  2. Băng thông bộ nhớ ngoài: Khi mở rộng ra toàn bộ DAG, băng thông truy xuất bộ nhớ ngẫu nhiên (Random Memory Access Bottleneck) sẽ là yếu tố giới hạn Hashrate thực tế.

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

  • Tích hợp bộ điều khiển bộ nhớ DDR4 / HBM: Thiết kế giao tiếp ngoại vi AXI-DDR4 Controller tốc độ cao trên các dòng FPGA cao cấp như Xilinx UltraScale+ hoặc Versal ACAP nhằm nạp toàn bộ DAG Mainnet.
  • Chuyển đổi sang vi mạch ASIC chuyên dụng: Tổng hợp thiết kế trên thư viện công nghệ bán dẫn tiêu chuẩn (Standard Cell ASIC 28nm / 14nm) để đẩy tần số làm việc của lõi Keccak lên trên $1.5\text{ GHz}$.
  • Tối ưu hóa cho các biến thể Blockchain hiện đại: Tận dụng các khối IP Keccak256_2stage đã tối ưu để phục vụ việc xác thực Layer 2 (Rollups) và cơ chế Zero-Knowledge Proofs (ZK-SNARKs) trên mạng Ethereum.

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

  • Sinh viên & Học viên ngành Kỹ thuật Máy tính / Điện tử: Cung cấp tài liệu tham khảo hoàn chỉnh về quy trình thiết kế vi mạch, kỹ thuật cân bằng đường ống (Pipeline Balancing) và phương pháp xác thực đồng thiết kế Phần cứng - Phần mềm.
  • Kỹ sư thiết kế vi mạch (ASIC/FPGA Designers): Nắm vững cấu trúc RTL tối ưu cho họ hàm băm Keccak/SHA-3 và giải pháp xử lý mạch số phức tạp như bộ chia Modulo tốc độ cao.
  • Doanh nghiệp & Đơn vị phát triển phần cứng Blockchain: Sở hữu giải pháp IP Core có hiệu suất diện tích cao, sẵn sàng tích hợp vào các thiết bị bảo mật chuyên dụng hoặc bộ tăng tốc mật mã (Hardware Security Modules - HSM).
  • Các nhà nghiên cứu mật mã học ứng dụng: Cung cấp dữ liệu thực nghiệm đo đạc chính xác về mối tương quan giữa thông lượng, diện tích phần cứng và công suất tiêu thụ trên FPGA thế hệ 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 và chạy thử thiết kế này là gì?

Hệ thống yêu cầu bo mạch FPGA Xilinx Virtex-7 (khuyến nghị kit VC707 với chip XC7VX485T), phần mềm Xilinx Vivado (từ bản 2018.x trở lên), máy tính chạy Linux hỗ trợ Python 3.8+ và Go-Ethereum để tạo dữ liệu nạp đầu vào thông qua cổng giao tiếp JTAG/UART.

2. Thiết kế giải quyết bài toán giới hạn kích thước tệp DAG (>4GB) như thế nào?

Trong khuôn khổ khóa luận, nhóm nghiên cứu tập trung tối ưu hóa các khối logic tính toán và đường ống băm, do đó sử dụng tệp mô phỏng thu nhỏ DAG_64.txt lưu trên BRAM nội bộ. Để triển khai sản phẩm thương mại hoàn chỉnh, hệ thống cần kết nối thêm bộ nhớ ngoài DDR3/DDR4 thông qua giao tiếp chuẩn AXI4.

3. Tại sao kiến trúc Keccak256_2stage lại đạt hiệu suất diện tích (Efficiency) cao hơn các nghiên cứu trước?

Nhóm đã loại bỏ các cổng MUX và logic biến đổi phức tạp ở đầu vào bằng giải pháp reset trạng thái thanh ghi REG1 được định thời chính xác, đồng thời nén mảng hằng số vòng $RC$ từ 64-bit về 8-bit, giúp tiết kiệm $25.5%$ số Slices nhưng vẫn duy trì tần số làm việc rất cao ($816.3\text{ MHz}$).

4. Hệ thống có khả năng tương thích với các thuật toán băm khác như SHA-256 của Bitcoin không?

Khối xử lý KeccakRound được thiết kế chuyên biệt cho cấu trúc SPONGE của Keccak (chuẩn SHA-3/Ethash). Tuy nhiên, các kỹ thuật phân tầng đường ống, bộ chia mod_3stage và hàm FNV hoàn toàn có thể tái sử dụng để xây dựng bộ tăng tốc cho các thuật toán mật mã khác.

5. Chi phí ước tính và thời gian hoàn vốn (ROI) khi chuyển đổi từ GPU sang FPGA/ASIC cho thiết kế này?

Chi phí phát triển trên kit FPGA Virtex-7 ban đầu có thể cao, nhưng mức tiêu thụ điện năng chỉ xấp xỉ 3-5W (so với >130W trên GPU). Khi đóng gói thành chip chuyên dụng ASIC, hiệu suất năng lượng tăng gấp hàng chục lần, giúp giảm chi phí tiền điện vận hành và rút ngắn chu kỳ hoàn vốn xuống dưới $6-8$ tháng trong điều kiện khai thác liên tục.

Kết luận

Khóa luận tốt nghiệp đã giải quyết trọn vẹn và chuyên sâu bài toán nghiên cứu và tối ưu hóa phần cứng tạo block cho mạng Ethereum Blockchain. Bằng phương pháp luận khoa học kết hợp giữa mô phỏng phần mềm (Python, Go-Ethereum) và thiết kế phần cứng (Verilog HDL trên FPGA Virtex-7 VC707), đề tài đã mang lại những đóng góp kỹ thuật nổi bật:

  • Hiện thực thành công khối Keccak256_2stage đạt tần số cực đại 816.3 MHz, thông lượng 36.2 Gbps và hiệu suất diện tích vượt trội 29.1 Mbps/Slice.
  • Tối ưu hóa thành công lõi Ethash Core hoàn chỉnh với cơ chế đường ống 5 tầng cho Main Loop và bộ chia Modulo 3 tầng, đạt tốc độ băm 414.7 KH/s ở chế độ xử lý luồng kép.
  • Toàn bộ kết quả phần cứng được kiểm chứng chính xác tuyệt đối $100%$ so với dữ liệu thực nghiệm từ mạng Ethereum Mainnet.

Công trình không chỉ khẳng định tính khả thi của việc tăng tốc phần cứng cho các thuật toán đồng thuận phân tán phức tạp, mà còn mở ra hướng tiếp cận giá trị cho các ứng dụng đồng xử lý mật mã và bảo mật hệ thống thông tin trong tương lai.