0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

三个不同AXI IP核的实现的方法_性能的对比及差异的分析

Hx 作者:工程师陈翠 2018-06-29 14:34 次阅读

本文先总结不同AXI IP核的实现的方法,性能的对比,性能差异的分析,可能改进的方面。使用的硬件平台是Zedboard。

不同的AXI总线卷积加速模块的概况

这次实现并逐渐优化了三个版本的卷积加速模块,先简要描述各个版本的主要内容。

版本一

版本一主要是用来测试AXI总线IP核的实现可能。

该模块拥有19个32位寄存器

其中前9个寄存器用来保存需要计算的值

后面9个寄存器用来保存卷积核

在读取第19个寄存器的地址的时候计算9个寄存器的卷积和(该计算可以在一个时钟周期内完成)

9个寄存器单独赋值,程序中分别向对应地址写入内容,通过总线进行传输。

故乐观的来算,需要10个总线周期可以获取一个输出

可以从驱动的书写简单理解一下:

void Conv_HW(int filter[3][3], int arr[100][100],

int filterW, int filterH, int arrW, int arrH) {

int i, j;

for (i = 2; i 《 filterH + arrH - 3; i++) {

for (j = 2; j 《 filterW + arrW - 3; j++) {

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR, arr[i][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+4, arr[i][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+8, arr[i][j - 2]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+12, arr[i - 1][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+16, arr[i - 1][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+20, arr[i - 1][j - 2]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+24, arr[i - 2][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+28, arr[i - 2][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR+32, arr[i - 2][j - 2]);

res[i][j] = Xil_In32(XPAR_CONV_0_S00_AXI_BASEADDR + 72);

}

if (i % 15 == 0)

printf(“=”);

}

}

版本一性能

版本一性能最惨,由于没有时间戳,目测软件计算速度远远快于FPGA核心运算速度。

版本一的改进速度就是引入滑动窗口,能够最大程度减少总线周期。

版本二

版本二引入滑动窗口,和初期设计的概念相同。

三个不同AXI IP核的实现的方法_性能的对比及差异的分析

该模块拥有19个32位寄存器

其中前9个寄存器用来保存需要计算的值

后面9个寄存器用来保存卷积核

在读取第19个寄存器的地址的时候计算9个寄存器的卷积和(该计算可以在一个时钟周期内完成)

三个寄存器滑动赋值,该计算窗口在计算矩阵上滑动 除了冷启动多余两个周期用来预载寄存器,后面的每一个计算只需要四个总线周期

可以通过写的驱动简单理解一下:

void Conv_HW(int filter[3][3], int arr[100][100], int arrW, int arrH) {

int i, j;

i = 2; j = 2;

for (i = 2; i 《 arrH; i++) {

//pre load

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, arr[i - 1][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, arr[i][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, arr[i + 1][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, arr[i - 1][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, arr[i][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, arr[i + 1][j]);

for (j = 2; j 《 arrW; j++) {

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, arr[i - 1][j + 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, arr[i][j + 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, arr[i + 1][j + 1]);

res[i][j] = Xil_In32(XPAR_CONV_0_S00_AXI_BASEADDR + 72);

}

}

}

版本二性能

测试样本 500*500的32bit单位的矩阵 计算200次。

软件消耗33.78秒,卷积IP核心40.25秒

这样的结果还是非常不乐观,分析可能有两种限制了IP核的速度。

两个寄存器的乘法LUT太大,无法硬件优化

总线周期太慢太慢

版本三对于这两种可能进行探索。

版本二的FPGA部分核心代码

// Implement memory mapped register select and write logic generation

// The write data is accepted and written to memory mapped registers when

// axi_awready, S_AXI_WVALID, axi_wready and S_AXI_WVALID are asserted. Write strobes are used to

// select byte enables of slave registers while writing.

// These registers are cleared when reset (active low) is applied.

// Slave register write enable is asserted when valid address and data are available

// and the slave is ready to accept the write address and write data.

assign slv_reg_wren = axi_wready && S_AXI_WVALID && axi_awready && S_AXI_AWVALID;

always @( posedge S_AXI_ACLK )

begin

if ( S_AXI_ARESETN == 1‘b0 )

begin

slv_reg0 《= 0;

slv_reg1 《= 0;

slv_reg2 《= 0;

slv_reg3 《= 0;

slv_reg4 《= 0;

slv_reg5 《= 0;

slv_reg6 《= 0;

slv_reg7 《= 0;

slv_reg8 《= 0;

slv_reg9 《= 0;

slv_reg10 《= 0;

slv_reg11 《= 0;

slv_reg12 《= 0;

slv_reg13 《= 0;

slv_reg14 《= 0;

slv_reg15 《= 0;

slv_reg16 《= 0;

slv_reg17 《= 0;

// slv_reg18 《= 0;

end

else begin

if (slv_reg_wren)

begin

case ( axi_awaddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )

5’h00:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 0

slv_reg0[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h01:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 1

slv_reg1[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h02:

begin

slv_reg0 《= slv_reg1;

slv_reg1 《= slv_reg2;

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 2

slv_reg2[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

end

5‘h03:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 3

slv_reg3[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h04:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 4

slv_reg4[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h05:

begin

slv_reg3 《= slv_reg4;

slv_reg4 《= slv_reg5;

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 5

slv_reg5[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

end

5’h06:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 6

slv_reg6[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h07:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 7

slv_reg7[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h08:

begin

slv_reg6 《= slv_reg7;

slv_reg7 《= slv_reg8;

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 8

slv_reg8[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

end

5‘h09:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 9

slv_reg9[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h0A:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 10

slv_reg10[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h0B:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 11

slv_reg11[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h0C:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 12

slv_reg12[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h0D:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 13

slv_reg13[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h0E:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 14

slv_reg14[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h0F:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 15

slv_reg15[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5’h10:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 16

slv_reg16[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

5‘h11:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 17

slv_reg17[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

// 5’h12:

// for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

// if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// // Respective byte enables are asserted as per write strobes

// // Slave register 18

// slv_reg18[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

// end

default : begin

slv_reg0 《= slv_reg0;

slv_reg1 《= slv_reg1;

slv_reg2 《= slv_reg2;

slv_reg3 《= slv_reg3;

slv_reg4 《= slv_reg4;

slv_reg5 《= slv_reg5;

slv_reg6 《= slv_reg6;

slv_reg7 《= slv_reg7;

slv_reg8 《= slv_reg8;

slv_reg9 《= slv_reg9;

slv_reg10 《= slv_reg10;

slv_reg11 《= slv_reg11;

slv_reg12 《= slv_reg12;

slv_reg13 《= slv_reg13;

slv_reg14 《= slv_reg14;

slv_reg15 《= slv_reg15;

slv_reg16 《= slv_reg16;

slv_reg17 《= slv_reg17;

end

endcase

end

end

end

// Implement memory mapped register select and read logic generation

// Slave register read enable is asserted when valid address is available

// and the slave is ready to accept the read address.

assign slv_reg_rden = axi_arready & S_AXI_ARVALID & ~axi_rvalid;

always @(*)

begin

// Address decoding for reading registers

case ( axi_araddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )

5‘h00 : reg_data_out 《= slv_reg0;

5’h01 : reg_data_out 《= slv_reg1;

5‘h02 : reg_data_out 《= slv_reg2;

5’h03 : reg_data_out 《= slv_reg3;

5‘h04 : reg_data_out 《= slv_reg4;

5’h05 : reg_data_out 《= slv_reg5;

5‘h06 : reg_data_out 《= slv_reg6;

5’h07 : reg_data_out 《= slv_reg7;

5‘h08 : reg_data_out 《= slv_reg8;

5’h09 : reg_data_out 《= slv_reg9;

5‘h0A : reg_data_out 《= slv_reg10;

5’h0B : reg_data_out 《= slv_reg11;

5‘h0C : reg_data_out 《= slv_reg12;

5’h0D : reg_data_out 《= slv_reg13;

5‘h0E : reg_data_out 《= slv_reg14;

5’h0F : reg_data_out 《= slv_reg15;

5‘h10 : reg_data_out 《= slv_reg16;

5’h11 : reg_data_out 《= slv_reg17;

5‘h12 : reg_data_out 《= slv_reg0 * slv_reg9 +

slv_reg1 * slv_reg10 +

slv_reg2 * slv_reg11 +

slv_reg3 * slv_reg12 +

slv_reg4 * slv_reg13 +

slv_reg5 * slv_reg14 +

slv_reg6 * slv_reg15 +

slv_reg7 * slv_reg16 +

slv_reg8 * slv_reg17;

default : reg_data_out 《= 0;

endcase

end

版本三

先尝试生成更小的LUT

该模块拥有19个32位寄存器

其中前9个寄存器用来保存需要计算的值

卷积核固定在Verilog中,用来生成更小的LUT

一个计算只需要四个总线周期

性能测试

仍然软件消耗33秒,卷积IP核心40秒

基本否决是LUT问题。

下面测试AXI总线问题:

假设所有数据均来自于FPGA,无需从总线写入:

void Conv_HW(int filter[3][3], int arr[100][100], int arrW, int arrH) {

int i, j;

i = 2; j = 2;

for (i = 2; i 《 arrH; i++) {

for (j = 2; j 《 arrW; j++) {

res[i][j] = Xil_In32(XPAR_CONV_0_S00_AXI_BASEADDR + 72);

}

}

}

只需要9.47秒即可完成计算,并传回CPU !!!

总结

至此,基本上可以否决利用AXI传数据的可能,所有需要利用AXI总线传输数据的模块均会被总线周期所连累,在优化了传输后,仍然无法解决该问题。确实需要一个更快的方式来传输数据。

Altera的NIOS2中,直接利用IO口传输数据,无需总线周期,再因为NIOS II内核没有流水线优化,所以硬件确实比较快。

附1:AXI4 总线的 FPGA 接口部分

先看总线接口:

// Users to add ports here

// User ports ends

// Do not modify the ports beyond this line

// Global Clock Signal

// 全局时钟

input wire S_AXI_ACLK,

// Global Reset Signal. This Signal is Active LOW

// 全局复位信号

input wire S_AXI_ARESETN,

// Write address (issued by master, acceped by Slave)

// 写地址

input wire [C_S_AXI_ADDR_WIDTH-1 : 0] S_AXI_AWADDR,

// 写地址的保护模式 包括privilege和security level

// Write channel Protection type. This signal indicates the

// privilege and security level of the transaction, and whether

// the transaction is a data access or an instruction access.

input wire [2 : 0] S_AXI_AWPROT,

// 写地址有效信号。为高指示地址有效。

// Write address valid. This signal indicates that the master signaling

// valid write address and control information.

input wire S_AXI_AWVALID,

// 写地址准备信号。为高表示从设备空闲,准备接收地址;为低表示从设备忙。

// ********** 注意 这里是地址 下面是数据 ********

// Write address ready. This signal indicates that the slave is ready

// to accept an address and associated control signals.

output wire S_AXI_AWREADY,

// 写数据,32位到1024位宽

// 从主设备来的数据 从设备接收

// Write data (issued by master, acceped by Slave)

input wire [C_S_AXI_DATA_WIDTH-1 : 0] S_AXI_WDATA,

// 写字节选通,用于表示更新存储器的字节通道,对于数据总线的每8位数据有一位写选通信号。

// Write strobes. This signal indicates which byte lanes hold

// valid data. There is one write strobe bit for each eight

// bits of the write data bus.

input wire [(C_S_AXI_DATA_WIDTH/8)-1 : 0] S_AXI_WSTRB,

// 写有效。为高指示数据有效。

// Write valid. This signal indicates that valid write

// data and strobes are available.

input wire S_AXI_WVALID,

// 写准备。为高表示从设备空闲,准备接收数据;为低表示从设备忙。

// Write ready. This signal indicates that the slave

// can accept the write data.

output wire S_AXI_WREADY,

// 写响应。该信号表示写状态,可允许相应的表示为OKAYEXOKAYSLVERRDECERR。

// Write response. This signal indicates the status

// of the write transaction.

output wire [1 : 0] S_AXI_BRESP,

// 写响应有效。为高指示响应数据有效

// Write response valid. This signal indicates that the channel

// is signaling a valid write response.

output wire S_AXI_BVALID,

// 写响应准备。为高表示主设备空闲,准备接收写响应;为低表示主设备忙。

// Response ready. This signal indicates that the master

// can accept a write response.

input wire S_AXI_BREADY,

//

// 读地址。读地址给出突发数据传输的第一个传输地址。

// Read address (issued by master, acceped by Slave)

input wire [C_S_AXI_ADDR_WIDTH-1 : 0] S_AXI_ARADDR,

// 保护类型,建议值为000。

// Protection type. This signal indicates the privilege

// and security level of the transaction, and whether the

// transaction is a data access or an instruction access.

input wire [2 : 0] S_AXI_ARPROT,

//

// Read address valid. This signal indicates that the channel

// is signaling valid read address and control information.

input wire S_AXI_ARVALID,

// 读地址准备信号。为高表示从设备空闲,准备接收地址;为低表示从设备忙。

// Read address ready. This signal indicates that the slave is

// ready to accept an address and associated control signals.

output wire S_AXI_ARREADY,

// Read data (issued by slave)

output wire [C_S_AXI_DATA_WIDTH-1 : 0] S_AXI_RDATA,

// Read response. This signal indicates the status of the

// read transfer.

output wire [1 : 0] S_AXI_RRESP,

// Read valid. This signal indicates that the channel is

// signaling the required read data.

output wire S_AXI_RVALID,

// Read ready. This signal indicates that the master can

// accept the read data and response information.

input wire S_AXI_RREADY

);

// AXI4LITE signals

reg [C_S_AXI_ADDR_WIDTH-1 : 0] axi_awaddr;

reg axi_awready;

reg axi_wready;

reg [1 : 0] axi_bresp;

reg axi_bvalid;

reg [C_S_AXI_ADDR_WIDTH-1 : 0] axi_araddr;

reg axi_arready;

reg [C_S_AXI_DATA_WIDTH-1 : 0] axi_rdata;

reg [1 : 0] axi_rresp;

reg axi_rvalid;

其中最为重要的读取总线信号寻址的部分:

assign slv_reg_wren = axi_wready && S_AXI_WVALID && axi_awready && S_AXI_AWVALID;

always @( posedge S_AXI_ACLK )

begin

if ( S_AXI_ARESETN == 1’b0 )

begin

slv_reg0 《= 0;

slv_reg1 《= 0;

slv_reg2 《= 0;

slv_reg3 《= 0;

slv_reg4 《= 0;

slv_reg5 《= 0;

slv_reg6 《= 0;

slv_reg7 《= 0;

slv_reg8 《= 0;

slv_reg9 《= 0;

end

else begin

if (slv_reg_wren)

begin

// 进行寻址

// 地址寻址 是这么玩的

// 当寄存器是32位的 最后就是 2位 4个Byte ADDR_LSB = 2

// 当寄存器是64位的 最后就是 3位 8个Byte ADDR_LSB = 3

// OPT_MEM_ADDR_BITS 用来寻址寄存器 这里选了十个寄存器 所以这里就是4位

case ( axi_awaddr[ADDR_LSB+OPT_MEM_ADDR_BITS:ADDR_LSB] )

4‘h0:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

// 只有在对应的Bit位置为1的时候才能开始读取

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 0

slv_reg0[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4’h1:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 1

slv_reg1[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4‘h2:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 2

slv_reg2[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4’h3:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 3

slv_reg3[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4‘h4:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 4

slv_reg4[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4’h5:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 5

slv_reg5[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4‘h6:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 6

slv_reg6[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4’h7:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 7

slv_reg7[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4‘h8:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 8

slv_reg8[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

4’h9:

for ( byte_index = 0; byte_index 《= (C_S_AXI_DATA_WIDTH/8)-1; byte_index = byte_index+1 )

if ( S_AXI_WSTRB[byte_index] == 1 ) begin

// Respective byte enables are asserted as per write strobes

// Slave register 9

slv_reg9[(byte_index*8) +: 8] 《= S_AXI_WDATA[(byte_index*8) +: 8];

end

default : begin

slv_reg0 《= slv_reg0;

slv_reg1 《= slv_reg1;

slv_reg2 《= slv_reg2;

slv_reg3 《= slv_reg3;

slv_reg4 《= slv_reg4;

slv_reg5 《= slv_reg5;

slv_reg6 《= slv_reg6;

slv_reg7 《= slv_reg7;

slv_reg8 《= slv_reg8;

slv_reg9 《= slv_reg9;

end

endcase

end

end

end

附2:AXI4的测试模块与仿真测试

`timescale 1ns/1ns

module conv_axi_test();

parameter integer C_S00_AXI_DATA_WIDTH = 32;

parameter integer C_S00_AXI_ADDR_WIDTH = 6;

reg s00_axi_aclk;

// 全局复位信号

reg s00_axi_aresetn;

reg [C_S00_AXI_ADDR_WIDTH-1 : 0] s00_axi_awaddr;

wire [2 : 0] s00_axi_awprot;

reg s00_axi_awvalid;

wire s00_axi_awready;

reg [C_S00_AXI_DATA_WIDTH-1 : 0] s00_axi_wdata;

reg [(C_S00_AXI_DATA_WIDTH/8)-1 : 0] s00_axi_wstrb;

reg s00_axi_wvalid;

wire s00_axi_wready;

wire [1 : 0] s00_axi_bresp;

wire s00_axi_bvalid;

wire s00_axi_bready;

reg [C_S00_AXI_ADDR_WIDTH-1 : 0] s00_axi_araddr;

wire [2 : 0] s00_axi_arprot;

reg s00_axi_arvalid;

wire s00_axi_arready;

wire [C_S00_AXI_DATA_WIDTH-1 : 0] s00_axi_rdata;

wire [1 : 0] s00_axi_rresp;

wire s00_axi_rvalid;

wire s00_axi_rready;

conv_v1_0_S00_AXI # (

.C_S_AXI_DATA_WIDTH(C_S00_AXI_DATA_WIDTH),

.C_S_AXI_ADDR_WIDTH(C_S00_AXI_ADDR_WIDTH)

) conv_v1_0_S00_AXI_inst (

.S_AXI_ACLK(s00_axi_aclk),

.S_AXI_ARESETN(s00_axi_aresetn),

.S_AXI_AWADDR(s00_axi_awaddr),

.S_AXI_AWPROT(s00_axi_awprot),

.S_AXI_AWVALID(s00_axi_awvalid),

.S_AXI_AWREADY(s00_axi_awready),

.S_AXI_WDATA(s00_axi_wdata),

.S_AXI_WSTRB(s00_axi_wstrb),

.S_AXI_WVALID(s00_axi_wvalid),

.S_AXI_WREADY(s00_axi_wready),

.S_AXI_BRESP(s00_axi_bresp),

.S_AXI_BVALID(s00_axi_bvalid),

.S_AXI_BREADY(s00_axi_bready),

.S_AXI_ARADDR(s00_axi_araddr),

.S_AXI_ARPROT(s00_axi_arprot),

.S_AXI_ARVALID(s00_axi_arvalid),

.S_AXI_ARREADY(s00_axi_arready),

.S_AXI_RDATA(s00_axi_rdata),

.S_AXI_RRESP(s00_axi_rresp),

.S_AXI_RVALID(s00_axi_rvalid),

.S_AXI_RREADY(s00_axi_rready)

);

initial

begin:d

integer i;

s00_axi_aclk = 1;

for(i = 0; i《 1000;i++)

begin

#1 s00_axi_aclk = ~ s00_axi_aclk;

end

$finish();

end

initial

begin

s00_axi_aresetn = 0;

s00_axi_arvalid = 0;

#4 s00_axi_aresetn = 1;

s00_axi_awvalid = 1;

s00_axi_wvalid = 1;

s00_axi_awaddr = 0;

s00_axi_wstrb = 4‘b1111;

s00_axi_wdata = 3;

#4 s00_axi_awaddr = 6’b000100;

s00_axi_wdata = 21;

#4 s00_axi_awaddr = 6‘b001000;

s00_axi_wdata = 19;

#4 s00_axi_awaddr = 6’b001100;

s00_axi_wdata = 22;

#4 s00_axi_awaddr = 6‘b010000;

s00_axi_wdata = 20;

#4 s00_axi_awaddr = 6’b010100;

s00_axi_wdata = 13;

#4 s00_axi_awaddr = 6‘b011000;

s00_axi_wdata = 16;

#4 s00_axi_awaddr = 6’b011100;

s00_axi_wdata = 14;

#4 s00_axi_awaddr = 6‘b100000;

s00_axi_wdata = 7;

#4

s00_axi_arvalid = 1;

s00_axi_araddr = 6’b100100;

end

initial

begin

$dumpfile(“test.vcd”);

$dumpvars();

end

endmodule

利用iverilog进行仿真GTKwave显示测试波形如下

三个不同AXI IP核的实现的方法_性能的对比及差异的分析

新建IP核如下:

三个不同AXI IP核的实现的方法_性能的对比及差异的分析

工程顶层图如下:

三个不同AXI IP核的实现的方法_性能的对比及差异的分析

附3:软件驱动

#include

#include “platform.h”

#include “xbasic_types.h”

#include “xparameters.h”

#include “xil_io.h”

#define test_speed

int res[1000][1000];

void delay() {

int i, j, k;

for (i = 0; i 《 1000; i++) {

for (j = 0; j 《 1000; j++) {

for (k = 0; k 《 100; k++)

;

}

}

}

void show_reg() {

int i;

u32 result;

printf(“ ============SHOW REG ================ ”);

for (i = 0; i 《 9; i++) {

result = Xil_In32(XPAR_CONV_0_S00_AXI_BASEADDR + 4 * i);

printf(“Reg %3d : %u ”, i, result);

}

}

void load_kernel(int filter[3][3]) {

UINTPTR kernel_addr = (UINTPTR) XPAR_CONV_0_S00_AXI_BASEADDR + 36;

Xil_Out32(kernel_addr, filter[0][0]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[0][1]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[0][2]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[1][0]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[1][1]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[1][2]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[2][0]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[2][1]);

kernel_addr = kernel_addr + 0x4;

Xil_Out32(kernel_addr, filter[2][2]);

}

void test_set() {

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, 3);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, 22);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, 16);

printf(“1 ”);

show_reg();

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, 21);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, 20);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, 14);

printf(“2 ”);

show_reg();

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, 19);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, 13);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, 7);

printf(“3 ”);

show_reg();

}

void Conv_SW(int filter[3][3], int arr[100][100], int arrW, int arrH) {

int i, j;

i = 2; j = 2;

for (i = 2; i 《 arrH; i++) {

for (j = 2; j 《 arrW;j++){

res[i][j] = 0;

res[i][j] += filter[0][0] * arr[i - 1][j - 1];

res[i][j] += filter[0][1] * arr[i - 1][j];

res[i][j] += filter[0][2] * arr[i - 1][j + 1];

res[i][j] += filter[1][0] * arr[i][j - 1];

res[i][j] += filter[1][1] * arr[i][j];

res[i][j] += filter[1][2] * arr[i][j + 1];

res[i][j] += filter[2][0] * arr[i + 1][j - 1];

res[i][j] += filter[2][1] * arr[i + 1][j];

res[i][j] += filter[2][2] * arr[i + 1][j + 1];

}

}

}

void Conv_HW(int filter[3][3], int arr[100][100], int arrW, int arrH) {

int i, j;

i = 2; j = 2;

for (i = 2; i 《 arrH; i++) {

//pre load

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, arr[i - 1][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, arr[i][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, arr[i + 1][j - 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, arr[i - 1][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, arr[i][j]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, arr[i + 1][j]);

for (j = 2; j 《 arrW; j++) {

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 8, arr[i - 1][j + 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 20, arr[i][j + 1]);

Xil_Out32(XPAR_CONV_0_S00_AXI_BASEADDR + 32, arr[i + 1][j + 1]);

res[i][j] = Xil_In32(XPAR_CONV_0_S00_AXI_BASEADDR + 72);

}

}

}

int main() {

printf(“HELLO WORLD”);

u32 result;

int filterW = 3;

int filterH = 3;

int arrW = 5;

int arrH = 5;

int resW = filterW + arrW - 1;

int resH = filterH + arrH - 1;

int i, j;

int pFilter[3][3];

int arr[100][100];

UINTPTR cur_addr = (UINTPTR) XPAR_CONV_0_S00_AXI_BASEADDR;

pFilter[0][0] = 1;

pFilter[0][1] = 3;

pFilter[0][2] = 1;

pFilter[1][0] = 0;

pFilter[1][1] = 5;

pFilter[1][2] = 0;

pFilter[2][0] = 2;

pFilter[2][1] = 1;

pFilter[2][2] = 2;

init_platform();

for (i = 0; i 《 9; i++) {

Xil_Out32(cur_addr, 0);

cur_addr = cur_addr + 4;

}

load_kernel(pFilter);

printf(“Kernel Loaded ”);

#ifdef test_single

test_set();

result = Xil_In32(XPAR_CONV_0_S00_AXI_BASEADDR + 72);

printf(“Test Set Result %u”, result);

show_reg();

#endif

#ifdef test_func

srand(10);

arrW = 20;

arrH = 20;

resH = filterH + arrH - 1;

resW = filterW + arrW - 1;

for (i = 0; i 《 arrH; i++) {

for (j = 0; j 《 arrW; j++) {

arr[i][j] = rand() % 20;

}

}

printf(“*********************************************** ”);

printf(“Filter: ”);

for (i = filterH - 1; i 》= 0; i--) {

for (j = filterW - 1; j 》= 0; j--) {

printf(“%d ”, pFilter[i][j]);

}

printf(“ ”);

}

printf(“*********************************************** ”);

printf(“Matrix: ”);

for (i = 0; i 《 arrH; i++) {

for (j = 0; j 《 arrW; j++) {

printf(“%4d ”, arr[i][j]);

}

printf(“ ”);

}

printf(“*********************************************** ”);

printf(“Software Start! ”);

Conv_SW(pFilter, arr, arrW, arrH);

printf(“ Software end! ”);

printf(“*********************************************** ”);

printf(“Result1: ”);

for (i = 0; i 《 resH; i++) {

for (j = 0; j 《 resW; j++) {

printf(“%5d ”, res[i][j]);

}

printf(“ ”);

}

for (i = 0; i 《 resH; i++) {

for (j = 0; j 《 resW; j++) {

res[i][j] = 0;

}

}

printf(“*********************************************** ”);

printf(“HardWare Start! ”);

Conv_HW(pFilter, arr, arrW, arrH);

printf(“ HardWare end!”);

printf(“Result2: ”);

for (i = 0; i 《 resH; i++) {

for (j = 0; j 《 resW; j++) {

printf(“%5d ”, res[i][j]);

}

printf(“ ”);

}

printf(“*********************************************** ”);

#endif

#ifdef test_speed

arrW = 500;

arrH = 500;

resH = filterH + arrH - 1;

resW = filterW + arrW - 1;

printf(“Software Start! ”);

for(i = 0; i《 200;i++) {

Conv_SW(pFilter, arr, arrW, arrH);

}

printf(“ Software end! ”);

printf(“HardWare Start! ”);

for(i = 0; i《 200;i++) {

Conv_HW(pFilter, arr, arrW, arrH);

}

printf(“ HardWare end!”);

cleanup_platform();

#endif

return 0;

}

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • IP核
    +关注

    关注

    4

    文章

    327

    浏览量

    49485
  • AXI
    AXI
    +关注

    关注

    1

    文章

    127

    浏览量

    16625
收藏 人收藏

    评论

    相关推荐

    基于IP桥接威廉希尔官方网站 实现密码算法多IP集成的应用方案设计

    分析上述两种集成方法基础上,本文基于方法二,给出了一种改进的多IP集成设计方法
    的头像 发表于 09-08 17:58 3635次阅读
    基于<b class='flag-5'>IP</b>桥接威廉希尔官方网站
<b class='flag-5'>实现</b>密码算法多<b class='flag-5'>IP</b><b class='flag-5'>核</b>集成的应用方案设计

    有人知道为什么MIG IP中的AXI协议。为什么没有AXI_WID这个信号呢?

    有人知道为什么MIG IP中的AXI协议。为什么没有AXI_WID这个信号呢。
    发表于 04-13 09:22

    PCIE项目中AXI4 IP例化详解

    ;next":选择AXI4的IP:输入IP的名称:点击"next":创建和使用AXI4的
    发表于 12-13 17:10

    基于MicroBlaze的AXI总线实时时钟IP设计

    作者:萨其日娜 内蒙古鲁电电力工程有限公司 摘要: 应用MicroBlaze软作为CPU的硬件平台,在此平台上设计了基于AXI总线的通用实时时钟IP。给出了创建
    发表于 11-17 16:34 3926次阅读

    AXI接口简介_AXI IP的创建流程及读写逻辑分析

    本文包含两部分内容:1)AXI接口简介;2)AXI IP的创建流程及读写逻辑分析。 1AXI
    的头像 发表于 06-29 09:33 1.6w次阅读
    <b class='flag-5'>AXI</b>接口简介_<b class='flag-5'>AXI</b> <b class='flag-5'>IP</b><b class='flag-5'>核</b>的创建流程及读写逻辑<b class='flag-5'>分析</b>

    自定义sobel滤波IPIP接口遵守AXI Stream协议

    自定义sobel滤波IP IP接口遵守AXI Stream协议
    的头像 发表于 08-06 06:04 3913次阅读

    关于STM32各系列MCU性能对比及测试说明

    STM32各系列MCU性能对比及测试说明
    的头像 发表于 03-04 10:20 1.3w次阅读

    如何使用MicroBlaze调用AXI IP详细解析

    在一项目中,当你使用microblaze作为控制器来进行系统调度的时候,一般是建议将所有模块封装成AXI形式的IP,这样好管理,也容易调试。
    的头像 发表于 04-27 11:17 6830次阅读
    如何使用MicroBlaze调用<b class='flag-5'>AXI</b> <b class='flag-5'>IP</b><b class='flag-5'>核</b>详细解析

    Xilinx FPGA里面的AXI DMA IP的简单用法

    本文以浮点数Floating-point IP将定点数转换为浮点数为例,详细讲解AXI DMA IP的使用
    的头像 发表于 02-16 16:21 9646次阅读
    Xilinx FPGA里面的<b class='flag-5'>AXI</b> DMA <b class='flag-5'>IP</b><b class='flag-5'>核</b>的简单用法

    AXI4-Stream Video 协议和AXI_VDMA的IP介绍

    本文主要介绍关于AXI4-Stream Video 协议和AXI_VDMA的IP相关内容。为后文完成使用带有HDMI接口的显示器构建图像视频显示的测试工程做准备。
    的头像 发表于 07-03 16:11 8336次阅读

    Video In to AXI4-Stream IP知识介绍

    大家好!今日分享一些关于Video In to AXI4-Stream IP 的知识。在具体学习IP的过程中,我也将分享一些关于如何看x
    的头像 发表于 05-18 14:55 1653次阅读
    Video In to <b class='flag-5'>AXI</b>4-Stream <b class='flag-5'>IP</b><b class='flag-5'>核</b>知识介绍

    简单讲解AXI Interconnect IP的使用方法

    最近需要用到AXI接口的模块,xilinx的IP很多都用到了AXI总线进行数据和指令传输。如果有多个设备需要使用AXI协议对
    的头像 发表于 06-19 15:45 1w次阅读
    简单讲解<b class='flag-5'>AXI</b> Interconnect <b class='flag-5'>IP</b><b class='flag-5'>核</b>的使用<b class='flag-5'>方法</b>

    自定义AXI-Lite接口的IP及源码分析

    在 Vivado 中自定义 AXI4-Lite 接口的 IP实现简单的 LED 控制功能,并将其挂载到 AXI Interconnec
    发表于 06-25 16:31 3333次阅读
    自定义<b class='flag-5'>AXI</b>-Lite接口的<b class='flag-5'>IP</b>及源码<b class='flag-5'>分析</b>

    LogiCORE JTAG至AXI Master IP简介

    LogiCORE JTAG至AXI Master IP是一可定制的,可生成AXIAXI总线可用于处理和驱动系统中FPGA内部的
    的头像 发表于 10-16 10:12 1108次阅读
    LogiCORE JTAG至<b class='flag-5'>AXI</b> Master <b class='flag-5'>IP</b><b class='flag-5'>核</b>简介

    芯驿电子 ALINX 推出全新 IP 产品线,覆盖 TCP/UDP/NVMe AXI IP

    10GBe/40GBe UDP 协议栈 IP 、10GbE TCP/IP 协议栈 IP 和 NVMe
    的头像 发表于 10-30 17:39 295次阅读
     芯驿电子 ALINX 推出全新 <b class='flag-5'>IP</b> <b class='flag-5'>核</b>产品线,覆盖 TCP/UDP/NVMe <b class='flag-5'>AXI</b> <b class='flag-5'>IP</b> <b class='flag-5'>核</b>