1、优化编译器的能力和局限性
(1)编译器有自己能够优化程序的能力,但会有局限性。
●指针指向内存的同一位置:
例如:
void twiddle1(long *xp, long *yp)
{
*xp += *yp;
*xp += *yp;
}
void twiddle2(long *xp, long *yp)
{
*xp += 2 * *yp;
}
函数twiddle1需要6次内存引用(2次读*xp,2次读*yp,2次写*xp),而函数twiddle2只需要3次内存引用(读*xp,读*yp,写*xp),所以twiddle2的执行会更加有效。
但是,考虑到xp和yp相等的情况(即内存引用同一个地方,指针指向同一个地址),两个函数的执行结果将不相等。
twiddle1将执行以下计算:
void twiddle1(long *xp, long *yp)
{
*xp += *xp;
*xp += *xp;
}
计算结果为xp增加4倍。
twiddle2将执行以下计算:
void twiddle2(long *xp, long *yp)
{
*xp += 2 * *xp;
}
计算结果为*xp增加3倍。
这时,编译器不会知道xp和yp是否相等,所以会考虑它们可能相等的情况,便不会产生优化的版本,这限制了可能的优化策略。
●函数调用:
long f();
long count = 0;
long func1()
{
return f() + f() + f() + f();
}
long func2()
{
return 4 * f();
}
long f()
{
return count++;
}
函数func1()和func2()似乎是相同的,但是,当调用的函数f()中对全局变量进行了改变后,func1()和func2()得到的结果便会不一样,避免不必要的函数调用,将计算过程改为如下:
long funclin()
{
long t = count++;
t += count++;
t += count++;
t += count++;
return t;
}
编译器可以统一对全局变量的更新,产生函数的优化版本如下:
long funclopt()
{
long t = 4 * count + 6;
count += 4;
return t;
}
2、消除循环的低效率
分析下面两个函数的效率:
void lower1(char *s)
{
long i;
for (i = 0; i < strlen(s); i++)
{
if (s[i] >= 'A'&&s[i] <= 'z')
s[i] -= ('A' - 'a');
}
}
void lower2(char *s)
{
long i;
long length = strlen(s);
for (i = 0; i < length; i++)
{
if (s[i] >= 'A'&&s[i] <= 'z')
s[i] -= ('A' - 'a');
}
}
很明显,当字符串长度逐渐变长时,lower2的性能便会成为瓶颈,而且,编译器并不知道strlen(s)的结果是否会变化(当循环里面有对于字符串从零变成非零或是从非零变成零时,长度会变化),便不会进行优化,需要我们手动进行优化。
3、消除不必要的循环引用
将循环内的指针使用尽可能的放在循环外面,例如:
void combine1()
{
for (i = 0; i < length; i++)
{
*dest = *dest + data[i];
}
}
void combine2()
{
data_t *dest;
data_t acc;
for (i = 0; i < length; i++)
{
acc = acc + data[i];
}
*dest = acc;
}
上面两个函数中,combine1()循环内每次对内存进行两次读一次写(在机器代码中,指针的地址是存放在寄存器中,需要通过寄存器中的地址找到相应的位置,再找到相应的数),而combine2()则减少为一次读(对data数组的访问)