我有一个名为 reorder.cc 的源文件，如下所示:

void reorder(float *output, float *input) {
  output[56] = input[0];
  output[57] = input[1];
  output[58] = input[2];
  output[59] = input[3];
  output[60] = input[4];
  ...
  output[75] = input[19];
  output[76] = input[20];
  output[77] = input[21];
  output[78] = input[22];
  output[79] = input[23];
  output[80] = input[24];
  ...
  output[98] = 0;
  output[99] = 0;
  output[100] = 0;
  output[101] = 0;
  output[102] = 0;
  output[103] = 0;
  output[104] = 0;
  output[105] = input[1];
  output[106] = input[2];
  output[107] = input[3];
  output[108] = input[4];
  output[109] = input[5];
  output[110] = input[6];
  output[111] = 0; 
  ...
}

reorder 函数有一个很长的从输入缓冲区到输出缓冲区的内存移动操作列表。从输入到输出的对应关系很复杂，但通常至少有 10 个 float 的足够长的运行保证是连续的。运行被从任意输入索引开始或值为“0”的新运行中断。

带有 (g++-6 -march=native -Ofast -S reorder.cc) 的关联程序集文件 (.S) 生成以下程序集:

 .file "reorder.cc"
  .text
  .p2align 4,,15
  .globl  _Z9optimizedPfS_
  .type _Z9optimizedPfS_, @function
_Z9optimizedPfS_:
.LFB0:
  .cfi_startproc
  movss (%rsi), %xmm0
  movss %xmm0, 32(%rdi)
  movss 4(%rsi), %xmm0
  movss %xmm0, 36(%rdi)
  movss 8(%rsi), %xmm0
  movss %xmm0, 40(%rdi)
  movss 12(%rsi), %xmm0
  movss %xmm0, 44(%rdi)
  movss 16(%rsi), %xmm0
  movss %xmm0, 48(%rdi)
  movss 20(%rsi), %xmm0
  movss %xmm0, 52(%rdi)
  movss 28(%rsi), %xmm0
  movss %xmm0, 60(%rdi)
  movss 32(%rsi), %xmm0
  movss %xmm0, 64(%rdi)
  movss 36(%rsi), %xmm0
  ...

... 对应于每条 assembly 线的单个移动单个标量 (fp32) 值。我认为编译器足够聪明，可以编译为更智能的指令，如 MOVDQU(移动未对齐的双四字，适用于 128 位字)运行足够长的时间？

我正在考虑手写一个简单的解析器，它需要长时间运行并自动调用 movdqu，但我发现这很乏味、笨拙且容易出错。

是否有一个特殊的编译器标志可以自动检测这些长时间运行并生成高效指令？我是注定要使用内部函数来进一步优化这段代码，还是有一个聪明的技巧可以自动为我做这个簿记？

reorder.cc 是这些输入、输出对的大约 100,000 条指令的顺序，这是我正在处理的较小的测试用例。

此外，关于编译 100K+ 或更多行这些移动指令的大型源文件有什么技巧吗？对于 Macbook Pro i7 处理器，g++-6 -Ofast 在这样的 1M 行文件上需要数小时。

最佳答案

使用例如 movups 或 movdqu 的版本意味着有效地并行执行赋值，如果函数的参数可能存在别名，这可能是不正确的。

如果他们不使用别名，您可以使用非标准的 __restrict__ 关键字。

也就是说，gcc 仍将只向量化循环，因此重写程序如下:

// #define __restrict__ 
void reorder(float * __restrict__ output, float * __restrict__ input) {

  for (auto i = 0; i < 5; i++)
    output[i+56] = input[i];

  for (auto i = 0; i < 6; i++)
    output[i+75] = input[i+19];

  for (auto i = 0; i < 7; i++)
    output[i+98] = 0;

  for (auto i = 0; i < 6; i++)
    output[i+105] = input[i+1];

  output[111] = 0; 
}

使用 -O2 -ftree-vectorize 编译生成:

reorder(float*, float*):
        movups  xmm0, XMMWORD PTR [rsi]
        movups  XMMWORD PTR [rdi+224], xmm0
        movss   xmm0, DWORD PTR [rsi+16]
        movss   DWORD PTR [rdi+240], xmm0
        movups  xmm0, XMMWORD PTR [rsi+76]
        movups  XMMWORD PTR [rdi+300], xmm0
        movss   xmm0, DWORD PTR [rsi+92]
        movss   DWORD PTR [rdi+316], xmm0
        movss   xmm0, DWORD PTR [rsi+96]
        movss   DWORD PTR [rdi+320], xmm0
        pxor    xmm0, xmm0
        movups  xmm1, XMMWORD PTR [rsi+4]
        movups  XMMWORD PTR [rdi+392], xmm0
        pxor    xmm0, xmm0
        movups  XMMWORD PTR [rdi+420], xmm1
        movss   DWORD PTR [rdi+408], xmm0
        movss   DWORD PTR [rdi+412], xmm0
        movss   xmm1, DWORD PTR [rsi+20]
        movss   DWORD PTR [rdi+436], xmm1
        movss   xmm1, DWORD PTR [rsi+24]
        movss   DWORD PTR [rdi+416], xmm0
        movss   DWORD PTR [rdi+440], xmm1
        movss   DWORD PTR [rdi+444], xmm0
        ret

不理想，但仍然有一些 Action 是用一个 insn 完成的。

https://godbolt.org/g/9aSmB1

关于c++ - 优化长时间的内存读写，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39136747/