计算机组成与设计(王诚)课后答案第二章

大学计算机第二章习题答案1.简述冯诺依曼体系结构。

采用“存储程序”，即程序和数据一起存储在内存中，计算机按照程序顺序执行，采用二进制表示数据，且计算机由5部分组成：运算器、控制器、存储器、输入设备、输出设备。

2.简述计算机的五大组成部分。

运算器、控制器、存储器、输入设备、输出设备。

3.简述计算机的基本工作原理。

计算机的工作过程是程序执行的过程。

程序是为实现特定目标而用程序设计语言描述的指令序列。

计算机在运行时，先从内存中取出第一条指令，通过控制器的译码分析，并按指令要求从存储器中取出数据进行指定的运算或逻辑操作，然后再按地址把结果送到内存中，接着按照程序的逻辑结构有序地取出第二条指令，在控制器的控制下完成规定操作。

4.什么是流水线技术？作用是什么？流水线技术：将不同指令的各个步骤通过多个硬件处理单元进行重叠操作作用：实现几条指令的并行处理，以加速程序运行进程。

5.ROM和RAM的作用和区别是什么？ROM：只读存储器，主要用于存放计算机的启动程序。

RAM：随机存取储存器，通常所说的内存，RAM里的内容可按其地址随时进行存取。

区别：RAM的特点是数据存取速度较快，但是掉电后数据不能保存。

ROM的数据只能被读取而不能写入，如果要更改，就需要紫外线来擦除。

6.系统软件和应用软件各自的作用是什么？系统软件：控制和维护计算机的正常运行，管理计算机的各种资源，以满足应用软件的需要。

应用软件：完成一个特定的任务，在系统软件的支持下才能运行。

7.总线的概念是什么？简述总线类型。

概念：总线是各部件（或设备）之间传输数据的公用通道。

类型:按功能和规范：数据总线、地址总线、控制总线、扩展总线、局部总线按传输数据的方式：串行总线、并行总线按时钟信号是否独立：同步总线、异步总线8．什么是主板？它主要有哪些部件？各部件之间如何连接？主板：即母板，是微型计算机中最大的一块集成电路板，也是其它部件和各种外部设备的连接载体。

部件：芯片：芯片组、BIOS芯片、集成芯片等插槽/接口：CPU插座、内存条插槽、PCI插槽、PCI-E插槽、SATA接口、键盘/鼠标接口、USB接口、音频接口、HDMI接口。

计算机组成和设计：
《计算机组成和设计》是2004年浙江大学出版社出版的图书，作者是王诚、刘卫东、宋佳兴。

本书主要论述了当代计算机的基本组成原理和设计CPU的方法等。

内容简介：
《计算机组成与设计/新世纪高等院校精品教材》内容包括组成计算机的基本逻辑部件与定时方法;指令系统设计的基本原则，与对现代编译器的支持接口CPU的构成和控制器的设计技术方法，存储体系的构成原理和设计，以及输入输出系统设计等。

书中的举例紧密结合当代计算机先进技术，取材先进、重点突出、叙述深入浅出。

《计算机组成与设计/新世纪高等院校精品教材》可作为理工科大学生学习《计算机组成与设计》课程，或《计算机组成原理》课程的教科书，也可提供从事计算机设计或计算机系统设计的工程技术人员参考。

作者简介：
加州大学伯克利分校计算机科学系教授，美国国家工程研究院院士，lEEE和ACM会员，曾因成功的启发式教育方法被IEEE 授予James H.MIAligan，Jr.教育奖章。

他因为对RISC技术的贡献而荣获1 995年IEEE技术成就奖。

在RAID技术方面的成就为他赢得了1999年lEEE Reyrlold Johnson信息存储奖。

2000年他和John L Henrlessy分享了冯·诺伊曼奖。

斯坦福大学校长，IEEE和ACM会士，美国国家工程研究院
院士及美国科学艺术研究院院士。

Hen rlessy教授因为在RISC 技术方面做出了突出贡献而荣获2001年的Eckert—MatJchly 奖章，他也是2001年SeymIour Cray计算机工程奖得主，并且和David A.Pattersorl分享了2000年的冯·诺伊曼奖。

1.1-1.26qufac dikjo wpnry slgxz tbhme v1.27-1.44jbfji edgcj dcjbf haa3.1、1: t0=02: t1=13: if (a0<t1) t2=1; else t2=04: if (t2= =0) goto finish5: t0=t0+t16: t1=t1+27: jump to loop8: v0=t03.2、Find the element which appears most times, $v0 stores the the maxium number of theidentical integer in the array, $v1 stores its value.3.4、addi $t0,$t1,1003.5、lui $t1,61addi $t1,$t1,2304lw $t2,11($t1)add $t2,$t2,$t0sw $t2,10($t1)3.6、Loop: lw $v1, 0($a0)sw $v1, 0($a1)addi $a0, $a0, 4addi $a1, $a1, 4beq $v1, $zero, Endaddi $v0, $v0, 1j LoopEnd:3.7、1: I format,3: I format,4: I format,5: I format,6: I format,3.8、v0=0;v1=a0;v0++;a1=v1;a0++;a1++;if(v1= =0) goto loop;v0--;3.9、bne $t0,$s5,exitloop: add $t1,$s3,$s3add $t1,$t1,$t1add $s3,$s3,$s6lw $t0,0(t1)beq $t0,$s5,loop exit:3.11、slti $t5,$t0,1bne $t0,1,exitloop: addi $t0,$zero,0add $t4,$t0,$t0add $t4,$t4,$t4lw $t1,0($a0)add $t2,$t4,$t1add $t3,$a1,$t1sw $t2,0($t3)addi $t0,$t0,1slti $t5,$t0,101beq $t5,1,loopexit:3.23、loop: addi $t0,$zero,98lb $t1,0($a0)addi $a0,$a0,1beq $t1,$zero,exitbne $t1,$t0,loopbeq $t1,$t0,nextsub $v0,$a0,1exit: add $v0,$zero,$zeronext:3.24、bcount: addi $sp,$sp,-12sw $ra,8($sp)sw $a0,4($sp)sw $s0,0($sp)add $s0,$zero,$zeroNext: jal bfindadd $a0,$v0,$zerolb $t0,0($a0)beq $t0,$zero,End #encounter nulladdi $s0,$s0,1addi $v0,$v0,1j NextEnd: add $v0,$s0,$zerolw $s0,0($sp)lw $a0,4($sp)lw $ra,8($sp)addi $sp,$sp,12jr $ra4.1、000000000000000000000010000000004.2、111111111111111111111100000000014.4、-5004.5、-14.6、21474836474.10、loop: sub $t3,$zero,$t3slt $t0,$t3,$zerobeq $t0,$zero,loopadd $t2,$t3,$zero how to use 3 instructions?4.13、If A_lower is positive, A_upper_adjusted equals to A_upper.If A_lower is negative, A_upper_adjusted equals to A_upper+1.4.17、addu $t0, $t3,$t4sltu $t2,$t0,$t34.22、srl $t0,$s0,8andi $s1,$t0,40954.23、when it overflew , set should be converted .4.40、xor $s0,$s0,$s1xor $s1,$s1,$s0xor $s0,$s0,$s14.46、ripple carry c1=a0*c0+b0*c0+a0*b0 2Tc2=a1*c1+b1*c1+a1*b1 4Tc3=a2*c2+b2*c2+a2*b2 6TThe worst case : c4=a3*c3+b3*c3+a3*b3 8TCarry look ahead : gi=ai*bi T pi=ai+bi Tc1=c2=c3=c4=3T4.53、4.54、step1 6.42*101=0.642*102step2 9.51*102+0.642*102=10.152*102step3 10.152*102=1.0152*102step4 1.0152*103 is rounded to three significant digits 1.015*1034.55、6.42X101=0.642X1020.642+9.51=10.1526.42X101+9.51X102=10.152X102=1.0152X103so the answer is 1.02X1035.1、RegDst=0 lw sw and branchAluSrc=0 R-format beqMemtoReg=0 R-format sw and beqZero=0 R-format sw and lw5.2、RegDst=1 R-format sw and beqAluSrc=1 lw and swMemtoReg=1 lw sw and beqZero=1 R-format lw and sw5.6、修改两个信号：MemtoReg: 00 :Alu result01 :From Mem data10 :PC+4RegDst: 00 : Instruction[20-16]01 :Instruction[15-11]10 :$ra寄存器5.8、lw $t0 ,$t1,$t25.14、P374页图Instruction a b cR-formatlwswbeqjlongest8 10 10time5.165.17、5.22、jr rsIt is an R-type instruction.So the changes can be made like following .5.24、M1=5*22%+4*11%+4*49%+3*16%+3*2%=4.04M2=4*22%+4*11%+3*49%+3*16%+3*2%=3.33M3=3*22%+3*11%+3*49%+3*16%+3*2%=3So the CPU excution time isT1=CPI*Clockcycletime=4.04/(500*106 )=8.08nsT2=3.33/(400*106 )=8.325nsT3=3/(250*106 )=12nsHence M1 is the fastest machine.5.26、beq $t3,$zero,Exitadd $t3,$t3,$t3add $t3,$t3,$t3 #get 4*$t3add $t3,$t3,$t2 #caculate the address of destination[$t3] loop: lw $t4,0($t1)sw $t4,0($t2)addi $t1,$t1,4addi $t2,$t2,4bne $t2,$t3,loopExit:branch 3 lw 5 and the rest are 4The number of executed instructions is 4+5*100=504The nmber of cycles is3+3*4+(5+4*3+3)*100=20155.27、1. According to the figure above there will be two changes.1>Extend the multiplexor for ALUSrcA by adding ALUout to it .We mark it with 102> We add a multiplexor between B and Memory write data ,connect memory dataregister with the multiplexor and mark it with 1.The multi is controled by the ]signal bcp.2. By making these changes ,we can directly increase the address $t1,$t2,in ALUout by 4When the memory data loading from $t1is read into memory data register, we canquickly write it into memory by setting bcp to 0.3. By estination ,we can cut down clock cycles distinctively by implementing theinstruction in hardware above .The performance increase comes from adding internal registers.7.7、7.8、7.9、212*(32*4+16+1)=580Kb7.11、a. 1+16*10+16*1=177 clock cyclesb. 1+4*10+4*1=45 clock cyclesc. 1+4*10+16*1=57 clock cycles7.12、The CPI of a is 1.2+0.5%*177=2.085The CPI of b is 1.2+0.5%*45=1.425The CPI of c is 1.2+0.5%*57=1.485The processor using wide memory is 2.085/1,425=1.46 times faster than using nerrowand 1.04 times faster than the one using interleaved memories.7.15、AMAT=(1+0.05*20)*2ns=4ns7.20、7.22、7.24、The number of sets in the cache: S/ABThe number of index bits in the address: log2(S/AB)The number of bits needed to implement the cache : Tag =k- log2(S/AB)-log2B7.27、Cache1: X+(4%+0.5*8%)*7=2So,X=1.44Cache2: 1.44+(2%+0.5*5%)*10=1.85Cache3: 1.44+(2%+0.5*4%)*10=1.84Thus,machine1spemds the most cycles on cache mises.7.32、Page size is 16-KB=214B240/214=226Total size of bits 226*(36-14+4)=208MB7.33、Virtual addressCache hit8.1 A 200 1000/5B 150 750/58.2 (1)n*5*(1/1000)+n*(1/10)*(20/1000)=1 n=142(2)5*n*(1/750)+500/5*(1/10)*18*(1/1000)+(5n-500)/5/5/10*25/1000 =1 n=1168.3 7和8距离近的那张图，原因是路程短8.10 a=1+19.7ms/5ns+2+2=3.9*10^6 cyclesb=3.94*10^6*128/4=1.26*10^8cycles) 32/b=50.798/a=12.750.79 12.78.18 17.84。

2 SolutionsSolution 2.12.1.1a.sub f, g, hb.addi f, h, −5 (note, no subi)add f, f, g2.1.2a.1b.22.1.3a.−1b.02.1.4a. f = f + 4b. f = g + h + i2.1.5a.5b.9Solution 2.22.2.1a.sub f, g, fb.addi f, h, −2 (note no subi)add f, f, iS2 ChapterSolutions22.2.2a.1b.22.2.3a.1b.22.2.4a. f += 4;b. f = i − (g + h);2.2.5a.5b.−1Solution 2.32.3.1a.sub f, $0, fsub f, f, gb.sub f, $0, faddi f, f, −5 (note, no subi)add f, f, g2.3.2a.2b.32.3.3a.−3b.−3Chapter 2 Solutions S32.3.4a. f += −4b. f += (g + h);2.3.5a.−3b.6Solution 2.42.4.1a.lw $s0, 16($s6)sub $s0, $0, $s0sub $s0, $s0, $s1b.sub $t0, $s3, $s4add $t0, $s6, $t0lw $t1, 16($t0)sw $t1, 32($s7)2.4.2a.3b.42.4.3a.3b.62.4.4a. f = 2j + i + g;b.B[g] = A[f] + A[1+f];S4 Chapter2Solutions2.4.5a.slli $s2, $s4, 1add $s0, $s2, $s3add $s0, $s0, $s1b.add $t0, $s6, $s0add $t1, $s7, $s1lw $s0, 0($t0)lw $t0, 4($t0)add $t0, $t0, $s0sw $t0, 0($t1)2.4.6a. 5 as written, 5 minimallyb.7 as written, 6 minimallySolution 2.52.5.1a. Address Data20 424 528 332 234 1temp = Array[0]; temp2 = Array[1]; Array[0] = Array[4]; Array[1] = Array[3]; Array[3] = temp; Array[4] = temp2;b. Address Data24 238 432 336 640 1temp = Array[0]; temp2 = Array[1]; Array[0] = Array[4]; Array[1] = temp; Array[4] = Array[3]; Array[3] = temp2;2.5.2a. Address Data20 424 528 332 234 1temp = Array[0];temp2 = Array[1];Array[0] = Array[4];Array[1] = Array[3];Array[3] = temp;Array[4] = temp2;lw $t0, 0($s6)lw $t1, 4($s6)lw $t2, 16($s6)sw $t2, 0($s6)lw $t2, 12($s6)sw $t2, 4($s6)sw $t0, 12($s6)sw $t1, 16($s6)Chapter 2 Solutions S5b. Address Data24 238 432 336 640 1temp = Array[0];temp2 = Array[1];Array[0] = Array[4];Array[1] = temp;Array[4] = Array[3];Array[3] = temp2;lw $t0, 0($s6)lw $t1, 4($s6)lw $t2, 16($s6)sw $t2, 0($s6)sw $t0, 4($s6)lw $t0, 12($s6)sw $t0, 16($s6)sw $t1, 12($s6)2.5.3a. Address Data20 424 528 332 234 1temp = Array[1];Array[1] = Array[5];Array[5] = temp;temp = Array[2];Array[2] = Array[4];temp2 = Array[3];Array[3] = temp;Array[4] = temp2;lw $t0, 0($s6)lw $t1, 4($s6)lw $t2, 16($s6)sw $t2, 0($s6)lw $t2, 12($s6)sw $t2, 4($s6)sw $t0, 12($s6)sw $t1, 16($s6)8 MIPS instructions,+1 MIPS inst. for everynon-zero offset lw/swpair (11 MIPS inst.)b. Address Data24 238 432 336 640 1temp = Array[3];Array[3] = Array[2];Array[2] = Array[1];Array[1] = Array[0];Array[0] = temp;lw $t0, 0($s6)lw $t1, 4($s6)lw $t2, 16($s6)sw $t2, 0($s6)sw $t0, 4($s6)lw $t0, 12($s6)sw $t0, 16($s6)sw $t1, 12($s6)8 MIPS instructions, +1MIPS inst. for every non-zero offset lw/sw pair(11 MIPS inst.)2.5.4a.2882400018b.2705449602.5.5a. Address Data12 ab8 cd4 ef0 12 Address Data 12 12 8 ef 4 cf 0 abb. Address Data12 108 204 300 40 Address Data 12 40 8 30 4 20 010S6 ChapterSolutions2Solution 2.62.6.1a.lw $t0, 4($s7) # $t0 <-- B[1]sub $t0, $t0, $s1 # $t0 <-- B[1] − gadd $s0, $t0, $s2 # f <-- B[1] −g + hb.sll $t0, $s1, 2 # $t0 <-- 4*gadd $t0, $t0, $s7 # $t0 <-- Addr(B[g])lw $t0, 0($t0) # $t0 <-- B[g]addi $t0, $t0, 1 # $t0 <-- B[g]+1sll $t0, $t0, 2 # $t0 <-- 4*(B[g]+1) = Addr(A[B[g]+1])lw $s0, 0($t0) # f <-- A[B[g]+1]2.6.2a.3b.62.6.3a.5b.42.6.4a. f = f – i;b. f = 2 * (&A);2.6.5a.$s0 = −30b.$s0 = 5122.6.6a.Chapter 2 Solutions S7 b.addi $t0, $s6, 4I-type82284add $t1, $s6, $0R-type02209sw $t1, 0($t0)I-type43890lw $t0, 0($t0)I-type35880add $s0, $t1, $t0R-type09816Solution 2.72.7.1a.613566756b.16063037442.7.2a.613566756b.16063037442.7.3a.24924924b.5FBE40002.7.4a.11111111111111111111111111111111b.100000000002.7.5a.FFFFFFFFb.4002.7.6a.1b.FFFFFC00S8 ChapterSolutions2Solution 2.82.8.1a.50000000, overflowb.0, no overflow2.8.2a.B0000000, no overflowb.2, no overflow2.8.3a.D0000000, overflowb.000000001, no overflow2.8.4a.overfl owb.overfl ow2.8.5a.overfl owb.overfl ow2.8.6a.overfl owb.overfl owSolution 2.92.9.1a.no overfl owb.overfl owChapter 2 Solutions S92.9.2a.no overfl owb.no overfl ow2.9.3a.no overfl owb.no overfl ow2.9.4a.overfl owb.overfl ow2.9.5a.94924924b.CFBE40002.9.6a.2492614948b.−809615360Solution 2.102.10.1a.add $s0, $s0, $s0b.sub $t1, $t2, $t32.10.2a.r-typeb.r-type2.10.3a.2108020b.14B4822S10 ChapterSolutions22.10.4a.0x21080001b.0xAD4900202.10.5a.i-typeb.i-type2.10.6a.op=0x8, rs=0x8, rs=0x8, imm=0x0b.op=0x2B, rs=0xA, rt=0x9, imm=0x20Solution 2.112.11.1a.0000 0001 0000 1000 0100 0000 0010 0000twob.0000 0010 0101 0011 1000 1000 0010 0010two2.11.2a.17317920b.390287702.11.3a.add $t0, $t0, $t0b.sub $s1, $s2, $s32.11.4a.r-typeb.i-type2.11.5a.sub $v1, $v1, $v0b.lw $v0, 4($at)2.11.6a.0x00621822b.0x8C220004Solution 2.122.12.12.12.2a.i-type67716total bits = 36b.i-type85516total bits = 342.12.3a.more registers → more bits per instruction → could increase code sizemore registers → less register spills → less instructionsb.more instructions → more appropriate instruction → decrease code sizemore instructions → larger opcodes → larger code size2.12.4a.17367058b.29030482102.12.5a.sub $t0, $t1, $0b.sw $t1, 12($t0)2.12.6a.r-type, op=0x0, rt=0x9b.i-type, op=0x2B, rt=0x8Solution 2.132.13.1a.0xBABEFEF8b.0x11D111D12.13.2a.0xAAAAAAA0b.0x00DD00D02.13.3a.0x00005545b.0x0000BA012.13.4a.0x00014B4Ab.0x000000012.13.5a.0x4b4a0000b.0x000000002.13.6a.0x4b4bfffeb.0x0000003CSolution 2.142.14.1a.lui $t1, 0x003fori $t1, $t0, 0xffe0and $t1, $t0, $t1srl $t1, $t1, 5b.lui $t1, 0x003fori $t1, $t0, 0xffe0and $t1, $t0, $t1sll $t1, $t1, 92.14.2a.add $t1, $t0, $0sll $t1, $t1, 28b.andi $t0, $t0, 0x000fsll $t0, $t0, 14ori $t1, $t1, 0x3fffsll $t1, $t1, 18ori $t1, $t1, 0x3fffor $t1, $t1, $t0 2.14.3a.srl $t1, $t0, 28sll $t1, $t1, 29b.srl $t0, $t0, 28andi $t0, $t0, 0x0007sll $t0, $t0, 14ori $t1, $t1, 0x7fffsll $t1, $t1, 17ori $t1, $t1, 0x3fffor $t1, $t1, $t02.14.4a.srl $t0, $t0, 11sll $t0, $t0, 26ori $t2, $0, 0x03ffsll $t2, $t2, 16ori $t2, $t2, 0xffffand $t1, $t1, $t2or $t1, $t1, $t0b.srl $t0, $t0, 11sll $t0, $t0, 26srl $t0, $t0, 12ori $t2, $0, 0xfff0sll $t2, $t2, 16ori $t2, $t2, 0x3fffand $t1, $t1, $t2or $t1, $t1, $t02.14.5a.sll $t0, $t0, 27ori $t2, $0, 0x07ffsll $t2, $t2, 16ori $t2, $t2, 0xffffand $t1, $t1, $t2or $t1, $t1, $t0b.sll $t0, $t0, 27srl $t0, $t0, 13ori $t2, $0, 0xfff8sll $t2, $t2, 16ori $t2, $t2, 0x3fffand $t1, $t1, $t2or $t1, $t1, $t02.14.6a.srl $t0, $t0, 29sll $t0, $t0, 30ori $t2, $0, 0x3fffsll $t2, $t2, 16ori $t2, $t2, 0xffffand $t1, $t1, $t2or $t1, $t1, $t0b.srl $t0, $t0, 29sll $t0, $t0, 30srl $t0, $t0, 16ori $t2, $0, 0xffffsll $t2, $t2, 16ori $t2, $t2, 0x3fffand $t1, $t1, $t2or $t1, $t1, $t0Solution 2.152.15.1a.0xff005a5ab.0x00ffffe72.15.2a.nor $t1, $t2, $t2b.nor $t1, $t3, $t3or $t1, $t2, $t12.15.3a.nor $t1, $t2, $t2000000 01010 01010 01001 00000 100111b.nor $t1, $t3, $t3or $t1, $t2, $t1000000 01011 01011 01001 00000 100111 000000 01010 01001 01001 00000 1001012.15.4a.0xFFFFFFFFb.0x000123402.15.5 Assuming $t1 = A, $t2 = B, $s1 = base of Array Ca. nor $t3, $t1, $t1or $t1, $t2, $t3b. lw $t3, 0($s1)sll $t1, $t3, 42.15.6a. nor $t3, $t1, $t1or $t1, $t2, $t3000000 01001 01001 01011 00000 100111 000000 01010 01011 01001 00000 100101b. lw $t3, 0($s1)sll $t1, $t3, 4100011 10001 01011 0000000000000000 000000 00000 01011 01001 00100 000000Solution 2.16 2.16.1a.$t2 = 1b.$t2 = 12.16.2a.noneb.none2.16.3a.Jump – No, Beq - Nob.Jump – No, Beq - No2.16.4a.$t2 = 2b.$t2 = 12.16.5a.$t2 = 0b.$t2 = 02.16.6a.jump – Yes, beq - nob.jump – no, beq - noSolution 2.172.17.1 The answer is really the same for all. All of these instructions are either supported by an existing instruction or sequence of existing instructions. Looking for an answer along the lines of, “these instructions are not common, and we are only making the common case fast.”2.17.2a.i-typeb.i-type2.17.3a.addi $t2, $t3, −5b.addi $t2, $t2, −1beq $t2, $0, loop2.17.4a.20b.202.17.5a.i = 10;do {B += 2;i = i – 1;} while ( i > 0)b.Same as part a.2.17.6a. 3 ´ Nb. 5 ´ N2.18.2a.addi $t0, $0, 0 beq $0, $0, TEST LOOP: add $s0, $s0, $s1 addi $t0, $t0, 1 TEST: slt $t2, $t0, $s0 bne $t2, $0, LOOPSolution 2.182.18.1b. addi $t0, $0, 0beq $0, $0, TEST1LOOP1:addi $t1, $0, 0beq $0, $0, TEST2LOOP2:add $t3, $t0, $t1sll $t2, $t1, 4add $t2, $t2, $s2sw $t3, ($t2)addi $t1, $t1, 1TEST2:slt $t2, $t1, $s1bne $t2, $0, LOOP2addi $t0, $t0, 1TEST1:slt $t2, $t0, $s0bne $t2, $0, LOOP12.18.3a. 6 instructions to implement and infi nite instructions executedb.14 instructions to implement and 158 instructions executed2.18.4a.351b.6012.18.5a.for(i=50; i>0; i--){result += MemArray[s0];result += MemArray[s0+1];s0 += 2;}b.for (i=0; i<100; i++) {result += MemArray[s0];s0 = s0 + 4;}2.18.6a. addi $t1, $s0, 400LOOP: lw $s1, 0($s0)add $s2, $s2, $s1lw $s1, 4($s0)add $s2, $s2, $s1addi $s0, $s0, 8bne $s0, $t1, LOOPb. addi $t1, $s0, 400LOOP: lw $s1, 0($t1)add $s2, $s2, $s1addi $t1, $t1, −4bne $t1, $s0, LOOPSolution 2.192.19.1a.fib: addi $sp, $sp, −12 # make room on stacksw $ra, 8($sp) # push $rasw $s0, 4($sp) # push $s0sw $a0, 0($sp) # push $a0 (N)bgt $a0, $0, test2 # if n>0, test if n=1 add $v0, $0, $0 # else fib(0) = 0j rtn #test2: addi $t0, $0, 1 #bne $t0, $a0, gen # if n>1, genadd $v0, $0, $t0 # else fib(1) = 1j rtngen: subi $a0, $a0,1 # n−1jal fib # call fib(n−1)add $s0, $v0, $0 # copy fib(n−1)sub $a0, $a0,1 # n−2jal fib # call fib(n−2)add $v0, $v0, $s0 # fib(n−1)+fib(n−2)rtn: lw $a0, 0($sp) # pop $a0lw $s0, 4($sp) # pop $s0lw $ra, 8($sp) # pop $raaddi $sp, $sp, 12 # restore spjr $ra# fib(0) = 12 instructions, fib(1) = 14 instructions,# fib(N) = 26 + 18N instructions for N >=2b.positive:addi $sp, $sp, −4sw $ra, 0($sp)jal additaddi $t1, $0, 1slt $t2, $0, $v0bne $t2, $0, exitaddi $t1, $0, $0exit:add $v0, $t1, $0lw $ra, 0($sp)addi $sp, $sp, 4jr $raaddit:add $v0, $a0, $a1jr $ra# 13 instructions worst-case2.19.2a.Due to the recursive nature of the code, not possible for thecompiler to in-line the function call.b.positive:add $t0, $a0, $a1addi $v0, $0, 1slt $t2, $0, $t0bne $t2, $0, exitaddi $v0, $0, $0exit:jr $ra# 6 instructions worst-case2.19.3a.after calling function fib:old $sp -> 0x7ffffffc−4 contents of register $ra for fib(N)−8 contents of register $s0 for fib(N)$sp-> −12 contents of register $a0 for fib(N)there will be N−1 copies of $ra, $s0, and $a0b.after calling function positive:old $sp -> 0x7ffffffc$sp-> −4 contents of register $raafter calling function addit:old $sp -> 0x7ffffffc−4 contents of register $ra$sp-> −8 contents of register $ra #return to positive2.19.4a.f: addi $sp,$sp,−12sw $ra,8($sp)sw $s1,4($sp)sw $s0,0($sp)move $s1,$a2move $s0,$a3jal funcmove $a0,$v0add $a1,$s0,$s1jal funclw $ra,8($sp)lw $s1,4($sp)lw $s0,0($sp)addi $sp,$sp,12jr $rab.f: addi $sp,$sp,−4sw $ra,0($sp)add $t0,$a1,$a0add $a1,$a3,$a2slt $t1,$a1,$t0beqz $t1,Lmove $a0,$t0jal funclw $ra,0($sp)addi $sp,$sp,4jr raL: move $a0,$a1move $a1,$t0jal funclw $ra,0($sp)addi $sp,$sp,4jr $ra2.19.5a.We can use the tail-call optimization for the second call to func, but then we must restore $ra,$s0, $s1, and $sp before that call. We save only one instruction (jr $ra).b.We can use the tail-call optimization for either call to func (when the condition for the if istrue or false). This eliminates the need to save $ra and move the stack pointer, so we execute5 fewer instructions (regardless of whether the if condition is true or not). The code of thefunction is 8 instructions shorter because we can eliminate both instances of the code thatrestores $ra and returns.2.19.6 Register $ra is equal to the return address in the caller function, registers $sp and $s3 have the same values they had when function f was called, and register $t5 can have an arbitrary value. For register $t5, note that although our function f does not modify it, function func is allowed to modify it so we cannot assume anything about the value of $t5 after function func has been called.Solution 2.202.20.1a.FACT: addi $sp, $sp, −8 # make room in stack for 2 more itemssw $ra, 4($sp) # save the return addresssw $a0, 0($sp) # save the argument nslti $t0, $a0, 1 # $t0 = $a0 x 2beq, $t0, $0, L1 # if $t0 = 0, goto L1add $v0, $0, 1 # return 1add $sp, $sp, 8 # pop two items from the stackjr $ra # return to the instruction after jalL1: addi $a0, $a0, −1 # subtract 1 from argumentjal FACT # call fact(n−1)lw $a0, 0($sp) # just returned from jal: restore nlw $ra, 4($sp) # restore the return addressadd $sp, $sp, 8 # pop two items from the stackmul $v0, $a0, $v0 # return n*fact(n−1)jr $ra # return to the callerb.FACT: addi $sp, $sp, −8 # make room in stack for 2 more itemssw $ra, 4($sp) # save the return addresssw $a0, 0($sp) # save the argument nslti $t0, $a0, 1 # $t0 = $a0 x 2beq, $t0, $0, L1 # if $t0 = 0, goto L1add $v0, $0, 1 # return 1add $sp, $sp, 8 # pop two items from the stackjr $ra # return to the instruction after jalL1: addi $a0, $a0, −1 # subtract 1 from argumentjal FACT # call fact(n−1)lw $a0, 0($sp) # just returned from jal: restore nlw $ra, 4($sp) # restore the return addressadd $sp, $sp, 8 # pop two items from the stackmul $v0, $a0, $v0 # return n*fact(n−1)jr $ra # return to the caller2.20.2a.25 MIPS instructions to execute non-recursive vs. 45 instructions to execute (corrected versionof) recursionNon-recursive version:FACT: addi $sp, $sp, −4sw $ra, 4($sp)add $s0, $0, $a0add $s2, $0, $1LOOP: slti $t0, $s0, 2bne $t0, $0, DONEmul $s2, $s0, $s2addi $s0, $s0, −1j LOOPDONE: add $v0, $0, $s2lw $ra, 4($sp)addi $sp, $sp, 4jr $rab.25 MIPS instructions to execute non-recursive vs. 45 instructions to execute (corrected versionof) recursionNon-recursive version:FACT: addi $sp, $sp, −4sw $ra, 4($sp)add $s0, $0, $a0add $s2, $0, $1LOOP: slti $t0, $s0, 2bne $t0, $0, DONEmul $s2, $s0, $s2addi $s0, $s0, −1j LOOPDONE: add $v0, $0, $s2lw $ra, 4($sp)addi $sp, $sp, 4jr $ra2.20.3a.Recursive versionFACT: addi $sp, $sp, −8sw $ra, 4($sp)sw $a0, 0($sp)add $s0, $0, $a0HERE: slti $t0, $a0, 2beq $t0, $0, L1addi $v0, $0, 1addi $sp, $sp, 8jr $raL1: addi $a0, $a0, −1jal FACTmul $v0, $s0, $v0lw $a0, 0($sp)lw $ra, 4($sp)addi $sp, $sp, 8jr $raat label HERE, after calling function FACT with input of 4: old $sp -> 0xnnnnnnnn−4 contents of register $ra$sp-> −8 contents of register $a0at label HERE, after calling function FACT with input of 3: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $a0−12 contents of register $ra$sp-> −16 contents of register $a0at label HERE, after calling function FACT with input of 2: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $a0−12 contents of register $ra−16 contents of register $a0−20 contents of register $ra$sp-> −24 contents of register $a0at label HERE, after calling function FACT with input of 1: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $a0−12 contents of register $ra−16 contents of register $a0−20 contents of register $ra−24 contents of register $a0−28 contents of register $ra$sp-> −32 contents of register $a0b.Recursive versionFACT: addi $sp, $sp, −8sw $ra, 4($sp)sw $a0, 0($sp)add $s0, $0, $a0HERE: slti $t0, $a0, 2beq $t0, $0, L1addi $v0, $0, 1addi $sp, $sp, 8jr $raL1: addi $a0, $a0, −1jal FACTmul $v0, $s0, $v0lw $a0, 0($sp)lw $ra, 4($sp)addi $sp, $sp, 8jr $raat label HERE, after calling function FACT with input of 4: old $sp -> 0xnnnnnnnn−4 contents of register $ra$sp-> −8 contents of register $a0at label HERE, after calling function FACT with input of 3: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $a0−12 contents of register $ra$sp-> −16 contents of register $a0at label HERE, after calling function FACT with input of 2: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $a0−12 contents of register $ra−16 contents of register $a0−20 contents of register $ra$sp-> −24 contents of register $a0at label HERE, after calling function FACT with input of 1: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $a0−12 contents of register $ra−16 contents of register $a0−20 contents of register $ra−24 contents of register $a0−28 contents of register $ra$sp-> −32 contents of register $a02.20.4a.FIB: addi $sp, $sp, −12sw $ra, 8($sp)sw $s1, 4($sp)sw $a0, 0($sp)slti $t0, $a0, 3beq $t0, $0, L1addi $v0, $0, 1j EXITL1: addi $a0, $a0, −1jal FIBaddi $s1, $v0, $0addi $a0, $a0, −1jal FIBadd $v0, $v0, $s1EXIT: lw $a0, 0($sp)lw $s1, 4($sp)lw $ra, 8($sp)addi $sp, $sp, 12jr $rab.FIB: addi $sp, $sp, −12sw $ra, 8($sp)sw $s1, 4($sp)sw $a0, 0($sp)slti $t0, $a0, 3beq $t0, $0, L1addi $v0, $0, 1j EXITL1: addi $a0, $a0, −1jal FIBaddi $s1, $v0, $0addi $a0, $a0, −1jal FIBadd $v0, $v0, $s1EXIT: lw $a0, 0($sp)lw $s1, 4($sp)lw $ra, 8($sp)addi $sp, $sp, 12jr $ra2.20.5a.23 MIPS instructions to execute non-recursive vs. 73 instructions to execute (corrected versionof) recursionNon-recursive version:FIB: addi $sp, $sp, −4sw $ra, ($sp)addi $s1, $0, 1addi $s2, $0, 1LOOP: slti $t0, $a0, 3bne $t0, $0, EXITadd $s3, $s1, $0add $s1, $s1, $s2add $s2, $s3, $0addi $a0, $a0, −1j LOOPEXIT: add $v0, s1, $0lw $ra, ($sp)addi $sp, $sp, 4jr $rab.23 MIPS instructions to execute non-recursive vs. 73 instructions to execute (corrected versionof) recursionNon-recursive version:FIB: addi $sp, $sp, −4sw $ra, ($sp)addi $s1, $0, 1addi $s2, $0, 1LOOP: slti $t0, $a0, 3bne $t0, $0, EXITadd $s3, $s1, $0add $s1, $s1, $s2add $s2, $s3, $0addi $a0, $a0, −1j LOOPEXIT: add $v0, s1, $0lw $ra, ($sp)addi $sp, $sp, 4jr $ra2.20.6a.Recursive versionFIB: addi $sp, $sp, −12sw $ra, 8($sp)sw $s1, 4($sp)sw $a0, 0($sp)HERE: slti $t0, $a0, 3beq $t0, $0, L1addi $v0, $0, 1j EXITL1: addi $a0, $a0, −1jal FIBaddi $s1, $v0, $0addi $a0, $a0, −1jal FIBadd $v0, $v0, $s1EXIT: lw $a0, 0($sp)lw $s1, 4($sp)lw $ra, 8($sp)addi $sp, $sp, 12jr $raat label HERE, after calling function FIB with input of 4: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $s1$sp-> −12 contents of register $a0 b.Recursive versionFIB: addi $sp, $sp, −12sw $ra, 8($sp)sw $s1, 4($sp)sw $a0, 0($sp)HERE: slti $t0, $a0, 3beq $t0, $0, L1addi $v0, $0, 1j EXITL1: addi $a0, $a0, −1jal FIBaddi $s1, $v0, $0addi $a0, $a0, −1jal FIBadd $v0, $v0, $s1EXIT: lw $a0, 0($sp)lw $s1, 4($sp)lw $ra, 8($sp)addi $sp, $sp, 12jr $raat label HERE, after calling function FIB with input of 4: old $sp -> 0xnnnnnnnn−4 contents of register $ra−8 contents of register $s1$sp-> −12 contents of register $a0Solution 2.212.21.1a.MAIN: addi $sp, $sp, −4sw $ra, ($sp)addi $a0, $0, 10addi $a1, $0, 20jal FUNCadd $t2, $v0 $0lw $ra, ($sp)addi $sp, $sp, 4jr $raFUNC: lw $t1, ($s0) #assume $s0 has global variable basesub $t0, $v0, $v1addi $v0, $t0, $t1jr $rab.MAIN: addi $sp, $sp, −4sw $ra, ($sp)lw $t1, ($s0) #assume $s0 has global variable baseaddi $a0, $t1, 1jal LEAFadd $t2, $v0 $0lw $ra, ($sp)addi $sp, $sp, 4jr $raLEAF: addi $v0, $a0, 1jr $ra2.21.2a.after entering function main:old $sp -> 0x7ffffffc$sp-> −4 contents of register $raafter entering function my_function:old $sp -> 0x7ffffffc−4 contents of register $ra$sp-> −8 c ontents of register $ra (return to main) global pointers:0x10008000 100 my_globalb.after entering function main:old $sp -> 0x7ffffffc$sp-> −4 contents of register $raglobal pointers:0x10008000 100 my_globalafter entering function leaf_function:old $sp -> 0x7ffffffc−4 contents of register $ra$sp-> −8 c ontents of register $ra (return to main) global pointers:0x10008000 101 my_global2.21.3a.MAIN: addi $sp, $sp, −4sw $ra, ($sp)addi $a0, $0, 10addi $a1, $0, 20jal FUNCadd $t2, $v0 $0lw $ra, ($sp)addi $sp, $sp, 4jr $raFUNC: lw $t1, ($s0) #assume $s0 has global variable basesub $t0, $v0, $v1addi $v0, $t0, $t1jr $rab.MAIN: addi $sp, $sp, −4sw $ra, ($sp)lw $t1, ($s0) #assume $s0 has global variable baseaddi $a0, $t1, 1jal LEAFadd $t2, $v0 $0lw $ra, ($sp)addi $sp, $sp, 4jr $raLEAF: addi $v0, $a0, 1jr $ra2.21.4a.The return address of the function is in $ra, so the last instruction should be “jr $ra.”b.The tail call to g must use jr, not jal. If jal is used, it overwrites the return address so function greturns back to f, not to the original caller of f as intended.2.21.5a.int f(int a, int b, int c){if(c)return (a+b);return (a−b);}b.int f(int a, int b, int c, int d){if(a>c+d)return b;return g(b);}2.21.6a.The function returns 101 (1000 is nonzero, so it returns 1+100).b.The function returns 500 (c+d is 1030, which is larger than 1, so the function returns g(b),which according to the problem statement is 500).Solution 2.222.22.1a.68 65 6C 6C 6F 20 77 6F 72 6C 64b.48 49 50 51 52 53 54 55 56 572.22.2a.U+0038, U+0020, U+0062, U+0069, U+0074, U+0073b.U+0030, U+0031, U+0032, U+0033, U+0034, U+0035, U+0036, U+0037,U+0038, U+00392.22.3a.ADDb.MIPSSolution 2.232.23.1a.MAIN: addi $sp, $sp, −4sw $ra, ($sp)add $t6, $0, 0x30 # ‘0’add $t7, $0, 0x39 # ‘9’add $s0, $0, $0add $t0, $a0, $0LOOP: lb $t1, ($t0)slt $t2, $t1, $t6bne $t2, $0, DONEslt $t2, $t7, $t1bne $t2, $0, DONEsub $t1, $t1, $t6beq $s0, $0, FIRSTmul $s0, $s0, 10FIRST: add $s0, $s0, $t1addi $t0, $t0, 1j LOOPDONE: add $v0, $s0, $0lw $ra, ($sp)addi $sp, $sp, 4jr $rab.MAIN: addi $sp, $sp, −4sw $ra, ($sp)add $t4, $0, 0x41 # ‘A’add $t5, $0, 0x46 # ‘F’add $t6, $0, 0x30 # ‘0’add $t7, $0, 0x39 # ‘9’add $s0, $0, $0add $t0, $a0, $0LOOP: lb $t1, ($t0)slt $t2, $t1, $t6bne $t2, $0, DONEslt $t2, $t7, $t1bne $t2, $0, HEXsub $t1, $t1, $t6j DECHEX: slt $t2, $t1, $t4bne $t2, $0, DONEslt $t2, $t5, $t1bne $t2, $0, DONEsub $t1, $t1, $t4addi $t1, $t1, 10DEC: beq $s0, $0, FIRSTmul $s0, $s0, 10FIRST: add $s0, $s0, $t1addi $t0, $t0, 1j LOOPDONE: add $v0, $s0, $0lw $ra, ($sp)addi $sp, $sp, 4jr $raSolution 2.242.24.1a.0x00000012b.0x0012ffff2.24.2a.0x00000080b.0x008000002.24.3a.0x00000011b.0x00115555Solution 2.252.25.1 Generally, all solutions are similar:lui $t1, top_16_bitsori $t1, $t1, bottom_16_bits2.25.2 Jump can go up to 0x0FFFFFFC.a.nob.yes2.25.3 Range is 0x604 + 0x1FFFC = 0x0002 0600 to 0x604 – 0x20000 = 0xFFFE 0604.a.nob.no2.25.4 Range is 0x1FFFF004 + 0x1FFFC = 0x2001F000 to 0x1FFFF004 – 0x20000 = 1FFDF004a.yesb.no2.25.5 Generally, all solutions are similar:add $t1, $0, $0 #clear $t1addi $t2, $0, top_8_bits #set top 8bsll $t2, $t2, 24 #shift left 24 spotsor $t1, $t1, $t2 #place top 8b into $t1 addi $t2, $0, nxt1_8_bits #set next 8bsll $t2, $t2, 16 #shift left 16 spotsor $t1, $t1, $t2 #place next 8b into $t1 addi $t2, $0, nxt2_8_bits #set next 8bsll $t2, $t2, 24 #shift left 8 spotsor $t1, $t1, $t2 #place next 8b into $t1 ori $t1, $t1, bot_8_bits #or in bottom 8b2.25.6a.0x12345678b.0x000000002.25.7a.t0 = (0x1234 << 16) + 0x5678;b.t0 = (0x1234 << 16) && 0x5678;Solution 2.262.26.1 Branch range is 0x00020000 to 0xFFFE0004.a.one branchb.one branch2.26.2a.oneb.can’t be done2.26.3 Branch range is 0x00000200 to 0xFFFFFE04.a.256 branchesb.one branch2.26.4a.branch range is 16× smallerb.branch range is 4× smaller2.26.5a.no changeb.jump to addresses 0 to 226 instead of 0 to 228, assuming the PC<0x080000002.26.6a.rs fi eld now 7 bitsb.no changeSolution 2.272.27.1a.MIPS lw/sw instructions: lw $t0, 8($t1)b.jump2.27.2a.i-typeb.j-type2.27.3a.+ allows memory from (base +/– 215) addresses to be loaded without changing the base– max size of 64 kB memory array without having to use multiple base addressesb.+ large jump range– jump range not as large as jump-register– can only access 1/16th of the total addressable space2.27.4a.0x00400000 beq $s0, $0, FAR...0x00403100 FAR: addi $s0, $s0, 10x12000c3c 0x22100001b.0x00000100 j AWAY...0x04000010 AWAY: addi $s0, $s0, 10x09000004 0x221000012.27.5a. addi $t0, $0, 0x31sll $t0, $t0, 8beq $s0, $0, TEMP...TEMP: jr $t0b. addi $s0, $0, 0x4sll $s0, $s0, 24ori $s0, $s0, 0x10jr $s0...addi $s0, $s0, 12.27.6a.2b.3Solution 2.282.28.1a. 3 instructions2.28.2a.The location specifi ed by the LL instruction is different than the SC instruction; hence, the operation of the store conditional is undefi ned.2.28.3a.try: MOV R3,R4LL R2,0(R1)ADDI R2, R2, 1SC R3,0(R1)BEQZ R3,tryMOV R4,R2。

1. 数据类型、数据表示和数据结构之间是什么关系？在设计一个计算机系统时，确定数据表示的原则主要有哪几个？ 答：略2. 假设有A 和B 两种不同类型的处理机，A 处理机中的数据不带标志位，其指令字长和数据字长均为32位。

B 处理机的数据带有标志位，每个数据的字长增加至36位，其中有4位是标志符，它的指令条数由最多256条减少至不到64条。

如果每执行一条指令平均要访问两个操作数，每个存放在存储器中的操作数平均要被访问8次。

对于一个由1000条指令组成的程序，分别计算这个程序在A 处理机和B 处理机中所占用的存储空间大小（包括指令和数据），从中得到什么启发？ 答：我们可以计算出数据的总数量：∵ 程序有1000条指令组成，且每条指令平均要访问两个操作数 ∴ 程序访问的数据总数为：1000×2＝2000个 ∵ 每个数据平均访问8次∴ 程序访问的不同数据个数为：2000÷8＝250对于A 处理机，所用的存储空间的大小为：bit 4000032250321000Mem Mem Mem data n instructio A =⨯+⨯=+=对于B 处理机，指令字长由32位变为了30位（条数由256减少到64），这样，所用的存储空间的大小为：bit 3900036250301000Mem Mem Mem data n instructio B =⨯+⨯=+=由此我们可以看出，由于数据的平均访问次数要大于指令，所以，采用带标志符的数据表示不会增加总的存储空间大小。

3. 对于一个字长为64位的存储器，访问这个存储器的地址按字节编址。

假设存放在这个存储器中的数据中有20％是独立的字节数据（指与这个字节数据相邻的不是一个字节数据），有30％是独立的16位数据，有20％是独立的32位数据，另外30％是独立的64位数据；并且规定只能从一个存储字的起始位置开始存放数据。

⑴计算这种存储器的存储空间利用率。

⑵给出提高存储空间利用率的方法，画出新方法的逻辑框图，并计算这种方法的存储空间利用率。

计算机组成原理课后答案1. 什么是计算机组成原理？计算机组成原理是研究计算机硬件的基本组成和工作原理的学科，主要包括处理器、内存、输入输出设备等方面的内容。

它研究计算机硬件的组成结构和各部件之间的组织、连接和控制方式，以及计算机如何运行和进行数据处理的原理和方法。

2. 计算机的五大基本部件是什么？计算机的五大基本部件是：•中央处理器（CPU）：负责执行计算机指令，控制和协调计算机的各部件工作。

•主存储器（Memory）：用于存储计算机处理数据和指令时所需要的数据。

•输入设备：用户通过输入设备向计算机输入数据和指令。

•输出设备：计算机将处理结果输出给用户。

•外部存储器：用于长期存储数据和程序的设备，例如硬盘和光盘等。

3. 简述冯·诺依曼体系结构的特点。

冯·诺依曼体系结构是计算机组成原理中最重要的概念之一，其特点包括：•存储程序：指令和数据以二进制形式存储在同一存储器中，计算机可以根据指令的地址自动取指令执行。

•以运算器和控制器为核心：运算器负责执行算术和逻辑运算，控制器负责控制计算机的运行和各部件的协调工作。

•输入输出分离：计算机的输入设备和输出设备与运算器和控制器分离，通过输入输出设备和外存进行数据交互。

•指令执行顺序：指令按照程序设计者指定的顺序执行，依次从存储器中取出指令并执行。

4. 什么是指令集架构？指令集架构是计算机体系结构的一种分类方式，它定义了计算机硬件与软件之间的接口和指令集的编码规则。

指令集架构决定了计算机的指令集和寻址方式，是软硬件协同工作的重要基础。

常见的指令集架构有精简指令集（RISC）和复杂指令集（CISC）两种。

精简指令集架构主张指令集简单、指令执行速度快，执行周期短，例如ARM架构；而复杂指令集架构主张指令集功能丰富、指令执行效率高，例如x86架构。

5. 计算机中的字长是什么意思？计算机中的字长是指计算机中最基本的数据单位的长度，决定了计算机的数据处理能力和寻址能力。

计算机组成原理第二章参考答案计算机组成原理第二章主要介绍了计算机的层次结构和性能指标。

以下是第二章的参考答案，详细介绍了计算机层次结构的各个层次和性能指标。

第二章：计算机的层次结构和性能指标1. 什么是计算机的层次结构？计算机的层次结构是指计算机系统中各个层次之间的相互关系和功能划分。

计算机的层次结构从上到下分为五个层次：应用层、操作系统层、汇编和机器语言层、微程序层和硬件层。

2. 请介绍计算机的五个层次结构。

- 应用层：计算机的最顶层，负责处理用户的应用程序和数据。

- 操作系统层：负责管理计算机系统的资源和控制计算机的运行。

- 汇编和机器语言层：负责将高级语言转化为机器语言，供计算机硬件执行。

- 微程序层：负责实现计算机指令的具体执行过程。

- 硬件层：计算机的最底层，包括处理器、内存、输入输出设备等硬件组件。

3. 什么是计算机的性能指标？计算机的性能指标是指衡量计算机性能优劣的指标，主要包括速度、存储容量、可靠性和成本四个方面。

4. 请介绍计算机的速度性能指标。

- 响应时间：指从用户发出请求到计算机给出响应的时间。

- 时钟周期：指计算机内部处理器的时钟周期时间。

- 主频：指处理器的时钟频率，单位为赫兹。

- MIPS：指每秒执行百万条指令数，是衡量计算机运算速度的指标。

5. 请介绍计算机的存储容量性能指标。

- 主存容量：指计算机中用于存储程序和数据的主存容量。

- 硬盘容量：指计算机中用于存储大容量数据的硬盘容量。

- 缓存容量：指计算机中用于提高数据访问速度的高速缓存容量。

6. 请介绍计算机的可靠性性能指标。

- 故障率：指计算机发生故障的概率。

- 可用性：指计算机正常工作的时间占总时间的比例。

- 容错能力：指计算机在部分组件故障时仍然可以正常工作的能力。

7. 请介绍计算机的成本性能指标。

- 硬件成本：指计算机硬件的购买和维护成本。

- 能耗成本：指计算机在运行过程中消耗的能源成本。

- 人工成本：指计算机的使用和维护所需的人力成本。

第二章运算方法和运算器练习一、填空题1. 补码加减法中，（符号位）作为数的一部分参加运算，（符号位产生的进位）要丢掉。

2. 为判断溢出，可采用双符号位补码，此时正数的符号用（00）表示，负数的符号用（11）表示。

3. 采用双符号位的方法进行溢出检测时，若运算结果中两个符号位（不相同），则表明发生了溢出。

若结果的符号位为（01），表示发生正溢出；若为（10），表示发生负溢出。

4. 采用单符号位进行溢出检测时，若加数与被加数符号相同，而运算结果的符号与操作数的符号（不一致），则表示溢出；当加数与被加数符号不同时，相加运算的结果（不会产生溢出）。

5. 利用数据的数值位最高位进位C和符号位进位Cf的状况来判断溢出，则其表达式为over=（C⊕Cf）。

6. 在减法运算中，正数减（负数）可能产生溢出，此时的溢出为（正）溢出；负数减（正数）可能产生溢出，此时的溢出为（负）溢出。

7. 补码一位乘法运算法则通过判断乘数最末位Yi和Yi-1的值决定下步操作，当YiYi-1=（10）时，执行部分积加【-x】补，再右移一位；当YiYi-1=（01）时，执行部分积加【x】补，再右移一位。

8. 浮点加减运算在（阶码运算溢出）情况下会发生溢出。

9. 原码一位乘法中，符号位与数值位（分开运算），运算结果的符号位等于（两操作数符号的异或值）。

10. 一个浮点数，当其补码尾数右移一位时，为使其值不变，阶码应该（加1）。

11. 左规的规则为：尾数（左移一位），阶码（减1）。

12. 右规的规则是：尾数（右移一位），阶码（加1）。

13. 影响进位加法器速度的关键因素是（进位信号的传递问题）。

14. 当运算结果的补码尾数部分不是（11.0×××××或00.1×××××）的形式时，则应进行规格化处理。

当尾数符号位为（01）或（10）时，需要右规。

(完整word版)第二章课后习题及参考答案亲爱的读者：本文内容由我和我的同事精心收集整理后编辑发布到文库，发布之前我们对文中内容进行详细的校对，但难免会有错误的地方，如果有错误的地方请您评论区留言，我们予以纠正，如果本文档对您有帮助，请您下载收藏以便随时调用。

下面是本文详细内容。

最后最您生活愉快 ~O(∩_∩)O ~第二章课后习题及参考答案一、选择题1.一个完整的计算机系统通常应包括（）。

A、系统软件和应用软件B、计算机及其外部设备C、硬件系统和软件系统D、系统硬件和系统软件2.一个计算机系统的硬件一般是由哪几部分构成的？（）A、CPU、键盘、鼠标和显示器B、运算器、控制器、存储器、输入设备和输出设备C、主机、显示器、打印机和电源D、主机、显示器和键盘3.CPU是计算机硬件系统的核心，它是由（）组成的。

A、运算器和存储器B、控制器和存储器C、运算器和控制器D、加法器和乘法器4.CPU中的控制器的功能是（）。

A、进行逻辑运算B、进行算术运算C、控制运算的速度D、分析指令并发出相应的控制信号5.计算机的存储系统通常包括（）。

A、内存储器和外存储器B、软盘和硬盘C、ROM和RAMD、内存和硬盘6.计算机的内存储器简称内存，它是由（）构成的。

A、随机存储器和软盘B、随机存储器和只读存储器C、只读存储器和控制器D、软盘和硬盘7.随机存储器简称为（）。

A、CMOSB、RAMC、XMSD、ROM8.计算机一旦断电后，（）中的信息会丢失。

A、硬盘B、软盘C、RAMD、ROM9.在下列存储器中，存取速度最快的是（）。

A、软盘B、光盘C、硬盘D、内存10.ALU完成算术操作和（）。

A、存储数据B、奇偶校验C、逻辑操作D、二进制计算11.计算机硬件由5个基本部分组成，下面（）不属于这5个基本组成部分。

A、运算器和控制器B、存储器C、总线D、输入设备和输出设备12.微型计算机是由输入设备、输出设备、运算器、存储器和（）组成。

第1章计算机系统概论之阿布丰王创作1. 什么是计算机系统、计算机硬件和计算机软件？硬件和软件哪个更重要？解：计算机系统：由计算机硬件系统和软件系统组成的综合体.计算机硬件：指计算机中的电子线路和物理装置.计算机软件：计算机运行所需的法式及相关资料.硬件和软件在计算机系统中相互依存,缺一不成,因此同样重要.2. 如何理解计算机的条理结构？答：计算机硬件、系统软件和应用软件构成了计算机系统的三个条理结构.（1）硬件系统是最内层的,它是整个计算机系统的基础和核心.（2）系统软件在硬件之外,为用户提供一个基本把持界面.（3）应用软件在最外层,为用户提供解决具体问题的应用系统界面.通常将硬件系统之外的其余层称为虚拟机.各条理之间关系密切,上层是下层的扩展,下层是上层的基础,各条理的划分不是绝对的.3. 说明高级语言、汇编语言和机器语言的分歧及其联系.答：机器语言是计算机硬件能够直接识另外语言,汇编语言是机器语言的符号暗示,高级语言是面向算法的语言.高级语言编写的法式（源法式）处于最高层,必需翻译成汇编语言,再由汇编法式汇编成机器语言（目标法式）之后才华被执行.4. 如何理解计算机组成和计算机体系结构？答：计算机体系结构是指那些能够被法式员所见到的计算机系统的属性,如指令系统、数据类型、寻址技术组成及I/O机理等.计算机组成是指如何实现计算机体系结构所体现的属性,包括对法式员透明的硬件细节,如组成计算机系统的各个功能部件的结构和功能,及相互连接方法等.5. 冯•诺依曼计算机的特点是什么？解：冯•诺依曼计算机的特点是：P8●计算机由运算器、控制器、存储器、输入设备、输出设备五年夜部件组成；●指令和数据以同同等位置寄存于存储器内,并可以按地址访问；●指令和数据均用二进制暗示；●指令由把持码、地址码两年夜部份组成,把持码用来暗示把持的性质,地址码用来暗示把持数在存储器中的位置；●指令在存储器中顺序寄存,通常自动顺序取出执行；●机器以运算器为中心（原始冯•诺依曼机）.6. 画出计算机硬件组成框图,说明各部件的作用及计算机系统的主要技术指标.答：计算机硬件组成框图如下：各部件的作用如下：控制器：整机的指挥中心,它使计算机的各个部件自动协调工作.运算器：对数据信息进行处置的部件,用来进行算术运算和逻辑运算.存储器：寄存法式和数据,是计算机实现“存储法式控制”的基础.输入设备：将人们熟悉的信息形式转换成计算机可以接受并识另外信息形式的设备.输出设备：将计算机处置的结果（二进制信息）转换成人类或其它设备可以接收和识另外信息形式的设备.计算机系统的主要技术指标有：机器字长：指CPU一次能处置的数据的位数.通常与CPU的寄存器的位数有关,字长越长,数的暗示范围越年夜,精度也越高.机器字长也会影响计算机的运算速度.数据通路宽度：数据总线一次能并行传送的数据位数.存储容量：指能存储信息的最年夜容量,通常以字节来衡量.一般包括主存容量和辅存容量.运算速度：通经常使用MIPS（每秒百万条指令）、MFLOPS （每秒百万次浮点运算）或CPI（执行一条指令所需的时钟周期数）来衡量.CPU执行时间是指CPU对特定法式的执行时间.主频：机器内部主时钟的运行频率,是衡量机器速度的重要参数.吞吐量：指流入、处置和流出系统的信息速率.它主要取决于主存的存取周期.响应时间：计算机系统对特定事件的响应时间,如实时响应外部中断的时间等.7. 解释下列概念：主机、CPU、主存、存储单位、存储元件、存储基元、存储元、存储字、存储字长、存储容量、机器字长、指令字长.解：P9-10主机：是计算机硬件的主体部份,由CPU和主存储器MM合成为主机.CPU：中央处置器,是计算机硬件的核心部件,由运算器和控制器组成；（早期的运算器和控制器不在同一芯片上,现在的CPU 内除含有运算器和控制器外还集成了CACHE）.主存：计算机中寄存正在运行的法式和数据的存储器,为计算机的主要工作存储器,可随机存取；由存储体、各种逻辑部件及控制电路组成.存储单位：可寄存一个机器字并具有特定存储地址的存储单位.存储元件：存储一位二进制信息的物理元件,是存储器中最小的存储单位,又叫存储基元或存储元,不能独自存取.存储字：一个存储单位所存二进制代码的逻辑单位.存储字长：一个存储单位所存储的二进制代码的总位数.存储容量：存储器中可存二进制代码的总量；（通常主、辅存容量分开描述）.机器字长：指CPU一次能处置的二进制数据的位数,通常与CPU的寄存器位数有关.指令字长：机器指令中二进制代码的总位数.8. 解释下列英文缩写的中文含义：CPU、PC、IR、CU、ALU、ACC、MQ、X、MAR、MDR、I/O、MIPS、CPI、FLOPS解：全面的回承诺分英文全称、中文名、功能三部份.CPU：Central Processing Unit,中央处置机（器）,是计算机硬件的核心部件,主要由运算器和控制器组成.PC：Program Counter,法式计数器,其功能是寄存以后欲执行指令的地址,并可自动计数形成下一条指令地址.IR：Instruction Register,指令寄存器,其功能是寄存以后正在执行的指令.CU：Control Unit,控制单位（部件）,为控制器的核心部件,其功能是发生微把持命令序列.ALU：Arithmetic Logic Unit,算术逻辑运算单位,为运算器的核心部件,其功能是进行算术、逻辑运算.ACC：Accumulator,累加器,是运算器中既能寄存运算前的把持数,又能寄存运算结果的寄存器.MQ：Multiplier-Quotient Register,乘商寄存器,乘法运算时寄存乘数、除法时寄存商的寄存器.X：此字母没有专指的缩写含义,可以用作任一部件名,在此暗示把持数寄存器,即运算器中工作寄存器之一,用来寄存把持数；MAR：Memory Address Register,存储器地址寄存器,在主存中用来寄存欲访问的存储单位的地址.MDR：Memory Data Register,存储器数据缓冲寄存器,在主存中用来寄存从某单位读出、或要写入某存储单位的数据.I/O：Input/Output equipment,输入/输出设备,为输入设备和输出设备的总称,用于计算机内部和外界信息的转换与传送.MIPS：Million Instruction Per Second,每秒执行百万条指令数,为计算机运算速度指标的一种计量单位.9. 画出主机框图,分别以存数指令“STA M”和加法指令“ADD M”（M均为主存地址）为例,在图中顺次标出完成该指令（包括取指令阶段）的信息流程（如→①）.假设主存容量为256M*32位,在指令字长、存储字长、机器字长相等的条件下,指出图中各寄存器的位数.解：主机框图如P13图1.11所示.（1）STA M指令：PC→MAR,MAR→MM,MM→MDR,MDR→IR,OP(IR)→CU,Ad(IR)→MAR,ACC→MDR,MAR →MM,WR（2）ADD M指令：PC→MAR,MAR→MM,MM→MDR,MDR→IR,OP(IR)→CU,Ad(IR)→MAR,RD,MM→MDR,MDR→X,ADD,ALU→ACC,ACC→MDR,WR假设主存容量256M*32位,在指令字长、存储字长、机器字长相等的条件下,ACC、X、IR、MDR寄存器均为32位,PC和MAR寄存器均为28位.10. 指令和数据都存于存储器中,计算机如何区分它们？解：计算机区分指令和数据有以下2种方法：●通过分歧的时间段来区分指令和数据,即在取指令阶段（或取指微法式）取出的为指令,在执行指令阶段（或相应微法式）取出的即为数据.●通过地址来源区分,由PC提供存储单位地址的取出的是指令,由指令地址码部份提供存储单位地址的取出的是把持数.第2章计算机的发展及应用1. 通常计算机的更新换代以什么为依据？答：P22主要以组成计算机基本电路的元器件为依据,如电子管、晶体管、集成电路等.2. 举例说明专用计算机和通用计算机的区别.答：依照计算机的效率、速度、价格和运行的经济性和实用性可以将计算机划分为通用计算机和专用计算机.通用计算机适应性强,但牺牲了效率、速度和经济性,而专用计算机是最有效、最经济和最快的计算机,但适应性很差.例如个人电脑和计算器.3. 什么是摩尔定律？该定律是否永远生效？为什么？答：P23,否,P36第3章系统总线1. 什么是总线？总线传输有何特点？为了减轻总线负载,总线上的部件应具备什么特点？答：P41.总线是一种能由多个部件分时共享的公共信息传送线路.总线传输的特点是：某一时刻只允许有一个部件向总线发送信息,但多个部件可以同时从总线上接收相同的信息.为了减轻总线负载,总线上的部件应通过三态驱动缓冲电路与总线连通.2. 总线如何分类？什么是系统总线？系统总线又分为几类,它们各有何作用,是单向的,还是双向的,它们与机器字长、存储字长、存储单位有何关系？答：依照连接部件的分歧,总线可以分为片内总线、系统总线和通信总线.系统总线是连接CPU、主存、I/O各部件之间的信息传输线.系统总线依照传输信息分歧又分为地址线、数据线和控制线.地址线是单向的,其根数越多,寻址空间越年夜,即CPU能访问的存储单位的个数越多；数据线是双向的,其根数与存储字长相同,是机器字长的整数倍.3. 经常使用的总线结构有几种？分歧的总线结构对计算机的性能有什么影响？举例说明.答：略.见P52-55.4. 为什么要设置总线判优控制？罕见的集中式总线控制有几种？各有何特点？哪种方式响应时间最快？哪种方式对电路故障最敏感？答：总线判优控制解决多个部件同时申请总线时的使用权分配问题；罕见的集中式总线控制有三种：链式查询、计数器按时查询、自力请求；特点：链式查询方式连线简单,易于扩充,对电路故障最敏感；计数器按时查询方式优先级设置较灵活,对故障不敏感,连线及控制过程较复杂；自力请求方式速度最快,但硬件器件用量年夜,连线多,本钱较高.5. 解释下列概念：总线宽度、总线带宽、总线复用、总线的主设备（或主模块）、总线的从设备（或从模块）、总线的传输周期和总线的通信控制.答：P46.总线宽度：通常指数据总线的根数；总线带宽：总线的数据传输率,指单位时间内总线上传输数据的位数；总线复用：指同一条信号线可以分时传输分歧的信号.总线的主设备（主模块）：指一次总线传输期间,拥有总线控制权的设备（模块）；总线的从设备（从模块）：指一次总线传输期间,配合主设备完成数据传输的设备（模块）,它只能主动接受主设备发来的命令；总线的传输周期：指总线完成一次完整而可靠的传输所需时间；总线的通信控制：指总线传送过程中双方的时间配合方式. 6. 试比力同步通信和异步通信.答：同步通信：指由统一时钟控制的通信,控制方式简单,灵活性差,当系统中各部件工作速度不同较年夜时,总线工作效率明显下降.适合于速度分歧不年夜的场所.异步通信：指没有统一时钟控制的通信,部件间采纳应答方式进行联系,控制方式较同步复杂,灵活性高,当系统中各部件工作速度不同较年夜时,有利于提高总线工作效率.7. 画图说明异步通信中请求与回答有哪几种互锁关系？答：见P61-62,图3.86.8. 为什么说半同步通信同时保管了同步通信和异步通信的特点？答：半同步通信既能像同步通信那样由统一时钟控制,又能像异步通信那样允许传输时间纷歧致,因此工作效率介于两者之间.9. 分离式通讯有何特点,主要用于什么系统？答：分离式通讯的特点是：（1）各模块欲占用总线使用权都必需提出申请；（2）在获得总线使用权后,主模块在先定的时间内向对方传送信息,采纳同步方式传送,不再等候对方的回答信号；（3）各模块在准备数据的过程中都不占用总线,使总线可接受其它模块的请求；（4）总线被占用时都在做有效工作,或者通过它发送命令,或者通过它传送数据,不存在空闲等候时间,充沛利用了总线的占用,从而实现了总线在多个主、从模块间进行信息交叉重叠并行传送.分离式通讯主要用于年夜型计算机系统.10. 为什么要设置总线标准？你知道目前流行的总线标准有哪些？什么叫plug and play？哪些总线有这一特点？答：总线标准的设置主要解决分歧厂家各类模块化产物的兼容问题；目前流行的总线标准有：ISA、EISA、PCI等；plug and play：即插即用,EISA、PCI等具有此功能.11. 画一个具有双向传输功能的总线逻辑图.答：在总线的两端分别配置三态门,就可以使总线具有双向传输功能.12. 设数据总线上接有A、B、C、D四个寄存器,要求选用合适的74系列芯片,完成下列逻辑设计：（1）设计一个电路,在同一时间实现D→A、D→B和D→C寄存器间的传送；（2）设计一个电路,实现下列把持：T0时刻完成D→总线；T1时刻完成总线→A；T2时刻完成A→总线；T3时刻完成总线→B.解：（1）由T翻开三态门将 D寄存器中的内容送至总线bus,由cp脉冲同时将总线上的数据打入到 A、B、C寄存器中. T和cp 的时间关系如图（1）所示.图（1）（2）三态门1受T0＋T1控制,以确保T0时刻D→总线,以及T1时刻总线→接收门1→A.三态门2受T2＋T3控制,以确保T2时刻A→总线,以及T3时刻总线→接收门2→B.T0、T1、T2、T3波形图如图（2）所示.图(2)13. 什么是总线的数据传输率,它与哪些因素有关？答：总线数据传输率即总线带宽,指单位时间内总线上传输数据的位数,通经常使用每秒传输信息的字节数来衡量.它与总线宽度和总线频率有关,总线宽度越宽,频率越快,数据传输率越高.14. 设总线的时钟频率为8MHZ,一个总线周期即是一个时钟周期.如果一个总线周期中并行传送16位数据,试问总线的带宽是几多？解：由于：f=8MHz,T=1/f=1/8M秒,一个总线周期即是一个时钟周期所以：总线带宽=16/（1/8M） = 128Mbps15. 在一个32位的总线系统中,总线的时钟频率为66MHZ,假设总线最短传输周期为4个时钟周期,试计算总线的最年夜数据传输率.若想提高数据传输率,可采用什么办法？解：总线传输周期=4*1/66M秒总线的最年夜数据传输率=32/(4/66M)=528Mbps若想提高数据传输率,可以提高总线时钟频率、增年夜总线宽度或者减少总线传输周期包括的时钟周期个数.16. 在异步串行传送系统中,字符格式为：1个起始位、8个数据位、1个校验位、2个终止位.若要求每秒传送120个字符,试求传送的波特率和比特率.解：一帧包括：1+8+1+2=12位故波特率为：（1+8+1+2）*120=1440bps比特率为：8*120=960bps存储器1. 解释概念：主存、辅存、Cache、RAM、SRAM、DRAM、ROM、PROM、EPROM、EEPROM、CDROM、Flash Memory.答：主存：主存储器,用于寄存正在执行的法式和数据.CPU可以直接进行随机读写,访问速度较高.辅存：辅助存储器,用于寄存以后暂不执行的法式和数据,以及一些需要永久保管的信息.Cache：高速缓冲存储器,介于CPU和主存之间,用于解决CPU 和主存之间速度不匹配问题.RAM：半导体随机存取存储器,主要用作计算机中的主存.SRAM：静态半导体随机存取存储器.DRAM：静态半导体随机存取存储器.ROM：掩膜式半导体只读存储器.由芯片制造商在制造时写入内容,以后只能读出而不能写入.PROM：可编程只读存储器,由用户根据需要确定写入内容,只能写入一次.EPROM：紫外线擦写可编程只读存储器.需要修改内容时,现将其全部内容擦除,然后再编程.擦除依靠紫外线使浮动栅极上的电荷泄露而实现.EEPROM：电擦写可编程只读存储器.CDROM：只读型光盘.Flash Memory：闪速存储器.或称快擦型存储器.2. 计算机中哪些部件可以用于存储信息？按速度、容量和价格/位排序说明.答：计算机中寄存器、Cache、主存、硬盘可以用于存储信息.按速度由高至低排序为：寄存器、Cache、主存、硬盘；按容量由小至年夜排序为：寄存器、Cache、主存、硬盘；按价格/位由高至低排序为：寄存器、Cache、主存、硬盘. 3. 存储器的条理结构主要体现在什么处所？为什么要分这些条理？计算机如何管理这些条理？答：存储器的条理结构主要体现在Cache-主存和主存-辅存这两个存储条理上.Cache-主存条理在存储系统中主要对CPU访存起加速作用,即从整体运行的效果分析,CPU访存速度加快,接近于Cache的速度,而寻址空间和位价却接近于主存.主存-辅存条理在存储系统中主要起扩容作用,即从法式员的角度看,他所使用的存储器其容量和位价接近于辅存,而速度接近于主存.综合上述两个存储条理的作用,从整个存储系统来看,就到达了速度快、容量年夜、位价低的优化效果.主存与CACHE之间的信息调度功能全部由硬件自动完成.而主存与辅存条理的调度目前广泛采纳虚拟存储技术实现,即将主存与辅存的一部份通过软硬结合的技术组成虚拟存储器,法式员可使用这个比主存实际空间（物理地址空间）年夜很多的虚拟地址空间（逻辑地址空间）编程,当法式运行时,再由软、硬件自动配合完成虚拟地址空间与主存实际物理空间的转换.因此,这两个条理上的调度或转换把持对法式员来说都是透明的.4. 说明存取周期和存取时间的区别.解：存取周期和存取时间的主要区别是：存取时间仅为完成一次把持的时间,而存取周期不单包括把持时间,还包括把持后线路的恢复时间.即：存取周期 = 存取时间 + 恢复时间5. 什么是存储器的带宽？若存储器的数据总线宽度为32位,存取周期为200ns,则存储器的带宽是几多？解：存储器的带宽指单位时间内从存储器进出信息的最年夜数量.存储器带宽 = 1/200ns ×32位 = 160M位/秒 = 20MB/秒 = 5M字/秒注意：字长32位,不是16位.（注：1ns=10-9s）6. 某机字长为32位,其存储容量是64KB,按字编址它的寻址范围是几多？若主存以字节编址,试画出主存字地址和字节地址的分配情况.解：存储容量是64KB时,按字节编址的寻址范围就是64K,如按字编址,其寻址范围为：64K / （32/8）= 16K主存字地址和字节地址的分配情况：如图7. 一个容量为16K×32位的存储器,其地址线和数据线的总和是几多？被选用下列分歧规格的存储芯片时,各需要几多片？1K×4位,2K×8位,4K×4位,16K×1位,4K×8位,8K×8位解：地址线和数据线的总和 = 14 + 32 = 46根；选择分歧的芯片时,各需要的片数为：1K×4：（16K×32） / （1K×4） = 16×8 = 128片2K×8：（16K×32） / （2K×8） = 8×4 = 32片4K×4：（16K×32） / （4K×4） = 4×8 = 32片16K×1：（16K×32）/ （16K×1） = 1×32 = 32片4K×8：（16K×32）/ （4K×8） = 4×4 = 16片8K×8：（16K×32） / （8K×8） = 2×4 = 8片8. 试比力静态RAM和静态RAM.答：略.（参看课件）9. 什么叫刷新？为什么要刷新？说明刷新有几种方法.解：刷新：对DRAM按期进行的全部重写过程；刷新原因：因电容泄漏而引起的DRAM所存信息的衰减需要及时弥补,因此安插了按期刷新把持；经常使用的刷新方法有三种：集中式、分散式、异步式.集中式：在最年夜刷新间隔时间内,集中安插一段时间进行刷新,存在CPU访存死时间.分散式：在每个读/写周期之后拔出一个刷新周期,无CPU访存死时间.异步式：是集中式和分散式的折衷.10. 半导体存储器芯片的译码驱动方式有几种？解：半导体存储器芯片的译码驱动方式有两种：线选法和重合法.线选法：地址译码信号只选中同一个字的所有位,结构简单,费器材；重合法：地址分行、列两部份译码,行、列译码线的交叉点即为所选单位.这种方法通过行、列译码信号的重合来选址,也称矩阵译码.可年夜年夜节省器材用量,是最经常使用的译码驱动方式.11. 一个8K×8位的静态RAM芯片,其内部结构排列成256×256形式,存取周期为0.1μs.试问采纳集中刷新、分散刷新和异步刷新三种方式的刷新间隔各为几多？解：采纳分散刷新方式刷新间隔为:2ms,其中刷新死时间为：256×0.1μs=25.6μs采纳分散刷新方式刷新间隔为：256×（0.1μs+×0.1μs）=51.2μs采纳异步刷新方式刷新间隔为:2ms12. 画出用1024×4位的存储芯片组成一个容量为64K×8位的存储器逻辑框图.要求将64K分成4个页面,每个页面分16组,指出共需几多片存储芯片.解：设采纳SRAM芯片,则：总片数 = （64K×8位） / （1024×4位）= 64×2 = 128片题意分析：本题设计的存储器结构上分为总体、页面、组三级,因此画图时也应分三级画.首先应确定各级的容量：页面容量 = 总容量 / 页面数 = 64K×8 / 4 = 16K×8位,4片16K×8字串连成64K×8位组容量 = 页面容量 / 组数 = 16K×8位 / 16 = 1K×8位,16片1K×8位字串连成16K×8位组内片数 = 组容量 / 片容量 = 1K×8位 / 1K×4位 = 2片,两片1K×4位芯片位并联成1K×8位存储器逻辑框图：（略）.13. 设有一个64K×8位的RAM芯片,试问该芯片共有几多个基本单位电路（简称存储基元）？欲设计一种具有上述同样多存储基元的芯片,要求对芯片字长的选择应满足地址线和数据线的总和为最小,试确定这种芯片的地址线和数据线,并说明有几种解答.解：存储基元总数 = 64K×8位 = 512K位 = 219位；思路：如要满足地址线和数据线总和最小,应尽量把存储元安插在字向,因为地址位数和字数成2的幂的关系,可较好地压缩线数.设地址线根数为a,数据线根数为b,则片容量为：2a×b = 219；b = 219-a；若a = 19,b = 1,总和 = 19+1 = 20；a = 18,b = 2,总和 = 18+2 = 20；a = 17,b = 4,总和 = 17+4 = 21；a = 16,b = 8,总和 = 16+8 = 24；…………由上可看出：芯片字数越少,芯片字长越长,引脚数越多.芯片字数减1、芯片位数均按2的幂变动.结论：如果满足地址线和数据线的总和为最小,这种芯片的引脚分配方案有两种：地址线 = 19根,数据线 = 1根；或地址线= 18根,数据线 = 2根.14. 某8位微型机地址码为18位,若使用4K×4位的RAM芯片组成模块板结构的存储器,试问：（1）该机所允许的最年夜主存空间是几多？（2）若每个模块板为32K×8位,共需几个模块板？（3）每个模块板内共有几片RAM芯片？（4）共有几多片RAM？（5）CPU如何选择各模块板？解：（1）该机所允许的最年夜主存空间是：218× 8位 = 256K×8位 = 256KB（2）模块板总数 = 256K×8 / 32K×8 = 8块（3）板内片数 = 32K×8位 / 4K×4位 = 8×2 = 16片（4）总片数 = 16片×8 = 128片（5）CPU通过最高3位地址译码输出选择模板,次高3位地址译码输出选择芯片.地址格式分配如下：15. 设CPU共有16根地址线,8根数据线,效）作访存控制信号,低电平为写）.现有下列存储芯片：ROM（2K×8位,4K×4位,8K×8位）,RAM（1K×4位,2K×8位,4K×8位）,及74138译码器和其他门电路（门电路自定）.试从上述规格中选用合适芯片,画出CPU和存储芯片的连接图.要求：（1）最小4K地址为系统法式区,4096~16383地址范围为用户法式区.（2）指出选用的存储芯片类型及数量.（3）详细画出片选逻辑.解：（1）地址空间分配图：系统法式区（ROM共4KB）：0000H-0FFFH用户法式区（RAM共12KB）：1000H-3FFFH（2）选片：ROM：选择4K×4位芯片2片,位并联RAM：选择4K×8位芯片3片,字串连(RAM1地址范围为:1000H-1FFFH,RAM2地址范围为2000H-2FFFH, RAM3地址范围为:3000H-3FFFH)（3）各芯片二进制地址分配如下：16. CPU假设同上题,现有8片8K×8位的RAM芯片与CPU相连,试回答：（1）用74138译码器画出CPU与存储芯片的连接图；（2）写出每片RAM的地址范围；（3）如果运行时发现不论往哪片RAM写入数据后,以A000H为起始地址的存储芯片都有与其相同的数据,分析故障原因.（4）根据（1）的连接图,若呈现地址线A13与CPU断线,并搭接到高电平上,将呈现什么后果？解：（1）CPU与存储器芯片连接逻辑图：（2）地址空间分配图：RAM0：0000H——1FFFHRAM1：2000H——3FFFHRAM2：4000H——5FFFHRAM3：6000H——7FFFHRAM4：8000H——9FFFHRAM5：A000H——BFFFH。

P13. 1.什么是计算机系统?计算机硬件、软件和数据通信设备的物理或逻辑的综合体.哪些部分属于硬件系统, 哪些部分属于软件系统?应如何看待二者之间的关系?硬软件二者相互依存,分工互动,缺一不可,硬件是计算机系统中的保存于运行软件程序的物质基础,软件则是只会硬件完成与其功能的智力部分.2.从传统的观点来看,基本计算机硬件系统由哪几个功能部件组成?计算机硬件是由:I/O设备,运算器,控制器,存储器组成的.每个部件完成的主要功能是什么?运算器: 数据处理、算术运算和逻辑运算.存储器: 存储数据与程序.控制器: 从存储器中取出只,并进行指令译码.输入设备: 输入数据,并且把人读数据变为机读数据输出设备: 输出数据,并且把机读数据变为人读数据它们之间是如何连接在一起的?它们是通过总线连接在一起的,其中总线包括:数据总线,地址总线,控制总线.3.什么是计算机系统的层次结构?一般可划分为哪几个层次?层次之间的关系体现在哪些方面?采用层次结构的观点来看待、分析计算机系统的组成由什么好处?P69 .1.把下面给出的几个十进制的数化成二进制的数(无法精确驶,小数点后取3位)、八进制的数和十六进制的数:7+3/4，-23/64, 27.5, -125.9375， 5.43十进制数二进制数八进制数十六进制数7+3/4 111.11 7.6 7.C-23/64 -0.010111 -0.2 -0.5C27.5 11011.1 33.4 1B.8-125.9375 -1111101.1111 -175.74 -7D.F5.43 101.011 5.3 5.682.把下面给出的几种不同进制的数化成十进制的数(1010.0101)2, -(101101111.101)2, (23.47)8, _(1A3C.D)16(1010.0101)2 =(10.3125) 10-(101101111.101)2 =-( 357.625)10(23.47)8 =(19+39/64)10 -(1A3C.D)16=-(6716+13/16) 10P91.1.简单说明ALU的设计过程和原理性电路组成.3.简述运算器部件在计算机整机系统中的功能和地位.7.在运算器部件中,为什么要设置多个累加器?累加器的数目多少对计算机的性能有什么影响吗? 为什么必须设置状态位寄存器?P110 .1一条指令通常由哪两部分内容组成?指令的操作码一般有哪几种组织方式?各自应用在什么场合?各自的优缺点是什么?一条指令要由操作码和操作数地址两部分组成,操作码用于指明本条指令的操作功能;指令的操作数地址,用于给出被操作的信息的地址,包括参加运算的一或多个操作数所在的地址、运算结果的保存地址、程序的转移地址、被调用的子程序的入口地址等.操作码的组织有如下三种处理情况:1、定长的操作码的组织方案:一般在指令字的最高位部分分配固定的若干位用于表示操作码. 优点: 简化计算机硬件设计,提高指令译码和识别的速度. 缺点: 单独为操作码划分出固定的多位后,留给表示操作数地址的位数就会严重不足.2、变长的操作码的组织方案:在指令字的最高位部分,安排指令的操作码,操作码有长有短.一些位在不同的指令中有不同的效用,在一些指令中,这些位用作操作码.而在另外一些指令中,这些位用作操作数的地址,则不同指令的操作数长度就会不同,即尽量为那些最常用、用于表示操作数地址的位数要求又较多的指令,少分配几位操作码;而对那些表示操作数地址位数要求较少的指令多分配几位操作码;对那些无操作数的质量,整个指令字的所有位均用作操作码. 优点: 在比较短的指令字中,既能表示出比较多的指令条数,又能尽量满足给出相应的操作数地址. 缺点: 指令复杂,译码时间长.执行时占用CPU周期多.3、操作码字段与操作数地址有所交叉的方案:与变长的操作码组织方案相类似,不同之处是表示操作码所用到的一些二进制位不再集中在指令字的最高位部分,而是与表示操作数地址的一引起字段有所交叉. 缺点: 指令比变长操作码的组织方案更复杂.2.说明CISC和RISC两种指令系统各自追求的目标、特点以及对计算机硬件系统构成方面的影响,人们在说到指令系统时,常提到的80%和20%是什么含义?CISC: 追求指令系统的功能复杂和完备,以弥补高级语言程序和机器语言程序之间的差异.RISC: 追求指令系统的精简高效,精简高速的硬件组成,精妙只能的编译软件,达到低价高性能的理想目的.CISC: 因为指令复杂,指令功能齐全,硬件实现复杂,指令条数多,并行性差.RISC: 指令条数少,指令长度固定,指令格式和寻址方式种类少,只有取数/存数指令访问存储器.4. 什么是形式地址?简述对变址寻址、相对寻址、基地址寻址英姿指令中给出些什么细心?如何得到相应的实际(有效)地址?各自有什么样的主要用法?表示在指令中的操作数地址,通常被称为形式地址;用这种形式地址并结合某些规则,可以计算出操作数在存储器中的存储单元地址,这一地址被称为物理地址.变址寻址:指令字中给出的一个数值(编制偏移量)与指定的一个寄存器(变址寄存器)的内容相加之和作为操作数的地址,用于读写存储器.主要是和于处理数组型数据.相对寻址: 指令字中给出的一个数值(相对寻址偏移量)与程序计数器PC的内容相加之和作为操作数的地址或转移指令的转移地址.与变址寻址的区别是,计算实际地址所用的寄存器已确定为PC,故无须再在指令中指定本次要使用哪一个.主要用于指令转移.基地址寻址: 把在程序中所用的地址与一个特定的寄存器(基地址寄存器)的内容相加之和作为操作数的地址或指令的地址.只要用于为多道程序或浮动地址程序定位存储器空间.基地址寄存器中的值是由系统程序用特权指令设定的,用户不能在自己的程序对其进行修改.5. 堆栈的主要作用的什么?如何完成读写堆栈的操作?6寄存器寻址和寄存器间接寻址的区别是什么?P148. 5.简述计算机控制器的功能和基本组成,说明微程序的控制器和硬连线的控制器在组成和运行原来方面的相同与不同之处.P185. 1.在计算机中,为什么要采用多级结构的存储器系统?它的应用是建立在程序的哪些特性之上的?在现代的计算机系统中,通常总是采用由三种运行原理不同,性能差异很大的存储介质分别构建高速缓冲存储器、主存储器和虚拟存储器,再将它们组成三级结构的统一管理、高度的一体化存储器系统.由高速缓冲存储器读写速度慢,不能满足CPU运行速度需要的矛盾; 用虚拟存储器更大的存储空间,解决主存储器容量小,存不下更大程序与更多数据的难题.这种三级结构的存储器系统的运行原理,是建立在程序运行的局部性原理之上的.即在一小段时间内,运行的程序只使用少量的指令和少量的数据.而这少量的指令和少量的数据网王又集中在存储器的一小片存储区域中,指令顺序执行比转移执行的比例要高,故可以按对所使用的指令和数据的急迫和频繁程度,将其存入容量、速度、价格不同的存储器中,从而取得更高的性价比.主要体现在时间、空间、指令执行顺序三个方面.2多级结构的存储器是由哪3级存储器组成的?每一级的存储器使用什么类型的存储介质?这些介质的主要特性是什么?答:三级存储器由高速缓冲存储器、主存储器和虚拟存储器组成.使用的存储器介质:高速缓存SRAM、主存DRAM和虚存DISC.这些介质的主要特性:高速缓存以块传送、主存以页传送、虚存以文件传送;它们的速度依次降低,每次价格依次降低;它们的管理依次由硬件、OS、OS/用户.在多级结构的存储器系统中,何谓信息的一致性原则和包含性原则?一致性原则:同一个信息会同时存放在几个级别的存储器中,此时,这一信息在几个级别的存储器重必须保持相同的值.包含性原则:处在内层(更靠近CPU)存储器中的信息一定被包含在各外层的存储器中,即内层存储器中的全部信息一定是各外层存储器中所存信息中的一小部分的副本.3.比较DRAM和SRAM芯片的主要特性.答:从所用的半导体生产工艺区分,存储器芯片可以分为静态存储器和动态存储器两种类型.由于动态存储器集成度高,生产成本低,被广泛地用于实际要求更大容量的主存储器.静态存储器读写速度快,生产成本高,通常多用实现容量可以较小的高速缓冲存储器.两者的不同之处如下表:。

一、填空题（20每空2分）1.计数制中使用的数据个数被称为。

（基）2.移码常用来表示浮点数的部分，移码和补码比较，它们除外，其他各位都相同。

（阶码，符号位）3.码值80H：若表示真值0，则为；若表示-128，则为；若表示-127，则为；若表示-0，则为。

（移码补码反码原码）4. 在浮点运算过程中，如果运算结果的尾数部分不是形式，则需要进行规格化处理。

设尾数采用补码表示形式，当运算结果时，需要进行右规操作；当运算结果时，需要进行左规操作。

（规格化溢出不是规格化数）二、选择题（20每题2分）1.以下给出的浮点数，______是规格化浮点数。

（B）A．2^-10×0.010101 B．2^-11×0.101010C．2^-100×1.010100 D．2^-1×0.00101012.常规乘除法器乘、除运算过程采用部分积、余数左移的做法，其好处是______。

（C）A．提高运算速度 B. 提高运算精度C. 节省加法器的位数D. 便于控制3.逻辑异运算10010011和01011101的结果是。

（B）A.01001110B.11001110C.11011101D.100011104.浮点数尾数基值rm=8,尾数数值部分长6位，可表示的规格化最小正尾数为。

（C）1.A.0.5 B.0.25 C.0.125 D.1/645.当浮点数尾数的基值rm=16,除尾符之外的尾数机器位数为8位时，可表示的规格化最大尾数值是。

（D）A.1/2B.15/16C.1/256D.255/2566.两个补码数相加，采用1位符号位，当时表示结果溢出。

（D）A、符号位有进位B、符号位进位和最高数位进位异或结果为0C、符号位为1D、符号位进位和最高数位进位异或结果为17.运算器的主要功能时进行。

（C）A、逻辑运算B、算术运算C、逻辑运算和算术运算D、只作加法8.运算器虽有许多部件组成，但核心部件是。

计算机组成与设计智慧树知到课后章节答案2023年下山东大学山东大学绪论单元测试1.完整的计算机系统通常包括( )A:运算器、控制器、存储器B:主机和应用软件器C:硬件系统与软件系统D:主机、外部设备答案:硬件系统与软件系统2.计算机硬件的主要指标（）A:运算速度B:总线宽度C:机器字长D:存储容量答案:运算速度;机器字长;存储容量3.将高级语言源程序转换为机器目标代码文件的程序是（）A:解释程序B:汇编程序C:链接程序D:编译程序答案:编译程序4.下列关于冯·诺依曼结构计算机基本思想的叙述中，错误的是（）A:程序执行前，指令和数据需预先存放在存储器中B:指令和数据都用二进制表示，形式上无差别C:指令按地址访问，数据都在指令中直接给出D:程序的功能都通过中央处理器执行指令实现答案:指令按地址访问，数据都在指令中直接给出5.汇编语言与机器语言的关系是（）A:一对多B:多对一C:多对多D:一对一答案:一对一6.冯·诺依曼计算机中指令和数据均以二进制形式存放在存储器中，CPU区分它们的依据是（）A:指令和数据的寻址方式B:指令周期的不同阶段C:指令操作码的译码结果D:指令和数据所在的存储单元答案:指令周期的不同阶段7.基于存储器，其主要作用是（）。

A:存放程序B:存放微程序C:存放数据D:存放程序和数据答案:存放程序和数据8.CPU内通用寄存器的位数取决于（）。

A:CPU的管脚数B:指令的长度C:存储器容量D:机器字长答案:机器字长9.下列关于硬件与软件关系的描述中，正确的是( )A:软件能完成的功能及性能与硬件有关B:软件的发展也推动硬件的发展C:硬件是软件运行的基础D:硬件的发展推动了软件的发展答案:软件能完成的功能及性能与硬件有关;软件的发展也推动硬件的发展;硬件是软件运行的基础;硬件的发展推动了软件的发展10.下列属于冯•诺依曼计算机的核心思想是( )A:存储程序和程序控制B:采用总线C:存储器按地址访问D:采用补码答案:存储程序和程序控制第一章测试1.设机器字长为8位（其中1位为符号位）的整数，当其表示为无符号数、机器数时的范围为（）A:补码 -128—127B:原码 -128—127C:反码 -128—127D:无符号数 0—255答案:无符号数 0—2552.在计算机中，小数点保存在（）A:存储单元的次高位B:存储单元的最低位C:存储单元的最高位D:不保存答案:不保存3.若八位寄存器中保存的信息是11111111时，若为补码，其真值大小为（）A:+127B:-1C:+1D:-128答案:-14.在下列表示法中，“0”只有一种表示形式的是（）A:补码B:转码C:原码D:反码答案:补码5.若某种编码的最小距离是4，其检错和纠错能力可能是（）A:检错1位，纠错2位B:检错3位，纠错2位C:检错2位，纠错2位D:检错3位，纠错1位答案:检错3位，纠错1位6.一个C语言程序在一台32位机器上运行。