优化程序性能

编写高效程序需要做到如下几点
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&lt; limit; i+=2) {
    acc = acc + data[i] + data[i+1];
}

for(; i &lt; 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超过了寄存器的数量，那么编译器就会溢出，将某些临时值存放到内存中，通常是在运行时堆栈上分配空间。