帮我改进这个 C++ 位缓冲处理代码

Question

我正在编写一个函数来处理传入的 32 位缓冲区，表示在将数据与相应存储的 32 位缓冲区进行比较时发生变化的数据。变化位的位置表示需要处理的数字（即值 8 表示位 3），以及变化是 0->1 还是 1->0。这是当前的实现，请帮助我改进它！请注意，这不是实际代码，它已被简化为与上下文无关。

uint32_t temp = oldBuffer ^ newBuffer;
uint32_t number = 0;
while (temp != 0)
{
    if (temp & 0x1)
    {
        uint32_t bitValue = 0;
        if ((newBuffer& (1 << number)) != 0) bitValue = 1;
        processNumber(number, bitValue);
    }
    number++;
    temp = temp >> 1;
}
oldBuffer = newBuffer;

现在它可以工作，但我不喜欢它必须通过检查位 1 并在整个过程中移动来检查每个位。如果保证只有 1 位设置，那并不难弄清楚，但事实并非如此。

编辑：对于 Neil，我想我希望找到一种方法来在恒定时间内获取 XOR 之后的位位置，而不是一直移动通过​​缓冲区并逐个检查位。

Answer 1

uint32_t temp=oldBuffer^newBuffer, ntemp=newBuffer;
for(int b=0;temp;++b,temp>>=1,ntemp>>=1)
    if(temp&1) processNumber(b,ntemp&1);

Answer 2

您可能会通过使用一种或多种“bit twiddling”技巧获得一些性能

• http://graphics.stanford.edu/~seander/bithacks.html

具体来说，“查找整数对数基数 2”（最高位集的位置）的算法。这将让您确定哪些位比循环遍历每个位更直接。

如果您必须按从低到高的顺序处理位，您可以稍微修改 Kernighan 的方法来计算位：

/* note: untested code */
while (temp) {

    uint32_t bit = temp & (~(temp & (temp - 1)); /* isolate lowest bit */

    temp &= ~bit;

    uint32_t bit_number = /* use find log base 2 hack */;

    /* etc... */

}

这应该使 while 循环的迭代次数恰好等于设置的位数。您的原始循环将迭代次数等于最高设置位的位位置。

但是，如果这会产生任何可衡量的差异，我会感到惊讶，除非这是一段超级关键的代码。

Answer 3

使用标准库怎么样？无需移位或等...来测试位是否为真。对位集中的位的测试保证是恒定的时间。而且它写得更清晰，更容易理解。

const std::bitset<32> oldbits( oldBuffer );
const std::bitset<32> newbits ( newBuffer );

for( size_t index = 0; index != oldbits.size(); ++index ) {
   if( oldbits[ index ] != newbits[ index ] ) {
       processNumber( index, newbits[ index ] )
   }
}

注意：这里也不需要 XOR，因为您可以直接访问这些位。不过，您可以使用它来节省性能。

Answer 4

 uint32_t temp = oldBuffer ^ newBuffer;
 uint32_t number = 0;
 uint32_t bitmask=1;
 while (temp != 0)
 {
     if (temp & 0x1)
     {
         processNumber(number, ((newBuffer & bitmask) != 0));
     }
     number++;
     temp = temp >> 1;
     bitmask <<=1;
 }
 oldBuffer = newBuffer;

2个超级小改动...

你的代码已经很高效了

Answer 5

这取决于您期望 (oldBuffer ^ newBuffer) 的分布。如果它是完全随机的并且是全范围的 32 位，那么你平均有 16 个循环。

一种可能的解决方案是制作这样的表格

int lookup[255][8] = {
  { -1, -1, -1, -1, -1, -1, -1, -1 }, // 0 has no bits set
  {  0, -1, -1, -1, -1, -1, -1, -1 }, // 1 has only the 0th bit set
  {  1, -1, -1, -1, -1, -1, -1, -1 }, // 2 has only the 1st bit set
  {  0,  1, -1, -1, -1, -1, -1, -1 }, // 3 has the 0th, 1st bit set
  {  2, -1, -1, -1, -1, -1, -1, -1 }, // 4 has only the 2nd bit set
  ...
  {  0,  1,  2,  3,  4,  5,  6,  7 }, // 255 has all bits set
}       

这样，您必须循环 4 次（每个字节 1 次），然后每个设置的位循环 1 次（平均 4 次）- 嘿，这是 16。

但是如果设置的位数很低（平均远低于 32 位的一半），那么查表就会失败。

不幸的是，每次使用查表时都会增加一个乘法和加法，所以不一定好。你必须测试它。换句话说，它在常数时间内找到设置的位，但常数可能大于循环。这取决于您期望有多少设置位。

Answer 6

你可以像递归 B-Tree 一样：)

go(oldBuffer ^ newBuffer, 16, 0, newBuffer);
...

void go(temp, half, pos, bitValue)
{
    if (half > 1) {
      uint32_t mask = (1 << half) - 1;
      if (temp & mask)    go(temp & mask, half/2, pos, bitValue & mask);
      temp >>= half;
      if (temp & mask)    go(temp & mask, half/2, pos + half, (bitValue >> half) & mask);
    } else {
      if (temp & 1) processNumber(pos, bitValue&1);
      if (temp & 2) processNumber(pos+1, bitValue/2&1);
    }
}