使用汇编加速位测试操作

Question

我有一个性能问题 - 我根本无法超越编译器生成代码的发布版本速度。它慢了 25%。我编写的函数在我的测试中被调用了大约 2000 万次，所以让它运行得更快会得到回报。

C++ 中的代码非常简单：

static inline char GetBit(char *data, size_t bit)
{ 
    return 0 != (data[bit / 8] & (1 << (bit % 8))); 
}

这是我为 64 位 MASM 编写的版本：

mov   rax, rdx  
mov   r10, 8h
xor   rdx, rdx  
div   rax, r10  
mov   al, byte ptr [rax+rcx]  
mov   bl, 1h
mov   cl, dl  
shl   bl, cl  
and   al, bl  
shr   al, cl  
ret 

好吧，我不是一个汇编程序专家，但我认为编译器不能仅仅创建更好的汇编程序就可以将代码速度提高 25%。所以诀窍[可能]在函数调用中。它尊重 C++ 代码的 inline 关键字并且不生成任何调用，但我无法使其适用于 asm 代码：​​

extern "C" inline char GetBitAsm(char *data, size_t bit);

我已经使用 dumpbin 反汇编了代码，我可以清楚地看到我的代码 + 函数调用。虽然没有为编译器的版本生成调用：

mov   rdx, qword ptr [bit]  
mov   rcx, qword ptr [data]  
call  GetBitAsm (013F588EFDh)  
mov   byte ptr [isbit], al  

另外还有 2 次读取和 1 次写入内存，而在编译器生成的内容中，可能只有 1 次读取。我在某处读到 div 操作码大约需要 20 个周期，而单个内存访问至少需要 100 个周期。因此，我认为从内存中删除 mov rdx 和 mov rcx ，用父函数中寄存器中的值替换它们就可以了

问题：

1. 这真的是它运行如此缓慢的原因吗？

2. 如何让asm写的函数在release版本中内联？

3. 如何进一步增强我的汇编代码，使其更快？

Answer 1

相对于任何编译器的内联代码，听到的函数调用和汇编代码中的 DIV 指令会降低性能。单独的函数调用开销可能大于编译器代码平均占用的周期数。 DIV 指令可能要大几倍。

现代处理器上的内存访问通常是免费的，因为它们可以从处理器的缓存中得到满足。在您的汇编版本中，您的内存访问平均花费 0 个周期，因为您的代码可能足够慢，以至于处理器可以在需要访问它之前轻松地将内存预取到其缓存中。另一方面，编译器的代码可能足够快，以至于它从内存中读取值的速度可能比处理器获取它的速度要快。它必须定期停止等待获取编译。因此，虽然编译器代码中的平均内存访问周期时间会更高，但这仅仅是因为它得到了更好的优化。

解决问题的最佳方法是让编译器进行优化。坦率地说，它似乎比你知道如何生成更好的代码。即使是汇编专家也很难改进编译器，并且需要在更广泛的范围内查看问题，而不仅仅是这一功能的指令选择。

如果您仍然宁愿使用自己的汇编代码，那么请使用编译器的内联汇编功能，并摆脱 DIV 指令。它的性能仍然不如编译器的版本，但应该会更接近。

Answer 2

我会在这里做一个长镜头，并推测一下你想要做什么，所以请耐心等待：

您的代码有几件事让我印象深刻，（C++ 和程序集）首先是其他人提到的您使用 div 和 mod。这些操作相当慢，您无法与编译器竞争的原因之一是，它很可能会优化这些操作。

您正在使用 2 的幂，计算机是为使用 2 的幂而设计的。这意味着这相当于您的代码：

static inline char GetBit(char *data, size_t bit)
{ 
    return 0 != (data[bit >> 3] & (1 << (bit & 0x07))); 
}

您可以使用它来改进您的程序集，但这不太可能给您带来很大的性能提升。

另一方面，如果您的目标是加快代码速度，我会建议进行以下更改：

1. 在您的大位掩码中，将基本类型更改为您的处理器本机大小，即 uint32_t 用于 32 位机器，uint64_t 用于 64 位机器。

2. 另外，将 getBit() 函数分成两个函数，getWord() 和 getBit()。

   getWord() 应该很长：

   static inline uint32_t getWord(const uint32_t *data, size_t bit) { 
       return data[ bit / sizeof(*data)*8 ]; // Again, the compiler will most 
                                             // likely pick up that this is a 
                                             // division by a power of 2 and 
                                             // optimize accordingly.
                                             // Check to be certain.
   }
   
   static inline uint32_t getBit(const uint32_t *data, size_t bit) { 
        return getWord(data, bit) & (1 << (bit & (sizeof(*data)*8 - 1)); 
        // Or just % like above, check which is faster. 
   }
   

3. 如果您使用此位掩码重写代码，应该会真正加快速度：

   1. 如果您在缓冲区中跳动很多次，您可能只会从上述建议中获得轻微的改善。

   2. 但是，如果您以线性方式迭代数据，我建议您将代码更改为：

       uint32_t mask = 1;
       uint32_t word;
       for ( int bit = 0; bit < 2048; i++) {
           word = getWord(buffer, i); // You could also move this outside a smaller loop, but I'm not sure it's worth it.
           if (word & mask) {
               cout << "Bit " << bit << " is set." << endl;
           }
      
           // Most modern compilers will recognize the following as a ROL 
           // (ROtational Left shift) and replace it with one instruction.
           mask = (mask << 1 | mask >> (sizeof(mask)*8-1)); 
       }
      

   这是一个好主意的原因是处理器经过优化以使用原生大小的整数，您可以避免对齐问题，升级寄存器中的值等。您可能还注意到，通过在外部使用掩码循环避免额外的移位/除法，因为我们只是让遮罩在填充时滚动。

Answer 3

除了已经说过的所有事情之外，您还必须注意“内联”功能：

您可以尝试从（纯 C/C++）函数中删除“内联”并将该函数移动到另一个 C 文件中，以确保编译器不会内联该函数。你会看到这个函数运行起来会慢很多。

原因：当一个函数“内联”时，编译器可能会优化很多。当函数不是“内联”时，编译器必须将函数参数存储在堆栈上（使用“推送”）并执行“调用”指令。这将花费大量时间并使代码比“内联”函数慢得多。

对于小段代码，这些操作所需的时间远远超过使用汇编代码可以节省的时间！