计算快速对数基数 2 上限

Question

什么是计算(long int) ceiling(log_2(i)) 的快速方法，其中输入和输出是 64 位整数？有符号或无符号整数的解决方案是可以接受的。我怀疑最好的方法是一种类似于here 的方法，但与其尝试我自己的方法，我更愿意使用已经过良好测试的方法。通用解决方案适用于所有正值。

例如，2,3,4,5,6,7,8 的值为 1,2,2,3,3,3,3

编辑：到目前为止，最好的方法似乎是使用任意数量的快速现有 bithacks 或寄存器方法来计算整数/地板对数基数 2（MSB 的位置），然后如果输入不是，则添加一个两个的幂。对 2 的幂的快速按位检查是 (n&(n-1))。

编辑 2：关于整数对数和前导零方法的一个很好的来源是 Henry S. Warren 在Hacker's Delight 中的第 5-3 和 11-4 节。这是我发现的最完整的治疗方法。

编辑 3：这种技术看起来很有前途：https://stackoverflow.com/a/51351885/365478

Answer 1

这个算法已经发布了，但是下面的实现非常紧凑，应该优化成无分支代码。

int ceil_log2(unsigned long long x)
{
  static const unsigned long long t[6] = {
    0xFFFFFFFF00000000ull,
    0x00000000FFFF0000ull,
    0x000000000000FF00ull,
    0x00000000000000F0ull,
    0x000000000000000Cull,
    0x0000000000000002ull
  };

  int y = (((x & (x - 1)) == 0) ? 0 : 1);
  int j = 32;
  int i;

  for (i = 0; i < 6; i++) {
    int k = (((x & t[i]) == 0) ? 0 : j);
    y += k;
    x >>= k;
    j >>= 1;
  }

  return y;
}


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  printf("%d\n", ceil_log2(atol(argv[1])));

  return 0;
}

Answer 2

如果您可以限制自己使用 gcc，则有一组内置函数可以返回前导零位的数量，并且可以通过一些工作来做您想做的事情：

int __builtin_clz (unsigned int x)
int __builtin_clzl (unsigned long)
int __builtin_clzll (unsigned long long)

Answer 3

如果您在 Windows 上为 64 位处理器进行编译，我认为这应该可以。 _BitScanReverse64 是一个内在函数。

#include <intrin.h>
__int64 log2ceil( __int64 x )
{
  unsigned long index;
  if ( !_BitScanReverse64( &index, x ) )
     return -1LL; //dummy return value for x==0

  // add 1 if x is NOT a power of 2 (to do the ceil)
  return index + (x&(x-1)?1:0);
}

对于 32 位，您可以模拟 _BitScanReverse64，对 _BitScanReverse 进行 1 或 2 次调用。 检查 x 的高 32 位 ((long*)&x)[1]，如果需要，检查低 32 位 ((long*)&x)[0]。

Answer 4

我所知道的最快的方法是使用快速向下舍入的log2，结合无条件调整前后输入值来处理向上舍入的情况，如下所示的lg_down()。

/* base-2 logarithm, rounding down */
static inline uint64_t lg_down(uint64_t x) {
  return 63U - __builtin_clzl(x);
}

/* base-2 logarithm, rounding up */
static inline uint64_t lg_up(uint64_t x) {
  return lg_down(x - 1) + 1;
}

基本上将 1 添加到舍入结果对于除 2 的精确幂之外的所有值都是正确的（因为在这种情况下，floor 和 ceil 方法应该返回相同的答案），因此减去就足够了1 从输入值处理该情况（它不会更改其他情况的答案）并将结果加一。

这通常比通过明确检查 2 的确切幂来调整值的方法稍微快一些（例如，添加 !!(x & (x - 1)) 术语）。它避免了任何比较和条件操作或分支，内联时更有可能简单，更适合向量化等。

这依赖于大多数 CPU 使用内置 clang/icc/gcc __builtin_clzl 提供的“计数前导位”功能，但其他平台也提供类似的功能（例如，Visual Studio 中的 BitScanReverse 内在函数）。

不幸的是，很多人都返回了log(1) 的错误答案，因为这会导致__builtin_clzl(0) 这是基于 gcc 文档的未定义行为。当然，一般的“计数前导零”函数在零处具有完美定义的行为，但 gcc 内置函数是以这种方式定义的，因为在 x86 上的 BMI ISA 扩展之前，它会使用本身未定义的 bsr instruction行为。

如果您知道自己有 lzcnt 指令，则可以通过直接使用 lzcnt 内在函数来解决此问题。除 x86 之外的大多数平台一开始就从未遇到过 bsr 错误，并且可能还提供了访问其“计数前导零”指令的方法（如果有的话）。

Answer 5

#include "stdafx.h"
#include "assert.h"

int getpos(unsigned __int64 value)
{
    if (!value)
    {
      return -1; // no bits set
    }
    int pos = 0;
    if (value & (value - 1ULL))
    {
      pos = 1;
    }
    if (value & 0xFFFFFFFF00000000ULL)
    {
      pos += 32;
      value = value >> 32;
    }
    if (value & 0x00000000FFFF0000ULL)
    {
      pos += 16;
      value = value >> 16;
    }
    if (value & 0x000000000000FF00ULL)
    {
      pos += 8;
      value = value >> 8;
    }
    if (value & 0x00000000000000F0ULL)
    {
      pos += 4;
      value = value >> 4;
    }
    if (value & 0x000000000000000CULL)
    {
      pos += 2;
      value = value >> 2;
    }
    if (value & 0x0000000000000002ULL)
    {
      pos += 1;
      value = value >> 1;
    }
    return pos;
}

int _tmain(int argc, _TCHAR* argv[])
{    
    assert(getpos(0ULL) == -1); // None bits set, return -1.
    assert(getpos(1ULL) == 0);
    assert(getpos(2ULL) == 1);
    assert(getpos(3ULL) == 2);
    assert(getpos(4ULL) == 2);
    for (int k = 0; k < 64; ++k)
    {
        int pos = getpos(1ULL << k);
        assert(pos == k);
    }
    for (int k = 0; k < 64; ++k)
    {
        int pos = getpos( (1ULL << k) - 1);
        assert(pos == (k < 2 ? k - 1 : k) );
    }
    for (int k = 0; k < 64; ++k)
    {
        int pos = getpos( (1ULL << k) | 1);
        assert(pos == (k < 1 ? k : k + 1) );
    }
    for (int k = 0; k < 64; ++k)
    {
        int pos = getpos( (1ULL << k) + 1);
        assert(pos == k + 1);
    }
    return 0;
}

Answer 6

使用@egosys 提到的 gcc 内置函数，您可以构建一些有用的宏。 对于快速粗略的 floor(log2(x)) 计算，您可以使用：

#define FAST_LOG2(x) (sizeof(unsigned long)*8 - 1 - __builtin_clzl((unsigned long)(x)))

对于类似的 ceil(log2(x))，使用：

#define FAST_LOG2_UP(x) (((x) - (1 << FAST_LOG2(x))) ? FAST_LOG2(x) + 1 : FAST_LOG2(x))

后者可以使用更多 gcc 特性进一步优化以避免对内置函数的双重调用，但我不确定你是否需要它。

Answer 7

以下代码 sn-p 是一种安全且可移植的方式，用于扩展纯 C 方法（例如 @dgobbi 的方法），以便在使用支持编译器 (Clang) 进行编译时使用编译器内在函数。将它放在方法的顶部将导致该方法在可用时使用内置函数。当内置函数不可用时，该方法将回退到标准 C 代码。

#ifndef __has_builtin
#define __has_builtin(x) 0
#endif

#if __has_builtin(__builtin_clzll) //use compiler if possible
  return ((sizeof(unsigned long long) * 8 - 1) - __builtin_clzll(x)) + (!!(x & (x - 1)));
#endif

Answer 8

真正最快的解决方案：

包含 63 个条目的二叉搜索树。这些是从 0 到 63 的 2 的幂。创建树的一次性生成函数。叶子代表幂的以 2 为底的对数（基本上是数字 1-63）。

要找到答案，您将一个数字输入树中，然后导航到大于该项目的叶节点。如果叶节点完全相等，则结果是叶值。否则，结果为叶子值 + 1。

复杂度固定为 O(6)。

Answer 9

查找具有整数输出的整数（64 位或任何其他位）的以 2 为底的对数等效于查找已设置的最高有效位。为什么？因为 log base 2 是你可以将数字除以 2 达到 1 的次数。

找到设置的 MSB 的一种方法是每次简单地向右位移 1 直到得到 0。另一种更有效的方法是通过位掩码进行某种二进制搜索。

通过检查是否设置了除 MSB 之外的任何其他位，可以轻松计算出 ceil 部分。

Answer 10

下面的代码更简单，只要输入 x >= 1 就可以工作。输入 clog2(0) 将得到未定义的答案（这是有道理的，因为 log(0) 是无穷大...）您可以添加错误如果需要，检查 (x == 0)：

unsigned int clog2 (unsigned int x)
{
    unsigned int result = 0;
    --x;
    while (x > 0) {
        ++result;
        x >>= 1;
    }

    return result;
}

顺便说一句，log2的楼层代码类似：（再次假设x >= 1）

unsigned int flog2 (unsigned int x)
{
    unsigned int result = 0;
    while (x > 1) {
        ++result;
        x >>= 1;
    }

    return result;
}

Answer 11

在撰写本文时，我将为您提供 x86-64 的最快方法，如果您有一个 适用于参数 的快速地板，如果您喜欢的话，我会给您一个通用技术完整的范围，然后见下文。

我对其他答案的低质量感到惊讶，因为它们告诉您如何获得地板，但以非常昂贵的方式（使用条件和一切！）将地板转换为天花板。

如果你可以快速得到对数的底，例如使用__builtin_clzll，那么底很容易得到，如下所示：

unsigned long long log2Floor(unsigned long long x) {
    return 63 - __builtin_clzll(x);
}

unsigned long long log2Ceiling(unsigned long long x) {
    return log2Floor(2*x - 1);
}

之所以有效，是因为它会将结果加 1，除非 x 正好是 2 的幂。

查看 x86-64 汇编器差异 at the compiler explorer 以了解像这样的天花板的另一种实现：

auto log2CeilingDumb(unsigned long x) {
    return log2Floor(x) + (!!(x & (x - 1)));
}

给予：

log2Floor(unsigned long): # @log2Floor(unsigned long)
  bsr rax, rdi
  ret
log2CeilingDumb(unsigned long): # @log2CeilingDumb(unsigned long)
  bsr rax, rdi
  lea rcx, [rdi - 1]
  and rcx, rdi
  cmp rcx, 1
  sbb eax, -1
  ret
log2Ceiling(unsigned long): # @log2Ceiling(unsigned long)
  lea rax, [rdi + rdi]
  add rax, -1
  bsr rax, rax
  ret

对于完整的范围，它在之前的答案中：return log2Floor(x - 1) + 1，这要慢得多，因为它在 x86-64 中使用了四个指令，而不是上面的三个。

Answer 12

我已经对 64 位“最高位”的几个实现进行了基准测试。最“无分支”的代码实际上并不是最快的。

这是我的highest-bit.c源文件：

int highest_bit_unrolled(unsigned long long n)
{
  if (n & 0xFFFFFFFF00000000) {
    if (n & 0xFFFF000000000000) {
      if (n & 0xFF00000000000000) {
        if (n & 0xF000000000000000) {
          if (n & 0xC000000000000000)
            return (n & 0x8000000000000000) ? 64 : 63;
          else
            return (n & 0x2000000000000000) ? 62 : 61;
        } else {
          if (n & 0x0C00000000000000)
            return (n & 0x0800000000000000) ? 60 : 59;
          else
            return (n & 0x0200000000000000) ? 58 : 57;
        }
      } else {
        if (n & 0x00F0000000000000) {
          if (n & 0x00C0000000000000)
            return (n & 0x0080000000000000) ? 56 : 55;
          else
            return (n & 0x0020000000000000) ? 54 : 53;
        } else {
          if (n & 0x000C000000000000)
            return (n & 0x0008000000000000) ? 52 : 51;
          else
            return (n & 0x0002000000000000) ? 50 : 49;
        }
      }
    } else {
      if (n & 0x0000FF0000000000) {
        if (n & 0x0000F00000000000) {
          if (n & 0x0000C00000000000)
            return (n & 0x0000800000000000) ? 48 : 47;
          else
            return (n & 0x0000200000000000) ? 46 : 45;
        } else {
          if (n & 0x00000C0000000000)
            return (n & 0x0000080000000000) ? 44 : 43;
          else
            return (n & 0x0000020000000000) ? 42 : 41;
        }
      } else {
        if (n & 0x000000F000000000) {
          if (n & 0x000000C000000000)
            return (n & 0x0000008000000000) ? 40 : 39;
          else
            return (n & 0x0000002000000000) ? 38 : 37;
        } else {
          if (n & 0x0000000C00000000)
            return (n & 0x0000000800000000) ? 36 : 35;
          else
            return (n & 0x0000000200000000) ? 34 : 33;
        }
      }
    }
  } else {
    if (n & 0x00000000FFFF0000) {
      if (n & 0x00000000FF000000) {
        if (n & 0x00000000F0000000) {
          if (n & 0x00000000C0000000)
            return (n & 0x0000000080000000) ? 32 : 31;
          else
            return (n & 0x0000000020000000) ? 30 : 29;
        } else {
          if (n & 0x000000000C000000)
            return (n & 0x0000000008000000) ? 28 : 27;
          else
            return (n & 0x0000000002000000) ? 26 : 25;
        }
      } else {
        if (n & 0x0000000000F00000) {
          if (n & 0x0000000000C00000)
            return (n & 0x0000000000800000) ? 24 : 23;
          else
            return (n & 0x0000000000200000) ? 22 : 21;
        } else {
          if (n & 0x00000000000C0000)
            return (n & 0x0000000000080000) ? 20 : 19;
          else
            return (n & 0x0000000000020000) ? 18 : 17;
        }
      }
    } else {
      if (n & 0x000000000000FF00) {
        if (n & 0x000000000000F000) {
          if (n & 0x000000000000C000)
            return (n & 0x0000000000008000) ? 16 : 15;
          else
            return (n & 0x0000000000002000) ? 14 : 13;
        } else {
          if (n & 0x0000000000000C00)
            return (n & 0x0000000000000800) ? 12 : 11;
          else
            return (n & 0x0000000000000200) ? 10 : 9;
        }
      } else {
        if (n & 0x00000000000000F0) {
          if (n & 0x00000000000000C0)
            return (n & 0x0000000000000080) ? 8 : 7;
          else
            return (n & 0x0000000000000020) ? 6 : 5;
        } else {
          if (n & 0x000000000000000C)
            return (n & 0x0000000000000008) ? 4 : 3;
          else
            return (n & 0x0000000000000002) ? 2 : (n ? 1 : 0);
        }
      }
    }
  }
}

int highest_bit_bs(unsigned long long n)
{
  const unsigned long long mask[] = {
    0x000000007FFFFFFF,
    0x000000000000FFFF,
    0x00000000000000FF,
    0x000000000000000F,
    0x0000000000000003,
    0x0000000000000001
  };
  int hi = 64;
  int lo = 0;
  int i = 0;

  if (n == 0)
    return 0;

  for (i = 0; i < sizeof mask / sizeof mask[0]; i++) {
    int mi = lo + (hi - lo) / 2;

    if ((n >> mi) != 0)
      lo = mi;
    else if ((n & (mask[i] << lo)) != 0)
      hi = mi;
  }

  return lo + 1;
}

int highest_bit_shift(unsigned long long n)
{
  int i = 0;
  for (; n; n >>= 1, i++)
    ; /* empty */
  return i;
}

static int count_ones(unsigned long long d)
{
  d = ((d & 0xAAAAAAAAAAAAAAAA) >>  1) + (d & 0x5555555555555555);
  d = ((d & 0xCCCCCCCCCCCCCCCC) >>  2) + (d & 0x3333333333333333);
  d = ((d & 0xF0F0F0F0F0F0F0F0) >>  4) + (d & 0x0F0F0F0F0F0F0F0F);
  d = ((d & 0xFF00FF00FF00FF00) >>  8) + (d & 0x00FF00FF00FF00FF);
  d = ((d & 0xFFFF0000FFFF0000) >> 16) + (d & 0x0000FFFF0000FFFF);
  d = ((d & 0xFFFFFFFF00000000) >> 32) + (d & 0x00000000FFFFFFFF);
  return d;
}

int highest_bit_parallel(unsigned long long n)
{
  n |= n >> 1;
  n |= n >> 2;
  n |= n >> 4;
  n |= n >> 8;
  n |= n >> 16;
  n |= n >> 32;
  return count_ones(n);
}

int highest_bit_so(unsigned long long x)
{
  static const unsigned long long t[6] = {
    0xFFFFFFFF00000000ull,
    0x00000000FFFF0000ull,
    0x000000000000FF00ull,
    0x00000000000000F0ull,
    0x000000000000000Cull,
    0x0000000000000002ull
  };

  int y = (((x & (x - 1)) == 0) ? 0 : 1);
  int j = 32;
  int i;

  for (i = 0; i < 6; i++) {
    int k = (((x & t[i]) == 0) ? 0 : j);
    y += k;
    x >>= k;
    j >>= 1;
  }

  return y;
}

int highest_bit_so2(unsigned long long value)
{
  int pos = 0;
  if (value & (value - 1ULL))
  {
    pos = 1;
  }
  if (value & 0xFFFFFFFF00000000ULL)
  {
    pos += 32;
    value = value >> 32;
  }
  if (value & 0x00000000FFFF0000ULL)
  {
    pos += 16;
    value = value >> 16;
  }
  if (value & 0x000000000000FF00ULL)
  {
    pos += 8;
    value = value >> 8;
  }
  if (value & 0x00000000000000F0ULL)
  {
    pos += 4;
    value = value >> 4;
  }
  if (value & 0x000000000000000CULL)
  {
    pos += 2;
    value = value >> 2;
  }
  if (value & 0x0000000000000002ULL)
  {
    pos += 1;
    value = value >> 1;
  }
  return pos;
}

这是highest-bit.h：

int highest_bit_unrolled(unsigned long long n);
int highest_bit_bs(unsigned long long n);
int highest_bit_shift(unsigned long long n);
int highest_bit_parallel(unsigned long long n);
int highest_bit_so(unsigned long long n);
int highest_bit_so2(unsigned long long n);

还有主程序（抱歉所有的复制粘贴）：

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "highest-bit.h"

double timedelta(clock_t start, clock_t end)
{
  return (end - start)*1.0/CLOCKS_PER_SEC;
}

int main(int argc, char **argv)
{
  int i;
  volatile unsigned long long v;
  clock_t start, end;

  start = clock();

  for (i = 0; i < 10000000; i++) {
    for (v = 0x8000000000000000; v; v >>= 1)
      highest_bit_unrolled(v);
  }

  end = clock();

  printf("highest_bit_unrolled = %6.3fs\n", timedelta(start, end));

  start = clock();

  for (i = 0; i < 10000000; i++) {
    for (v = 0x8000000000000000; v; v >>= 1)
      highest_bit_parallel(v);
  }

  end = clock();

  printf("highest_bit_parallel = %6.3fs\n", timedelta(start, end));

  start = clock();

  for (i = 0; i < 10000000; i++) {
    for (v = 0x8000000000000000; v; v >>= 1)
      highest_bit_bs(v);
  }

  end = clock();

  printf("highest_bit_bs = %6.3fs\n", timedelta(start, end));

  start = clock();

  for (i = 0; i < 10000000; i++) {
    for (v = 0x8000000000000000; v; v >>= 1)
      highest_bit_shift(v);
  }

  end = clock();

  printf("highest_bit_shift = %6.3fs\n", timedelta(start, end));

  start = clock();

  for (i = 0; i < 10000000; i++) {
    for (v = 0x8000000000000000; v; v >>= 1)
      highest_bit_so(v);
  }

  end = clock();

  printf("highest_bit_so = %6.3fs\n", timedelta(start, end));

  start = clock();

  for (i = 0; i < 10000000; i++) {
    for (v = 0x8000000000000000; v; v >>= 1)
      highest_bit_so2(v);
  }

  end = clock();

  printf("highest_bit_so2 = %6.3fs\n", timedelta(start, end));

  return 0;
}

我已经尝试过各种新旧 Intel x86 机器。

highest_bit_unrolled（展开的二进制搜索）始终比highest_bit_parallel（无分支位操作）快得多。这比highest_bit_bs（二分搜索循环）快，反过来又比highest_bit_shift（简单的移位和计数循环）快。

highest_bit_unrolled 也比接受的 SO 答案 (highest_bit_so) 和另一个答案 (highest_bit_so2) 中给出的更快。

基准测试循环通过覆盖连续位的一位掩码。这是为了尝试在展开的二分搜索中击败分支预测，这是现实的：在现实世界的程序中，输入案例不太可能表现出位位置的局部性。

这是旧的Intel(R) Core(TM)2 Duo CPU E4500 @ 2.20GHz 的结果：

$ ./highest-bit
highest_bit_unrolled =  6.090s
highest_bit_parallel =  9.260s
highest_bit_bs = 19.910s
highest_bit_shift = 21.130s
highest_bit_so =  8.230s
highest_bit_so2 =  6.960s

在较新的型号上Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz：

highest_bit_unrolled =  1.555s
highest_bit_parallel =  3.420s
highest_bit_bs =  6.486s
highest_bit_shift =  9.505s
highest_bit_so =  4.127s
highest_bit_so2 =  1.645s

在较新的硬件上，highest_bit_so2 在较新的硬件上更接近 highest_bit_unrolled。顺序不太一样；现在highest_bit_so 真的落后了，而且比highest_bit_parallel 慢。

最快的highest_bit_unrolled 包含最多的代码和最多的分支。每个返回值都由一组不同的条件通过自己的专用代码达到。

“避免所有分支”的直觉（由于担心分支错误预测）并不总是正确的。现代（甚至不再那么现代）处理器包含相当多的狡猾，以免受到分支的阻碍。

---

附： highest_bit_unrolled 是在 December 2011 的 TXR 语言中引入的（有错误，因为已调试）。

最近，我开始想知道一些没有分支的更好、更紧凑的代码是否可能不会更快。

我对结果有些惊讶。

可以说，对于 GNU C 并使用一些编译器原语，代码实际上应该是 #ifdef-ing，但就可移植性而言，该版本仍然存在。

Answer 13

如果您有 80 位或 128 位浮点数可用，请转换为该类型，然后读取指数位。此链接包含详细信息（最多 52 位的整数）和其他几种方法：

http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogIEEE64Float

另外，检查 ffmpeg 源。我知道他们有一个非常快的算法。即使它不能直接扩展到更大的尺寸，你也可以轻松地做类似if (x>INT32_MAX) return fastlog2(x>>32)+32; else return fastlog2(x);

Answer 14

朴素线性搜索可能是均匀分布整数的一种选择，因为它平均需要略少于 2 次比较（对于任何整数大小）。

/* between 1 and 64 comparisons, ~2 on average */
#define u64_size(c) (              \
    0x8000000000000000 < (c) ? 64  \
  : 0x4000000000000000 < (c) ? 63  \
  : 0x2000000000000000 < (c) ? 62  \
  : 0x1000000000000000 < (c) ? 61  \
...
  : 0x0000000000000002 < (c) ?  2  \
  : 0x0000000000000001 < (c) ?  1  \
  :                             0  \
)

Answer 15

一种对最高位的二进制搜索。

在 stanford.edu 上发布的按位运算技巧的良好参考：Bit Twiddling Hacks。 该参考资料中有很多示例，包括用于计算 log2 值的几种算法。这包括与此类似的——也许更好的——方法。

我的想法是，对最高有效位进行二进制搜索会比简单解决方案的最大 60 多个循环更快。该算法在每次迭代中将 n 移位其最后一次移位值的一半，在 msb 上为零。

对于 64 位值，需要 6 次迭代才能确定最高有效位的位置 - 即n 的下限 log2。

根据我的测量，这种方法的性能并不比下面第二个示例中的简单循环好多少。

// floor log2 in 6 max iterations for unsigned 64-bit values.
//
int floor_log2(unsigned long long n)
{
    int shval = 32;
    int msb   =  0;
    while (shval) {
        if (n >> shval) {
            msb += shval;
            n  >>= shval;
        }
        shval >>= 1;
    }
    return msb;
}

int ceil_log2(unsigned long long n) 
{
    return floor_log2(2 * n - 1);
}

简单算法：

int floor_log2_simple(unsigned long long n)
{
    int c =  0;
    while (n) {
        n >>= 1;
        c++;
    }
    return c - 1;
}

在 Rust 中实现的这些相同算法的性能几乎相同。顶级方法的性能稍微好一点——但平均只有几纳秒。再多的调整算法也不会带来更好的性能。

嗯……