Solution* for Chapter 1 Exercise*

Solutions for Chapter 1 Exercises
1.1 5, CPU
1.2 1, abstraction
1.3 3, bit
1.4 8, computer family
1.5 19, memory
1.6 10, datapath
1.7 9, control
1.8 11, desktop (personal computer)
1.9 15, embedded system
1.10 22, server
1.11 18, LAN
1.12 27, WAN
1.13 23, supercomputer
1.14 14, DRAM
1.15 13, defect
1.16 6, chip
1.17 24, transistor
1.18 12, DVD
1.19 28, yield
1.20 2, assembler
1.21 20, operating system
1.22 7, compiler
1.23 25, VLSI
1.24 16, instruction
1.25 4, cache •
1.26 17, instruction set architecture

Solutions for Chapter 1 Exercises

1.27 21, semiconductor
1.28 26, wafer
1.29 i
1.30 b
1.31 e
1.32 i
1.33 h
1.34 d
1.35 f
1.36 b
1.37 c
1.38 f

1.39 d
1.40 a
1.41 c
1.42 i
1.43 e
1.44 g
1.45 a
1.46 Magnetic disk:
Time for 1/2 revolution =1/2 rev x 1/7200 minutes/rev X 60 seconds/ minutes 3 4.17 ms
Time for 1/2 revolution = 1/2 rev x 1/10,000 minutes/rev X 60 seconds/ minutes = 3 ms

Bytes on center circle = 1.35 MB/seconds X 1/1600 minutes/rev x 60 seconds/minutes = 50.6 KB
Bytes on outside circle = 1.35 MB/seconds X 1/570 minutes/rev X 60 seconds/minutes = 142.1 KB
1.48 Total requests bandwidth = 30 requests/sec X 512 Kbit/request = 15,360
Kbit/sec < 100 Mbit/sec. Therefore, a 100 Mbit Ethernet link will be sufficient.

Solution* for Chapter X Exarclsm

1.49 Possible solutions:
Ethernet, IEEE 802.3, twisted pair cable, 10/100 Mbit
Wireless Ethernet, IEEE 802.1 lb, no medium, 11 Mbit
Dialup, phone lines, 56 Kbps
ADSL, phone lines, 1.5 Mbps
Cable modem, cable, 2 Mbps
1.50
a. Propagation delay = mis sec
Transmission time = LIR sec
End-to-end delay =m/s+L/R
b. End-to-end delay =mls+ LJR+t
c. End-to-end delay = mis + 2I/R + f/2
1.51 Cost per die = Cost per wafer/(Dies per wafer x Yield) = 6000/( 1500 x 50%)
=8
Cost per chip = (Cost per die + Cost_packaging + Cost_testing)/Test yield =
(8 + 10)/90% = 20
Price = Cost per chip x (1 + 40%) - 28
If we need to sell n chips, then 500,000 + 20« = 28», n = 62,500.
1.52 CISCtime = P x 8 r = 8 P r n s
RISC time = 2Px 2T= 4 PTns
RISC time = CISC time/2, so the RISC architecture has better performance.
1.53 Using a Hub:
Bandwidth that the other four computers consume = 2 Mbps x 4 = 8 Mbps
Bandwidth left for you = 10 - 8 = 2 Mbps
Time needed = (10 MB x 8 bits/byte) / 2 Mbps = 40 seconds
Using a Switch:
Bandwidth that the other four computers consume = 2 Mbps x 4 = 8 Mbps
Bandwidth left for you = 10 Mbps. The communication between the other computers will not disturb you!
Time needed = (10 MB x 8 bits/byte)/10 Mbps = 8 seconds

Solutions for Chapter 1 EXWCIMS

1.54 To calculate d = a x f c - a x c , the CPU will perform 2 multiplications and 1 subtraction. Time needed = 1 0 x 2 + 1 x 1 = 2 1 nanoseconds.
We can simply rewrite the equation &sd = axb-axc= ax (b-c). Then 1 multiplication and 1 subtraction will be performed.
Time needed = 1 0 x 1 + 1 x 1 = 11 nanoseconds.
1.55 No solution provided.
1.56 No solution provided.
1.57 No solution provided.
1.68 Performance characteristics:
Network address
Bandwidth (how fast can data be transferred?)
Latency (time between a request/response pair)
Max transmission unit (the maximum number of data that can be transmitted in one shot)
Functions the interface provides:
Send data
Receive data
Status report (whether the cable is connected, etc?)
1.69 We can write Dies per wafer = /((Die area)"1) and Yield = /((Die area)"2) and thus Cost per die = /((Die area)3).
1.60 No solution provided.
1.61 From the caption in Figure 1.15, we have 165 dies at 100% yield. If the defect density is 1 per square centimeter, then the yield is approximated by
1

= .198.

1 +

Thus, 165 x .198 = 32 dies with a cost of $1000/32 = $31.25 per die.

Solution* for Chapter 1 Exercises

1.62 Defects per area.
1

Yield =

1
(1 + Defects per area x Die a r e a / 2 ) 2

Defects per area = —:

1992

Die ares
Yield
Defect density
Die area

1992 + 19S0

Yield
Defect density improvement 1980

j —L ••— - 1 |

0.16
0.48
5.54
0.97
0.48
0.91
6.09

Solutions for Chapter 2 ExardsM

Solutions for Chapter 2 Exercises
2.2 By lookup using the table in Figure 2.5 on page 62,
7ffififfohoi = 0111 1111 1111 1111 1111 1111 1
= 2,147,483,642^.
2.3 By lookup using the table in Figure 2.5 on page 62,
1100 1010 1111 1110 1111 1010 1100 111
V Time,
*->
'

y Time;
M,
LzJ

l JL,
- > Tirr n-^ where AM is the arithmetic mean of the corresponding execution times.
4.32 No solution provided.
4.33 The time of execution is (Number of instructions) * (CPI) * (Clock period).
So the ratio of the times (the performance increase) is:
10.1 = (Number of instructions) * (CPI) * (Clock period)
(Number of instructions w/opt.) * (CPI w/opt.) * (Clock period)
= l/(Reduction in instruction count) * (2.5 improvement in CPI)
Reduction in instruction count = .2475.
Thus the instruction count must have been reduced to 24.75% of the original.
4.34 We know that
(Number of instructions on V) * (CPI on V) * (Clock period)
(Time on V) _ (Number of instructions on V) * (CPI on V) * (Clock period)
(Time on P) "* (Number of instructions on P) * (CPI on P) * (Clock period)
5 = (1/1.5) * (CPI ofV)/(1.5 CPI)
CPI of V= 11.25.
4.45 The average CPI is .15 * 12 cycles/instruction + .85 * 4 cycles/instruction =
5.2 cycles/instructions, of which .15 * 12 = 1.8 cycles/instructions of that is due to multiplication instructions. This means that multiplications take up 1.8/5.2 =
34.6% of the CPU time.

Solutions for Chapter 4 E X W C I M *

4.46 Reducing the CPI of multiplication instructions results in a new average CPI of .15 * 8 + .85 * 4 = 4.6. The clock rate will reduce by a factor of 5/6 . So the new performance is (5.2/4.6) * (5/6) = 26/27.6 times as good as the original. So the modification is detrimental and should not be made.
4.47 No solution provided.
4.48 Benchmarking suites are only useful as long as they provide a good indicator of performance on a typical workload of a certain type. This can be made untrue if the typical workload changes. Additionally, it is possible that, given enough time, ways to optimize for benchmarks in the hardware or compiler may be found, which would reduce the meaningfulness of the benchmark results. In those cases changing the benchmarks is in order.
4.49 Let Tbe the number of seconds that the benchmark suite takes to run on
Computer A. Then the benchmark takes 10 * T seconds to run on computer B. The new speed of A is (4/5 * T+ 1/5 * (T/50)) = 0.804 Tseconds. Then the performance improvement of the optimized benchmark suite on A over the benchmark suite on
B is 10 * T/(0.804 T) = 12.4.
4.50 No solution provided.
4.51 No solution provided.
4.82 No solution provided.

Solution* for Chapter 5 E X M C I M S

Solutions for Chapter 5 Exercises
5.1 Combinational logic only: a, b, c, h, i
Sequential logic only: f, g, j
Mixed sequential and combinational: d, e, k
5.2
a. RegWrite = 0: All R-format instructions, in addition to 1 w, will not work because these instructions will not be able to write their results to the register file.
b. ALUopl = 0: All R-format instructions except subtract will not work correctly because the ALU will perform subtract instead of the required ALU operation. c. ALUopO = 0: beq instruction will not work because the ALU will perform addition instead of subtraction (see Figure 5.12), so the branch outcome may be wrong.
d. Branch (or PCSrc) = 0: beq will not execute correctly. The branch instruction will always be not taken even when it should be taken.
e. MemRead = 0: 1 w will not execute correctly because it will not be able to read data from memory.
f. MemWrite = 0: sw will not work correctly because it will not be able to write to the data memory.
S.3
a. RegWrite = 1: sw and beq should not write results to the register file, sw
(beq) will overwrite a random register with either the store address (branch target) or random data from the memory data read port.
b. ALUopO = 1: 1 w and sw will not work correctly because they will perform subtraction instead of the addition necessary for address calculation.
c. ALUopl = 1: 1 w and sw will not work correctly. 1 w and sw will perform a random operation depending on the least significant bits of the address field instead of addition operation necessary for address calculation.
d. Branch = 1: Instructions other than branches (beq) will not work correctly if the ALU Zero signal is raised. An R-format instruction that produces zero output will branch to a random address determined by its least significant
16 bits.
e. MemRead = 1: All instructions will work correctly. (Data memory is always read, but memory data is never written to the register file except in the case oflw.) Solution* for Chapter B ExardsM

f. MemWrite = 1: Only sw will work correctly. The rest of instructions will store their results in the data memory, while they should not.
5.7 No solution provided.
5.8 A modification to the datapath is necessary to allow the new PC to come from a register (Read data 1 port), and a new signal (e.g., JumpReg) to control it through a multiplexor as shown in Figure 5.42.
A new line should be added to the truth table in Figure 5.18 on page 308 to implement the j r instruction and a new column to produce the JumpReg signal.
5.9 A modification to the data path is necessary (see Figure 5.43) to feed the shamt field (instruction [10:6]) to the ALU in order to determine the shift amount
The instruction is in R-Format and is controlled according to the first line in Figure 5.18 on page 308.
The ALU will identify the s 11 operation by the ALUop field.
Figure 5.13 on page 302 should be modified to recognize the opcode of si 1; the third line should be changed to 1X1X0000 0010 (to discriminate the a d d and s s 1 functions), and a new line, inserted, for example, 1X0X0000 0011 (to define si 1 by the 0011 operation code).
5.10 Here one possible 1 u i implementation is presented:
This implementation doesn't need a modification to the datapath. We can use the
ALU to implement the shift operation. The shift operation can be like the one presented for Exercise 5.9, but will make the shift amount as a constant 16. A new line should be added to the truth table in Figure 5.18 on page 308 to define the new shift function to the function unit. (Remember two things: first, there is no funct field in this command; second, the shift operation is done to the immediate field, not the register input.)
RegDst = 1: To write the ALU output back to the destination register ( t r t ) .
ALUSrc = 1: Load the immediate field into the ALU.
MemtoReg = 0: Data source is the ALU.
RegWrite = 1: Write results back.
MemRead = 0: No memory read required.
MemWrite = 0: No memory write required.
Branch = 0: Not a branch.
ALUOp = 11: si 1 operation.
This ALUOp (11) can be translated by the ALU asshl,ALUI1.16by modifying the truth table in Figure 5.13 in a way similar to Exercise 5.9.

Solutions for ChapUr S ExardMS

Solutions for Chapter 8 Exorclsos

Solutions for Chapter 5 Ex*rd*«»

5 . U A modification is required for the datapath of Figure 5.17 to perform the autoincrement by adding 4 to the $ r s register through an incrementer. Also we need a second write port to the register file because two register writes are required for this instruction. The new write port will be controlled by a new signal, "Write 2", and a data port, "Write data 2." We assume that the Write register 2 identifier is always the same as Read register 1 {$ rs). This way "Write 2" indicates that there is second write to register file to the register identified by "Read register
1," and the data is fed through Write data 2.
A new line should be added to the truth table in Figure 5.18 for the 1 _ i n c command as follows:
RegDst = 0: First write to $rt.
ALUSrc = 1: Address field for address calculation.
MemtoReg = 1: Write loaded data from memory.
RegWrite = 1: Write loaded data into $ r t.
MemRead = 1: Data memory read.
MemWrite = 0: No memory write required.
Branch = 0: Not a branch, output from the PCSrc controlled mux ignored.
ALUOp = 00: Address calculation.
Write2 = 1: Second register write (to $rs).
Such a modification of the register file architecture may not be required for a multiple-cycle implementation, since multiple writes to the same port can occur on different cycles.
5.12 This instruction requires two writes to the register file. The only way to implement it is to modify the register file to have two write ports instead of one.
5.13 From Figure 5.18, the MemtoReg control signal looks identical to both signals, except for the don't care entries which have different settings for the other signals. A don't care can be replaced by any signal; hence both signals can substitute for the MemtoReg signal.
Signals ALUSrc and MemRead differ in that sw sets ALSrc (for address calculation) and resets MemRead (writes memory: can't have a read and a write in the same cycle), so they can't replace each other. If a read and a write operation can take place in the same cycle, then ALUSrc can replace MemRead, and hence we can eliminate the two signals MemtoReg and MemRead from the control system.
Insight: MemtoReg directs the memory output into the register file; this happens only in loads. Because sw and beq don't produce output, they don't write to the

Solutions for Chapter 8 Exercise*

register file (Regwrite = 0), and the setting of MemtoReg is hence a don't care. The important setting for a signal that replaces the MemtoReg signal is that it is set for
1 w (Mem->Reg), and reset for R-format (ALU->Reg), which is the case for the
ALUSrc (different sources for ALU identify 1 w from R-format) and MemRead (1 w reads memory but not R-format).
5.14 swap $rs,$rt can be implemented by addi $rd,$rs,0

addi

$rs,$rt,0

addi

$rt,$rd,0

if there is an available register $ r d or sw $rs,temp($rO) addi $rs,$rt,0

Iw $ r t , t e m p ( $ r O ) if not.
Software takes three cycles, and hardware takes one cycle. Assume Rs is the ratio of swaps in the code mix and that the base CPI is 1:
Average MIPS time per instruction = Rs* 3* T + ( l - Rs)* 1* T={2Rs + 1) * T
Complex implementation time = 1.1 * T
If swap instructions are greater than 5% of the instruction mix, then a hardware implementation would be preferable.
. 5.27 l _ i n c r $ r t , A d d r e s s ( I r s ) can be implemented as
?w trt.Address(trs) addi $rs,$rs,l
Two cycles instead of one. This time the hardware implementation is more efficient if the load with increment instruction constitute more than 10% of the instruction mix.
5.28 Load instructions are on the critical path that includes the following functional units: instruction memory, register file read, ALU, data memory, and register file write. Increasing the delay of any of these units will increase the clock period of this datapath. The units that are outside this critical path are the two

I

Solutions for Chapter B ExarcUa*

adders used for PC calculation (PC + 4 and PC + Immediate field), which produce the branch outcome.
Based on the numbers given on page 315, the sum of the the two adder's delay can tolerate delays up to 400 more ps.
Any reduction in the critical path components will lead to a reduction in the dock period. 5.29
a. RegWrite = 0: All R-format instructions, in addition to 1 w, will not work because these instructions will not be able to write their results to the register file.
b. MemRead = 0: None of the instructions will run correctly because instructions will not be fetched from memory.
c. MemWrite = 0: s w will not work correctly because it will not be able to write to the data memory.
d. IRWrite = 0: None of the instructions will run correctly because instructions fetched from memory are not properly stored in the IR register.
e. PCWrite = 0: Jump instructions will not work correctly because their target address will not be stored in the PC.
f. PCWriteCond = 0: Taken branches will not execute correctly because their target address will not be written into the PC.
5.30
a. RegWrite = 1: Jump and branch will write their target address into the register file, sw will write the destination address or a random value into the register file.
b. MemRead = 1: All instructions will work correctly. Memory will be read all the time, but IRWrite and IorD will safeguard this signal.
c. MemWrite = 1: All instructions will not work correctly. Both instruction and data memories will be written over by the contents of register B.
d. IRWrite= 1: lw will not work correctly because data memory output will be translated as instructions.
e. PCWrite = 1: All instructions except jump will not work correctly. This signal should be raised only at the time the new PC address is ready (PC + 4 at cycle 1 and jump target in cycle 3). Raising this signal all the time will corrupt the PC by either ALU results of R-format, memory address of 1 w/sw, or target address of conditional branch, even when they should not be taken.
f. PCWriteCond = 1: Instructions other than branches (beq) will not work correctly if they raise the ALU's Zero signal. An R-format instruction that produces zero output will branch to a random address determined by .their least significant 16 bits.

Solution* for Chapter 8 E X M V I S M

5.31 RegDst can be replaced by ALUSrc, MemtoReg, MemRead, ALUopl.
MemtoReg can be replaced by RegDst, ALUSrc, MemRead, or ALUOpl.
Branch and ALUOpO can replace each other.
5.32 We use the same datapath, so the immediate field shift will be done inside theALU. 1. Instruction fetch step: This is the same (IR