Vícevláknový RISC-V softprocesor pro FPGA

Implementace hardwarové vícevláknovosti v softwarovém procesoru RISC-V pro FPGA

Vícevláknová mikroarchitektura softwarového procesoru založeného na RISC-V využívá stínové registry pro ukládání stavů hartů, což umožňuje rychlé přepínání kontextů bez softwarového zásahu. Toto zjednodušuje zpracování asynchronních událostí v FPGA projektech, minimalizuje zatížení řadiče přerušení a snižuje objem kódu. Implementace je zaměřena na systémy s jednou úrovní privilegií a společným adresním prostorem.

Základy mikroarchitektury

Klíčovým prvkem jsou pole stínových registrů pro každý hart (podle terminologie RISC-V). Každý hart ukládá svůj stav v kopiích registrů x0-x31 a PC. Společné zůstávají ALU, paměť, periferie a CSR registry. Ochrana dat je implementována na úrovni softwaru.

Je podporována základní sada instrukcí I+Zicsr. Řízení vláken probíhá přes CSR registry a tabulku hartů (hart_table). Přepínání hartů probíhá cyklicky podle systémového časovače, jehož nižší bity adresují tabulku.

Bity aktivity hartů řídí zápis do PC, registrů a paměti a také resetují ALU pipeline pro neaktivní vlákna.

Modul CSR registrů

CSR blok je rozdělen na nezávislé porty pro čtení a zápis pro kompatibilitu s vícevláknovostí:

module rv_csr
#(
  parameter DATA_WIDTH=32, 
  parameter ADDR_WIDTH=12,
  parameter CSR_size = 32
  )
(input clk,
  input [(ADDR_WIDTH-1):0] csr_addr_in,
  input [(DATA_WIDTH-1):0] csr_in,
  input [(ADDR_WIDTH-1):0] csr_addr_out,
  output reg [(DATA_WIDTH-1):0] csr_out,
  input csr_wr,
  input en
);
// csr register file
reg [ADDR_WIDTH-1:0] csr_reg[0:CSR_size-1];

always @ (posedge clk)
begin
  case (csr_addr_in)
    32'h0 : begin
      if (csr_wr&en) begin
        csr_reg[0] <= csr_in;
      end 
    end
    default: begin
      csr_reg[1] <= 32'h555;
    end
  endcase
  case (csr_addr_out)
    32'h0 : begin
      csr_out <= csr_reg[0];
    end
    default: begin
      csr_out<=32'hAAA;
    end
  endcase
end

endmodule

Soubor registrů s podporou hartů

Vícevláknový register file implementuje pole RAM pro 8 hartů. Čtení/zápis jsou adresovány podle čísla hart_in/hart_out:

module rv_reg_file
#(
  parameter DATA_WIDTH=32, 
  parameter ADDR_WIDTH=5
  )
( input clk,
  input [(ADDR_WIDTH-1):0] rs1,
  input [(ADDR_WIDTH-1):0] rs2,
  input [(ADDR_WIDTH-1):0] rd,
  output reg [(DATA_WIDTH-1):0] Rs1_out,
  output reg [(DATA_WIDTH-1):0] Rs2_out,
  input [(DATA_WIDTH-1):0] Rd_input,
  input [2:0] hart_in, // hart to read out data from
  input [2:0] hart_out, // hart to write data to
  input we,
  input en,
  output reg [(DATA_WIDTH-1):0] x1_out,
  output reg [(DATA_WIDTH-1):0] x2_out,
  output reg [(DATA_WIDTH-1):0] x3_out,
  output reg [(DATA_WIDTH-1):0] x4_out,
  output reg [(DATA_WIDTH-1):0] x5_out
);

// RAM array
  reg [DATA_WIDTH-1:0] ram[0:2**ADDR_WIDTH-1][0:7];
  wire rd_nonzero;
  wire rs1_nonzero;
  wire rs2_nonzero;
  assign rd_nonzero = |rd;
  assign rs1_nonzero = |rs1;
  assign rs2_nonzero = |rs2;

always @ (posedge clk)
  begin
    if (en & we & rd_nonzero) ram[rd][hart_in] <= Rd_input;
  end

always @ (*)
  begin
    Rs1_out <= rs1_nonzero ? ram[rs1][hart_out] : 32'h0;
    Rs2_out <= rs2_nonzero ? ram[rs2][hart_out] : 32'h0;
    x1_out <= ram[1][hart_out];
    x2_out <= ram[2][hart_out];
    x3_out <= ram[3][hart_out];
    x4_out <= ram[4][hart_out];
    x5_out <= ram[5][hart_out];
  end
// */
endmodule

Programový čítač pro vlákna

PC je implementován jako pole registrů s inicializací ze souboru pc.txt. Inkrement a načtení probíhají pouze pro aktivní hart:

module rv_pc
#(
parameter WIDTH=32
)
(
  input clk,
  input rst_n,
  input en,
  input pc_load,
  input [WIDTH-1:0] pc_next,
  output [WIDTH-1:0] pc,
  output reg [WIDTH-1:0] pc_plus,
  input [2:0] hart_in,
  input [2:0] hart_out
);
reg [WIDTH-1:0] pc_reg[0:7];
// read initial PCs data values
initial
$readmemh("pc.txt",pc_reg);

always@(posedge clk or negedge rst_n)
  begin
    if (en) begin
      if(pc_load==1'b1)
        pc_reg[hart_in] <= pc_next;
      else
        pc_reg[hart_in] <= pc_reg[hart_in] + 3'h4;
      end
    end
assign pc = pc_reg[hart_out];

always @ *
  begin
    pc_plus <= pc_reg[hart_out] + 3'h4;
  end

endmodule

Tabulka hartů a řízení

Hart_table je ROM na 8 záznamů (4 bity: 1 bit aktivity + 3 bity čísla hartu), adresovaná časovačem. Systémový 64bitový časovač slouží jako cyklický čítač a systémový chronometr.

Úplný seznam modulů:

• rv_pc — vícevláknový čítač instrukcí
• rv_mem — unifikovaná paměť
• rv_desh — dekodér s resetem pipeline
• rv_reg_file — stínové registry
• rv_alu_v — pipeline ALU
• rv_csr — společné speciální registry
• rv_hart_reg — stav hartů
• rv_timer — 64bitový časovač
• rv_hart_table — konfigurace vláken

Výhody implementace

• Rychlé přepínání: hardwarové, bez ukládání/obnovování registrů
• Zjednodušení IRQ: vlákna místo vektorů přerušení
• Kompatibilita RISC-V: podpora hart konceptu
• Optimalizace pro FPGA: sdílené zdroje, minimum logiky

Co je důležité

• Stínové registry ukládají úplný architektonický stav každého hartu
• Společné CSR vyžadují oddělené porty R/W pro správnou funkci
• Aktivita hartu řídí všechny zápisy a resetuje pipeline
• Časovač cyklicky adresuje hart_table, zajišťuje round-robin
• Ochrana paměti a synchronizace jsou odpovědností OS/RTOS

— Editorial Team