一.代码移动

将在循环里面多次计算，但是结果不会改变的计算，移到循环外面去。

例子：

优化前：

void lower1(char *s){

int i;

for(i=0;i

if(s[i]>='A'&&s[i]<='Z')

s[i]-=('A'-'a');

}

优化后：

void lower2(char *s){

int i;

int len=strlen(s);

for(int i=0;i

if(s[i]>='A'&&s[i]<='Z')

s[i]-=('A'-'a');

}

优化前的版本，由于每次循环都要调用strlen计算s的长度，实际上的复杂度成了O(n2)了，而优化后的版本只需计算一次s的长度，因此性能上比优化前版本要好。

二.减少函数调用

例子：

优化前：

void sum1(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

*dest=0;

for(i=0;i

data_t val;

get_vec_element(v,i,&val);

*dest+=val;

}

}

优化后：

data_t get_vec_start(vec_ptr v){

return v->data;

}

void sum2(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

data_t *data=get_vec_start(v);

*dest=0;

for(i=0;i

*dest+=data[i];

}

优化前的版本在每次循环中都要调用一次get_vec_element获得相应的项，而优化后的版本只需在循环外调用一次get_vec_start获得开始的内存地址，循环内直接访问内存，无需调用函数。

三.减少内存访问

例子：

优化前：

void sum2(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

data_t *data=get_vec_start(v);

*dest=0;

for(i=0;i

*dest+=data[i];

}

优化后：

void sum3(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

data_t *data=get_vec_start(v);

data_t acc=0;

for(i=0;i

acc+=data[i];

*dest=acc;

}

优化前的版本每次迭代都要从dest读出值再加上data[i]，再将结果写回dest。这样的读写很浪费，因此每次迭代开始从dest读出的值就是上次迭代写回dest的指。优化后的版本通过加入acc临时变量，它循环中累积计算出的结果，循环结束后再写回。

这里给出两个版本相应的汇编结果就可以很清楚看出区别：

优化前：

优化前的版本每次迭代都要从dest读出值再加上data[i]，再将结果写回dest。这样的读写很浪费，因此每次迭代开始从dest读出的值就是上次迭代写回dest的指。优化后的版本通过加入acc临时变量，它循环中累积计算出的结果，循环结束后再写回。

第二行和第四行分别对dest进行了读写。

优化后：

从汇编结果可以看出编译器将acc直接放在了寄存器里，循环中无需对内存进行读写。

四.循环展开

循环展开可以减少循环的次数，对程序的性能带了两方面的提高。一是减少了对循环没有直接贡献的计算，比如循环计数变量的计算，分支跳转指令的执行等。二是提供了进一步利用机器特性进行的优化的机会。

例子：

优化前的代码见前一篇博客里的sum3.

优化后：

void sum4(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

int limit=len-3;

data_t *data=get_vec_start(v);

data_t acc=0;

for(i=0;i

acc=acc+data[i]+data[i+1];

acc=acc+data[i+2]+data[i+3];

}

for(;i

acc+=data[i];

*dest=acc;

}

通过循环展开，每次迭代将累加4个元素，减少了循环次数，从而减少了总的执行时间(单独使用这种优化方法，对浮点数累乘几乎没有提高，但是整数累乘得益于编译器的重关联代码变化会有大幅度提高)。

这种优化可以直接利用编译器完成，将优化level设定到较高，编译器会自动进行循环展开。使用gcc，可以显式使用-funroll-loops选项。

五.提高并行性

现代处理器大多采用了流水线、超标量等技术，可以实现指令级并行。我们可以利用这个特性对代码做进一步的优化。

2.1使用多个累积变量

优化代码示例

void sum5(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

int limit=len-1;

data_t *data=get_vec_start(v);

data_t acc0=0;

data_t acc1=0;

for(i=0;i

acc0+=data[i];

acc1+=data[i+1];

}

for(;i

acc0+=data[i];

*dest=acc0+acc1;

}

这里同时使用了循环展开和使用多个累加变量，一方面减少了循环次数，另一方面指令级并行的特性使得每次迭代的两次加法可以并行执行。基于这两点可以显著减少程序执行的时间。通过增加展开的次数和累加变量的个数，可以进一步提高程序的性能，直到机器指令执行的吞吐量的极限。

2.2重结合变换

除了使用多个累积变量显式利用机器的指令级并行特性外，还可以对运算重新结合变换，打破顺序相关性来享受指令级并行带来的好处。

在sum4中，acc=acc+data[i]+data[i+1]的结合顺序是acc=(acc+data[i])+data[i+1];

我们将之变成acc=acc+(data[i]+data[i+1])；

代码如下：

void sum6(vec_ptr v,data_t *dest){

int i;

int len=vec_length(v);

int limit=len-3;

data_t *data=get_vec_start(v);

data_t acc=0;

for(i=0;i

acc=acc+(data[i]+data[i+1]);

acc=acc+(data[i+2]+data[i+3]);

}

for(;i

acc+=data[i];

*dest=acc;

}

进一步增加循环展开的次数，可以进一步提高程序性能，最终也可以达到机器指令执行的吞吐量的极限。(在循环展示提到的整数乘法的性能提高就在于编译器隐式采取了这种变换，但是由于浮点数不具备结合性，所以编译器没有采用，但是程序员在保证程序结果正确性的情况下，可以显式使用这一点)。