16位有符号乘法器设计

采用Booth算法的16×16并行乘法器设计刘东（西南交通大学计算机与通信工程学院四川成都610031）摘要：介绍了一种可以完成16位有符号／无符号二进制数乘法的乘法器。

该乘法器采用了改进的Booth算法，简化了部分积的符号扩展，采用Wallace 树和超前进位加法器来进一步提高电路的运算速度。

本乘法器可以作为嵌入式CPU内核的乘法单元，整个设计用VHDL语言实现。

关键词：乘法器；Booth算法；Wallace树；超前进位加法器在专用集成电路设计中，面积小但功能强大的CPU内核可以为设计提供很大的方便。

而乘法器又是CPU中一个重要的部件，本文分析了设计乘法器所用到的算法并提供了乘法器的设计方案。

乘法器的处理过程大致相同，都是先生成部分积再相加。

为了提高乘法器的性能，可以从减少部分积的个数，对部分积的相加采用并行加法。

采用Booth算法［1］可以使部分积的个数减少一半［1］，采用Wallace 树行结构的加法器完成N个部分积需要lgN次加法时间［2］，最后再使用超前进位加法器来减少加法运算中进位传播时间［3］。

本文设计的乘法器由Booth编码、Wallace树形结构和超前进位加法器3部分组成。

1乘法器结构本乘法器提供16位二进制有符号／无符号乘法运算。

为了区分是有符号还是无符号数，增加了1位即第17位用于符号控制，有符号则为1，无符号则为0。

无符号数的范围是0～216－1，有符合的范围是－215～215－1。

乘法器的结构如图1所示。

在执行一次乘法运算时，首先乘数和被乘数扩展1位符号控制位以判断是有符号数还是无符号数，然后用并行Booth编码器对乘数进行编码，根据Booth 编码输出并行生成部分积。

生成所有部分积后需要对部分积进行符号扩展以便进行相加，然后用Wallace树形结构加法器将部分积相加得到32位乘法结果。

2 Booth算法在乘法器设计中大都采用改进Booth算法以减少部分积，简化电路和提高运算速度。

课程名称电子设计自动化题目十六位硬件乘法器电路院系班级信息学院11电子信息工程A班姓名学号指导老师凌朝东2013 年 12 月 5 日题目名称：十六位硬件乘法器电路摘要：设计一个16位硬件乘法器电路.要求2位十进制乘法，能用LED数码管同时显示乘数,被乘数和积的值.本设计利用Quartus II软件为设计平台,通过移位相加的乘法原理：即从被乘数的最低位开始，若为1，则乘数左移后与上一次的和相加；若为0，左移后以全零相加，直至被乘数的最高位。

经软件仿真和硬件测试验证后,以达到实验要求。

目录1.题目名称 (2)2.摘要 (2)3.目录 (3)4.正文 (4)4.1. 系统设计 (4)4.1 设计要求 (4)4.2 系统设计方案 (4)4.2 单元电路设计 (4)4.2.1十进制计算模块 (5)4.2.2 BCD码转二进制模块 (5)4.2.3 8位右移寄存器模块 (6)4.2.4 8位加法器模块 (7)4.2.5 1乘法器multi_1模块 (7)4.2.6 16位移位寄存器reg_16模块 (8)4.2.7 16位二进制转BCD码B_BCD模块 (9)4.2.8 8位乘法器multi_8x8顶层设计 (10)4.3 软件设计 (12)4.3.1设计平台和开发工具 (12)4.3.2程序流程方框图 (13)4.4 系统测试 (14)4.1仿真分析 (14)4.2硬件验证 (15)5. 结论 (15)6. 参考文献 (15)7. 附录 (15)4.正文4.1系统设计1.1设计要求题目要求设计一个16位硬件乘法器电路.要求2位十进制乘法;能用LED数码管同时显示乘数,被乘数和积的信息.设置一个乘法使能端,控制乘法器的计算和输出.1.2系统设计方案此设计问题可分为乘数和被乘数输入控制模块,乘法模块和输出乘积显示模块基本分.乘数和被乘数的输入模块使输入的十进制数转化为二进制数输入乘法模块,乘法模块利用移位相加的方法将输入的两组二进制数进行相乘,并将16位乘积输出到乘积输出显示模块.显示模块将输入的二进制数按千,百,十,个位分别转化为十进制数输出.乘数和被乘数的输入可用数据开关K1~K10分别代表数字1,2,…,9,0,用编码器对数据开关K1~K10的电平信号进行编码后输入乘法器进行计算.但此方案所用硬件资源较多,输入繁琐,故不采取.方案二是利用硬件箱自带16进制码发生器,由对应的键控制输出4位2进制构成的1位16进制码,数的范围是0000~1111,即0H~FH.每按键一次,输出递增1,输出进入目标芯片的4位2进制数将显示在该键对应的数码管.乘数和被乘数的输入模块将16进制码的A~F码设计成输出为null.使得减少了无用码的输入.两数相乘的方法很多,可以用移位相加的方法,也可以将乘法器看成计数器,乘积的初始值为零,每一个时钟周期将乘数的值加到积上,同时乘数减一,这样反复执行,直到乘数为零.本设计利用移位相加的方法使得程序大大简化.系统总体电路组成原理图如下图所示：4.2单元电路设计下面分解8位乘法器的层次结构，分为以下7个模块：1. 十进制计算模块：使用4个十进制计数模块，输入乘数的十位个位，被乘数的十位个位。

一种高效16位有符号数乘法器设计
李娅妮;郎世坤;王雅;师瑞之
【期刊名称】《集成电路与嵌入式系统》
【年(卷),期】2024(24)6
【摘要】为了进一步优化乘法器的性能,提高乘法运算单元的运算速率,本文基于Radix 4 Booth算法和Wallace树压缩结构提出了一种改进的16位有符号数乘法器。

其特点包括优化Radix 4 Booth编码方式,有效减小部分积选择电路的面积;改进部分积计算过程,通过优化取反加1的方法直接生成被乘数的相反数,同时采用经典的符号位补偿算法使得部分积阵列变得规整易压缩;提出一种新型42压缩器,采用单个全加器处理压缩器的中间进位,针对每行部分积不同的数据特征,细化处理了Wallace树压缩结构,提高了部分积的压缩效率。

基于SMIC 180 nm标准单元库进行了综合与验证,结果表明本文所设计的乘法器关键路径延时为3.94 ns,面积为16246μm^(2),相比于现有的乘法器,本文乘法器的运算速率和综合性能都得到显著提升。

【总页数】5页(P41-45)
【作者】李娅妮;郎世坤;王雅;师瑞之
【作者单位】西安电子科技大学
【正文语种】中文
【中图分类】TM76
【相关文献】
1.一种高效双精度浮点乘法器
2.一种高效模（2n-2p）乘法器的设计
3.一种基于中国剩余定理的高效乘法器设计
4.基于有符号数乘法器优化设计的自适应陷波器FPGA实现
5.一种高效能可重构1024位大数乘法器的设计
因版权原因，仅展示原文概要，查看原文内容请购买。

摘要随着现代数字技术的高速发展，乘法器在高速实时信号处理中特别是在数字信号处理和数字图像处理系统中起到了重要的作用。

乘法器已经是现代计算机中必不可少的一部分。

随着乘数和被乘数位数的增加，乘法器电路中的加法器位树也要相应的增加。

通过研究CLA电路的特性，也可以在乘法器中开发出更快的加法阵列。

纯组合逻辑构成的乘法器虽然工作速度比较快，但过于占用硬件资源，难以实现宽位乘法器。

这里介绍由十六位加法器构成的以时序逻辑方式设计的十六位乘法器，具有一定的实用价值，而且由FPGA\CPLD构成实验系统后，可以很容易的用ASIC大型集成芯片来完成，性价比高，可操作性强。

其运算速度是决定逻辑运算单元(ALU)工作频率的关键，并在很大程度上决定了系统的性能。

由于DSP芯片是串行执行，速度慢、功耗大，所以现在高速实时信号处理中一般采用FPGA\CPLD来进行并行处理。

现在很多系统设计中，要求速度越来越快，功耗越来越小，因此研究高速低功率的乘法器相当重要。

在此次课设中我将在modelsim的环境下完成十六位的乘法器的设计。

关键词FPGA；加法器；Modelsim；锁存器,；移位寄存器目录引言 (1)1总体电路结构设计 (2)1.1电路功能与性能 (2)1.2关键功能电路设计 (3)1.3电路接口 (3)1.4电路功能框图 (5)1.5验证方案 (6)2模块的设计 (7)2.1 输入信号处理模块设计 (8)2.2 16位移位寄存器模块 (9)2.3 16位计数器模块 (9)2.4 输出信号处理模块 (10)3 设计仿真与测试 (12)3.1仿真与测试的功能列表 (12)3.2 仿真平台构建和仿真结果 (12)3.2.1 顶层仿真平台与激励..................... 错误！未定义书签。

3.2.2 电路功能仿真结果....................... 错误！未定义书签。

3.2.3 电路后仿真结果......................... 错误！未定义书签。

有符号乘法器设计报告——VLSI课程设计2010年12月复旦大学专用集成电路与国家重点实验室第一章 设计要求完成16*16有符号乘法器的设计。

具体设计方案选择要求如下：1、 编码方式：non-booth 编码，Booth 编码，Booth2编码（任选一种）2、 拓扑结构：简单阵列，双阵列，二进制树，Wallace 树（任选一种）3、 加法器：Ripple Carry Adder ，Carry bypass ，Carry select ，Carrylook ahead （任选一种或采用混合方法）设计报告必须包含设计方案说明及选择该方案的理由、仿真和设计结构等。

第二章 设计分析在微控制器（MCU ）、微处理器（MPU ）、数字信号处理器（DSP ）、滤波器（FIR/IIR ）等各种电路中都会用到乘法器，乘法器是最基本、最重要的运算模块之一。

并且乘法器往往还是处在关键路径上，所以乘法器的性能就显得更加重要。

伴随着现在工艺水平的提高，模块的面积也随着减小，在一定程度下以面积为代价来追求性能的提升，这也是允许的。

本设计是以追求性能为设计目标的，采用全并行的乘法器电路，设计指标设为传播延时为5ns 。

第三章 乘法器原理分析乘法器通常有三种结构形式，全串行乘法器、串并行乘法器以及全并行乘法器。

全串行乘法器都可以是串行的，需要多个时钟周期，速度很慢；串并行乘法器的一个输入是并行的，另一输入是串行的，乘积串行输出；全并行乘法器，输入和输出都是并行的，电路较为复杂，但是速度极快。

本设计追求的就是速度，所以采用全并行乘法器机构。

16位有符号乘法器可以分为三个部分：根据输入的被乘数和乘数产生部分积、部分积压缩产生和和进位、将产生的和和进位相加。

这三个部分分别对应着编码方式、拓扑结构以及加法器。

3.1 编码方式本设计采用booth2编码。

Booth 算法的提出主要是为了解决有符号数乘法运算中的复杂的符号修正的问题，所以采用booth2编码对于补码表示的两数就不需要考虑符号的问题。

基于CSD编码的16位并行乘法器的设计
王瑞光;田利波
【期刊名称】《微计算机信息》
【年(卷),期】2008(024)023
【摘要】文中介绍了二进制数的CSD(Canonic Signed-Digit)编码技术;针对目前CSD编码大都是用软件预先求得或基于查找表实现,本文设计了一种有/无符号二进制数的CSD码快速转换的电路结构,其速度快、占用资源少.该编码电路用于乘法器中可以减少一半的部分积数目,文中设计了一种16位有/无符号的乘法器,其采用了Wallace加法树和超前进位加法器,整个设计用Verilog HDL语言实现了RTL描述,并在Altera公司的FPGA上进行了实验验证,结果表明该乘法器是可行性的.
【总页数】3页(P75-76,26)
【作者】王瑞光;田利波
【作者单位】130033,中国科学院长春光学精密机械与物理研究所,吉林,长
春;130033,中国科学院长春光学精密机械与物理研究所,吉林,长春;100039,中国科学院研究生院,北京
【正文语种】中文
【中图分类】TP301.6
【相关文献】
1.基于BoothCSD混合编码的模2n+1乘法器的设计 [J], 王敏;徐祖强;邱陈辉
2.基于改进的BOOTH编码的高速32×32位并行乘法器设计 [J], 刘强;王荣生
3.基于CSD编码的高速乘法器IP设计 [J], 熊承义;田金文;柳健
4.基于16位定点DSP的并行乘法器的设计 [J], 王叶辉;林贻侠;严伟
5.基于FPGA的CSD编码乘法器 [J], 何永泰;黄文卿
因版权原因，仅展示原文概要，查看原文内容请购买。

乘法器是众多数字系统中的基本模块。

从原理上说它属于组合逻辑范畴；但从工程实际设计上来说，它往往会利用时序逻辑设计的方法来实现，属于时序逻辑范畴。

通过这个实验使大家能够掌握利用FPGA/CPLD设计乘法器的思想，并且能够将我们设计的乘法器应用到实际工程中。

下面我们分别列举了十进制乘法运算和二进制乘法运算的例子。

下面这种计算乘法的方式是大家非常熟悉的：乘积项与乘数相应位对齐（即将乘积项左移），加法运算的数据宽度与被乘数的数据位宽相同。

下面例子中的被乘数和乘数都是无符号的整数，对于有符号数的乘法，可以将符号与数据绝对值分开处理，即绝对值相乘，符号异或。

乘法器的设计方法有两种：组合逻辑设计方法和时序逻辑设计方法。

采用组合逻辑设计方法，电路事先将所有的乘积项全部计算出来，最后加法运算。

采用时序逻辑设计方法，电路将部分已经得到的乘积结果右移，然后与乘积项相加并保存和值，反复迭代上述步骤直到计算出最终乘积。

在本次实验中我们就利用时序逻辑设计方法来设计一个16位乘法器，既然是利用时序逻辑设计方法那么我们就得利用时钟信号控制乘法器运算，那么这样用时序逻辑设计方法与用组合逻辑设计方法比较，它有什么好处呢？利用时序逻辑设计方法可以使整体设计具备流水线结构的特征，能适用在实际工程设计中。

IO口定义：clk：芯片的时钟信号。

rst_n:低电平复位、清零信号。

定义为0表示芯片复位；定义为1表示复位信号无效。

start: 芯片使能信号。

定义为0表示信号无效；定义为1表示芯片读入输入管脚得乘数和被乘数，并将乘积复位清零。

ain:输入a（被乘数），其数据位宽为16bit.bin:输入b（乘数），其数据位宽为16bit.yout:乘积输出，其数据位宽为32bit.done:芯片输出标志信号。

定义为1表示乘法运算完成，yout端口的数据稳定，得到最终的乘积；定义为0表示乘法运算未完成，yout端口的数据不稳定。

数据吞吐量的计算：数据吞吐量使指芯片在一定时钟频率条件下所能处理的有效数据量。

EDA课程设计16位（8x8）硬件乘法器设计学校：华侨大学学院：信息与工程学院班级：10集成姓名：项传煜学号：1015251031老师：凌朝东目录摘要一．设计要求二．正文2.1. 系统设计2.1.1 系统设计方案 (3)2.1.2 系统设计原理 (4)2.2. 各子模块设计2.2.1 十进制加计数器设计 (5)2.2.2 BCD码转二进制码BCD_B的设计 (5)2.2.3 8位移位寄存器reg_8的设计 (6)2.2.4 8位加法器adder_8的设计 (7)2.2.5 1位乘法器multi_1的设计 (7)2.2.6 16位移位寄存器reg_16的设计 (8)2.2.7 16位二进制转BCD码B_BCD的设计 (9)2.3. 软件设计2.3.1 设计平台和开发工具 (10)2.3.2 程序流程方框图 (10)2.3.3 实现功能 (11)2.3.4 8位乘法器的顶层设计 (11)2.4. 系统测试2.4.1 乘法器使用 (13)2.4.2 仪器设备 (13)2.4.3 测试数据 (14)2.5. 结论 (14)三．测试结果仿真图 (14)四．参考文献 (15)五．附录：设计说明书及使用说明书 (15)摘要本设计通过对一个8×8的二进制乘法器的设计，学习利用VHDL语言来描述简单的算法，掌握利用移位相加方法实现乘法运算的基本原理。

在此次设计中该乘法器是由十进制计数器，BCD码（输入）转二进制码，8位寄存器，8位加法器，16位寄存器，8x1乘法器，二进制码转BCD码（输出显示）7个模块构成的以时序方式设计的8位乘法器，采用逐项移位相加的方法来实现相乘。

设计中乘数，被乘数的十位和个位分别采用cnt10（十进制加法器）来输入，经拼接符“&”拼接成8位BCD码，再由BCD_B（BCD码转二进制码）转化成二进制码后计算，计算结果由B_BCD(二进制转BCD码)转化成BCD码输入到数码管中显示。

目录引言....................................................................................................................................... - 1 - 摘要....................................................................................................................................... - 2 -一、乘法器概述....................................................................................................................... - 3 -1.1 EDA技术的概念........................................................................................................ - 3 -1.2 EDA技术的特点........................................................................................................ - 3 -1.3 EDA设计流程............................................................................................................ - 5 -1.4硬件描述语言（Verilog HDL）................................................................................ - 5 -二、16位乘法器的设计要求与设计思路.............................................................................. - 6 -2.2 设计要求.................................................................................................................... - 6 -三、16位乘法器的总体框图.................................................................................................. - 6 -四、16位乘法器的综合设计.................................................................................................. - 7 -4.1 16位乘法器功能........................................................................................................ - 7 -4.2 16位乘法器设计思路................................................................................................ - 8 -4.3 基于Verilog HDL 硬件语言的乘法器设计 ............................................................ - 8 -（1）输入模块......................................................................................................... - 8 -（2）乘法模块......................................................................................................... - 9 -五、总体调试与仿真结果..................................................................................................... - 10 -5.1乘法器的RTL Viewer .......................................................................................... - 10 -5.2 16位乘法器的系统程序：....................................................................................... - 11 -5.3计算结果仿真结果................................................................................................... - 12 -5.3.1仿真测试程序（a=6，b=10）.............................................................................. - 12 - 总结......................................................................................................................................... - 16 - 参考文献................................................................................................................................. - 16 -引言随着微电子技术的飞速发展，集成电路工艺进入深亚微米阶段，特征尺寸变得越来越小。

16位乘法器芯片设计1.方法乘法器的设计方法有两种：组合逻辑设计方法和时序逻辑设计方法。

采用组合逻辑设计方法，电路事先将所有的乘积项全部算出来，然后做加法运算。

采用时序逻辑设计方法，电路将部分已经得到的乘积结果右移，然后与乘积项相加并保存和值，反复迭代上述步骤直到计算出最终积。

2.组合逻辑的实现可以以16*3位的乘法器为例做出如下设想：A为16位二进制乘数，B为3位二进制乘数,C为A与B相乘的积。

则：C的结果实际上只能为如下值中的一个：0,A,2A,3A,4A,5A,6A,7A因为B为3位二进制，则B只能是000,001,010,011,100,101,110,111中的一个。

初步设想符合现实，由于要实现ASIC芯片的生产，所以对各端口定义如下：reset：芯片复位、清零信号。

值为0，芯片复位。

start：芯片使能信号。

值为1，芯片读入乘数和被乘数，并将乘积复位清零。

ain：被乘数，16bit。

bin：乘数，3bit。

yout：乘积输出，19bit。

done：芯片输出标志信号，值为1，乘法运算完成，yout端口的数据稳定，得到最终的乘积；值为0，乘法运算未完成，yout端口数据不稳定。

编写的Verilog程序如下：Module mult16(reset,start,ain,bin,done,yout);Parameter N=16;Input reset;Input start;Input [N-1:0] ain;Input [2:0]bin;Output [N+3:0] yout;Output done;Integer aa,ab,ac,temp;Integer su;Reg done;Always @(ain)BeginIf(start&&!reset)Beginaa=ain;ab=ain+ain;ac=ab+ab;temp=aa+ab;case(bin)3’b000: su=0;done=1’b1;3’b001: su<=aa;done=1’b1;3’b010: su<=ab;done=1’b1;3’b011: su<=aa+ab;done=1’b1;3’b100: su<=ac;done=1’b1;3’b101: su<=aa+ac;done=1’b1;3’b110: su<=ab+ac;done=1’b1;3’b111: su<=temp+ac;done=1’b1;default: su<=0;done=1’b0;else if (reset)beginsu=0;aa=0;ab=0;ac=0;done=1’b0;endelse if (!start)beginsu=0;done=1’b0;endendassign yout=su;endmodule基于组合逻辑的乘法器，在程序语言上通俗易懂，思路清晰，但是有致命缺点，当乘数和被乘数位数很多的时候，不可能一一列举各种乘积结果，用case语句就显得很繁琐，所以基于时序逻辑的乘法器的研制在所难免。

课程名称电子设计自动化题目十六位乘法器院系班级信息学院09电子信息工程1班姓名崔钦婉学号**********指导老师凌朝东2011 年7 月6 日题目名称：十六位硬件乘法器电路摘要：设计一个16位硬件乘法器电路.要求2位十进制乘法，能用LED数码管同时显示乘数,被乘数和积的值.本设计利用Quartus II软件为设计平台,通过移位相加的乘法原理：即从被乘数的最低位开始，若为1，则乘数左移后与上一次的和相加；若为0，左移后以全零相加，直至被乘数的最高位。

经软件仿真和硬件测试验证后,以达到实验要求。

目录摘要 (2)1. 系统设计 (3)1.1设计要求 (3)1.2系统设计方案 (3)2. 单元电路设计 (5)3. 软件设计 (8)4. 系统测试 (9)结论 (9)参考文献 (9)附录 (10)1.系统设计1.1设计要求题目要求设计一个16位硬件乘法器电路.要求2位十进制乘法;能用LED数码管同时显示乘数,被乘数和积的信息.设置一个乘法使能端,控制乘法器的计算和输出.1.2系统设计方案此设计问题可分为乘数和被乘数输入控制模块,乘法模块和输出乘积显示模块基本分.乘数和被乘数的输入模块使输入的十进制数转化为二进制数输入乘法模块,乘法模块利用移位相加的方法将输入的两组二进制数进行相乘,并将16位乘积输出到乘积输出显示模块.显示模块将输入的二进制数按千,百,十,个位分别转化为十进制数输出.乘数和被乘数的输入可用数据开关K1~K10分别代表数字1,2,…,9,0,用编码器对数据开关K1~K10的电平信号进行编码后输入乘法器进行计算.但此方案所用硬件资源较多,输入繁琐,故不采取.方案二是利用硬件箱自带16进制码发生器,由对应的键控制输出4位2进制构成的1位16进制码,数的范围是0000~1111,即0H~FH.每按键一次,输出递增1,输出进入目标芯片的4位2进制数将显示在该键对应的数码管.乘数和被乘数的输入模块将16进制码的A~F码设计成输出为null.使得减少了无用码的输入.两数相乘的方法很多,可以用移位相加的方法,也可以将乘法器看成计数器,乘积的初始值为零,每一个时钟周期将乘数的值加到积上,同时乘数减一,这样反复执行,直到乘数为零.本设计利用移位相加的方法使得程序大大简化.系统总体电路组成原理图如下图所示：2.单元电路设计（1）乘数和被乘数的输入模块:可分为两部分:十位输入和个位输入;十位输入的4位16进制码转换为8位2进制码后输入乘数和被乘数组成模块利用’&’与个位输入的4位16进制数组合而成.模块图如下图所示：此功能模块的仿真图如下图所示：结果显示：当乘数十位（a1）输入4，个位（a0）输入7时，out1能输出4；当被乘数十位（b1）输入8，个位（b0）输入5时，out2能输出85。

《计算机组成原理课程设计》 —— 十六位运算器部件的设计一、运算器概述根据冯﹒诺依曼的计算机模型，计算机由运算器、控制器、存储器、输入设备和输出设备五大部件构成，其中运算器是执行各种算术和逻辑运算操作的核心部件。

运算器的基本操作包括：1）加、减、乘、除等算术运算 2）与、或、非、异或等逻辑运算 3）数据传送、移位、比较等操作运算器的组成除了算术/逻辑运算（ALU ）单元外，还包括必要的寄存器和移位器等部件。

寄存器用于存放操作数和运算结果，以节省访问存储器的时间。

移位器实现数据的移位功能，以扩展ALU 的运算功能，增加数据传送的灵活性。

从功能和电路上看，运算器的可分为两部分：数据运算电路和数据暂存电路。

在讨论运算器结构时，需要明确几个问题：1）参加运算的数据来源及结果去向运算器能直接运算的数据通常来自运算器本身的寄存器。

运算器内部的寄存器能够以最快的速度提供参加运算的数据，因此运算器内部通常设有一定数量的数据寄存器。

为此需要能够指定参加运算的两个寄存器的地址。

运算的结果通常存放在寄存器中，应能指定接收数据的寄存器。

此外，还必须明确在时间上的关系，即什么时刻送出数据参加运算，什么时刻才能正确接收运算的结果。

图1和图2给出了示意性的表示。

图1 运算器组成示意图 图2 一个运算周期中各种操作的时间关系2）明确将要执行的运算功能除指出数据操作的具体类型外，还需确定什么时刻可以开始指定运算处理，什么时刻可以得控制信号的建立时间寄存器内容送出时间运算器执行运算时间运算结果到寄存器输入端时间寄存器接收运算结果时间送出结果数据输入控制信号到正确的运算结果。

完成数据运算功能的电路是纯组合逻辑电路，即其输出结果随输入的变化而变化，其输出结果的稳定主要取决于输入数据的稳定，电路本身没有记忆功能，因此输入数据需要有锁存器来保持稳定。

3）运算器需要与计算机的其它部件连接起来协调工作运算器必须能够接收计算机其它部件（如存储器、I/O 设备）送来的数据，以保障源源不断的数据来源，同时把运算结果送到计算机的其它部件，以体现运算处理的效能和使用价值。

十六位硬件乘法器一、摘要1、设计要求：位宽十六，输入2个两位十进制相乘，能在数码管上显示积的信息！2、原理说明：十六位硬件乘法器可以分解为由2个8位2进制相乘得到，但要求输入十进制，故可用8421BCD码将2位十进制译成8位2进制即可，本次课设使用的是移位相加法来实现乘法！3、开发板使用说明：sw1到sw8开关是数据输入按键，即一次可同时输入八位数据，对于运算y=a*b,由于加入了辅助程序，总共要输入2次，每次输入的数据分别代表a转换为2进制的八位数，b转换成2进制的八位数，。

每按一次按键s3，即输入当前所设定的八位数据一次，,在数据输入完成后，按s2，进行运算，并由数码管输出用十进制表示的结果。

二、正文1、系统设计方案提出由于是2位的十进制，输入的数据不是很大，转换为二进制也是8位，故想到使用移位相加的方法来实现乘法的功能，同时移位相加是最节省资源的一种方法，其思路是乘法通过逐项移位相加来实现，根据乘数的每一位是否为1，若为1将被乘数移位相加，比较简单，适合本次课程设计。

2，电路划分，电路主要由3部分组成，第一部分是将输入的十进制译成2进制，第二部分是乘法器部分，第三部分是将得到的16位二进制结果译为十进制！第一部分LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;USE IEEE.STD_LOGIC_UNSIGNED.ALL;ENTITY chengshu ISPORT (a: IN STD_LOGIC_VECTOR(3 DOWNTO 0);cq : OUT STD_LOGIC_VECTOR(7 DOWNTO 0) );END chengshu;ARCHITECTURE behav OF chengshu ISBEGINprocess(a)begincase a iswhen "0000" => cq<="00000000";when "0001" => cq<="00001010";when "0010" => cq<="00010100";when "0011" => cq<="00011110";when "0100" => cq<="00101000";when "0101" => cq<="00110010";when "0110" => cq<="00111100";when "0111" => cq<="01000110";when "1000" => cq<="01010000";when "1001" => cq<="01011010";when others =>null;end case ;end process;end ARCHITECTURE behav;library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity add8 isport(a:in std_logic_vector(7 downto 0);b:in std_logic_vector(3 downto 0);qout:out std_logic_vector(7 downto 0));end add8;architecture ab of add8 issignal tmp1,tmp2,tmp:std_logic_vector(8 downto 0); begintmp1<='0'&a;tmp2<="00000"&b;tmp<=tmp1+tmp2;qout<=tmp(7 downto 0);end ab;第二部分：library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity cheng isport ( start : in std_logic;a : in std_logic_vector(7 downto 0);b : in std_logic_vector(7 downto 0);y : out std_logic_vector(15 downto 0)); end cheng;architecture behav of cheng issignal ql : std_logic_vector(7 downto 0);signal qz : std_logic_vector(7 downto 0);signal qy : std_logic_vector(15 downto 0);beginprocess(a,ql,qz,qy,b,start)variable q0 : std_logic_vector(15 downto 0); variable q1 : std_logic_vector(15 downto 0); variable q2 : std_logic_vector(15 downto 0); variable q3 : std_logic_vector(15 downto 0); variable q4 : std_logic_vector(15 downto 0); variable q5 : std_logic_vector(15 downto 0); variable q6 : std_logic_vector(15 downto 0); variable q7 : std_logic_vector(15 downto 0); variable q8 : std_logic_vector(15 downto 0); beginql<=a;qz<=b;q8:="0000000000000000";q7:="00000000"&ql;q0:="00000000"&ql;q7:=q7+q7;q1:=q7;q7:=q7+q7;q2:=q7;q7:=q7+q7;q3:=q7;q7:=q7+q7;q4:=q7;q7:=q7+q7;q5:=q7;q7:=q7+q7;q6:=q7;q7:=q7+q7;if start='1' thenif qz(0)='1' then q8:=q8+q0;end if;if qz(1)='1' then q8:=q8+q1;end if;if qz(2)='1' then q8:=q8+q2;end if;if qz(3)='1' then q8:=q8+q3;end if;if qz(4)='1' then q8:=q8+q4;end if;if qz(5)='1' then q8:=q8+q5;end if;if qz(6)='1' then q8:=q8+q6;end if;if qz(7)='1' then q8:=q8+q7;end if;end if;qy<=q8;end process;y<=qy;end behav;第三部分IBRARY ieee;USE ieee.std_logic_1164.all;USE ieee.std_logic_unsigned.all;USE ieee.std_logic_arith.all;ENTITY jian ISport( a: in std_logic_vector(15 downto 0) ;cnt : OUT std_logic_vector(15 downto 0) ;qout: OUT std_logic_vector(3 downto 0) );END ;ARCHITECTURE hdlarch OF jian ISBEGINprocess(a)beginif a>8999 then cnt<=a-9000;qout<="1001";elsif a>7999 then cnt<=a-8000;qout<="1000";elsif a>6999 then cnt<=a-7000;qout<="0111";elsif a>5999 then cnt<=a-6000;qout<="0110";elsif a>4999 then cnt<=a-5000;qout<="0101";elsif a>3999 then cnt<=a-4000;qout<="0100";elsif a>2999 then cnt<=a-3000;qout<="0011";elsif a>1999 then cnt<=a-2000;qout<="0010";elsif a>999 then cnt<=a-1000;qout<="0001";else cnt<=a ;qout<="0000";end if;end process;end hdlarch;LIBRARY ieee;USE ieee.std_logic_1164.all;USE ieee.std_logic_unsigned.all;USE ieee.std_logic_arith.all;ENTITY jian1 ISport( a: in std_logic_vector(15 downto 0) ;cnt : OUT std_logic_vector(15 downto 0) ;qout: OUT std_logic_vector(3 downto 0) );END ;ARCHITECTURE hdlarch OF jian1 ISBEGINprocess(a)beginif a>899 then cnt<=a-900;qout<="1001";elsif a>799 then cnt<=a-800;qout<="1000";elsif a>699 then cnt<=a-700;qout<="0111";elsif a>599 then cnt<=a-600;qout<="0110";elsif a>499 then cnt<=a-500;qout<="0101";elsif a>399 then cnt<=a-400;qout<="0100";elsif a>299 then cnt<=a-300;qout<="0011";elsif a>199 then cnt<=a-200;qout<="0010";elsif a>99 then cnt<=a-100;qout<="0001";else cnt<=a ;qout<="0000";end if;end process;end hdlarch;LIBRARY ieee;USE ieee.std_logic_1164.all;USE ieee.std_logic_unsigned.all;USE ieee.std_logic_arith.all;ENTITY jian2 ISport( a: in std_logic_vector(15 downto 0) ;cnt : OUT std_logic_vector(15 downto 0) ;qout: OUT std_logic_vector(3 downto 0) );END ;ARCHITECTURE hdlarch OF jian2 ISBEGINprocess(a)beginif a>89 then cnt<=a-90;qout<="1001";elsif a>79 then cnt<=a-80;qout<="1000";elsif a>69 then cnt<=a-70;qout<="0111";elsif a>59 then cnt<=a-60;qout<="0110";elsif a>49 then cnt<=a-50;qout<="0101";elsif a>39 then cnt<=a-40;qout<="0100";elsif a>29 then cnt<=a-30;qout<="0011";elsif a>19 then cnt<=a-20;qout<="0010";elsif a>9 then cnt<=a-10;qout<="0001";else cnt<=a ;qout<="0000";end if;end process;end hdlarch;但是由于2个8位2进制在开发板上不好输入和最后的16位不好译成十进制，故加入几段辅助程序减少其输入次数！library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity test_in isport(test_in: in std_logic_vector(7 downto 0);test_out_ah: out std_logic_vector(3 downto 0);test_out_al: out std_logic_vector(3 downto 0);test_out_bh: out std_logic_vector(3 downto 0);test_out_bl: out std_logic_vector(3 downto 0);clk: in std_logic;led: out std_logic);end entity;architecture one of test_in issignal test_temp: std_logic_vector(7 downto 0);signal cnt: std_logic;begin--process(clk)--begin--if(clk'event and clk='1')then--led<='1';--else--led<='0';--end if;--end process;process(clk)beginif(clk'event and clk='0')thencnt<=not cnt;test_temp<=test_in;end if;end process;process(cnt)begin--if(clk'event and clk='0')thenif(cnt='1')thentest_out_ah<=test_temp(7 downto 4);test_out_al<=test_temp(3 downto 0);elsetest_out_bh<=test_temp(7 downto 4);test_out_bl<=test_temp(3 downto 0);end if;--end if;end process;end architecture;library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity de_shake isport(key_in: in std_logic;key_out: out std_logic;clk_1_2hz: in std_logic);end entity;architecture one of de_shake issignal a,b,c: std_logic;beginprocess(clk_1_2hz)variable key_out_temp: std_logic;beginif(clk_1_2hz'event and clk_1_2hz='1')thena<= key_in;b<=a;c<=b;key_out_temp:=(a and b and c );end if;key_out<=key_out_temp;end process;end architecture;library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity fre_deshake isport(clk_50m: in std_logic;clk_deshake: out std_logic;clk_50: out std_logic);end entity;architecture one of fre_deshake issignal clk_temp: std_logic_vector(20 downto 0); beginclk_50<=clk_50m;process(clk_50m)beginif(clk_50m'event and clk_50m='1')thenclk_temp<=clk_temp+1;end if;end process;clk_deshake<=clk_temp(20);--clk_deshake(1)<=clk_temp(20);end architecture;library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity decode isport(clk_50M: in std_logic;input4: in std_logic_vector(3 downto 0);input3: in std_logic_vector(3 downto 0);input2: in std_logic_vector(3 downto 0);input1: in std_logic_vector(3 downto 0);output: out std_logic_vector(7 downto 0);address: out std_logic_vector(7 downto 0));end entity;architecture one of decode issignal div_clk: std_logic_vector(18 downto 0);signal mode: std_logic_vector(7 downto 0);signal data: std_logic_vector(3 downto 0);begindivclk:process(clk_50M)beginif(clk_50M'event and clk_50M='1')thendiv_clk<=div_clk+1;end if;end process;de_code_01: process(clk_50M,div_clk(18 downto 16))beginif(clk_50M'event and clk_50M='1')thencase div_clk(18 downto 16) iswhen "000"=>mode<="01111111";when "001"=>mode<="10111111";when "010"=>mode<="11011111";when "011"=>mode<="11101111";--when "100"=>--mode<="11110111";--when "101"=>--mode<="11111011";--when "110"=>--mode<="11111101";--when "111"=>--mode<="11111110";when others=>mode<="11111111";end case;end if;end process;de_code_02: process(mode)beginaddress <= mode;case mode iswhen "01111111"=>data<=input4;when "10111111"=>data<=input3;when "11011111"=>data<=input2;when "11101111"=>data<=input1;--when "11110111"=>--data<=input(15 downto 12);--when "11111011"=>--data<=input(11 downto 8);--when "11111101" =>--data<=input(7 downto 4);--when "11111110"=>--data<=input(3 downto 0);when others=>null;end case;end process;decode_03: process(data)begincase data iswhen "0000"=>output<="11000000";when "0001"=>output<="11111001";when"0010"=>output<="10100100";when"0011"=>output<="10110000";when"0100"=>output<="10011001";when"0101"=>output<="10010010";when"0110"=>output<="10000010";when"0111"=>output<="11111000";when"1000"=>output<="10000000";when"1001"=>output<="10010000";--when"1010"=>--output<="10001000";--when"1011"=>--output<="10000011";--when"1100"=>--output<="11000110";--when"1101"=>--output<="10100011";--when"1110"=>--output<="10000110";when others=>output<="10001110";end case;end process;end architecture;第二种方案（无硬件测试）library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity mult16_16 isport(clk: in std_logic;start: in std_logic;ina: in std_logic_vector(15 downto 0);inb: in std_logic_vector(15 downto 0);sout: out std_logic_vector(31 downto 0));end entity;architecture one of mult16_16 issignal cout1: std_logic_vector(19 downto 0);signal cout2: std_logic_vector(23 downto 0);signal cout3: std_logic_vector(27 downto 0);signal cout4: std_logic_vector(31 downto 0);signal a4b1: std_logic_vector(19 downto 0);signal a3b1: std_logic_vector(19 downto 0);signal a2b1: std_logic_vector(19 downto 0);signal a1b1: std_logic_vector(19 downto 0);signal a4b2: std_logic_vector(23 downto 0);signal a3b2: std_logic_vector(23 downto 0);signal a2b2: std_logic_vector(23 downto 0);signal a1b2: std_logic_vector(23 downto 0);signal a4b3: std_logic_vector(27 downto 0);signal a3b3: std_logic_vector(27 downto 0);signal a2b3: std_logic_vector(27 downto 0);signal a1b3: std_logic_vector(27 downto 0);signal a4b4: std_logic_vector(31 downto 0);signal a3b4: std_logic_vector(31 downto 0);signal a2b4: std_logic_vector(31 downto 0);signal a1b4: std_logic_vector(31 downto 0);beginprocess(clk)beginif(clk'event and clk='1')thena4b1<=((ina(15 downto 12)*inb(3 downto 0))&"000000000000");a3b1<=("0000"&(ina(11 downto 8)*inb(3 downto 0))&"00000000");a2b1<=("00000000"&(ina(7 downto 4)*inb(3 downto 0))&"0000");a1b1<=("000000000000"&(ina(3 downto 0)*inb(3 downto 0)));a4b2<=((ina(15 downto 12)*inb(7 downto 4))&"0000000000000000");a3b2<=("0000"&(ina(11 downto 8)*inb(7 downto 4))&"000000000000");a2b2<=("00000000"&(ina(7 downto 4)*inb(7 downto 4))&"00000000");a1b2<=("000000000000"&(ina(3 downto 0)*inb(7 downto 4))&"0000");a4b3<=((ina(15 downto 12)*inb(11 downto 8))&"00000000000000000000");a3b3<=("0000"&(ina(11 downto 8)*inb(11 downto 8))&"0000000000000000");a2b3<=("00000000"&(ina(7 downto 4)*inb(11 downto8))&"000000000000");a1b3<=("000000000000"&(ina(3 downto 0)*inb(11 downto 8))&"00000000");a4b4<=((ina(15 downto 12)*inb(15 downto 12))&"000000000000000000000000");a3b4<=("0000"&(ina(11 downto 8)*inb(15 downto 12))&"00000000000000000000");a2b4<=("00000000"&(ina(7 downto 4)*inb(15 downto 12))&"0000000000000000");a1b4<=("000000000000"&(ina(3 downto 0)*inb(15 downto 12))&"000000000000");end if;end process;process(clk)beginif(clk'event and clk='1')thencout1<=a4b1+a3b1+a2b1+a1b1;cout2<=a4b2+a3b2+a2b2+a1b2;cout3<=a4b3+a3b3+a2b3+a1b3;cout4<=a4b4+a3b4+a2b4+a1b4;end if;end process;process(clk,start)beginif(start='1')thensout<="00000000000000000000000000000000";elsesout<=("000000000000"&cout1)+("00000000"&cout2)+("0000"&cout3)+cout4;end if;end process;end architecture;仿真结果三，参考文献资料，EDA技术和VHDL，和同学一起讨论！四，仿真结果，随便输入几个数字后，进行仿真，结果正确，但只能用16进制看结果，因为是译成8421BCD码，是一位十进制数对应4位2进制，最终的结果范围是0~9801，需要16位2进制来对应！五，硬件测试在硬件上进行测试，结果正确！六，实验总结这次课设让我学会了很多东西，刚开始的时候对很多东西不是很理解，后来请教同学，查资料，虽然有些的程序不是自己写的，但跟同学讨论，请教，大概也懂得的那些程序是干什么用的，在最后测试的时候，在仿真阶段，刚开始一直仿真不对，以为是程序错误，但检验后程序并没有错误，由于是8421BCD码故应该用十六进制进行仿真。

16*16位Wallace乘法器测试激励文件设计摘要课题首先要深入分析和掌握Wallace加法树的基本原理，Wallace树是对部分积规约，减小乘法器关键路径时延的一种算法。

设计的思想是为了加快乘法器的运行速度并减少芯片面积开销，采用阵列累加原理实现乘法运算。

本课题设计采用加法器阵列结构来完成部分积相加的，相加的研究和应用方法有多种，本课题基于Wallace加法树结构，并在Wallace加法树算法的基础上进行基于Wallace加法树的16位乘法器的Verilog设计与实现。

功能验证通过后，采用Synopsys公司EDA综合工具Design Compiler进行设计综合。

在此过程中，首先要对工具应用进行综合脚本文件的编写。

然后采用脚本文件对RTL代码进行设计综合，得到门级网表与电路实现。

关键词乘法器；Wallace加法树；Verilog硬件描述语言在乘法器的计算过程中，一般是通过减少部分积的总数，来减少部分积相加的次数，从而来提高计算的速度。

而对于Wallace Tree算法则是通过改进部分积累加的方式以减少部分积累加所需的时间，从而来加快运算的速度。

Wallace树算法的基本思想是通过3-2编码器来减少累加过程中所需要的时间。

加法器中的时延问题主要是出现在进位的过程中所花费大量的时间，如果我们单纯的使用串行的方式，逐级相加，那么所花费的时间也是很长的。

对于一个N比特的被乘数和一个N比特的乘数相乘的算法如下图所示：Y=Yn-1 Yn-2.....................Y2 Y1 Y0 被乘数X=Xn-1 Xn-2.....................X2 X1 X0 乘数一般来说：Y=Yn-1Yn-2....................... Y2Y1Y0X=Xn-1Xn-2 (X2X1X0)2Yn-1X0 Yn-2X0 Yn-3X0 ……Y1X0 Y0X0Yn-1X1 Yn-2X1 Yn-3X1 ……Y1X1 Y0X1Yn-1X2 Yn-2X2 Yn-3X2 ……Y1X2 Y0X2… … … ……. …. …. …. ….Yn-1Xn-2 Yn-2X0 n-2 Yn-3X n-2 ……Y1Xn-2 Y0Xn-2Yn-1Xn-1 Yn-2X0n-1 Yn-3Xn-1 ……Y1Xn-1 Y0Xn-1 ----------------------------------------------------------------------------------------------------------------P2n-1 P2n-2 P2n-3 P2 P1 P0例如：1101 4-bits1101 4-bits110100001101110110010101“与”门被用来产生部分乘积，如果被乘数是N比特，乘数是M比特，那么就会产生N*M个部分积，然而在不同结构和类型的乘法器当中，部分乘积的产生方式是不同的。

两个16位有符号数,输出32位相乘结果,采用booth编码和wallace树型结构要实现两个16位有符号数的乘积的32位结果，我们首先需要使用Booth编码来对乘数进行编码，然后利用Wallace树结构进行计算。

首先，我们考虑16位有符号数。

它们的有效范围是-32768到32767。

我们需要对这些数字进行编码以实现乘法。

一种常见的编码方式是使用Booth编码。

然后，我们需要利用Wallace树来进行计算。

Wallace树是一个计算乘积的树状结构，它将每4位分为一组，并使用加法器、全加器和半加器进行计算。

以下是使用Python语言实现的基本步骤：1. 读取两个16位有符号数。

2. 使用Booth编码对这两个数进行编码。

3. 利用Wallace树结构进行计算。

4. 输出32位的结果。

注意：由于这是一个复杂的问题，涉及到数字逻辑和硬件设计，因此，下面的代码只是概念性的示例，并不能直接运行。

```pythondef booth_encode(num):# 实现Booth编码的逻辑passdef wallace_tree_multiply(encoded_num1, encoded_num2): # 实现基于Wallace树结构的乘法逻辑pass# 输入两个16位有符号数num1 = -1000 # 例如-1000num2 = 2000 # 例如2000# 对两个数进行Booth编码encoded_num1 = booth_encode(num1)encoded_num2 = booth_encode(num2)# 使用Wallace树进行乘法计算result = wallace_tree_multiply(encoded_num1, encoded_num2)# 输出32位结果（如果需要的话）print(result)```这个代码示例只是为了说明如何使用Booth编码和Wallace树来计算两个16位数的乘积，实际操作时需要考虑如何处理溢出，以及如何将结果从Wallace树中提取出来等等。

16X16无符号／有符号可综合高速乘法器的设计
陈志军;唐伟
【期刊名称】《集成电路应用》
【年(卷),期】2002(000)012
【摘要】高速乘法器在数字信号处理等方面具有重要的应用价值，而且正成为许
多高速电路设计的瓶颈。

目前大多乘法器是在针对具体工艺的技术上进行设计，而本文设计实现的乘法器是建立在RTL基础上的，可以十分方便应用在不同的工艺。

设计的乘法器采用了Booth编码和Wallace-Tree及Carry-Look-Ahead相结合
的方法，最长延时可以达到4.2ns(0.35u 3.3V 25℃）。

【总页数】3页(P30-32)
【作者】陈志军;唐伟
【作者单位】旺宏电子苏州有限公司215021;旺宏电子苏州有限公司215021
【正文语种】中文
【中图分类】TP332.22
【相关文献】
1.基于RTL级实现的可综合的16×16位带符号/无符号高速乘法器 [J], 石碧;程伟综;何晓雄
2.32位无符号并行乘法器的设计与实现 [J], 胡小龙;颜煦阳
3.16X16无符号/有符号可综合高速乘法器的设计 [J], 陈志军; 唐伟
4.定点符号高速乘法器的设计与FPGA实现 [J], 李小进;初建朋;赖宗声;徐晨;景为
平
5.16×16位带符号/无符号基于RTL级实现的可综合的高速乘法器 [J], 石碧;程伟综;何晓雄
因版权原因，仅展示原文概要，查看原文内容请购买。