CSAPP |task05|优化程序性能

5.优化程序性能-|

优化编译器的能力和局限性

void twiddle1(long *xp,long *yp){
*xp += *yp;
*xp += *yp;
}
void twiddle2(long *xp,long *yp){
*xp += 2* *yp;
}

在上两页的两段代码中，函数twiddle2的效率更高，因为它只要求3次内存引用，（读*xp,读*yp,写*xp）
而twiddle1需要6次
（2次读*xp,两次读*yp,两次写*xp）
如果xp=yp那么函数twiddle1实际操作是将xp的值增加4倍，而函数twiddle2是将xp的值增加了3倍

由于编译器不知道xp与yp是否可能相等，因此twiddle2不能作为twiddle1的优化版本

函数调用对优化的影响

考虑下面的代码

long f();
long func1(){
return f()+f()+f()+f();
}
long func2(){
return 4*f();
}

静态RAM(SRAM)
先不考虑函数f的具体内容，func2只调用f 一次，而func1调用f 四次。但如果考虑从函数f如下

long counter=0;
long f(){
return counter++;
}

对于这样的f，func1会返回6(0+1+2+3),而func2会返回0
这种情况编译器也是无法判断的

程序性能的表示

对于一个程序，如果我们记录该程序的数据规模以及对应的运行所需的时钟周期，并通过最小二乘法来拟合这些点，我们将得到形如y=a+bx的表达式，其中y是时钟周期，x是数据规模，当数据规模较大的时候，运行时间就主要由线性因子b来决定，这时候，我们将b作为度量程序性能的标准，称为每元素的周期数

为了方便说明，先声明一个如下的结构

typedef struct{
long len;
data_t *data;
}vec_rec,*vec_ptr

这个声明用data_t来表示基本元素的数据类型

先考虑如下的代码

void combine1(vec_ptr v,data_t *dest){
long i;
*dest =IDENT;
for(i=0;i<vec_length(v);i++){
data_t val;
get_vec_element(v,i,&val);
*dest = *dest OP val;
}
}

传统DRAM
循环体每执行一次，就会调用一次函数vec_length,但数组的长度是不变的，那么可以考虑将vec_length移出循环体来提升效率

void combine2(vec_ptr v,data_t *dest){
long i;
long length=vec_length(v);//vec长度重复调用
*dest = IDENT;
for(i=0;i<length;i++){
data_t val;
get_vec_element(v,i,&val);
*dest = *dest OP val;
}
}

减少过程调用

data_t *get_vec_start(vec_ptr v){
return v->data;
}
void combine3(vec_ptr v,data_t *dest){
long i;
long length = vec_length(v);
data_t *data = get_vec_start(v);
*dest =IDENT;
for(i=0;i<length;i++){
*dest = *dest OP data[i];
}
}

在上一页的代码中，我们消除了循环体中所有的调用，但是实际上，这样的改变不会有带来性能的提升，在整数求和的情况下还会造成性能下降，这是因为内循环中还有其他的操作形成了瓶颈

消除不必要的内存引用

combine3的汇编代码

通过上面的汇编代码可以看到，每次迭代的时候，累积变量的数值都要从内存中读出再写入到内存，这样的读写是很浪费的，而且是可以消除的

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 = IDENT;
for(i=0;i<length;i++){
acc = acc OP data[i];
}
*dest = acc;
}

近期的Intel处理器是超标量的，意思是它可以在每个时钟周期执行多个操作，此外还是乱序的，意思是指令执行的顺序不一定与机器级中的顺序一致

这样的设计会使得处理器能够达到更高的并行度。例如，在执行分支结构的程序时，处理器会采用分支预测技术来预测是否需要选择分支，同时预测分支的目标地址

此外还有一种投机执行技术，意思是处理器会在分支之前执行分支之后的操作，如果预测错误，那么处理器就会将状态充值到分支点的状态

循环展开

所谓循环展开，指的是通过每次增加迭代计算的元素数量来减少循环的迭代次数，考虑如下的程序

void psum1(float a[],float p[],long n){
long i;
p[0] = a[0];
for (i=1;i<n;i++){
p[i] = p[i-1]+a[i];
}
}

通过对psum1进行循环展开，能够使得迭代次数减半

void psum2(float a[],float p[],long n){
long i;
p[0]=a[0];
for(i=0;i<n;i=n-1;i+=2){
float mid_val = p[i-1]+a[i];
p[i] = mid_val;
p[i+1] = mid_val+a[i+1];
}
if(i<n){
p[i] = p[i-1]+a[i];
}
}

---

寄存器溢出

对于循环展开，很自然考虑下面的问题，是否展开的次数越多，性能提升越大。实际上，循环展开需要维护多个变量，一旦展开的次数过多，没有足够的寄存器保存变量，那么就需要将变量保存到内存中，这就导致访存时间消耗增加，即便是在x86-64这样拥有足够多寄存器的架构中，循环也很可能在寄存器溢出之前就达到吞吐量限制，从而无法持续提升性能