Question

我正在开始一个项目，我将矩阵乘法并在FPGA / Changes DE2中合成它。在我开始时，我想指导如何在内存中存储此值。我想做的是[C] = [A] * [B]。注意：[A]，[B]和[C]的值是自动存储在SRAM还是SDRAM中？当我读到这个问题时：Verilog For Loop For Array Multiplication变得更清楚如何操作，但我看不出如何管理它进入内存。任何人都有一些我可以适应读写内存的代码吗？我遵循这条道路会是对的吗？

编辑：

我有这个代码用于矩阵4x4乘法。你能告诉我这段代码是否正确吗？我尝试运行，但C值不会保存到内存中。

module rams(
input clk,
  //  SRAM Interface
  inout  [15:0] SRAM_DQ,   // SRAM Data bus 16 Bits
  output [17:0] SRAM_ADDR, // SRAM Address bus 18 Bits
  output SRAM_UB_N,        // SRAM High-byte Data Mask
  output SRAM_LB_N,        // SRAM Low-byte Data Mask 
  output SRAM_WE_N,    // SRAM Write Enable
  output SRAM_CE_N,        // SRAM Chip Enable
  output SRAM_OE_N        // SRAM Output Enable
);

parameter mat_size = 4;  // change the size of the matrices here.
reg [7:0] A_mat [0:mat_size*mat_size-1];
reg [7:0] B_mat [0:mat_size*mat_size-1];


wire [15:0] mem_in;
reg [17:0] mem_address;

wire [7:0] A,B;
wire [7:0] C;
wire [19:0] A_addr,B_addr,C_addr;
reg reset;
wire start;
reg [9:0] Cr,Cc;

assign SRAM_ADDR = mem_address;
assign SRAM_UB_N = 1'b0;        // SRAM High-byte Data Mask
assign SRAM_LB_N = 1'b0;        // SRAM Low-byte Data Mask 
assign SRAM_CE_N = 1'b0;        // SRAM Chip Enable
assign SRAM_OE_N = 1'b0;        // SRAM Output Enable

reg [2:0] state;
parameter idle=0, read_A=1, read_B=2, start_process=3,do_nothing = 4;;

assign SRAM_WE_N = (valid_output ? 1'b0 : 1'b1);
assign start = !(valid_output | reset);//(valid_output ? 1'b0 : 1'b1);
assign SRAM_DQ = (valid_output ? mem_in : 16'hzzzz);

    // Instantiate the Unit Under Test (UUT)
    mat_mult uut (
        .clk(clk), 
        .reset(reset), 
        .start(start),
        .A_addr(A_addr), 
        .B_addr(B_addr), 
        .C_addr(C_addr), 
        .A(A), 
        .B(B), 
        .mat_size(mat_size), 
        .C(C), 
        .valid_output(valid_output)
    );

assign mem_in = {4'h00,C};

initial begin
    state = idle;
end     

always @(posedge clk)
begin
    case (state)
        idle :
            begin
                mem_address <= 16'h0000;
                state = read_A;
                reset <= 1'b1;
            end
        read_A :    
            begin
                A_mat[mem_address] <= SRAM_DQ;
                if(mem_address < mat_size*mat_size) begin
                    state = read_A;
                    mem_address <= mem_address + 1;
                end else begin
                    state = read_B;
                end 
            end
        read_B :    
            begin
                B_mat[mem_address-(mat_size*mat_size)] <= SRAM_DQ;
                if(mem_address < 2*mat_size*mat_size) begin
                    state = read_B;
                    mem_address <= mem_address + 1;
                end else begin
                    state = start_process;
                    reset <= 1'b0;
                end 
            end 
        start_process : 
            begin
                state = start_process;
                mem_address <= 2*mat_size*mat_size + C_addr;
                if(C_addr == mat_size*mat_size-1) begin 
                    state = do_nothing;
                end else begin
                    reset <= 1'b0;
                end
            end     
        do_nothing : 
            if(valid_output) begin
                reset <= 1'b1;
            end 
    endcase

end

assign A = A_mat[A_addr];
assign B = B_mat[B_addr];

endmodule

我将值A和B一起加载，格式化十六进制16.我使用DE_Control Altera进入值，因为我不知道如何使用您的代码加载。乘法模块是：

module mat_mult(
    input clk,
    input reset,
     input start,
    output [19:0] A_addr,
    output [19:0] B_addr,
    output [19:0] C_addr,
    input [7:0] A,
    input [7:0] B,
     input [9:0] mat_size,
    output [7:0] C,
     output valid_output
    );

reg [9:0] Ar,Br,Bc,Cr,Cc;
reg [7:0] C_res;
reg v;

always @ (posedge clk or posedge reset)
    if (reset) begin
        Ar <= 10'b0000000000;
        Br <= 10'b0000000000;
        Bc <= 10'b0000000000;
        Cr <= 10'b0000000000;
        Cc <= 10'b0000000000;
        C_res <= 8'h00;
        v <= 1'b0;
    end else begin
        if (start) begin
            if (Br == mat_size-1) begin
                Br <= 10'b0000000000;
                if (Bc == mat_size-1) begin
                    Bc <= 10'b0000000000;
                    if (Ar == mat_size-1) begin
                        Ar <= 10'b0000000000;
                    end else begin
                        Ar <= Ar + 1;
                    end
                end else begin
                    Bc <= Bc + 1;
                end
                v <= 1'b1;
            end else begin
                Br <= Br + 1;
            end
            C_res <= C_res + A*B;
        end else begin
            C_res <= 8'h00;
            v <= 1'b0;
        end 
    end 

assign A_addr = (Ar * mat_size) + Br;
assign B_addr = (Br * mat_size) + Bc;
assign C_addr = (Ar * mat_size) + Bc;
assign C = C_res;
assign valid_output = v;

endmodule

Answer 1

使用内存时，请记住它只是地址和字节之间的映射。所以如果你想到一个矩阵（为了简单起见，我假设这里有4x4的32位浮点数），那么你真正拥有的只是16个浮点32位数。

如果您打算将这些存储在片上存储器（集成在FPGA芯片中的SRAM单元）或片外存储到某种DDR类型的存储器中，那么将它们存储在存储器中的方式会有所不同。

将它们存储在芯片上更容易使用，在这种情况下，在verilog中，您只需声明一个数组，然后一次读取和写入一个元素。如果您的FPGA具有适当大小的可用ram单元，您的合成器会将其推断为RAM。

module matrixmem;

input clk;
input [3:0] addr;
input [31:0] data_in;
output [31:0] data_out;
input write;
input read;

reg [31:0] mem [0:15]; //16 32-bit elements, enough to store one 4x4 array.

always @(posedge clk) begin
   if(write)
       mem[addr] <= data_in;
   else if (read)
       data_out <= mem[addr];
end

然后通过这个模块，你可以通过改变地址，一次一个地拉出数组的元素，其中地址代表你想要拉出的矩阵的哪个元素。

如果你想将这些芯片存储起来有点复杂，因为你需要实现一个DDR控制器或利用你的FPGA附带的一些IP来与外部RAM进行通信。但基本上它的工作方式相同，因为矩阵的每个元素都将存储在某个地址中。

Answer 2

您必须始终牢记的另一个预防措施是，在声明始终阻止时，如果输出端口是顺序块，则建议将输出端口声明为reg类型。

至于解决方案，如果我们想使用data_out来存储值，我们需要将其声明为reg类型。否则很好。

乘法矩阵和存储sram或sdram

2 个答案: