深入理解计算机系统家庭作业第六章

最新推荐文章于 2024-07-22 17:14:08 发布
最新推荐文章于 2024-07-22 17:14:08 发布
阅读量5k 收藏 14
点赞数 2
分类专栏： 深入理解计算机系统家庭作业 文章标签： 家庭作业 操作系统 计算机 第六章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/phx_storm/article/details/40513989
版权

/*

***6.23

*/

等价于求xr(1 - x)的最大值，由代数知识得x=0.5的时候取得最大。


/*

***6.24

*/

0.5 * 60 / 12000 * 1000 + 60 / 12000 * 1000 /500 + 3 = 5.51ms


/*

***6.25

*/

定位时间 = 3 + 2.5 = 5.5ms

A.     3072 / 500 * 5 + 5.5 = 36.22ms

B.     5.5 * 3072 = 16896ms


6.26,6.27 根据公式C = B * E * S即可推得，此处略之


/*

***6.28

*/

A.     0x1238, 0x1239, 0x123a, 0x123b

B.     0x8a4, 0x8a5, 0x8a6, 0x8a7                       0x704, 0x705, 0x706, 0x707


/*

***6.29

*/

A.     0x1bdc, 0x1bdd, 0x1bde, 0x1bdf

B.     0xe34, 0xe35, 0xe36, 0xe37

C.     0x18f0, 0x18f1, 0x18f2, 0x18f3     0xb0, 0xb1, 0xb2, 0xb3

D.     不会命中


/*

***6.30

*/ 

B.     1.不命中，有效位为0

         2.命中。在1中已加载

         3.命中。值为D0


/*

***6.31

*/

A.     C= E*B*S = 128

B.     CO   最后两位

         CI   除去最后两位的后三位

         CT   前8位


/*

***6.32

*/

A.     0011100011000

B.     CO      0x0

         CI      0x6

         CT      0x38

         没有命中


/*

***6.33

*/

A.     1011011101100

B.     CO      0x0

         CI      0x3

         CT      0xB7

         没有命中

    

/*

***6.34

*/

0x1314, 0x1315, 0x1316, 0x1317

0x1794, 0x1795, 0x1796, 0x1797


/*

***6.35

*/

缓存一共有两个块，src[0],src[2],dst[0],dst[2]访问缓存第一个块，src[1],src[3],dst[1],dst[3]访问缓存第二个块。


dst数组

m  h  m  h

m  m  h  m

m  h  m  h

m  m  h  m


src数组

m  m  m  m 

m  m  m  m

m  m  m  m

m  m  m  m


/*

***6.36

*/

当总大小为128时，能容纳下src与dst数组中的所有元素

dst数组

m  h  h  h

m  h  h  h

m  h  h  h

m  h  h  h


src数组

m  h  h  h

m  h  h  h

m  h  h  h

m  h  h  h


/*

***6.37

*/

A.   x[0][i]和x[1][i]是同一个缓存条目。不命中率为100%，属于交叉不命中

B.   缓存大小可容纳数组所有内容。不命中率为1/8。

C.    x[0][i]和x[1][i]加载到不同行。不命中率为1/8.

D.   不能，存在冷不命中。

E.   能。加大块大小能减小冷不命中概率。


/*

***6.38

*/

N=64时：

sumA:   1/4

sumB:   1

sumC:   1/2


N= 60时：

sumA ,sumB,sumC的缓存不命中率均为   1/4


比较难判断的是N = 60时sumB的缓存不命中率（sumC与sumB是一样的），我写了一个函数返回不命中次数，将形参n赋值60即可。

//高速缓存命中率函数，返回不命中次数
int noHitPercentage(int n)
{
	//不命中的次数
	int result = 0;
	//总共要循环的次数
	int count;
	//存储块的标记位
	int a[256];
	for(int i =0;i < 256;i++)
	{
		a[i] = -1;
	}
	for(int j = 0;j < n;j++)
		for(int i = 0;i < n;i++)
		{
			//求出这个数的相对索引
			count = i * n + j;
			//求这个索引对应的块号
			int blockNo = (count/4) % 256;
			//求出标记t
			int t = (count/4)/256;
			//如果标记位不相等则不明中
			if(t != a[blockNo])
			{
				a[blockNo] = t;
				result++;
			}


		}

		return result;	
}

/*

***6.39

*/

A.   16 * 16 * 4 = 1024

B.   64

C.   1/16


/*

***6.40

*/

A.   1024

B.   256

C.   1/4


/*

***6.41

*/

A.   1024

B.   64 + 64 = 128

C.   1/8


/*

***6.42

*/

25%


/*

***6.43

*/

25%


/*

***6.44

*/

100%


/*

***6.46

*/

void betterTranspose(int *dst,int *src,int dim)
{
<span style="white-space:pre">	</span>int i, j;
<span style="white-space:pre">	</span>int iCount,jCount;


<span style="white-space:pre">	</span>//以4 * 4 的方阵为单位依次计算，增加了写的缓存命中率，多个元素一起读写还减少了循环开销
<span style="white-space:pre">	</span>for(i = 0;i < dim - 3;i += 4)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>iCount = i * dim;
<span style="white-space:pre">		</span>for(j = 0;j < dim - 3;j += 4)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>jCount = j * dim;


<span style="white-space:pre">			</span>dst[jCount + i] = src[iCount + j];      //dst[j][i] = src[i][j]
<span style="white-space:pre">			</span>dst[jCount + i + 1] = src[iCount + dim + j];  //dst[j][i + 1] = src[i + 1][j]
<span style="white-space:pre">			</span>dst[jCount + i + 2] = src[iCount + dim * 2 + j];   //dst[j][i + 2] = src[i + 2][j]
<span style="white-space:pre">			</span>dst[jCount + i + 3] = src[iCount + dim * 3 + j];   //dst[j][i + 3] = src[i + 3][j]


<span style="white-space:pre">			</span>dst[jCount + dim + i] = src[iCount + j + 1];      //dst[j + 1][i] = src[i][j + 1]
<span style="white-space:pre">			</span>dst[jCount + dim + i + 1] = src[iCount + dim + j + 1];  //dst[j + 1][i + 1] = src[i + 1][j + 1]
<span style="white-space:pre">			</span>dst[jCount + dim + i + 2] = src[iCount + dim * 2 + j + 1];   //dst[j + 1][i + 2] = src[i + 2][j + 1]
<span style="white-space:pre">			</span>dst[jCount + dim + i + 3] = src[iCount + dim * 3 + j + 1];   //dst[j + 1][i + 3] = src[i + 3][j + 1]


<span style="white-space:pre">			</span>dst[jCount + dim * 2 + i] = src[iCount + j + 2];      //dst[j + 2][i] = src[i][j + 2]
<span style="white-space:pre">			</span>dst[jCount + dim * 2 + i + 1] = src[iCount + dim + j + 2];  //dst[j + 2][i + 1] = src[i + 1][j + 2]
<span style="white-space:pre">			</span>dst[jCount + dim * 2 + i + 2] = src[iCount + dim * 2 + j + 2];   //dst[j + 2][i + 2] = src[i + 2][j + 2]
<span style="white-space:pre">			</span>dst[jCount + dim * 2+ i + 3] = src[iCount + dim * 3 + j + 2];   //dst[j + 2][i + 3] = src[i + 3][j + 2]


<span style="white-space:pre">			</span>dst[jCount + dim * 3 + i] = src[iCount + j + 3];      //dst[j + 3][i] = src[i][j + 3]
<span style="white-space:pre">			</span>dst[jCount + dim * 3 + i + 1] = src[iCount + dim + j + 3];  //dst[j + 3][i + 1] = src[i + 1][j + 3]
<span style="white-space:pre">			</span>dst[jCount + dim * 3 + i + 2] = src[iCount + dim * 2 + j + 3];   //dst[j + 3][i + 2] = src[i + 2][j + 3]
<span style="white-space:pre">			</span>dst[jCount + dim * 3 + i + 3] = src[iCount + dim * 3 + j + 3];   //dst[j + 3][i + 3] = src[i + 3][j + 3]
<span style="white-space:pre">			</span>
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>//记录当前行和列的索引，以便执行完剩余的项
<span style="white-space:pre">	</span>int curIndex = i;


<span style="white-space:pre">	</span>//处理剩余项，简单的交换处理
<span style="white-space:pre">	</span>for(i = 0;i < curIndex;i++)
<span style="white-space:pre">		</span>for(j = curIndex;j < dim;j++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>dst[j * dim + i] = src[i * dim + j];
<span style="white-space:pre">		</span>}


<span style="white-space:pre">	</span>for(i = curIndex;i < dim;i++)
<span style="white-space:pre">		</span>for(j = 0;j < dim;j++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>dst[j * dim + i] = src[i * dim + j];
<span style="white-space:pre">		</span>}
}



/*

***6.47

*/

void better_col_convert(int *G,int dim)
{
	int i, j;
	int iCount,jCount;

	//以4 * 4 的方阵为单位依次计算，增加了写的缓存命中率，多个元素一起读写还减少了循环开销
	for(i = 0;i < dim - 3;i += 4)
	{
		iCount = i * dim;
		for(j = 0;j < dim - 3;j += 4)
		{
			jCount = j * dim;

			G[jCount + i] = G[iCount + j] || G[jCount + i];      //G[j][i] = G[i][j] || G[j][i]
			G[jCount + i + 1] = G[iCount + dim + j] || G[jCount + i + 1];  //G[j][i + 1] = G[i + 1][j] || G[j][i + 1]
			G[jCount + i + 2] = G[iCount + dim * 2 + j] || G[jCount + i + 2];   //G[j][i + 2] = G[i + 2][j] || G[j][i + 2]
			G[jCount + i + 3] = G[iCount + dim * 3 + j] || G[jCount + i + 3];   //G[j][i + 3] = G[i + 3][j] || G[j][i + 3]

			G[jCount + dim + i] = G[iCount + j + 1] || G[jCount + dim + i];      //G[j + 1][i] = G[i][j + 1] || G[j + 1][i]
			G[jCount + dim + i + 1] = G[iCount + dim + j + 1] || G[jCount + dim + i + 1];  //G[j + 1][i + 1] = G[i + 1][j + 1] || G[j +1][i + 1]
			G[jCount + dim + i + 2] = G[iCount + dim * 2 + j + 1] || G[jCount + dim + i + 2];   //G[j + 1][i + 2] = G[i + 2][j + 1] || G[j +1][i + 2]
			G[jCount + dim + i + 3] = G[iCount + dim * 3 + j + 1] || G[jCount + dim + i + 3];   //G[j + 1][i + 3] = G[i + 3][j + 1] || G[j + 1][i + 3]

			G[jCount + dim * 2 + i] = G[iCount + j + 2] || G[jCount + dim * 2 + i];      //G[j + 2][i] = G[i][j + 2] || G[j +2][i]
			G[jCount + dim * 2 + i + 1] = G[iCount + dim + j + 2] || G[jCount + dim * 2 + i +1];  //G[j + 2][i + 1] = G[i + 1][j + 2] || G[j +2][i + 1]
			G[jCount + dim * 2 + i + 2] = G[iCount + dim * 2 + j + 2] || G[jCount + dim * 2 + i + 2];   //G[j + 2][i + 2] = G[i + 2][j + 2] || G[j +2][i + 2]
			G[jCount + dim * 2+ i + 3] = G[iCount + dim * 3 + j + 2] || G[jCount + dim * 2 + i + 3];   //G[j + 2][i + 3] = G[i + 3][j + 2] || G[j + 2][i + 3]

			G[jCount + dim * 3 + i] = G[iCount + j + 3] || G[jCount + dim * 3 + i];      //G[j + 3][i] = G[i][j + 3] || G[j +3][i]
			G[jCount + dim * 3 + i + 1] = G[iCount + dim + j + 3] || G[jCount + dim * 3 + i + 1];  //G[j + 3][i + 1] = G[i + 1][j + 3] || G[j +3][i + 1]
			G[jCount + dim * 3 + i + 2] = G[iCount + dim * 2 + j + 3] || G[jCount + dim * 3 + i + 2];   //G[j + 3][i + 2] = G[i + 2][j + 3] || G[j + 3][i + 2]
			G[jCount + dim * 3 + i + 3] = G[iCount + dim * 3 + j + 3] || G[jCount + dim * 3 + i + 3];   //G[j + 3][i + 3] = G[i + 3][j + 3] || G[j + 3][i + 3]

		}
	}

	//记录当前行和列的索引，以便执行完剩余的项
	int curIndex = i;

	//处理剩余项，简单的交换处理
	for(i = 0;i < curIndex;i++)
		for(j = curIndex;j < dim;j++)
		{
			G[j * dim + i] = G[i * dim + j] || G[j * dim + i];
		}

		for(i = curIndex;i < dim;i++)
			for(j = 0;j < dim;j++)
			{
				G[j * dim + i] = G[i * dim + j] || G[j * dim + i];
			}
}


phx_storm
关注
专栏目录
深入理解计算机系统第三版 家庭作业第六章6.38-6.40参考答案和测试程序
a764695611的博客
05-10 378
测试程序：可直接运行 #include <iostream> using namespace std; #define line 64 unsigned calc_address(unsigned head, int i, int j, int N,int bias) { return head + i * N * 16 + j * 16 + bias * 4; } unsigned calc_line(unsigned add, int block_size) { return (ad
深入理解计算机系统（第三版）第6章 家庭作业
weixin_42916038的博客
03-01 5302
若有错误，还望各位不吝赐教~ 6.22 由题意可知： 每条磁道位数 = 2 * Π * x * r 假设每单位的长度为一个磁道 则总的磁道数 = r - x * r 故有磁盘容量 = 2 * Π * r * r * x * (1 - x) 故当x = 1/2时，磁盘有最大容量 6.23 由图可知： Tavg seek = 4 ms 由公式可得： Tavg rotation = 1/2 Tmax ...
深入理解计算机系统（第三版）家庭作业 第六章
RivaJ的博客
07-14 1294
《深入理解计算机系统（第三版）》家庭作业答案，望指正
零基础入门网络安全必看的5本书籍（附PDF)_web应用安全 教材
最新发布
wholeliubei的博客
07-22 337
书中自有黄金屋，书中自有颜如玉。很多人学习一门技术都会看大量的书籍，经常也有朋友询问：零基础刚入门，应该看哪些书？应该怎么学？等等问题。今天就整理了5本零基础入门网络安全必看书籍，希望能帮到每一位认真学习网络安全的朋友！（文末有领取方式）
深入理解计算机系统——第六章
a12b345c6789的博客
12-03 569
存储器 磁盘 磁盘可以存储大量的数据，但是速度慢 磁盘由盘片组成，每个盘片有两面，上面覆盖着磁性记录材料，盘片中央有一个可以旋转的主轴 转载于:https://www.cnblogs.com/ifannie/p/10058181.html...
《深入理解计算机系统》家庭作业
weixin_30600197的博客
11-04 750
第二章、第七章 选题：2.63、2.75、3.54、3.58、3.59、7.11 合作伙伴： 20135317韩玉琪：第二章、第七章习题 20135337朱荟潼：第三章习题 合作方式：分别研究题目，互相讲解，分工发博客。 家庭作业2.63 题目： 解答思路及代码： 运行: 家庭作业2.75 题目： 解答思路： - 根据补码乘法公式与无符号乘法模2^w比较： - 补码乘法和无符号乘法的...
深入理解计算机系统第六章家庭作业之6.35 6.36
weixin_30590285的博客
10-23 288
6.35 解题过程 对于写分配的高速缓存，每次写不命中时，需要读取数据到高速缓存中。 该高速缓存只有2个组，对于相同的i,j，src[i][j]和dst[i][j]对应相同的组。 src[0] src[2] 对应组0； src[1] src[3] 对于组1。 dst同src。 dst数组 　 列0 列1 列2 列3 行0 m h m h 行1 m m h m 行2 m h m h 行3 m m h...
《深入理解计算机系统》家庭作业的答案
01-30
《深入理解计算机系统》是一本将程序设计者视角下计算机系统的各个方面介绍得十分详尽的经典教材。读者通过阅读这本书，可以对计算机硬件、操作系统、编译器等多个层次有一个全面而深刻的认识。在学习过程中，课后题...
深入理解计算机系统家庭作业答案instructor-solutions
07-26
根据提供的文件信息，以下内容将详细展开介绍《深入理解计算机系统》家庭作业答案的各个章节的知识点。 《深入理解计算机系统》是一本计算机科学领域的经典教材，它深入探讨了计算机系统的设计和实现，以及系统软件...
深入理解计算机系统第三版 家庭作业第六章6.37参考答案和测试程序
a764695611的博客
05-10 625
6.37 答案： 函数 N=64 N=60 sumA 25% 25% sumB 100% 25% sumC 50% 25% 参考程序：可以直接运行 #include <iostream> using namespace std; #define line 256 unsigned calc_address(unsigned head, int i, int j, int N); unsigned calc_address(unsigned head, int i,
csapp2e 家庭作业 6.34
深入理解计算机系统 第二版 家庭作业 解答
07-19 1876
0x1314 0x1315 0x1316 0x1317 0x1794 0x1795 0x1796 0x1797
CSAPP的前六章题库与答案
05-23
CSAPP深入理解计算机系统各章节的题库，附答案。比较适合一些同学复习刷题用
深入理解计算机系统第三版答案
04-06
深入理解计算机系统第三版答案
CSAPP第六章家庭作业（原书第二版）
无知亦乐
01-14 1950
6.32 A：地址格式 因为地址宽13位且题目所给地址为0x0718，转换成二进制表示为 0 0111 0001 1000，填下表： B：存储器引用 由题S=8，E=4,B=4,m=13所以s=3,b=2,t=m-(s+b)=8,0-1位是块偏移，2-4位是组索引，5-12是标记位，故根据题A中二进制地址表示可知，CO为00，CI为110，CT为00111000,由题中所给高速缓存表查看索引为0x6、标记位为0x38、块偏移量为0x0的数据为FA，命中。填下表： 6.33 A：地址格式 因为地址宽1
第六章作业
hao19980524的博客
09-05 510
二.1.说明在循环结构中break语句和continue语句的区别。 答： continue语句只结束本次循环，而不是终止整个循环的执行。 break语句则是结束整个循环过程，不再判断执行循环的条件是否成立 2.使用for循环结构实现:从键盘上接收从周一至周五明天的学习时间（以小时为单位），并计算每日平均学习时间。输出结果如图6.12所示。 答： 3.鸡兔同笼是我国古代著名的趣题之一。大约...
CSAPP 第三版 第六章 家庭作业and so on
weixin_43172803的博客
12-05 2936
CSAPP 第三版 第六章 家庭作业 自己做的 仅供参考 可能出现错误 注：5.18 5.19 mark一下 6.22 假设磁道沿半径均匀分布，即总磁道数和(1-x)r成正比，则设磁道数为k(1-x)r；故2πkx(1-x)r2，从而x = 0.5时最大 6.23 Tavg seek = 4 ms Tavg rotation = (1 / 2) * (1 / 15000 RPM) × (60s /...
深入理解计算机系统（csapp）家庭作业——第六章存储器层次结构
醉等佳人归
03-04 2684
6.22 磁盘容量 = 磁道数 * 一个磁道上的位数 = (1-x)*r*k2πr (k为比例因子) 由此可知当x=0.5时磁盘容量最大 6.23 平均旋转延迟： T_arg_rotation = 1/2 * T_max_rotation = 1/2 * 60s/15000 RPM * 1000ms/s = 2ms 平均传送时间： T_arg_tranfer = 60s/15...
csapp2e 家庭作业 6.28 6.29
深入理解计算机系统 第二版 家庭作业 解答
07-19 1973
顺序列出所有八个组的命中地址 0 0x120 0x121 0x122 0x123 1 0x8a4 0x8a5 0x8a6 0x8a7 0x704 0x705 0x706 0x707 2 3 0x64c 0x64d 0x64e 0x64f 4 0x18f0 0x18f1 0x18f2 0x18f3 0xb0 0xb1 0xb2 0xb3 5 0xe34 0xe35 0xe36 0xe3
csapp2e 家庭作业 6.36
深入理解计算机系统 第二版 家庭作业 解答
07-26 1765
因为高速缓存能装下两个数组，所以只有冷不命中 dst 和 src都是 m h h h m h h h m h h h m h h h
深入理解计算机系统：课后习题答案解析
"深入理解计算机系统习题答案，包含清晰的PDF课后家庭作业答案和代码，适合自学《深入理解计算机系统》这本书。" 在《深入理解计算机系统》这本书中，作者Randal E. Bryant和David R. O’Hallaron为我们揭示了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值