集成电路技术分享

 找回密码
 我要注册

QQ登录

只需一步,快速开始

搜索
查看: 1763|回复: 2

我这个程序怎么占用逻辑单元3万多个,太多了!

[复制链接]
lig82 发表于 2011-12-17 21:30:30 | 显示全部楼层 |阅读模式
本帖最后由 lig82 于 2011-12-17 21:52 编辑

我用QuartusII编译下面这个模块,结果竟然耗用了30000多LE,太多了,而且综合时间特别长,器件资源不够啊。什么原因啊,是我用的数组太多?怎么优化呢?是编程方式不对吗? 请人解决一下。
附件为这个程序的文件。

module bpblock_rd_ctr(
        reset,
        rdclk,
        mb_wrdone,
        bpblock_rden,       
        bpblock_rd_addr,
        bpblock_data,       
        mb_rden,
        mb_rd_addr,
        mb_data,
        match_done,
        x_offset,
        y_offset       
);

`include "edge_para.v"

input        reset;
input         rdclk;
input        mb_wrdone;
input        [127:0]        bpblock_data;
input        [63:0]        mb_data;

output        bpblock_rden;
output        mb_rden;
output        [6:0]        bpblock_rd_addr;
output        [5:0]        mb_rd_addr;
output        [6:0]        x_offset;
output        [6:0]        y_offset;
output        match_done;

wire [63:0]        offset_data[64:0];

genvar  i;

generate for(i=0; i<65; i=i+1)
        begin: offsetbus
                assign offset_data = bpblock_data[i+63:i];
        end
endgenerate


`define                         idle                         0
`define                reading_a_mb                1
`define                searching_min_sum          2
`define                move_to_next_row                 3
`define                search_done                4

reg        [2:0]        current_state;
reg        [2:0]        next_state;

reg        [6:0]        bpblock_rd_addr;
reg        [5:0]        mb_rd_addr;

reg        [11:0]        min_sum;
reg        [6:0]        x_offset, y_offset;
reg        bpblock_rden;
reg        mb_rden;
reg match_done;

reg [6:0]        row_num;
reg        [11:0]        mb_offset_sum[64:0];

reg        [63:0]        xor_result[64:0];

reg        [3:0]        hamming_step;
reg        [2:0]        compare_step;
reg        [5:0]        min_x_index[31:0];

                       
always@(negedge rdclk, negedge reset)
begin
        if(!reset) current_state <= `idle;
        else current_state <= next_state;
end

always@(mb_wrdone, current_state, mb_rd_addr, hamming_step, compare_step, row_num)
begin
        mb_rden = 0;
        bpblock_rden = 0;
        match_done = 0;
        next_state = current_state;
       
        case(current_state)
                         `idle:        if(mb_wrdone) next_state = `reading_a_mb;
        `reading_a_mb:        begin
                               mb_rden = 1;
                               bpblock_rden = 1;                                                               
                               if(&mb_rd_addr && hamming_step==8) next_state = `searching_min_sum;
                        end
        `searching_min_sum:        if(&compare_step) next_state = `move_to_next_row;
        `move_to_next_row:        if(row_num==64) next_state = `search_done;
                        else  next_state = `reading_a_mb;
          `search_done:        begin
                               match_done = 1;
                               next_state = `idle;
                        end
        endcase
end

integer j;

always@(negedge rdclk)
begin
case(current_state)
        `idle:            begin
                       bpblock_rd_addr <= 0;
                       mb_rd_addr <= 0;
                       row_num <= 0;
                       hamming_step <= 0;       
                       compare_step <= 0;
                                                       
                      min_sum <= 12'hFFF;
                                                       
                      x_offset <= 32;
                      y_offset <= 32;                                                       
                                       
                for(j=0; j<65; j=j+1)
                      mb_offset_sum[j] <= 0;
                for(j=0; j<32; j=j+1)
                       min_x_index[j] <= j;
                 end
//////////////////////////////////////////////////////////////////////////////////////////////                                               
`reading_a_mb:        begin                       
                if(hamming_step==8) hamming_step <= 0;
                else hamming_step <= hamming_step + 1;

                case(hamming_step)
                1:        for(j=0; j<65; j=j+1)
                        xor_result[j] <= offset_data[j]^mb_data;
        //////////////////////////////////////////////////////////////               
                2:        for(j=0; j<65; j=j+1)
                xor_result[j] <= (xor_result[j]&64'h5555_5555_5555_5555)+((xor_result[j]>>1)&64'h5555_5555_5555_5555);
                3:            for(j=0; j<65; j=j+1)
                xor_result[j] <= (xor_result[j]&64'h3333_3333_3333_3333)+((xor_result[j]>>2)&64'h3333_3333_3333_3333);
                4:        for(j=0; j<65; j=j+1)
                xor_result[j] <= (xor_result[j]&64'h0f0f_0f0f_0f0f_0f0f)+((xor_result[j]>>4)&64'h0f0f_0f0f_0f0f_0f0f);
                5:        for(j=0; j<65; j=j+1)
                xor_result[j] <= (xor_result[j]&64'h00ff_00ff_00ff_00ff)+((xor_result[j]>>8)&64'h00ff_00ff_00ff_00ff);
                6:        for(j=0; j<65; j=j+1)
                xor_result[j] <= (xor_result[j]&64'h0000_ffff_0000_ffff)+((xor_result[j]>>16)&64'h0000_ffff_0000_ffff);
                7:        for(j=0; j<65; j=j+1)
                xor_result[j] <= (xor_result[j]&64'h0000_0000_ffff_ffff)+((xor_result[j]>>32)&64'h0000_0000_ffff_ffff);
        //////////////////////////////////////////////////////////////               
                8:      begin
                        for(j=0; j<65; j=j+1)
                        mb_offset_sum[j] <=  mb_offset_sum[j] + xor_result[j];
                                                                                       
                        if(!(&mb_rd_addr))begin
                                mb_rd_addr <= mb_rd_addr + 1;
                                bpblock_rd_addr <= bpblock_rd_addr + 1;
                        end                                                                                       
                         end
             //default:       
        endcase
         end
///////////////////////////////////////////////////////////////////////////////////////////////                                                                       
  `searching_min_sum:        begin
                                                compare_step <= compare_step + 1;
                        case(compare_step)
                        0:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[64])begin
                                mb_offset_sum[0] <= mb_offset_sum[64];
                                min_x_index[0] <= 64;
                                end
                                                                               
                                if(mb_offset_sum[1]>mb_offset_sum[63])begin
                                mb_offset_sum[1] <= mb_offset_sum[63];
                                min_x_index[1] <= 63;
                                end
                                                                               
                                if(mb_offset_sum[2]>mb_offset_sum[62])begin
                                mb_offset_sum[2] <= mb_offset_sum[62];
                                min_x_index[2] <= 62;
                                end
                                                                               
                                        if(mb_offset_sum[3]>mb_offset_sum[61])begin
                                mb_offset_sum[3] <= mb_offset_sum[61];
                                min_x_index[3] <= 61;
                                end
                                                                               
                                        if(mb_offset_sum[4]>mb_offset_sum[60])begin
                                        mb_offset_sum[4] <= mb_offset_sum[60];
                                        min_x_index[4] <= 60;
                                end
                                                                               
                                if(mb_offset_sum[5]>mb_offset_sum[59])begin
                                        mb_offset_sum[5] <= mb_offset_sum[59];
                                        min_x_index[5] <= 59;
                                end
                                                                               
                                if(mb_offset_sum[6]>mb_offset_sum[58])begin
                                        mb_offset_sum[6] <= mb_offset_sum[58];
                                        min_x_index[6] <= 58;
                                end
                                                                               
                                if(mb_offset_sum[7]>mb_offset_sum[57])begin
                                        mb_offset_sum[7] <= mb_offset_sum[57];
                                        min_x_index[7] <= 57;
                                end
                                                                               
                                if(mb_offset_sum[8]>mb_offset_sum[56])begin
                                        mb_offset_sum[8] <= mb_offset_sum[56];
                                        min_x_index[8] <= 56;
                                end
                                                                               
                                        if(mb_offset_sum[9]>mb_offset_sum[55])begin
                                        mb_offset_sum[9] <= mb_offset_sum[55];
                                        min_x_index[9] <= 55;
                                end
                                                                               
                                if(mb_offset_sum[10]>mb_offset_sum[54])begin
                                        mb_offset_sum[10] <= mb_offset_sum[54];
                                        min_x_index[10] <= 54;
                                end
                                                                               
                                if(mb_offset_sum[11]>mb_offset_sum[53])begin
                                        mb_offset_sum[11] <= mb_offset_sum[53];
                                        min_x_index[11] <= 53;
                                end
                                                                               
                                if(mb_offset_sum[12]>mb_offset_sum[52])begin
                                        mb_offset_sum[12] <= mb_offset_sum[52];
                                        min_x_index[12] <= 52;
                                end
                                                                               
                                if(mb_offset_sum[13]>mb_offset_sum[51])begin
                                        mb_offset_sum[13] <= mb_offset_sum[51];
                                        min_x_index[13] <= 51;
                                end
                                                                               
                                if(mb_offset_sum[14]>mb_offset_sum[50])begin
                                        mb_offset_sum[14] <= mb_offset_sum[50];
                                        min_x_index[14] <= 50;
                                end
                                                                               
                                if(mb_offset_sum[15]>mb_offset_sum[49])begin
                                        mb_offset_sum[15] <= mb_offset_sum[49];
                                        min_x_index[15] <= 49;
                                end
                                                                               
                                if(mb_offset_sum[16]>mb_offset_sum[48])begin
                                        mb_offset_sum[16] <= mb_offset_sum[48];
                                        min_x_index[16] <= 48;
                                end
                                                                               
                                if(mb_offset_sum[17]>mb_offset_sum[47])begin
                                        mb_offset_sum[17] <= mb_offset_sum[47];
                                        min_x_index[17] <= 47;
                                end
                                                                               
                                if(mb_offset_sum[18]>mb_offset_sum[46])begin
                                        mb_offset_sum[18] <= mb_offset_sum[46];
                                        min_x_index[18] <= 46;
                                end
                                                                               
                                if(mb_offset_sum[19]>mb_offset_sum[45])begin
                                        mb_offset_sum[19] <= mb_offset_sum[45];
                                        min_x_index[19] <= 45;
                                end
                                                                               
                                if(mb_offset_sum[20]>mb_offset_sum[44])begin
                                        mb_offset_sum[20] <= mb_offset_sum[44];
                                        min_x_index[20] <= 44;
                                end
                                                                               
                                if(mb_offset_sum[21]>mb_offset_sum[43])begin
                                        mb_offset_sum[21] <= mb_offset_sum[43];
                                        min_x_index[21] <= 43;
                                end
                                                                               
                                if(mb_offset_sum[22]>mb_offset_sum[42])begin
                                        mb_offset_sum[22] <= mb_offset_sum[42];
                                        min_x_index[22] <= 42;
                                end
                                                                               
                                if(mb_offset_sum[23]>mb_offset_sum[41])begin
                                        mb_offset_sum[23] <= mb_offset_sum[41];
                                        min_x_index[23] <= 41;
                                end
                                                                               
                                if(mb_offset_sum[24]>mb_offset_sum[40])begin
                                        mb_offset_sum[24] <= mb_offset_sum[40];
                                        min_x_index[24] <= 40;
                                end
                                                                               
                                if(mb_offset_sum[25]>mb_offset_sum[39])begin
                                        mb_offset_sum[25] <= mb_offset_sum[39];
                                        min_x_index[25] <= 39;
                                end
                                                                               
                                if(mb_offset_sum[26]>mb_offset_sum[38])begin
                                        mb_offset_sum[26] <= mb_offset_sum[38];
                                        min_x_index[26] <= 38;
                                end
                                                                               
                                if(mb_offset_sum[27]>mb_offset_sum[37])begin
                                        mb_offset_sum[27] <= mb_offset_sum[37];
                                        min_x_index[27] <= 37;
                                end
                                                                               
                                if(mb_offset_sum[28]>mb_offset_sum[36])begin
                                        mb_offset_sum[28] <= mb_offset_sum[36];
                                        min_x_index[28] <= 36;
                                end
                                                                               
                                if(mb_offset_sum[29]>mb_offset_sum[35])begin
                                        mb_offset_sum[29] <= mb_offset_sum[35];
                                        min_x_index[29] <= 35;
                                end
                                                                               
                                if(mb_offset_sum[30]>mb_offset_sum[34])begin
                                        mb_offset_sum[30] <= mb_offset_sum[34];
                                        min_x_index[30] <= 34;
                                end
                                                                               
                                if(mb_offset_sum[31]>mb_offset_sum[33])begin
                                        mb_offset_sum[31] <= mb_offset_sum[33];
                                        min_x_index[31] <= 33;
                                end
                        end                                                                                                                                                       
                1:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[31])begin
                                        mb_offset_sum[0] <= mb_offset_sum[31];
                                        min_x_index[0] <= min_x_index[31];
                                end
                                                                               
                                if(mb_offset_sum[1]>mb_offset_sum[30])begin
                                               mb_offset_sum[1] <= mb_offset_sum[30];
                                        min_x_index[1] <= min_x_index[30];
                                end
                                                                               
                                if(mb_offset_sum[2]>mb_offset_sum[29])begin
                                        mb_offset_sum[2] <= mb_offset_sum[29];
                                        min_x_index[2] <= min_x_index[29];
                                end
                                                                               
                                if(mb_offset_sum[3]>mb_offset_sum[28])begin
                                        mb_offset_sum[3] <= mb_offset_sum[28];
                                        min_x_index[3] <= min_x_index[28];
                                end
                                                                               
                                if(mb_offset_sum[4]>mb_offset_sum[27])begin
                                        mb_offset_sum[4] <= mb_offset_sum[27];
                                        min_x_index[4] <= min_x_index[27];
                                end
                                                                               
                                        if(mb_offset_sum[5]>mb_offset_sum[26])begin
                                        mb_offset_sum[5] <= mb_offset_sum[26];
                                        min_x_index[5] <= min_x_index[26];
                                end
                                                                               
                                if(mb_offset_sum[6]>mb_offset_sum[25])begin
                                        mb_offset_sum[6] <= mb_offset_sum[25];
                                        min_x_index[6] <= min_x_index[25];
                                        end
                                                                               
                                if(mb_offset_sum[7]>mb_offset_sum[24])begin
                                        mb_offset_sum[7] <= mb_offset_sum[24];
                                        min_x_index[7] <= min_x_index[24];
                                end
                                                                               
                                if(mb_offset_sum[8]>mb_offset_sum[23])begin
                                        mb_offset_sum[8] <= mb_offset_sum[23];
                                        min_x_index[8] <= min_x_index[23];
                                end
                                                                               
                                if(mb_offset_sum[9]>mb_offset_sum[22])begin
                                        mb_offset_sum[9] <= mb_offset_sum[22];
                                        min_x_index[9] <= min_x_index[22];
                                end
                                                                               
                                if(mb_offset_sum[10]>mb_offset_sum[21])begin
                                        mb_offset_sum[10] <= mb_offset_sum[21];
                                        min_x_index[10] <= min_x_index[21];
                                end
                                                                               
                                if(mb_offset_sum[11]>mb_offset_sum[20])begin
                                        mb_offset_sum[11] <= mb_offset_sum[20];
                                        min_x_index[11] <= min_x_index[20];
                                end
                                                                               
                                if(mb_offset_sum[12]>mb_offset_sum[19])begin
                                        mb_offset_sum[12] <= mb_offset_sum[19];
                                        min_x_index[12] <= min_x_index[19];
                                end
                                                                               
                                if(mb_offset_sum[13]>mb_offset_sum[18])begin
                                        mb_offset_sum[13] <= mb_offset_sum[18];
                                        min_x_index[13] <= min_x_index[18];
                                end
                                                                               
                                if(mb_offset_sum[14]>mb_offset_sum[17])begin
                                        mb_offset_sum[14] <= mb_offset_sum[17];
                                        min_x_index[14] <= min_x_index[17];
                                end
                                                                               
                                if(mb_offset_sum[15]>mb_offset_sum[16])begin
                                        mb_offset_sum[15] <= mb_offset_sum[16];
                                        min_x_index[15] <= min_x_index[16];
                                end
                        end                                               
                2:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[15])begin
                                                mb_offset_sum[0] <= mb_offset_sum[15];
                                        min_x_index[0] <= min_x_index[15];
                                end
                                                                               
                                if(mb_offset_sum[1]>mb_offset_sum[14])begin
                                        mb_offset_sum[1] <= mb_offset_sum[14];
                                        min_x_index[1] <= min_x_index[14];
                                end
                                                                               
                                if(mb_offset_sum[2]>mb_offset_sum[13])begin
                                        mb_offset_sum[2] <= mb_offset_sum[13];
                                        min_x_index[2] <= min_x_index[13];
                                end
                                                                               
                                if(mb_offset_sum[3]>mb_offset_sum[12])begin
                                        mb_offset_sum[3] <= mb_offset_sum[12];
                                        min_x_index[3] <= min_x_index[12];
                                end
                                                                               
                                if(mb_offset_sum[4]>mb_offset_sum[11])begin
                                        mb_offset_sum[4] <= mb_offset_sum[11];
                                        min_x_index[4] <= min_x_index[11];
                                end
                                                                               
                                if(mb_offset_sum[5]>mb_offset_sum[10])begin
                                        mb_offset_sum[5] <= mb_offset_sum[10];
                                        min_x_index[5] <= min_x_index[10];
                                end
                                                                               
                                if(mb_offset_sum[6]>mb_offset_sum[9])begin
                                        mb_offset_sum[6] <= mb_offset_sum[9];
                                        min_x_index[6] <= min_x_index[9];
                                end
                                                                               
                                if(mb_offset_sum[7]>mb_offset_sum[8])begin
                                        mb_offset_sum[7] <= mb_offset_sum[8];
                                        min_x_index[7] <= min_x_index[8];
                                end
                        end       
                3:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[7])begin
                                        mb_offset_sum[0] <= mb_offset_sum[7];
                                        min_x_index[0] <= min_x_index[7];
                                end
                                                                               
                                if(mb_offset_sum[1]>mb_offset_sum[6])begin
                                        mb_offset_sum[1] <= mb_offset_sum[6];
                                        min_x_index[1] <= min_x_index[6];
                                end
                                                                               
                                if(mb_offset_sum[2]>mb_offset_sum[5])begin
                                        mb_offset_sum[2] <= mb_offset_sum[5];
                                        min_x_index[2] <= min_x_index[5];
                                end
                                                                               
                                if(mb_offset_sum[3]>mb_offset_sum[4])begin
                                        mb_offset_sum[3] <= mb_offset_sum[4];
                                        min_x_index[3] <= min_x_index[4];
                                end
                        end       
                4:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[3])begin
                                                mb_offset_sum[0] <= mb_offset_sum[3];
                                        min_x_index[0] <= min_x_index[3];
                                end
                                                                               
                                if(mb_offset_sum[1]>mb_offset_sum[2])begin
                                        mb_offset_sum[1] <= mb_offset_sum[2];
                                        min_x_index[1] <= min_x_index[2];
                                end
                        end       
                5:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[1])begin
                                        mb_offset_sum[0] <= mb_offset_sum[1];
                                        min_x_index[0] <= min_x_index[1];
                                end
                        end       
                6:        begin
                                if(mb_offset_sum[0]>mb_offset_sum[32])begin
                                        mb_offset_sum[0] <= mb_offset_sum[32];
                                        min_x_index[0] <= 32;
                                end
                        end
                7:        begin
                                if(min_sum>mb_offset_sum[0])begin
                                               min_sum <= mb_offset_sum[0];
                                        x_offset <=  min_x_index[0];
                                        y_offset <= row_num;
                                end
                        end
                     endcase
        end
`move_to_next_row:        begin
                        mb_rd_addr <= 0;//lg, 地址归零
                        bpblock_rd_addr <= row_num + 1;
                        row_num <= row_num + 1;
                                                       
                        for(j=0; j<65; j=j+1)
                                mb_offset_sum[j] <= 0;
                        for(j=0; j<32; j=j+1)
                                min_x_index[j] <= j;
                end
        endcase               
end


endmodule

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?我要注册

x
至芯兴洪 发表于 2011-12-23 20:27:44 | 显示全部楼层
程序中的for语句太多了,硬件与软件是有很大区别的,程序中还有大量的不可综合语句,还有大量的错去,例如min_x_index[26] <= 38;很显然的错误,先理解再去做,不然写得再多也没用
您需要登录后才可以回帖 登录 | 我要注册

本版积分规则

关闭

站长推荐上一条 /1 下一条

QQ|小黑屋|手机版|Archiver|fpga论坛|fpga设计论坛 ( 京ICP备20003123号-1 )

GMT+8, 2025-7-16 17:30 , Processed in 0.092692 second(s), 24 queries .

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表