优化头痛 - 从查找表中删除 if

Question

我正在尝试优化以下代码，这是我的应用程序的瓶颈。 它的作用：它采用双值 value1 和 value2 并尝试找到包括校正因子在内的最大值。如果两个值之间的差异大于 5.0（LUT 被缩放 10 倍），我可以取这两个值的最大值。如果差值小于 5.0，我可以使用 LUT 中的校正因子。

有谁知道这段代码有什么更好的风格？我不知道我在哪里浪费时间 - 是大量的 if 还是乘以 10？

double value1, value2;
// Lookup Table scaled by 10 for (ln(1+exp(-abs(x)))), which is almost 0 for x > 5 and symmetrical around 0. LUT[0] is x=0.0, LUT[40] is x=4.0.
const logValue LUT[50] = { ... }

if (value1 > value2)
{
    if (value1 - value2 >= 5.0)
    {
        return value1;
    }
    else
    {
        return value1 + LUT[(uint8)((value1 - value2) * 10)];
    }
}
else
{
    if (value2 - value1 >= 5.0)
    {
        return value2;
    }
    else
    {
        return value2 + LUT[(uint8)((value2 - value1) * 10)];
    }
}

Answer 1

使用 Excel 几分钟会生成一个近似方程，看起来它可能具有您需要的精度，因此您可以完全取消查找表。您仍然需要一个条件来确保方程的参数保持在优化的范围内。

double diff = abs(value1 - value2);
double dmax = (value1 + value2 + diff) * 0.5; // same as (min+max+(max-min))/2
if (diff > 5.0)
    return dmax;
return dmax + 4.473865638/(2.611112371+diff) + 0.088190879*diff + -1.015046114;

附：我不保证这会更快，只是它是一种足够不同的方法，值得进行基准测试。

附言可以更改约束以得出略有不同的常数，有很多变化。这是我做的另一组，你的表格和公式之间的差异总是小于 0.008，而且每个值都小于前面的值。

return dmax + 3.441318133/(2.296924445+diff) + 0.065529678*diff + -0.797081529;

编辑：我测试了这段代码（第二个公式），通过 100 次对 0 到 10 之间的一百万个随机数，以及来自问题的原始代码 MSalters currently accepted answer 和蛮力实施max(value1,value2)+log(1.0+exp(-abs(value1-value2)))。我在双核 AMD Athlon 和 Intel 四核 i7 上试了一下，结果大致一致。这是一个典型的运行：

• 原始：1.32 秒。
• MSalters：1.13 秒。
• 我的：0.67 秒。
• 蛮力：4.50 秒。

这些年来，处理器的速度快得令人难以置信，现在它们可以进行几次浮点乘法和除法运算，速度比在内存中查找值的速度还要快。这种方法不仅在现代 x86 上更快，而且更准确；方程中的近似误差远小于截断查找输入所导致的步长误差。

自然结果仍会因您的处理器和编译器而异；您自己的特定目标仍然需要进行基准测试。

Answer 2

它可能会在两条路径上同等地下降，从而导致处理器出现大量流水线问题。

您是否尝试过分析？

我还建议尝试使用标准库，看看是否有帮助（例如，它是否能够使用特定于处理器的指令）：

double diff = std::fabs(value1 - value2);
double maxv = std::max(value1, value2);
return (diff >= 5.0) ? maxv : maxv + LUT[(uint8)((diff) * 10)];

Answer 3

我可能会编写一些不同的代码来处理value2<value1 案例：

if (value2 < value1) std::swap(value1, value2);
assert(value1 <= value2); // Assertion corrected
int diff = int((value2 - value1) * 10.0);
if (diff >= 50) diff = 49; // Integer comparison iso floating point
return value2 + LUT[diff];

Answer 4

我将假设在调用该函数时，您很可能会得到必须使用查找表的部分，而不是 >=5.0 部分。在这种情况下，最好引导编译器这样做。

double maxval = value1;
double difference_scaled = (value1-value2)*10;
if (difference < 0)
{
    difference = -difference;
    maxval = value2;
}
if (difference < 50)
    return maxval+LUT[(int)difference_scaled];
else
    return maxval;

试试这个，如果这能提高你的程序的性能，请告诉我。

Answer 5

此代码成为应用程序瓶颈的唯一原因是您多次调用它。你确定你需要吗？也许代码中较高的算法可以更改为使用比较少？

Answer 6

我已经进行了一些非常快速的测试，但请自行分析代码以验证效果。

将LUT[] 更改为静态变量让我的速度提高了 600%（从 3.5 秒到 0.6 秒）。这接近我使用的绝对最小值（0.4s）。看看这是否有效并重新分析以确定是否需要进一步优化。

作为参考，我只是在 VC++ 2010 中计时了这个循环的执行时间（内部循环的 1 亿次迭代）：

int Counter = 0;

for (double j = 0; j < 10; j += 0.001)
    {
        for (double i = 0; i < 10; i += 0.001)
        {
            ++Counter;
            Value1 += TestFunc1(i, j);
        }
    }

Answer 7

您在函数中计算了很多次value1 - value2。只做一次。

转换为uint8_t 也可能有问题。就性能而言，用作从双精度数转换为整数的最佳整数类型是int，使用数组索引的最佳整数类型是int。

max_value = value1;
diff = value1 - value2;
if (diff < 0.0) {
  max_value = value2;
  diff = -diff;
}

if (diff >= 5.0) {
  return max_value;
}
else {
  return max_value + LUT[(int)(diff * 10.0)];
}

请注意，上述保证 LUT 索引将介于 0（含）和 50（不含）之间。这里不需要uint8_t。

编辑
在尝试了一些变化之后，这是一个相当快的基于 LUT 的近似 log(exp(value1)+exp(value2))：

#include <stdint.h>

// intptr_t *happens* to be fastest on my machine. YMMV.
typedef intptr_t IndexType;

double log_sum_exp (double value1, double value2, double *LUT) {
  double diff = value1 - value2;
  if (diff < 0.0) {
    value1 = value2;
    diff = -diff;
  }   
  IndexType idx = diff * 10.0;
  if (idx < 50) {
    value1 += LUT[idx];
  }   
  return value1;
}   

整数类型IndexType 是加快速度的关键之一。我用 clang 和 g++ 进行了测试，两者都表明转换为 intptr_t（我的计算机上的 long）并使用 intptr_t 作为 LUT 的索引比其他整数类型更快。它比某些类型快得多。例如，unsigned long long 和 uint8_t 在我的计算机上是非常糟糕的选择。

类型不仅仅是一个提示，至少在我使用的编译器中是这样。这些编译器完全按照代码告诉它从浮点类型到整数类型的转换执行了该操作，而不管优化级别如何。

将整数类型与 50 进行比较而不是将浮点类型与 5.0 进行比较会产生另一个减速带。

最后一个减速带：并非所有编译器都是平等的。 在我的计算机上 (YMMV)，g++ -O3 生成的代码比clang -O3 生成的代码慢得多（这个问题慢了25%！），而clang -O3 生成的代码又比由clang -O4.

我也玩过有理函数逼近方法（类似于 Mark Ransom 的回答），但上面显然没有使用这种方法。