Использование встроенной памяти ПЛИС. Опции

[m0use]

Доброго всем времени суток!

Вопрос такой. Пишу код, который работает с матрицами, в том числе обрабатывает их в циклах. Получилось так, что текущая версия кода при размере матрицы, далёком от практических потребностей код требует значительных ресурсов (насколько я понял из отчёта, близких к предельным для этой ПЛИСы):

Logic Utilization:
Number of Slice Flip Flops: 1,231 out of 9,312 13%
Number of 4 input LUTs: 8,329 out of 9,312 89%
Logic Distribution:
Number of occupied Slices: 4,654 out of 4,656 99%
Total Number of 4 input LUTs: 8,741 out of 9,312 93%
Number of bonded IOBs: 19 out of 232 8%
Number of BUFGMUXs: 1 out of 24 4%
Number of MULT18X18SIOs: 20 out of 20 100%

Скажите, ребят, если я буду использовать память (пока я себе это представляю как модуль памяти из IP Core Generator), то снизит ли это количество используемых LUT? То есть если данные будут хранится в памяти, а по мере необходимости вычислений они оттуда будут выдёргиваться.

Если да, то был бы благодарен за ссылки на примеры использование памяти или статьи. Безусловно, гуглить обязательно буду, но вдруг, у кого уже под рукой хороший готовый материал. Просто пока для меня это чёрный ящик, надо в него заглянуть с фонариком .

Заранее спасибо, коллеги!

[m0use]

Посмотрел код. Может, в этой триаде - бумага+карандаш+мозг - что-то недостаточно развито, но мне показалось, что главный вопрос был сформулирован CaPpuCcino уже давно:

и вообще-то меня терзают смутные сомнения... (правильно ли вы описываете то, что проектируете)

Меня тоже терзают, поэтому сначала приведу описание того, что я проектирую на языке Русский, а потом то, как я это описал на языке Veilog.

Русский:

Код

Функциональная задача такая - на вход поступает изображение, матрицы RGB. Пусть пока это одна матрица I (требуемый порядок - 640x480). Из этой матрицы получается две градиентные матрицы - по x (Ix) и по y (Iy). После этого из этих градиентных матриц строится матрица Харриса по формуле выше.

Собственно, всё. Условно я вижу это в железе как проводки идущие от двух ячеек исходной матрицы через сумматор к одной ячейке градиентных матриц. И также от нескольких ячеек градиентных матриц - к одной ячейке матрицы Харриса (свёртка). Всё это должно выполняться параллельно и потому быстро :).

Verilog:

Код

// ASSIGNES //
assign end_load_w = ( int_bytes_loaded == P_IMAGE_ROWS * P_IMAGE_COLS - 1 );
assign end_grad_w = ( int_grad == P_IMAGE_ROWS * P_IMAGE_COLS  );
assign end_harris_w = ( int_harris == P_HARRIS_SIZE );
<...>;
// END ASSIGNES //

/ ALWAYS-BLOCKS //
// ** RESET & LOAD & DBOUTPUT ** //
always @( posedge CLK or posedge RESET ) begin
    if( RESET ) <начальная иницализация>;
    else if( IN_1_BTN_CLICK && !end_load_w ) begin
        mem_image[ int_bytes_loaded ] <= IN_8_IMAGE;
        int_bytes_loaded <= int_bytes_loaded + 1;
        DB_OUT_7_LED_r <= int_bytes_loaded;
    end
    else <после окончания преобразования вывод результата>;
end
// ** GRADIENT & HARRIS ROUTINE ** //
always @( posedge CLK or posedge RESET ) begin
    if( RESET ) <начальная инициализация>
    else if( end_load_w && !end_grad_w && !end_harris_w  )
        for( int_xi = 0; int_xi < P_IMAGE_COLS; int_xi = int_xi + 1 )
            for( int_yi = 0; int_yi < P_IMAGE_ROWS; int_yi = int_yi + 1 )
                if( int_grad != P_IMAGE_ROWS * P_IMAGE_COLS ) begin
                    mem_image_x[ int_xi + P_IMAGE_COLS*int_yi ] = <разность по x>;
                    mem_image_y[ int_xi + P_IMAGE_COLS*int_yi ] = <разность по y>;
                    int_grad = int_grad + 1;
                end
                else;
    else if( end_load_w && end_grad_w && end_db_output_w && !end_harris_w )
        for( int_xi_2 = P_RADIUS; int_xi_2 < ( P_IMAGE_COLS - P_RADIUS ); int_xi_2 = int_xi_2 + 1 )
            for( int_yi_2 = P_RADIUS; int_yi_2 < ( P_IMAGE_ROWS - P_RADIUS ); int_yi_2 = int_yi_2 + 1 )
                if( int_harris != P_HARRIS_SIZE ) begin
                    mem_harris[ <адрес блока памяти> ] = f_harris_block( int_xi_2, int_yi_2 );
                    int_harris = int_harris + 1;
                end
                else;
    else;
end
<...>;
// END ALWAYS-BLOCKS //

// FUNCTIONS //
// ** TABLE SQRT ** //
function integer f_my_sqrt;
    input integer f_int_x;
    
    case( f_int_x )
        0: f_my_sqrt = 0;
        3: f_my_sqrt = 1;
        4: f_my_sqrt = 2;
        default: f_my_sqrt = 255;
    endcase
endfunction
// ** HARRIS BLOCK ** //
function integer f_harris_block;
    // FARGUMENTS //
    input integer f_int_x;
    input integer f_int_y;
    // FVARIABLES //
    integer f_int_ki;
    integer f_int_ri;
    integer f_int_xx;
    integer f_int_xy;
    integer f_int_yy;
    
    begin
        f_int_xx = 0;
        f_int_xy = 0;
        f_int_yy = 0;
        for( f_int_ki = -P_RADIUS; f_int_ki <= P_RADIUS; f_int_ki = f_int_ki + 1)
            for( f_int_ri = -P_RADIUS; f_int_ri <= P_RADIUS; f_int_ri = f_int_ri + 1 )
            begin
                if( `_ABS( f_int_ri ) <= f_my_sqrt( `_SQR( P_RADIUS ) - `_SQR( f_int_ki ) ) ) begin
                    f_int_xx = f_int_xx + <mem_image_x * mem_image_x>;
                    f_int_xy = f_int_xy + <mem_image_x * mem_image_y>;
                    f_int_yy = f_int_yy + <mem_image_y * mem_image_y>;
                end
                else;
            end
        f_harris_block = f_int_xx + f_int_xy + f_int_yy;
    end
endfunction
// END FUNCTIONS //

Я память попробую использовать, это просто как сохранение перед миссией - выложить тот код, который уже есть, чтобы Вы профессиональным взглядом на него посмотрели. Может, что там, действительно не так, что только LUT ест.

Сообщение отредактировал m0use - Sep 22 2010, 14:49