Sorting verilog中的单周期排序

我试图在verilog中对9个随机数进行排序。我使用冒泡排序（嵌套循环）算法，但我有一个挑战。我想在一个clk周期内对它们进行排序，但它并不能满足我的要求。至少需要9个周期来对它们进行排序

always @(posedge clk)
begin

if(m >= 68 && sort_valid == 0) begin
    pool_sort[0] <= pool_buffer[66];
    pool_sort[1] <= pool_buffer[65];
    pool_sort[2] <= pool_buffer[64];
    pool_sort[3] <= pool_buffer[34];
    pool_sort[4] <= pool_buffer[33];
    pool_sort[5] <= pool_buffer[32];
    pool_sort[6] <= pool_buffer[2];
    pool_sort[7] <= pool_buffer[1];
    pool_sort[8] <= pool_buffer[0];

sort_valid <= 1;

 end

if(sort_valid == 1) begin
        for(k=0;k<8;k=k+1) begin
            if(pool_sort[k] < pool_sort[k+1]) begin
                pool_sort[k] <= pool_sort[k+1];
                pool_sort[k+1] <= pool_sort[k];
            end
        end
    if(sort_counter == 0) begin
        sort_valid <= 0;
        pool_out <= pool_sort[0];
    end
end
end

always @(posedge clk)
begin

if(sort_valid == 1) begin
sort_counter <= sort_counter - 1;
end
if(sort_counter == 0) begin
    sort_counter <= 8;
end

end
endmodule

始终@（posedge clk）
开始
如果（m>=68&&sort\u valid==0）开始
pool_sort[0]如果需要对多轮9个数字进行排序，请提前考虑

您可以在1个周期内进行排序，但最高频率可能会受到很大限制。但是，如果你在低频时花了1个时钟周期，或者在更高频率时花了9个时钟周期，这并不重要

如果您将有多个轮次，那么您可以管道排序阶段，在每个时钟周期上获得新的结果，并为第一个结果提供一些时钟延迟

另请参阅，因为它更适合于在硬件中使用少量输入进行并行排序。
这里有一个用于Verilog的参数化1时钟周期分类器（灵感来源于，但我对模块进行了参数化，减少了周期数，并进行了一些清理）

在模拟中，它可以做你想做的事情，但当你合成它时，它可能会非常大和丑陋

module sort #(
    parameter NUM_VALS = 5,
    parameter SIZE     = 16
)(  input  wire clk,
    input  wire [NUM_VALS*SIZE-1:0] in,
    output reg  [NUM_VALS*SIZE-1:0] out
);
    reg [NUM_VALS*SIZE-1:0] sorted_bus;
    always @(posedge clk) begin
        out <= sorted_bus;
    end

    integer i, j;
    reg [SIZE-1:0] temp;
    reg [SIZE-1:0] array [1:NUM_VALS];
    always @* begin
        for (i = 0; i < NUM_VALS; i = i + 1) begin
            array[i+1] = in[i*SIZE +: SIZE];
        end

        for (i = NUM_VALS; i > 0; i = i - 1) begin
            for (j = 1 ; j < i; j = j + 1) begin
                if (array[j] < array[j + 1]) begin
                    temp         = array[j];
                    array[j]     = array[j + 1];
                    array[j + 1] = temp;
                end 
            end
        end

       for (i = 0; i < NUM_VALS; i = i + 1) begin
            sorted_bus[i*SIZE +: SIZE] = array[i+1];
       end
    end
endmodule

模块排序#(
参数NUM_VALS=5，
参数大小=16
)（输入线时钟，
输入导线[NUM_VALS*SIZE-1:0]英寸，
输出寄存器[NUM_VALS*SIZE-1:0]输出
);
reg[NUM\u VALS*SIZE-1:0]已排序的\u总线；
始终@（posedge clk）开始
0分；i=i-1）开始
对于（j=1；j

和一个试验台：

module sort_tb;
    reg clk;
    reg  [16-1:0] in1,  in2,  in3,  in4,  in5;
    wire [16-1:0] out1, out2, out3, out4, out5;

    sort #(.NUM_VALS(5), .SIZE(16)) dut (
        .clk(clk),
        .in ({in1,  in2,  in3,  in4,  in5}),
        .out({out1, out2, out3, out4, out5})
    );

    always @(posedge clk) begin
        in1 <= $random;
        in2 <= $random;
        in3 <= $random;
        in4 <= $random;
        in5 <= $random;
    end

    always @(posedge clk) begin
        $display("In:  %0d %0d %0d %0d %0d", in1,  in2,  in3,  in4,  in5);
        $display("Out: %0d %0d %0d %0d %0d", out1, out2, out3, out4, out5);
    end

    initial begin
        #100;
        $finish;
    end

    always begin
        clk = 1'b0; #5;
        clk = 1'b1; #5;
    end
endmodule

模块排序\u tb；
注册时钟；
reg[16-1:0]in1，in2，in3，in4，in5；
导线[16-1:0]输出1、输出2、输出3、输出4、输出5；
排序（.NUM\u VALS（5），.SIZE（16））dut(
.clk（clk），
.in（{in1，in2，in3，in4，in5}），
.out（{out1，out2，out3，out4，out5}）
);
始终@（posedge clk）开始
请给我们看一下你到目前为止有什么。请缩进你的代码，以便在这里正确显示。你可能想看看排序网络。我不认为双音算法可以在一个周期内执行。你为什么这么认为？您只需将所有比较阶段链接到一个长的组合函数中，一旦输入通过所有阶段传播，您就可以得到结果。这将限制你的频率，但仍然是1个周期。通过流水线（对于许多排序），您可以在一个周期中执行一个阶段，这会给出延迟，然后每1个时钟执行一个结果。