CS/COE0447 Computer Organization & Assembly Language Chapter 5 Part 3 In-Class Exercises

For Reference The following slides contain a subset of Chapter 5 Part 3 – the essentials, without the animations, discussion, and so on. You will get a copy of Figure 5.28 on Exam3 and the Final Rather than trying to memorize the other slides, try to reconstruct them while looking at Figure 5.28 and thinking about how the instructions are executed

Multi-Cycle Execution: R-type Instruction fetch IR <= Memory[PC]; sub $t0,$t1,$t2 PC <= PC + 4; Decode instruction/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; rt ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution ALUOut <= A op B; op = add, sub, and, or,… Completion Reg[IR[15:11]] <= ALUOut; $t0 <= ALU result

Multi-cycle Execution: lw Instruction fetch IR <= Memory[PC]; lw $t0,-12($t1) PC <= PC + 4; Instruction Decode/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution ALUOut <= A + sign-extend(IR[15:0]); $t1 + -12 (sign extended) Memory Access MDR <= Memory[ALUOut]; M[$t1 + -12] Write-back Load: Reg[IR[20:16]] <= MDR; $t0 <= M[$t1 + -12]

Multi-cycle Execution: sw Instruction fetch IR <= Memory[PC]; sw $t0,-12($t1) PC <= PC + 4; Decode/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; rt ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution ALUOut <= A + sign-extend(IR[15:0]); $t1 + -12 (sign extended) Memory Access Memory[ALUOut] <= B; M[$t1 + -12] <= $t0

Multi-cycle execution: beq Instruction fetch IR <= Memory[PC]; beq $t0,$t1,label PC <= PC + 4; Decode/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; rt ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution if (A == B) then PC <= ALUOut; if $t0 == $t1 perform branch

Multi-cycle execution: j Instruction fetch IR <= Memory[PC]; j label PC <= PC + 4; Decode/register read A <= Reg[IR[25:21]]; B <= Reg[IR[20:16]]; ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution PC <= {PC[31:28],IR[25:0],”00”};

Fig 5.28 Our final multicycle datapath

A Finite State Machine to generate the control signals  wrong; RegDst = 0; MemtoReg = 1

Question In terms of the datapath in Figure 5.28, how is the branch target address calculated, and where is it stored? In other words, fill in the following: ______ <= ______ + ______________

Answer In terms of the datapath in Figure 5.28, how is the branch target address calculated, and where is it stored? ALUOut <= PC + (sign-extend(IR[15:0])<<2) Recall: beq is I-format: Opcode[31:26] rs[25:21] rt[20:16] imm[15:0] Quiz yourself until it’s easy: what is imm[15:0] for a beq instruction? Why is the above the branch target address?

Question For which instruction(s) is the branch target address calculated? During which cycle(s)? Ans: It is calculated during cycle 2 for all instructions. If the current instruction turns out to not be a branch, then the value was calculated for nothing. But, doing this means that branch instructions take 3 rather than 4 cycles. Go back and look at the instruction execution steps for beq (slide 6). The ALU is not being used for anything else that cycle, so we can use it for this. The things added are the PC and information from the IR, both of which are available during this cycle. Note: the hardware is decoding the instruction during this cycle, but the various fields ARE available, in the IR. The hardware HAS the current instruction; it just doesn’t “understand” it yet.

Question What happens during the 3rd cycle for a memory access instruction? Well, which are the memory access instructions? lw, sw in the subset covered in this chapter. [Others are lbu, lhu, lui] _____ <= _______ + _______________

Answer What happens during the 3rd cycle for a memory access instruction? ALUOut <= A + sign-extend(IR[15:0]) What does A contain? rs, which was read into A 2nd cycle What does ALUOut now contain? The effective address for the memory access: the memory location we are reading from or writing to

Question What happens during the first cycle for all instructions? Ans: IR <= Memory[PC] The next instruction is read from memory, and stored in the Instruction Register (IR) PC = PC + 4 The PC is incremented to point to the next instruction

Question Is the ALU needed to execute a j instruction? No: its execution is PC <= {PC[31:28],IR[25:0],”00”}

Question Why does the j instruction require 3 cycles, since it doesn’t require rs, rt, or rd and does not require the ALU? Cycle 1: instruction fetch Cycle 2: decode instruction Cycle 3: It is only by here that the instruction has been decoded, and the hardware “knows” it is a j (see slide 7)

Question For a LW, what is ALUSrcB on each cycle? (Figure 5.28 is on slide 8) Cycle 1: PC = PC+4, so ans = 01 Cycle 2: Compute branch target address, so ans = 3 0b11 Cycle 3: Compute effective address, so ans = 2 0b10 Cycle 4: No use of ALU, so X Cycle 5: No use of ALU, so X

Question For a BEQ, what is ALUSrcB on each cycle? (Figure 5.28 is on slide 8) Cycle 1: PC = PC+4, so ans = 01 Cycle 2: Compute branch target address, so ans = 3 0b11 Cycle 3: Perform A – B, so ans = 00

Question For which instructions, during which cycles, is ALUSrcA = 0? Well, it is 0 whenever something is added to the PC All instructions, Cycle 1 PC = PC + 4 All instructions, Cycle 2 ALUOut <= PC + (sign-extend(IR[15:0])<<2) That’s it!

Question For which instructions, during which cycles, is ALUSrcA = 01? (not X) Whenever the ALU is used to compute something and the top input is A (rs) R-type, cycle 3 ALUOut <= A op B Memory access (lw, sw), cycle 3 ALUOut <= A + sign-extend(IR[15:0]) beq, cycle 3 If (A == B): if A – B == 0

Question Is there any instruction, cycle where one of ALUSrcA and ALUSrcB is X and the other one isn’t? Nope. If the ALU is needed for something, it needs 2 operands. These two control signals choose the operands.

Question In the FSM for generating the control signals, not all of the signals are shown in each state. Look at the machine, and figure out when a signal is not shown. Hint: there are two cases Case 1: a signal that is X (MUXs and ALU Op) Case 2: a signal that is essentially an on/off switch whose value is 0 (and cannot be X) PCWriteCond,PCWrite,MemWrite,IRWrite, RegWrite (can’t be X: incorrect writes!) MemRead (can’t be X: we don’t want unneeded memory reads)

Question In the FSM, which instruction, cycle is state 8? Beq, cycle 3 How about state 1? All instructions, cycle 2 How about state 7? R-type, cycle 4

Question In the FSM, when is the transition made from state 4 to state 0? After a lw instruction finishes: we start over again in state 0 for the next instruction. Note that this is an unconditional transition: After state 4 finishes, we always transition to state 0.

Question In the FSM, where do we transition from state 1? It depends on the opcode: 2 if opcode == 0x23 or 0x2b 6 if opcode = 0b000000 8 if opcode = 0x4 9 if opcode = 0x2

Remember this from the single-cycle datapath?

And this (from single-cycle datapath)? This needs to change. The signals depend on opcode plus which cycle it is. And, it is under the control of the clock. We won’t look at further details of the FSM implementation. Control Unit ALU Control Unit This can stay the same. The current values of ALUOp1 and ALUOp0 determine what the ALU does. Before, ALUOp0 and ALUOp1 depended only on the opcode. Now, as with the other control signals, they also need to depend on which cycle it is.

from the single-cycle datapath What we do want to do is figure out what values ALUOp1 and ALUOp0 have for each instruction, and for each cycle Note: they are X if the ALU is not used during a cycle.

from the single-cycle datapath The ALU is used during cycles 1 and 2 for all instructions PC = PC+4 (c1); Calculate the branch target address (c2) It is used to calculate the effective address for lw,sw on cycle 3 It is used to perform the op for R-type instructions on cycle 3 It is used to perform the comparison for beq instructions on cycle 3

Remember this from the single-cycle datapath? It is used to perform the op for R-type instructions on cycle 3. So, what should ALUOp1 and ALUOp2 be for R instructions on cycle 3? They should be 10, so that the funct field determines what the ALU does.

from the single-cycle datapath ALU is used to calculate the effective address for lw,sw on cycle 3. So, on cycle 3, ALUOp1 and ALUOp0 should be … 00

from the single-cycle datapath What should ALUOp1 and ALUOp0 be for a beq instruction (in the multicycle datapath?) Bad question! You should ask me, during which cycle? I’ll turn things around: during which cycle should they have the 01 value listed in the table above for BEQ? During cycle 3! that is when the subtraction is performed to do the comparison

from the single-cycle datapath The ALU is used during cycles 1 and 2 for all instructions PC = PC+4 (c1); Calculate the branch target address (c2) Which value should ALUOp have during cycles 1 and 2? In both cases: 00. Then, the ALU will perform addition.

from the single-cycle datapath The ALU is used during cycles 1 and 2 for all instructions In both cases: 00. Then, the ALU will perform addition. Is the R-type ADD an option? No! The funct field is the bottom 6 bits of the IR, whatever they happen to be!