Random 如何约束非零值的字对齐地址？

我想在Packet类中约束我的地址，以便

addr不是0

addr是单词对齐的

addr是32位向量的32位未打包数组，它在数据包类中声明为

class Packet;
    
    rand bit [31:0] dest_addr;
    rand bit [31:0] source_addr;
    rand bit [7:0] data_length;
    rand byte data[];
    rand byte fcs;
    rand bit [31:0] addr [0:3];
    string name;
    rand bit [28:0] n;
    rand bit [3:0] test;
    static int count;
        
    rand da_kind_t da_kind;
    rand fcs_kind_t fcs_kind;
    rand length_kind_t length_kind;
  
   constraint c_n {
    n != 0;
  }
      
    //Word alignment constraint 
    constraint c_addr {
      foreach(addr[i]) 
        addr[i] == 4*n; 
    }

出现以下错误消息：

Driver_mem.sv(20): randomize() failed due to conflicts between the following constraints:
#   Packet.sv(29): c_n { (n != 0); }
# Where:
#   n = 29'h00000000 /* non-random */ 
# ** Note: (vsim-7130) Enabling enhanced debug (-solvefaildebug=2) may generate a more descriptive constraint contradiction report.
#    Time: 0 ps  Iteration: 2  Instance: /tb_router/test
# ** Note: (vsim-7106) Use vsim option '-solvefailtestcase[=filename]' to generate a simplified testcase that will reproduce the failure.
#    Time: 0 ps  Iteration: 2  Instance: /tb_router/test

但是，约束解析程序失败。我也尝试过这些方法，但也失败了

constraint c_addr {
    foreach(addr[i])
        addr[i][31:2] != 0;
        addr[i][1:0] == 0;
}

这种方法也失败了

constraint c_addr {
   addr[0] > 0;
   addr[1] > 0;
   addr[2] > 0;
   addr[3] > 0;
}

constraint c_addr1 {
   foreach(addr[i])
      addr[i][1:0] == 0;
}

使用输出消息：

Driver_mem.sv(20): randomize() failed due to conflicts between the following constraints:
#   Packet.sv(23): c_addr { (addr[0] > 0); }
#   Packet.sv(24): c_addr { (addr[1] > 0); }
#   Packet.sv(25): c_addr { (addr[2] > 0); }
#   Packet.sv(26): c_addr { (addr[3] > 0); }
#   Packet.sv(31): c_addr1 { (addr[3][1:0] == 0); }
#   Packet.sv(31): c_addr1 { (addr[2][1:0] == 0); }
#   Packet.sv(31): c_addr1 { (addr[1][1:0] == 0); }
#   Packet.sv(31): c_addr1 { (addr[0][1:0] == 0); }
#   Packet.sv(97): c_dest_addr { (dest_addr inside { addr[3], addr[2], addr[1], addr[0] }); }
# Where:
#   addr[0][1:0] = 2'h0
#   addr[1][1:0] = 2'h0
#   addr[2][1:0] = 2'h0
#   addr[3][1:0] = 2'h0
#   dest_addr = 0 /* non-random */ 
# Given:
#   bit [31:0] addr[3]
#   bit [31:0] addr[2]
#   bit [31:0] addr[1]
#   bit [31:0] addr[0]

同样，这4种方法虽然没有失败，但输出如下

# addr0: 0x00000000
# addr1: 0x00000000
# addr2: 0x00000000
# addr3: 0x00000000



//Word alignment constraint 
    constraint c_addr {
      foreach(addr[i]) {
            addr[i][31:2] != 0;
            addr[i][1:0] == 0;  
      }
    }

constraint c_addr0 {
      addr[0] == 4*(n+1);
      addr[1] == 4*(n+2);
      addr[2] == 4*(n+3);
      addr[3] == 4*(n+4);
}

constraint c_addr0 {
      addr[0] == 4*(n+1);
      addr[1] == addr[0] + 4;
      addr[2] == addr[1] + 4;
      addr[3] == addr[2] + 4;     
    }

constraint c_addr0 {
        foreach(addr[i])
          addr[i] == (i+4);
    }

---

该数据包用于1x4路由器验证，要求目标端口的地址必须以非0值的相同方式进行字对齐。感谢您的帮助。另外，请注意，addr只需随机化一次，即一组4个唯一的非0字对齐地址，如果我只提供字对齐约束，我在数组中始终会得到一个addr，即0x00000000。

好吧，我可以通过一些复杂的过程来解决这个问题。但一个更好更简单的方法仍在等待和赞赏。我受到的限制是

constraint c_addrn {
        foreach(addr[i])
          if(i >0)
            addr[i] == addr[i-1] + 4;
    }

首先，我采取了

rand bit [31:0] addr [0:15];

而不是

rand bit [31:0] addr [0:3];

这样，即使约束不能解析范围内的一个或两个地址，我也可以得到更大范围的地址值。 然后在我的驱动程序类中，我声明了一个数组

bit [31:0] addr [16];

还有一个队列

bit [31:0] q[$];

然后将数据包地址复制到驱动程序类addr中

foreach(p.addr[i])
    addr[i] = p.addr[i];
    

并将此本地数组复制到项目队列中！=0

foreach(addr[i])
   q = addr.find with (item != 32'b0);

最后在开始任务时，我做了4次q.pop_front

@(posedge ipif.clk)
memif.mem_data <= q.pop_front;

---

这对我来说是个好消息。也许你的模拟器有一个bug；在EDAPlayde的不同模拟器上尝试您的代码。@toolic我在EDAPlayde的Mentor Questa 1.0上尝试过。

# addr is 0xfffffff8
# addr is 0xfffffffc
# addr is 0x00000000
# addr is 0x00000004
# addr is 0x00000008
# addr is 0x0000000c
# addr is 0x00000010
# addr is 0x00000014
# addr is 0x00000018
# addr is 0x0000001c
# addr is 0x00000020
# addr is 0x00000024
# addr is 0x00000028
# addr is 0x0000002c
# addr is 0x00000030
# addr is 0x00000034



# addr0: 0xfffffff8
# addr1: 0xfffffffc
# addr2: 0x00000004
# addr3: 0x00000008