您的位置：首页 > 理论基础

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

2014-10-27 20:16 435 查看
/*

***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">	</sp
4000
an>}

<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];
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签：  家庭作业 操作系统 计算机 第六章
相关文章推荐
新的分享
章节导航