在c ++中将4个字节转换为float的最快方法

Question

我需要将一个字节数组转换为浮点数组。我通过网络连接获取字节，然后需要将它们解析为浮点数。阵列的大小没有预定义。这是我到目前为止使用工会的代码。您对如何让它运行得更快有什么建议吗？

int offset = DATA_OFFSET - 1;
UStuff bb;
//Convert every 4 bytes to float using a union
for (int i = 0; i < NUM_OF_POINTS;i++){
    //Going backwards - due to endianness
    for (int j = offset + BYTE_FLOAT*i + BYTE_FLOAT ; j > offset + BYTE_FLOAT*i; --j)
    {
        bb.c[(offset + BYTE_FLOAT*i + BYTE_FLOAT)- j] = sample[j];
    }
    res.append(bb.f);
}
return res;

这是我使用的联盟

union UStuff
{
        float   f;
        unsigned char   c[4];
};

Answer 1

Short Answer

#include <cstdint>
#define NOT_STUPID 1
#define ENDIAN NOT_STUPID

namespace _ {
inline uint32_t UI4Set(char byte_0, char byte_1, char byte_2, char byte_3) {
#if ENDIAN == NOT_STUPID
  return byte_0 | ((uint32_t)byte_1) << 8 | ((uint32_t)byte_2) << 16 |
         ((uint32_t)byte_3) << 24;
#else
  return byte_3 | ((uint32_t)byte_2) << 8 | ((uint32_t)byte_1) << 16 |
         ((uint32_t)byte_0) << 24;
#endif
}

inline float FLTSet(char byte_0, char byte_1, char byte_2, char byte_3) {
  uint32_t flt = UI4Set(byte_0, byte_1, byte_2, byte_3);
  return *reinterpret_cast<float*>(&flt);
}

/* Use this function to write directly to RAM and avoid the xmm
   registers. */
inline uint32_t FLTSet(char byte_0, char byte_1, char byte_2, char byte_3,
                   float* destination) {
  uint32_t value = UI4Set (byte_0, byte_1, byte_2, byte_3);
  *reinterpret_cast<uint32_t*>(destination) = value;
  return value;
}

} //< namespace _
using namespace _; //< @see Kabuki Toolkit

static flt = FLTSet (0, 1, 2, 3);

int main () {
  uint32_t flt_init = FLTSet (4, 5, 6, 7, &flt);
  return 0;
}
//< This uses 4 extra bytes doesn't use the xmm register

Long Answer

通常不建议使用Union来转换为浮点数和从浮点数转换为整数，因为到目前为止的联合并不总是生成最佳汇编代码，而其他技术更明确，可能使用更少的输入;而不是我对Unions上其他StackOverflow帖子的看法，我们将证明它将使用现代编译器进行反汇编：Visual-C ++ 2018。

关于如何优化浮点算法我们必须知道的第一件事是寄存器的工作原理。 CPU的核心只是一个整数处理单元，它们上面有协处理器（即扩展），用于处理浮点数。这些加载存储机器（LSM）只能使用整数，它们必须使用一组单独的寄存器与浮点协处理器进行交互。在x86_64上，这些是xmm寄存器，它们是128位宽，可以处理单指令多数据（SIMD）。在C ++中，加载和存储浮点寄存器的方法是：

int Foo(double foo) { return foo + *reinterpret_cast<double*>(&foo); }

int main() {
  double foo = 1.0;
  uint64_t bar = *reinterpret_cast<uint64_t*>(&foo);
  return Foo(bar);
}

现在让我们用Visual-C ++ O2优化来检查反汇编，因为没有它们你会得到一堆调试堆栈帧变量。我不得不将函数Foo添加到示例中以避免代码被优化掉。

  double foo = 1.0;
  uint64_t bar = *reinterpret_cast<uint64_t*>(&foo);
00007FF7482E16A0  mov         rax,3FF0000000000000h  
00007FF7482E16AA  xorps       xmm0,xmm0  
00007FF7482E16AD  cvtsi2sd    xmm0,rax  
  return Foo(bar);
00007FF7482E16B2  addsd       xmm0,xmm0  
00007FF7482E16B6  cvttsd2si   eax,xmm0  
}
00007FF7482E16BA  ret  

如上所述，我们可以看到LSM首先将double值移入整数寄存器，然后使用xor函数将xmm0寄存器清零，因为寄存器为128位宽，我们正在加载64位整数，然后使用cvtsi2sd指令将整数寄存器的内容加载到浮点寄存器，最后是cvttsd2si指令，然后在最终返回之前将值从xmm0寄存器加载回返回寄存器。

现在让我们解决使用此测试脚本和Visual-C ++ 2018生成最佳汇编代码的问题：

#include <stdafx.h>
#include <cstdint>
#include <cstdio>

static float foo = 0.0f;

void SetFooUnion(char byte_0, char byte_1, char byte_2, char byte_3) {
  union {
    float flt;
    char bytes[4];

  } u = {foo};

  u.bytes[0] = byte_0;
  u.bytes[1] = byte_1;
  u.bytes[2] = byte_2;
  u.bytes[3] = byte_3;
  foo = u.flt;
}

void SetFooManually(char byte_0, char byte_1, char byte_2, char byte_3) {
  uint32_t faster_method = byte_0 | ((uint32_t)byte_1) << 8 |
                           ((uint32_t)byte_2) << 16 | ((uint32_t)byte_3) << 24;
  *reinterpret_cast<uint32_t*>(&foo) = faster_method;
}

namespace _ {
inline uint32_t UI4Set(char byte_0, char byte_1, char byte_2, char byte_3) {
  return byte_0 | ((uint32_t)byte_1) << 8 | ((uint32_t)byte_2) << 16 |
         ((uint32_t)byte_3) << 24;
}

inline float FLTSet(char byte_0, char byte_1, char byte_2, char byte_3) {
  uint32_t flt = UI4Set(byte_0, byte_1, byte_2, byte_3);
  return *reinterpret_cast<float*>(&flt);
}

inline void FLTSet(char byte_0, char byte_1, char byte_2, char byte_3,
                   float* destination) {
  uint32_t value = byte_0 | ((uint32_t)byte_1) << 8 | ((uint32_t)byte_2) << 16 |
                   ((uint32_t)byte_3) << 24;
  *reinterpret_cast<uint32_t*>(destination) = value;
}

}  // namespace _

int main() {
  SetFooUnion(0, 1, 2, 3);

  union {
    float flt;
    char bytes[4];

  } u = {foo};

  // Start union read tests

  putchar(u.bytes[0]);
  putchar(u.bytes[1]);
  putchar(u.bytes[2]);
  putchar(u.bytes[3]);

  // Start union write tests

  u.bytes[0] = 4;
  u.bytes[2] = 5;

  foo = u.flt;

  // Start hand-coded tests

  SetFooManually(6, 7, 8, 9);

  uint32_t bar = *reinterpret_cast<uint32_t*>(&foo);
  putchar((char)(bar));
  putchar((char)(bar >> 8));
  putchar((char)(bar >> 16));
  putchar((char)(bar >> 24));

  _::FLTSet (0, 1, 2, 3, &foo);

  return 0;
}

现在，在检查了O2优化的反汇编之后，我们已经证明编译器不能生成最佳代码：

int main() {
00007FF6DB4A1000  sub         rsp,28h  
  SetFooUnion(0, 1, 2, 3);
00007FF6DB4A1004  mov         dword ptr [rsp+30h],3020100h  
00007FF6DB4A100C  movss       xmm0,dword ptr [rsp+30h]  

  union {
    float flt;
    char bytes[4];

  } u = {foo};
00007FF6DB4A1012  movss       dword ptr [rsp+30h],xmm0  

  // Start union read tests

  putchar(u.bytes[0]);
00007FF6DB4A1018  movsx       ecx,byte ptr [u]  
  SetFooUnion(0, 1, 2, 3);
00007FF6DB4A101D  movss       dword ptr [foo (07FF6DB4A3628h)],xmm0  

  // Start union read tests

  putchar(u.bytes[0]);
00007FF6DB4A1025  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  
  putchar(u.bytes[1]);
00007FF6DB4A102B  movsx       ecx,byte ptr [rsp+31h]  
00007FF6DB4A1030  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  
  putchar(u.bytes[2]);
00007FF6DB4A1036  movsx       ecx,byte ptr [rsp+32h]  
00007FF6DB4A103B  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  
  putchar(u.bytes[3]);
00007FF6DB4A1041  movsx       ecx,byte ptr [rsp+33h]  
00007FF6DB4A1046  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  

  uint32_t bar = *reinterpret_cast<uint32_t*>(&foo);
  putchar((char)(bar));
00007FF6DB4A104C  mov         ecx,6  

  // Start union write tests

  u.bytes[0] = 4;
  u.bytes[2] = 5;

  foo = u.flt;

  // Start hand-coded tests

  SetFooManually(6, 7, 8, 9);
00007FF6DB4A1051  mov         dword ptr [foo (07FF6DB4A3628h)],9080706h  

  uint32_t bar = *reinterpret_cast<uint32_t*>(&foo);
  putchar((char)(bar));
00007FF6DB4A105B  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  
  putchar((char)(bar >> 8));
00007FF6DB4A1061  mov         ecx,7  
00007FF6DB4A1066  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  
  putchar((char)(bar >> 16));
00007FF6DB4A106C  mov         ecx,8  
00007FF6DB4A1071  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  
  putchar((char)(bar >> 24));
00007FF6DB4A1077  mov         ecx,9  
00007FF6DB4A107C  call        qword ptr [__imp_putchar (07FF6DB4A2160h)]  

  return 0;
00007FF6DB4A1082  xor         eax,eax  

  _::FLTSet(0, 1, 2, 3, &foo);
00007FF6DB4A1084  mov         dword ptr [foo (07FF6DB4A3628h)],3020100h  
}
00007FF6DB4A108E  add         rsp,28h  
00007FF6DB4A1092  ret  

这是原始主反汇编，因为缺少内联函数：

; Listing generated by Microsoft (R) Optimizing Compiler Version 19.12.25831.0 

include listing.inc

INCLUDELIB OLDNAMES

EXTRN   __imp_putchar:PROC
EXTRN   __security_check_cookie:PROC
?foo@@3MA DD    01H DUP (?)             ; foo
_BSS    ENDS
PUBLIC  main
PUBLIC  ?SetFooManually@@YAXDDDD@Z          ; SetFooManually
PUBLIC  ?SetFooUnion@@YAXDDDD@Z             ; SetFooUnion
EXTRN   _fltused:DWORD
;   COMDAT pdata
pdata   SEGMENT
$pdata$main DD  imagerel $LN8
    DD  imagerel $LN8+137
    DD  imagerel $unwind$main
pdata   ENDS
;   COMDAT xdata
xdata   SEGMENT
$unwind$main DD 010401H
    DD  04204H
xdata   ENDS
; Function compile flags: /Ogtpy
; File c:\workspace\kabuki-toolkit\seams\0_0_experiments\main.cc
;   COMDAT ?SetFooManually@@YAXDDDD@Z
_TEXT   SEGMENT
byte_0$dead$ = 8
byte_1$dead$ = 16
byte_2$dead$ = 24
byte_3$dead$ = 32
?SetFooManually@@YAXDDDD@Z PROC             ; SetFooManually, COMDAT

  00000 c7 05 00 00 00
    00 06 07 08 09   mov     DWORD PTR ?foo@@3MA, 151521030 ; 09080706H

  0000a c3       ret     0
?SetFooManually@@YAXDDDD@Z ENDP             ; SetFooManually
_TEXT   ENDS
; Function compile flags: /Ogtpy
; File c:\workspace\kabuki-toolkit\seams\0_0_experiments\main.cc
;   COMDAT main
_TEXT   SEGMENT
u$1 = 48
u$ = 48
main    PROC                        ; COMDAT

$LN8:
  00000 48 83 ec 28  sub     rsp, 40            ; 00000028H

  00004 c7 44 24 30 00
    01 02 03     mov     DWORD PTR u$1[rsp], 50462976 ; 03020100H

  0000c f3 0f 10 44 24
    30       movss   xmm0, DWORD PTR u$1[rsp]

  00012 f3 0f 11 44 24
    30       movss   DWORD PTR u$[rsp], xmm0

  00018 0f be 4c 24 30   movsx   ecx, BYTE PTR u$[rsp]

  0001d f3 0f 11 05 00
    00 00 00     movss   DWORD PTR ?foo@@3MA, xmm0

  00025 ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  0002b 0f be 4c 24 31   movsx   ecx, BYTE PTR u$[rsp+1]
  00030 ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  00036 0f be 4c 24 32   movsx   ecx, BYTE PTR u$[rsp+2]
  0003b ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  00041 0f be 4c 24 33   movsx   ecx, BYTE PTR u$[rsp+3]
  00046 ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  0004c b9 06 00 00 00   mov     ecx, 6

  00051 c7 05 00 00 00
    00 06 07 08 09   mov     DWORD PTR ?foo@@3MA, 151521030 ; 09080706H

  0005b ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  00061 b9 07 00 00 00   mov     ecx, 7
  00066 ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  0006c b9 08 00 00 00   mov     ecx, 8
  00071 ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  00077 b9 09 00 00 00   mov     ecx, 9
  0007c ff 15 00 00 00
    00       call    QWORD PTR __imp_putchar

  00082 33 c0        xor     eax, eax

  00084 48 83 c4 28  add     rsp, 40            ; 00000028H
  00088 c3       ret     0
main    ENDP
_TEXT   ENDS
END

那么区别是什么呢？

?SetFooUnion@@YAXDDDD@Z PROC                ; SetFooUnion, COMDAT
; File c:\workspace\kabuki-toolkit\seams\0_0_experiments\main.cc
; Line 7
    mov BYTE PTR [rsp+32], r9b
; Line 14
    mov DWORD PTR u$[rsp], 50462976     ; 03020100H
; Line 18
    movss   xmm0, DWORD PTR u$[rsp]
    movss   DWORD PTR ?foo@@3MA, xmm0
; Line 19
    ret 0
?SetFooUnion@@YAXDDDD@Z ENDP                ; SetFooUnion

与：

?SetFooManually@@YAXDDDD@Z PROC             ; SetFooManually, COMDAT
; File c:\workspace\kabuki-toolkit\seams\0_0_experiments\main.cc
; Line 34
    mov DWORD PTR ?foo@@3MA, 151521030      ; 09080706H
; Line 35
    ret 0
?SetFooManually@@YAXDDDD@Z ENDP             ; SetFooManually

首先要注意的是Union对内联内存优化的影响。工会专门设计用于在不同时间段内为不同目的多路复用RAM以减少RAM使用，因此这意味着存储器必须在RAM中保持一致，因此不太可用。 Union代码强制编译器将Union写入RAM，而非Union方法只抛出您的代码并替换为单个mov DWORD PTR ?foo@@3MA, 151521030指令而不使用xmm0寄存器！ O2优化自动内联SetFooUnion和SetFooManually函数，但非Union方法内联了更多的代码，使用较少的RAM读取，来自Union方法代码行之间差异的证据：

movsx       ecx,byte ptr [rsp+31h]

与非联盟方法的版本：

mov         ecx,7  

联盟正在从一个POINTER到RAM加载ecx，而另一个正在使用更快的单周期mov指令。这是一个巨大的表现增加！但是，在使用实时系统和多线程应用程序时，这实际上可能是所需的行为，因为编译器优化可能是不需要的并且可能会弄乱我们的时序，或者您可能希望使用这两种方法的混合。

除了可能不太理想的RAM使用情况之外，我尝试了几个小时让编译器生成次优装配，但我无法解决大部分玩具问题，所以看起来这似乎是Unions的一个相当漂亮的功能而不是避开它们的理由。我最喜欢的C ++比喻是C ++就像一个装满锋利刀具的厨房，你需要为正确的工作选择正确的刀具，只是因为厨房里有很多锋利的刀具并不意味着你全部拿出来一次刀，或者你把刀留下来。只要你保持厨房整洁，那么你就不会削减自己。联盟是一把锋利的刀，可能有助于确保更大的RAM一致性，但它需要更多的打字并减慢程序的速度。

Answer 2

从技术上讲，你不允许在C ++中使用union来打字，尽管你可以在C中使用它。你的代码的行为是未定义的。

抛开这个重要的行为点：即便如此，你假设float在所有机器上以相同的方式表示，而不是。您可能认为float是32位IEEE754 little-endian数据块，但它不一定是那样。

可悲的是，最好的解决方案最终会变慢。浮点数据的大多数序列化是通过进入和退出字符串来执行的，在您的情况下几乎可以解决问题，因为您可以将它们表示为unsigned char数据的数组。所以你唯一的争论就是找出数据的编码。任务完成！