我有两个逻辑等效的函数：
long ipow1(int base, int exp) {
// HISTORICAL NOTE:
// This wasn't here in the original question, I edited it in,
if (exp == 0) return 1;
long result = 1;
while (exp > 1) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
}
return result * base;
}
long ipow2(int base, int exp) {
long result = 1;
while (exp) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
}
return result;
}
这些循环是等效的，因为在前一种情况下，我们将返回result * base（处理exp已经或已减少为1时的情况）但在第二种情况下，我们将返回result。
奇怪的是，-O3和-O0 ipow1因此优于ipow2约25％。这怎么可能？
我使用的是Windows 7，x64，gcc 4.5.2并使用gcc ipow.c -O0 -std=c99进行编译。
这是我的分析代码：
int main(int argc, char *argv[]) {
LARGE_INTEGER ticksPerSecond;
LARGE_INTEGER tick;
LARGE_INTEGER start_ticks, end_ticks, cputime;
double totaltime = 0;
int repetitions = 10000;
int rep = 0;
int nopti = 0;
for (rep = 0; rep < repetitions; rep++) {
if (!QueryPerformanceFrequency(&ticksPerSecond)) printf("\tno go QueryPerformance not present");
if (!QueryPerformanceCounter(&tick)) printf("no go counter not installed");
QueryPerformanceCounter(&start_ticks);
/* start real code */
for (int i = 0; i < 55; i++) {
for (int j = 0; j < 11; j++) {
nopti = ipow1(i, j); // or ipow2
}
}
/* end code */
QueryPerformanceCounter(&end_ticks);
cputime.QuadPart = end_ticks.QuadPart - start_ticks.QuadPart;
totaltime += (double)cputime.QuadPart / (double)ticksPerSecond.QuadPart;
}
printf("\tTotal elapsed CPU time: %.9f sec with %d repetitions - %ld:\n", totaltime, repetitions, nopti);
return 0;
}
答案 0 :(得分：10)
不，真的，两者不等同。当ipow2没有时，ipow1会返回正确的结果。
P.S。我不在乎你留下多少评论“解释”为什么它们是相同的，只需要一个反例就可以反驳你的说法。
P.P.S。 -1对于那些已经试图向你指出这一点的人来说，这是一种令人难以忍受的傲慢的问题。
答案 1 :(得分：3)
因为while（exp＆gt; 1），for将从exp运行到2（它将以exp = 2执行，将其递减为1然后结束循环）。 使用while（exp），for将从exp运行到1（它将以exp = 1执行，将其递减为0然后结束循环）。
因此，对于while（exp），您需要额外的迭代，这需要额外的时间来运行。
编辑：即使使用exp＆gt; 1进行循环后的乘法运算，请记住乘法不是循环中的唯一内容。
答案 2 :(得分：2)
如果您不想阅读所有这些内容，请通过对代码的分析得出21％的差异。
不同的系统，编译器的版本，由不同的人/发行版构建的相同编译器版本将提供不同的指令混合，这只是您可能得到的一个示例。
long ipow1(int base, int exp) {
long result = 1;
while (exp > 1) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
}
return result * base;
}
long ipow2(int base, int exp) {
long result = 1;
while (exp) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
}
return result;
}
0000000000000000 <ipow1>:
0: 83 fe 01 cmp $0x1,%esi
3: ba 01 00 00 00 mov $0x1,%edx
8: 7e 1d jle 27 <ipow1+0x27>
a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
10: 40 f6 c6 01 test $0x1,%sil
14: 74 07 je 1d <ipow1+0x1d>
16: 48 63 c7 movslq %edi,%rax
19: 48 0f af d0 imul %rax,%rdx
1d: d1 fe sar %esi
1f: 0f af ff imul %edi,%edi
22: 83 fe 01 cmp $0x1,%esi
25: 7f e9 jg 10 <ipow1+0x10>
27: 48 63 c7 movslq %edi,%rax
2a: 48 0f af c2 imul %rdx,%rax
2e: c3 retq
2f: 90 nop
0000000000000030 <ipow2>:
30: 85 f6 test %esi,%esi
32: b8 01 00 00 00 mov $0x1,%eax
37: 75 0a jne 43 <ipow2+0x13>
39: eb 19 jmp 54 <ipow2+0x24>
3b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
40: 0f af ff imul %edi,%edi
43: 40 f6 c6 01 test $0x1,%sil
47: 74 07 je 50 <ipow2+0x20>
49: 48 63 d7 movslq %edi,%rdx
4c: 48 0f af c2 imul %rdx,%rax
50: d1 fe sar %esi
52: 75 ec jne 40 <ipow2+0x10>
54: f3 c3 repz retq
隔离循环：
while (exp > 1) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
}
//if exp & 1 not true jump to 1d to skip
10: 40 f6 c6 01 test $0x1,%sil
14: 74 07 je 1d <ipow1+0x1d>
//result *= base
16: 48 63 c7 movslq %edi,%rax
19: 48 0f af d0 imul %rax,%rdx
//exp>>=1
1d: d1 fe sar %esi
//base *= base
1f: 0f af ff imul %edi,%edi
//while(exp>1) stayin the loop
22: 83 fe 01 cmp $0x1,%esi
25: 7f e9 jg 10 <ipow1+0x10>
比较某些东西通常可以为你节省一条指令，你可以在这里看到
while (exp) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
}
//base *= base
40: 0f af ff imul %edi,%edi
//if exp & 1 not true jump to skip
43: 40 f6 c6 01 test $0x1,%sil
47: 74 07 je 50 <ipow2+0x20>
//result *= base
49: 48 63 d7 movslq %edi,%rdx
4c: 48 0f af c2 imul %rdx,%rax
//exp>>=1
50: d1 fe sar %esi
//no need for a compare
52: 75 ec jne 40 <ipow2+0x10>
你的计时方法会产生很多错误/混乱。根据循环的拍频和定时器的精确度，您可以在一个中创造大量增益，在另一个中创造大量损失。这种方法通常可以提供更好的准确性：
starttime = ... 对于（REP = bignumber;代表; rep--） { //正在测试的代码 ... } endtime = ... total = endtime - starttime;
当然，如果您在操作系统计时上运行它，那么它无论如何都会有相当大的错误。
此外，您还希望将volatile变量用于计时器变量，以帮助编译器不重新排列执行顺序。 （见过那里）。
如果我们从基数倍数的角度来看这个：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
unsigned int mults;
long ipow1(int base, int exp) {
long result = 1;
while (exp > 1) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
mults++;
}
result *= base;
return result;
}
long ipow2(int base, int exp) {
long result = 1;
while (exp) {
if (exp & 1) result *= base;
exp >>= 1;
base *= base;
mults++;
}
return result;
}
int main ( void )
{
int i;
int j;
mults = 0;
for (i = 0; i < 55; i++) {
for (j = 0; j < 11; j++) {
ipow1(i, j); // or ipow2
}
}
printf("mults %u\n",mults);
mults=0;
for (i = 0; i < 55; i++) {
for (j = 0; j < 11; j++) {
ipow2(i, j); // or ipow2
}
}
printf("mults %u\n",mults);
}
有
mults 1045
mults 1595
ipow2（）多50％。实际上，不仅仅是你经历循环50％以上的倍数。
ipow1（）在其他乘法上得到一点回报：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
unsigned int mults;
long ipow1(int base, int exp) {
long result = 1;
while (exp > 1) {
if (exp & 1) mults++;
exp >>= 1;
base *= base;
}
mults++;
return result;
}
long ipow2(int base, int exp) {
long result = 1;
while (exp) {
if (exp & 1) mults++;
exp >>= 1;
base *= base;
}
return result;
}
int main ( void )
{
int i;
int j;
mults = 0;
for (i = 0; i < 55; i++) {
for (j = 0; j < 11; j++) {
ipow1(i, j); // or ipow2
}
}
printf("mults %u\n",mults);
mults=0;
for (i = 0; i < 55; i++) {
for (j = 0; j < 11; j++) {
ipow2(i, j); // or ipow2
}
}
printf("mults %u\n",mults);
}
ipow1（）执行结果* = base的次数与ipow2（）相同（或多次）
mults 990
mults 935
作为long * int可以使这些更昂贵。不足以弥补ipow2（）中循环周围的损失。
即使没有反汇编，也要粗略猜测编译器使用的操作/指令。这里考虑的处理器一般不一定是x86，有些处理器会比其他处理器更好地运行这些代码（从执行的一些指令来看，不计算所有其他因素）。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
unsigned int ops;
long ipow1(int base, int exp) {
long result = 1;
ops++; //result = immediate
while (exp > 1) {
ops++; // compare exp - 1
ops++; // conditional jump
//if (exp & 1)
ops++; //exp&1
ops++; //conditional jump
if (exp & 1)
{
result *= base;
ops++;
}
exp >>= 1;
ops++;
//ops+=?; //using a signed number can cost you this on some systems
//always use unsigned unless you have a specific reason to use signed.
//if this had been a short or char variable it might cost you even more
//operations
//if this needs to be signed it is what it is, just be aware of
//the cost
base *= base;
ops++;
}
result *= base;
ops++;
return result;
}
long ipow2(int base, int exp) {
long result = 1;
ops++;
while (exp) {
//ops++; //cmp exp-0, often optimizes out;
ops++; //conditional jump
//if (exp & 1)
ops++;
ops++;
if (exp & 1)
{
result *= base;
ops++;
}
exp >>= 1;
ops++;
//ops+=?; //right shifting a signed number
base *= base;
ops++;
}
return result;
}
int main ( void )
{
int i;
int j;
ops = 0;
for (i = 0; i < 55; i++) {
for (j = 0; j < 11; j++) {
ipow1(i, j); // or ipow2
}
}
printf("ops %u\n",ops);
ops=0;
for (i = 0; i < 55; i++) {
for (j = 0; j < 11; j++) {
ipow2(i, j); // or ipow2
}
}
printf("ops %u\n",ops);
}
假设我计算了所有主要操作并且没有不公平地给出一个功能而不是另一个：
ops 7865
ops 9515
我认为这个大杀手在整个循环中的次数增加了50％。如果它依赖于数据，您可能会在基准测试中找到输入，使功能之间的差异大于或低于您所看到的25％。
答案 3 :(得分：0)
您的功能在“逻辑上并不相同”。
while (exp > 1){...}
NOT 逻辑上等于
while (exp){...}
为什么这么说？
答案 4 :(得分：0)
这是否真的生成相同的汇编代码？当我尝试（在OpenSuse 11.4上使用gcc 4.5.1时，我会承认）我发现了一点点差异。
ipow1.s：
cmpl $1, -24(%rbp)
jg .L4
movl -20(%rbp), %eax
cltq
imulq -8(%rbp), %rax
leave
ipow2.s：
cmpl $0, -24(%rbp)
jne .L4
movq -8(%rbp), %rax
leave
对于jg而言，处理器的分支预测可能比使用jne更有效吗？一个分支指令似乎不可能比另一个分支指令运行快25％（特别是当cmpl完成了大部分繁重的工作时）