Wallace树形乘法器(Verilog)，自动生成器(C/C++版)

最新推荐文章于 2024-05-11 10:00:00 发布
最新推荐文章于 2024-05-11 10:00:00 发布
阅读量5.4k 收藏 37
点赞数 9
分类专栏： 硬件 Verilog C/C++ 文章标签： Wallace乘法器 树形乘法器 乘法器生成器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxwd14388/article/details/82972947
版权
硬件 同时被 3 个专栏收录
2 篇文章 1 订阅
订阅专栏
Verilog
1 篇文章 0 订阅
订阅专栏
C/C++
1 篇文章 0 订阅
订阅专栏

学过《数字逻辑》课程的同学，对于Wallace树形乘法器应该不陌生（手拙，灵魂画师……建议读者参考网上的图片）。

总的来说，就是一个无符号数乘法器。特点是速度快，使用逻辑电路完成乘法，但是占用的资源也比较多（对于位数比较多的乘法而言）。

 

之前在学习李亚明老师写的书《计算机原理与设计——Verilog HDL版》时，由于其中用到了26x26的Wallace乘法器，分析了该乘法器的特点，并按照自己的思路利用C/C++语言编写了一下Wallace乘法器的生成器（设置好几位乘几位的参数后，生成可以执行的Verilog代码）。

 

生成器的关键在于，将项（）放到合适的一位全加器的一个输入上。全加器的当前输出位仍然在当前列，但是进位应该放到下一层的前一列全加器的输入中。

下面是6x4的Wallace代码（其中add1表示一位全加器，s表示加法结果，c表示进位）：

module wallace_tree6x4(
		input  [5:0] a,
		input  [3:0] b,
		//output [5:0] sum,
		//output [6:0] carry,
		//output [2:0] z3,
		output [9:0] z
	);

	wire zero = 1'b0;
	reg [3:0] p[5:0];

	integer i, j;
	always @*
	begin
		for(i=0; i<6; i=i+1)
			for(j=0; j<4; j=j+1)
				p[i][j] = a[i] & b[j];
	end

//level 1
	wire [1:0] s1[10:00];
	wire [1:0] c1[10:00];
	//	p[05][03]
	add1 fa01_07_00 (p [04][03], p [05][02], zero      , s1[07][00], c1[08][00]);
	add1 fa01_06_00 (p [03][03], p [04][02], p [05][01], s1[06][00], c1[07][00]);
	add1 fa01_05_00 (p [02][03], p [03][02], p [04][01], s1[05][00], c1[06][00]);
	//	p[05][00]
	add1 fa01_04_00 (p [01][03], p [02][02], p [03][01], s1[04][00], c1[05][00]);
	//	p[04][00]
	add1 fa01_03_00 (p [00][03], p [01][02], p [02][01], s1[03][00], c1[04][00]);
	//	p[03][00]
	add1 fa01_02_00 (p [00][02], p [01][01], p [02][00], s1[02][00], c1[03][00]);
	add1 fa01_01_00 (p [00][01], p [01][00], zero      , s1[01][00], c1[02][00]);
	//	p[00][00]

//level 2
	wire [10:00] s2;
	wire [10:00] c2;
	add1 fa02_08_00 (p [05][03], c1[08][00], zero      , s2[08], c2[09]);
	add1 fa02_07_00 (s1[07][00], c1[07][00], zero      , s2[07], c2[08]);
	add1 fa02_06_00 (s1[06][00], c1[06][00], zero      , s2[06], c2[07]);
	add1 fa02_05_00 (p [05][00], s1[05][00], c1[05][00], s2[05], c2[06]);
	add1 fa02_04_00 (p [04][00], s1[04][00], c1[04][00], s2[04], c2[05]);
	add1 fa02_03_00 (p [03][00], s1[03][00], c1[03][00], s2[03], c2[04]);
	add1 fa02_02_00 (s1[02][00], c1[02][00], zero      , s2[02], c2[03]);
	//	s1[01][00]
	//	p[00][00]

	assign z[2] = s2[02];
	assign z[1] = s1[01][00];
	assign z[0] = p [00][00];
	//assign z3 = z[2:0];
	//assign sum = s2[08:03];
	//assign carry = {s2[09]|c2[09], c2[08:03]};
	assign z[09:03] = s2[09:03] + c2[09:03];

endmodule

以下是64x64位的Wallace乘法器的仿真结果：

我的计算机自带计算器只能进行32x32的乘法，没有尝试用其他语言模拟大数运算（感觉应该不会有错）。

以下是代码生成器代码：


/* 其中参数有N和M，LEVEL三个宏定义了的参数
 * N和M表示乘法器位数为N*M的乘法器
 * 其中LEVEL需要根据设定的N和M测试，例如（N，M，LEVEL）有（24，24，7），（8，8，4）
 * 生成的代码在文件名：test1.txt
 * 生成的模块的主要输入有：a[N-1:0], b[M-1:0];
 *            主要输出有：z[N+M-1:0];
 */


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;

#define N 6
#define M 4
#define LEVEL 2

int p[N+M][N+M];
int s[LEVEL+1][N+M][N+M];
int c[LEVEL+1][N+M][N+M];

char w[3];
int  a[3];
int  b[3];
int  t[3];

char functionName[] = "add1";

void init();
void clean(char w, int a, int b, int c);
void print(int f, int sum, int n, int l);
int fill_w_a_b(int sum, int l);
void sub_P_wab(char w, int a, int b, int c);
void getend();


int main()
{
    freopen("test1.txt", "w", stdout);
    init();
    int T = LEVEL;
    int l = 1;
    int L = max(N, M);
    while(T--){
        cout<<"//level "<<l<<endl;
        if(T > 0){
            printf("\twire [%d:0] s%d[%2d:00];\n", (L-2)/3, l, N+M);
            printf("\twire [%d:0] c%d[%2d:00];\n", (L-2)/3, l, N+M);
        }
        else{
            printf("\twire [%2d:00] s%d;\n", N+M, l);
            printf("\twire [%2d:00] c%d;\n", N+M, l);
        }
        for(int i=N+M; i>=0; i--){
            int n = 0;
            int sum = i;
            //cout<<sum<<endl;
            while(1){
                int num = 0;
                num = fill_w_a_b(sum, l);
                print(num, sum, n++, l);
                if(num <= 1)
                    break;
            }
        }
        cout<<endl;
        l++;
    }
    getend();
    return 0;
}


int fill_w_a_b(int sum, int l)
{
    int n = 0;
    for(int i=0; i<N+M && n<3; i++){
        for(int j=0; j<N+M && n<3; j++){
            if((i+j)==sum && p[i][j]){
                w[n] = 'p';
                a[n] = i;
                b[n] = j;
                t[n] = -1;
                n++;
            }
        }
    }
    for(int z=0; z<LEVEL; z++){
        for(int i=0; i<N+M && n<3; i++){
            for(int j=0; j<N+M && n<3; j++){
                if(i==sum && z<l && s[z][i][j]){
                    w[n] = 's';
                    a[n] = i;
                    b[n] = j;
                    t[n] = z;
                    if(z == 0)
                        cout<<"???????1111"<<endl;
                    n++;
                }
            }
        }
    }
    for(int z=0; z<LEVEL; z++){
        for(int i=0; i<N+M && n<3; i++){
            for(int j=0; j<N+M && n<3; j++){
                if(i==sum && z<l && c[z][i][j]){
                    w[n] = 'c';
                    a[n] = i;
                    b[n] = j;
                    t[n] = z;
                    if(z == 0)
                        cout<<"???????2222"<<endl;
                    n++;
                }
            }
        }
    }
    return n;
}

void print(int f, int sum, int n, int l)
{
    if(f == 3){
        printf("\t");
        printf("%s ", functionName);
        printf("fa%02d_%02d_%02d ", l, sum, n);
        printf("(");

        sub_P_wab(w[0], a[0], b[0], t[0]);
        sub_P_wab(w[1], a[1], b[1], t[1]);
        sub_P_wab(w[2], a[2], b[2], t[2]);

        if(l != LEVEL)
            printf("s%d[%02d][%02d], ", l, sum, n);
        else
            printf("s%d[%02d], ", l, sum);
        s[l][sum][n] = 1;

        if(l != LEVEL)
            printf("c%d[%02d][%02d]", l, sum+1, n);
        else
            printf("c%d[%02d]", l, sum+1);
        c[l][sum+1][n] = 1;

        printf(");\n");
    }
    else if(f == 2){
        printf("\t");
        printf("%s ", functionName);
        printf("fa%02d_%02d_%02d ", l, sum, n);
        printf("(");

        sub_P_wab(w[0], a[0], b[0], t[0]);
        sub_P_wab(w[1], a[1], b[1], t[1]);
        printf("zero      , ");

        if(l != LEVEL)
            printf("s%d[%02d][%02d], ", l, sum, n);
        else
            printf("s%d[%02d], ", l, sum);
        s[l][sum][n] = 1;

        if(l != LEVEL)
            printf("c%d[%02d][%02d]", l, sum+1, n);
        else
            printf("c%d[%02d]", l, sum+1);
        c[l][sum+1][n] = 1;

        printf(");\n");
    }
    else if(f == 1){
        if(w[0]=='s' || w[0]=='c'){
            if(t[0] != 0)
                printf("\t//\t%c%d[%02d][%02d]\n", w[0], t[0], a[0], b[0]);
        }
        else
            printf("\t//\t%c[%02d][%02d]\n", w[0], a[0], b[0]);
    }
}

void sub_P_wab(char w, int a, int b, int c)
{
    if(w == 'p'){
        printf("%-2c[%02d][%02d], ", w, a, b);
        clean(w, a, b, c);
    }
    else if(w == 's' || w == 'c'){
        printf("%c%d[%02d][%02d], ", w, c, a, b);
        clean(w, a, b, c);
    }
}

void clean(char w, int a, int b, int t)
{
    switch(w){
        case 'p' : p[a][b] = 0; break;
        case 's' : s[t][a][b] = 0; break;
        case 'c' : c[t][a][b] = 0; break;
        default : break;
    }
}

void init()
{
    memset(p, 0, sizeof(p));
    memset(s, 0, sizeof(p));
    memset(c, 0, sizeof(p));
    for(int i=0; i<N; i++)
        for(int j=0; j<M; j++)
            p[i][j] = 1;
    printf("module wallace_tree%dx%d(\n", N, M);
    printf("\t\tinput  [%d:0] a,\n", N-1);
    printf("\t\tinput  [%d:0] b,\n", M-1);
    printf("\t\t//output [%d:0] sum,\n", N+M-LEVEL-3);
    printf("\t\t//output [%d:0] carry,\n", N+M-LEVEL-2);
    printf("\t\t//output [%d:0] z%d,\n", LEVEL, LEVEL+1);
    printf("\t\toutput [%d:0] z\n", N+M-1);
    printf("\t);\n\n");

    printf("\twire zero = 1\'b0;\n");
    printf("\treg [%d:0] p[%d:0];\n\n", M-1, N-1);

    printf("\tinteger i, j;\n");
    printf("\talways @*\n");
    printf("\tbegin\n");
    printf("\t\tfor(i=0; i<%d; i=i+1)\n", N);
    printf("\t\t\tfor(j=0; j<%d; j=j+1)\n", M);
    printf("\t\t\t\tp[i][j] = a[i] & b[j];\n");
    printf("\tend\n\n");
}

void getend()
{
    printf("\tassign z[%d] = s%d[%02d];\n", LEVEL, LEVEL, LEVEL);
    for(int i=LEVEL-1; i>0; i--){
        printf("\tassign z[%d] = s%d[%02d][00];\n", i, i, i);
    }
    printf("\tassign z[0] = p [00][00];\n");

    printf("\t//assign z%d = z[%d:0];\n", LEVEL+1, LEVEL);
    printf("\t//assign sum = s%d[%02d:%02d];\n", LEVEL, N+M-2, LEVEL+1);
    printf("\t//assign carry = {s%d[%02d]|c%d[%02d], c%d[%02d:%02d]};\n", LEVEL, N+M-1, LEVEL, N+M-1, LEVEL, N+M-2, LEVEL+1);
    printf("\tassign z[%02d:%02d] = s%d[%02d:%02d] + c%d[%02d:%02d];\n\n",
                        N+M-1, LEVEL+1, LEVEL, N+M-1, LEVEL+1, LEVEL, N+M-1, LEVEL+1);

    printf("endmodule\n");
}

 

有疑问或者有问题或者想要提意见的读者，可以给我留言哈！

 

威风的趣味
关注
  • 9
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数字IC/FPGA】Wallace乘法器
qq_40268672的博客
03-23 1265
Wallace乘法器原理 为了简单起见，本文以4x4乘法器为例。如下图所示 Wallace乘法器的基本思想就是对输入进行3-2压缩，它采用的是一个类似全加器的结构:输入为三个数，输出为两个数，并且在逻辑运算上和全加器完全一致(可以认为是全加器)，输出的加法结果位置不变，而输出的进位送入下一级(高位)参与运算。 我们将上图重写为下面的形式 然后，在第一级，我们用半加器将x1y2和x0y3求和，得到结果a0和进位输出b0(写到下一级)，同时也用半加器将x2y2和x1y3求和，得到结果a1和进位输出b1。
Wallace树乘法器verilog代码
05-14
在乘法器的设计中采用树形乘法器，可以减少关键路径和所需的加法器单元数目，Wallace树乘法器就是其中的一种。下面以一个4*4位乘法器为例介绍Wallace树乘法器及其Verilog HDL实现。
常见的乘法器Verilog源代码及仿真结果
09-02
常见的乘法器Verilog源代码及仿真结果！！！！ 仿真 , 源代码
Wallace树乘法器及Verilog实现
最新发布
qq_43433724的博客
05-11 799
Wallace树乘法器就是将多个部分积进行分组，每三个一组，最后如果剩下的部分积个数不够三个的不做处理，然后将各组的部分积进行相加得到和以及进位信息，直到最终只剩下两行部分积，相加后得到最终结果。以下面的例子进行说明：，然后按照三个三个，如图中相同颜色的为一组，但是最后黄色的两个由于不够则不进行运算，然后对一组内的三行部分积进行运算，得到的和留在本位，得到的进位填充到前一列的最后一行，详见下图2图1图2在上图中，我们以红色部分的进行举例，三行的。
Wallace树乘法器
qq_41844618的博客
02-11 5733
当前乘法器的设计主要有两种方式，Wallace树乘法器和booth编码乘法器。本篇主要讲述的是Wallace树乘法器。
Wallace_乘法器_Wallace树形乘法器_Wallace_
10-01
8*8Wallace树形乘法器 8*8Wallace树形乘法器 8*8Wallace树形乘法器 8*8Wallace树形乘法器
乘法器——Wallace树型乘法器
qq_29768741的博客
05-16 8781
文章转自https://www.cnblogs.com/wangkai2019/p/11153887.html，在此保存一下 博主最近在看乘法器相关的知识，发现现在用的比较多的是booth编码的乘法器和Wallace树型乘法器，当然两者并不是互斥的关系，他们也可以结合使用。在这里给大家介绍一下Wallace树型乘法器，希望能对大家有所帮助。 首先我们以两个无符号8位二进制数相乘为例来说明Wallace树的算法。由图1所示，图中8位二进制数a和8位二进制数b相乘，产生64个乘积项，记做a[i]*b[j]，i,
Verilog HDL实现Wallace树乘法器
qq_44002905的博客
03-27 256
【代码】Verilog HDL实现Wallace树乘法器。
复数乘法器的verilog HDL设计代码及其测试文件（修改版）
05-15
在这个例子中，使用了Wallace树乘法器，这是一种高效的二进制乘法结构。Wallace树通过将乘法分解为一系列的加法和半加器，极大地减少了乘法所需的门延迟，提高了计算速度。 2. **乘积的组合**：实部乘以实部、虚部...
booth_wallace_multiplier:展位编码的华莱士树乘法器
05-17
【华莱士树乘法器】是数字电路设计中一种高效实现乘法运算的方法，尤其在硬件描述语言如Verilog中被广泛使用。华莱士树乘法器利用了二进制补码表示的乘法规则，通过并行计算部分积和串行相加来完成两个二进制数的...
verilog实现大位宽乘法器优化对比与研究
12-28
在本文中，我们探讨了在Verilog中实现大位宽乘法器的优化策略，重点研究了不同算法模型和低功耗设计。大位宽乘法器在许多领域，如数字信号处理（DSP）和嵌入式系统中扮演着重要角色。由于对高速计算和低功耗的需求日...
华莱士树乘法器
12-12
介绍华莱士树算法乘法器，即阵列加法器原理设计的高速乘法器。
Wallace树乘法器专题研究
05-14
看了很多个博客，看了很多本书，就为了研究一个wallace树乘法器，研究了几天，没有任何一个资源把这个问题写的仔仔细细，明明白白，痛苦万分。功夫不负有心人，经过几天的研究以及同学的帮助，最终解决了这个问题，于是同大家分享。希望你们遇到这个问题能够前进地更容易点。
Wallace树型乘法器的设计
01-19
引言 　　在微处理器芯片中，乘法器是进行数字信号处理的，同时也是微处理器中进行数据处理的关键部件。乘法器完成操作的周期基本上决定了微处理器的主频。乘法器的速度和面积优化对于整个CPU的性能来说是非常重要的。为了加快乘法器的执行速度，减少乘法器的面积，有必要对乘法器的算法、结构及电路的具体实现做深入的研究。 基4 Booth算法与乘法器的一般结构 　　乘法器工作的基本原理是首先生成部分积，再将这些部分积相加得到乘积。在目前的乘法器设计中，基４Booth算法是部分积生成过程中普遍采用的算法。对于N位有符号数乘法A×B来说，常规的乘法运算会产生N个部分积。如果对乘数B进行基４Booth编码，每
【verilog】快速乘法器。两个16位有符号数，输出32位相乘结果，采用Booth编码和Wallace树型结构
06-20
输入为两个16位有符号数，输出32位相乘结果。要求采用Booth编码和Wallace树型结构。 计算例子： 0110000010000000 * 1000000000000001 = 11001111110000000110000010000000 (24704) * (-32767) = (-809475968) 顶层模块名为mul_tc_16_16，输入输出功能定义： 名称 方向 位宽 描述 a I 16 输入数据，二进制补码 b I 16 输入数据，二进制补码 product O 32 输出乘积a * b，二进制补码
小学算术生成工具
09-13
此款小学数学题生成工具，主要用于小学1-2年级数学练习，通过不断的练习，可以使得算术运算的速度有所提高。省去了家长编题的烦恼，而且不会生成0以下的负数形式。此版本需要运行Excel宏，可能由于宏级别太高而无法运行，可以将宏级别降低试试。如担心有病毒，亲们可以先打开源代码看看，源代码是不加密的哦。
fpga 8位乘法器 verilog HDL 源代码
08-25
以下是一个简单的8位乘法器Verilog HDL代码示例： ```verilog module mul8bit(x, y, product); input [7:0] x, y; output [15:0] product; // 使用Booth算法或其他乘法算法 // 这里仅用作概念展示，实际实现...
8*8wallace乘法器
weixin_46781565的博客
04-01 2181
8*8 wallace乘法器 此次乘法器主要是使用全加器来进行运算，用四级全加器来讲wallace树压缩，最后进行相加。 如图所示，可以理解为第一级别压缩，使用20个全加器。给下面的列数标号，可以看出每一列的a和b的 参数相加和列数相同，这个地方可以方便写代码是进行检查。此步骤使用全加器得出的结果位和进位可以用一个两位变量来放置进行下一步的压缩或者说累加。01列计算出来的进位和结果为使用b1[1：0],b1[1]表示01列计算的进位，b1[0]表示计算的结果位。 如图所示，显示为第二次压缩，本次使用15
verilog学习笔记之一--（简化）华莱士(Wallace)树形乘法器设计--（原代码出自用芯学项目）
qq_44875030的博客
03-27 7590
verilog学习笔记之一–（简化）华莱士(Wallace)树形乘法器设计–（原代码出自用芯学项目） 学习准备1： 树形乘法器原理：参考《数字集成电路-电路、系统与设计(第二版)》–P437 根据上图这种压缩的原理在部分积产生之后可以减少关键路径和所需的加法器单元数目；如下图所示： 上图是以下代码的原理，但是如果按照上图方法编写代码我感觉是一个巨量工程，我这种小白想不出来，而在用芯学的前端课程...
wallace树乘法器verilog
06-06
### 回答1： Wallace树乘法器是一种用于高速乘法运算的电路结构。它是将数字按照二进制位拆分成多个部分，并通过逐级相乘的方式计算乘积，最终得到结果的。在Verilog中，可以使用结构化描述的方法来实现Wallace树乘法器。具体实现过程需要根据设计需求进行调整，包括输入位数、输出位数、逻辑门的类型等等。在设计完成后，需要进行仿真和验证，确保电路的正确性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值