Question

我有一段代码在执行某些任务后以每秒约120万次运行的速度运行，最大的代码是使用来自两个uint32_t数据的位移数据设置uint8_t数组。摘录代码如下：

next_state

这是实现这一目标的最佳方式吗？我也有一个uint64_t版本：

    static inline uint32_t RotateRight(uint32_t val, int n)
{
    return (val >> n) + (val << (32 - n));

}

static inline uint32_t CSUInt32BE(const uint8_t *b)
{
    return ((uint32_t)b[0] << 24) | ((uint32_t)b[1] << 16) | ((uint32_t)b[2] << 8) | (uint32_t)b[3];
}

static uint32_t ReverseBits(uint32_t val) // Usually just static, tried inline/static inline
{
    //  uint32_t res = 0;
    //  for (int i = 0; i<32; i++)
    //  {
    //      res <<= 1;
    //      res |= val & 1;
    //      val >>= 1;
    //  }
    // Original code above, benched ~220k l/s

    //val = ((val & 0x55555555) << 1) | ((val >> 1) & 0x55555555);
    //val = ((val & 0x33333333) << 2) | ((val >> 2) & 0x33333333);
    //val = ((val & 0x0F0F0F0F) << 4) | ((val >> 4) & 0x0F0F0F0F);
    //val = ((val & 0x00FF00FF) << 8) | ((val >> 8) & 0x00FF00FF);
    //val = (val << 16) | (val >> 16);
    // Option 0, benched ~770k on MBP

    uint32_t c = 0;
    c = (BitReverseTable256[val & 0xff] << 24) |
        (BitReverseTable256[(val >> 8) & 0xff] << 16) |
        (BitReverseTable256[(val >> 16) & 0xff] << 8) |
        (BitReverseTable256[val >> 24]); // was (val >> 24) & 0xff
                                         // Option 1, benched ~970k l/s on MBP, Current, minor tweak to 24

                                         //unsigned char * p = (unsigned char *)&val;
                                         //unsigned char * q = (unsigned char *)&c;
                                         //q[3] = BitReverseTable256[p[0]];
                                         //q[2] = BitReverseTable256[p[1]];
                                         //q[1] = BitReverseTable256[p[2]];
                                         //q[0] = BitReverseTable256[p[3]];
                                         // Option 2 at ~970k l/s on MBP from http://stackoverflow.com/questions/746171/best-algorithm-for-bit-reversal-from-msb-lsb-to-lsb-msb-in-c


    return c; // Current
              //    return val; // option 0
              //    return res; // original


              //uint32_t m;
              //val = (val >> 16) | (val << 16);                            // swap halfwords
              //m = 0x00ff00ff; val = ((val >> 8) & m) | ((val << 8) & ~m); // swap bytes
              //m = m^(m << 4); val = ((val >> 4) & m) | ((val << 4) & ~m); // swap nibbles
              //m = m^(m << 2); val = ((val >> 2) & m) | ((val << 2) & ~m);
              //m = m^(m << 1); val = ((val >> 1) & m) | ((val << 1) & ~m);
              //return val;
              // Benches at 850k l/s on MBP

              //uint32_t t;
              //val = (val << 15) | (val >> 17);
              //t = (val ^ (val >> 10)) & 0x003f801f;
              //val = (t + (t << 10)) ^ val;
              //t = (val ^ (val >>  4)) & 0x0e038421;
              //val = (t + (t <<  4)) ^ val;
              //t = (val ^ (val >>  2)) & 0x22488842;
              //val = (t + (t <<  2)) ^ val;
              //return val;
              // Benches at 820k l/s on MBP
}
static void StuffItDESCrypt(uint8_t data[8], StuffItDESKeySchedule *ks, BOOL enc)
{
uint32_t left = ReverseBits(CSUInt32BE(&data[0]));
uint32_t right = ReverseBits(CSUInt32BE(&data[4]));

right = RotateRight(right, 29);
left = RotateRight(left, 29);

//Encryption function runs here

left = RotateRight(left, 3);
right = RotateRight(right, 3);

uint32_t left1 = ReverseBits(left);
uint32_t right1 = ReverseBits(right);

data[0] = right1 >> 24;
data[1] = (right1 >> 16) & 0xff;
data[2] = (right1 >> 8) & 0xff;
data[3] = right1 & 0xff;
data[4] = left1 >> 24;
data[5] = (left1 >> 16) & 0xff;
data[6] = (left1 >> 8) & 0xff;
data[7] = left1 & 0xff;

我测试了如果我完全跳过这个赋值会发生什么（ReverseBits函数仍然完成），并且代码以每秒约650万次运行的速度运行。此外，如果我只做一个，即使没有触及其他7个任务也能达到120万，这种速度就会发生。

我不愿意认为这项操作由于这项工作而大幅降低了80％的速度，并且不能更快。

这是在Windows Visual Studio 2015上（尽管我尽量将源代码保持为可移植到macOS和Linux）。

编辑：完整的基本代码位于Github。我不是代码的原始作者，但是我已经将它分叉并使用经过修改的速度版本维护密码恢复解决方案。您可以通过各种解决方案和平台速度在ReverseBits中看到我的加速成功。

这些文件已有20多年的历史，并且已经成功恢复了文件，尽管这些文件速度很快。请参阅blog post。

Answer 1

你肯定做的工作超出了你的需要。注意函数ReverseBits()如何努力将反转字的字节按正确的顺序排列，以及接下来发生的事情 - 你将减速所归属的部分 - 如何重新排序字节。

您可以编写并使用ReverseBits()的修改版本，将反转表示的字节直接放入数组中的正确位置，而不是将它们打包成整数，只是为了再次解压缩它们。这应该至少要快一点，因为你会严格删除操作。

Answer 2

我的直接想法是“查看”int32_t，好像它们是int8_t类似

的数组

uint8_t data2[8];
*((uint32_t*)&data2[0]) = right1;
*((uint32_t*)&data2[4]) = left1;

但是，您将right1的最高有效位存储在data[0]中，而此方法允许最低有效位转到data[0]。无论如何，因为我不知道ReverseBits做了什么以及你是否也可以根据不同的顺序调整你的代码，这可能会有所帮助......

优化Bitshift成阵列

2 个答案: