深入理解计算机系统------优化程序性能（2）

1、理解现代处理器
在代码级上，看上去是一次执行一条指令，每条指令都包括从寄存器或内存取值，执行一个操作，并把结果存回到一个寄存器或内存位置。在实际的处理器中，是同时执行多条指令的，这个现象称为指令级并行。多条指令并行地执行，同时又呈现出一种简单的顺序执行的表象。

延迟界限：下一条指令执行之前，这条指令必须结束，当代码中的数据相关限制了处理器利用指令集并行的能力时，延迟界限能够限制程序的性能。
吞吐量界限：刻画了处理器原始单元的原始计算能力，这个界限是程序的终极限制。

2、可以通过以下的方法优化程序的性能，提高并行度
（1）循环展开
循环展开能够从两方面改变程序的性能：首先，它减少了不直接有助于程序结果的操作数量，例如循环索引计算和条件分支。第二，它提供了一些方法，可以进一步变化代码，减少整个计算关键路径上的操作数量。

例如：

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


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

函数psum2（）采用“2x1”循环展开，一个循环每次处理数组的两个元素，也就是每次迭代，循环索引i加2，在一次迭代中，对数组元素i和i+1使用合并运算；循环结束条件改为n-1；最后判断是否加完（为奇数个时没有加完所有元素）。
以此类推，按照“kx1”循环展开时，上限设为n-k+1，每次 i += k。

（2）多个累计变量（提高并行性）
虽然循环展开减少了迭代次数，但是展开后的两个乘法仍然是限制因素，他们相互相关，不能并行，因而增加多个累计变量，提高程序的并行性。

void psum3(float p[], long n)
{
    long i;
    float acc0 = 1;
    float acc1 = 1;
    float acc = 1;
    for (i = 0; i < n - 1; i += 2)
    {
        acc0 = acc0 * p[i];
        acc1 = acc1 * p[i + 1];
    }
    if (i < n)
    {
        acc0 = acc0 * p[i];
    }
    acc = acc0 * acc1;
}

通过增加中间变量，使两个乘法运算能够同时运行（并行），从而提高了程序的性能

（3）重新结合变换

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

void psum4( float p[], long n)
{
    long i;
    float acc = 1;
    for (i = 1; i < n-1; i+=2)
    {
        acc = acc * (p[i] * p[i + 1]);//不需要前一次迭代的累计值就可以执行
    }
    if (i < n)
    {
        acc = acc * p[i];
    }
}

函数psum4看上去跟psum2没有什么区别，但是性能却优化了接近一倍；因为，当将后面 p[i] * p[i + 1] 结合时，可以在上一轮计算acc时同时计算，而不用等待acc的计算结果，所以关键路径上由两个乘法减少为只有一个乘法。

（4）考虑局部性原理的优化
局部性原理
空间局部性：被引用过一次的内存位置很可能在不久的将来再被多次引用。
时间局部性：一个内存位置被引用了一次，在不久的将来很可能引用附近的位置。

有良好的局部性的程序比局部性差的程序运行的更快。

void clear1(point *p, int n)
{
    int i, j;
    for (j = 0; j < 3; j++)
    {
        for (i = 0; i < n; i++)
        {
            p[i].vel[j] = 0;
        }
        for (i = 0; i < n; i++)
        {
            p[i].acc[j] = 0;
        }
    }
}

void clear2(point *p, int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < 3; j++)
        {
            p[i].vel[j] = 0;
            p[i].acc[j] = 0;
        }
    }
}

void clear3(point *p, int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < 3; j++)
        {
            p[i].vel[j] = 0;
        }
        for (j = 0; j < 3; j++)
        {
            p[i].acc[j] = 0;
        }
    }
}

对于上述的三个函数，它们的空间局部性的顺序是：clear1() < clear()2 < clear3()
虽然三个函数实现的功能相同，但是程序的性能却不同，作为程序员，了解机器内部的运行以及一些原理，有利于更好地优化程序。