总体感觉掌握的还不是很好，虽然大致思想掌握了，但是还有很多细节感觉比较模糊，等以后再巩固。
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;
}
}
