实验目的

• 理解定点乘法的不同实现算法的原理，掌握基本实现算法。
• 熟悉并运用 Verilog 语言进行电路设计。
• 为后续设计 CPU 的实验打下基础。

实验内容

定点乘法器有多种实现，实验要求实现迭代乘法器，其结构如图所示。

乘数每次右移一位，根据最低位，判断是加被乘数移位后的值还是加0，不停地累加，最后就得到乘积了。

可以看到迭代乘法是用多次加法完成乘法操作的，故需要多拍时间，其结束标志为乘数移位后为0，故对于32位乘法，最多需要32拍才能完成一次乘法。

原码一位乘

该迭代乘法器的运算过程与原码一位乘相似。

原码一位乘运算规则主要由两部分组成：

• 乘积的符号位由两原码符号位异或运算结果决定。
• 乘积的数值部分由两数绝对值相乘。

基本硬件配置框图

图中A、X、Q 均为 n +1位的寄存器，其中 X 存放被乘数的原码，Q 存放乘数的原码。移位和加控制电路受末位乘数 Q 的控制 （当 \(Q_n\) = 1 时，A 和 X 内容相加后，A，Q 右移一位; 当 \(Q_n\) = 0 时，只作 A、Q 右移一位的操作)。计数器 C 用于控制逐位相乘的次数。S 存放乘积的符号。\(G_M\)为乘法标记。

原码一位乘控制流程

乘法运算前，A 寄存器被清零，作为初始部分积，被乘数原码在 X 中，乘数原码在 Q 中，计数器 C 中存放乘数的位数 n。乘法开始后，首先通过异或运算，求出乘积的符号并存于 S，接着将被乘数和乘数从原码形式变为绝对值。然后根据Q的状态决定部分积是否加上被乘数,再逻辑右移一位,重复 n 次，即得运算结果。

设计代码

本乘法器，类似于原码一位乘。为了减少循环加法次数，添加了比较两因数的大小的部分。

所以主要流程如下：

1. 初始化各信号，得出积的正负符号，将两因数的绝对值存于寄存器。

2. 比较两因数的绝对值大小，符合条件交换，减少 加法次数 。

3. 迭代加法运算，两因数的绝对值分别左移，右移运算。

4. 加法迭代完成，输出信号。

   module multiplier # (parameter WIDTH = 32)(
   input sys_clk,
   input rst_n,
   input [WIDTH - 1 : 0] multiplicand, // 因数
   input [WIDTH - 1 : 0] multiplier, // 因数
   input start,
   output [WIDTH * 2 - 1 : 0] mult_end,
   output done
   );
   reg [WIDTH - 1 : 0] multiplicand_temp;
   reg [WIDTH - 1 : 0] multiplier_temp;
   reg [WIDTH * 2 - 1 : 0] product;
   reg pos_neg_flag;
   reg [1:0] i;
   reg done_temp;
   reg start_temp;

   assign mult_end = pos_neg_flag ? (~product + 1'b1) : product;
   assign done = done_temp;
   
   always @(posedge sys_clk) begin
       if (!rst_n) begin
           done_temp <= 1'b0;
           start_temp <= 1'b0;
       end
       else if (start) begin
           start_temp <= start;
       end
       else if (done_temp) begin
           start_temp <= 1'b0;
       end
   end
   
   always @(posedge sys_clk) begin
       if (!rst_n) begin
           multiplicand_temp <= 0;
           multiplier_temp <= 0;
           product <= 0;
           i <= 2'b0;
       end
       else if (start_temp) begin
           case (i)
               0: begin
                   pos_neg_flag <= multiplicand[WIDTH - 1] ^ multiplier[WIDTH - 1];
                   multiplicand_temp[WIDTH - 1 : 0] <= multiplicand[WIDTH - 1] ? (~multiplicand + 1'b1) : multiplicand;
                   multiplier_temp <= multiplier[WIDTH - 1] ? (~multiplier + 1'b1) : multiplier;
                   i <= i + 1'b1;
               end
               1: begin // 交换大小，减小加法次数
                   {multiplicand_temp, multiplier_temp} <= (multiplicand_temp > multiplier_temp)?
                   {multiplicand_temp, multiplier_temp} : {multiplier_temp, multiplicand_temp};
                   i <= i + 1'b1;
               end
               2: begin
                   if (!multiplier_temp) begin
                       i <= i + 1'b1;
                   end
                   else begin // 加法
                       if (multiplier_temp[0]) begin
                           product <= product + multiplicand_temp;
                       end
                   multiplier_temp &lt;= {1'b0, multiplier_temp[WIDTH - 1 : 1]};
                   multiplicand_temp &lt;= {multiplicand_temp[WIDTH - 2 : 0], 1'b0};
               end
           end
           3: begin
               done_temp &lt;= 1'b1;
               i &lt;= 2'b0;
           end
       endcase
   end
   end

   endmodule

仿真

仿真仅有一个测试，\(12 \times -12\)，结果应为\(-144\)。

`timescale 1ns / 1ps
module sim();
    reg sys_clk;
    reg rst_n;
    reg start;
    reg [31 : 0] multiplicand;
    reg [31 : 0] multiplier;
    wire [63 : 0] mult_end;
    wire done;

    initial begin
        sys_clk = 0;
        forever #10 sys_clk = ~sys_clk;
    end
    initial begin
        start = 1;
        #1020 start = 0;
    end

    initial begin
        rst_n = 0;
        #1000 rst_n = 1;
    end

    initial begin
        multiplicand = -32'd12;
    end

    initial begin
        multiplier = 32'd12;
    end

    multiplier u0 (
        .sys_clk(sys_clk),
        .rst_n(rst_n),
        .start(start),
        .done(done),
        .multiplicand(multiplicand),
        .multiplier(multiplier),
        .mult_end(mult_end)
    );
endmodule

波形图

其他乘法器

• Booth乘法器：更适合硬件实现的乘法器算法。

• 华莱士树：通过面积换时间的方式实现并行加法。

参考文献

唐朔飞. 计算机组成原理[M]. 北京: 高等教育出版社, 2020.