【仅供参考】Csapp第六章课后习题答案（欢迎批评指正）

6.22

【答案】 x = 0.5

【解释】

假设磁道延半径均匀分布，则磁道数 = r - x*r = (1 - x) * r，而每个磁道位数 = k * 2πxr;

所以总位数 = k*2πrx * (1-x)*r = 2kπr²x(1-x)，易知x = 0.5时取最大值。

6.23

【答案】

平均寻道时间：T_avg_seek​=4ms

平均旋转时间：T_avg_rotation​ = 0.5*1/15000 *60s/min *1000ms/s= 2ms

平均传送时间：T_avg_transfer =2* T_avg_rotation​ /800 = 0.005ms

总时间：T = 6.005ms

6.24

【答案】

A.最优时间为22ms

B.随机时间为24s

【解释】

A.最优情况，我们假设所有的文件快连续储存，并且在同一柱面。

平均寻道时间：T_avg_seek​=4ms

平均旋转时间：T_avg_rotation​ = 0.5*1/15000 *60s/min *1000ms/s= 2ms

首先计算块数 = 2MB/512字节 = 4000块，根据我们假设的情况只需要一次寻道，需要转4圈，

每一圈的时间T_max_rotation，四圈的总时间= T_max_rotation*4 = 4* 4 = 16ms

第一个块定位时间 = T_avg_seek​+T_avg_rotation = 6s

所以总时间 = 第一个块定位时间+四圈的时间 = 6+16 = 22ms

B.若随机映射，则每次读一个块都需要定位，所以总时间 = 4000*6 = 24s

6.25

【答案】

高速缓存	m	C	B	E	S	t	s	b
1.	32	1024	4	4	64	24	6	2
2.	32	1024	4	256	1	30	0	2
3.	32	1024	8	1	128	22	7	3
4.	32	1024	8	128	1	29	0	3
5.	32	1024	32	1	32	22	5	5
6.	32	1024	32	4	8	24	3	5

【解释】

以第一行为例，b = log₂(B) =  log₂(4) = 2，s =  log₂(S) = 6，t = m-b-s = 32-2-6 = 24

6.26

【答案】

高速缓存	m	C	B	E	S	t	s	b
1.	32	2048	8	1	256	21	8	3
2.	32	2048	4	4	128	23	7	2
3.	32	1024	2	8	64	25	6	1
4.	32	1024	32	2	16	23	4	5

【解释】参考上题

6.27

【答案】

A.命中行0组1地址范围：0x08A4~0x08A7
    命中行1组1地址范围：0x0704~0x0707

B.命中行0组6地址范围：0x1238~0x123B

【解释】

以命中行0组1字节0为例：本题中标记位有8位，索引位有3位，偏移位有2位

       标记位：0x45 二进制表示 ：0100 0101

       索引位：0x1   二进制表示 ：001

       偏移位：0x0   二进制表示 ：00

对应地址为0100 0101 001 00 便于看我们改一下分隔0 1000 1010 0100

所以对应地址为0x08A4，其他的以此类推。

6.28

【答案】

A.没有

B.命中行0组4地址范围：0x18F0-0x18F3

   命中行1组4地址范围：0x00B0-0x00B3

C.命中行0组5地址范围：0x0E34-0x0E37

D.命中行1组7地址范围: 0x1BDC-0x1BDF

【解释】见上题

6.29

A.0 1 偏移位CO，2 3索引位为CI，其余为CT.

B.

操作	地址	命中	读出的值
读	0x834	不命中	——
写	0x836	命中	未知
读	0xFFD	命中	0xC0

【解释】

A.B = 4, 则b（即CO) = 2，S=4，则s(即CI) = 2

B.地址0x834转换为二进制为1000 0011 0100，所以CO为00 = 0，CI为01 = 1，CT为1000 0011 = 83，所以对应到cache为组1，标记83，字节0，此时我们可以看到会发生不命中，接下来会从内存中加载4个字节进来，再读出对应的值，但是值我们未知。题目说内存访问顺序执行，则第二次进行写的时候因为从内存中加载进来4个字节，要写的内容在上一步要读的数据后面两个字节，所以被一同加载了进来，这样写就命中，最后的读命中，内容也易知。

6.30

【答案】

A.B*E*S = 4*4*8=128字节

B.0 1 偏移位CO，2 3 4索引位为CI，其余为CT.

6.31

【答案】

A.0 0111 0001 1010

B.

参数	值
高速缓存块偏移（CO）	0x2
高速缓存组索引（CI）	0x6
高速缓存标记（CT）	0x38
高速缓存命中？	命中
返回的高速缓存字节	0xEB

【解释】

B.对于组相联cache，因为要搜索每一行，找到一个有效行，首先在组6行0，我们找到标记38，但是其有效位为0，所以会继续搜寻，找到行3，标记38，有效位为1，对应偏移量2为0xEB.

6.32

【答案】

A.1 0110 1111 1000

B.略

6.33

【答案】

命中行0：0x1788-0x178B

命中行1：0x16C8-0x16CB

【解释】

注意只有行0与行1有效位为1.

6.34

【答案】

dst数组	列0	列1	列2	列3
行0	m	m	m	m
行1	m	m	m	m
行2	m	m	m	m
行3	m	m	m	m

src数组	列0	列1	列2	列3
行0	m	m	h	m
行1	m	h	m	h
行2	m	m	h	m
行3	m	h	m	h

【解释】

首先我们要明确这个cache的基本参数：b = 4，s = 1，m = 7 (因为内存连续储存，从地址0到地址127，一共128个数，所以需要7位来表示），接下来我们需要明确映射关系，因为这个高速缓存只有32字节，所以当存到32的时候高速缓存就存满了，那么接下来就要回到开头重新存，同理每隔32字节就要从头开始存储（为了便于理解，我把地址列出来，src[0][0]的地址是0，对应二进制也就是00 0 0000（注意此处的间隔，分别是标记位，索引位，偏移位），因为是内存按行存储的所以，存到src[1][3]，就满了，接下来是src[2][0]，地址为32，对应的二进制为01 0 0000，我们观察组索引，和偏移量可以发现，src[0][0]和src[2][0]，映射到同一块高速缓存，同理dst[0][0]（地址为64对应的二进制为10 0 0000，dst[2][0]地址为11 0 0000，观察组索引和偏移量我们可以发现，这俩也映射到cache最头上），那么src[0][0]，src[2][0]，dst[0][0]，dst[2][0]这四个都映射到cache最头上，那么类推就知道src[0][1]，src[2][1]，dst[0][1]，dst[2][1]这四个都映射到cache第一行偏移1的位置，后面也一样类推。

好接下来就开始映射了，首先读src[0][0]，最开始cache是空的，所以未命中，然后就要把src[0][0]加载进来，因为预存，所以后面三个也被加载进来到第一行，然后写dst[0][0]，未命中，那么就要把dst[0][0]的地址加载进来，同样预存，那么src[0][0]以及后面三个就要被覆盖了，接下来读src[0][1]，因为上一步的写dst[0][0]把原本预存的src[0][1]给覆盖了，所以还是未命中，后面就这样推，一样的道理。

6.36

【答案】

dst数组	列0	列1	列2	列3
行0	m	h	h	h
行1	m	h	h	h
行2	m	h	h	h
行3	m	h	h	h

src数组	列0	列1	列2	列3
行0	m	h	h	h
行1	m	h	h	h
行2	m	h	h	h
行3	m	h	h	h

【解释】道理和上面一道题类似，但是这个高速缓存为128字节，能够装下两个数组，所以不会有不同的数组映射到同一块cache，所以每次只有开始的冷不命中，后买三个因为预存所以会命中。

6.36

【答案】

A.100%

B.25%

C.25%

D.不会，组相连的命中率是和你能预存进来的块的个数相关的，行替换是有空行用空行，行数的改变不会影响命中率，影响命中率的其实是块的大小。

E.会，更大的块则预存会会存进来更多的块，那么命中率就会提高。

【解释】

A.因为你一次最多只能加载满这个数组的一行，而在这个循环中是交替读这个数组的两行，所以没读完一次，就会被覆盖，那么每次都不命中。

B.1024字节正好装下所有数组，所以只会发生冷不命中。

C.读数组的第一行，会加载到一个组的第一行，读数组的第二行会加载到同一组的第二行（因为组相联是有空行首先用空行），所以只有每次的冷不命中。

6.37

【答案】

函数	N=64	N=60
sumA	25%	25%
sumB	100%	25%
sumC	50%	25%

【解释】

N = 64就是正常的情况，我们主要讨论N= 60的sumB,sumC

为了便于想，我们给256个块取号从0~255，对于sumB，我们以a[0][0]~a[60][0]的访问为例子，
它的访问顺序为0, 15, 30, 45, 60…255，14，29，44，59…254, 13, 28, 43, 58…254, 12, 27, 42, 57, 72, 87, 102, 117（sumB是按列读取的，因为a[1][0]的地址与a[0][0]相差60，所以在cache中相差15行，对应的块号就是15，后面以此类推，要注意最后读完a[16][0]高速缓存还剩一行，所以再一轮循环，首个要读的块就要减去1，那么就是14，后面以此类推）那么我们发现它并不会覆盖前面已经完成预存，所以只有冷不命中。C类推。

个人认为这是一种类似于修正“抖动”的方法，有点像课本P432的修正抖动的方法。

6.38

【答案】

A.16*16*4 = 1024

B.16*16*4*1/8 = 128

C.1/8

【解释】

只有冷不命中

6.39

【答案】

A.16*16*4 = 1024

B.16*16*4*1/4 = 256

C.1/4

【解释】

如果把结构体看作一个整体，则每次都是不命中，但对于每个结构体内会发生冷不命中。

6.40

【答案】

A.1024

B.16*16*1/2+16*16*1/6 = 256

C.1/4

【解释】

第一个循环有一半不命中，第二个循环六个中只有一个不命中

6.41

【答案】

25%

【解释】

因为高速缓存能够容下全部的数组，所以只会发生冷不命中

6.42

【答案】

25%

【解释】

本质上和上题一样，只是循环条件改成了地址的形式

6.43

【答案】

25%

6.44

略

6.45

【答案】我们考虑充分利用写数组，因为前面的写数组都是写一次后就将这部分抛弃掉，

我们假设数据块得到宽度为B，不仅要延展src，而且要对dst进行延展。

#define B chunkdatas_length_of_side
void faster_transpose(int *dst, int *src, int dim)
{
	long limit = dim * dim;
	for (int i = 0; i < dim; i += B)
	{
		for (int j = 0; j < dim; j += B)
		{
			/* Using blocking to improve temporal locality */

			for (int k = i; k < i+B; ++k)
			{
				for (int l = j; l < j+B; ++l)
				{
                    /* independent calculations */
					int d = l*dim + k;
					int s = k*dim + l;
					if (s < limit && d < limit)
					{
						dst[d] = src[s]
					}
				}
			}

		}
	}
}