数字IC前端学习笔记:数字乘法器的优化设计(基4布斯编码华莱士树乘法器)

本文主要是介绍数字IC前端学习笔记:数字乘法器的优化设计(基4布斯编码华莱士树乘法器),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

相关阅读

数字IC前端icon-default.png?t=N7T8https://blog.csdn.net/weixin_45791458/category_12173698.html?spm=1001.2014.3001.5482


        使用基2布斯乘法器虽然能减少乘数中0的数量,但最终还是无法减少部分积的数量,因此一种更合理的编码方式产生了——基4布斯编码。它可以将部分积的数量减少一半,本文中还会使用华莱士树结构对部分积进行压缩,进一步提高其性能。

        基4布斯编码的推导和基2布斯编码类似,首先同样把乘数展开为2的幂之和形式。

X=-X_{n-1}2^{n-1}+\sum_{i=0}^{n-2}X_{i}2^{I}=-X_{n-1}2^{n-1}+X_{n-2}2^{n-2}+X_{n-3}2^{n-3}+...+X_{2}2^{2}+X_{1}2^{1}+X_{-1}

        基4布斯编码的基系数为Coef_{I}=(-2B_{i+1}+B_{i}+B_{i-1}),上式可改写为:

-2X_{n-1}2^{n-2}+X_{n-2}2^{n-2}+2X_{n-3}2^{n-3}-2X_{n-3}2^{n-4}+X_{n-4}2^{n-4}+2X_{n-5}2^{n-5}-X_{n-5}2^{n-5}+...=(-2X_{n-1}+X_{n-2}+X_{n-3})2^{n-2}+(-2X_{n-3}+X_{n-4}+X_{n-5})2^{n-4}+... 

        编码规则变成了从X_{0}开始每次检查三位,注意,第二个被检查的位是X_{2},所以设计要求被乘数包括符号位为偶数位,如果不满足,则需要符号拓展一位以适应编码规则。根据上述推导,总结得到的基4布斯编码规则如下表1所示。

表1 补码的基4布斯编码规则

Xn+1

Xn

Xn-1

Code

BRCn+1

BRCn

被乘数操作

0

0

0

0

0

0

0

左移两位

0

0

1

1

0

1

+1

相加,左移两位

0

1

0

2

0

1

+1

相加,左移两位

0

1

1

3

1

0

+2

左移一位,相加,左移一位

1

0

0

4

1

0

-2

左移一位,相减,左移一位

1

0

1

5

0

1

-1

相减,左移两位

1

1

0

6

0

1

-1

相减,左移两位

1

1

1

7

0

0

0

左移两位

        将相邻三位编码成两位,每位可以是1、1和0,其实也可以编码成一位,这样每位就可以是0、1、2、12,最后结果的处理都是一样的。

        乘法器每次检查乘数的三个位,并决定执行以下操作之一:

  1. 被乘数相加并左移两位。
  2. 被乘数左移一位,相加,再左移一位。
  3. 被乘数相减(加上被乘数相反数的补码),并左移两位。
  4. 被乘数左移两位。

        作为基4布斯编码的一个例子,下图1给出了十进制-65的基4布斯编码。

图1 十进制数(-65)基4布斯编码

        基4布斯编码华莱士树乘法器由三部分组成,基4布斯编码模块、部分积产生模块和最后的华莱士树累加结构。下面分别介绍它们的详细组成。

        基4布斯编码模块的接口方框图如图2所示,布斯编码模块对每三位乘数进行布斯编码,因此对于八位的数据宽度,设计需要四个编码模块,输出为四个信号,分别是表示减操作的Neg信号,表示部分积为零、部分积两倍和一倍的Zero、Two和One信号。这些信号被提供给部分积产生模块,随后部分积产生模块将根据这些信息输出正确的部分积。

图2 基4布斯编码模块

         部分积产生模块的方框接口图如图3所示。部分积产生模块的方框接口图如图3所示。它根据不同的控制信号和被乘数产生特定的部分积形式。注意,作为一种最简单的实现形式,为了保证补码运算的统一性和正确性,设计只需要将所有输入模块的被乘数负号拓展至乘积结果的位宽即可(这其实也可通过一些算法来优化)。

图3 部分积产生模块

        注意,这里的部分积只在从乘数的包括最低位在内的间隔一位产生,因此所有部分积的会错开两位,这与之前的部分积的规律不同。
        例如表2表示了两个八位数使用基4布斯编码相乘的过程。可以看到对于八位数据,使用基4布斯编码只产生了四行部分积,是不使用编码部分积行数的一般,乘法器的速度很大情况下取决于部分积的深度而不是最后的向量合成。 

表2 基4布斯编码的部分积产生和累加过程

A

0

0

0

0

0

1

1

1

  

7

×B

0

0

0

0

1

0

0

1

9

0

1

-2

1

Radix 4 Booth

0

0

0

0

0

0

0

0

0

0

0

0

0

1

1

1

1*2^0*A

1

1

1

1

1

1

1

1

1

1

0

0

1

0

-2*2^2*A

0

0

0

0

0

0

0

0

0

1

1

1

1*2^4*A

0

0

0

0

0

0

0

0

0

0

0*2^6*A

0

0

0

0

0

0

0

0

0

0

1

1

1

1

1

1

63

        根据华莱士树构建的规则,部分积的构建过程为第一阶段使用两个半加器、十二个全加器压缩前三行部分积,第一行低两位无需压缩直接得到结果低两位,第三列的和也可以直接被当做结果的第三位。第二阶段使用三个半加器,十个全加器对最后的三行压缩,此时乘积的第四位也可得到。最后使用向量合成器对高十二位的两个数进行相加,即可得到最后结果。

        具体的Verilog代码实现见附录,Modelsim软件仿真截图如图4所示。使用Synopsis的综合工具Design Compiler综合的结果如图3所示,综合使用了0.13μm工艺库。 

图4 基4布斯编码华莱士树乘法器仿真结果

 图5 基4布斯编码华莱士树乘法器综合结果

        在Design Compiler中使用report_timing命令,可以得到关键路径的延迟,如图6所示,可以看出延迟有4.24ns。

图6 基4布斯编码华莱士树乘法器关键路径报告

在Design Compiler中使用report_area命令,报告所设计电路的面积占用情况,如图7所示。

图7 基4布斯编码华莱士树乘法器面积报告

        基4布斯编码华莱士树乘法器的Verilog代码如下所示。

module Booth_Encoder(
input [2:0] Code,
output Neg,Zero,One,Two
);assign Neg = Code[2];assign Zero = (Code == 3'b000) || (Code == 3'b111);assign Two = (Code == 3'b100) || (Code == 3'b011);assign One = (!Zero) & (!Two);endmodulemodule Partial_Generater(
input [7:0] Multiplicand,
input Neg,Zero,One,Two,
output [15:0] Partial_Product);reg [15:0]Partial_Tmp;always@(*) beginPartial_Tmp=16'b0;if(Zero)Partial_Tmp=16'b0;else if(One)Partial_Tmp={{8{Multiplicand[7]}},Multiplicand};else if(Two)Partial_Tmp={{7{Multiplicand[7]}},Multiplicand,1'b0};endassign Partial_Product = Neg?(~Partial_Tmp+1'b1) : Partial_Tmp;endmodulemodule Adder_half (input  Mult1,input  Mult2,output Res,output Carry
);assign Res = Mult1 ^ Mult2;assign Carry = Mult1 & Mult2;endmodulemodule Adder (input  Mult1,input  Mult2,input  I_carry,output Res,output Carry
);assign Res = Mult1 ^ Mult2 ^ I_carry;assign Carry = (Mult1 & Mult2) | ((Mult1 ^ Mult2) & I_carry);endmodulemodule Multiplier_Radix_4_Wallace(input      [7:0]    A      ,input      [7:0]    B      ,output  [15:0]    Sum
);//A Multiplicand //B Multiplierwire Neg[3:0];wire Zero[3:0];wire One[3:0];wire Two[3:0];wire [15:0]Partial_Product[3:0];wire [15:0]Partial_Product_t[3:0];wire [13:0]Result_0;wire [12:0]Carry_0;wire [12:0]Result_1;wire [12:0]Carry_1;//Booth_EncoderBooth_Encoder Booth_Encoder_0({B[1:0],1'b0},Neg[0],Zero[0],One[0],Two[0]);Booth_Encoder Booth_Encoder_1({B[3:1]},Neg[1],Zero[1],One[1],Two[1]);Booth_Encoder Booth_Encoder_2({B[5:3]},Neg[2],Zero[2],One[2],Two[2]);Booth_Encoder Booth_Encoder_3({B[7:5]},Neg[3],Zero[3],One[3],Two[3]);//Partial_GeneraterPartial_Generater         Partial_Generater_0(A,Neg[0],Zero[0],One[0],Two[0],Partial_Product_t[0]);Partial_Generater Partial_Generater_1(A,Neg[1],Zero[1],One[1],Two[1],Partial_Product_t[1]);Partial_Generater Partial_Generater_2(A,Neg[2],Zero[2],One[2],Two[2],Partial_Product_t[2]);Partial_Generater Partial_Generater_3(A,Neg[3],Zero[3],One[3],Two[3],Partial_Product_t[3]);assign Partial_Product[0]=Partial_Product_t[0];assign Partial_Product[1]=Partial_Product_t[1]<<2;assign Partial_Product[2]=Partial_Product_t[2]<<4;assign Partial_Product[3]=Partial_Product_t[3]<<6;//Wallace_Tree//Stage1assign Sum[0]=Partial_Product[0][0];assign Sum[1]=Partial_Product[0][1];Adder_half Adder_half_0(Partial_Product[0][2],Partial_Product[1][2],Result_0[0],Carry_0[0]);Adder_half Adder_half_1(Partial_Product[0][3],Partial_Product[1][3],Result_0[1],Carry_0[1]);Adder Adder_0(Partial_Product[0][4],Partial_Product[1][4],Partial_Product[2][4],Result_0[2],Carry_0[2]);Adder Adder_1(Partial_Product[0][5],Partial_Product[1][5],Partial_Product[2][5],Result_0[3],Carry_0[3]);Adder Adder_2(Partial_Product[0][6],Partial_Product[1][6],Partial_Product[2][6],Result_0[4],Carry_0[4]);Adder Adder_3(Partial_Product[0][7],Partial_Product[1][7],Partial_Product[2][7],Result_0[5],Carry_0[5]);Adder Adder_4(Partial_Product[0][8],Partial_Product[1][8],Partial_Product[2][8],Result_0[6],Carry_0[6]);Adder Adder_5(Partial_Product[0][9],Partial_Product[1][9],Partial_Product[2][9],Result_0[7],Carry_0[7]);Adder Adder_6(Partial_Product[0][10],Partial_Product[1][10],Partial_Product[2][10],Result_0[8],Carry_0[8]);Adder Adder_7(Partial_Product[0][11],Partial_Product[1][11],Partial_Product[2][11],Result_0[9],Carry_0[9]);Adder Adder_8(Partial_Product[0][12],Partial_Product[1][12],Partial_Product[2][12],Result_0[10],Carry_0[10]);Adder Adder_9(Partial_Product[0][13],Partial_Product[1][13],Partial_Product[2][13],Result_0[11],Carry_0[11]);Adder Adder_10(Partial_Product[0][14],Partial_Product[1][14],Partial_Product[2][14],Result_0[12],Carry_0[12]);Adder Adder_11(Partial_Product[0][15],Partial_Product[1][15],Partial_Product[2][15],Result_0[13],);//Stage2assign Sum[2]=Result_0[0];assign Sum[3]=Result_1[0];Adder_half Adder_half_2(Carry_0[0],Result_0[1],Result_1[0],Carry_1[0]);Adder_half Adder_half_3(Carry_0[1],Result_0[2],Result_1[1],Carry_1[1]);Adder_half Adder_half_4(Carry_0[2],Result_0[3],Result_1[2],Carry_1[2]);Adder Adder_12(Carry_0[3],Result_0[4],Partial_Product[3][6],Result_1[3],Carry_1[3]);Adder Adder_13(Carry_0[4],Result_0[5],Partial_Product[3][7],Result_1[4],Carry_1[4]);Adder Adder_14(Carry_0[5],Result_0[6],Partial_Product[3][8],Result_1[5],Carry_1[5]);Adder Adder_15(Carry_0[6],Result_0[7],Partial_Product[3][9],Result_1[6],Carry_1[6]);Adder Adder_16(Carry_0[7],Result_0[8],Partial_Product[3][10],Result_1[7],Carry_1[7]);Adder Adder_17(Carry_0[8],Result_0[9],Partial_Product[3][11],Result_1[8],Carry_1[8]);Adder Adder_18(Carry_0[9],Result_0[10],Partial_Product[3][12],Result_1[9],Carry_1[9]);Adder Adder_19(Carry_0[10],Result_0[11],Partial_Product[3][13],Result_1[10],Carry_1[10]);Adder Adder_20(Carry_0[11],Result_0[12],Partial_Product[3]    [14],Result_1[11],Carry_1[11]);Adder Adder_21(Carry_0[12],Result_0[13],Partial_Product[3][15],Result_1[12],);assign Sum[15:4]=Result_1[12:1]+Carry_1[11:0];
endmodule 

 

 

这篇关于数字IC前端学习笔记:数字乘法器的优化设计(基4布斯编码华莱士树乘法器)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/854513

相关文章

Vue3 的 shallowRef 和 shallowReactive:优化性能

大家对 Vue3 的 ref 和 reactive 都很熟悉,那么对 shallowRef 和 shallowReactive 是否了解呢? 在编程和数据结构中,“shallow”(浅层)通常指对数据结构的最外层进行操作,而不递归地处理其内部或嵌套的数据。这种处理方式关注的是数据结构的第一层属性或元素,而忽略更深层次的嵌套内容。 1. 浅层与深层的对比 1.1 浅层(Shallow) 定义

HarmonyOS学习(七)——UI(五)常用布局总结

自适应布局 1.1、线性布局(LinearLayout) 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列,Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距,达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式,且在各类尺寸屏幕上表现一致,其中交叉轴为垂直时,取值为Vert

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya(不是本人,claude AI)在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容: 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例,告诉我们不懂推荐算法的产品,也能从产品侧出发, 设计出一款不错的推荐系统。 相信很多新手产品,看到算法二字,多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法(注:传统是指科班出身的产品都会接触过)。但对于推荐算法,多数产品对着网上搜到的资源,都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后,更是加大了理解的难度。 但,不了解推荐算法,就无法做推荐系

这15个Vue指令,让你的项目开发爽到爆

1. V-Hotkey 仓库地址: github.com/Dafrok/v-ho… Demo: 戳这里 https://dafrok.github.io/v-hotkey 安装: npm install --save v-hotkey 这个指令可以给组件绑定一个或多个快捷键。你想要通过按下 Escape 键后隐藏某个组件,按住 Control 和回车键再显示它吗?小菜一碟: <template

【 html+css 绚丽Loading 】000046 三才归元阵

前言:哈喽,大家好,今天给大家分享html+css 绚丽Loading!并提供具体代码帮助大家深入理解,彻底掌握!创作不易,如果能帮助到大家或者给大家一些灵感和启发,欢迎收藏+关注哦 💕 目录 📚一、效果📚二、信息💡1.简介:💡2.外观描述:💡3.使用方式:💡4.战斗方式:💡5.提升:💡6.传说: 📚三、源代码,上代码,可以直接复制使用🎥效果🗂️目录✍️

HDFS—存储优化(纠删码)

纠删码原理 HDFS 默认情况下,一个文件有3个副本,这样提高了数据的可靠性,但也带来了2倍的冗余开销。 Hadoop3.x 引入了纠删码,采用计算的方式,可以节省约50%左右的存储空间。 此种方式节约了空间,但是会增加 cpu 的计算。 纠删码策略是给具体一个路径设置。所有往此路径下存储的文件,都会执行此策略。 默认只开启对 RS-6-3-1024k

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画(下)

【课程链接】 AntV G6:深入图形与图形分组、自定义节点、节点动画(下)_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中,应该怎样去计算和绘制图形,如何给一个图形制作不间断的动画,以及在鼠标事件之后产生动画。(有点难,需要好好理解) <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06

从去中心化到智能化:Web3如何与AI共同塑造数字生态

在数字时代的演进中,Web3和人工智能(AI)正成为塑造未来互联网的两大核心力量。Web3的去中心化理念与AI的智能化技术,正相互交织,共同推动数字生态的变革。本文将探讨Web3与AI的融合如何改变数字世界,并展望这一新兴组合如何重塑我们的在线体验。 Web3的去中心化愿景 Web3代表了互联网的第三代发展,它基于去中心化的区块链技术,旨在创建一个开放、透明且用户主导的数字生态。不同于传统

学习hash总结

2014/1/29/   最近刚开始学hash,名字很陌生,但是hash的思想却很熟悉,以前早就做过此类的题,但是不知道这就是hash思想而已,说白了hash就是一个映射,往往灵活利用数组的下标来实现算法,hash的作用:1、判重;2、统计次数;