声明：本文转载于http://www.cnblogs.com/kingst/，版权归akuei2及黑金动力社区（http://www.heijin.org）共同所有。

第一章 整数乘法器

1.1 整数的概念

整数在 IEEE 的规定上有，短整数 short integer , 中整数 integer 和 长整数 long integer ，它们之间的关系如下：

在这里笔者以短整数为笔记的主角。

短整数的最高位是符号位，符号位的正负表示了该值是“正还是负”？。正值的表示方法很简单，反之负值的表示方法是以补码来表示。

+127 亦即 8'b0111_1111;

+4 亦即 8'b0000_0100;

-127 亦即 8'b1000_0001;

-4 亦即 8'b1111_1100;

补码在英文又叫 2^nd implementation   , 其实是“正值的求反又加一”的操作。（哎~年轻时的笔者曾经这个东西头疼过）。一个负值表示如 -4 ，是由 +4 求反由加一后而成。

8'b0000_0100;  // 正值 4

8'b1111_1011;  // 求反

8'b1111_1100;  // 加1 ， 负值 4

那么符号位和正值，负值，补码，取值由有什么关系呢？举个例子 ：A = 8'b0111_1111 (+127) 和 B = 8'b1000_0001 ( -127 )。

当我们在进行判断一个短整数是正值还是负值的时候，我们可以这样表示：

 if ( !A[7] ) ...  // A是正值

 if ( B[7] ) ...  // B是负值

在事实的事实上。我们知道短整数 2⁸ ，亦即取值范围是 0~255，但是符号位的出现吃掉了最高位，所以造成由 2⁸ 的取值范围变成 2⁷ = 0~171 。

你知道吗？在短整数家族里面永远存在一个幽灵成员。该成员很神秘，它不是正值，即不是负值或者0值。而且它的能力也不可忽视，它划分了正值和负值的边界，它就是 8'b1000_0000。

+127     8'b0111_1111;

划分      8'b1000_0000;

-127      8'b1000_0001;

换句话说，在 8'b1000_0000 之前的都是正值 ，然而在 8'b1000_0000 之后是负值。如果读者硬是要说 8'b1000_0000 是 “负0”，笔记也无话可说 ......

从上述的内容，我们可以知道：正值可以进行求反又加一之后成为负值。那么负值如何变成正值？同样的一个道理“负值求反又加一后，成为正值”。

8'b1111_1100;  // 负4

8'b0000_0011;  // 求反

8'b0000_0100;  // 加1 ， 正4

1.2 传统乘法的概念

笔者还记得笔者在上小学三年级的时候，老师在黑板上写上 3 x 4 = 12。笔者对这神秘的数学公式迷糊了头脑。后来老师解释道: " 3粒苹果重复加上4 次等于12粒苹果"，小时的笔者顿时恍然大悟！

当笔者上了初中，老师在黑板上写上 3 + -4 = -1。大伙们都明白那是整数，但是初中的笔者，脑袋过很迟钝。因为在现实中，初中的笔者认为没有“-3粒苹果”类似实体的概念纯在，后来老师解释道：“ 小明欠小黄4粒苹果，后来小明还了小黄1粒苹果，结果小明还欠小黄一粒苹果”，初中的笔者又恍然大悟。

又在初中，当老师又在黑板上写上如下的内容。那时候的笔者，嘴巴长得大大 ，有好一段时间说不出话来 。好一段时间笔者都是自己在嘀咕 ....

 3 x 4 = 12;    " 3粒苹果重复叠加4次，等于12粒苹果"

-3 x 4 = -12;    " 欠3粒苹果，重复欠4次，等于欠12粒苹果"

3 x -4 = -12;    " 欠4粒苹果，重复欠3次，等于欠12粒苹果 "

-3 x -4 = 12;    " @#￥%#￥*！%…… " ( 嘀咕中 ... )

读者们不要笑，上述的故事确实是笔者的真实故事。那时候的笔者，真的拿不到整数的乘法的门儿，考试还常常满江红，真的悲剧的初衷时代......

在传统的概念上乘法等价于“重复几次”。打个比方：B = 4；A x B 亦即 A要重复加四次才能得到答案。

然而在乘法中“负值正值的关系”就是“异或的关系”。

 A x B = C；

 3 x 4 = 12;   

-3 x 4 = -12;   

3 x -4 = -12;   

-3 x -4 = 12; 

从上面的内容看来，无论A值和B值是什么样的“正值和负值的关系”，结果C都是一样。

那么我们可以换一个想法：

“在作乘法的时候只是我们只要对正值进行操作。然而“负值和正值的结果”，我们用“异或”关系来判断 ... ”

实验一 ：传统的乘法器

该乘法器的大致操作如下：

（一）在初始化之际，取乘数和被乘数的正负关系，然后取被乘数和乘数的正值。

（二）每一次累加操作，递减一次乘数。直到乘数的值为零，表示操作结束。

（三）输出结果根据正负关系取得。

multiplier_module.v

第3~11行是该模块的输入输出。看到 Start_Sig 和 Done_Sig 是仿顺序操作的标志性结构，不明白的去看笔者之前写的笔记。Multiplicand 和Multiplier (被乘数和乘数)，都是8位位宽，所以输出 Product 是16位位宽。

第16~21行是该模块所使用的寄存器，i寄存表示步骤，Mcand 用来暂存 Multiplicand 的正值，Mer 用来暂存 Multiplier 的正值，Temp 寄存器是操作空间。然而 isNeg 标志寄存器是用来寄存 Multiplicand 和 Multiplier 之间的正负关系。

在步骤0（36~45行）是初始化的步骤。第39行isNeg寄存“乘数和被乘数之间的正负关系”。第40行，Mcand寄存 Multiplicand 的正值，该行表示：如果被乘数的符号位是逻辑1的话，就将负值转换为正值，然后Mcand寄存该值，否则Mcand直接寄存 Multiplicand 的值。第41行是用来寄存Multiplier 的正值，该行的操作和40行很相识。

在步骤1（47~49行），是“重复加几次”的操作。Temp寄存器的每一次值的叠加，Mer寄存就递减（49行）。直到Mer的值等于0（48行），就进入下一个步骤。步骤2~3是产生完成信号。

在62行，Product输出信号的输出值是由isNeg寄存器作决定，如果isNeg是逻辑1，那么Temp的结果从负值转换为正值。否则直接输出Temp的值。

multiplier_module.vt

第16~22行是复位信号和时钟信号的激励。第26~35行是 multiplier_module.v 的实例化。

第39行以下和普通的仿顺序操作的写法一样，不明白的话请看笔者以往写过的笔记。

步骤0~3, 会输入不同的乘数和被乘数来激励 multiplier_module.v。

仿真结果：

 实验说明：

其实传统的乘法器是很容易的，但是短整数的出现，负值和正值随着出现，使得设计上难以下手。但是只要掌握负值和正值的关系以后，乘法只作正值也“无问题”。只要在输出下一点手脚就行了。

实验结论：

传统的乘法器虽然简单，但是它有一个致命的问题。就是被乘数越大就越消耗时钟。具体的原因在下一章节解释 ......

1.3 传统乘法器的改进

Verilog HDL 语言所描述的乘法器的消耗是以“时钟”作为时间单位。反之，组合逻辑所建立的乘法器是以“广播时间”作为时间单位。说简单点就是，Verilog HDL 语言所描述的乘法器“快不快”是根据“时钟消耗”作为评估。

假设 A = 10 , B = 20,  A x B ，那么时钟的消耗至少需要20个，因为 A值需要累加20次才能得到结果。到底有没有什么办法，改进这个缺点呢？

有学过乘法的朋友都知道 A ( B ) = B ( A )。如果以实验一的乘法器作为基础，那么 A( B ) 和 B( A ) 所消耗的时间就不一样了。所以我们可以这样改进：

如果被乘数小于乘数，那么被乘数和乘数互换。

{ Multiplier , Multiplicand } = Multiplicand < Multiplier ? { Multiplicand ，Multiplier } :

                         {Multiplier ，Multiplicand }；

举个例子：Multiplicand = 2 ，Multiplicand = 10 ;

更换之前 被乘数2 需要10次的累加，才能得到结果。 更换之后 被乘数为10 乘数为2，亦即被乘数10只要累加2次就能得到结果。

如此一来，可以减少不少时钟的消耗。

实验二 : 传统乘法器改进

和实验一相比，在进行累加操作之间，多了一个被乘数和乘数比较的步骤。

（一）在初始化之际，取乘数和被乘数的正负关系，然后取被乘数和乘数的正值。

（二）乘数和被乘数比较，如果被乘数小于乘数，结果乘数和被乘数互换。

（三）每一次累加操作，递减一次乘数。直到乘数的值为零，表示操作结束。

（四）输出结果根据正负关系取得。

multiplier_module_2.v

和实验一先比，添加了一个比较的步骤（46~49行）。

仿真结果：

仿真 .vt 文件和实验一样。

在仿真的结果上，10 x 2 和 2 x 10 的时钟消耗都一样。

实验说明：

与实验一的乘法器比较，关于时钟的消耗多少都有改进。

实验结论：

传统的乘法器无论如何改进也好，当遇见如 127 x 127 的乘数和被乘数，咋也看不出什么优化 ......

1.4 补码君存在的意义

每一个人都有存在的意义，有的人用一生的时间去寻找自己的存在意义，有的人则是经过生活的大反转，看到了自己存在意义，有的人则不闻不问... 当然补码也有存在的意义，只是在前面的实验被笔者滥用而已。

补码不仅可以执行正值和负值转换，其实补码存在的意义，就是避免计算机去做减法的操作。

     1101     -3补

+    1000     8

      0101     5

假设 -3 + 8，只要将 -3 转为补码形式，亦即 0011 => 1101，然后和8，亦即1000相加

就会得到 5，亦即0101。至于溢出的最高位可以无视掉。

1101     -3补

+     1110      -2补

   1011     -5补

其实你知道吗，如Quartus II 综合器 ，当我们使用“－”算术操作符的时候，其实就是使用补码的形式，具体如下：

A = 8'd5;

B = 8'd9;

A － B 等价于 A + ( ~B + 1'b1 )；

在实际的操作中，综合器都会如上优化。

1.5：Booth算法乘法器

传统的乘法器是有极限的，因此位操作乘法器就出现了。笔者在网上冲浪找资源的时候，还常常撞到许多稀奇古怪的位操作乘法器。但是有一种位操作乘法器，吸引了笔者的眼球，它就是 Booth算法乘法器。实际上 Booth 算法是一种“加码”乘法运算。

Booth 算法的概念也很简单，我们先从数学的角度去理解看看：

B[-1] 是什么？先假设 B是2的，然而B的最低位的右边后一个“负一位”那就是B[-1]。

0010 0  // LSB 右边出现的就是 -1位

那么上面那个加码表和乘法又有什么关系呢？其实要加码的目标是“乘数”，假设乘数为2, 那么乘数2的加码过程会是如下。

举个例子，被乘数为7，0111; 乘数为2，0010；结果会是什么？

从数学的角度看来，确实Booth算法是麻烦的存在，但是在位操作的角度来看就不是这么一回事。实际上在千奇百怪的位操作乘法中，Booth算法其中可以容纳“补码”亦即“负数”来执行操作。

上面的图表是位操作时候的 Booth 算法。Booth算法在位操作的时候，它使用一个很有个性的空间，就是P空间。

先假设：被乘数A 为7 (0111)，乘数B为2 (0010) ，它们n均为4位，所以 P空间的容量是 n x 2 + 1 , 亦即 9 位。

_ _ _ _ _ _ _ _  _  // P空间

那么P空间如何实现乘法的位操作呢？

从上面的操作看来，由于乘数和被乘数均为 n 位所以 “判断P[1:0]，后操作,之后移位”的操作仅执行四次而已。

实验三：Booth算法乘法器

实验中建立的Booth算法乘法器大致的步骤正如 1.5章节所描述的那样。

booth_multiplier_module.v

第13~15行是仿真的输出（S - Simulation , Q - Output）。第20~25行定义了该模块所使用的寄存器。a寄存器用来寄存 A 值，s寄存器用来寄存 -1(A) 的值，p寄存器是P空间。输入信号A和B均为8位位宽，所以p寄存器是17位位宽。至于X寄存器是用来表示n位，用来指示 n 次循环。

步骤0（40~41行），初始化了a，s寄存器。p[8:1]填入B值，亦即乘数，其余的位均为0值。

步骤1（43~51行）是用来判断 p[1:0] 的操作。步骤2（53~55行）是执行右移一位，是补0还是补1，完全取决于p[16]。步骤1~2会重复交替执行，直到X的值达到8次，就会进入下一步步骤。

步骤3~4（57~61行）是用来产生完成信号。第68行输出信号product 是由p空间的[16..1]来驱动。第72~74行是仿真用的输出信号，功能如字面上的意思。

booth_multiplier_module.vt

在仿真中，从步骤0~3（59~73行），激励了不同A和B的值（被乘和数乘数）。

仿真结果：

P空间的详细操作过程，自己代开modelsim看吧，界面有限的关系。从仿真结果上可以看到，4次的乘法操作所使用的时间都一样，尤其是 -127 x -127 的情形，不像传统乘法器那样累加127次，才能得到结果。（p空间的[ Width :1]是用来填入乘数B，然而p空间的 [Width * 2 : Width + 1 ] 是用来执行和被乘数A的操作）

实验结论：

按常理来说8位的乘数和被乘数，位操作会是使用8个时钟而已，但是实验3的乘法器，需要先操作后移位的关系，所以多出8个时钟的消耗 ......

1.6 笔者情有独钟的步骤i

在笔者初学Verilog HDL语言，笔者老是捉不好 Verilog HDL 语言和时序的关系，吃了不少苦头。世界就是很巧妙，脑子里就忽然间冒出步骤i。

步骤i是什么？

有关《Verilog HDL 那些事儿》那本笔记，虽然笔者的实例都和“它”有关。但是在笔记中，笔者只是微微的带过“步骤i是仿顺序操作相关的写法 ... ”。但是要探讨步骤i是什么，那不是初学 Verilog HDL 的任务。步骤i的用法很简单，从概念上和“顺序操作”很类似，它可以补助初学者不必过度依赖功能仿真，也能“从代码中看到时序”。

如果从低级建模的角度去探讨步骤i，低级建模里面有一个准则，就是“一个模块一个功能”，步骤i好比这个准则的支持者。步骤i从0开始，表示了这个模块开始工作，直到i被清理，这也表示了这个模块已经结束工作。或者可以这样说“一个模块不会出现两个步骤i”。

具体上，步骤i的“值”是指示着“第几个时钟沿”发生，然而 Verilog HDL语言里的“步骤”和C语言里的“步骤”是不一样。C语言里的“步骤”就好比“把大象放进冰箱需要几个步骤 ... ”。相反的 Verilog HDL 语言里的“步骤”，有如“时间点”的观念。

如上面的示意图所示, 在这个时间点里所发生的“决定”会产生不一样的未来。然而在这个时间点里“可以允许不同的决定在这一刻存在”。举一个例子：A的初值是4，B的初值是0。

case( i )

0:

begin A <= A + 2'd2; B <= B + 2'd3; i <= i + 1'b1; end

1:

if( A > 3 ) begin B <= A; A = 0; i <= i + 1'b1; end

else if i <= i + 1'b1;

咋看是一个简单的代码，但是你知道里边包含的秘密吗？

在 i = 0的时候，A 累加2，B 累加 3。

在 i = 1的时候，如果Ａ大于３, 就Ｂ寄存Ａ的值将Ａ清零。

无论是ｉ等于０还是等于１，它们“只是这一时间点发生的决定”，结果会在这个时间点的过后发生。如果用“生动”的话来描述的话。

在时间点０的时候，这个模块决定Ａ累加２，Ｂ累加３。然后在时间点０过后，结果就产生。直到迎来下一个时间点，这个模块才能再一次作决定。

在时间点１的时候，这个模块判断Ａ是否大于3。那么，问题来了“这个模块是以什么作为基础，判断A大于3呢？”。答案很简单就是“时间点1的过去的结果”或者说“在时间点0过后所产生的结果”。

上图完全将上述的内容表达了出来。在这里笔者有一个很在意的问题，那就是 "<=" 赋值操作符。在众多的参考书中“<=”赋值操作符被解释为“时间沿有效的赋值操作符”。笔者初学的时候的，完全不知道它是虾米 ... 如果换做时间点的概念来说“<=”的操作符，表示了“在这个时间点下决定”专用的赋值操作符。

与“=”赋值操作符不一样，它是没有时间点的概念的赋值操作符。所以在 always @ ( posedge CLK ... ) 有效区域内，它是不适合使用，因为它会破坏这个模块的时间和结果。

我们的人生，下错了决定只要知错，吸取教训还有从来的机会。但是模块下错了决定，就影响它的一生，所以我们在编辑的时候要特别小心，不然会可能因我们的疏忽，导致了这个模块的一生悲剧。

小时候，笔者读道德教育的时候，有一句话是笔者一生受用，那就是“先三思而后行”。

这个又和上述的内容有什么关系呢？

我们知道“时间点”的概念就是“就是在这个时间点决定了什么，这个时间点的过后会产生什么”。难道模块的世界就是那么现实, 就连三思的机会也没有吗？这是一个很好的问题 ......

举个例子，有一个模块他有 A ，B和C三个寄存器，它们的初值都是0：

case( i )

   0:

   begin A <= 3; B <= 4; C <= 0; i <= i + 1'b1; end

   1:

   begin

       C <= A + B;

       if( C > 0 ) begin A <= 0; B <= 0 ; end

       else begin A <= 1; B <= 1; end

       i <= i + 1'b1;

   end

从上面的代码，我们可以知道。在时间点0，该模块决定了 A 等于3，B等于4，C等于0。然后到了时间1, 问题来了“在时间点1，该模块是以什么作为基础去判断 C 的值呢？是时间点1过去的C值，还是在这一个瞬间 A + B 所产生的值？”。

答案如上图所示，if是以时间点1过去的C值作为判断的基础。所以说模块的现实是很残忍的，它们不但没有重来的机会，就连“思考”的时间也不给它。它们"只能以当前时间点过去的值，作为当前时间点下决定的参考 ......  ( 写到这里, 笔者流泪了! )

实际上“=”不是不可以在 always @ ( posedge CLK ... ) 里出现，只不过它比较危险。

case( i )

   0:

   begin A <= 3; B <= 4; C <= 0; i <= i + 1'b1; end

   1:

   begin

       C = A + B;

       if( C > 0 ) begin A <= 0; B <= 0 ; end

       else begin A <= 1; B <= 1; end

       i <= i + 1'b1;

   end

笔者将上面的代码稍微修改了一下， 在步骤1 变成了 C = A + B。

如果把步骤i按照“时间点”的概念，结果会是如上图。在时间点1，“=”造成了一个而外的时间停止空间，在这个空间里 C 不但可以“作决定”，而且“即时得到结果”。在某种程度上，它的存在会破坏和谐，如果没有步骤i的控制，它很容易暴走。笔者在设计模块中，除非出现“不得已”的情况，否则笔者在 always @ ( posedge CLK ... )区域内，绝对不会使用它。

1.7 Booth算法乘法器的改进

在实验三中所建立的Booth算法乘法器，要完成一次乘法计算，至少要消耗16个时钟，而且其中8个时间就是消耗在移位的方面上。那么有什么办法改进 实验三中的 Booth算法乘法器呢？

在1.6章节，笔者说了步骤i有如时间点的概念，假设我这样修改实验三的Booth乘法器 ：

case ( i )

   0: ... 初始化

   1,2,3,4,5,6,7,8:

   begin

       if( p[1:0] == 2'b01 ) p <= { p[16] , p[16:9] + a , p[8:1] };

       else if( p[1:0] == 2'b10 ) p <= { p[16] , p[16:9] + s , p[8:1]};

       else p <= { p[16] , p[16:1]};

       i <= i + 1'b1;

   end

从上面的代码，读者能看出什么破绽吗？我们尝试回忆 Booth算法的流程图，先判断p[1:0] 的操作，然后右移一位，最高位补0还是补1,是取决与 经p[1:0]操作之后的p[16]。

那么问题来了，从上面的代码看来 p <= { p[16] , p[16:9] + a , p[8:1]}; 其中的 p[16] 是以当前时间点的过去值作为基础，而不是p[1:0]操作过后的值, 所以上面的代码不行！

case( i )

0: ... 初始化

1,2,3,4,5,6,7,8：

begin

    Diff1 = p[16:9] + a;  Diff2 = p[16:9] +s;

    if( p[1:0] == 2'b01 ) p <= { Diff1[7] , Diff1 , p[8:1]};

    else if( p[1:0] == 2'b10 ) p <= { Diff2[7] , Diff2 , p[8:1]};

    else p <= { p[16] , p[16:1]};

    i <= i + 1'b1;

end

上面的代码表示了，在步骤1~8里 Diff1 寄存了 p[16:9] + a 的结果，反之 Diff2 寄存了 p[16:9] + s的结果。然后判断 p[1:0] 再来决定 p的结果是取决于 Diff1 ，Diff2 或者其他。和第一段的代码不同，第二段代码的p输出值是一致的。在这里有一个重点是，Diff1 和 Diff2 没有使用“<=”而是使用 “=”，换一句话说，Diff1 和 Diff2 结果的产生在“该时间点作决定的时候”，亦即“取得即时的结果”，而不是该时间点过后，才产生结果。

实验四：Booth算法乘法器改进

基于实验三的Booth算法乘法器，从原先的一次乘法需要16次、个时钟，优化至8个时钟。

booth_multiplier_module_2.v

同样是 Booth 算法的原理，和实验三不同的是在55~67行，是步骤1~8的循环操作。不再使用X寄存器作为循环计数，而是直接使用步骤来指示8个循环操作。在55~67行，这样的写法有一个好处，就是可以使得p的值输出一致，因此可以减少8个时钟。

仿真结果：

实验四所使用的 .vt 文件和实验三的一样。

从仿真结果看来，一次的乘法操作只消耗8个时钟而已（步骤0初始化，和步骤9~10完成信号产生除外）。现在我们把上面的仿真结果切成一块一块的来看。

实验说明：

如果以“大象放进冰箱”这样的概念去理解步骤i，在实验四中可能会产生许多思考逻辑上的矛盾。换一个想法，如果以“时间点”的概念去理解步骤i的话，从仿真图看来是绝对逻辑的。（再唠叨的补充一下，p空间的[ Width :1]是用来填入乘数B，然而p空间的 [Width * 2 : Width + 1 ] 是用来执行和被乘数A的操作）

实验结论：

这一章节笔记的重点不是要“如何如何实现一个算法”，而是“以不同概念的理解去完成乘法器的改进”。

1.8 LUT乘法器

从1.8章节以前的乘法器都可以归纳为“慢速乘法器”，当然它们不是真正意义上的慢，只不过它们无法达到急性一族人的任性而已。LUT乘法器，又成为查表乘法器。用傻瓜的话来说，就是先吧各种各样的结果储存在一个表中，然后将输入资源以“查表”的方式，许对比“等于的结果”。

举个例子，笔者先建立一个 16 x 16 正值的查表：

假设A x B，它们均为4位，A为10，B为2，那么结果会是 20。查表乘法器之所以被称为快速乘法器，就是上面的原因 ( 实际上许多硬件乘法器都是使用查表的方式 )。

如果 A x B ，它们均为8位，那么应该如何呢？难道再建立一个 256 x 256 乘法器！？这样会死人的。

不知道读者有没有听过Quarter square 乘法查表呢？

上边是该算法的公式，在公式的结束得到 ab = ( ( a + b )² )/4 - ( ( a - b )² )/4 。

如果再进一步细分的话，无论是 ( a + b )²/4  或者 ( a - b )²/4 ，经过幂运算后，得到的结果都是正值。

假设a 和 b的位宽都是 8 位的短整数话 ( 127 + 127 )² / 4 = ( -127 - 127 )² / 4。那么我们可以得到一个结论“ ( a + b )²/4  或者 ( a - b )²/4  使用同样的 (C)²/4 查表”。

那么我们建立一个 C = 0 ~ 255 ，并且内容是 (C)²/4 的查表。

这个查表的寻址虽然是 0~255，但是实际上下限是254而已。因为我们知道两个短整数最大值相加仅有 -127 + -127 = -254 或者 127 + 127 = 254 。

那么问题来了, 短整数的最大取值范围是 -127 ~ 127 而已，何来寄存 -254 ~ 254 呢？

这里我们就涉及了“不同容量空间的相互赋值”。假设 C 是9位位宽的不正规整数

，然而 A 和 B 都是 8位位宽的正规整数，那么 C = A + B ?

接下来，我们来看一看下面的代码：

reg [8:0]I1,I2;

case( i )

0:

begin

    I1 <= { A[7], A } + { B[7], B };            // C =A + B;

    I2 <= { A[7], A } + { ~B[7], ( ~B + 1'b1 ) };  // C = A - B;

    i <= i + 1'b1;

end

1:  // 取正值

begin

    I1 <= I1[8] ? ( ~I1 + 1'b1 ) : I1;

    I2 <= I2[8] ? ( ~I2 + 1'b1 ) : I2;

    i <= i + 1'b1;

end

上面的 I1 和 I2 均为9位位宽。在步骤0，I1表示了 C = A + B，相反的 I2 表示了 C = A - B。由于短整数的赋值采用补码的表示方式，所以大大简化了正负转换的操作。

假设 A = -1 ( 1111 1111 ) , B = -3 ( 1111 1101 ), 经过上面步骤0的操作：

I1 = { 1 11111111 } + { 1 1111 1101 } = 1 1111 1100 (-4) 等价于 I1 = -1 + -3 = -4

I2 = { 1 11111111 } + { 0 0000 0011 } = 0 0000 0010 ( 2) 等价于 I2 = -1 - (-3) = -1 + 3 = 2

步骤1是 I1 和 I2 从负值转换为正值。

假设 I1 = -4 (1 111 1100) ，I2 = 2 (0 0000 0010), 经过步骤1的操作：

I1 = 0 0000 0011 + 1 = 0 0000 0100;

I2 = 0 0000 0010;

为什么在步骤1中，要特意将负值转换为正值呢？笔者在前面已经说过，无论是 (-C)² 还是 (C)² 取得的结果都是一至。为了两者 I1 和 I2 共用相同的查表这是必须的步骤。

如果用 I1和I2 来表达 Quarter square 公式，那么：

 ( | I1 |² / 4 ) - ( | I2 |² / 4 )

实验五：基于 Quarter square 的查表乘法器

首先笔者手动建立 0~255 关于 (C)²/4 结果的 lut_module.v ，因为用Quartus II建立的rom 仿真不给力，很别扭。

lut_module.v

这是我目前，贴过最长的 .v 文件了 ...

lut_multiplier_module.v

这个模块的功能很简单。首先取得 I1 = A + B ，I2 = A - B，然后I1 和 I2 都正值值，将I1 和 I2 送至各自的查表，然后将得出的结果Q1_Sig (I1的结果) 和 Q2_Sig

(I2的结果) , 执行相减。实际上是补码形式的相加，Q1_Sig + ( ~Q2_Sig + 1'b1 ) ，以致符合Quarter square的公式：

 ( a + b )²/4  - ( a - b )²/4 = ( |I1| )²/4  + [ ( |I2| )²/4]补

                               = Q1_Sig + [Q2_Sig]补

第15~18行是仿真的输出。第26~27行建立 Q1_Sig 和 Q2_Sig ，实际上这两个线型数据是U1（81~87行）和 U2（91~97行） 实例前申明的，可是modelsim 那么混蛋，偏偏就不给我通过。

从37~77行是该模块的主功能。步骤0（49~54行）是取 I1 和 I2 的值。步骤1（56~61行）是I1和I2的正值化操作。步骤2（63~64行）是延迟一个时钟，给予足够的时间从 lut_module.v读出结果。步骤3（66~67行），是Quarter square公式操作的最后一步。

89~99行是 lut_module.v 的实例化 ，U1是给 I1使用 ，U2是给I2使用，它们的输出连线分别是 Q1_Sig 和 Q2_Sig 。102行的Product 输出信号由 Data寄存器驱动。然而106~109行是仿真输出的驱动，分别有I1 , I2 ,Q1_Sig 和 Q2_Sig 的仿真输出。

lut_multiplier_module.vt

.vt 文件的写法和之前的实验都一样，如果真的不知道笔者在写什么，就得好好看笔者之前写的笔记。

仿真结果：

看吧！一次的乘法操作仅需4个时钟的而已。比起改进的Booth算法减少了一半的时钟消耗。真不愧是查表式的乘法器，佩服佩服。

实验结论：

说实话查表式的乘法器是“以空间换时间”的乘法器，所以说查表式的乘法器是很消耗空间。到底有什么乘法器“可以节约空间，又节省时钟”呢？

你知道吗？传统查表的乘法器都有一个僵局，假设A(B)，那么其中一个变量需要是“恒数”，否则建立查表的工作是非常的劳动。但是Quarter square 公式的出现把这个僵局给打破。感谢前人的努力吧，我们后人才能乘凉 ......

1.9 Modified Booth 算法乘法器

事先声明 modified booth 算法 和 改进的 booth 算法乘法器（实验四）是没有任何关系的。如字面上的意思 modified booth 算法是 booth算法的升级版。我们稍微来回味一下 booth 算法。

假设B是4位位宽的乘数，那么 booth 算法会对 B[0: -1] , B[1:0], B[2:1], B[3:2] 加码，而使得乘法运算得到简化。booth 算法有典型数学做法，也有位操作的做法。Modified booth 算法比起 booth 算法，对于4位位宽B乘数的加码返回会更广，而使得 n/2 乘法运算的优化。再假设B是4微微款的倍数，那么 modified booth 算法会对 B[1:-1] , B[3:1] 执行加码。

如果站在位操作的角度上：

Modified booth 算法同样也有使用 p空间，假设乘数A，和被乘数B，均为4位，那么p空间的大小 n x 2 + 1 ，亦即 9位。乘数A为7 (0111)，被乘数B为2 (0010)。

关于 4 位为位宽的乘数和被乘数操作流程图如下：

说实话 modified booth 算法的位操作是很不规则，从上面的流程图可以看到，不同的p[2:0]操作都有“不同的步骤次数”，这也使得它非常不适合作为运用。

实验六：Modified Booth 乘法器

这个模块大致的操作如上述的流程图。

modified_booth_module.v

15~17行是仿真输出。43~94行是该模块的主功能。在步骤0（45~51行）取得被乘数A并且寄存在a寄存器，此外取得 -1(被乘数A) 并且寄存在s寄存器。在初始化p空间的同时，将乘数B填入p[8:1]。

（由于被乘数A和乘数B的位宽为8，所以p空间是 n x 2 + 1 亦即9。我知道我很长气，但是还是容许笔者补充一下：p空间的[ Width :1]是用来填入乘数B，然而p空间的 [Width * 2 : Width + 1 ] 是用来执行和被乘数A的操作）。

步骤1和2（53~62行）是p[2:0] 等于 3'b000 | 111 | 001 | 010 | 101 | 110 的操作。相反的，由于 modified booth 算法当 p[2:0] 等于3'b011 和 3'b100 所执行的步骤次数是不一样（56~57行）。

所以在步骤3~5（66~73行）针对 p[2:0] 等于 3'b011 的操作（56行）。反之步骤6~8 (77~84行)针对 p[2:0] 3'b100 的操作（57行）。

步骤9~10产生完成信号。第102行的product输出信号是由 p[16:1]来驱动。第106~109的仿真输出信号，分别由寄存器 a ，s 和p来驱动。

modified_booth_multiplier_module.v

这是激励文件，在写这个文件的时候，笔者心情很糟糕，所以在步骤5加入了类似for嵌套循环的东西。其他的和之前的 .vt 文件都是大同小异 ~自己看着吧。

仿真结果：

在仿真结果中，可以很明显的看到当 2(4) 和 127（-127）有明显的时钟消耗差异。

实验结论：

如果 Modified booth 算法用在“位操作”，虽然它是快速的乘法操作，但是很多时候它还是很别扭。换句话说，用它还要图运气，因为不同的乘数和被乘数都有不同的时钟消耗 ......

1.10 Modified Booth 乘法器·改

如果要把 Modified Booth 乘法器别扭的性格去掉，我们不得站在“数学的角度”去看 modified booth 算法。下表是从数学的角度去看modified booth 针对乘数B的加码。

我们假设 A被乘数和乘数B均为4位位宽 ：A=7（0111），B=2（0010）。

A = (7) 0000 0111；2A = (14) 0000 1110；-2A = (-14) 1111 0010。

在这里我们必须注意一下当 B[1:-1] 等于 011 或者 100 的时候，4位的被乘数A的取值范围最大是 -7 ~ 7 然而，+2(被乘数) 或者 －2(被乘数) 都会使得A的最大值突破取值范围。所以需要从4位位宽的空间向更大的位位宽哦空间转换。这里就选择向8位位宽的空间转换吧。

B乘数加码为 B[1:-1] = 3'b100 ，亦即 －2(被乘数) 和 B[3:1] = 3'b100 ，亦即 +被乘数。

    A      0 1 1 1

    B      0 0 1 0  0

    ==============

           +1  -2       B乘数加码

    ==============

  1 1 1 1 0 0 1 0

 + 0 0 0 0 0 1 1 1          << 2 左移两位

   ===============

    1 0 0 0 0 1 1 1 0      无视超过8位最高位的益处

   ===============

还记得 booth算法在数学角度上的运算吗？4位的乘数和被乘数相乘，乘数必须加码n次，而且乘积也是 n 位的次数，亦即4次哦加码操作，和4次的乘积操作。相反的 modified booth 算法在数学的角度上运算的话，4位的乘数和被乘数相乘，乘数加码为 n位/ 2 次，而且乘积也是n位/2 的次数，亦即 2次加码操作，和2次的乘积操作

实验七：Modified Booth 乘法器·改

modified_booth_multiplier_module_2.v

第29~27行是该模块所使用的寄存器。a是用来寄存A，a2是用来寄存2A，s是用来寄存 -A，s2是用来寄存 -2A。M是用来表示每次乘积的偏移量。

由于这个实验不是站在位操作的角度上，所以P空间仅是作为累加空间的存在。作为补偿寄存器N用来判别 booth 加码操作，所以寄存器N用于寄存乘数B的值。乘数B是8位位宽，所以N空间的大小是 “乘数B的大小 + 1”。多出来的1个空间是用来寄存B[-1]的值。”

在步骤0（54~65行），是用来初始化所有相关的寄存器。寄存器a，a2，s，s2 在初始化的同时也进行 8位 向 16位 空间转换。寄存器p和M都清零，至于寄存器N[8:1]是用来填充乘数B，N[0] 填入零值。

步骤1~4（67~79），也就是4次的乘积次数，因为受到 n/2 的关系。每一次的乘积操作都是先判别N[2:0]，然后累加相关的值。

我们知道传统的乘法，每一次的乘积操作，都有偏移量 ，打个比方。

   123

   111

=====

   123  <= 十进制的第一个乘积是 偏移 0，没有左移位操作。

  123   <= 十进制的第二个乘积是 偏移10，也就是左移1位。

 123    <= 十进制的第三个乘积是 偏移100，也就是左移2位。

=====

同样的道理寄存器M 是用于记录二进制的每一次乘积偏移量，但是 modified booth乘法的乘积偏移量是普通2进制乘法乘积偏移量的2被。所以每一次乘积操作结束都左移+2。

至于寄存器N它寄存了 B[7:1] + B[-1] 的值。然而每一次用于的判别都是 N[2:0],所以每一次的乘积之后，N都需要右移两位。

假设 B = 1101 0010 ， N 必然是 1101 0010 0。

为什么说 8 位位宽的数据相乘，乘积运算次数是 n / 2 ，亦即 4。这是 Modified booth算法的一个特点。如果站在数学的角度上，他可以节省“乘积次数 / 2”。

第92行的 product 输出是由寄存器p驱动。前面笔者说过了，如果站在数学的角度，p空间只是累加空间的作用而已。然而p空间的大小是“乘数和被乘数位宽大小的相加”。

第96~101行是仿真输出信号的被驱动。有一点很特别，除了寄存a, a2, s, s2 和 N 以外，笔者还故意将该模块的 i 引出，这是为了观察“Modified booth 乘法使得乘积次数减半”这一事实。在仿真中，SQ_i 从1~4经过，如果输出的结果是真确，那么可以证明 Modified booth算法确实何以减少一半的乘积。

modified_booth_multiplier_module_2.vt

仿真结果：

从仿真结果上，我们可以看到，每一个乘法操作都消耗同样数目的时钟。此外还有一点, 当SQ_i 等于 4 之后，就会得到正确的答案。

实验结论：

实验七和实验六相比，不仅每一次乘法操作时钟消耗都一致，而且这样结果带来一个好处，就是- 实验七和实验六相比比起乘法运算更快。此外，从SQ_i信号等于4之后，product 就输出正确的结果，所以我们可以证明 modified booth算法是可以减半乘积的次数。