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

最新推荐文章于 2024-10-09 16:26:33 发布
最新推荐文章于 2024-10-09 16:26:33 发布
阅读量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 392
测试程序：可直接运行 #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
scau：《深入理解计算机系统》家庭作业第二章
zero_019的博客
09-28 663
1.最低有效字节：因为十六进制中，以F为例，一个F表示4个二进制位。进制的位数从右往左开始数，所以最低是在右边。这样00000000（二进制）就可以判断为真（产生1），并且具有唯一性。D.是B和C的变式，这里采用了移位的方式，将最高有效字节移到最低有效字节的位置，再提取。C.是A的变式，加了一个提取最低有效字节的操作。2.我觉得这道题目使用^或者|都是对的。2.&：只有都为1时才为1 |：只有都为0时才为0。，即左边第一个 1 保持为 1，其他位为 0。编号，最右边的位是第 0 位，依次向左递增。
深入理解计算机系统（第三版）家庭作业 第六章
RivaJ的博客
07-14 1392
《深入理解计算机系统（第三版）》家庭作业答案，望指正
深入理解计算机系统阅读笔记-第六章
最新发布
马不停提的专栏
10-09 776
每个行由B个大小为2^b字节的数据块（block）组成，一个有效位（valid bit）指明这个行包含的数据是否有意义，还有t=m-(b+s)个标记位（tag bit）（是当前块的存储器地址 的位子集），它们唯一地标识存储在这个高速缓存行中的块。一个区中的每个磁道都有相同数量的扇区，这个扇区的数量是由该区中最里面的磁道所包含的扇区数确定的。如下图所示：第k+1层被划分成16个固定大小的块，第k层被分成4个块，块的大小和k+1层的大小一样，它包含的是k+1层中编号为4,9,14,3的块的拷贝。
深入理解计算机系统——第六章
a12b345c6789的博客
12-03 577
存储器 磁盘 磁盘可以存储大量的数据，但是速度慢 磁盘由盘片组成，每个盘片有两面，上面覆盖着磁性记录材料，盘片中央有一个可以旋转的主轴 转载于:https://www.cnblogs.com/ifannie/p/10058181.html...
《深入理解计算机系统》家庭作业
weixin_30600197的博客
11-04 765
第二章、第七章 选题：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 294
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
《深入理解计算机系统》是一本将程序设计者视角下计算机系统的各个方面介绍得十分详尽的经典教材。读者通过阅读这本书，可以对计算机硬件、操作系统、编译器等多个层次有一个全面而深刻的认识。在学习过程中，课后题...
深入理解计算机系统（第三版）第6章 家庭作业
weixin_42916038的博客
03-01 5343
若有错误，还望各位不吝赐教~ 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 ...
深入理解计算机系统家庭作业答案instructor-solutions
07-26
根据提供的文件信息，以下内容将详细展开介绍《深入理解计算机系统》家庭作业答案的各个章节的知识点。 《深入理解计算机系统》是一本计算机科学领域的经典教材，它深入探讨了计算机系统的设计和实现，以及系统软件...
深入理解计算机系统第三版 家庭作业第六章6.37参考答案和测试程序
a764695611的博客
05-10 635
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,
CSAPP的前六章题库与答案
05-23
CSAPP深入理解计算机系统各章节的题库，附答案。比较适合一些同学复习刷题用
深入理解计算机系统第三版答案
04-06
深入理解计算机系统第三版答案
csapp2e 家庭作业 6.34
深入理解计算机系统 第二版 家庭作业 解答
07-19 1890
0x1314 0x1315 0x1316 0x1317 0x1794 0x1795 0x1796 0x1797
CSAPP第六章家庭作业（原书第二版）
无知亦乐
01-14 2001
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 527
二.1.说明在循环结构中break语句和continue语句的区别。 答： continue语句只结束本次循环，而不是终止整个循环的执行。 break语句则是结束整个循环过程，不再判断执行循环的条件是否成立 2.使用for循环结构实现:从键盘上接收从周一至周五明天的学习时间（以小时为单位），并计算每日平均学习时间。输出结果如图6.12所示。 答： 3.鸡兔同笼是我国古代著名的趣题之一。大约...
CSAPP 第三版 第六章 家庭作业and so on
weixin_43172803的博客
12-05 2995
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 2733
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 1980
顺序列出所有八个组的命中地址 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
深入理解计算机系统：课后习题答案解析
"深入理解计算机系统习题答案，包含清晰的PDF课后家庭作业答案和代码，适合自学《深入理解计算机系统》这本书。" 在《深入理解计算机系统》这本书中，作者Randal E. Bryant和David R. O’Hallaron为我们揭示了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值