FPGA, Float 32bit, multiplyier by Verilog

1, FPGA device, using three 18bit x 18 bit multiplier to implement 32bit float multiplier

2, comparing to Altera float multiplyer IP

　  (1)  just half of the LEs were used

(2)  nearly same accuracy

VS2013, simulation by C

/////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <ios>
#include <iostream>

typedef unsigned int uint;
typedef unsigned long long uint64;
typedef long long int64;

uint GetBits(const float& v, int nstart, int cnt){
    uint bits = 0;
    uint vv;
    memcpy(&vv, &v, sizeof(v));
    //printf("%f, 0x%h) << std::endl; ", v, vv);
    for(int i = cnt - 1; i >= 0; i--){
        int idx = nstart + i;
        uint t = 1 << idx;

bits <<= 1;
        int b = (vv >> idx) & 1;
        bits |= b;
        //printf("%d", b);
    }
    //printf("\n");
    return bits;
}

int64 HighestOne(int64 v){
    int idx = -1;
    for(int i = sizeof(v)* 8 - 1; i >= 0; i--){
        if((v >> i) & 1){
            idx = i;
            break;
        }
    }
    return idx;
}

template<typename T1, typename T2>
void SetBit(T1& src, int src_idx, T2& dst, int dst_idx){
    int v = (src >> src_idx) & 1;
    if(v)
        dst |= v << dst_idx;
}

template<typename T1, typename T2>
void SetBits(T1& src, int src_idx, T2& dst, int dst_idx, int count){
    for(int i = 0; i < count; i++){
        SetBit(src, src_idx + i, dst, dst_idx + i);
    }
}

float fpmul(float a, float b){
    int64 s1 = GetBits(a, 31, 1);
    int64 s2 = GetBits(b, 31, 1);
    int64 e1 = GetBits(a, 23, 8);
    int64 e2 = GetBits(b, 23, 8);
    int64 f1 = GetBits(a, 0, 23);
    int64 f2 = GetBits(b, 0, 23);
    int64 a1 = GetBits(a, 14, 9);
    int64 a2 = GetBits(b, 14, 9);
    int64 b1 = GetBits(a, 5, 9);
    int64 b2 = GetBits(b, 5, 9);

//sum = 1 + f1 + f2 + [ (a1*a2) + (a1*b2 + a2*b1)*2^(-9) + (c1*a2 + b1*b2 + a1*c2)*2^(-18) + 0]               
    int64 sum = int64(1 << 23)
        + (f1 + f2)
        + (int64(a1 * a2) << (28 - 23))
        + (int64(a1*b2 + a2*b1) >> (9 - (28 - 23)));
    int nHightIndx = HighestOne(sum);

uint val = 0;
    SetBits(sum, nHightIndx - 23, val, 0, 23);

int e = e1 - 127 + e2 - 127 + 127 + (nHightIndx - 23);
    int s = ((s1 + s2) & 1) ? (1) : (0);

SetBits(e, 0, val, 23, 8);
    SetBit(s, 0, val, 31);

//val = 0x4023d702;
    float v;
    memcpy(&v, &val, sizeof(v));

return v;
}

void Test_fpmul(){
    //float v1 = 0.056984*0.056984;
    //float v = fpmul(0.056984, 0.056984);
    for(int i = -1000; i < 1000; i++){
        float a = -0.23 + i*0.0003;
        float b = 0.19 + i*0.0003;
        float v = fpmul(a, b);
        printf("a(%e), b(%e), a*b=%e, my_fmul=%e\n", a, b, (a*b), v);
    }
}

inline float Hex2Float(uint val){
    float v = 0;
    memcpy(&v, &val, sizeof(val));
    return v;
}

#define HEX2FLOAT(_x)  Hex2Float((0x##_x))

inline void Verify(){
    float s;
    std::cout << HEX2FLOAT(3fc30f28) << " x " << HEX2FLOAT(3fc30f28) << std::endl;
    std::cout << HEX2FLOAT(00000000) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(40a7a9fc) << " x " << HEX2FLOAT(40a7a9fc) << std::endl;
    std::cout << HEX2FLOAT(40800000) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(4251954d) << " x " << HEX2FLOAT(4251954d) << std::endl;
    std::cout << HEX2FLOAT(4014a012) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(4402fd52) << " x " << HEX2FLOAT(4402fd52) << std::endl;
    std::cout << HEX2FLOAT(41db9e50) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(4251954d) << " x " << HEX2FLOAT(4402fd52) << std::endl;
    std::cout << HEX2FLOAT(452b9514) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(3f07929f) << " x " << HEX2FLOAT(3f07929f) << std::endl;
    std::cout << HEX2FLOAT(48860c65) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(bf07929f) << " x " << HEX2FLOAT(4402fd52) << std::endl;
    std::cout << HEX2FLOAT(46d67a53) << std::endl;
    std::cout << "--------------------------------" << std::endl;
    //
    //
    std::cout << HEX2FLOAT(4380650b) << " x " << HEX2FLOAT(4380650b) << std::endl;
    std::cout << HEX2FLOAT(3e8f97e9) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3da1ab4b) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(c38abd2d) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3da1ab4b) << " x " << HEX2FLOAT(3f07929f) << std::endl;
    std::cout << HEX2FLOAT(4780ca5b) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3da1ab4b) << " x " << HEX2FLOAT(00000000) << std::endl;
    std::cout << HEX2FLOAT(3bcc31b9) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3bbab9a5) << std::endl;
    std::cout << HEX2FLOAT(3d2b3bca) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(7e21ab4b) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(3808323b) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(39ebd749) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(39ebd749) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(39ebd749) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(39ebd749) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(39ebd749) << std::endl;
    std::cout << "--------------------------------" << std::endl;

std::cout << HEX2FLOAT(3bbab9a5) << " x " << HEX2FLOAT(3da1ab4b) << std::endl;
    std::cout << HEX2FLOAT(39ebd749) << std::endl;
    std::cout << "--------------------------------" << std::endl;

}

void main(){
    Test_fpmul();
    Verify();
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////// Verilog Implement ///////////////////////////

//`define _DEBUG
module my_fpmul(clk, rst_n, dataa, datab, result
`ifdef _DEBUG
        ,_a1 ,_b1 ,_a2 ,_b2, _e1, _e2
        ,_ss
        ,_sum
        , _se
        ,_sf1f2
        ,_sa1a2
        ,_sa1b2
        ,_sa2b1
`endif
        );

input  clk;
input  rst_n;
input  [31:0] dataa;
input  [31:0] datab;
output [31:0] result;

`ifdef _DEBUG
output [8:0]_a1;
output [8:0]_b1;
output [8:0]_a2;
output [8:0]_b2;
output [8:0]_e1;
output [8:0]_e2;
output _ss;
output [26:0]_sum;
output [8:0]_se;
output [24:0]_sf1f2;
output [22:0]_sa1a2;
output [18:0]_sa1b2;
output [18:0]_sa2b1;
`endif

//clk 1
reg [31:0]datac = 32‘h0;
reg s1          = 1‘b0;
reg s2          = 1‘b0;
reg [8:0]e1     = 8‘b0;
reg [8:0]e2     = 8‘b0;
reg [22:0]f1    = 23‘b0;
reg [22:0]f2    = 23‘b0;
reg [17:0]a1     = 18‘b0;
reg [17:0]a2     = 18‘b0;
reg [17:0]b1     = 18‘b0;
reg [17:0]b2     = 18‘b0;

//clk 2
reg ss = 1‘b0;
reg [24:0]sf1f2 = 25‘b0;
reg [22:0]sa1a2 = 23‘b0;
reg [18:0]sa1b2 = 19‘b0;
reg [18:0]sa2b1 = 19‘b0;
reg [26:0]sum   = 32‘b0;
reg [8:0]se    = 9‘b0;

////clk 3
reg  sss = 1‘b0;
reg [7:0]sse   = 8‘b0;
reg [22:0]ssum = 23‘b0;

//pipline step 1
[email protected](posedge clk or negedge rst_n) begin
    if (!rst_n) datac <= 32‘h0;
    else begin
        s1 <= dataa[31:31];
        s2 <= datab[31:31];
        e1 <= dataa[30:23];
        e2 <= datab[30:23];
        f1 <= dataa[22:0];
        f2 <= datab[22:0];
        a1 <= {9‘b0, dataa[22:14]};
        a2 <= {9‘b0, datab[22:14]};
        b1 <= {9‘b0, dataa[13:5]};
        b2 <= {9‘b0, datab[13:5]};
    end
end

//pipline step 2
[email protected](posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        ss <= 1‘b0;
        se <= 1‘b0;
        sum <= 27‘b0;
    end else begin
        ss <= s1^s2;
        se <= e1 + e2 - 8‘d127;        
        sf1f2 = (24‘b1 << 23) + (f1 + f2);
        sa1a2 = {a1*a2,5‘b0};
        sa1b2 = a1*b2;
        sa2b1 = a2*b1;    
        sum <= sf1f2 + sa1a2 + ((sa1b2 + sa2b1)>>3‘d4);
        //sum <= (26‘b1 << 23) + (f1 + f2) + {a1*a2,5‘b0} + {{9‘b0, a1}*{9‘b0, a2}, 5‘b0} + {9‘b0, a1}*{9‘b0, b2} + {9‘b0, a2}*{9‘b0, b1};
    end
end

//pipline step 3
[email protected](posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        sss <= 1‘b0;
        sse <= 8‘b0;
        ssum <= 23‘b0;
    end else begin    
        sss <= ss;
        if (sum[25]) begin
            sse <= se + 2‘d2;
            ssum <= sum[24:2];
        end else if (sum[24]) begin
            sse <= se + 2‘d1;
            ssum <= sum[23:1];
        end else begin
            sse <= se;
            ssum <= sum[22:0];
        end
    end
end

assign result = {sss, sse, ssum};

`ifdef _DEBUG
assign _e1 = e1;
assign _e2 = e2;
assign _a1 = a1;
assign _b1 = b1;
assign _a2 = a2;
assign _b2 = b2;
assign _ss = ss;
assign _sum = sum;
assign _se = se;
assign _sf1f2 = sf1f2;
assign _sa1a2 = sa1a2;
assign _sa1b2 = sa1b2;
assign _sa2b1 = sa2b1;
`endif

endmodule

//////////////////////////////////////////////////////////////////////////////

/////////////////////////////Test Bench////////////////////////////////////

//`define _DEBUG

`timescale 1 ns/ 1 ps
module my_fpmul_vlg_tst();
// constants                                           
// general purpose registers
reg eachvec;
// test vector input registers
reg clk;
reg [31:0] dataa;
reg [31:0] datab;
reg rst_n;
// wires                                               
wire [31:0]  result;

`ifdef _DEBUG
wire [8:0]  _a1, _b1, _a2, _b2;
wire[8:0]_e1;
wire[8:0]_e2;
wire _ss;
wire [26:0]_sum;
wire [8:0]_se;
wire [24:0]_sf1f2;
wire [22:0]_sa1a2;
wire [18:0]_sa1b2;
wire [18:0]_sa2b1;
`endif

// assign statements (if any)                          
my_fpmul i1 (
// port map - connection between master ports and signals/registers   
    .clk(clk),
    .rst_n(rst_n),    
    .dataa(dataa),
    .datab(datab),
    .result(result)
`ifdef _DEBUG
    ,._a1(_a1) , ._b1(_b1) , ._a2(_a2) , ._b2(_b2), ._e1(_e1), ._e2(_e2)
    ,._ss(_ss) , ._sum(_sum)    , ._se(_se)
    ,._sf1f2(_sf1f2)
        ,._sa1a2(_sa1a2)
        ,._sa1b2(_sa1b2)
        ,._sa2b1(_sa2b1)
`endif
);

initial begin
    rst_n = 1;
    clk   = 0;
    forever #10 clk = ~clk;
end

initial begin
    repeat(30)
    begin
        #7
        $display("%x * %x : ", dataa, datab);
        #5
        $display("%x", result);
        #8
        $display("\n");
    end    
end

initial begin
    //dataa<=32‘h3bbab9a5; //0.0056984  
    //datab<=32‘h3bbab9a5; //0.0056984

dataa <= 32‘b0;
    datab <= 32‘b0;    
    #5;  
    dataa<=32‘h3fc30f28; //1.5239  
    datab<=32‘h3fc30f28;  
    #20;  
    dataa<=32‘h40a7a9fc; //5.2395  
    datab<=32‘h40a7a9fc;  
    #20;  
    dataa<=32‘h4251954d; //52.3958  
    datab<=32‘h4251954d;  
    #20;  
    dataa<=32‘h4402fd52; //523.9581  
    datab<=32‘h4402fd52;  
    #20;  
    dataa<=32‘h4251954d; //52.3958  
    datab<=32‘h4402fd52; //523.9581  
    #20;  
    dataa<=32‘h3f07929f; //0.529581  
    datab<=32‘h3f07929f;  
    #20;  
    dataa<=32‘hbf07929f; //-0.529581  
    datab<=32‘h4402fd52; //523.9581  
    #20;  
    dataa<=32‘h4380650b; //256.7894  
    datab<=32‘h4380650b;   
    #20;  
    dataa<=32‘h3da1ab4b; //0.07894  
    datab<=32‘h3da1ab4b;   
    #20;  
    dataa<=32‘h3da1ab4b; //0.07894  
    datab<=32‘h3f07929f; //0.529581  
    #20;  
    dataa<=32‘h3da1ab4b; //0.07894  
    datab<=32‘h0; //0.529581  
    #20;  
    dataa<=32‘h3bbab9a5; //0.0056984  
    datab<=32‘h3bbab9a5; //0.0056984  
    #20;  
    dataa<=32‘h3bbab9a5; //0.0056984  
    datab<=32‘h3da1ab4b; //0.07894

#2000
     $stop;
     //$finish;
    
end

endmodule
//////////////////////////////////////////////////////////////////////////////////////////////

时间： 2024-10-10 12:41:08

FPGA, Float 32bit, multiplyier by Verilog的相关文章

FPGA培训专家 V3学院 FPGA专家 带你学习Verilog语言top_down书写技巧

此文章为原创出自 V3学院 www.v3edu.org,FPGA培训专家 为了提高我们代码的复用率,我们可以将不同的功能的代码分模块书写,然后在顶层连线即可.我们举一个简单的例子,如下程序,我们实现的是LED流水. 我们在led模块中先将系统时钟分频为1HZ的时钟,然后用分频后的时钟控制LED灯的流水,但我的分频和LED灯流水完全不是相同的工程,只是把分频后的时钟作为LED灯的控制时钟.这样我们会发现如果我再次用到流水灯的模块的话需要修改很多地方,那么为了让我们的模块复用率更高.更容易复用,我们

134-基于TMS320C6678、FPGA XC5VSX95T的一路Full模式Camera Link图像理平台

基于TMS320C6678.FPGA XC5VSX95T的一路Full模式Camera Link图像理平台 一.板卡概述 该板卡采用TI公司新一代DSP TMS320C6678,结合FPGA,型号为Xilinx Spratan 6 XC6SLX100T,支持 一路Full模式的Camera Link信号输入.可选工业级芯片. 二.性能指标: 1.自定义标准结构,几何大小 250X120mm.  2. 采用单DSP,TMS320C6678,实现8核,1.25GMHz的快速数据处理.支持定点和浮点运

C中的Float分析

C/C++中, 浮点数,float以及 double 在内存中是怎样存储的? 假如,我有32-bit 8bit 8bit 8bit 0 0 0 0 0 1 1 1 1 对于整形int,我们可以很快得出,这是 int i = 15的内存形式. 假设,最低位的bit的位权为-1,最高位为30. 那么这个就不再表示数字15了,而是 2^-1+2^0+2^1+2^2 = 7.5 了. 当然,上面只是假设,那么真正的Float 浮点型 在内存中是什么样子的呢? 首先需要知道的是 float 在内存中 占

java基本类型（数值范围）：浮点的底层表示定义，float计算快一些

Java八种基本类型: 六种数字类型(四个整数型,两个浮点型), 一种字符类型, 一种布尔型. 详细例如以下 1.整数:包含int,short,byte,long 2.浮点型:float,double 3.字符:char 4.布尔:boolean 相应空间和范围例如以下 基本型别 二进制位数 最小值 最大值 包装类 boolean 无 无 无 char 16-bit 0(Unicode) 65535(Unicode 2^16-1) java.lang.Character byte 8-bit -

我的 FPGA 学习历程（01）&mdash;&mdash; 数字逻辑入门

       大概是在13年的时候,弟弟给我看了一段 verilog 代码,并且跟我说这东西很有用,于是网上查了查资料,大神们是这样说的:在大学,你只能学到 51单片机,作为电子的入门基础,但是实际上嵌入式市场上用的大多是更为高端的芯片,主要分为三类:ARM.DSP.FPGA.        既然决定学下 FPGA,就一定要有一块开发板.淘宝上的板子有很多家,有黑金.特权.至芯科技等等好多家,最后选了黑金的一块学生版AX301.当时以为 FPGA 嘛,肯定要比 51 高级一些,板子上有个 VGA

通过FPGA驱动OV5640调试记录

最近无聊,想通过FPGA来驱动OV5640,达到高速并行的图像处理.其中使用了8个sensor.是Omnivision的500W高清摄像头.主要用于手机,pad,等移动设备的主摄像头.在网上搜索了一把,包括谷歌和百度.都没发现太有价值的信息.后面自己硬着头皮开始自己来弄.应该用fpga控制ov5640我属于首创. 经过漫长的原理图设计,原理图如下: 其中的DOVDD使用的是D1.8V,这样就可以使用内部的LDO,外部只需要2.8V和1.8V.在使用DOVDD为1.8V时,可以不连接DVDD这个电

Verilog HDL那些事儿

第一章:我眼中的 FPGA 和 Verilog HDL 1."在笔者的心里,FPGA 宛如 “一堆乐高积木”和 Verilog HDL 是自己的手(工具) ,自己可以随心所愿的要怎么拆就怎么拆." 第二章:低级建模 - 基础知识 1.Verilog HDL 不是“编程”是“建模”.“建模”这一词是指,使用“硬件描述语言”去建立某个资源模块.如果说 c 语言可以使用“编程”一词,那么 Verilog HDL 语言使用“建模”这一词更适合不过了.Verilog HDL 语言是一种富有 “形

Java中浮点类型的精度问题 double float

要说清楚Java浮点数的取值范围与其精度,必须先了解浮点数的表示方法与浮点数的结构组成.因为机器只认识01,你想表示小数,你要机器认识小数点这个东西,必须采用某种方法.比如,简单点的,float四个字节,前两个字节表示整数位,后两个字节表示小数位(这就是一种规则标准),这样就组成一个浮点数.而Java中浮点数采用的是IEEE 754标准. IEEE 754 标准 更多详见:https://baike.baidu.com/item/IEEE%20754 IEEE 754 标准是IEEE二进位浮点数

我的 FPGA 学习历程（01）&mdash;&mdash; FPGA 基础知识和 Quartus 的安装

高级的嵌入式市场主要分为以下三类:ARM.DSP 和 FPGA. 其中 ARM 是行业内的佼佼者,目前几乎所有的安卓智能手机都使用 ARM 授权的 CPU架构:而 DSP(数字信号处理器) 早年就被大面积的应用与电话.DVD.通讯基站等领域.DSP 与 ARM 的区别在于,ARM 是通用 CPU,DSP 则是专用 CPU.FPGA 则与他们不同,FPGA 的名称的由来是由于 FPGA 功能的成型是在实验室等通常工作环境下进行的:区别与专有集成电路 (ASIC)在晶圆工厂的制造,所以 FPGA 被