如何在SystemVerilog中编写满足组合唯一且可重复的数组约束？

原代码的问题 #

你写的约束存在两个核心错误：

1. unique {p[i].A, p[i].B} 的用法错误：该约束会强制每个 p[i] 的 A 和 B 值必须不同，而不是要求 (A,B) 组合在数组中可重复但属于唯一的组合集合。
2. 未处理重复逻辑：原约束没有定义如何让合法的 (A,B) 组合重复指定次数，反而错误地限制了单个元素的 A 和 B 不能相同。

可行解决方案 #

以下是满足需求的两种实现方式，均支持：

• 所有 (A,B) 组合来自指定范围内的唯一集合
• 每个组合可随机重复 1~MAX_REPEAT 次，总元素数匹配数组长度

方式一：使用计数数组（高效且直观）

通过辅助计数数组控制每个唯一组合的重复次数，再约束数组元素符合计数要求：

class PacketGenerator;
    typedef struct packed {
        logic [3:0] A;
        logic [3:0] B;
    } pkt;

    // 可配置参数
    parameter int A_MIN = 0, A_MAX = 1;
    parameter int B_MIN = 0, B_MAX = 2;
    parameter int MAX_REPEAT = 3;
    parameter int ARRAY_SIZE = 10;

    rand pkt p[ARRAY_SIZE];
    rand int repeat_count[];
    pkt unique_pairs[];

    function new();
        int idx = 0;
        // 预先生成所有合法的唯一(A,B)组合
        unique_pairs = new[(A_MAX - A_MIN + 1) * (B_MAX - B_MIN + 1)];
        repeat_count = new[unique_pairs.size()];
        
        for (int a = A_MIN; a <= A_MAX; a++) begin
            for (int b = B_MIN; b <= B_MAX; b++) begin
                unique_pairs[idx] = '{A: a, B: b};
                idx++;
            end
        end
    endfunction

    // 约束每个组合的重复次数在1~MAX_REPEAT之间，且总次数等于数组长度
    constraint repeat_count_constraint {
        foreach (repeat_count[i]) {
            repeat_count[i] inside {[1:MAX_REPEAT]};
        }
        sum(repeat_count) == ARRAY_SIZE;
    }

    // 约束数组元素为合法组合，且每个组合的出现次数匹配repeat_count
    constraint packet_constraint {
        foreach (p[i]) {
            p[i] inside unique_pairs;
        }
        foreach (unique_pairs[j]) {
            p.count(unique_pairs[j]) == repeat_count[j];
        }
    }

    // 打印结果
    function void print_result();
        $write("A = ");
        foreach (p[i]) $write("%0d, ", p[i].A);
        $write("\nB = ");
        foreach (p[i]) $write("%0d, ", p[i].B);
        $display("\n");
    endfunction
endclass

// 测试示例
module test;
    PacketGenerator gen = new();
    initial begin
        repeat(3) begin
            if (gen.randomize()) begin
                gen.print_result();
            end else begin
                $display("随机化失败，请检查参数配置");
            end
        end
    end
endmodule

方式二：直接使用count()约束（简洁但效率稍低）

无需辅助数组，直接通过count()方法约束每个合法组合的出现次数：

class PacketGenerator;
    typedef struct packed {
        logic [3:0] A;
        logic [3:0] B;
    } pkt;

    parameter int A_MIN = 0, A_MAX = 1;
    parameter int B_MIN = 0, B_MAX = 2;
    parameter int MAX_REPEAT = 3;
    parameter int ARRAY_SIZE = 10;

    rand pkt p[ARRAY_SIZE];

    constraint packet_constraint {
        // 约束A和B的取值范围
        foreach (p[i]) {
            p[i].A inside {[A_MIN:A_MAX]};
            p[i].B inside {[B_MIN:B_MAX]};
        }
        // 约束每个合法(A,B)组合的出现次数在1~MAX_REPEAT之间
        for (int a = A_MIN; a <= A_MAX; a++) {
            for (int b = B_MIN; b <= B_MAX; b++) {
                p.count('{A: a, B: b}) inside {[1:MAX_REPEAT]};
            }
        }
    }

    function void print_result();
        $write("A = ");
        foreach (p[i]) $write("%0d, ", p[i].A);
        $write("\nB = ");
        foreach (p[i]) $write("%0d, ", p[i].B);
        $display("\n");
    endfunction
endclass

// 测试示例
module test;
    PacketGenerator gen = new();
    initial begin
        repeat(3) begin
            if (gen.randomize()) begin
                gen.print_result();
            end else begin
                $display("随机化失败，请检查参数配置");
            end
        end
    end
endmodule

关键说明 #

1. 参数配置：可通过修改A_MIN、A_MAX、B_MIN、B_MAX、MAX_REPEAT和ARRAY_SIZE调整取值范围、最大重复次数和数组长度。
2. 随机化合法性：需确保 唯一组合数 ≤ 数组长度 ≤ 唯一组合数 × MAX_REPEAT，否则随机化会失败（例如：6个唯一组合，数组长度10，MAX_REPEAT=3，6≤10≤18，合法）。
3. 随机顺序：两种方式都会随机打乱数组元素的顺序，生成符合要求的随机序列。

内容的提问来源于stack exchange，提问作者vasinator