Принцип работы делителя (с фиксированной точкой)

Подобно делению в десятичной системе, процесс вычисления 27, делённого на 5, выглядит следующим образом:

Процесс операции деления выглядит следующим образом:

  • (1) Возьмите старшие биты делимого с разрядностью, равной делителю (в примере — 3-битные данные).
  • (2) Сравните старшие разряды делимого с делителем. Если старшие разряды не меньше делителя, соответствующий бит частного равен 1, а разность между ними даёт остаток первого шага; в противном случае соответствующий бит частного равен 0, а старшие разряды напрямую используются в качестве остатка.
  • (3) Объедините остаток от предыдущего шага с оставшимся старшим 1-битным разрядом делимого, чтобы сформировать новые данные, затем сравните их с делителем. Можно получить новые частное и остаток.
  • (4) Повторяйте процесс (3), пока младший бит делимого также не будет задействован в вычислении.

Следует отметить, что разрядность частного должна совпадать с разрядностью делимого, поскольку делитель может быть равен 1.Поэтому в приведённом выше примере ручного деления при выполнении первого сравнения старший бит 1 числа 27 (3'b001) следует сравнить с 3'b101.На основе этого процесса вычисления спроектируйте конвейерный делитель с настраиваемой разрядностью, где количество тактов задержки конвейера равно разрядности делимого.

Проектирование делителя

Проектирование одношаговой операции

При одношаговом делении разрядность одношагового делимого (сигнал dividend) должна быть на 1 бит шире исходного делителя (сигнал divisor), чтобы избежать переполнения.

Чтобы упростить конвейеризацию, на выходе требуются регистры для хранения исходного делителя (сигналы divisor и divisor_kp) и информации о делимом (сигналы dividend_ci и dividend_kp).

Результатом одношаговой операции являются новое 1-битное частное (сигнал merchant) и остаток (сигнал remainder).

Чтобы получить окончательный результат деления, новое 1-битное частное (сигнал merchant) также необходимо сдвинуть и накопить вместе с результатом частного предыдущего такта (merchant_ci).

Проектирование блока одношаговой операции выглядит следующим образом (имя файла: divider_cell.v):

Пример

// параметр M означает фактическую ширину делителя
module    divider_cell
    #(параметр N=5,
      параметр M=3)
    (
      input                     clk,
      input                     rstn,
      input                     en,

      input [M:0]               dividend,
      input [M-1:0]             divisor,
      input [N-M:0]             merchant_ci , //Выход частного с предыдущего этапа
      input [N-M-1:0]           dividend_ci , //Исходный делитель

      output reg [N-M-1:0]      dividend_kp,  //Информация об исходном делимом
      output reg [M-1:0]        divisor_kp,   //Информация об исходном делителе
      output reg                rdy ,
      output reg [N-M:0]        merchant ,  //Выход частного из операционного блока
      output reg [M-1:0]        remainder   //Выход остатка из операционного блока
    );

    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            rdy            <= 'b0 ;
            merchant       <= 'b0 ;
            remainder      <= 'b0 ;
            divisor_kp     <= 'b0 ;
            dividend_kp    <= 'b0 ;
        end
        else if (en) begin
            rdy            <= 1'b1 ;
            divisor_kp     <= divisor ;  //Исходный делитель остаётся неизменным
            dividend_kp    <= dividend_ci ;  //Исходное делимое передаётся без изменений
            if (dividend >= {1'b0, divisor}) begin
                merchant    <= (merchant_ci<<1) + 1'b1 ; //Частное равно 1
                remainder   <= dividend - {1'b0, divisor} ; //Вычислить остаток
            end
            else begin
                merchant    <= merchant_ci<<1 ;  //Частное равно 0
                remainder   <= dividend ;        //Остаток не изменяется
            end
        end // if (en)
        else begin
            rdy            <= 'b0 ;
            merchant       <= 'b0 ;
            remainder      <= 'b0 ;
            divisor_kp     <= 'b0 ;
            dividend_kp    <= 'b0 ;
        end
    end

endmodule

Инстанцирование ступени конвейера

Объедините остаток (сигнал remainder) из одношагового вычисления с соответствующими 1-битными данными исходного делимого (сигнал dividend) и используйте его в качестве нового входного делимого для следующего блока одношагового деления.

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

Проект делителя, выполненный путем инстанцирования модулей ступеней конвейера, выглядит следующим образом (имя файла: divider_man.v):

Пример

//параметр N означает фактическую ширину делимого
//используется 29/5=5...4
module    divider_man
    #(параметр N=5,
      параметр M=3,
      parameter N_ACT = M+N-1)
    (
      input                     clk,
      input                     rstn,

      input                     data_rdy ,  //Разрешение данных
      input [N-1:0]             dividend,   //Делимое
      input [M-1:0]             divisor,    //Делитель

      output                    res_rdy ,
      output [N_ACT-M:0]        merchant ,  //Разрядность частного: N
      output [M-1:0]            remainder ); //Итоговый остаток

    wire [N_ACT-M-1:0]   dividend_t [N_ACT-M:0] ;
    wire [M-1:0]         divisor_t [N_ACT-M:0] ;
    wire [M-1:0]         remainder_t [N_ACT-M:0];
    wire [N_ACT-M:0]     rdy_t ;
    wire [N_ACT-M:0]     merchant_t [N_ACT-M:0] ;

    //Инициализировать первый операционный блок
    divider_cell      #(.N(N_ACT), .M(M))
       u_divider_step
    ( .clk              (clk),
      .rstn             (rstn),
      .en               (data_rdy),
      //Использовать старший 1-битный фрагмент данных делимого в качестве делимого для первой одношаговой операции с заполнением старших битов нулями
      .dividend         ({{(M){1'b0}}, dividend[N-1]}),
      .divisor          (divisor),                  
      .merchant_ci      ({(N_ACT-M+1){1'b0}}),   //Частное изначально 0
      .dividend_ci      (dividend[N_ACT-M-1:0]), //Исходное делимое
      //выход
      .dividend_kp      (dividend_t[N_ACT-M]),   //Исходная информация о делимом, переданная дальше
      .divisor_kp       (divisor_t[N_ACT-M]),    //Исходная информация о делителе передаётся дальше
      .rdy              (rdy_t[N_ACT-M]),
      .merchant         (merchant_t[N_ACT-M]),   //Первый результат частного
      .remainder        (remainder_t[N_ACT-M])   //Первый остаток
      );

    genvar               i ;
    generate
        for(i=1; i<=N_ACT-M; i=i+1) begin: sqrt_stepx
            divider_cell      #(.N(N_ACT), .M(M))
              u_divider_step
              (.clk              (clk),
               .rstn             (rstn),
               .en               (rdy_t[N_ACT-M-i+1]),
               .dividend         ({remainder_t[N_ACT-M-i+1], dividend_t[N_ACT-M-i+1][N_ACT-M-i]}),   //Объединить остаток с однобитными данными исходного делимого
               .divisor          (divisor_t[N_ACT-M-i+1]),
               .merchant_ci      (merchant_t[N_ACT-M-i+1]),
               .dividend_ci      (dividend_t[N_ACT-M-i+1]),
               //выход
               .divisor_kp       (divisor_t[N_ACT-M-i]),
               .dividend_kp      (dividend_t[N_ACT-M-i]),
               .rdy              (rdy_t[N_ACT-M-i]),
               .merchant         (merchant_t[N_ACT-M-i]),
               .remainder        (remainder_t[N_ACT-M-i])
              );
        end // блок: sqrt_stepx
    endgenerate

    assign res_rdy       = rdy_t[0];
    assign merchant      = merchant_t[0];  //Результат последнего частного как итоговое частное
    assign remainder     = remainder_t[0]; //Последний остаток как итоговый остаток

endmodule

testbench

Установите разрядность делимого равной 5, разрядность делителя равной 3 и добавьте самопроверку в тестбенче, как описано ниже:

Пример

`timescale 1ns/1ns

module test ;
    параметр    N = 5 ;
    параметр    M = 3 ;
    reg          clk;
    reg          rstn ;
    reg          data_rdy ;
    reg [N-1:0]  dividend ;
    reg [M-1:0]  divisor ;

    wire         res_rdy ;
    wire [N-1:0] merchant ;
    wire [M-1:0] remainder ;

    //синхросигнал
    always begin
        clk = 0 ; #5 ;
        clk = 1 ; #5 ;
    end

    //драйвер
    initial begin
        rstn      = 1'b0 ;
        #8 ;
        rstn      = 1'b1 ;

        #55 ;
        @(negedge clk ) ;
        data_rdy  = 1'b1 ;
                dividend  = 25;      divisor      = 5;
        #10 ;   dividend  = 16;      divisor      = 3;
        #10 ;   dividend  = 10;      divisor      = 4;
        #10 ;   dividend  = 15;      divisor      = 1;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 7;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 5;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 4;
        repeat(32)    #10   dividend   = dividend + 1 ;
        divisor      = 6;
        repeat(32)    #10   dividend   = dividend + 1 ;
    end

    //Задержка входных данных, чтобы результаты данных можно было сравнить в одном и том же цикле для выполнения самопроверки
    reg  [N-1:0]   dividend_ref [N-1:0];
    reg  [M-1:0]   divisor_ref [N-1:0];
    always @(posedge clk) begin
        dividend_ref[0] <= dividend ;
        divisor_ref[0]  <= divisor ;
    end

    genvar         i ;
    generate
        for(i=1; i<=N-1; i=i+1) begin
            always @(posedge clk) begin
                dividend_ref[i] <= dividend_ref[i-1];
                divisor_ref[i]  <= divisor_ref[i-1];
            end
        end
    endgenerate

    //Самопроверка
    reg  error_flag ;
    always @(posedge clk) begin
    # 1 ;
        if (merchant * divisor_ref[N-1] + remainder != dividend_ref[N-1] && res_rdy) beginb      //В тестбенче знак умножения можно использовать напрямую, не учитывая циклы операции
            error_flag <= 1'b1 ;
        end
        else begin
            error_flag <= 1'b0 ;
        end
    end

    //создание экземпляра модуля
    divider_man  #(.N(N), .M(M))
    u_divider
     (
      .clk              (clk),
      .rstn             (rstn),
      .data_rdy         (data_rdy),
      .dividend         (dividend),
      .divisor          (divisor),
      .res_rdy          (res_rdy),
      .merchant         (merchant),
      .remainder        (remainder));

   //завершение моделирования
   initial begin
      forever begin
         #100;
         if ($time >= 10000)  $finish ;
      end
   end

endmodule // test

Результаты моделирования

Как показано на рисунке, два входных данных дают правильные результаты деления после задержки, равной количеству тактов, соответствующему разрядности делимого. Более того, достигается конвейерный вывод без дополнительной задержки, что соответствует проекту.

Скачать исходный код

Скачать