CS:APP 第5章 优化程序性能 作业

总体感觉掌握的还不是很好，虽然大致思想掌握了，但是还有很多细节感觉比较模糊，等以后再巩固。

5.13

A

数据流

关键路径用粗线标出。

关键路径

B

浮点加法

C

整数加法

D

因为前后两个乘法之间没有依赖，可以并行计算。

5.14

A

因为瓶颈在于整数加法，至少需要一个CPE。

B

因为浮点版本的瓶颈在于浮点数加法，需要三个CPE，相比之下循环索引的整数加法开销就可以忽略了，而循环展开主要减少的是索引的整数加法的消耗，所以提升不大。

5.15

浮点版本的极限是因为浮点加法的容量为1，整数版本的原因不太清楚，我觉得大概率是两个加载单元正好载入两个数导致的。

5.16

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

void inner4(vec_ptr u, vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(u);
    data_t *udata = get_vec_start(u);
    data_t *vdata = get_vec_start(v);
    data_t sum = (data_t)0;

    long limit = length - 5;
    for (i = 0; i < limit; i += 6)
    {
        sum = sum + (udata[i] * vdata[i] + udata[i + 1] * vdata[i + 1] +
                 udata[i + 2] * vdata[i + 2] + udata[i + 3] * vdata[i + 3] +
                 udata[i + 4] * vdata[i + 4] + udata[i + 5] * vdata[i + 5]);
    }
    for (; i < length; i++)
    {
        sum = sum + udata[i] * vdata[i];
    }
    *dest = sum;
}

5.17

void *optimized_memset(void *s, int c, size_t n)
{
    size_t k = sizeof(unsigned long);
    unsigned char c_low = c;
    unsigned long stuff = 0;
    size_t i;
    for (i = 0; i < k; i++)
    {
        stuff |= c << (i * 8);
    }
    
    unsigned char *add = (unsigned char *)s;
    for (; (size_t)add % k; add++)
    {
        *add = c;
    }
    unsigned char *end = (unsigned char *)s + n;
    for (; add + k <= end; add += k)
    {
        *add = stuff;
    }
    for (; add < end; add++)
    {
        *add = c;
    }
    return s;
}

5.18

既然要求CPE接近1，那么需要保证流水线几乎是满的，我这里使用普通的多项式计算方法，关键路径是一次浮点数乘法，CPE为5，容量为2，理论上极限CPE应该为0.5，由于一次迭代需要两个浮点数乘法，所以极限CPE为1，为了达到这个极限必须使用并行积累，在一次循环中计算5个值以充分利用流水线。

double optimized_poly(double a[], double x, long degree)
{
    long i;
    long limit = degree - 4;
    double result = a[0];
    double x1 = x;
    double x2 = x1 * x;
    double x3 = x2 * x;
    double x4 = x3 * x;
    double x5 = x4 * x;
    double xq = x5;
    for (i = 1; i <= limit; i += 5)
    {
        result += a[i] * x1 + a[i + 1] * x2 + a[i + 2] * x3 + a[i + 3] * x4 + a[i + 4] * x5;
        x1 *= xq;
        x2 *= xq;
        x3 *= xq;
        x4 *= xq;
        x5 *= xq;
    }
    for (; i <= degree; i++)
    {
        result += a[i] * x1;
        x1 *= x;
    }
    return result;
}

答案应该是正确的，但不知道效率是否提高到极限。在自己的机器上测了一下，和原版对比，使用-Og编译参数编译，运行速度相差一倍左右。使用-O3编译运行速度无差别。可见效率确实提升了，但无法知道是否已经是极限了。
找了几个网上别人的答案也跑了一下，发现和这个自己写的速度差不多。

5.19

不太明白，试了几个效率都没有明显的提高，网上别人的代码也没提高，不知道什么情况，摸了。

void optimized_psum1a(float a[], float p[], long n)
{
    long i;
    long limit = n - 2;
    float sum = a[0];
    p[0] = sum;

    for (i = 1; i < limit; i += 3)
    {
        float u = a[i];
        float v = u + a[i + 1];
        p[i] = sum + u;
        p[i + 1] = sum + v;
        sum += v + a[i + 2];
        p[i + 2] = sum;
    }

    for (; i < n; i++)
    {
        sum += a[i];
        p[i] = sum;
    }
}