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

1、优化编译器的能力和局限性
（1）编译器有自己能够优化程序的能力，但会有局限性。
●指针指向内存的同一位置：
例如：

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

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

函数twiddle1需要6次内存引用（2次读*xp，2次读*yp，2次写*xp），而函数twiddle2只需要3次内存引用（读*xp，读*yp，写*xp），所以twiddle2的执行会更加有效。

但是，考虑到xp和yp相等的情况（即内存引用同一个地方，指针指向同一个地址），两个函数的执行结果将不相等。

twiddle1将执行以下计算：

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

计算结果为xp增加4倍。

twiddle2将执行以下计算：

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

计算结果为*xp增加3倍。

这时，编译器不会知道xp和yp是否相等，所以会考虑它们可能相等的情况，便不会产生优化的版本，这限制了可能的优化策略。

●函数调用：

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

函数func1()和func2()似乎是相同的，但是，当调用的函数f()中对全局变量进行了改变后，func1()和func2()得到的结果便会不一样，避免不必要的函数调用，将计算过程改为如下：

long funclin()
{
    long t = count++;
    t += count++;
    t += count++;
    t += count++;
    return t;
}

编译器可以统一对全局变量的更新，产生函数的优化版本如下：

long funclopt()
{
    long t = 4 * count + 6;
    count += 4;
    return t;
}

2、消除循环的低效率
分析下面两个函数的效率：

void lower1(char *s)
{
    long i;
    for (i = 0; i < strlen(s); i++)
    {
        if (s[i] >= 'A'&&s[i] <= 'z')
            s[i] -= ('A' - 'a');
    }
}

void lower2(char *s)
{
    long i;
    long length = strlen(s);
    for (i = 0; i < length; i++)
    {
        if (s[i] >= 'A'&&s[i] <= 'z')
            s[i] -= ('A' - 'a');
    }
}

很明显，当字符串长度逐渐变长时，lower2的性能便会成为瓶颈，而且，编译器并不知道strlen(s)的结果是否会变化（当循环里面有对于字符串从零变成非零或是从非零变成零时，长度会变化），便不会进行优化，需要我们手动进行优化。

3、消除不必要的循环引用
将循环内的指针使用尽可能的放在循环外面，例如：

void combine1()
{
    for (i = 0; i < length; i++)
    {
        *dest = *dest + data[i];
    }
}
void combine2()
{
    data_t *dest;
    data_t acc;
    for (i = 0; i < length; i++)
    {
        acc = acc + data[i];
    }
    *dest = acc;
}

上面两个函数中，combine1()循环内每次对内存进行两次读一次写（在机器代码中，指针的地址是存放在寄存器中，需要通过寄存器中的地址找到相应的位置，再找到相应的数），而combine2()则减少为一次读（对data数组的访问）