1.1
个人电脑、服务器、个人移动设备、超级计算机、嵌入式计算机等
1.2
a. 采用流水线提高性能
b. 通过冗余提高可靠性
c. 采用预测提高性能
d. 加速大概率事件
e. 存储器层次
f. 通过并行提高性能
g. 面向摩尔定律的设计
h, 使用抽象简化设计
这道题的题目和solution都很奇怪。先存疑。
1.3
由编译器转化为汇编语言后进一步由汇编器生成平台相关的二进制机器指令。
目前大部分编译器都是直接生成到机器指令。
1.4
a
\[n=1280\times1024\times8\div8\times3=3932160\ bytes
\]
b
\[t=1280\times1024\times8\times3\div10^8=0.3145728\ s=314.5728\ ms
\]
注意题目表达的意思是：每种基色占用8个字节，而不是三个基色一共占8个字节。CSS中的16进制颜色中，事实上也是每种基色占用8个字节，如#FFCC00。所以最终\(n\)和\(t\)都要\(\times 3\)。
1.5
a
\[平均每条指令时钟周期数CPI=\frac{程序总执行时间t\times 时钟频率f}{总指令个数n} \\
每秒钟执行的指令数目（以百万计）MIPS=\frac{n}{10^6t}=\frac{f}{10^6CPI} \\
MIPS_1=\frac{3\times10^9}{10^6\times1.5}=2\times10^3 \\
MIPS_2=\frac{2.5\times10^9}{10^6\times1.0}=2.5\times10^3 \\
MIPS_3=\frac{4\times10^9}{10^6\times2.2}=1.82\times10^3 \\
\]
可见，这种标准下第二个处理器P2具有最优性能。
b
\[时钟周期数n_c=\frac{t}{CPU时钟周期T}=t\times f \\
n=\frac{n_c}{CPI}
\]
于是，时钟周期数：
\[n_{c1}=t\times f_1=10\times3\times10^9=3\times10^{10}\ 个 \\
n_{c2}=t\times f_2=10\times2.5\times10^9=2.5\times10^{10}\ 个 \\
n_{c3}=t\times f_3=10\times4\times10^9=4\times10^{10}\ 个 \\
\]
指令数目：
\[n_1=\frac{n_{c1}}{CPI_1}=3\times10^{10}\div 1.5=2\times10^{10} \\
n_2=\frac{n_{c2}}{CPI_2}=2.5\times10^{10}\div 1.0=2.5\times10^{10} \\
n_3=\frac{n_{c3}}{CPI_3}=4\times10^{10}\div 2.2=1.82\times10^{10}
\]
c
假设新的时钟频率为\(n'_c\)。在整个过程中，总指令个数\(n\)不变。根据题意以及关系可知，
\[\frac{CPI'}{CPI}=1.2=\frac{t'\times f'}{t\times f}
\]
由于：
\[t'=0.7\times t
\]
可知：
\[f'=\frac{t}{t'}\times f\times1.2=\frac{12f}{7}
\]
所以，每一个处理器的频率需要分别达到：
\[f_1=5.14\ GHz\\
f_2=4.28\ GHz\\
f_2=6.85\ GHz
\]
1.6
a
\[CPI_1=10\%\times1+20\%\times2+50\%\times3+20\%\times3=2.6 \\
CPI_2=10\%\times2+20\%\times2+50\%\times2+20\%\times2=2.0 \\
\]
b
\[时钟周期数目n_c=CPI\times 指令总数n \\
n_{c1}=CPI_1\times n=2.6\times10^6\ 条 \\
n_{c2}=CPI_1\times n=2.0\times10^6\ 条
\]
1.7
a
\[CPI=\frac{程序总执行时间t}{时钟周期T\times指令个数n} \\
CPI_1=\frac{1.1}{10^{-9}\times1\times10^9}=1.1 \\
CPI_2=\frac{1.5}{10^{-9}\times1.2\times10^9}=1.25
\]
b
\[f=\frac{CPI\times n}{t} \\
\frac{f_1}{f_2}=\frac{CPI_1\times n_1}{CPI_2\times n_2}=\frac{1.1\times1.0\times10^9}{1.25\times1.2\times10^9}=0.73
\]
c
\[new相对old的加速比r=\frac{t_{old}}{t_{new}}=\frac{T\times CPI_{old}\times n_{old}}{T\times CPI_{new}\times n_{new}}=\frac{CPI_{old}\times n_{old}}{CPI_{new}\times n_{new}} \\
所以新的编译程序相对A的加速比
r_A=\frac{1.0\times10^9\times1.1}{0.6\times10^9\times1.1}=1.67 \\
r_B=\frac{1.2\times10^9\times1.25}{0.6\times10^9\times1.1}=2.27
\]
这题翻译有问题。首先b问假定在两个不同的处理器上运行。而a中假定的是相同的两个处理器。如果不说明b和a中所述的处理器只有时钟频率不同（特别是要说明指令的实现方式不影响CPI），CPI可能会有变化，理论上是无法计算本题的。
1.8
1.8.1
\[功耗P=\frac{1}{2}\times 负载电容量C\times 电压V^2\times f
\]
所以，
\[C_1=\frac{2P}{V^2f}=\frac{2\times90}{1.5625\times3.6\times10^9}=3.2\times10^{-8}\ F \\
C_2=\frac{2P}{V^2f}=\frac{2\times40}{0.81\times3.4\times10^9}=2.9\times10^{-8}\ F
\]
1.8.2
\[P_{静1}:P_{总1}=1:10 \\
P_{静1}:P_{动1}=1:9 \\
P_{静2}:P_{总2}=3:7 \\
P_{静2}:P_{动2}=3:4
\]
1.8.3
第三小问正确的做法后面更新。漏电流指的是设备上电后没有信号改变的情况下就有的电流。漏电流导致的功耗被称为静态功耗。
1.9
1.9.1
\[执行时间t=\frac{每个指令的时钟周期数CPI}{时钟频率f}\times 指令个数n
\]
所以，对于多核的情况
\[t_总=\frac{CPI_{算数}}{0.7pf}\times n_{算数}+\frac{CPI_{l/s}}{0.7pf}\times n_{l/s}+\frac{CPI_{分支}}{f}\times n_{分支}
\]
单核的情况，
\[t_总=\frac{CPI_{算数}}{f}\times n_{算数}+\frac{CPI_{l/s}}{f}\times n_{l/s}+\frac{CPI_{分支}}{f}\times n_{分支}
\]
计算得到
\[t_1=\frac{1}{2}\times10^{-9}\times(1\times2.56\times10^9+12\times1.28\times10^9+5\times2.56\times10^8)=9.6\ s \\
t_2=\frac{1}{2}\times10^{-9}\times(\frac{1\times2.56\times10^9}{1.4}+\frac{12\times1.28\times10^9}{1.4}+5\times2.56\times10^8)=7.04\ s \\
t_4=\frac{1}{2}\times10^{-9}\times(\frac{1\times2.56\times10^9}{2.8}+\frac{12\times1.28\times10^9}{2.8}+5\times2.56\times10^8)=3.84\ s \\
t_8=\frac{1}{2}\times10^{-9}\times(\frac{1\times2.56\times10^9}{5.6}+\frac{12\times1.28\times10^9}{5.6}+5\times2.56\times10^8)=2.24\ s \\
\]
1.9.2
CPI加倍后，
\[t'_1=\frac{1}{2}\times10^{-9}\times(2\times2.56\times10^9+12\times1.28\times10^9+5\times2.56\times10^8)=10.88\ s \\
t'_2=\frac{1}{2}\times10^{-9}\times(\frac{2\times2.56\times10^9}{1.4}+\frac{12\times1.28\times10^9}{1.4}+5\times2.56\times10^8)=7.95\ s \\
t'_4=\frac{1}{2}\times10^{-9}\times(\frac{2\times2.56\times10^9}{2.8}+\frac{12\times1.28\times10^9}{2.8}+5\times2.56\times10^8)=4.29\ s \\
t'_8=\frac{1}{2}\times10^{-9}\times(\frac{2\times2.56\times10^9}{5.6}+\frac{12\times1.28\times10^9}{5.6}+5\times2.56\times10^8)=2.46\ s \\
\]
可见核数大的情况下，CPI的增长被均分了。核数越大影响越小。
1.9.3
设应该将CPI降低为\(x\)。
\[t'=\frac{1}{2}\times10^{-9}\times(1\times2.56\times10^9+x\times1.28\times10^9+5\times2.56\times10^8)=4.29\ s
\]
\[x=3.70
\]
于是应该将CPI值降低为\(3.70\)。
1.10
1.10.1
芯片生产单位具有芯片成品率计算经验公式
\[成品率r=\frac{1}{(1+\frac{单位面积的瑕疵数n\times芯片面积S}{2})^2}
\]
所以
\[r_1=\frac{1}{(1+\frac{0.020\times\pi\times7.5^2/84}{2})^2}=0.96 \\
r_2=\frac{1}{(1+\frac{0.031\times\pi\times10^2/100}{2})^2}=0.91
\]
1.10.2
芯片价格的计算方式为
\[芯片价格P=\frac{每晶圆价格P_晶}{芯片个数n芯\times 芯片成品率r}
\]
所以，
\[P_1=\frac{12}{84\times0.96}=0.15 \\
P_2=\frac{15}{100\times0.91}=0.16
\]
1.10.3
1.10.4
3、4两问后面更新。
1.11
1.11.1
\[CPI=\frac{t}{Tn}=\frac{750}{0.333\times10^{-9}\times2.38\times10^{12}}=0.95
\]
1.11.2
\[s=\frac{t_{参考}}{t_{执行}}=\frac{9650}{750}=12.87
\]
1.11.3
\[t=CPI\times T\times n
\]
其中，\(CPI\)和\(T\)都不变，\(n\)增加\(10\%\)，于是\(t\)也增加\(10%\)，所以变多的时间为
\[\Delta t=10\%\times0.333=0.0333\ ns
\]
1.11.4
\[\Delta t'=(1.05\times1.1-1)t=0.0517\ ns
\]
1.11.5
SPEC分值将会降低
\[(1-1/(1.05\times1.1))\times100\%=13\%
\]
1.11.6
\[CPI=\frac{tf}{n}=\frac{700\times4\times10^9}{85\%\times2.38\times10^{12}}=1.38
\]
1.11.7
不相同。指令数目和CPU时间也都发生变化了。
1.11.8
CPU时间减小了
\[\frac{750-700}{750}\times100\%=6.67%
\]
1.11.9
执行时间降低为
\[t=90\%\times960\times10^{-9}\ s=8.64\times10^{-7}\ s
\]
CPI为
\[CPI=1.61
\]
时钟频率为
\[f=4\times10^9Hz
\]
于是，指令总个数
\[n=\frac{tf}{CPI}=2146.5\ 条
\]
1.11.10
进一步减小，由于\(n\)、\(CPI\)都不变，而
\[t=\frac{n\times CPI}{f}
\]
要将\(t\)变为原来的\(90\%\)，只需要将\(\frac{1}{f}\)变为原来的\(90\%\)。
于是得到
\[f'=\frac{f}{0.9}=3.33\ GHz
\]
1.11.11
\[f'=\frac{n\times 85\%\times CPI}{80\%\times t}=1.0625f=3.1875\ GHz
\]
这题翻译的也很糟糕。10、11里面的旧的时钟频率是取第9问里面的3Ghz。需要注意，1.11.3、1.11.4最好使用相对原时间的改变比率来作为时间减少了多少的衡量，而不要使用具体数字。
1.12
1.12.1
这种想法不正确。
\[t=\frac{CPI\times n}{f}
\]
\[t_1=\frac{0.9\times5\times10^9}{4\times10^9}=1.125\ s\\
t_2=\frac{0.75\times1\times10^9}{3\times10^9}=0.25\ s
\]
很明显，第一个处理的时钟周期虽然快，但是指令总数很大，且CPI也较大。所以最终第一个处理器还是比第二个处理器执行时间长。
1.12.2
\[t_1=\frac{0.9\times1\times10^9}{4\times10^9}=0.225\ s\\
\]
\[n=\frac{t_1\times f}{CPI}=\frac{0.225\times3\times10^9}{0.75}=0.9\times10^9
\]
P2使用相同的时间只能执行更少的指令。而P1执行的指令个数更多，花费的时间和P2是一样的。
1.12.3
\[MIPS=\frac{n}{t\times10^6}
\]
所以，
\[MIPS_1=\frac{5\times10^9}{1.125\times10^6}=4444.44 \\
MIPS_2=\frac{1\times10^9}{0.25\times10^6}=4000.00 \\
\]
第二个处理器的MIPS小，但是在这里运行时间更短。因为才用第二个处理器的指令个数更少。
1.12.4
\[MFLOPS_1=\frac{5\times10^9\times40\%}{1.125\times10^6}=1777.78 \\
MFLOPS_2=\frac{1\times10^9\times40\%}{0.25\times10^6}=1600 \\
\]
1.13
1.13.1
\[t'=80\%\times70+(250-70)=56+180=236 \\
减少了5.6\%
\]
1.13.2
总时间变为
\[t_总=250\times0.8=200 \\
t_{当前整数操作}=200-70-85-40=5 \\
t_{之前整数操作}=250-70-85-40=55 \\
减少90.91\%
\]
1.13.3
即使假设分支指令的时间减小到\(0\)，其他指令的时间都将达到\(210\ s\)。所以不可实现。这是因为阿姆达尔定律（Amdahl定律）在起作用。
1.14
\[t_1=\frac{50\times10^6\times1}{2\times10^9}=0.025\ s \\
t_2=\frac{110\times10^6\times1}{2\times10^9}=0.055\ s \\
t_3=\frac{80\times10^6\times4}{2\times10^9}=0.160\ s \\
t_4=\frac{16\times10^6\times2}{2\times10^9}=0.016\ s
\]
1.14.1
\[t_1+t_2+t_3+t_4=2(x+t_2+t_3+t_4) \\
解出来x=-0.103<0，所以不可能实现。
\]
1.14.2
\[t_1+t_2+t_3+t_4=2(t_1+t_2+x+t_4) \\
x=0.032
\]
解得CPI为0.8。
1.14.3
\[t_1=\frac{50\times10^6\times0.6}{2\times10^9}=0.015\ s \\
t_2=\frac{110\times10^6\times0.6}{2\times10^9}=0.033\ s \\
t_3=\frac{80\times10^6\times2.8}{2\times10^9}=0.112\ s \\
t_4=\frac{16\times10^6\times1.4}{2\times10^9}=0.011\ s
\]
总时间
\[t'=0.171
\]
减小了33.2%
1.15
加速比
\[speed\_up=\frac{t_{before}}{t_{after}}
\]
\[t_2=100/2+4=54\ s \\
t_4=100/4+4=29\ s \\
t_8=100/8+4=16.5\ s \\
t_{16}=100/16+4=10.25\ s \\
t_{32}=100/32+4=7.125\ s \\
t_{64}=100/64+4=5.5625\ s \\
t_{128}=100/128+4=4.78125\ s
\]
| 核数 | 时间 | 加速比 | 理想加速比 | 加速比:理想加速比 |
|---|---|---|---|---|
| 2 | 54s | 1.85 | 2 | 92% |
| 4 | 29s | 3.44 | 4 | 86% |
| 8 | 16.5s | 6.06 | 8 | 75% |
| 16 | 10.25s | 9.75 | 16 | 60% |
| 32 | 7.125s | 14.03 | 32 | 43% |
| 64 | 5.5625s | 17.97 | 64 | 28% |
| 128 | 4.78125s | 20.91 | 128 | 16% |
