我做了一些速度测试，以确定在对数字进行乘法或除法时最快的速度。我必须努力工作以击败优化者。我得到了无意义的结果，例如在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;
}
答案 0 :(得分：9)
有很多方法可以执行某些算术，因此可能没有单一的答案（移位，小数乘法，实际除法，通过对数单位的某些往返等等;这些可能都有不同的相对成本，具体取决于操作数和资源分配）。
让编译器利用它拥有的程序和数据流信息来完成它的工作。
对于适用于x86上的程序集的某些数据，您可以查看："Instruction latencies and throughput for AMD and Intel x86 processors"
答案 1 :(得分：4)
最快的将完全取决于目标架构。它看起来像你只对你碰巧遇到的平台感兴趣，从你的执行时间猜测似乎是64位x86，无论是Intel（Core2？）还是AMD。
也就是说，反向浮点乘法在许多平台上都是最快的，但是，正如你推测的那样，通常不如浮点除法（两次舍入而不是一次） - 无论是否重要对于您的使用是一个单独的问题）。一般来说，你最好重新安排你的算法使用较少的分数，而不是跳过箍来使分割尽可能高效（最快的分工是你不做的），并确保在你之前进行基准测试花费时间进行优化，因为划分分区的算法很少而且很远。
此外，如果您有整数源并需要整数结果，请确保在基准测试中包括整数和浮点之间的转换成本。
由于您对特定计算机上的计时感兴趣，因此您应该知道英特尔现在会在Optimization Reference Manual (pdf)中发布此信息。具体来说，您将对附录C第3.1节“注册操作数的延迟和吞吐量”表格感兴趣。
请注意，整数除法时间很大程度上取决于所涉及的实际值。根据该指南中的信息，您的计时例程似乎仍有相当大的开销，因为您衡量的性能比率与英特尔公布的信息不符。
答案 2 :(得分：2)
正如斯蒂芬所提到的，使用optimisation manual - 但你也应该考虑使用SSE指令。这些可以在一条指令中进行4或8次除法/乘法运算。
此外，分部采用单个时钟周期进行处理是相当普遍的。结果可能在几个时钟周期（称为延迟）中不可用，但是下一个除法可以在此期间开始（与第一个重叠），只要它不需要第一个的结果。这是由于CPU中的管道衬里，就像在先前的负载仍在干燥时可以洗更多的衣服一样。
乘以除法是一种常见的技巧，应该在你的除数不经常改变的地方使用。
你很有可能花费时间和精力使数学快速发现只是发现存储器访问的速度（当您导航输入并写入输出时）限制了最终的实施。
答案 3 :(得分：0)
我在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”那么它会显着增加时间。虽然，虽然很多可能是从磁盘重新加载，但很明显编译器无法轻易地优化它。
要了解此类微观优化，请尝试阅读this pdf.
我认为，如果你担心这些事情，你显然没有描述你的代码。在实际出现问题时对问题进行概述和修复。
答案 4 :(得分：0)
Agner Fog自己做了一些非常详细的测量，可以找到here。如果您真的想要优化内容，您还应该从他的software optimization resources阅读其余文档。
我想指出，即使您正在测量非向量化浮点运算，编译器也会为生成的程序集提供两个选项：它可以使用FPU指令（fadd，fmul）或者它可以使用SSE指令，同时仍然按照指令操作一个浮点值（addss，mulss）。根据我的经验，SSE指令更快，并且具有更少的不准确性，但编译器不会将其作为默认值，因为它可能会破坏与依赖于旧行为的代码的兼容性。您可以使用-mfpmath=sse标记在gcc中打开它。