问题描述
我想将我的地址限制在Packet类中，这样
- addr非0
- 地址是单词对齐的
addr是32位向量的32位解压缩数组，在Packet类中声明为
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]
# 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];
这样，即使约束不能解决该范围内的一个或两个地址，我也可以得到更大范围的地址值。 然后在我的Driver类中，我声明了一个数组
bit [31:0] addr [16];
和一个队列
bit [31:0] q[$];
然后将数据包地址复制到Driver类addr
foreach(p.addr[i])
addr[i] = p.addr[i];
然后将此本地数组复制到队列中，以获取项！= 0
foreach(addr[i])
q = addr.find with (item != 32'b0);
最后在开始任务时，我做了q.pop_front 4次
@(posedge ipif.clk)
memif.mem_data <= q.pop_front;
因此，分组地址的输出显示和队列的输出为
# 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