基于FPGA的矩阵乘法

最新推荐文章于 2024-02-01 16:32:29 发布
最新推荐文章于 2024-02-01 16:32:29 发布
阅读量7.3k 收藏 55
点赞数 5
分类专栏： FPGA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40268672/article/details/109678846
版权

最近在学system verilog，于是就打算用它写一下矩阵乘法，来体验一把system verilog相对于verilog的方便之处（sv中数组可以作为接口)
以下是矩阵乘法的代码：

`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(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

以下是testbench:

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


module test(

    );
parameter Tn = 4;

logic [15:0]A[0:Tn-1][0:Tn-1];
logic [15:0]B[0:Tn-1][0:Tn-1];
logic [15:0]O[0:Tn-1][0:Tn-1];
logic [15:0]OO[0:Tn-1][0:Tn-1];
logic start;
logic done;
logic clk;
logic rst;

initial 
begin
    rst=1;
    #10 rst=0;
end
initial 
begin
    clk=0;
    forever 
    #5 clk=~clk;    
end
initial 
begin
    start=0;
    #20
    start=1;
    #10;
    start=0;    
end
//显示结果
always_ff@(posedge clk)
if(done)
begin
    int count=0;
    for(int i=0;i<Tn;i++)
    begin
        for(int j=0;j<Tn;j++)
        begin
           if(O[i][j]!=OO[i][j])
               $display("error");
           else
               count=count+1; 
        end
    end
    $display("correct count is %d",count);
end
//初始化矩阵
initial 
begin
for(int i=0;i<Tn;i++)
    for(int j=0;j<Tn;j++)
    begin
        A[i][j]={$random}%10;
        B[i][j]={$random}%10;
    end
for(int i=0;i<Tn;i++)
    for(int j=0;j<Tn;j++)
    begin
        OO[i][j]=0;
        for(int k=0;k<Tn;k++)
            OO[i][j]=OO[i][j]+A[i][k]*B[k][j];
    end
end

block_mm U
(.*);

endmodule

仿真无误：
在这里插入图片描述

更

分块矩阵加载的代码：

`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/13 18:51:33
// Design Name: 
// Module Name: load_test
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module load_test(

    );
parameter Tn = 4;
parameter N = 16;

logic clk;
logic rst;
logic [15:0]read_data;
logic [7:0]addr;
logic [7:0]addra;
logic [7:0]write_addr;
logic [15:0]block_mat[0:Tn-1][0:Tn-1];
logic start;
logic done;
logic [7:0]block_row;
logic [7:0]block_col;
logic [15:0]count;
logic flag;

logic we;
logic [15:0]write_data;
initial 
begin
    for(int i=0;i<N;i++)
    begin
        for(int j=0;j<N;j++)
        begin
            $write("%d,",i*N+j);
        end
        $write("\n");
    end
end
//clk
initial 
begin
    clk=0;
    forever 
    #5 clk=~clk;
end
//rst
initial
begin
    rst=1;
    #10
    rst=0;
end
//初始化矩阵
always@(posedge clk,posedge rst)
if(rst)
begin
    we<=1'b0;
    write_addr<=8'd0;
    write_data<=16'd0;
end
else if(write_addr==255)
begin
    we<=1'b0;
end
else
begin
    write_addr<=write_addr+8'd1;
    write_data<=write_data+16'd1;
    we<=1'b1;
end
//count
always_ff@(posedge clk,posedge rst)
if(rst)
    count<=16'd0;
else 
    count<=count+16'd1;
always_ff@(posedge clk,posedge rst)
if(rst)
    flag<=1'b0;
else if(count==300)
    flag<=1'b1;
//block_row and block_col
always_ff@(posedge clk,posedge rst)
if(rst)
begin
    block_row<=8'd0;
    block_col<=8'd0;
    start<=1'b0;
end
else if(count==300)
begin
    block_row<=8'd12;
    block_col<=8'd12;
    start<=1'b1;
end
else
    start<=1'b0;
//done
always@(posedge clk,posedge rst)
if(rst)
 ;
else if(done)
begin
    for(int i=0;i<Tn;i++)
    begin
        for(int j=0;j<Tn;j++)
        begin
            $write("%d,",block_mat[i][j]);
        end
        $write("\n");
    end
end

assign addra=(flag==1'b1)?addr:write_addr;

Matrix M(
  .clka(clk),    // input wire clka
  .ena(1'b1),      // input wire ena
  .wea(we),      // input wire [0 : 0] wea
  .addra(addra),  // input wire [7 : 0] addra
  .dina(write_data),    // input wire [15 : 0] dina
  .douta(read_data)  // output wire [15 : 0] douta
);

load_block V(
.start(start),
.clk(clk),
.rst(rst),
.din(read_data),
.addr(addr),
.block_row(block_row),
.block_col(block_col),         //读取M[block_row:block_row+Tn,block_col:block_col+Tn]
.block_mat(block_mat),
.done(done)
     );
endmodule

仿真结果
在这里插入图片描述

分块矩阵存储的代码

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/17 19:12:44
// Design Name: 
// Module Name: store_block
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module store_block(
input logic [7:0]block_row,
input logic [7:0]block_col,
input logic [15:0]block_mat[0:Tn-1][0:Tn-1],
input logic clk,
input logic rst,
input logic start,
output logic we,
output logic [7:0]addr,
output logic [15:0]dout,
output logic done
    );
parameter Tn=4;
parameter N=16;
logic [7:0]row;
logic [7:0]col;
logic busy;
//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;
//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)
   if(row==block_row+Tn-1)
       row<=8'd0;
   else
       row<=row+8'd1;
//col
always_ff@(posedge clk,posedge rst)
if(rst)
   col<=8'd0;
else if(start)
   col<=block_col;
else if(col==block_col+Tn-1)
   col<=block_col;
else
   col<=col+8'd1;
//we
always_ff@(posedge clk,posedge rst)
if(rst)
   we<=1'b0;
else if(busy)
   we<=1'b1;
else
   we<=1'b0;
//addr
always_ff@(posedge clk,posedge rst)
if(rst)
   addr<=8'd0;
else if(busy)
   addr<=row*N+col;
else
   addr<=8'd0;
//dout
always_ff@(posedge clk,posedge rst)
if(rst)
   dout<=16'd0;
else if(busy)
   dout<=block_mat[row-block_row][col-block_col];
else 
   dout<=16'd0;
//done
assign done=(~busy&&we)?1'b1:1'b0;
endmodule

testbench:

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2020/11/17 19:35:10
// Design Name: 
// Module Name: store_block_test
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module store_block_test;
parameter Tn = 4;
parameter N  = 16;

logic clk;
logic rst;
logic [7:0]block_row;
logic [7:0]block_col;
logic [15:0]block_mat[0:Tn-1][0:Tn-1];
logic start;
logic done;
logic we;
logic [7:0]addr;
logic [15:0]dout;
//clk
initial 
begin
   clk=0;
   forever
    #5 clk=~clk;
end
//rst
initial
begin
    rst=1;
    #10
    rst=0;
end
//
initial 
begin
    for(int i=0;i<Tn;i++)
       for(int j=0;j<Tn;j++)
          block_mat[i][j]<={$random}%100;
end
initial 
begin
   block_row=8;
   block_col=12;    
end
initial
begin
    start=0;
    #100
    start=1;
    #10
    start=0;
end
//
store_block U(.*);
endmodule

仿真结果正确！

FPGA硅农
关注
  • 5
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
基于FPGA的矩阵逆inv计算
FPGA/MATLAB学习教程/源码/项目合作开发
10-29 1万+
这里，M的具体表达式为： M=x00*x11*x22*x33-x00*x11*x23*x32-x00*x12*x21*x33+x00*x12*x23*x31+x00*x13*x21*x32 -x00*x13*x22*x31-x01*x10*x22*x33+x01*x10*x23*x32+x01*x12*x20*x33-x01*x12*x23*x30 -x01*x13*x20*x32+x01*x13*x22*x30+x02*x10*x21*x33-x02*x10*x23*x31-x02*x11*x2..
LDPC的FPGA代码
03-30
基于FPGA的奇偶校验码，低密度奇偶校验码 (LDPC)是一种特殊的具有稀疏的奇偶校验矩阵的线性纠错码。本课题从理论和硬件实现两方面对LDPC码进行讨论研究,最后完成LDPC码的编码设计。它的直接编码运算量较大,通常具有码长的二次方复杂度.为此,利用有效的校验矩阵 ,来降低编码的复杂度 ,同时研究利用大规模集成电路实现LDPC码的编码，在QuartusⅡ开发平台上，应用VHDL语言实现了有效的编码过程,为LDPC码的硬件实现和实际应用提供依据。
基于FPGA的全流水双精度浮点矩阵乘法器设计.pdf
07-13
基于FPGA的全流水双精度浮点矩阵乘法器设计.pdf
Matrix-Multiplication:使用 Verilog 设计 4 x 4 矩阵乘法
05-31
矩阵乘法 使用 Verilog 设计 4 x 4 矩阵乘法 该设计已通过以下数据验证 设计文件可以在 /src 下找到 可以在 /tb 下找到测试平台 请注意，所有输入数据均应使用8位符号进行签名，而输出数据应使用11位符号进行签名。 输出以有符号十进制监控。 执照 有关许可权利和限制 (Apache 2.0)，请参阅文件。
基于FPGA的4x4补码阵列乘法器Verilog代码Quartus仿真
最新发布
xiakunpei123的博客
02-01 469
代码功能： 4x4补码阵列乘法器 调用4位无符号阵列乘法器,将有符号乘法转换为无符号乘法 若符号位为1，则表示为负数，对齐取反加1，否则表示正数，即本身
FPGA————构建3*3矩阵实现每一列求和
啦啦啦啦啦
05-28 4327
实验目标： 设计思路： 因为要在同一个时间周期对不同时间发送来的数据进行处理，就必须将使用的数据缓存起来，这里使用两个fifo对数据进行缓存。首先将uart_data（串口接收到的数据）写入fifo1中，当第二行第一个数据到来的时候，将fifo1中的数据读出，写入到fifo2中，同时将第二行的数据写入到fifo1中。这里就实现了对数据的缓存。 同时在第三行数据到来的时候，将fifo1，f...
基于脉动阵列的矩阵乘法加速（FPGA）
m0_50735735的博客
03-30 7176
基于脉动阵列的矩阵乘法加速（FPGA） ​ 原本准备做FADDEV求逆矩阵算法的FPGA实现，其中有一个概念挺吸引人，就是：脉动阵列。 1、脉动阵列 ​ 先来讲讲脉动阵列的概念，脉动阵列其实是一种处理单元的结构。数据同步流过，能够减小降低重复访问，调高处理效率和资源消耗。 ​ 其实这是个比较旧的概念了，1982就有学者提出了。18年谷歌提出的TPU（Tensor Processing Unit）让这个概念回到大众视野，通过脉动阵列可以设计完成矩阵乘法和卷积的操作。今天先讲讲矩阵乘法的实现。 2、脉动阵列结构
FPGA 脉动阵列的设计
热门推荐
kebu12345678的博客
02-11 1万+
http://archive.ednchina.com/bbs.ednchina.com/BLOG_ARTICLE_3017115.HTM 一：定义 脉动阵列：数据流同步流过相邻的二维阵列单元的处理器结构，一般不同方向流过不同数据。如下图： 二维不同数据在同一时钟下依次输入每个处理单元，而后完成乘法并存在其寄存器中。 二：举例
用FPGA处理矩阵加法
qq_39810493的博客
10-22 1581
FPGA矩阵加法
矩阵乘法的多种理解形式（硬件设计的基础）（FPGA）
星智云图StarImagine
04-19 7684
1、外积和内积：（1）内积：一个行向量乘以一个列向量称作向量的内积 ，又叫作点积，结果是一个数：；（2）外积：一个列向量乘以一个行向量称作向量的外积 ，外积是一种特殊的克罗内克积（克罗内克积是两个任意大小的矩阵间的运算），结果是一个矩阵，；2、矩阵乘法的变换理解：       矩阵是由向量组成的，将矩阵乘法转换为向量乘法，是从多种角度理解矩阵乘法的精髓。        我们对一个矩阵A（假设行和列...
FPGA HLS Matrix_MUL 矩阵乘法的计算与优化
xiongyuqing的博客
11-01 2472
端口信息，ABC数组默认存在存储器ap_memory中，以下ap_clk、ap_rst、ap_start、ap_done、ap_idle、ap_ready都是控制信号。使用C++完成testbench，同样地，C语言可以编译为对应的激励，驱动上一步骤完成的电路模块。vivado工具比较保守，计算需要的延迟是14，实际优化可以在10，设置大一点，优化的计算更多，一般约束设置大一点在30-50。C++代码综合成RTL逻辑，生成综合报告，包括时序，延时，资源占用，端口信息等。重定义数组在存储器中的排列方式。
FPGA矩阵计算并行算法与结构
01-16
FPGA算法实现类的相关资料，FIR滤波器IIR滤波器等等材料
用Verilog实现阵列乘法器
11-11
用Verilog实现阵列乘法器，采用的是流水线的做法
FPGA实现各种矩阵运算
06-24
介绍了采用FPGA实现的各种矩阵运算的方法，是FPGA实现信号处理的基础。
vivado2019.2平台中通过Verilog编程实现mxn维度大小的矩阵卷积运算+代码操作视频
06-06
1.领域：FPGA，矩阵卷积运算 2.内容：vivado2019.2平台中通过Verilog编程实现mxn维度大小的矩阵卷积运算+代码操作视频 3.用处：用于矩阵卷积运算算法编程学习 4.指向人群：本科，硕士，博士等教研使用 5.运行注意事项： 使用vivado2019.2或者更高版本测试，用软件打开FPGA工程，然后参考提供的操作录像视频跟着操作。 工程路径必须是英文，不能中文。
基于FPGA的矩阵乘法器
02-01
该代码是基于FPGA的矩阵乘法器的代码，可以实现32x32大小有符号矩阵相乘，开发环境是ISE，用modelsim进行仿真
基于FPGA的全流水双精度浮点矩阵乘法器设计 (2012年)
05-29
设计了一个全流水结构的并行双精度浮点矩阵乘法器以提高计算性能,并在Xilinx Virtex-5 LX155现场可编程门阵列(FPGA)上完成了方案的实现.乘法器中处理单元(PE)按阵列形式排列,在一个FPGA芯片上可集成10 个PE单元实现...
gemm_hls:在Xilinx FPGA的Vivado HLS中实现的基于可伸缩脉动阵列的矩阵矩阵乘法
05-06
FPGA上的可扩展矩阵矩阵乘法 该存储库包括用于Xilinx FPGA的矩阵矩阵乘法（A * B = C）的纯Vivado HLS实现，使用Xilinx Vitis / SDx / SDAccel实例化内存和PCIe控制器并与主机接口。 在上进行的实验实现了一半，单...
应用FPGA矩阵求逆
08-03
FPGA（Field-Programmable Gate Array）是一种可编程逻辑器件，可以根据需要重新配置其内部电路，因此在矩阵计算中具有广泛的应用。矩阵求逆是矩阵运算中的重要操作之一，而在通信信号处理等领域，对实时性和计算精度的要求较高。因此，基于FPGA的矩阵求逆成为一个重要的课题。 基于FPGA的矩阵求逆的实现方法有多种。根据引用[1]和引用[2]的内容，可以采用Verilog语言来实现7x7矩阵求逆。通过在FPGA上编写相应的Verilog代码，可以实现矩阵求逆的功能。这种方法可以提高计算速度和满足实时性需求。 引用[3]中提到了基于FPGA的矩阵运算的设计原则和实现方法。通过分析矩阵乘法的线型阵列固化结构和矩阵分解的循环线型阵列结构，可以对矩阵求逆的FPGA固化结构进行改进和优化。具体的架构和实现流程可以根据具体需求进行设计和实现。 综上所述，基于FPGA的矩阵求逆是一种应用广泛的技术，在通信信号处理等领域具有重要意义。通过采用Verilog语言编写相应的代码，可以在FPGA上实现矩阵求逆的功能，并提高计算速度和满足实时性需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

FPGA硅农

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

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

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

打赏作者

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

抵扣说明：

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

余额充值