分裂的速度更快？ 双打/浮点数/ UInt32 / UInt64？ 在C ++ / C中

Question

我做了一些速度测试，以确定在对数字进行乘法或除法时最快的速度。 我必须努力工作以击败优化者。 我得到了无意义的结果，例如在2微秒内运行的大量循环，或者乘法与除法的速度相同（如果只是那样）。

在我最终努力工作以击败足够的编译器优化之后，同时仍然让它优化速度，我得到了这些速度结果。 他们可能对别人感兴趣？

如果我的测试仍然悬而未决，请告诉我，但要善待，因为我只花了两个小时写这个垃圾：P

64 time: 3826718 us
32 time: 2476484 us
D(mul) time: 936524 us
D(div) time: 3614857 us
S time: 1506020 us

使用双打“乘以除法”似乎是进行除法的最快方法，其次是整数除法。 我没有测试分裂的准确性。 可能是“正确的划分”更准确吗？ 我不想在这些速度测试结果之后发现，因为我只是在基数为10的常数上使用整数除法，让我的编译器为我优化它;）（并且不会破坏它的优化）。

这是我用来获得结果的代码：

#include <iostream>

int Run(int bla, int div, int add, int minus) {
    // these parameters are to force the compiler to not be able to optimise away the
    // multiplications and divides :)
    long LoopMax = 100000000;

    uint32_t Origbla32 = 1000000000;
    long i = 0;

    uint32_t bla32 = Origbla32;
    uint32_t div32 = div;
    clock_t Time32 = clock();
    for (i = 0; i < LoopMax; i++) {
        div32 += add;
        div32 -= minus;
        bla32 = bla32 / div32;
        bla32 += bla;
        bla32 = bla32 * div32;
    }
    Time32 = clock() - Time32;

    uint64_t bla64 = bla32;
    clock_t Time64 = clock();
    uint64_t div64 = div;
    for (long i = 0; i < LoopMax; i++) {
        div64 += add;
        div64 -= minus;
        bla64 = bla64 / div64;
        bla64 += bla;
        bla64 = bla64 * div64;
    }
    Time64 = clock() - Time64;

    double blaDMul = Origbla32;
    double multodiv = 1.0 / (double)div;
    double multomul = div;
    clock_t TimeDMul = clock();
    for (i = 0; i < LoopMax; i++) {
        multodiv += add;
        multomul -= minus;
        blaDMul = blaDMul * multodiv;
        blaDMul += bla;
        blaDMul = blaDMul * multomul;
    }
    TimeDMul = clock() - TimeDMul;

    double blaDDiv = Origbla32;
    clock_t TimeDDiv = clock();
    for (i = 0; i < LoopMax; i++) {
        multodiv += add;
        multomul -= minus;
        blaDDiv = blaDDiv / multomul;
        blaDDiv += bla;
        blaDDiv = blaDDiv / multodiv;
    }
    TimeDDiv = clock() - TimeDDiv;

    float blaS = Origbla32;
    float divS = div;
    clock_t TimeS = clock();
    for (i = 0; i < LoopMax; i++) {
        divS += add;
        divS -= minus;
        blaS = blaS / divS;
        blaS += bla;
        blaS = blaS * divS;
    }
    TimeS = clock() - TimeS;

    printf("64 time: %i us  (%i)\n", (int)Time64, (int)bla64);
    printf("32 time: %i us  (%i)\n", (int)Time32, bla32);

    printf("D(mul) time: %i us  (%f)\n", (int)TimeDMul, blaDMul);
    printf("D(div) time: %i us  (%f)\n", (int)TimeDDiv, blaDDiv);
    printf("S time: %i us  (%f)\n", (int)TimeS, blaS);

    return 0;
}

int main(int argc, char* const argv[]) {
    Run(0, 10, 0, 0); // adds and minuses 0 so it doesn't affect the math, only kills the opts
    return 0;
}

Answer 1

有很多方法可以执行某些算术，所以可能没有一个答案（移位，小数乘法，实际除法，通过对数单位的某些往返等等;这些可能都有不同的相对成本，具体取决于操作数和资源分配）。

让编译器使用它具有的程序和数据流信息。

对于适用于x86上的汇编的一些数据，您可能会看到： “AMD和Intel x86处理器的指令延迟和吞吐量”

Answer 2

最快的将完全取决于目标架构。 它看起来像你只对你碰巧在的平台感兴趣，从你的执行时间猜测似乎是64位x86，无论是Intel（Core2？）还是AMD。

也就是说，反向浮点乘法在许多平台上都是最快的，但正如你推测的那样，通常不如浮点除法（两次舍入而不是一次） - 无论这对你的使用是否重要是一个单独的问题）。 一般来说，你最好重新安排你的算法使用较少的分数，而不是跳过箍来使分割尽可能高效（最快的分工是你不做的），并确保在你之前进行基准测试花费时间进行优化，因为划分分区的算法很少而且很远。

此外，如果您有整数源并需要整数结果，请确保在基准测试中包括整数和浮点之间的转换成本。

由于您对特定计算机上的计时感兴趣，因此您应该知道英特尔现在在其优化参考手册（pdf）中发布此信息。 具体来说，您将对附录C第3.1节“注册操作数的延迟和吞吐量”表格感兴趣。

请注意，整数除法时间很大程度上取决于所涉及的实际值。 根据该指南中的信息，您的计时程序似乎仍有相当大的开销，因为您测量的性能比率与英特尔公布的信息不符。

Answer 3

正如Stephen提到的那样，使用优化手册 - 但您也应该考虑使用SSE指令。 这些可以在单个指令中进行4或8个分区/乘法。

此外，分区采用单个时钟周期进行处理是相当普遍的。 结果可能在几个时钟周期（称为延迟）中不可用，但是下一个除法可以在此期间开始（与第一个重叠），只要它不需要第一个的结果。 这是由于CPU中的管道衬里，就像在先前的负载仍在干燥时可以洗更多的衣服一样。

乘以除法是一种常见的技巧，应该在你的除数不经常改变的地方使用。

您很有可能花费时间和精力使数学运算快速，只是发现内存访问的速度（当您导航输入并写入输出时）限制了您的最终实施。

Answer 4

我在MSVC 2008上写了一个有缺陷的测试

double i32Time  = GetTime();
{
    volatile __int32 i = 4;
    __int32 count   = 0;
    __int32 max     = 1000000;
    while( count < max )
    {
        i /= 61;
        count++;
    }
}
i32Time = GetTime() - i32Time;

double i64Time  = GetTime();
{
    volatile __int64 i = 4;
    __int32 count   = 0;
    __int32 max     = 1000000;
    while( count < max )
    {
        i /= 61;
        count++;
    }
}
i64Time = GetTime() - i64Time;


double fTime    = GetTime();
{
    volatile float i = 4;
    __int32 count   = 0;
    __int32 max     = 1000000;
    while( count < max )
    {
        i /= 4.0f;
        count++;
    }
}
fTime   = GetTime() - fTime;

double fmTime   = GetTime();
{
    volatile float i = 4;
    const float div = 1.0f / 4.0f;
    __int32 count   = 0;
    __int32 max     = 1000000;
    while( count < max )
    {
        i *= div;
        count++;
    }
}
fmTime  = GetTime() - fmTime;

double dTime    = GetTime();
{
    volatile double i = 4;
    __int32 count   = 0;
    __int32 max     = 1000000;
    while( count < max )
    {
        i /= 4.0f;
        count++;
    }
}
dTime   = GetTime() - dTime;

double dmTime   = GetTime();
{
    volatile double i = 4;
    const double div = 1.0f / 4.0f;
    __int32 count   = 0;
    __int32 max     = 1000000;
    while( count < max )
    {
        i *= div;
        count++;
    }
}
dmTime  = GetTime() - dmTime;


DebugOutput( _T( "%f\n" ), i32Time );
DebugOutput( _T( "%f\n" ), i64Time );
DebugOutput( _T( "%f\n" ), fTime );
DebugOutput( _T( "%f\n" ), fmTime );
DebugOutput( _T( "%f\n" ), dTime );
DebugOutput( _T( "%f\n" ), dmTime );

DebugBreak();

然后我以32位模式在AMD64 Turion 64上运行它。 我得到的结果如下：

0.006622
0.054654
0.006283
0.006353
0.006203
0.006161

测试有缺陷的原因是使用volatile会强制编译器从内存中重新加载变量，以防万一它被更改。 所有这些都表明这台机器上的任何实现之间没有什么区别（__int64显然很慢）。

它还明确地表明MSVC编译器通过倒数优化执行乘法运算。 我想GCC会做同样的事情，如果不是更好的话。 如果我改变浮点数和双除法检验除以“i”那么它会显着增加时间。 虽然，虽然很多可能是从磁盘重新加载，但很明显编译器无法轻易地优化它。

要了解这种微观优化，请尝试阅读此pdf。

我所有人都认为，如果你担心这些事情，你显然还没有描述你的代码。 在实际出现问题时，对问题进行概述和修复。

Answer 5

Agner Fog自己做了一些非常详细的测量，可以在这里找到。 如果您真的想要优化内容，您还应该从他的软件优化资源中阅读其余文档。

我要指出的是，即使您正在测量非向量化浮点运算，编译器也会为生成的汇编提供两个选项：它可以使用FPU指令（ fadd ， fmul ），也可以使用SSE指令同时仍然操作一个浮点运算每条指令的点值（ addss ， mulss ）。 根据我的经验，SSE指令更快，并且具有更少的不准确性，但编译器不会将其作为默认值，因为它可能会破坏与依赖于旧行为的代码的兼容性。 您可以使用-mfpmath=sse标志在gcc中打开它。