Принцип работы делителя (с фиксированной точкой)
Подобно делению в десятичной системе, процесс вычисления 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):
Пример
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):
Пример
//используется 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 и добавьте самопроверку в тестбенче, как описано ниже:
Пример
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
Результаты моделирования
Как показано на рисунке, два входных данных дают правильные результаты деления после задержки, равной количеству тактов, соответствующему разрядности делимого. Более того, достигается конвейерный вывод без дополнительной задержки, что соответствует проекту.
Скачать исходный код
Скачать
