分块矩阵乘法+乒乓操作

最新推荐文章于 2022-09-27 08:30:53 发布
最新推荐文章于 2022-09-27 08:30:53 发布
阅读量1.3k 收藏 10
点赞数 2
分类专栏： FPGA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40268672/article/details/109689511
版权

SystemVerilog 矩阵乘法 乒乓操作 分块 并行计算
关键词由CSDN通过智能技术生成

本文用system verilog实现了分块矩阵乘法中计算输出矩阵的某一块，并且进行了pingpang操作，以掩盖数据传输时间。
这是顶层模块的代码：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/16 22:53:40
// Design Name: 
// Module Name: compute_one_block
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module compute_one_block(
input logic clk,
input logic rst,
input logic start,
input logic [15:0]dina,
input logic [15:0]dinb,
input logic [7:0]block_row,
input logic [7:0]block_col,
output logic [7:0]addra,
output logic [7:0]addrb,
output logic [15:0]result[0:Tn-1][0:Tn-1],
output logic done
    );
parameter Tn=4;
parameter N=16;

logic [15:0] buff_a1[0:Tn-1][0:Tn-1];
logic [15:0] buff_a2[0:Tn-1][0:Tn-1];
logic [15:0] buff_b1[0:Tn-1][0:Tn-1];
logic [15:0] buff_b2[0:Tn-1][0:Tn-1];
logic [15:0] buff_o1[0:Tn-1][0:Tn-1];
logic [15:0] buff_o2[0:Tn-1][0:Tn-1];

logic pingpang;
logic pingpang_start;
logic pingpang_done;

logic start_load1;
logic start_load2;
logic start_compute1;
logic start_compute2;
logic load1_done;
logic load2_done;
logic compute1_done;
logic compute2_done;
logic load1_done_ff;
logic load2_done_ff;
logic compute1_done_ff;
logic compute2_done_ff;

logic [7:0]addra1;
logic [7:0]addra2;
logic [7:0]addrb1;
logic [7:0]addrb2;

logic [7:0]block_k;
logic [7:0]pre_block_k;          //load block and compute pre_block_k

logic first_load;
logic final_compute;
logic busy;
//result
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    for(int i=0;i<Tn;i++)
        for(int j=0;j<Tn;j++)
            result[i][j]<=16'd0;
end
else if(start)
begin
    for(int i=0;i<Tn;i++)
        for(int j=0;j<Tn;j++)
            result[i][j]<=16'd0;
end
else if(busy)
    if(compute1_done)
        for(int i=0;i<Tn;i++)
            for(int j=0;j<Tn;j++)
                result[i][j]<=result[i][j]+buff_o1[i][j];
    else if(compute2_done)
        for(int i=0;i<Tn;i++)
            for(int j=0;j<Tn;j++)
                result[i][j]<=result[i][j]+buff_o2[i][j];
//first_load,final_compute
assign first_load=(busy&&block_k==0)?1'b1:1'b0;
assign final_compute=(busy&&pre_block_k==N-Tn)?1'b1:1'b0;
assign init=(busy&&pre_block_k==0)?1'b1:1'b0;
//busy
always_ff@(posedge clk,posedge rst)
if(rst)
    busy<=1'b0;
else if(start)
    busy<=1'b1;
else if(pingpang_done&&pre_block_k==N-Tn)
    busy<=1'b0;
//pingpang_start
always_ff@(posedge clk,posedge rst)
if(rst)
    pingpang_start<=1'b0;
else if(start)
    pingpang_start<=1'b1;
else if(pingpang_done&&~pingpang_start&&busy&&~done)
    pingpang_start<=1'b1;
else
    pingpang_start<=1'b0;
//pingpang
always_ff@(posedge clk,posedge rst)
if(rst)
    pingpang<=1'b0;
else if(start)
    pingpang<=1'b0;
else if(pingpang_done)
    pingpang<=~pingpang;
//load1_done_ff
always_ff@(posedge clk,posedge rst)
if(rst)
    load1_done_ff<=1'b0;
else if(start||pingpang_done)
    load1_done_ff<=1'b0;
else if(load1_done)
    load1_done_ff<=1'b1;
//load2_done_ff
always_ff@(posedge clk,posedge rst)
if(rst)
    load2_done_ff<=1'b0;
else if(start||pingpang_done)
    load2_done_ff<=1'b0;
else if(load2_done)
    load2_done_ff<=1'b1;
//compute1_done_ff
always_ff@(posedge clk,posedge rst)
if(rst)
    compute1_done_ff<=1'b0;
else if(start||pingpang_done)
    compute1_done_ff<=1'b0;
else if(compute1_done)
    compute1_done_ff<=1'b1;
//compute2_done_ff
always_ff@(posedge clk,posedge rst)
if(rst)
    compute2_done_ff<=1'b0;
else if(start||pingpang_done)
    compute2_done_ff<=1'b0;
else if(compute2_done)
    compute2_done_ff<=1'b1;
//pingpang_done
always_ff@(posedge clk,posedge rst)
if(rst)
    pingpang_done<=1'b0;
else if(pingpang==1'b0)                     //load buffer1 and compute buffer2
   if(~pingpang_done)
        if(first_load&&load1_done_ff)
            pingpang_done<=1'b1;
        else if(final_compute&&compute2_done_ff)
            pingpang_done<=1'b1;
        else if(load1_done_ff&&compute2_done_ff)
            pingpang_done<=1'b1;
        else
            pingpang_done<=1'b0;
    else
        pingpang_done<=1'b0;
else                                       //load2 and compute1
    if(~pingpang_done)
        if(first_load&&load2_done_ff)
            pingpang_done<=1'b1;
        else if(final_compute&&compute1_done_ff)
            pingpang_done<=1'b1;
        else if(load2_done_ff&&compute1_done_ff)
            pingpang_done<=1'b1;
        else
            pingpang_done<=1'b0;
    else
        pingpang_done<=1'b0;
//1，2的start_load和start_compute信号
assign start_load1=(~pingpang&&pingpang_start&&~final_compute)?1'b1:1'b0;
assign start_load2=(pingpang&&pingpang_start&&~final_compute)?1'b1:1'b0;
assign start_compute1=(pingpang&&pingpang_start&&~first_load)?1'b1:1'b0;
assign start_compute2=(~pingpang&&pingpang_start&&~first_load)?1'b1:1'b0;
//根据pingpang选择地址线来源
assign addra=(pingpang==1'b1)?addra2:addra1;
assign addrb=(pingpang==1'b1)?addrb2:addrb1;
//block_k
always_ff@(posedge clk,posedge rst)
if(rst)
    block_k<=8'd0;
else if(start)
    block_k<=8'd0;
else if(pingpang_done)
    block_k<=(block_k==N-Tn)?block_k:block_k+Tn;
//pre_block_k
always_ff@(posedge clk,posedge rst)
if(rst)
    pre_block_k<=8'd0;
else if(start)
    pre_block_k<=8'd0;
else if(pingpang_done)
    pre_block_k<=block_k;
//done
assign done=(pingpang_done&&pre_block_k==N-Tn)?1'b1:1'b0;
//模块例化
load_two_block   load1
(
.clk(clk),
.rst(rst),
.start(start_load1),
.block_row(block_row),
.block_col(block_col),
.block_k(block_k),                            //load A[block_row:block_row+Tn,block_k:block_k+Tn]
.dina(dina),                                        //load B[block_k:bloc_k+Tn,block_col:block_col+Tn]
.dinb(dinb),
.addra(addra1),
.addrb(addrb1),
.block_mat_a(buff_a1),
.block_mat_b(buff_b1),
.done(load1_done)
);

load_two_block   load2
(
.clk(clk),
.rst(rst),
.start(start_load2),
.block_row(block_row),
.block_col(block_col),
.block_k(block_k),                            //load A[block_row:block_row+Tn,block_k:block_k+Tn]
.dina(dina),                                        //load B[block_k:bloc_k+Tn,block_col:block_col+Tn]
.dinb(dinb),
.addra(addra2),
.addrb(addrb2),
.block_mat_a(buff_a2),
.block_mat_b(buff_b2),
.done(load2_done)
);

block_mm compute1
(
.clk(clk),
.rst(rst),
.start(start_compute1),                 //start拉高一个周期表示开始
.A(buff_a1),
.B(buff_b1),
.O(buff_o1),
.done(compute1_done)                              //done拉高一个周期表示完成
);

block_mm compute2
(
.clk(clk),
.rst(rst),
.start(start_compute2),                 //start拉高一个周期表示开始
.A(buff_a2),
.B(buff_b2),
.O(buff_o2),
.done(compute2_done)                              //done拉高一个周期表示完成
);

endmodule

block_mm模块，计算A中某一块和B中某一块的乘法。

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/13 16:04:32
// Design Name: 
// Module Name: block_mm
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module block_mm
#(parameter Tn=4)
(
input logic clk,
input logic rst,
input logic start,                 //start拉高一个周期表示开始
input logic [15:0] A[0:Tn-1][0:Tn-1],
input logic [15:0] B[0:Tn-1][0:Tn-1],
output logic [15:0] O[0:Tn-1][0:Tn-1],
output logic done                              //done拉高一个周期表示完成
    );
int row;
int col;
int k;
logic busy;
//busy
always_ff@(posedge clk,posedge rst)
if(rst)
    busy<=1'b0;
else if(start)
    busy<=1'b1;
else if(row==Tn-1&&col==Tn-1&&k==Tn-1)
    busy<=1'b0;
//k
always_ff@(posedge clk,posedge rst)
if(rst)
    k<=0;
else if(start)
    k<=0;
else if(busy)
if(k==Tn-1)
    k<=0;
else
    k<=k+1;
//col
always_ff@(posedge clk,posedge rst)
if(rst)
    col<=0;
else if(start)
    col<=0;
else if(k==Tn-1)
if(col==Tn-1)
    col<=0;
else
    col<=col+1;
//row
always_ff@(posedge clk,posedge rst)
if(rst)
    row<=0;
else if(start)
    row<=0;
else if(col==Tn-1&&k==Tn-1)
    row<=row+1;
//done
always_ff@(posedge clk,posedge rst)
if(rst)
    done<=1'b0;
else if(row==Tn-1&&col==Tn-1&&k==Tn-1&&done==1'b0)
    done<=1'b1;
else
    done<=1'b0;
//calculate matrix 
always_ff@(posedge clk,posedge rst)
if(rst)
    ;
else if(busy)
    if(k==0)
        O[row][col]<=A[row][k]*B[k][col];
    else
        O[row][col]<=O[row][col]+A[row][k]*B[k][col];

endmodule

load_two_block模块，分别加载A和B中的某一块。

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/14 10:30:18
// Design Name: 
// Module Name: load_two_block
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module load_two_block
(
input logic clk,
input logic rst,
input logic start,
input logic [7:0]block_row,
input logic [7:0]block_col,
input logic [7:0]block_k,                        //load A[block_row:block_row+Tn,block_k:block_k+Tn]
input logic [15:0]dina,                          //load B[block_k:bloc_k+Tn,block_col:block_col+Tn]
input logic [15:0]dinb,
output logic [7:0]addra,
output logic [7:0]addrb,
output logic [15:0]block_mat_a[0:Tn-1][0:Tn-1],
output logic [15:0]block_mat_b[0:Tn-1][0:Tn-1],
output logic done
);
parameter Tn=4;

logic done_a;
logic done_b;
assign done=done_a&&done_b;

load_block block_a(
.start(start),
.clk(clk),
.rst(rst),
.din(dina),
.addr(addra),
.block_row(block_row),
.block_col(block_k),         //读取M[block_row:block_row+Tn,block_col:block_col+Tn]
.block_mat(block_mat_a),
.done(done_a)
);

load_block block_b(
.start(start),
.clk(clk),
.rst(rst),
.din(dinb),
.addr(addrb),
.block_row(block_k),
.block_col(block_col),         //读取M[block_row:block_row+Tn,block_col:block_col+Tn]
.block_mat(block_mat_b),
.done(done_b)
);
endmodule

load_block模块，load_two_block的子模块，加载一个分块矩阵。

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/13 18:10:01
// Design Name: 
// Module Name: load_block
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module load_block(
input logic start,
input logic clk,
input logic rst,
input logic [15:0] din,
output logic [7:0] addr,
input logic [7:0]block_row,
input logic [7:0]block_col,         //读取M[block_row:block_row+Tn,block_col:block_col+Tn]
output logic [15:0]block_mat[0:Tn-1][0:Tn-1],
output logic done
     );
parameter Tn = 4;
parameter N = 16 ;

logic [7:0]row;
logic [7:0]col;
logic [7:0]row_ff1;
logic [7:0]row_ff2;
logic [7:0]col_ff1;
logic [7:0]col_ff2;
logic busy;
logic busy_ff1;
logic busy_ff2;
logic done_ff0;
logic done_ff1;
logic done_ff2;

assign done=done_ff2;
//done_ff0
always_ff@(posedge clk,posedge rst)
if(rst)
    done_ff0<=1'b0;
else if(row==block_row+Tn-1&&col==block_col+Tn-1&&~done_ff0)
    done_ff0<=1'b1;
else 
    done_ff0<=1'b0;
//done_ff1,ff2
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    done_ff1<=1'b0;
    done_ff2<=1'b0;
end
else
begin
    done_ff1<=done_ff0;
    done_ff2<=done_ff1;
end
//busy
always_ff@(posedge clk,posedge rst)
if(rst)
    busy<=1'b0;
else if(start)
    busy<=1'b1;
else if(row==block_row+Tn-1&&col==block_col+Tn-1)
    busy<=1'b0;
//busy_ff1,busy_ff2
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    busy_ff1<=1'b0;
    busy_ff2<=1'b0;
end
else
begin
    busy_ff1<=busy;
    busy_ff2<=busy_ff1;
end
//row
always_ff@(posedge clk,posedge rst)
if(rst)
    row<=8'd0;
else if(start)
    row<=block_row;
else if(col==block_col+Tn-1)
    row<=row+1;
//col
always_ff@(posedge clk,posedge rst)
if(rst)
    col<=8'd0;
else if(start)
    col<=block_col;
else if(busy)
if(col==block_col+Tn-1)
    col<=block_col;
else 
    col<=col+1;
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    row_ff1<=8'd0;
    row_ff2<=8'd0;
    col_ff1<=8'd0;
    col_ff2<=8'd0;
end
else
begin
    row_ff1<=row;
    row_ff2<=row_ff1;
    col_ff1<=col;
    col_ff2<=col_ff1;
end
//addr
assign addr=(row*N+col);
//din
always_ff@(posedge clk,posedge rst)
if(rst)
    ;
else if(busy_ff2)
    block_mat[row_ff2-block_row][col_ff2-block_col]<=din;    

endmodule

testbench:

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/17 08:43:39
// Design Name: 
// Module Name: compute_one_block_test
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module compute_one_block_test;
parameter N = 16;
parameter Tn = 4;
logic clk;
logic rst;
logic start;
logic [7:0]block_row;
logic [7:0]block_col;
logic [15:0]dina;
logic [15:0]dinb;
logic [7:0]addra;
logic [7:0]addrb;
logic [15:0]result[0:Tn-1][0:Tn-1];
logic done;

logic wea;
logic web;
logic [7:0]address_a;
logic [7:0]address_b;
logic [7:0]write_addra;
logic [7:0]write_addrb;
logic [15:0]write_data_a;
logic [15:0]write_data_b;
logic [15:0]read_data_a;
logic [15:0]read_data_b;

logic init_done;
logic init_done_ff;
//

//clk
initial 
begin
    clk=0;
    forever 
    #5 clk=~clk;
end
//rst
initial
begin
    rst=1;
    #10
    rst=0;
end
//初始化A,B
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    wea<=1'b0;
    web<=1'b0;
    write_data_a<=16'd0;
    write_data_b<=16'd0;
    write_addra<=8'd0;
    write_addrb<=8'd0;
end
else if(write_addra<N*N-1)
begin
    wea<=1'b1;
    web<=1'b1;
    write_data_a<=write_data_a+1;
    write_data_b<=write_data_b+1;
    write_addra<=write_addra+1;
    write_addrb<=write_addrb+1;
end
else
begin
    wea<=1'b0;
    web<=1'b0;
end
//init_done
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    init_done<=1'b0;
end
else if(write_addra==N*N-1)
    init_done<=1'b1;
//init_done_ff
always_ff@(posedge clk,posedge rst)
if(rst)
    init_done_ff<=1'b0;
else 
    init_done_ff<=init_done;
//start
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    start<=1'b0;
    block_row<=8'd0;
    block_col<=8'd0;
end
else if(init_done&&~init_done_ff&&~start)
begin
    start<=1'b1;
    block_row<=8'd0;
    block_col<=8'd0;
end
else 
    start<=1'b0;
//
assign dina=read_data_a;
assign dinb=read_data_b;
assign address_a=(init_done==1'b1)?addra:write_addra;
assign address_b=(init_done==1'b1)?addrb:write_addrb;
//模块例化
compute_one_block U(
.clk(clk),
.rst(rst),
.start(start),
.dina(dina),
.dinb(dinb),
.block_row(block_row),
.block_col(block_col),
.addra(addra),
.addrb(addrb),
.result(result),
.done(done)
    );

Matrix A (
  .clka(clk),    // input wire clka
  .ena(1'b1),      // input wire ena
  .wea(wea),      // input wire [0 : 0] wea
  .addra(address_a),  // input wire [7 : 0] addra
  .dina(write_data_a),    // input wire [15 : 0] dina
  .douta(read_data_a)  // output wire [15 : 0] douta
);

Matrix B (
  .clka(clk),    // input wire clka
  .ena(1'b1),      // input wire ena
  .wea(web),      // input wire [0 : 0] wea
  .addra(address_b),  // input wire [7 : 0] addra
  .dina(write_data_b),    // input wire [15 : 0] dina
  .douta(read_data_b)  // output wire [15 : 0] douta
);
endmodule

仿真波形及结果
在这里插入图片描述
在这里插入图片描述
上图中的result数组即计算结果，和C++的计算结果相同（这里采用的是16位无符号整数，因此，c++中的int型最终结果要对 2 16 2^{16} 216取模）
在这里插入图片描述

FPGA硅农
关注
专栏目录
目标检测YOLO实战应用案例100讲-基于印刷缺陷检测的嵌入式图像处理(续)
qq_36130719的博客
01-23 213
1）硬件资源本设计是基于嵌入式硬件平台为Xilinx推出的异构可扩展处理平台：ZYNQ-7000 SoC(System-on-Chip,片上系统)系列，芯片型号为XC7Z020CLG400-2(简称ZYNQ 7020), 该硬件平台的PS端采用了双核ARM Cortex-A9处理器，而PL端则使用了可编程逻辑 门阵列FPGA。这个系统最大的优点在于，它能够在嵌入式平台有限的资源和空间下， 兼具ARM处理器高效任务调度和FPGA硬件平台并行计算的能力。
MATLAB程序对分块矩阵在矩阵乘法中算法的实现.pdf
06-30
有关大矩阵分块乘法的实现，matlab代码实现
矩阵分块相乘的Strassen算法
晨宇思远
12-13 9870
  【摘自Intel软件网络博客：http://software.intel.com/zh-cn/blogs/2009/12/08/400002843/?cid=sw:prccsdn893】 对于矩阵乘法 C = A × B，通常的做法是将矩阵进行分块相乘，如下图所示： 从上图可以看出这种分块相乘总共用了8次乘法，当然对于子矩阵相乘（如A0×B0），还可以继续递归使用分块相乘。对于中小矩
乒乓操作
atlll1的博客
03-02 785
乒乓操作是一个用于数据流控制的处理技巧。液晶显示 对于外部接口传输的图像数据，以一帧图像为单位进行SDRAM的切换控制。当SDRAM1缓存图像数据时候，液晶显示的是SDRAM2的数据图像；反之，当SDRAM2缓存图像数据时候，液晶显示的是SDRAM1的图像数据；如此反复。这样处理的好处在于液晶显示的图像切换瞬间完成，掩盖了可能比较缓慢的图像流数据变换过程。 乒乓操作可以通过输入数据选择控制...
矩阵分块乘法
qq_41967508的博客
12-01 3412
矩阵乘法 普通矩阵乘法（ijk） void matrix_multply(float *a, float *b, float *c, int n) { for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { float sum = c[i*N + j] ; for(int k = 0; k < n; k++)
简单乒乓操作
h1580824951的专栏
08-05 857
执行流程： 数据进入缓存1 ——>数据进入缓存2，同时缓存1中的数据处理并输出 ——>数据进入缓存1，同时缓存2中的数据处理并输出
pingpang_block_mm.rar
11-18
分块矩阵乘法将大矩阵拆分成多个小矩阵，然后逐一进行运算，这种方式可以有效减少内存访问和数据传输的时间，同时充分利用FPGA的并行计算能力。 2. **乒乓操作（Ping-Pong Operation）**：乒乓操作是一种常见的数据...
计算机与数学
09-25
15. **分块矩阵的逆**：分块矩阵的逆矩阵可以通过其子块的逆来计算，这里涉及到矩阵运算的高级技巧。 16. **齐次线性方程组的解**：对于特定形式的矩阵和齐次线性方程组，可以找到它们的解空间。 17. **矩阵的运算...
《线性代数》课后答案
03-17
15. **分块矩阵的逆**：分块矩阵的逆可以通过其子块的逆来计算，这在处理大型矩阵时非常有用。 16. **齐次线性方程组**：当矩阵与单位矩阵相乘时，这对应于一组齐次线性方程，其解通常包含零解和其他无限多的解。 ...
面向卷积神经网络的硬件加速器设计方法.pdf
09-25
1. 设计空间探索：为了提高数据重用，采用设计空间探索确定循环分块因子，最大化数据重用。 2. 循环展开技术：为了充分挖掘计算并行度，采用循环展开技术，充分发挥四种计算并行度。 3. 内存池、乒乓缓存和动态数据...
FPGA重要设计思想及工程应用之乒乓操作设计
05-07
乒乓操作是FPGA中一种重要的算法思想。本文详细讲解了乒乓操作的原理及实现方法。
xilinx乘加器ip核中文版v3.0.pdf
08-23
xilinx 乘法器 ip核最新翻译中文版，初学者可以对照着看学习fpga
生产者消费者多线程程序
03-21
本资源是基于mfc的生产者消费者的多线程学习资源，对初学mfc的人来说很有用
C语言分块矩阵乘法,c语言矩阵相乘
weixin_31925685的博客
05-19 718
该楼层疑似违规已被系统折叠隐藏此楼查看此楼程序清单#include&nbspint&nbspmain(void){&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbspchar&nbsp&nbsp&nbsp&nbspa[2][3];&nbsp&...
基于C++的Winograd卷积实现(分片+乒乓)
qq_40268672的博客
09-04 760
#include<stdio.h> #include<iostream> #define M 2 #define R 3 #define N (M+R-1) #define Tm 8 #define Tn 4 #define Tr 8 #define Tc 8 using namespace std; typedef float data_t; /* A^T = [1 1 1 0 0 1 - 1 1] G = [1 0 0 0.5 0.5 0.5
system verilog实现矩阵乘法
qq_40268672的博客
11-15 3212
`timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2020/11/13 17:28:51 // Design Name: // Module Name: mm // Project Name: // Target Devices: // Tool Ver
矩阵代数（四）- 分块矩阵
github_40153370的博客
03-09 1241
小结 分块矩阵 分块矩阵运算 分块矩阵的逆 分块矩阵 矩阵A=[30−159−2−5240−31−8−6317−4]\boldsymbol{A} = \left[\begin{array}{ccc|cc|c} 3 &amp;amp; 0 &amp;amp; -1 &amp;amp; 5 &amp;amp; 9 &amp;amp; -2 \\ -5 &amp;amp; 2 &amp;amp;...
程序性能优化探讨（6）——矩阵乘法优化之分块矩阵
热门推荐
u013471946的专栏
02-26 1万+
有一种性格叫做偏执，有一种矩阵优化运算叫做分块。实话说，也许我这辈子也用不上这种随牛B但很复杂的算法，有些版本的教材直接删除这个内容。但越是这样我越想不过，因此借写这篇博客，把分块矩阵乘法彻底分析清楚。          把矩阵乘法进行分块优化，很奇妙的算法，假设我们要做11X11矩阵乘法，AXB = C原本是这样算的：         比如我们要计算C1.2，就要把上图的
【Verilog我思我用】-generate
OpenFPGA的博客
09-27 3729
【Verilog我思我用】-generate在使用xilinx官方例程《XAPP585》实现CameraLink接口发送或者接收数据时，有个程序还是值得学习的，下面把这段程序截出来：genvari; genvarj; generate for(i=0;i<=(N-1);i=i+1) begin:loop0 serdes_7_to_1_diff_sdr#...
FPGA实现矩阵乘法
最新发布
05-09
FPGA可以通过并行计算实现高效的矩阵乘法。实现矩阵乘法的步骤如下： 1. 将输入的两个矩阵分别存储在FPGA的存储器中。 2. 将其中一个矩阵的行拆分为多个片段，并将这些片段分配到不同的计算单元中。另一个矩阵按列分割成多个片段，并将每个片段放入对应的计算单元中。 3. 计算每个计算单元内的矩阵乘法结果，将结果存储在该计算单元的输出缓冲区中。 4. 将每个计算单元的输出缓冲区中的结果进行合并，得到最终的矩阵乘法结果。 在实现过程中，需要注意FPGA的资源利用率和计算单元之间的通信效率。优化资源利用率和通信效率可以提高矩阵乘法的计算速度。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FPGA硅农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值