当前位置:   article > 正文

关于FPGA的浮点数处理 III_fpga实现浮点运算

fpga实现浮点运算

关于FPGA的浮点数处理 III

语言 :System Verilg
EDA工具:ISE、Vivado、Quartus II

  • 关键词: 调用,浮点数处理,floating point、单精度浮点数的乘、加、开方、绝对值操作

一、引言

在FPGA中实现浮点运算是一个复杂但有用的过程,因为浮点运算在许多应用中都是必需的,如数字信号处理、图像处理和科学计算等,上篇博客中介绍了在FPGA中使用浮点数运算的背景以及实现方式,传送链接:0315 FPGA的浮点数处理 I,以及浮点数在FPGA和有符号整数之间的转换关于FPGA的浮点数处理 II本篇博客注重描述单精度浮点数在FPGA中乘、加、开方、绝对值等操作

二、单精度浮点数运算的FPGA实现

1. 单精度浮点数的加法FPGA实现
(1)实现代码(FpAdd模块)
module FpAdd (
    input             iCLK,
    input      [26:0] iA,
    input      [26:0] iB,
    output reg [26:0] oSum
);

    // Extract fields of A and B.
    wire        A_s;
    wire [7:0]  A_e;
    wire [17:0] A_f;
    wire        B_s;
    wire [7:0]  B_e;
    wire [17:0] B_f;
    assign A_s = iA[26];
    assign A_e = iA[25:18];
    assign A_f = {1'b1, iA[17:1]};
    assign B_s = iB[26];
    assign B_e = iB[25:18];
    assign B_f = {1'b1, iB[17:1]};
    wire A_larger;

    // Shift fractions of A and B so that they align.
    wire [7:0]  exp_diff_A;
    wire [7:0]  exp_diff_B;
    wire [7:0]  larger_exp;
    wire [36:0] A_f_shifted;
    wire [36:0] B_f_shifted;

    assign exp_diff_A = B_e - A_e; // if B bigger
    assign exp_diff_B = A_e - B_e; // if A bigger

    assign larger_exp = (B_e > A_e) ? B_e : A_e;

    assign A_f_shifted = A_larger             ? {1'b0,  A_f, 18'b0} :
                         (exp_diff_A > 9'd35) ? 37'b0 :
                         ({1'b0, A_f, 18'b0} >> exp_diff_A);
    assign B_f_shifted = ~A_larger            ? {1'b0,  B_f, 18'b0} :
                         (exp_diff_B > 9'd35) ? 37'b0 :
                         ({1'b0, B_f, 18'b0} >> exp_diff_B);

    // Determine which of A, B is larger
    assign A_larger =    (A_e > B_e)                   ? 1'b1  :
                         ((A_e == B_e) && (A_f > B_f)) ? 1'b1  :
                         1'b0;

    // Calculate sum or difference of shifted fractions.
    wire [36:0] pre_sum;
    assign pre_sum = ((A_s^B_s) &  A_larger) ? A_f_shifted - B_f_shifted :
                     ((A_s^B_s) & ~A_larger) ? B_f_shifted - A_f_shifted :
                     A_f_shifted + B_f_shifted;

    // buffer midway results
    reg  [36:0] buf_pre_sum;
    reg  [7:0]  buf_larger_exp;
    reg         buf_A_e_zero;
    reg         buf_B_e_zero;
    reg  [26:0] buf_A;
    reg  [26:0] buf_B;
    reg         buf_oSum_s;
    always @(posedge iCLK) begin
        buf_pre_sum    <= pre_sum;
        buf_larger_exp <= larger_exp;
        buf_A_e_zero   <= (A_e == 8'b0);
        buf_B_e_zero   <= (B_e == 8'b0);
        buf_A          <= iA;
        buf_B          <= iB;
        buf_oSum_s     <= A_larger ? A_s : B_s;
    end

    // Convert to positive fraction and a sign bit.
    wire [36:0] pre_frac;
    assign pre_frac = buf_pre_sum;

    // Determine output fraction and exponent change with position of first 1.
    wire [17:0] oSum_f;
    wire [7:0]  shft_amt;
    assign shft_amt = pre_frac[36] ? 8'd0  : pre_frac[35] ? 8'd1  :
                      pre_frac[34] ? 8'd2  : pre_frac[33] ? 8'd3  :
                      pre_frac[32] ? 8'd4  : pre_frac[31] ? 8'd5  :
                      pre_frac[30] ? 8'd6  : pre_frac[29] ? 8'd7  :
                      pre_frac[28] ? 8'd8  : pre_frac[27] ? 8'd9  :
                      pre_frac[26] ? 8'd10 : pre_frac[25] ? 8'd11 :
                      pre_frac[24] ? 8'd12 : pre_frac[23] ? 8'd13 :
                      pre_frac[22] ? 8'd14 : pre_frac[21] ? 8'd15 :
                      pre_frac[20] ? 8'd16 : pre_frac[19] ? 8'd17 :
                      pre_frac[18] ? 8'd18 : pre_frac[17] ? 8'd19 :
                      pre_frac[16] ? 8'd20 : pre_frac[15] ? 8'd21 :
                      pre_frac[14] ? 8'd22 : pre_frac[13] ? 8'd23 :
                      pre_frac[12] ? 8'd24 : pre_frac[11] ? 8'd25 :
                      pre_frac[10] ? 8'd26 : pre_frac[9]  ? 8'd27 :
                      pre_frac[8]  ? 8'd28 : pre_frac[7]  ? 8'd29 :
                      pre_frac[6]  ? 8'd30 : pre_frac[5]  ? 8'd31 :
                      pre_frac[4]  ? 8'd32 : pre_frac[3]  ? 8'd33 :
                      pre_frac[2]  ? 8'd34 : pre_frac[1]  ? 8'd35 :
                      pre_frac[0]  ? 8'd36 : 8'd37;

    wire [53:0] pre_frac_shft, uflow_shift;
	 // the shift +1 is because high order bit is not stored, but implied
    assign pre_frac_shft = {pre_frac, 17'b0} << (shft_amt+1); //? shft_amt+1
	 assign uflow_shift = {pre_frac, 17'b0} << (shft_amt); //? shft_amt for overflow
    assign oSum_f = pre_frac_shft[53:36];

    wire [7:0] oSum_e;
    assign oSum_e = buf_larger_exp - shft_amt + 8'b1;

    // Detect underflow
    wire underflow;
	 // this incorrectly sets uflow for 10-10.1
    //assign underflow = ~oSum_e[7] && buf_larger_exp[7] && (shft_amt != 8'b0);
	 
	 // if top bit of matissa is not set, then denorm
	 assign underflow = ~uflow_shift[53]; 
	 
	 always @(posedge iCLK) begin
			oSum <= (buf_A_e_zero && buf_B_e_zero)    ? 27'b0 :
                  buf_A_e_zero                     ? buf_B :
                  buf_B_e_zero                     ? buf_A :
                  underflow                        ? 27'b0 :
                  (pre_frac == 0)                  ? 27'b0 :
                  {buf_oSum_s, oSum_e, oSum_f};
	 end //output update
endmodule
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
(2)代码分析

FpAdd模块的作用是实现浮点数的加法运算。浮点数的表示通常由三个部分组成:符号位(sign bit)、指数(exponent)和尾数(fraction)。这个模块将两个浮点数相加,并将结果存储在输出寄存器oSum中。

对代码分析:

1、输入输出定义:
iCLK:时钟信号。
iA和iB:输入的两个浮点数,每个数27位,包括1位符号位、8位指数位和17位尾数位。
oSum:输出的浮点数结果,也是27位。

2、提取输入浮点数的各部分:
A_s和B_s:分别表示iA和iB的符号位。
A_e和B_e:分别表示iA和iB的指数位。
A_f和B_f:分别表示iA和iB的尾数位,其中最高位隐含为1。

3、对齐尾数:
计算两个指数的差值,确定哪个指数更大。
根据差值,将尾数右移或左移,使它们对齐。

4、确定哪个数更大:
通过比较指数和尾数来确定A和B中哪个数更大,并赋值给A_larger。

5、计算求和或差:
根据符号位和A_larger的值,计算两个浮点数的和或差。

6、缓冲中间结果:
使用always块在时钟上升沿更新中间结果。

7、处理结果的尾数和指数:
根据预处理的尾数pre_frac,确定输出尾数oSum_f和输出指数oSum_e。

8、检测下溢:
检查是否发生下溢,并在必要时将结果设置为0。

9、输出结果:
在时钟上升沿更新输出寄存器oSum,根据条件设置结果。

2. 单精度浮点数的乘法FPGA实现
(1)实现代码(FpMul模块)
module FpMul (
    input      [26:0] iA,    // First input
    input      [26:0] iB,    // Second input
    output     [26:0] oProd  // Product
);

    // Extract fields of A and B.
    wire        A_s;
    wire [7:0]  A_e;
    wire [17:0] A_f;
    wire        B_s;
    wire [7:0]  B_e;
    wire [17:0] B_f;
    assign A_s = iA[26];
    assign A_e = iA[25:18];
    assign A_f = {1'b1, iA[17:1]};
    assign B_s = iB[26];
    assign B_e = iB[25:18];
    assign B_f = {1'b1, iB[17:1]};

    // XOR sign bits to determine product sign.
    wire        oProd_s;
    assign oProd_s = A_s ^ B_s;

    // Multiply the fractions of A and B
    wire [35:0] pre_prod_frac;
    assign pre_prod_frac = A_f * B_f;

    // Add exponents of A and B
    wire [8:0]  pre_prod_exp;
    assign pre_prod_exp = A_e + B_e;

    // If top bit of product frac is 0, shift left one
    wire [7:0]  oProd_e;
    wire [17:0] oProd_f;
    assign oProd_e = pre_prod_frac[35] ? (pre_prod_exp-9'd126) : (pre_prod_exp - 9'd127);
    assign oProd_f = pre_prod_frac[35] ? pre_prod_frac[34:17] : pre_prod_frac[33:16];

    // Detect underflow
    wire        underflow;
    assign underflow = pre_prod_exp < 9'h80;

    // Detect zero conditions (either product frac doesn't start with 1, or underflow)
    assign oProd = underflow        ? 27'b0 :
                   (B_e == 8'd0)    ? 27'b0 :
                   (A_e == 8'd0)    ? 27'b0 :
                   {oProd_s, oProd_e, oProd_f};

endmodule
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
(2)代码分析

FpMul的模块,它的作用是实现了两个浮点数的乘法运算。代码的目的是将两个27位的浮点数相乘,并将结果存储在输出oProd中。以下是对代码的详细解释:

1、模块输入输出:

(1)iA和iB:分别是乘法操作的两个输入浮点数,每个数27位,包括1位符号位、8位指数位和17位尾数位。
(2)oProd:乘法操作的结果,也是27位。

2、提取浮点数的各个字段:
(1)A_s和B_s:分别表示iA和iB的符号位。
(2)A_e和B_e:分别表示iA和iB的指数位。
(3)A_f和B_f:分别表示iA和iB的尾数位,其中最高位隐含为1。

3、确定乘积的符号:
使用异或操作A_s ^ B_s来确定乘积的符号位oProd_s。

4、相乘尾数:

(1)将A_f和B_f相乘,得到36位的中间结果pre_prod_frac。
相加指数:

(2)将A_e和B_e相加,得到9位的中间结果pre_prod_exp。

5、调整指数和尾数:
如果pre_prod_frac的最高位为0,说明乘积需要左移一位,指数减去126(而不是127),否则直接使用减去127的指数。
根据最高位是否为1,选择正确的尾数部分。

6、处理下溢:

如果pre_prod_exp小于9’h80(即小于十进制的128),则认为发生了下溢,此时输出结果为0。

7、处理零条件:

如果B_e或A_e为0,表示其中一个输入数为0,乘积也为0。
如果没有发生下溢,且两个输入数的指数都不为0,将计算得到的符号位、指数和尾数组合成最终的乘积oProd。

代码中有几个需要注意的地方:
尾数相乘的结果pre_prod_frac是36位,这意味着乘法结果可能会超出浮点数尾数的表示范围,需要进行舍入和规范化处理。
指数调整时,如果乘积的尾数需要左移(即pre_prod_frac[35]为0),则指数减去127,否则减去126。这是为了将尾数规范化,使其最高位为1。
下溢条件的检测使用了pre_prod_exp < 9’h80,这个条件可能需要根据具体的实现和标准进行调整。

三、结尾

本篇博客注重描述单精度浮点数在FPGA中乘、加操作。上述两段verilog代码分别实现了浮点数的加法和乘法操作。浮点加法模块FpAdd通过提取输入浮点数的符号位、指数和尾数,对齐尾数,计算和或差,并考虑了下溢情况来生成结果。浮点乘法模块FpMul则通过提取输入浮点数的相应字段,计算尾数的乘积和指数的和,处理可能的下溢,并根据结果的规范化要求调整指数和尾数。两个模块都考虑了符号位的处理,确保了结果的符号正确,并在输出时组合了符号位、指数和尾数来形成最终的浮点数结果。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/Guff_9hys/article/detail/1010865
推荐阅读
相关标签
  

闽ICP备14008679号