优化程序性能
编写高效程序需要做到如下几点
1.选择适当的算法和数据结构。
2.编写出编译器能够有效优化以转换成高效可执行代码的源代码(理解编译器的能力和局限性尤为重要)。
3.针对运算量特别大的计算，将一个任务分成多个部分，并行的去计算。
程序示例
typedef long data_t
typedef struct {
long len;
data_t *date
}ver_rec,*ver_ptr;
ver_ptr new(long len) {
ver_ptr result = (vec_ptr)malloc(sizeof(ver_rec));
data_t *data = NULL;
if (!result) {
return NULL;
}
result->len = len;
if(len > 0) {
data = (data_t *)calloc(len, sizeof(data_t));
if(!data) {
free((void *)result);
return NULL;
}
}
result->data = data;
return result;
}
int get_vec_element(ver_ptr v, long index, data_t *dest) {
if(index < 0 || index >=v->len) return 0 ;
*dest = v->data[index];
return 1;
}
long ver_length(vec_ptr v) {
return v->len;
}
void combine1(vec_ptr v, data_t *dest) {
long i;
*dest = 0;
for(int i =0; i< vec_length(v); i++) {
data_t val;
get_vec_element(v,i,&val);
*dest = *desc + val;
}
}
上面代码主要是给出生成向量、访问元素、计算长度的一些方法。我们通过将一个向量中所有的元素合并成一个值得例子，来说明如果做程序优化。
消除循环的低效率
通过combine1函数我们可以看到，循环每个元素时，都会调用vec_length()方法，我们知道向量的长度不会随着循环的进行而改变，我们只需要计算一次向量的长度。
void combine2(vec_ptr v, data_t *dest) {
long i;
long length = vec_length(v);
*dest = 0;
for(int i =0; i< length; i++) {
data_t val;
get_vec_element(v,i,&val);
*dest = *desc + val;
}
}
这种优化称为代码移动(code motion)。执行多次，但不会改变的计算，一般用代码移动来优化
减少过程调用
太多的过程调用会带来性能的开销，从combine我们可以看到，每次循环都会调用get_vec_element方法，我们可以用下面的方法来优化
void combine3(vec_ptr v, data_t *dest) {
long i;
long length = vec_length(v);
data_t *data = get_vec_start(v);
*dest = 0;
for(int i =0; i< length; i++) {
*dest = *desc + data[i];
}
}
消除不必要的内存引用
我们看到每次循环迭代时，累积变量的值都要从内存中读出在写入到内存中，每次都要访问两次*dest。我们可以建立一个临时变量，每次循环累积的值都用它来存储，循环结束时，再把它复制到内存中。
void combine4(vec_ptr v, data_t *dest) {
long i;
long length = vec_length(v);
data_t *data = get_vec_start(v);
data_t acc = 0;
*dest = 0;
for(int i =0; i< length; i++) {
acc = acc + data[i];
}
*dest = acc;
}
通过上面的优化，我们将每次迭代的内存操作从两次读和一次写减少到只需要一次读
循环展开
循环展开是一种程序变换，通过增加每次迭代程序计算的数量，减少循环的迭代次数。循环展开能够从两个方面改进程序的性能
1.减少了不直接有助于程序结果的操作的数量，列如循环索引计算和条件分支。
2.提供了一些方法，可以进一步变化代码，减少整个计算中关键路径上的操作数量。
void combine5(vec_ptr v, data_t *dest) {
long i;
long length = vec_length(v);
long limit = length - 1;
data_t *data = get_vec_start(v);
data_t acc = 0;
for(int i =0; i< limit; i+=2) {
acc = acc + data[i] + data[i+1];
}
for(; i < length; i++) {
acc = acc + data[i]
}
*dest = acc;
}
提高并行性
多个累积变量
对于一个可结合和可变换的合并运算来说，比如说整数加法或乘法，我们可以通过将一组合并分割成两个或更多部分。
void combine6(vec_ptr v, data_t *dest) {
long i;
long length = vec_length(v);
long limit = length - 1;
data_t *data = get_vec_start(v);
data_t acc0 = 0;
data_t acc1 = 0;
for(int i =0; i< limit; i+=2) {
acc0 = acc0 + data[i];
acc1 = acc1 + data[i+1];
}
for(; i < length; i++) {
acc0 = acc0 + data[i]
}
*dest = acc0 + acc1;
}
重新结合变换
void combine7(vec_ptr v, data_t *dest) {
long i;
long length = vec_length(v);
long limit = length - 1;
data_t *data = get_vec_start(v);
data_t acc = 0;
for(int i =0; i< limit; i+=2) {
acc = acc + (data[i] + data[i+1]);
}
for(; i < length; i++) {
acc = acc + data[i]
}
*dest = acc;
}
一些限制因素
寄存器溢出
如果我们的并行p超过了寄存器的数量，那么编译器就会溢出，将某些临时值存放到内存中，通常是在运行时堆栈上分配空间。
