【Memory】Ultrascale系列URAM存储资源使用方法

于 2024-03-28 23:23:13 发布
阅读量1.7k 收藏 16
点赞数 44
分类专栏： # 片上资源 文章标签： fpga开发 Xilinx Verilog URAM 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45434284/article/details/137125791
版权

URAM存储资源优势

  在FPGA中常使用LUTRAM(Distributed RAM)、BRAM（Block RAM）两种片上存储资源。LUTRAM由SLICEM资源派生而来，容量为512b；BRAM容量一般固定36Kb，由RAMBFIFO36资源派生而来，可拆分成两个18Kb BRAM。二者的读延时均较低，基本在1-2个时钟周期（是否使用输出寄存器优化时序）。
在这里插入图片描述

SLICEM在某FPGA芯片X1Y4域内排布

在这里插入图片描述

BRAM在某FPGA芯片X2Y4域内排布

  随着FPGA计算能力的提高，片上存储资源容量（一般单个仅36Kb，总容量不超过4MB）无法满足高带宽计算的要求，而片外存储资源（如DDR、HBM等）的读写延时较大（一般需要上百时钟周期）无法满足低延时计算的要求。为此，Xilinx自Ultrascale系列开始引入URAM（Ultra RAM）存储资源，该资源容量为288Kb，读延时较低，在不使用级联的情况下，基本保持在1-2个时钟周期（是否使用输出寄存器优化时序）。
在这里插入图片描述

URAM在某FPGA芯片X1Y4域内排布

使用方法

本文介绍三种使用URAM存储资源的方式：

  • IP核

  在具有URAM的FPGA上可通过使用URAM READ BACK IP核进行URAM例化，可参考相关IP产品手册，不多赘述，需要注意的是这种方式仅能例化单个URAM，无法简单进行URAM级联。
在这里插入图片描述

  • xpm_memory原语

xpm_memory原语通过配置memory_type参数为ultra可使用URAM，类似于Distributed RAM、BRAM类型的使用方法，本文不多赘述。

  • URAM原语

  本文重点介绍URAM原语的使用，该原语声明如下，在Ultrascale+及之前系列中，URAM288的位宽固定为72,深度固定为4K，相比BRAM配置灵活度较低：

URAM288_BASE #(
      .AUTO_SLEEP_LATENCY(8),            // Latency requirement to enter sleep mode
      .AVG_CONS_INACTIVE_CYCLES(10),     // Average consecutive inactive cycles when is SLEEP mode for power
                                         // estimation
      .BWE_MODE_A("PARITY_INTERLEAVED"), // Port A Byte write control
      .BWE_MODE_B("PARITY_INTERLEAVED"), // Port B Byte write control
      .EN_AUTO_SLEEP_MODE("FALSE"),      // Enable to automatically enter sleep mode
      .EN_ECC_RD_A("FALSE"),             // Port A ECC encoder
      .EN_ECC_RD_B("FALSE"),             // Port B ECC encoder
      .EN_ECC_WR_A("FALSE"),             // Port A ECC decoder
      .EN_ECC_WR_B("FALSE"),             // Port B ECC decoder
      .IREG_PRE_A("FALSE"),              // Optional Port A input pipeline registers
      .IREG_PRE_B("FALSE"),              // Optional Port B input pipeline registers
      .IS_CLK_INVERTED(1'b0),            // Optional inverter for CLK
      .IS_EN_A_INVERTED(1'b0),           // Optional inverter for Port A enable
      .IS_EN_B_INVERTED(1'b0),           // Optional inverter for Port B enable
      .IS_RDB_WR_A_INVERTED(1'b0),       // Optional inverter for Port A read/write select
      .IS_RDB_WR_B_INVERTED(1'b0),       // Optional inverter for Port B read/write select
      .IS_RST_A_INVERTED(1'b0),          // Optional inverter for Port A reset
      .IS_RST_B_INVERTED(1'b0),          // Optional inverter for Port B reset
      .OREG_A("FALSE"),                  // Optional Port A output pipeline registers
      .OREG_B("FALSE"),                  // Optional Port B output pipeline registers
      .OREG_ECC_A("FALSE"),              // Port A ECC decoder output
      .OREG_ECC_B("FALSE"),              // Port B output ECC decoder
      .RST_MODE_A("SYNC"),               // Port A reset mode
      .RST_MODE_B("SYNC"),               // Port B reset mode
      .USE_EXT_CE_A("FALSE"),            // Enable Port A external CE inputs for output registers
      .USE_EXT_CE_B("FALSE")             // Enable Port B external CE inputs for output registers
   )
   URAM288_BASE_inst (
      .DBITERR_A(DBITERR_A),               // 1-bit output: Port A double-bit error flag status
      .DBITERR_B(DBITERR_B),               // 1-bit output: Port B double-bit error flag status
      .DOUT_A(DOUT_A),                     // 72-bit output: Port A read data output
      .DOUT_B(DOUT_B),                     // 72-bit output: Port B read data output
      .SBITERR_A(SBITERR_A),               // 1-bit output: Port A single-bit error flag status
      .SBITERR_B(SBITERR_B),               // 1-bit output: Port B single-bit error flag status
      .ADDR_A(ADDR_A),                     // 23-bit input: Port A address
      .ADDR_B(ADDR_B),                     // 23-bit input: Port B address
      .BWE_A(BWE_A),                       // 9-bit input: Port A Byte-write enable
      .BWE_B(BWE_B),                       // 9-bit input: Port B Byte-write enable
      .CLK(CLK),                           // 1-bit input: Clock source
      .DIN_A(DIN_A),                       // 72-bit input: Port A write data input
      .DIN_B(DIN_B),                       // 72-bit input: Port B write data input
      .EN_A(EN_A),                         // 1-bit input: Port A enable
      .EN_B(EN_B),                         // 1-bit input: Port B enable
      .INJECT_DBITERR_A(INJECT_DBITERR_A), // 1-bit input: Port A double-bit error injection
      .INJECT_DBITERR_B(INJECT_DBITERR_B), // 1-bit input: Port B double-bit error injection
      .INJECT_SBITERR_A(INJECT_SBITERR_A), // 1-bit input: Port A single-bit error injection
      .INJECT_SBITERR_B(INJECT_SBITERR_B), // 1-bit input: Port B single-bit error injection
      .OREG_CE_A(OREG_CE_A),               // 1-bit input: Port A output register clock enable
      .OREG_CE_B(OREG_CE_B),               // 1-bit input: Port B output register clock enable
      .OREG_ECC_CE_A(OREG_ECC_CE_A),       // 1-bit input: Port A ECC decoder output register clock enable
      .OREG_ECC_CE_B(OREG_ECC_CE_B),       // 1-bit input: Port B ECC decoder output register clock enable
      .RDB_WR_A(RDB_WR_A),                 // 1-bit input: Port A read/write select
      .RDB_WR_B(RDB_WR_B),                 // 1-bit input: Port B read/write select
      .RST_A(RST_A),                       // 1-bit input: Port A asynchronous or synchronous reset for output
                                           // registers

      .RST_B(RST_B),                       // 1-bit input: Port B asynchronous or synchronous reset for output
                                           // registers

      .SLEEP(SLEEP)                        // 1-bit input: Dynamic power gating control
   );

  在实际使用时，URAM的使用方式与BRAM相似，需要注意的是，URAM不同于BRAM，必须使用复位信号复位后方能进行使用，复位过程需要保证未进行写操作。

级联

  与BRAM一样，在需要时，URAM可以通过使用专用布线级联的方式增加容量。级联需要注意参数配置和端口的连接关系，此外在级联状态下，读周期会相应延长，在不需要拓展位宽，需要拓展深度时的一维级联的代码如下：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: wjh776a68
// 
// Create Date: 03/22/2023 10:35:33 PM
// Design Name: 
// Module Name: uram72
// Project Name: 
// Target Devices: xcvu37p
// Tool Versions: 2022.2
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//

module uram72 # (
    parameter cascade_level = 6,
    parameter addr_mask = 11'h7f8
) (
    input clk,
    output wire [71:0] DOUT_A,
    output wire [71:0] DOUT_B,
    output wire        RDACCESS_A,
    output wire        RDACCESS_B,
    input [22:0] ADDR_A,
    input [22:0] ADDR_B,
    input [8:0]  BWE_A,
    input [8:0]  BWE_B,
    input [71:0] DIN_A,
    input [71:0] DIN_B,
    input        RDB_WR_A,
    input        RDB_WR_B,
    input        EN_A,
    input        EN_B
   //  input rst
    );
    
    // 7 uram casade to save one row of output of systolic array (226*226*32). 
    // 64 * (2 ^ 12) * 7 - 226 * 226 * 32 >= 0

    logic [23 - 1 : 0]     CAS_ADDR_A[cascade_level:0];
    logic [23 - 1 : 0]     CAS_ADDR_B[cascade_level:0];
    logic [9 - 1 : 0]       CAS_BWE_A[cascade_level:0];
    logic [9 - 1 : 0]       CAS_BWE_B[cascade_level:0];
    logic [1 - 1 : 0]   CAS_DBITERR_A[cascade_level:0];
    logic [1 - 1 : 0]   CAS_DBITERR_B[cascade_level:0];
    logic [72 - 1 : 0]      CAS_DIN_A[cascade_level:0];
    logic [72 - 1 : 0]      CAS_DIN_B[cascade_level:0];
    logic [72 - 1 : 0]     CAS_DOUT_A[cascade_level:0];
    logic [72 - 1 : 0]     CAS_DOUT_B[cascade_level:0];
    logic [1 - 1 : 0]        CAS_EN_A[cascade_level:0];
    logic [1 - 1 : 0]        CAS_EN_B[cascade_level:0];
    logic [1 - 1 : 0]  CAS_RDACCESS_A[cascade_level:0];
    logic [1 - 1 : 0]  CAS_RDACCESS_B[cascade_level:0];
    logic [1 - 1 : 0]    CAS_RDB_WR_A[cascade_level:0];
    logic [1 - 1 : 0]    CAS_RDB_WR_B[cascade_level:0];
    logic [1 - 1 : 0]   CAS_SBITERR_A[cascade_level:0];
    logic [1 - 1 : 0]   CAS_SBITERR_B[cascade_level:0];
    logic [1 - 1 : 0]   CAS_RST      [cascade_level:0];
    assign  CAS_ADDR_A[0] = 0;
    assign  CAS_ADDR_B[0] = 0;
    assign  CAS_BWE_A[0] = 0;
    assign  CAS_BWE_B[0] = 0;
    assign  CAS_DBITERR_A[0] = 0;
    assign  CAS_DBITERR_B[0] = 0;
    assign  CAS_DIN_A[0] = 0;
    assign  CAS_DIN_B[0] = 0;
    assign  CAS_DOUT_A[0] = 0;
    assign  CAS_DOUT_B[0] = 0;
    assign  CAS_EN_A[0] = 0;
    assign  CAS_EN_B[0] = 0;
    assign  CAS_RDACCESS_A[0] = 0;
    assign  CAS_RDACCESS_B[0] = 0;
    assign  CAS_RDB_WR_A[0] = 0;
    assign  CAS_RDB_WR_B[0] = 0;
    assign  CAS_SBITERR_A[0] = 0;
    assign  CAS_SBITERR_B[0] = 0;
   //  assign  CAS_RST[0] = rst;

    /* always_ff @(posedge clk) begin
      CAS_RST[cascade_level:0] <= {CAS_RST[cascade_level - 1:0], rst};
    end */

   generate
      for (genvar i = 0; i < cascade_level + 1; i++) begin
         assign CAS_RST[i] = 0;
      end
   endgenerate

    generate 
    for (genvar i = 0; i < cascade_level; i++) begin : uram_cascade
        if (i == 0) begin
            URAM288 #(
              .AUTO_SLEEP_LATENCY(8),            // Latency requirement to enter sleep mode
              .AVG_CONS_INACTIVE_CYCLES(10),     // Average consecutive inactive cycles when is SLEEP mode for power
                                                 // estimation
              .BWE_MODE_A("PARITY_INDEPENDENT"), // Port A Byte write control
              .BWE_MODE_B("PARITY_INDEPENDENT"), // Port B Byte write control
              .CASCADE_ORDER_A("FIRST"),          // Port A position in cascade chain
              .CASCADE_ORDER_B("FIRST"),          // Port B position in cascade chain
              .EN_AUTO_SLEEP_MODE("FALSE"),      // Enable to automatically enter sleep mode
              .EN_ECC_RD_A("FALSE"),             // Port A ECC encoder
              .EN_ECC_RD_B("FALSE"),             // Port B ECC encoder
              .EN_ECC_WR_A("FALSE"),             // Port A ECC decoder
              .EN_ECC_WR_B("FALSE"),             // Port B ECC decoder
              .IREG_PRE_A("TRUE"),              // Optional Port A input pipeline registers
              .IREG_PRE_B("TRUE"),              // Optional Port B input pipeline registers
              .IS_CLK_INVERTED(1'b0),            // Optional inverter for CLK
              .IS_EN_A_INVERTED(1'b0),           // Optional inverter for Port A enable
              .IS_EN_B_INVERTED(1'b0),           // Optional inverter for Port B enable
              .IS_RDB_WR_A_INVERTED(1'b0),       // Optional inverter for Port A read/write select
              .IS_RDB_WR_B_INVERTED(1'b0),       // Optional inverter for Port B read/write select
              .IS_RST_A_INVERTED(1'b0),          // Optional inverter for Port A reset
              .IS_RST_B_INVERTED(1'b0),          // Optional inverter for Port B reset
              .OREG_A("TRUE"),                  // Optional Port A output pipeline registers
              .OREG_B("TRUE"),                  // Optional Port B output pipeline registers
              .OREG_ECC_A("FALSE"),              // Port A ECC decoder output
              .OREG_ECC_B("FALSE"),              // Port B output ECC decoder
              .REG_CAS_A("FALSE"),               // Optional Port A cascade register
              .REG_CAS_B("FALSE"),               // Optional Port B cascade register
              .RST_MODE_A("SYNC"),               // Port A reset mode
              .RST_MODE_B("SYNC"),               // Port B reset mode
              .SELF_ADDR_A(11'h000),             // Port A self-address value
              .SELF_ADDR_B(11'h000),             // Port B self-address value
              .SELF_MASK_A(addr_mask),             // Port A self-address mask
              .SELF_MASK_B(addr_mask),             // Port B self-address mask
              .USE_EXT_CE_A("FALSE"),            // Enable Port A external CE inputs for output registers
              .USE_EXT_CE_B("FALSE")             // Enable Port B external CE inputs for output registers
           )
           URAM288_inst (
              .CAS_OUT_ADDR_A(CAS_ADDR_A[i + 1]),         // 23-bit output: Port A cascade output address
              .CAS_OUT_ADDR_B(CAS_ADDR_B[i + 1]),         // 23-bit output: Port B cascade output address
              .CAS_OUT_BWE_A(CAS_BWE_A[i + 1]),           // 9-bit output: Port A cascade Byte-write enable output
              .CAS_OUT_BWE_B(CAS_BWE_B[i + 1]),           // 9-bit output: Port B cascade Byte-write enable output
              .CAS_OUT_DBITERR_A(CAS_DBITERR_A[i + 1]),   // 1-bit output: Port A cascade double-bit error flag output
              .CAS_OUT_DBITERR_B(CAS_DBITERR_B[i + 1]),   // 1-bit output: Port B cascade double-bit error flag output
              .CAS_OUT_DIN_A(CAS_DIN_A[i + 1]),           // 72-bit output: Port A cascade output write mode data
              .CAS_OUT_DIN_B(CAS_DIN_B[i + 1]),           // 72-bit output: Port B cascade output write mode data
              .CAS_OUT_DOUT_A(CAS_DOUT_A[i + 1]),         // 72-bit output: Port A cascade output read mode data
              .CAS_OUT_DOUT_B(CAS_DOUT_B[i + 1]),         // 72-bit output: Port B cascade output read mode data
              .CAS_OUT_EN_A(CAS_EN_A[i + 1]),             // 1-bit output: Port A cascade output enable
              .CAS_OUT_EN_B(CAS_EN_B[i + 1]),             // 1-bit output: Port B cascade output enable
              .CAS_OUT_RDACCESS_A(CAS_RDACCESS_A[i + 1]), // 1-bit output: Port A cascade read status output
              .CAS_OUT_RDACCESS_B(CAS_RDACCESS_B[i + 1]), // 1-bit output: Port B cascade read status output
              .CAS_OUT_RDB_WR_A(CAS_RDB_WR_A[i + 1]),     // 1-bit output: Port A cascade read/write select output
              .CAS_OUT_RDB_WR_B(CAS_RDB_WR_B[i + 1]),     // 1-bit output: Port B cascade read/write select output
              .CAS_OUT_SBITERR_A(CAS_SBITERR_A[i + 1]),   // 1-bit output: Port A cascade single-bit error flag output
              .CAS_OUT_SBITERR_B(CAS_SBITERR_B[i + 1]),   // 1-bit output: Port B cascade single-bit error flag output
              .ADDR_A(ADDR_A),                         // 23-bit input: Port A address
              .ADDR_B(ADDR_B),                         // 23-bit input: Port B address
              .BWE_A(BWE_A),                           // 9-bit input: Port A Byte-write enable
              .BWE_B(BWE_B),                           // 9-bit input: Port B Byte-write enable
              .CAS_IN_ADDR_A(CAS_ADDR_A[i]),           // 23-bit input: Port A cascade input address
              .CAS_IN_ADDR_B(CAS_ADDR_B[i]),           // 23-bit input: Port B cascade input address
              .CAS_IN_BWE_A(CAS_BWE_A[i]),             // 9-bit input: Port A cascade Byte-write enable input
              .CAS_IN_BWE_B(CAS_BWE_B[i]),             // 9-bit input: Port B cascade Byte-write enable input
              .CAS_IN_DBITERR_A(CAS_DBITERR_A[i]),     // 1-bit input: Port A cascade double-bit error flag input
              .CAS_IN_DBITERR_B(CAS_DBITERR_B[i]),     // 1-bit input: Port B cascade double-bit error flag input
              .CAS_IN_DIN_A(CAS_DIN_A[i]),             // 72-bit input: Port A cascade input write mode data
              .CAS_IN_DIN_B(CAS_DIN_B[i]),             // 72-bit input: Port B cascade input write mode data
              .CAS_IN_DOUT_A(CAS_DOUT_A[i]),           // 72-bit input: Port A cascade input read mode data
              .CAS_IN_DOUT_B(CAS_DOUT_B[i]),           // 72-bit input: Port B cascade input read mode data
              .CAS_IN_EN_A(CAS_EN_A[i]),               // 1-bit input: Port A cascade enable input
              .CAS_IN_EN_B(CAS_EN_B[i]),               // 1-bit input: Port B cascade enable input
              .CAS_IN_RDACCESS_A(CAS_RDACCESS_A[i]),   // 1-bit input: Port A cascade read status input
              .CAS_IN_RDACCESS_B(CAS_RDACCESS_B[i]),   // 1-bit input: Port B cascade read status input
              .CAS_IN_RDB_WR_A(CAS_RDB_WR_A[i]),       // 1-bit input: Port A cascade read/write select input
              .CAS_IN_RDB_WR_B(CAS_RDB_WR_B[i]),       // 1-bit input: Port B cascade read/write select input
              .CAS_IN_SBITERR_A(CAS_SBITERR_A[i]),     // 1-bit input: Port A cascade single-bit error flag input
              .CAS_IN_SBITERR_B(CAS_SBITERR_B[i]),     // 1-bit input: Port B cascade single-bit error flag input
              .CLK(clk),                               // 1-bit input: Clock source
              .DIN_A(DIN_A),                           // 72-bit input: Port A write data input
              .DIN_B(DIN_B),                           // 72-bit input: Port B write data input
              .EN_A(EN_A),                             // 1-bit input: Port A enable
              .EN_B(EN_B),                             // 1-bit input: Port B enable
              .INJECT_DBITERR_A(1'b0),     // 1-bit input: Port A double-bit error injection
              .INJECT_DBITERR_B(1'b0),     // 1-bit input: Port B double-bit error injection
              .INJECT_SBITERR_A(1'b0),     // 1-bit input: Port A single-bit error injection
              .INJECT_SBITERR_B(1'b0),     // 1-bit input: Port B single-bit error injection
              .OREG_CE_A(1'b1),                   // 1-bit input: Port A output register clock enable
              .OREG_CE_B(1'b1),                   // 1-bit input: Port B output register clock enable
              .OREG_ECC_CE_A(1'b1),           // 1-bit input: Port A ECC decoder output register clock enable
              .OREG_ECC_CE_B(1'b1),           // 1-bit input: Port B ECC decoder output register clock enable
              .RDB_WR_A(RDB_WR_A),                     // 1-bit input: Port A read/write select
              .RDB_WR_B(RDB_WR_B),                     // 1-bit input: Port B read/write select
              .RST_A(CAS_RST[i]),                           // 1-bit input: Port A asynchronous or synchronous reset for
                                                       // output registers
        
              .RST_B(CAS_RST[i]),                           // 1-bit input: Port B asynchronous or synchronous reset for
                                                       // output registers
        
              .SLEEP(1'b0)                            // 1-bit input: Dynamic power gating control
           );
        
        end
        else if (i == cascade_level - 1) begin
            URAM288 #(
              .AUTO_SLEEP_LATENCY(8),            // Latency requirement to enter sleep mode
              .AVG_CONS_INACTIVE_CYCLES(10),     // Average consecutive inactive cycles when is SLEEP mode for power
                                                 // estimation
              .BWE_MODE_A("PARITY_INDEPENDENT"), // Port A Byte write control
              .BWE_MODE_B("PARITY_INDEPENDENT"), // Port B Byte write control
              .CASCADE_ORDER_A("LAST"),          // Port A position in cascade chain
              .CASCADE_ORDER_B("LAST"),          // Port B position in cascade chain
              .EN_AUTO_SLEEP_MODE("FALSE"),      // Enable to automatically enter sleep mode
              .EN_ECC_RD_A("FALSE"),             // Port A ECC encoder
              .EN_ECC_RD_B("FALSE"),             // Port B ECC encoder
              .EN_ECC_WR_A("FALSE"),             // Port A ECC decoder
              .EN_ECC_WR_B("FALSE"),             // Port B ECC decoder
              .IREG_PRE_A("FALSE"),              // Optional Port A input pipeline registers
              .IREG_PRE_B("FALSE"),              // Optional Port B input pipeline registers
              .IS_CLK_INVERTED(1'b0),            // Optional inverter for CLK
              .IS_EN_A_INVERTED(1'b0),           // Optional inverter for Port A enable
              .IS_EN_B_INVERTED(1'b0),           // Optional inverter for Port B enable
              .IS_RDB_WR_A_INVERTED(1'b0),       // Optional inverter for Port A read/write select
              .IS_RDB_WR_B_INVERTED(1'b0),       // Optional inverter for Port B read/write select
              .IS_RST_A_INVERTED(1'b0),          // Optional inverter for Port A reset
              .IS_RST_B_INVERTED(1'b0),          // Optional inverter for Port B reset
              .OREG_A("TRUE"),                  // Optional Port A output pipeline registers
              .OREG_B("TRUE"),                  // Optional Port B output pipeline registers
              .OREG_ECC_A("FALSE"),              // Port A ECC decoder output
              .OREG_ECC_B("FALSE"),              // Port B output ECC decoder
              .REG_CAS_A("TRUE"),               // Optional Port A cascade register
              .REG_CAS_B("TRUE"),               // Optional Port B cascade register
              .RST_MODE_A("SYNC"),               // Port A reset mode
              .RST_MODE_B("SYNC"),               // Port B reset mode
              .SELF_ADDR_A(i),             // Port A self-address value
              .SELF_ADDR_B(i),             // Port B self-address value
              .SELF_MASK_A(addr_mask),             // Port A self-address mask
              .SELF_MASK_B(addr_mask),             // Port B self-address mask
              .USE_EXT_CE_A("FALSE"),            // Enable Port A external CE inputs for output registers
              .USE_EXT_CE_B("FALSE")             // Enable Port B external CE inputs for output registers
           )
           URAM288_inst (
              .CAS_OUT_ADDR_A(CAS_ADDR_A[i + 1]),         // 23-bit output: Port A cascade output address
              .CAS_OUT_ADDR_B(CAS_ADDR_B[i + 1]),         // 23-bit output: Port B cascade output address
              .CAS_OUT_BWE_A(CAS_BWE_A[i + 1]),           // 9-bit output: Port A cascade Byte-write enable output
              .CAS_OUT_BWE_B(CAS_BWE_B[i + 1]),           // 9-bit output: Port B cascade Byte-write enable output
              .CAS_OUT_DBITERR_A(CAS_DBITERR_A[i + 1]),   // 1-bit output: Port A cascade double-bit error flag output
              .CAS_OUT_DBITERR_B(CAS_DBITERR_B[i + 1]),   // 1-bit output: Port B cascade double-bit error flag output
              .CAS_OUT_DIN_A(CAS_DIN_A[i + 1]),           // 72-bit output: Port A cascade output write mode data
              .CAS_OUT_DIN_B(CAS_DIN_B[i + 1]),           // 72-bit output: Port B cascade output write mode data
              .CAS_OUT_DOUT_A(CAS_DOUT_A[i + 1]),         // 72-bit output: Port A cascade output read mode data
              .CAS_OUT_DOUT_B(CAS_DOUT_B[i + 1]),         // 72-bit output: Port B cascade output read mode data
              .CAS_OUT_EN_A(CAS_EN_A[i + 1]),             // 1-bit output: Port A cascade output enable
              .CAS_OUT_EN_B(CAS_EN_B[i + 1]),             // 1-bit output: Port B cascade output enable
              .CAS_OUT_RDACCESS_A(CAS_RDACCESS_A[i + 1]), // 1-bit output: Port A cascade read status output
              .CAS_OUT_RDACCESS_B(CAS_RDACCESS_B[i + 1]), // 1-bit output: Port B cascade read status output
              .CAS_OUT_RDB_WR_A(CAS_RDB_WR_A[i + 1]),     // 1-bit output: Port A cascade read/write select output
              .CAS_OUT_RDB_WR_B(CAS_RDB_WR_B[i + 1]),     // 1-bit output: Port B cascade read/write select output
              .CAS_OUT_SBITERR_A(CAS_SBITERR_A[i + 1]),   // 1-bit output: Port A cascade single-bit error flag output
              .CAS_OUT_SBITERR_B(CAS_SBITERR_B[i + 1]),   // 1-bit output: Port B cascade single-bit error flag output
              .DOUT_A(DOUT_A),                         // 72-bit output: Port A read data output
              .DOUT_B(DOUT_B),                         // 72-bit output: Port B read data output
              .RDACCESS_A(RDACCESS_A),                 // 1-bit output: Port A read status
              .RDACCESS_B(RDACCESS_B),                 // 1-bit output: Port B read status
              .ADDR_A({23{1'b1}}),                         // 23-bit input: Port A address
              .ADDR_B({23{1'b1}}),                         // 23-bit input: Port B address
              .BWE_A({9{1'b1}}),                           // 9-bit input: Port A Byte-write enable
              .BWE_B({9{1'b1}}),                           // 9-bit input: Port B Byte-write enable
              .CAS_IN_ADDR_A(CAS_ADDR_A[i]),           // 23-bit input: Port A cascade input address
              .CAS_IN_ADDR_B(CAS_ADDR_B[i]),           // 23-bit input: Port B cascade input address
              .CAS_IN_BWE_A(CAS_BWE_A[i]),             // 9-bit input: Port A cascade Byte-write enable input
              .CAS_IN_BWE_B(CAS_BWE_B[i]),             // 9-bit input: Port B cascade Byte-write enable input
              .CAS_IN_DBITERR_A(CAS_DBITERR_A[i]),     // 1-bit input: Port A cascade double-bit error flag input
              .CAS_IN_DBITERR_B(CAS_DBITERR_B[i]),     // 1-bit input: Port B cascade double-bit error flag input
              .CAS_IN_DIN_A(CAS_DIN_A[i]),             // 72-bit input: Port A cascade input write mode data
              .CAS_IN_DIN_B(CAS_DIN_B[i]),             // 72-bit input: Port B cascade input write mode data
              .CAS_IN_DOUT_A(CAS_DOUT_A[i]),           // 72-bit input: Port A cascade input read mode data
              .CAS_IN_DOUT_B(CAS_DOUT_B[i]),           // 72-bit input: Port B cascade input read mode data
              .CAS_IN_EN_A(CAS_EN_A[i]),               // 1-bit input: Port A cascade enable input
              .CAS_IN_EN_B(CAS_EN_B[i]),               // 1-bit input: Port B cascade enable input
              .CAS_IN_RDACCESS_A(CAS_RDACCESS_A[i]),   // 1-bit input: Port A cascade read status input
              .CAS_IN_RDACCESS_B(CAS_RDACCESS_B[i]),   // 1-bit input: Port B cascade read status input
              .CAS_IN_RDB_WR_A(CAS_RDB_WR_A[i]),       // 1-bit input: Port A cascade read/write select input
              .CAS_IN_RDB_WR_B(CAS_RDB_WR_B[i]),       // 1-bit input: Port B cascade read/write select input
              .CAS_IN_SBITERR_A(CAS_SBITERR_A[i]),     // 1-bit input: Port A cascade single-bit error flag input
              .CAS_IN_SBITERR_B(CAS_SBITERR_B[i]),     // 1-bit input: Port B cascade single-bit error flag input
              .CLK(clk),                               // 1-bit input: Clock source
              .DIN_A({72{1'b1}}),                           // 72-bit input: Port A write data input
              .DIN_B({72{1'b1}}),                           // 72-bit input: Port B write data input
              .EN_A(1'b1),                             // 1-bit input: Port A enable
              .EN_B(1'b1),                             // 1-bit input: Port B enable
              .INJECT_DBITERR_A(1'b0),     // 1-bit input: Port A double-bit error injection
              .INJECT_DBITERR_B(1'b0),     // 1-bit input: Port B double-bit error injection
              .INJECT_SBITERR_A(1'b0),     // 1-bit input: Port A single-bit error injection
              .INJECT_SBITERR_B(1'b0),     // 1-bit input: Port B single-bit error injection
              .OREG_CE_A(1'b1),                   // 1-bit input: Port A output register clock enable
              .OREG_CE_B(1'b1),                   // 1-bit input: Port B output register clock enable
              .OREG_ECC_CE_A(1'b1),           // 1-bit input: Port A ECC decoder output register clock enable
              .OREG_ECC_CE_B(1'b1),           // 1-bit input: Port B ECC decoder output register clock enable
              .RDB_WR_A(1'b1),                     // 1-bit input: Port A read/write select
              .RDB_WR_B(1'b1),                     // 1-bit input: Port B read/write select
              .RST_A(CAS_RST[i]),                           // 1-bit input: Port A asynchronous or synchronous reset for
                                                       // output registers
        
              .RST_B(CAS_RST[i]),                           // 1-bit input: Port B asynchronous or synchronous reset for
                                                       // output registers
        
              .SLEEP(1'b0)                            // 1-bit input: Dynamic power gating control
           );
        end
        else begin
            URAM288 #(
              .AUTO_SLEEP_LATENCY(8),            // Latency requirement to enter sleep mode
              .AVG_CONS_INACTIVE_CYCLES(10),     // Average consecutive inactive cycles when is SLEEP mode for power
                                                 // estimation
              .BWE_MODE_A("PARITY_INDEPENDENT"), // Port A Byte write control
              .BWE_MODE_B("PARITY_INDEPENDENT"), // Port B Byte write control
              .CASCADE_ORDER_A("MIDDLE"),          // Port A position in cascade chain
              .CASCADE_ORDER_B("MIDDLE"),          // Port B position in cascade chain
              .EN_AUTO_SLEEP_MODE("FALSE"),      // Enable to automatically enter sleep mode
              .EN_ECC_RD_A("FALSE"),             // Port A ECC encoder
              .EN_ECC_RD_B("FALSE"),             // Port B ECC encoder
              .EN_ECC_WR_A("FALSE"),             // Port A ECC decoder
              .EN_ECC_WR_B("FALSE"),             // Port B ECC decoder
              .IREG_PRE_A("FALSE"),              // Optional Port A input pipeline registers
              .IREG_PRE_B("FALSE"),              // Optional Port B input pipeline registers
              .IS_CLK_INVERTED(1'b0),            // Optional inverter for CLK
              .IS_EN_A_INVERTED(1'b0),           // Optional inverter for Port A enable
              .IS_EN_B_INVERTED(1'b0),           // Optional inverter for Port B enable
              .IS_RDB_WR_A_INVERTED(1'b0),       // Optional inverter for Port A read/write select
              .IS_RDB_WR_B_INVERTED(1'b0),       // Optional inverter for Port B read/write select
              .IS_RST_A_INVERTED(1'b0),          // Optional inverter for Port A reset
              .IS_RST_B_INVERTED(1'b0),          // Optional inverter for Port B reset
              .OREG_A("TRUE"),                  // Optional Port A output pipeline registers
              .OREG_B("TRUE"),                  // Optional Port B output pipeline registers
              .OREG_ECC_A("FALSE"),              // Port A ECC decoder output
              .OREG_ECC_B("FALSE"),              // Port B output ECC decoder
              .REG_CAS_A("TRUE"),               // Optional Port A cascade register
              .REG_CAS_B("TRUE"),               // Optional Port B cascade register
              .RST_MODE_A("SYNC"),               // Port A reset mode
              .RST_MODE_B("SYNC"),               // Port B reset mode
              .SELF_ADDR_A(i),             // Port A self-address value
              .SELF_ADDR_B(i),             // Port B self-address value
              .SELF_MASK_A(addr_mask),             // Port A self-address mask
              .SELF_MASK_B(addr_mask),             // Port B self-address mask
              .USE_EXT_CE_A("FALSE"),            // Enable Port A external CE inputs for output registers
              .USE_EXT_CE_B("FALSE")             // Enable Port B external CE inputs for output registers
           )
           URAM288_inst (
              .CAS_OUT_ADDR_A(CAS_ADDR_A[i + 1]),         // 23-bit output: Port A cascade output address
              .CAS_OUT_ADDR_B(CAS_ADDR_B[i + 1]),         // 23-bit output: Port B cascade output address
              .CAS_OUT_BWE_A(CAS_BWE_A[i + 1]),           // 9-bit output: Port A cascade Byte-write enable output
              .CAS_OUT_BWE_B(CAS_BWE_B[i + 1]),           // 9-bit output: Port B cascade Byte-write enable output
              .CAS_OUT_DBITERR_A(CAS_DBITERR_A[i + 1]),   // 1-bit output: Port A cascade double-bit error flag output
              .CAS_OUT_DBITERR_B(CAS_DBITERR_B[i + 1]),   // 1-bit output: Port B cascade double-bit error flag output
              .CAS_OUT_DIN_A(CAS_DIN_A[i + 1]),           // 72-bit output: Port A cascade output write mode data
              .CAS_OUT_DIN_B(CAS_DIN_B[i + 1]),           // 72-bit output: Port B cascade output write mode data
              .CAS_OUT_DOUT_A(CAS_DOUT_A[i + 1]),         // 72-bit output: Port A cascade output read mode data
              .CAS_OUT_DOUT_B(CAS_DOUT_B[i + 1]),         // 72-bit output: Port B cascade output read mode data
              .CAS_OUT_EN_A(CAS_EN_A[i + 1]),             // 1-bit output: Port A cascade output enable
              .CAS_OUT_EN_B(CAS_EN_B[i + 1]),             // 1-bit output: Port B cascade output enable
              .CAS_OUT_RDACCESS_A(CAS_RDACCESS_A[i + 1]), // 1-bit output: Port A cascade read status output
              .CAS_OUT_RDACCESS_B(CAS_RDACCESS_B[i + 1]), // 1-bit output: Port B cascade read status output
              .CAS_OUT_RDB_WR_A(CAS_RDB_WR_A[i + 1]),     // 1-bit output: Port A cascade read/write select output
              .CAS_OUT_RDB_WR_B(CAS_RDB_WR_B[i + 1]),     // 1-bit output: Port B cascade read/write select output
              .CAS_OUT_SBITERR_A(CAS_SBITERR_A[i + 1]),   // 1-bit output: Port A cascade single-bit error flag output
              .CAS_OUT_SBITERR_B(CAS_SBITERR_B[i + 1]),   // 1-bit output: Port B cascade single-bit error flag output
              .ADDR_A({23{1'b1}}),                         // 23-bit input: Port A address
              .ADDR_B({23{1'b1}}),                         // 23-bit input: Port B address
              .BWE_A({9{1'b1}}),                           // 9-bit input: Port A Byte-write enable
              .BWE_B({9{1'b1}}),                           // 9-bit input: Port B Byte-write enable
              .CAS_IN_ADDR_A(CAS_ADDR_A[i]),           // 23-bit input: Port A cascade input address
              .CAS_IN_ADDR_B(CAS_ADDR_B[i]),           // 23-bit input: Port B cascade input address
              .CAS_IN_BWE_A(CAS_BWE_A[i]),             // 9-bit input: Port A cascade Byte-write enable input
              .CAS_IN_BWE_B(CAS_BWE_B[i]),             // 9-bit input: Port B cascade Byte-write enable input
              .CAS_IN_DBITERR_A(CAS_DBITERR_A[i]),     // 1-bit input: Port A cascade double-bit error flag input
              .CAS_IN_DBITERR_B(CAS_DBITERR_B[i]),     // 1-bit input: Port B cascade double-bit error flag input
              .CAS_IN_DIN_A(CAS_DIN_A[i]),             // 72-bit input: Port A cascade input write mode data
              .CAS_IN_DIN_B(CAS_DIN_B[i]),             // 72-bit input: Port B cascade input write mode data
              .CAS_IN_DOUT_A(CAS_DOUT_A[i]),           // 72-bit input: Port A cascade input read mode data
              .CAS_IN_DOUT_B(CAS_DOUT_B[i]),           // 72-bit input: Port B cascade input read mode data
              .CAS_IN_EN_A(CAS_EN_A[i]),               // 1-bit input: Port A cascade enable input
              .CAS_IN_EN_B(CAS_EN_B[i]),               // 1-bit input: Port B cascade enable input
              .CAS_IN_RDACCESS_A(CAS_RDACCESS_A[i]),   // 1-bit input: Port A cascade read status input
              .CAS_IN_RDACCESS_B(CAS_RDACCESS_B[i]),   // 1-bit input: Port B cascade read status input
              .CAS_IN_RDB_WR_A(CAS_RDB_WR_A[i]),       // 1-bit input: Port A cascade read/write select input
              .CAS_IN_RDB_WR_B(CAS_RDB_WR_B[i]),       // 1-bit input: Port B cascade read/write select input
              .CAS_IN_SBITERR_A(CAS_SBITERR_A[i]),     // 1-bit input: Port A cascade single-bit error flag input
              .CAS_IN_SBITERR_B(CAS_SBITERR_B[i]),     // 1-bit input: Port B cascade single-bit error flag input
              .CLK(clk),                               // 1-bit input: Clock source
              .DIN_A({72{1'b1}}),                           // 72-bit input: Port A write data input
              .DIN_B({72{1'b1}}),                           // 72-bit input: Port B write data input
              .EN_A(1'b1),                             // 1-bit input: Port A enable
              .EN_B(1'b1),                             // 1-bit input: Port B enable
              .INJECT_DBITERR_A(1'b0),     // 1-bit input: Port A double-bit error injection
              .INJECT_DBITERR_B(1'b0),     // 1-bit input: Port B double-bit error injection
              .INJECT_SBITERR_A(1'b0),     // 1-bit input: Port A single-bit error injection
              .INJECT_SBITERR_B(1'b0),     // 1-bit input: Port B single-bit error injection
              .OREG_CE_A(1'b1),                   // 1-bit input: Port A output register clock enable
              .OREG_CE_B(1'b1),                   // 1-bit input: Port B output register clock enable
              .OREG_ECC_CE_A(1'b1),           // 1-bit input: Port A ECC decoder output register clock enable
              .OREG_ECC_CE_B(1'b1),           // 1-bit input: Port B ECC decoder output register clock enable
              .RDB_WR_A(1'b1),                     // 1-bit input: Port A read/write select
              .RDB_WR_B(1'b1),                     // 1-bit input: Port B read/write select
              .RST_A(CAS_RST[i]),                           // 1-bit input: Port A asynchronous or synchronous reset for
                                                       // output registers
        
              .RST_B(CAS_RST[i]),                           // 1-bit input: Port B asynchronous or synchronous reset for
                                                       // output registers
        
              .SLEEP(1'b0)                            // 1-bit input: Dynamic power gating control
           );
        end
   end
   endgenerate
仿真

  对于级联后URAM的使用方法可参考仿真文件激励的使用过程。

`timescale 1ns / 1ps
//
// Company: 
// Engineer: wjh776a68
// 
// Create Date: 03/23/2023 11:50:49 AM
// Design Name: 
// Module Name: uram72_tb
// Project Name: 
// Target Devices: XCVU37P
// Tool Versions: 2022.2
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module uram72_tb(

    );
    logic  clk;
    logic  [71:0] DOUT_A;
    logic  [71:0] DOUT_B;
    logic         RDACCESS_A;
    logic         RDACCESS_B;
    logic  [22:0] ADDR_A;
    logic  [22:0] ADDR_B;
    logic  [8:0]  BWE_A;
    logic  [8:0]  BWE_B;
    logic  [71:0] DIN_A;
    logic  [71:0] DIN_B;
    logic         RDB_WR_A;
    logic         RDB_WR_B;
    logic rst;
    initial begin
        clk = 0;
        forever #1 clk = ~clk;
    end

    initial begin
        rst <= 1;
        repeat(2) @(posedge clk);
        rst <= 0;
        RDB_WR_A <= 0;
        RDB_WR_B <= 0;
        ADDR_A <= 0;
        ADDR_B <= 0;
        BWE_A <= 0;
        BWE_B <= 0;
        @(posedge clk);
        @(posedge RDACCESS_A);
        ADDR_A <= 23'h000f00;
        DIN_A <= 72'h121112111211121121;
        DIN_B <= 72'h121112111211121121;
        BWE_A <= 'b111111111;
        BWE_B <= 0;
        RDB_WR_A <= 1;
        @(posedge clk);
        RDB_WR_A <= 0;
        ADDR_B <= 23'h100;
        @(posedge clk);

    end

    uram72 uram72_inst (
        clk,
        DOUT_A,
        DOUT_B,
        RDACCESS_A,
        RDACCESS_B,
        ADDR_A,
        ADDR_B,
        BWE_A,
        BWE_B,
        DIN_A,
        DIN_B,
        RDB_WR_A,
        RDB_WR_B,
        
        rst
    );
endmodule

完整代码可从公众号回复URAM下载。

参考链接

UltraScale Architecture Memory Resources User Guide (UG573)

wjh776a68
关注
  • 44
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
URAM使用说明：xpm_memory_tdpram 原语调用 uram
qq_63346357的博客
10-10 1250
uram调用和相关参数说明
Xilinx UltraScale 架构 SelectIO 资源英文手册
01-08
Xilinx Xilinx UltraScale 架构 SelectIO 资源英文手册（UltraScale Architecture SelectIO Resources v1.15），包括功能介绍、IP核配置简介、内部逻辑接口、引脚端口的使用方法等
BRAM 和 URAM 大小
justdemo的博客
03-19 2214
先说结论 ZU4EV 中 BRAM 4.5Mbits = 128 * 36Kbits URAM 13.5Mbits = 48 * 288Kbits 来源如下 根据 ug573-ultrascale-memory-resources.pdf The block RAM features include: • Per-block memory storage capability where each block RAM can store up to 36 Kbits of data. • Support
Xilinx UltraScale内存资源英文手册（ug573）
01-08
Xilinx UltraScale内存资源英文手册（UltraScale Architecture Memory Resources User Guide），包含对UltraScale系列芯片片上BRAM、URAM资源的功能介绍、结构简图、引脚说明等
BRAM与URAM在verilog设计中的应用
Lily4801的博客
11-01 311
Xilinx7系列FPGA中的块RAM可存储36 Kb的数据，可以配置为两个独立的18 Kb RAM或一个36 Kb RAM。在简单双端口模式下，每个36 Kb块RAM可以配置为64K x 1（与相邻的36 Kb块内存级联时）、32K x 1、16K x 2、8K x 4、4K x 9、2K x 18、1K x 36或512 x 72。在简单双端口模式下，每个18 Kb块RAM可以配置为16K x 1、8K x2、4K x 4、2K x 9、1K x 18或512 x 36。
BRAM/URAM资源介绍
captain
09-06 3566
Bram是FPGA中常见的一种RAM资源，其优势、劣势和使用场景如下：速度快：Bram通常具有较高的读写速度，对于需要频繁读写数据的应用非常适用。稳定性高：由于Bram是专门的RAM模块，其具有较高的稳定性和可靠性，不会因为FPGA内部电路的变化而出现误码。面积小：Bram比其他存储器更小，且可以在FPGA片内自定义存储器大小以满足应用需求。低功耗：由于Bram是基于FPGA片内元素的存储器，因此功耗较低。容量限制：Bram容量通常在几KB到几十KB之间，无法满足大量数据存储的需求。
DDR、Flash、Ram、Rom的区别
h_8410435的博客
09-29 1万+
内存和硬盘的区别 一、定义 内存：内存又称主存，计算机中的程序的运行都是在内存中进行的，只有计算机在运行，计算机CPU就会把需要的计算数据调到内存中进行运算。通常内存分为随机存储器（RAM）、只读存储器（ROM）、高速缓存（CACHE）。 硬盘：从计算机的结构体系来讲，硬盘应该算是计算机的“外存”。 二、内存和硬盘的区别 内存和硬盘的主要区别，主要为以下三点： 1、内存是计算机运行的场所，硬盘用...
XILINX UltraScale+系列FPGA/SoC中的UltraRAM
jiang1960034308的博客
05-23 9701
UltraRAM的简单介绍与测试
如何使用UltraScale+芯片中UltraRam资源
BIGMAC的博客
10-10 3155
本文介绍如何使用Xilinx UltraScale+芯片中UltraRam资源
Vivado中URAM通过XPM例化
qq_40015999的博客
03-26 239
Xilinx Ultrascale系列FPGA包含URAM资源，在Vivado IP Catalog中无法通过GUI方式对URAM进行例化，下面是通过XPM例化一个真双口URAM，PortA和PortB使用同一时钟，地址位宽12bit，数据位宽256bit，深度为3072，内存容量为1048576bit，字节写使能为32bit。
Vivado的XPM在modelism中仿真时例化failed的问题。
kimi169的专栏
08-09 4419
写下第一篇技术blog，学习以及记录。 1. 问题 RT，工程中使用URAM，通过XPM的方式例化完成，仿真时问题来了，遇到如下图所示的错误： 找不到该模块，是因为已经编译添加的xilinxIP库文件中没有这玩意儿。 2. 解决方法 于是搜索xilinx/vivado/data/ip目录： 找到了xpm_memory.sv，添加这个文件到work library下面，使用mod...
基于UltraScale 架构的FPGA配置方法及实现
01-12
针对基于UltraScale架构FPGA，本文分析了其配置模式、配置过程，介绍了两种应用案例中的设计方案和硬件连接图，并分别采用主BPI和从SelectMAP两种方法在通用信号处理系统上完成了验证。目前该技术已在航空电子领域多...
pg150-ultrascale-memory-ip.pdf
07-14
Xilinx pg150-ultrascale-memory-ip官方文档，可参考DDR3，DDR4得相关设计说明及时序，有助于对DDR得理解。
Xilinx Zynq UltraScale+ MPSoC ZCU106-硬件开发文档类资源--完整版.zip
09-14
Xilinx Zynq UltraScale+ MPSoC ZCU102开发板的最新PCB、原理图、BOM单、约束文件...本博客文章”Zynq Ultrascale+ MPSOC硬件开发之与Zynq7000芯片资源对比说明及开发资料介绍“内有资源详细介绍以及免费下载方式。
使用fifo时，如何选择dram、bram及uram资源配置
m0_64935294的博客
10-27 663
使用fifo时，如何选择dram、bram及uram资源配置
Xilinx Vivado的使用详细介绍（3）：使用IP核
热门推荐
jzj1993的专栏
05-06 1万+
IP核（IP Core） Vivado中有很多IP核可以直接使用，例如数学运算（乘法器、除法器、浮点运算器等）、信号处理（FFT、DFT、DDS等）。IP核类似编程中的函数库（例如C语言中的printf()函数），可以直接调用，非常方便，大大加快了开发速度。 使用Verilog调用IP核 这里简单举一个乘法器的IP核使用实例，使用Verilog调用。首先新建工程，新建demo.v
ROM、RAM、IROM、IRAM、DRAM、SRAM、Flash
一万HOURS的知识库
08-31 1万+
1 ROM 、RAM、IROM、IRAMROM：read only memory 只读存储器ROM是指程序运行的过程中不能直接通过数据总线、地址总线进行数据的写操作，必须借助于相关的控制器接口来进行数据的写操作。RAM：ramdom access memory 随机访问存储器IROM：internal rom 内部ROM，指的是集成到SoC内部的ROMIRAM：internal ram 内部RAM，
UltraRAM：在UltraScale+器件上集成嵌入式存储器
一个早起的程序员
01-09 2510
UltraScale+ 系列中的新产品是一款容量更大的称为 UltraRAM 的灵活存储器模块。 UltraRAM 模块可级联在一起构成更大的片上存储器。在设计中使用 UltraRAM 很简单，因为赛灵思提供了所有必要工具，利用这些工具可以在设计中集成功能强大的最新模块。 缓冲与存储的需求增加 UltraScale+FPGA 和 MPSoC 能够传输和处理的数据比前一代器件多得多。最大的 V...
URAM288_BASE
最新发布
03-30
URAM288_BASE是一种存储器技术，它是一种高性能的存储器模块。URAM代表Ultra RAM，是一种专用于FPGA（现场可编程门阵列）的存储器类型。URAM288_BASE是URAM的一种规格，表示该模块具有288个存储单元。 URAM288_BASE具有以下特点： 1. 高性能：URAM288_BASE具有非常快的读写速度和低延迟，适用于对存储器性能要求较高的应用场景。 2. 大容量：每个URAM288_BASE模块具有288个存储单元，每个存储单元的容量可以根据具体的FPGA型号而定，通常可以达到几十KB甚至更大。 3. 可编程性：URAM288_BASE可以通过FPGA的编程接口进行配置和控制，可以根据应用需求进行灵活的使用和管理。 4. 低功耗：URAM288_BASE在提供高性能的同时，也具有较低的功耗特性，有助于提高系统的能效。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wjh776a68

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

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

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

打赏作者

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

抵扣说明：

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

余额充值