（转）一个浮点数跨平台产生的问题

感谢网友唐磊（微博@唐磊_name）投稿，本文原文在唐磊的博客上（原文地址），原文分析还不够好，并且可能对人有误导，因此，我对原文作了不少修改，并加了Linux下的内容。浮点数是一个很复杂的事情，但愿这篇文章有助于你们了解浮点数与其相关的C/C++的编译选项。（注：我没有Windows 32位以及C#的环境，因此，对于Windows 32位的程序和C#的程序没有验证过）

背景就简单点儿说，最近一个项目C#编写，涉及浮点运算，前因后果省去，直接看以下代码。

1 2 3 4

float  p3x = 80838.0f; float  p2y = -2499.0f; double  v321 = p3x * p2y; Console.WriteLine(v321);

很简单吧，立刻笔算下结果为-202014162，没问题，难道C#没有产生这样的结果？不可能吧，开启Visual Studio，copy代码试试，果真结果是-202014162。就这样完了么？显然没有！你把编译时的选项从AnyCPU改为x64试试~(服务器环境正是64位滴哦！！)结果竟然边成了-202014160，对没错，就是-202014160。有点不相信，再跑两遍，仍然是-202014160。呃，想通了，由于浮点运算的偏差，-202014160这个结果是合理的。

为何合理呢？很正常，由于上面的p3x和p2y是两个float类型，虽然v321是double，但也是两个float类型计算完后再转成double的，float的精度原本也只有7位，因此，对于这个上亿的数，天然没有办法保证精度。

可是为何修改CPU的type会有不一样的效果？嗯，咱们再试试C/C++。

 

1 2 3 4 5 6 7 8 9 10 11 12 13

#include using  namespace  std;   int  main() {      float  p3x = 80838.0f;      float  p2y = -2499.0f;      double  v321 = p3x * p2y;      std::cout.precision(15);      std::cout << v321 << std::endl;        return  0; }

上面这段C++代码在不一样的平台下的结果以下：

• Windows 32/64位下：-202014160
• Linux 64位下（CentOS 6 gcc 4.4.7）-202014160，
• Linux 32位下（Ubuntu 12.04+ gcc 4.6.3）是：-202014162

合理的结果应该是-202014160，正确的运算结果是-202014162，合理性是浮点精度不够形成的（文后解释了合理性）。如果用两个double相乘可得正确且合理的运算结果（注：把上面C++的程序中的p3x和p2y的类型声明成double，就能获得正确的结果，由于double是双精度的，float是单精度，因此double有足够的位数存放更多的数位）。可是咱们有点不明白，为何Linux 32位下，竟然能算出“正确”的数，而不是“合理”的数。

与C++同样，C#在32位和64位（DEBUG下，这个后面会说）下没有获得一致的结果，那咱们来看一下C++/C#的汇编代码（使用gdb的disassemble /m main 命令，另外下面只显示 float * float 而后转成double的那一行代码的汇编）

Linux平台下用G++编译

1 2 3 4 5 6 7

//C++ 32位系统下 Ubuntu 12.04 8        double  v321 = p3x * p2y;     0x0804860f <+27>:  flds   0x18(%esp)     0x08048613 <+31>:  fmuls  0x1c(%esp)     0x08048617 <+35>:  fstpl  0x10(%esp)   .......

1 2 3 4 5 6 7

//C++ 64位系统下 CentOS 6 9            double  v321 = p3x * p2y;     0x000000000040083c <+24>:    movss  -0x20(%rbp),%xmm0     0x0000000000400841 <+29>:    mulss  -0x1c(%rbp),%xmm0     0x0000000000400846 <+34>:    unpcklps %xmm0,%xmm0     0x0000000000400849 <+37>:    cvtps2pd %xmm0,%xmm0     0x000000000040084c <+40>:    movsd  %xmm0,-0x18(%rbp)

Windows平台下用Visual Studio编译

1 2 3 4 5

//C# AnyCPU编译，Windows VS2012 double  v321 = p3x * p2y; 00000049  fld         dword ptr [ebp-40h] 0000004c  fmul        dword ptr [ebp-44h] 0000004f  fstp        qword ptr [ebp-4Ch]

1 2 3 4 5 6

//C# X64位编译 Windows7 VS2012 double  v321 = p3x * p2y;</pre> 009B43B8 movss xmm0,dword ptr [p3x] 009B43BD mulss xmm0,dword ptr [p2y] 009B43C2 cvtss2sd xmm0,xmm0 009B43C6 movsd mmword ptr [v321],xmm0

从上面的汇编代码能够看出，不管是Linux和Windows，C++或C# 32位和64对浮点数的汇编指令并不同。 32位生成代码用的指令是fld/fmul/fstp等，而64位下的使用了movss/mulss/movsd/的指令。看下来，彷佛这个事情和平台有关系。

咱们继续调查，咱们发现，其中fld/fmul/fstp等指令是由FPU(float point unit)浮点运算处理器作的，准确的说，是FPU x87指令，FPU在进行浮点运算时，用了80位的寄存器作相关浮点运算，而后再根据是float/double截取成32位或64位，FPU默认上会尽可能减小因为须要四舍五入带来的精度问题。可参看浮点运算标准IEEE-754 推荐标准实现者提供浮点可扩展精度格式(Extended precision)，Intel x86处理器有FPU(float point unit)浮点运算处理器支持这种扩展。

非FPU的状况是用了SSE中128位寄存器(float实际只用了其中的32位，计算时也是以32位计算的)，这就是致使上述问题产生的最终缘由。详细分析见文末说明。

知道了这一点，咱们能够man g++ 看一下文档，咱们能够找到一个编译选项叫：-mfpmath，在32位下，这个编译选项的默认值是：387，也就是x87 FPU指令，在64位下，这个编译选项的值是sse，也就是使用SSE的指令。因此，就这篇文章中的这个例子而言，若是你在64bits下加上如 -mfpmath=387，你会获得“正确的”结果，而不是“合理的”结果。

而在VS2012中C++，编译选项能够设置(代码生成中)可选，/fp:[precise | fast | strict]，本例中Release 32位下用precise 或者 strict将获得合理的结果(-202014160)，fast将产生正确的结果(-202014162), fast debug/release下结果也不同哦(release下才优化了)。64系统下各个结果能够你们本身去测试下(Debug/Release)，分别看看VS编译后产生的中间代码长什么样。（陈皓注：个人VS2012在debug编译下，不管你怎么设置/fp的参数值，汇编都是同样的，使用SSE指令，而Release就不同了，可是个人release下看代码的汇编很是怪异和源代码对上号，多年不用Windows开发了，对VS的使用仅停留在VC6++/VC2005上）

因此，咱们在从x87 FPU指令向SSE指令作代码移植的时候，咱们可能会遇到向这样的浮点数的精度问题，这个精度问题会屡次科学计算中会更糟糕。这个问题并不简单的只是在32位和64位中的系统出算，这个问题主要仍是看语言编译器的实现。在更为高级的语言中，如：C99或Fortran 2003中，引入了“long double”来作可扩展双精度（Extension Double），这样就能够消除更多的精度问题。

下面咱们把程序改为long double，（注：其中的类型变成long double）

1 2 3 4 5 6 7 8 9 10 11 12 13

#include using  namespace  std;   int  main() {      long  double  p3x = 80838.0;      long  double  p2y = -2499.0;      long  double  v321 = p3x * p2y;      std::cout.precision(15);      std::cout << v321 << std::endl;        return  0; }

用gdb的disassemble /m main你会看到其中的运算的汇编以下（使用了fmlp指令）：

1 2 3 4 5 6

//linux 32位系统 8        long  double  v321 = p3x * p2y;     0x08048633 <+63>:  fldt   0x10(%esp)     0x08048637 <+67>:  fldt   0x20(%esp)     0x0804863b <+71>:  fmulp  %st,%st(1)     0x0804863d <+73>:  fstpt  0x30(%esp)

1 2 3 4 5 6

//linux 64位系统 8            long  double  v321 = p3x * p2y;     0x0000000000400818 <+52>:    fldt   -0x30(%rbp)     0x000000000040081b <+55>:    fldt   -0x20(%rbp)     0x000000000040081e <+58>:    fmulp  %st,%st(1)     0x0000000000400820 <+60>:    fstpt  -0x10(%rbp)

咱们能够看到，32位系统和64位系统使用了一样的汇编指令（固然，我没有那么多物理机，我只是在VMWare Play的虚拟机上测试的，因此上面的示例并不必定适用于全部的地方，另外，C/C++语言和编译器和平台有很是大的关系） ，缘由天然是咱们用到了long double这个扩展双精度的数据类型。（注：若是你用double或float，在Linux上，32位用x87 FPU 指令编译，而64位用SSE指令编译）

好了，咱们再回到C#上来，C#的浮点是支持该标准的，其中其官方文档也提到了浮点运算可能会产生比返回类型更高精度的值（正如上面的返回值精度就超过了float的精度），并说明若是硬件支持可扩展浮点精度的话，那么全部的浮点运算都将用此精度进行以提升效率，举个例子x*y/z, x*y的值可能都在double的能力范围以外了，但真实状况可能除以z后又能把结果拉回到double范围内，这样的话，用了FPU的结果就会获得一个准确的double值，而非FPU的就是无穷大之类的了。

因此，对于C#来讲，你显然没法找到一个像C/C++同样的利用编译器选项的来解决这个问题的“解决方案”（其实，用编译器参数是一个伪解决方案）。

并且，要解决这个问题也不是要修改编译器选项，由于这个问题明显不是FPU或是SSE的问题，FPU是个过期的技术，SSE才是合理的技术，因此，若是你不想你的浮点数在计算上有什么问题，并且你须要精度准确，正确的解决方案不是搞编译参数，而是——你必定要使用精度更高字节数更多的数据类型，好比：double 或是long double。

另外，你们在写代码的时候得保证明际运行环境/测试环境/开发环境的一致性(包括OS架构啊、编译选项等)啊（尤为是C/C++ 并且，编译器上的参数可能会有不少坑，并且有些坑可能会掩盖你程序中的问题），否则莫名其妙的问题会产生（本文就是开发环境与运行环境不一致致使的问题，纠结了很久才发现是这个缘由）；遇到涉及浮点运算的时候别忘了有多是这个缘由产生的；float/double混用的状况得特别注意。

Reference：

[1] C# Language Specification Floating point types
[2] Are floating-point numbers consistent in C#? Can they be? 
[3] The FPU Instruction Set

附录

80838.0f * -2499.0f = -202014160.0浮点运算过程的说明

32位浮点数在计算机中的表示方式为：1位符号位(s)-8位指数位(E)-23位有效数字(M)。
32位Float = (-1)^s * (1+m) * 2^(e-127), 其中e是实际转换成1.xxxxx*2^e的指数,m是前面的xxxxx(节约1位)

80838.0f = 1 0011 1011 1100 0110.0= 1.00111011110001100*2^16
有效位M = 0011 1011 1100 0110 0000 000
指数位E = 16 + 127 = 143 =  10001111
内部表示 80838.0 =  0 [1000 1111] [0011 1011 1100 0110 0000 000]
= 0100 0111 1001 1101 1110 0011 0000 0000
= 47 9d e3 00 //实际调试时看到的内存值 多是00 e3 9d 47是由于调试环境用了小端表示法法：低位字节排内存低地址端，高位排内存高地址

-2499.0 = -100111000011.0 = -1.001110000110 * 2^11
有效位M = 0011 1000 0110 0000 0000 000
指数位E = 11+127=138= 10001010
符号位s = 1
内部表示-2499.0 = 1 [10001010] [0011 1000 0110 0000 0000 000]
=1100 0101 0001 1100 0011 0000 0000 0000
=c5 1c 30 00

80838.0 * -2499.0 = ?

首先是指数 e = 11+16 = 27
指数位E = e + 127 = 154 = 10011010
有效位相乘结果为 1.1000 0001 0100 1111 1011 1010 01 //能够本身动手实际算下
实际中只能有23位，后面的被截断即1000 0001 0100 1111 1011 1010 01 
相乘结果内部表示=1[10011010][1000 0001 0100 1111 1011 101]
= 1100 1101 0100 0000 1010 0111 1101 1101
= cd 40 a7 dd

结果 =  -1.1000 0001 0100 1111 1011 101 *2^27
=  -11000 0001 0100 1111 1011 1010000
=  -202014160
再转成double后仍是-202014160.

若是是FPU的话，上面的有效位结果不会被截断，即
FPU结果 = -1.1000 0001 0100 1111 1011 101001 *2^27
= -11000 0001 0100 1111 1011 1010010
= -202014162

全文完，若本文有纰漏之处欢迎指正。

 

本文转自 酷 壳 – CoolShell.cn