Quartus II中Verilog快速排序代码报错：终止条件需用常量表达式

错误根源 #

Quartus II作为FPGA综合工具，要求所有循环的终止条件必须是常量表达式——FPGA需要生成固定结构的硬件，无法根据运行时变量动态调整逻辑规模。你代码里的partition函数中for (i = l; i < h; i = i + 1)、qs函数中while (top >= 0)，终止条件都依赖输入变量，属于动态循环，不符合综合规则。换while循环没用，本质不是循环类型的问题，是FPGA对循环确定性的硬性要求。

可行修改方案 #

你的输入是固定的10个数据，完全可以用固定迭代次数的排序逻辑或排序网络实现，这类结构的循环次数是常量，能被综合工具正常处理。以下是两种实用方案：

方案1：固定迭代次数的冒泡排序 #

冒泡排序的循环次数固定为N*(N-1)/2（这里N=10），逻辑简单易综合：

module verilog_qs(
    input  wire clk,
    input  wire [10:0] in1, in2, in3, in4, in5, in6, in7, in8, in9, in10,
    output reg  [10:0] out1, out2, out3, out4, out5, out6, out7, out8, out9, out10
);

    reg [10:0] data [0:9];
    reg [10:0] temp;
    integer i, j;

    always @(posedge clk) begin
        // 加载输入数据
        data[0] = in1;
        data[1] = in2;
        data[2] = in3;
        data[3] = in4;
        data[4] = in5;
        data[5] = in6;
        data[6] = in7;
        data[7] = in8;
        data[8] = in9;
        data[9] = in10;

        // 固定次数的冒泡排序循环
        for (i = 0; i < 9; i = i + 1) begin
            for (j = 0; j < 9 - i; j = j + 1) begin
                if (data[j] > data[j+1]) begin
                    temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                end
            end
        end

        // 输出排序后的数据
        out1 = data[0];
        out2 = data[1];
        out3 = data[2];
        out4 = data[3];
        out5 = data[4];
        out6 = data[5];
        out7 = data[6];
        out8 = data[7];
        out9 = data[8];
        out10 = data[9];
    end

endmodule

方案2：Bitonic排序网络（硬件效率更高） #

Bitonic排序是并行排序结构，固定长度下能生成高效硬件，完全基于组合逻辑的比较交换：

module verilog_qs(
    input  wire clk,
    input  wire [10:0] in1, in2, in3, in4, in5, in6, in7, in8, in9, in10,
    output reg  [10:0] out1, out2, out3, out4, out5, out6, out7, out8, out9, out10
);

    reg [10:0] stage0[0:9];
    reg [10:0] stage1[0:9];
    reg [10:0] stage2[0:9];
    reg [10:0] stage3[0:9];
    reg [10:0] stage4[0:9];

    // 比较交换任务
    task swap;
        inout [10:0] a, b;
        reg [10:0] temp;
        begin
            if (a > b) begin
                temp = a;
                a = b;
                b = temp;
            end
        end
    endtask

    always @(posedge clk) begin
        // 加载输入到第一阶段
        stage0[0] = in1;
        stage0[1] = in2;
        stage0[2] = in3;
        stage0[3] = in4;
        stage0[4] = in5;
        stage0[5] = in6;
        stage0[6] = in7;
        stage0[7] = in8;
        stage0[8] = in9;
        stage0[9] = in10;

        // 阶段1：相邻分组比较交换
        swap(stage0[0], stage0[1]);
        swap(stage0[2], stage0[3]);
        swap(stage0[4], stage0[5]);
        swap(stage0[6], stage0[7]);
        swap(stage0[8], stage0[9]);
        stage1 = stage0;

        // 阶段2：组间交叉比较交换
        swap(stage1[0], stage1[2]);
        swap(stage1[1], stage1[3]);
        swap(stage1[4], stage1[6]);
        swap(stage1[5], stage1[7]);
        swap(stage1[8], stage1[9]);
        stage2 = stage1;

        // 阶段3：大分组比较交换
        swap(stage2[0], stage2[4]);
        swap(stage2[1], stage2[5]);
        swap(stage2[2], stage2[6]);
        swap(stage2[3], stage2[7]);
        swap(stage2[8], stage2[9]);
        stage3 = stage2;

        // 阶段4：最终全局调整
        swap(stage3[0], stage3[1]);
        swap(stage3[2], stage3[3]);
        swap(stage3[4], stage3[5]);
        swap(stage3[6], stage3[7]);
        swap(stage3[0], stage3[2]);
        swap(stage3[1], stage3[3]);
        swap(stage3[4], stage3[6]);
        swap(stage3[5], stage3[7]);
        swap(stage3[0], stage3[4]);
        swap(stage3[1], stage3[5]);
        swap(stage3[2], stage3[6]);
        swap(stage3[3], stage3[7]);
        swap(stage3[8], stage3[9]);
        stage4 = stage3;

        // 输出排序结果
        out1 = stage4[0];
        out2 = stage4[1];
        out3 = stage4[2];
        out4 = stage4[3];
        out5 = stage4[4];
        out6 = stage4[5];
        out7 = stage4[6];
        out8 = stage4[7];
        out9 = stage4[8];
        out10 = stage4[9];
    end

endmodule

核心注意点 #

• FPGA综合不支持动态循环，所有循环必须是固定迭代次数，或用纯组合逻辑的排序网络。
• 避免在综合代码中使用automatic函数（这类函数多用于仿真），优先用task或结构化逻辑。
• 固定长度输入场景下，排序网络的硬件效率远高于循环类排序。

内容的提问来源于stack exchange，提问作者Катя Голубь