1. DLX computer
Electronic Computers M

2. RISC architectures
RISC vs CISC (Reduced Instruction Set Computer vs Complex Instruction Set Computer
In CISC architectures the 10% of the instructions are used in 90% of cases
Waste of silicium
Bottleneck: the bus
Mid ‘80s a new architecture: RISC
Solution: reduction of instruction number and complexity (fewer simpler machine instructions)
Fixed instruction format (simpler instruction decoders)
Simpler control logic network increasing the number of on-chip registers
Reduction of bus/memory accesses
Increase of machine instructions needed for a job which is (in many cases) more than compensated (in term of time) by the reduction of bus accesses
CISC and RISC are each one the best solution in different application fields
Nowadays coexistence of both architectures in the same processor: analysis at the end of the course
A simplified RISC architecture: DLX (implemented as real processor in the ‘80s as R4000)

3. DLX (fixed) instruction format
6 bit
5 bit
5 bit
5 bit
11 bit R
Op-code
RS1
RS2 Rd
Cod. op (11 bit) extension
Arithmetic or logic instructions as Rd  RS1 op RS2 or Set Conditions between registers I
Op-code
RS1
RS2
16 bit immediate operand
Load, Store, conditional Branch , JR and JALR (Control transfer via register), Set Condition e ALU with immediate operator. In LD and ALU instructions RS2=destination, in the ST RS2=source. -- RS1 used as base address or as ALU value for the immediate instructions J
Op-code
26 bit (PC relative) offset
Direct and unconditional control transfer(J e JAL)

4. DLX non floating-point instructions
(31x32bit registers R31…R1 - R0=0 fixed - Ra and Rb any of the 32 registers)
Data Transfer
LW Ra, offset(Rb)
LB Ra, offset(Rb)
LBU Ra, offset(Rb)
LHU Ra, offset(Rb)
LH Ra, offset(Rb)
SW Ra, offset(Rb)
SH Ra, offset(Rb)
SB Ra, offset(Rb)
LHI Ra, value
Arithmetic/Logic
ADD Ra,Rb,Rc
ADDI Ra,Rb,value
ADDU Ra,Rb,Rc
ADDUI Ra,Rb, value
SUB Ra,Rb,Rc
SUBI Ra,Rb,value
SUBU Ra,Rb,Rc
SUBUI Ra,Rb, value
DIV Ra,Rb,Rc
DIVI Ra,Rb,value
MULU Ra,Rb,Rc
MULI Ra,Rb, value
SLL Ra ,Rb,Rc
SLLI Ra,Rb;value
SHR Ra,Rb.Rc
SHRI Ra,Rb,value
SLA Ra,Rb,Rc
SLAI Ra,Rb,value
OR Ra,Rb,Rc
ORI Ra,Rb,value
XOR Ra,Rb,Rc
XORI Ra,Rb,value
AND Ra,Rb,Rc
ANDI Ra,Rb,value
Control
SETx Ra,Rb,Rc
SETIx Ra,Rb,value
BEQZ Ra, offset
BNEQZ Ra, offset
J offset
JR Ra
JL offset
JLR Ra
N.B. x can be LT, GT, LE, GE, EQ, NE
JLx-> Jump and link saving PC in R31
Offset is a value within the instruction
Postfix I means «immediate» (value within the instruction)
PostfixA means «arithmetic» (sign extension)
Postfix U means «unsigned»
Postfix «x» is the ste condition
Value is the immediate within the instruction

5. DLX ALU operations ALU is a combinatorial circuit !!!
S1 , S2 => ALU inputs (32 bit)
S1 + S2
S1 – S2
S1 and S2
S1 or S2
S1 exor S2
Left Shift S1 of S2 positions
Right Shift S1 of S2 positions
Arithmetic Right Shift S1 of S2 positions S1 S2 1
Output Flags
Zero
Negative sign
ALU is a combinatorial circuit !!!

6. Abstract instruction execution
Ready ?
INSTR <= M [PC]
INSTRUCTION FETCH
INSTRUCTION
DECODE*
PC <= PC +4
A <= RS1
B <= RS2
Data transfer
ALU
Set
Jump
Branch
A and B two internal registers unknown to the programmer

7. Example: LB (LOAD BYTE format I)
INSTR < M [PC]
Op-code
RS1
RS2
16 bit immediate operand
PC < PC +4
A < RS1
B < RS2
LB Ra, offset(Rb)
LOAD
Address < A + (Instr15)16 ## Instr15..0
(A) = (RS1)
Instr15.0. is the instruction offset
Address 32 bit
31 MBbit LSbit
Sign extension
Dest. Reg. < (M[Addr]7)24 ## M[Addr]7..0
(Dest. Reg. = RS2)
Sign extension !!
Example
M[Addr]7..0=A7H => ( )b
Dest.REG <= FFFFFFA7H
## => JOIN operator
Next Instruction
Memory byte

8. Sign extension From the Control Unit IR 15 31 31 30…………17 16 15-0
(IR15)16 ## IR15..0
From the Control Unit IR 15 31
31 30…………17 16
15-0
BUS S1 o S0

9. Data transfer Instructions (R format) Examples
Addr. <- A + (Instr15)16 ## Instr15..0
A unsigned
Data transfer Instructions (R format) Examples
M[Addr]<=B SW LB
Dest. <(M[Addr]7)24 ## M[Addr]7..0 LH
Dest. < (M[Addr]15)16 ## M[Addr]15..0
Signed
LBU
Dest. < (0)24 ## M[Addr]7..0 .
LHU LW
Dest. <(0)16 ## M[Addr]15..0
Unsigned
LW Ra, offset(Rb)
LB Ra, offset(Rb)
LBU Ra, offset(Rb)
LHU Ra, offset(Rb)
SW Ra, offset(Rb)

10. Register (format R)
Immediate (format I)
T<= B
T<= (Instr15)16 ## Instr15..0
Register content signed if arithmetic operations
ALUinstructions examples (I format) (T is a temporary hidden register unknown to the programmer)
Dest <= A + T
Dest <= A xor T
Dest <= A = T
Dest <= A and T
Dest <= A or T
ADD
AND
SUB
XOR OR
ADD Ra,Rb,Rc ADDI Ra,Rb,value ADDU Ra,Rb,Rc ADDUI Ra,Rb, value ………………………
The same scheme for the shift etc.
A and B generic registers (RS1, RS2)

11. Register (format R)
Immediate (format I)
T<= B
T<= (Instr15)16 ## Instr15..0
SET instructions (see branch) ex. SLT R1,R2,R3 Set R1=1 if R2 is less than R3
Dest=1 if A = T
SEQ
SLT
SGE
SNE
SGT
SLE
Dest=1 if A < T
Dest=1 if A >= T
Dest=1 A <= T
Dest=1 A > T
Dest=1 if A! = T
Register content as signed

12. JUMP Instructions JAL JALR JR JMP JAL JALR JAL JALR T <= PC
For saving PC in R31
T <= PC
JALR
JAL
T <= PC JR
JALR
JMP
JAL
PC <= PC + (Instr25)6 ## Instr25..0
PC <= A
format I
format J
JUMP Instructions
J offset
JR Ra
JL offset
JLR Ra
JALR
JAL
R31 <= T

13. Branch Instructions A = 0 A! = 0 Ex. BNEQZ R5, 100
BEQZ
BNEZ
A = 0
A! = 0
YES
YES NO NO
Ex. BNEQZ R5, 100
Jump to PC+100 if R5 not equal 0
PC <= PC + (Instr15)16 ## Instr15..0
INIT

14. The Pipelining Principle
Pipelining is the main basic technique used for “speeding-up” a CPU.
The key idea for pipelining is general, and is currently applied to
several industry fields (productions lines, oil pipelines, …)
A system S must execute N times a task A:
A1 , A2 , A3 …AN S
R1 , R2 , R3 …RN
Latency : time occurring between the beginning and the end of
task A (TA ).
Throughput : frequency of each task completion

15. The Pipelining Principle
1) Sequential System A1 A2 A3 AN t TA
Latency (execution time of a single instruction) = TA
2) Pipelined System (instruction are subdivided in stages – each stage during one nth – 4 in this example - of the entire instruction) – Instructions overlap S A P1 P2 P3 P4 t S1 S2 S3 S4
Si: pipeline
stage

16. The Pipelining PrincipleTP A1 P1 P2 P3 P4
TP : pipeline cycle
Each cycle one instruction terminates P1 A2 P2 P3 P4 P1 A3 P2 P3 P4 P1 A4 P2 P3 P4 t An S S1 S2 S3 S4
L’intervallo di tempo Tp , detto cycle time della pipeline, costituisce la durata
dell’intervallo elementare di funzionamento e determina il ritmo con cui le attività attraversano la pipeline: tutti gli stadi sono perfettamente sincronizzati in modo che allo scadere di ogni intervallo di funzionamento una attività viene completata, ed abbandona la pipeline, una nuova attività viene inserita nella pipeline e le altre attività presenti avanzano di uno stadio.

17. Instruction write-back Instruction execution
Instruction stages IF ID EX
MEM WB
Instruction fetch
(from memory)
Instruction write-back
(if needed)
Instruction decode
Data memory access
(if needed)
Instruction execution
(ALU)

18. Pipelining of a CPU (DLX)
Instruction sequence: I1 , I2 , I3 …IN
Instruction j IF ID EX
MEM WB t
Combinatorial
circuits
IF/ID
ID/EX
EX/MEM
MEM/WB IF ID EX
MEM WB
Registers
(Pipeline
D FF)
CPU (datapath)
Delay of the slowest
stage
Pipeline Cycle
Clock Cycle
CPI=1 (ideally !)

19. DLX Pipeline CPI (ideally) = 1 Tclk = Td + TP + Tsu Instr i Instr i+1IF ID EX
MEM WB
CPI (ideally) = 1
Instr i IF ID EX
MEM WB
Instr i+1
Instr i+2 IF ID EX
MEM WB IF ID EX
MEM WB
Instr i+3 IF ID EX
MEM WB
Instr i+4
Overhead introduced by the Pipeline Registers:
Tclk = Td + TP + Tsu
Clock
Cycle
Switch delay of the
input stage register
Delay of the slowest
combinatorial stage
Set-up time of the
output stage register

20. Tp Delay of the slowest combinatorial stage Set-up time of the
Circuit
Delay of the slowest
combinatorial stage D
Set-up time of the
output stage register D
Switch delay of the
input stage register

21. Pipeline implementation requirements
Each stage is active at each clock cycle.
The PC is incremented in the IF stage. PC
Always 0
An ADDER should be introduced (PC <=PC+4) in the IF stage. But instructions are aligned then a 30 bit register (counter) is used, incremented by 1 each clock cycle
Two Memory Data Registers are required (referred to as LMDR e SMDR). In fact when a LOAD is immediately followed by a STORE there is a WB/MEM stages overlap – two data waiting therefore to be written (one onto the memory, the other onto the RF).
Each clock cycle 2 memory accesses must be possibly executed (IF, MEM): Instruction Memory (IM) and Data Memory (DM): “Harvard” Architecture
The CPU clock is determined by the slowest stage:
Pipeline Registers store both data and control information ( “distributed” control unit)

22. DLX Pipelined Datapath
Actually a programmable counter
For Set Condition
(also <0 and >0)
[it acts on the output] IF ID EX
MEM WB
for Branch
if jump
For computing
new PC value
when branch
JL and JLR
(PC in R31) 4 A D M U X PC
DEC
=0?
=0?
INSTR
MEM RF PC M U X
RS1 A L U
RS2
DATA
MEM M U X RD M U X D
I passi in cui viene suddivisa l’esecuzione di un’istruzione DLX sono quelli che abbiamo anticipato precedentemente: click , vengono giù. Come già anticipato, ogni passo
Dell’esecuzione dell’istruzione viene eseguito da un’unità funzionale detta stadio click ed appaiono gli stadi; per consentire agli sia stadi di operarare simultaneamente su istruzioni diverse sia di scambiarsi informazioni fra gli stadi vengono inseriti dei registri, detti pipeline registers. Per semplicità pensiamo che siano dei registri edge-triggered che camponano sui fronti del clock della CPU, anche se è possibile utilizzare dei latch ed una diversa strategia di clocking.
In un generico ciclo di clock ogni stadio elabora le informazioni presenti sul suo registro di ingresso, relative ad una data istruzione K e produce delle nuove informazioni, anch’esse relative all’istruzione K: all’inizio del ciclo successive queste informazioni vengono campionate sul regsitro d’uscita dello stadio, che è il regsistro d’ingresso dello stadio successivo: in questo modo lo stadio successivo esegue il passo che gli compete dell’istruzione K. Lo stadio su cui abbiamo focalizzato la nostra attenzione campionerà invece le informazioni provenienti dallo stadio a valle ed eseguirà il proprio passo sull’istruzione precedente (K-1). In sostanza, grazie ad i registri di pipeliene, in un dato ciclo ogni stadio lavora su informazioni relative ad un’istruzione diversa, e le istruzioni presenti nella pipeline avanzano di uno stadio ad ogni clock.
L’uso dei pipeline regsister non è specifico del datapath dl DLX, ogni CPU in pipeline usa questi registri per trasportare le informazioni relative ad una sequenza di istruzioni attraverso gli stadi della pipeline. Vediamo invece ora come sono fatti gli stadi della pipeline del DLX.
I primi due stadi sono indipendenti dal tipo di istruzione, mentre il tipo di elaborazione che viene eseguito nei 3 stadi successivi dipende dal tipo di istruszione. Ci limiteremo a 2 delle 3 istruzioni che abbiamo introdotto precedentemente: ALU e LOAD. Discuteremo successivamente il caso dei BRANCH.
IF: Il PC fornisce l’indirizzo usato per accedere alla IM e prelevare l’istruzione: simultaneamente il PC viene incrementato al fine di ottenere l’indirizzo che sarà usato
Per prelevare la prossima istruzione. Ignoriamo per ora la presenza del MUX.
ID: l’istruzione prelevata nello stadio IF viene campionata su IF/ID e decodificata nello stadio ID: la rete di decodifica genera i segnali di controllo che vengono propagati verso tutti gli stadi attraverso i regsitri: in ID il decoder genera i segnali che verranno poi utilizzati nei vari stadi man mano che l’istruzione procede nella pipeline.
Quasi tutte le istruzioni del DLX prevedono l’accesso in lettura ad uno o due registri: i campi dell’istruzione che specificano i registri da leggere occupano una posizione fissa nell’istruzione e nettamente separata dall’opcode: è possibile allora utilizzare questi campi per accedere ai regsitri e prelevare gli operandi dell’istruzione simultaneamente alla fase di decodifica: leggiamo gli operandi mentre siamo decodificando l’istruzione, senza sapere bene ancora cosa dovremo fare: poco male, se ci servirà un solo operando, o nessuno non li useremo, ma non ci costa nulla leggerli.
I tre stadi successivi sono dipendenti dall’ istruzione: istruzione ALU: dobbiamo eseguire un’operazione logico/aritmetica sui registri letti in ID: i MUX selezioneranno come ingressi della ALU i valori dei registri provenienti dal regsitro ID/EX i segnali di controllo della ALU, provenienti dallo stadio precedente, selezioneranno l’operazione da eseguire: il risultato sarà pronto all’uscita della ALU alla fine del ciclio di clock e camponato sul regsitri EX/MEM all’inizio del clock successivo.
Se l’istruzione è una LOAD, lo stadio EX è usato per calcolare l’indirizzo: ricordando che la modalità di indirizzamento è displacement, e che il registro che contiene la base dell’indirizzo è già stato letto in ID, quello che è necessario fare è abilitare la via in basso del MUX e come secondo operando abilitare il displacement: questo è contenuto nell’istruzione e viene estratto e cooertito a 32 bit nello stadio ID e passato allo stadio EX mediante il regsisto di pipeline ID/EX.
Quindi dopo lo stadio EX il registro EX/MEM contiene il risultato dell’elaborazione, se è un’istruzione ALU, l’indirizzo se è una LOAD.
MEM: se è una ALU, non bisogna accedere alla memoria: il risultato verrà semplicemente passato allo stadio WB attraverso il registro di pipeline MEM/WB.
se è una LOAD, si accede alla memoria tramite l’indirizzo presente su EX/MEM ed il dato letto viene campionato poi sul registro MEM/WB.
Stadio di WB: è attivo sia per una LOAD sia per un’istruzione di tipo ALU: in entrambi i casi bisogna scrivere sul Register File: nel primo caso il valore
da scrivere è quello proveniente dalla data-memory, nel secondo caso è quello che è stato propagato dallo stadio EX: il MUX consente
di selezionare fra i due valori quello che viene inviato sulla porta di scrittura del RF. L’identificatore del registro che deve essere scritto (campo Rd dell’istruzione) viene anch’esso dallo stadio WB, su cui è stato propagato da ID: difatti non possiamo usare il campo Rd dell’istruzione correntemente in ID
Perché cosi’ facendo scriveremmo erroneamente sulla destinazione dell’istruzione correntemente in ID che non è qiuella di cui staimo seguendo l’evoluzione attraverso la pipeline ma bensi’ quella che la segue di 3 clock (è stata prelevata con 3 clock di ritardo) SE
For operations with immediates
Sign extension
Number of dest. registers
in case of LOAD
and ALU instr.
destination register number
Data
IF/ID
ID/EX
EX/MEM
MEM/WB

23. ID stage (N.B. stage layout different from previous slide!)
IF/ID
ID/EX
IR (Jump; Jump and Link) 32 I R
26 (J and JL)
IR (Offset/Immediate– Dest. reg. in R instr. ) LB
IR31-26 (Opcode) SW
DEC
IR10-00 (R Istr.)
Info travelling with
the instruction
IR25-21
RS1 A 32 P C 32
IR20-16
RS2 RF B DR 32 D
Sign extension
IR15
(31-16) Immed./Branch 16
IR25 SE
(31-26) Jump 6
Sing extension
PC (JL and JLR) 32
Data (from WB stage)
Number of the dest. register (from WB stage)

24. DLX Pipelined Datapath
SMDR => Store Memory Data Register
LMDR => Load memory data Register
IRi => Instruction Register i
for Set Condition
(also <0 e >0)
[it acts on output] IF ID
for Branch EX
MEM WB JL
JLR
(PC saved in R31) 4 A D M U X P C 1 P C 2 P C 3 P C 4
DEC C O N D
=0?
Address
=0? PC M U X
Data A A L U IM I R 1 RF L M D R X M U X B M U X DM S M D R
I passi in cui viene suddivisa l’esecuzione di un’istruzione DLX sono quelli che abbiamo anticipato precedentemente: click , vengono giù. Come già anticipato, ogni passo
Dell’esecuzione dell’istruzione viene eseguito da un’unità funzionale detta stadio click ed appaiono gli stadi; per consentire agli sia stadi di operarare simultaneamente su istruzioni diverse sia di scambiarsi informazioni fra gli stadi vengono inseriti dei registri, detti pipeline registers. Per semplicità pensiamo che siano dei registri edge-triggered che camponano sui fronti del clock della CPU, anche se è possibile utilizzare dei latch ed una diversa strategia di clocking.
In un generico ciclo di clock ogni stadio elabora le informazioni presenti sul suo registro di ingresso, relative ad una data istruzione K e produce delle nuove informazioni, anch’esse relative all’istruzione K: all’inizio del ciclo successive queste informazioni vengono campionate sul regsitro d’uscita dello stadio, che è il regsistro d’ingresso dello stadio successivo: in questo modo lo stadio successivo esegue il passo che gli compete dell’istruzione K. Lo stadio su cui abbiamo focalizzato la nostra attenzione campionerà invece le informazioni provenienti dallo stadio a valle ed eseguirà il proprio passo sull’istruzione precedente (K-1). In sostanza, grazie ad i registri di pipeliene, in un dato ciclo ogni stadio lavora su informazioni relative ad un’istruzione diversa, e le istruzioni presenti nella pipeline avanzano di uno stadio ad ogni clock.
L’uso dei pipeline regsister non è specifico del datapath dl DLX, ogni CPU in pipeline usa questi registri per trasportare le informazioni relative ad una sequenza di istruzioni attraverso gli stadi della pipeline. Vediamo invece ora come sono fatti gli stadi della pipeline del DLX.
I primi due stadi sono indipendenti dal tipo di istruzione, mentre il tipo di elaborazione che viene eseguito nei 3 stadi successivi dipende dal tipo di istruszione. Ci limiteremo a 2 delle 3 istruzioni che abbiamo introdotto precedentemente: ALU e LOAD. Discuteremo successivamente il caso dei BRANCH.
IF: Il PC fornisce l’indirizzo usato per accedere alla IM e prelevare l’istruzione: simultaneamente il PC viene incrementato al fine di ottenere l’indirizzo che sarà usato
Per prelevare la prossima istruzione. Ignoriamo per ora la presenza del MUX.
ID: l’istruzione prelevata nello stadio IF viene campionata su IF/ID e decodificata nello stadio ID: la rete di decodifica genera i segnali di controllo che vengono propagati verso tutti gli stadi attraverso i regsitri: in ID il decoder genera i segnali che verranno poi utilizzati nei vari stadi man mano che l’istruzione procede nella pipeline.
Quasi tutte le istruzioni del DLX prevedono l’accesso in lettura ad uno o due registri: i campi dell’istruzione che specificano i registri da leggere occupano una posizione fissa nell’istruzione e nettamente separata dall’opcode: è possibile allora utilizzare questi campi per accedere ai regsitri e prelevare gli operandi dell’istruzione simultaneamente alla fase di decodifica: leggiamo gli operandi mentre siamo decodificando l’istruzione, senza sapere bene ancora cosa dovremo fare: poco male, se ci servirà un solo operando, o nessuno non li useremo, ma non ci costa nulla leggerli.
I tre stadi successivi sono dipendenti dall’ istruzione: istruzione ALU: dobbiamo eseguire un’operazione logico/aritmetica sui registri letti in ID: i MUX selezioneranno come ingressi della ALU i valori dei registri provenienti dal regsitro ID/EX i segnali di controllo della ALU, provenienti dallo stadio precedente, selezioneranno l’operazione da eseguire: il risultato sarà pronto all’uscita della ALU alla fine del ciclio di clock e camponato sul regsitri EX/MEM all’inizio del clock successivo.
Se l’istruzione è una LOAD, lo stadio EX è usato per calcolare l’indirizzo: ricordando che la modalità di indirizzamento è displacement, e che il registro che contiene la base dell’indirizzo è già stato letto in ID, quello che è necessario fare è abilitare la via in basso del MUX e come secondo operando abilitare il displacement: questo è contenuto nell’istruzione e viene estratto e cooertito a 32 bit nello stadio ID e passato allo stadio EX mediante il regsisto di pipeline ID/EX.
Quindi dopo lo stadio EX il registro EX/MEM contiene il risultato dell’elaborazione, se è un’istruzione ALU, l’indirizzo se è una LOAD.
MEM: se è una ALU, non bisogna accedere alla memoria: il risultato verrà semplicemente passato allo stadio WB attraverso il registro di pipeline MEM/WB.
se è una LOAD, si accede alla memoria tramite l’indirizzo presente su EX/MEM ed il dato letto viene campionato poi sul registro MEM/WB.
Stadio di WB: è attivo sia per una LOAD sia per un’istruzione di tipo ALU: in entrambi i casi bisogna scrivere sul Register File: nel primo caso il valore
da scrivere è quello proveniente dalla data-memory, nel secondo caso è quello che è stato propagato dallo stadio EX: il MUX consente
di selezionare fra i due valori quello che viene inviato sulla porta di scrittura del RF. L’identificatore del registro che deve essere scritto (campo Rd dell’istruzione) viene anch’esso dallo stadio WB, su cui è stato propagato da ID: difatti non possiamo usare il campo Rd dell’istruzione correntemente in ID
Perché cosi’ facendo scriveremmo erroneamente sulla destinazione dell’istruzione correntemente in ID che non è qiuella di cui staimo seguendo l’evoluzione attraverso la pipeline ma bensi’ quella che la segue di 3 clock (è stata prelevata con 3 clock di ritardo) SE Y
X: Computed data or
Memory Address or
Branch Address I R 2 I R 3 I R 4
Y: Computed data
from the previous stage
destination register number
IF/ID
ID/EX
EX/MEM
MEM/WB

25. Pipelined execution of an “ALU” instructionIF
IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4
A <= RS1; B <= RS2; PC2 <= PC1; IR2<=IR1
ID/EX <= Instruction decode; ID
NOTE:
IRi bits which are dropped stage by stage when no more needed for all instructions.
X <= A op B or
X <= A op [(IR215)16 ## IR215..0]
[PC3 <= PC2] EX
[IR3 <= IR2]
Decoded opcode travels through all stages
MEM
Y <= X (temp. Storage for WB)
Why ?
[IR4 <.= IR3]
[PC4 <= PC3] WB
RD <= Y
X : “ALUOUTPUT” (in EX/MEM), Y : “ALUOUTPUT1”

26. Pipelined execution of a “MEM” instructionIF
IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4
A <= RS1; B <= RS2; PC2 <= PC1; IR2<=IR1
ID/EX <= Instruction decode; ID
MAR <= A op (IR215)16 ## IR215..0
SMDR <= B EX
[IR3 <= IR2
[PC4 <= PC3]
[PC3 <= PC2]
Decoded opcode travels through all stages
LMDR <= M[MAR] (if LOAD) or
M[MAR] <= SMDR (if STORE)
MEM
[IR4 <= IR3] WB
RD <= MDR (if LOAD) [Sign ext.]

27. Pipelined execution of a “BRANCH” instruction (normally after a SCn instruction – see later)IF
IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4
A <= RS1; B <= RS2; PC2 <= PC1; IR2<=IR1
ID/EX <= Instruction decode; ID
X <= PC2 op (IR15)16 ## IR15..0
Cond <= A op 0
[PC3 <= PC2] EX
[IR3 <= IR2]
Decoded opcode travels through all stages
MEM
if (Cond) PC <= X
[PC4 <= PC3]
[IR4 <= IR3
New value in PC in this interval . When Branch is taken 3 new unwanted instructions
are already started
(NOP) WB
X : “BTA (BRANCH TARGET ADDRESS)”
Branch on Reg A value (0/1)

28. Pipelined execution of a “JR” instructionID IF
IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4
A <= RS1; B <= RS2; PC2 <= PC1; IR2<=IR1
ID/EX <= Instruction decode; ID
X <= A EX
MEM
[IR3 <= IR2]
[PC4 <= PC3]
[PC3 <= PC2]
Decoded opcode travels through all stages WB
MEM
PC <= X
[IR4 <= IR3]
New value in PC in this interval .
When Jump executed 3 new unwanted instructions
are already started
(NOP) WB
Which would be the stage sequence for a J instruction?

29. Pipelined execution of a “JL or JLR” instructionID IF
IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4
A <= RS1; B <= RS2; PC2 <= P1; IR2<=IR1
ID/EX <= Instruction decode; ID
PC3 <= PC2
X <= A (If JLR) X <= PC2 + (IR25)6 ## IR25..0 (If JL)
[IR3 <= IR2] EX
MEM
PC <= X ; PC4<= PC3
[IR4 <= IR3]
New value in PC in this interval .
When Jump executed 3 new unwanted instructions
are already started WB
R31 <= PC4
In this case PCi
values are used
Decoded opcode through all stages
NOTE: Write on R31 CANNOT be performed on-the fly since it could overlap with another register write

30. Which would be the sequence in case of SCn (ex SLT R1,R2,R3) ?ID IF
IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4
A <= RS1; B <= RS2; PC2 <= P1; IR2<=IR1
ID/EX <= Instruction decode; ID EX ?
MEM ? WB ?

31. Pipeline Hazards
A “Hazard” occurs when during a clock cycle an instruction currently in a pipeline stage can’t be executed in the same clock cycle.
Structural Hazards – The same resource is used by two different pipeline stages: the instructions currently in those stages can not be executed simultaneously.
Data Hazards – they are due to instruction dependencies. For example, an instruction that needs to read a register not yet written by a previous instruction (Read After Write).
Control Hazards – Instructions following a branch depend from the branch result (taken/not taken).
L’indirizzo virtuale si compone di un page number ed un page offset. La traslazione avviene a livello di page number, l’offset rimane invariato.
Il numero di bit del page offset determina la dimensione della pagina. Il numero di pagine indirizzabili con l’indirizzo virtuale non deve necessariamente essere
Pari a quello indirizzabile con l’indirizzo fisico. Nel caso in cui lo sia, tipicamente la memoria fisica avrà comunque dimensioni minori dello spazio
Virtuale, quindi in pratica, verrano usati meno indirizzi. Se anche la memoria fisica fosse pari allo spazio virtuale non dobbiamo dimenticare che
La memoria virtuale fa si che più processsi vedano simultaneamente lo stesso spazio di indirizzamento virtuale, ragion per cui lo
Spazio fisico sarà comunque insufficiente.
The instruction that cannot be executed must be stalled (“pipeline stall” or “pipeline bubbling”), together with all the following instructions, while the previous instructions must proceed normally (so as to eliminate the hazard).

32. Hazards and stalls T5 = 8 * CLK = (5 + 3) * CLK
The consequence of a data hazard: if instruction Ii needs the result of instruction Ii-1 (data are read in ID stage), must wait until after WB of Ii-1
Clk 1
Clk 2
Clk 3
Clk 4
Clk 5
Clk 6
Clk 7
Clk 8
Clk 9
Clk 10
Clk 11
Clk 12
Ii-3 IF ID EX
MEM WB
Ii-2 IF ID EX
MEM WB
Ii-1 IF ID EX
MEM WB ID Ii IF
Ii+1 WB S
Stall: the clock signal for Ii, Ii+1 …etc. is blocked for three periods
T5 = 8 * CLK = (5 + 3) * CLK
T5 = 5 * (1 + 3/5 ) * CLK
Instruction stalls
L’ESEMPIO CHE STIAMO CONSIDERANDO VIENE DAL LUCIDO PRECEDENTE: è UN’ALEA RAW DEL DLX: e spieghiamo bene la situazione. Poi il calcolo di sinistra,
Che fa ancora riferimento al caso di sinistra. Infine, prima del clock che attiva la parte di destra la generalizzazione: le ALEE fanno si che un’istruzione non possa procedere nella pipeline a causa della presenza nella stessa di un’sitruzione precedente: l’istruzione e la quelle che la seguono devono essere stallate, quelle che la precdeno vanno avanti. L’istruzione rimane stallata fino a che il procedere delle istruzioni che la precedono non rimuove la causa dell’alea. Gli stalli introdotti nella pipeline riducono le prestazioni della pipeline stessa: da CPI=1 si va a CPI>1.
Qui un discorso semplice del perché un set di istruzioni RISC porta ad un pipelining più efficiente: tanto più il set di istruzioni è complesso, vario, con istruzioni molto diverse fra loro tanto più queste daranno luogo a dipendenze se eseguite in pipeline.
Poi la formula per le prestazioni con la percentuale di stalli.

33. Data are read from registers in the ID stage
Forwarding
Data are read from registers in the ID stage
Clk 6
Clk 7
Clk 8
MEM WB IF ID EX
Clk 1
Clk 2
Clk 3
Clk 4
Clk 5
Clk 9
ADD R3, R1, R4
SUB R7, R3, R5 hazard ID
OR R1, R3, R5 hazard ID
LW R6, 100 (R3) hazard ID
Here too the requested data is not yet in RF since it is written on the
positive clock edge at the end of WB (register value is read in ID!)
AND R9, R5, R3 no hazard
Forwarding allows eliminating almost all RAW hazards of
the pipeline without stalling the pipeline.
(NOTE: in DLX, registers are modified only in WB stage)

34. Forwarding implementation
Comparison
between
RS1, RS2 and
RD1, RD2
and the Opcodes
Alternatively,
SPLIT-CYCLE
(see next slide)
write before read
RD1 (destination register/OpCode)
RD2/OpCode
FU1
RS1/RS2
OPCODE
IR3
IR4
Bypass RF M U X A M U X
Memory A L U B M U X M U X M U X M U X
ALU
Offset
ID/EX
EX/MEM
MEM/WB
Often performed
inside the RF
It allows “the anticipation” of the register on ID/EX
MUX control: IF/ID opcode and comparison of RD with RS1 and RS2

35. Data hazard due to LOAD instructions
LW R1,32(R6)
MEM WB IF ID EX
ADD R4,R1,R7
SUB R5,R1,R8
AND R6,R1,R7
NOTE: the data required by the ADD is available only at the end of MEM stage. This hazard cannot be eliminated by forwarding (unless there is an additional input in the MUXs between memory and ALU – delays!)
Actually the clock signal is not generated. The clock block is propagated along the pipeline one stage at a time.
LW R1,32(R6)
ADD R4,R1,R7
SUB R5,R1,R8
AND R6,R1,R7 IF ID EX
MEM WB S
The pipeline needs to
be stalled
From the end of this stage onwards: standard forwarding

36. with a “useful” instruction
Delayed load
In many RISC CPUs, the hazard associated with the LOAD instruction is not handled by HW by stalling the pipeline but by software through the compiler (delayed load):
LOAD Instruction
The compiler tries to
fill the delay-slot
with a “useful” instruction
(worst case: NOP).
delay slot
Next instruction
LW R1,32(R6)
LW R3,10 (R4)
ADD R5,R1,R3
LW R6, 20 (R7)
LW R8, 40(R9)
LW R1,32(R6)
LW R3,10 (R4)
ADD R5,R1,R3
LW R6, 20 (R7)
LW R8, 40(R9)

37. Control Hazards PC BEQZ R4, 200 PC+4 SUB R7, R3, R5 PC+8 OR R1, R3, R5
Next Instruction
Address
PC BEQZ R4, 200
R4 = 0 : Branch Target Address
(taken)
R4  0 : PC+4
(not taken)
PC+4 SUB R7, R3, R5
PC+8 OR R1, R3, R5
PC+12 LW R6, 100 (R8)
PC AND R9, R5, R3
(BTA)
New computed PC value (Aluout)
New value in PC (one clock after)
Clk 1
Clk 2
Clk 3
Clk 4
Clk 5
Clk 6
Clk 7
Clk 8
Fetch with the new PC
BEQZ R4, 200 IF ID EX
MEM WB
SUB R7, R3, R5 IF ID ID EX
MEM WB
L’indirizzo della prossima istruzione
è noto solo quando è terminata l’istruzione
di branch, , ma l’esecuzione in pipeline
implica il fetch di una nuova istruzione ad
ogni ciclo di clock
OR R1, R3, R5 IF ID ID EX
MEM WB
LW R6, 100 (R8) ID IF EX WB
MEM ID IF EX WB
MEM

38. DLX Pipelined Datapath (Branch or JMP)
NOTE if the feedback signal of the new PC were output directly from the ALU instead than from ALUOUT the required stalls would be only two – slower clock!
Instruction Fetch
Instruction
Decode
Execute
Write
Back
Memory
BEQZ R4, 200 4 A D M U X
DEC M U X
=0?
=0? PC M U X DM A L U IM RF M U X
When the new PC acts on the IM three instructions have already travelled through the first three stages (EX included) SE
IF/ID
ID/EX
EX/MEM
MEM/WB

39. Handling the Control Hazards
Always Stall (three-clock block being propagated)
Fetch at new PC
Clk 1
Clk 2
Clk 3
Clk 4
Clk 5
Clk 6
Clk 7
Clk 8 IF
BEQZ R4,200 ID EX
MEM WB S IF ID
IF here: the previous instruction has not been yet decoded
Real situation
Repeated IF
PC <= PC - 4 S S S IF
Here the new value
is sampled by the PC
Branch Completion
Predict Not Taken
Clk 1
Clk 2
Clk 3
Clk 4
Clk 5
Clk 6
Clk 7
Clk 8
Flush:
they become
NOP
BEQZ R4, 200 IF ID EX
MEM WB
NOP IF ID ID EX
MEM WB
SUB R7, R3, R5
NOP IF ID EX
MEM WB
OR R1, R3, R5 ID
NOP IF ID ID EX
MEM WB
LW R6, 100 (R8)
No problem because no instruction in WB stage

40. Three NOPs MUST replace the 3 unwanted instructions already started
Stalls with jumps (1/3)
When the Branch Target Address is clocked into the PC three unwanted instructions are already in IF/ID, ID/EX and EX/MEM IF ID EX
MEM WB
if jump
Jump forced NOP N O P N O P N O P 4 A D M U X PC
DEC
=0?
=0?
INSTR
MEM RF PC M U X
RS1 A L U
RS2
DATA
MEM M U X DR M U X D
I passi in cui viene suddivisa l’esecuzione di un’istruzione DLX sono quelli che abbiamo anticipato precedentemente: click , vengono giù. Come già anticipato, ogni passo
Dell’esecuzione dell’istruzione viene eseguito da un’unità funzionale detta stadio click ed appaiono gli stadi; per consentire agli sia stadi di operarare simultaneamente su istruzioni diverse sia di scambiarsi informazioni fra gli stadi vengono inseriti dei registri, detti pipeline registers. Per semplicità pensiamo che siano dei registri edge-triggered che camponano sui fronti del clock della CPU, anche se è possibile utilizzare dei latch ed una diversa strategia di clocking.
In un generico ciclo di clock ogni stadio elabora le informazioni presenti sul suo registro di ingresso, relative ad una data istruzione K e produce delle nuove informazioni, anch’esse relative all’istruzione K: all’inizio del ciclo successive queste informazioni vengono campionate sul regsitro d’uscita dello stadio, che è il regsistro d’ingresso dello stadio successivo: in questo modo lo stadio successivo esegue il passo che gli compete dell’istruzione K. Lo stadio su cui abbiamo focalizzato la nostra attenzione campionerà invece le informazioni provenienti dallo stadio a valle ed eseguirà il proprio passo sull’istruzione precedente (K-1). In sostanza, grazie ad i registri di pipeliene, in un dato ciclo ogni stadio lavora su informazioni relative ad un’istruzione diversa, e le istruzioni presenti nella pipeline avanzano di uno stadio ad ogni clock.
L’uso dei pipeline regsister non è specifico del datapath dl DLX, ogni CPU in pipeline usa questi registri per trasportare le informazioni relative ad una sequenza di istruzioni attraverso gli stadi della pipeline. Vediamo invece ora come sono fatti gli stadi della pipeline del DLX.
I primi due stadi sono indipendenti dal tipo di istruzione, mentre il tipo di elaborazione che viene eseguito nei 3 stadi successivi dipende dal tipo di istruszione. Ci limiteremo a 2 delle 3 istruzioni che abbiamo introdotto precedentemente: ALU e LOAD. Discuteremo successivamente il caso dei BRANCH.
IF: Il PC fornisce l’indirizzo usato per accedere alla IM e prelevare l’istruzione: simultaneamente il PC viene incrementato al fine di ottenere l’indirizzo che sarà usato
Per prelevare la prossima istruzione. Ignoriamo per ora la presenza del MUX.
ID: l’istruzione prelevata nello stadio IF viene campionata su IF/ID e decodificata nello stadio ID: la rete di decodifica genera i segnali di controllo che vengono propagati verso tutti gli stadi attraverso i regsitri: in ID il decoder genera i segnali che verranno poi utilizzati nei vari stadi man mano che l’istruzione procede nella pipeline.
Quasi tutte le istruzioni del DLX prevedono l’accesso in lettura ad uno o due registri: i campi dell’istruzione che specificano i registri da leggere occupano una posizione fissa nell’istruzione e nettamente separata dall’opcode: è possibile allora utilizzare questi campi per accedere ai regsitri e prelevare gli operandi dell’istruzione simultaneamente alla fase di decodifica: leggiamo gli operandi mentre siamo decodificando l’istruzione, senza sapere bene ancora cosa dovremo fare: poco male, se ci servirà un solo operando, o nessuno non li useremo, ma non ci costa nulla leggerli.
I tre stadi successivi sono dipendenti dall’ istruzione: istruzione ALU: dobbiamo eseguire un’operazione logico/aritmetica sui registri letti in ID: i MUX selezioneranno come ingressi della ALU i valori dei registri provenienti dal regsitro ID/EX i segnali di controllo della ALU, provenienti dallo stadio precedente, selezioneranno l’operazione da eseguire: il risultato sarà pronto all’uscita della ALU alla fine del ciclio di clock e camponato sul regsitri EX/MEM all’inizio del clock successivo.
Se l’istruzione è una LOAD, lo stadio EX è usato per calcolare l’indirizzo: ricordando che la modalità di indirizzamento è displacement, e che il registro che contiene la base dell’indirizzo è già stato letto in ID, quello che è necessario fare è abilitare la via in basso del MUX e come secondo operando abilitare il displacement: questo è contenuto nell’istruzione e viene estratto e cooertito a 32 bit nello stadio ID e passato allo stadio EX mediante il regsisto di pipeline ID/EX.
Quindi dopo lo stadio EX il registro EX/MEM contiene il risultato dell’elaborazione, se è un’istruzione ALU, l’indirizzo se è una LOAD.
MEM: se è una ALU, non bisogna accedere alla memoria: il risultato verrà semplicemente passato allo stadio WB attraverso il registro di pipeline MEM/WB.
se è una LOAD, si accede alla memoria tramite l’indirizzo presente su EX/MEM ed il dato letto viene campionato poi sul registro MEM/WB.
Stadio di WB: è attivo sia per una LOAD sia per un’istruzione di tipo ALU: in entrambi i casi bisogna scrivere sul Register File: nel primo caso il valore
da scrivere è quello proveniente dalla data-memory, nel secondo caso è quello che è stato propagato dallo stadio EX: il MUX consente
di selezionare fra i due valori quello che viene inviato sulla porta di scrittura del RF. L’identificatore del registro che deve essere scritto (campo Rd dell’istruzione) viene anch’esso dallo stadio WB, su cui è stato propagato da ID: difatti non possiamo usare il campo Rd dell’istruzione correntemente in ID
Perché cosi’ facendo scriveremmo erroneamente sulla destinazione dell’istruzione correntemente in ID che non è qiuella di cui staimo seguendo l’evoluzione attraverso la pipeline ma bensi’ quella che la segue di 3 clock (è stata prelevata con 3 clock di ritardo)
Three NOPs MUST replace the 3 unwanted instructions already started SE
Data
IF/ID
ID/EX
EX/MEM
MEM/WB

41. Two NOPs MUST replace the 2 unwanted instructions already started
Stalls with jump (2/3)
NOTE in this case the jump condition detection and the new PC value are input to the MUX in the same clok interval IF ID EX
MEM WB
if jump
forced NOP when jump N O P N O P 4 A D M U X PC
DEC
=0?
=0?
INSTR
MEM RF PC M U X
RS1 A L U
RS2
DATA
MEM M U X DR M U X D
I passi in cui viene suddivisa l’esecuzione di un’istruzione DLX sono quelli che abbiamo anticipato precedentemente: click , vengono giù. Come già anticipato, ogni passo
Dell’esecuzione dell’istruzione viene eseguito da un’unità funzionale detta stadio click ed appaiono gli stadi; per consentire agli sia stadi di operarare simultaneamente su istruzioni diverse sia di scambiarsi informazioni fra gli stadi vengono inseriti dei registri, detti pipeline registers. Per semplicità pensiamo che siano dei registri edge-triggered che camponano sui fronti del clock della CPU, anche se è possibile utilizzare dei latch ed una diversa strategia di clocking.
In un generico ciclo di clock ogni stadio elabora le informazioni presenti sul suo registro di ingresso, relative ad una data istruzione K e produce delle nuove informazioni, anch’esse relative all’istruzione K: all’inizio del ciclo successive queste informazioni vengono campionate sul regsitro d’uscita dello stadio, che è il regsistro d’ingresso dello stadio successivo: in questo modo lo stadio successivo esegue il passo che gli compete dell’istruzione K. Lo stadio su cui abbiamo focalizzato la nostra attenzione campionerà invece le informazioni provenienti dallo stadio a valle ed eseguirà il proprio passo sull’istruzione precedente (K-1). In sostanza, grazie ad i registri di pipeliene, in un dato ciclo ogni stadio lavora su informazioni relative ad un’istruzione diversa, e le istruzioni presenti nella pipeline avanzano di uno stadio ad ogni clock.
L’uso dei pipeline regsister non è specifico del datapath dl DLX, ogni CPU in pipeline usa questi registri per trasportare le informazioni relative ad una sequenza di istruzioni attraverso gli stadi della pipeline. Vediamo invece ora come sono fatti gli stadi della pipeline del DLX.
I primi due stadi sono indipendenti dal tipo di istruzione, mentre il tipo di elaborazione che viene eseguito nei 3 stadi successivi dipende dal tipo di istruszione. Ci limiteremo a 2 delle 3 istruzioni che abbiamo introdotto precedentemente: ALU e LOAD. Discuteremo successivamente il caso dei BRANCH.
IF: Il PC fornisce l’indirizzo usato per accedere alla IM e prelevare l’istruzione: simultaneamente il PC viene incrementato al fine di ottenere l’indirizzo che sarà usato
Per prelevare la prossima istruzione. Ignoriamo per ora la presenza del MUX.
ID: l’istruzione prelevata nello stadio IF viene campionata su IF/ID e decodificata nello stadio ID: la rete di decodifica genera i segnali di controllo che vengono propagati verso tutti gli stadi attraverso i regsitri: in ID il decoder genera i segnali che verranno poi utilizzati nei vari stadi man mano che l’istruzione procede nella pipeline.
Quasi tutte le istruzioni del DLX prevedono l’accesso in lettura ad uno o due registri: i campi dell’istruzione che specificano i registri da leggere occupano una posizione fissa nell’istruzione e nettamente separata dall’opcode: è possibile allora utilizzare questi campi per accedere ai regsitri e prelevare gli operandi dell’istruzione simultaneamente alla fase di decodifica: leggiamo gli operandi mentre siamo decodificando l’istruzione, senza sapere bene ancora cosa dovremo fare: poco male, se ci servirà un solo operando, o nessuno non li useremo, ma non ci costa nulla leggerli.
I tre stadi successivi sono dipendenti dall’ istruzione: istruzione ALU: dobbiamo eseguire un’operazione logico/aritmetica sui registri letti in ID: i MUX selezioneranno come ingressi della ALU i valori dei registri provenienti dal regsitro ID/EX i segnali di controllo della ALU, provenienti dallo stadio precedente, selezioneranno l’operazione da eseguire: il risultato sarà pronto all’uscita della ALU alla fine del ciclio di clock e camponato sul regsitri EX/MEM all’inizio del clock successivo.
Se l’istruzione è una LOAD, lo stadio EX è usato per calcolare l’indirizzo: ricordando che la modalità di indirizzamento è displacement, e che il registro che contiene la base dell’indirizzo è già stato letto in ID, quello che è necessario fare è abilitare la via in basso del MUX e come secondo operando abilitare il displacement: questo è contenuto nell’istruzione e viene estratto e cooertito a 32 bit nello stadio ID e passato allo stadio EX mediante il regsisto di pipeline ID/EX.
Quindi dopo lo stadio EX il registro EX/MEM contiene il risultato dell’elaborazione, se è un’istruzione ALU, l’indirizzo se è una LOAD.
MEM: se è una ALU, non bisogna accedere alla memoria: il risultato verrà semplicemente passato allo stadio WB attraverso il registro di pipeline MEM/WB.
se è una LOAD, si accede alla memoria tramite l’indirizzo presente su EX/MEM ed il dato letto viene campionato poi sul registro MEM/WB.
Stadio di WB: è attivo sia per una LOAD sia per un’istruzione di tipo ALU: in entrambi i casi bisogna scrivere sul Register File: nel primo caso il valore
da scrivere è quello proveniente dalla data-memory, nel secondo caso è quello che è stato propagato dallo stadio EX: il MUX consente
di selezionare fra i due valori quello che viene inviato sulla porta di scrittura del RF. L’identificatore del registro che deve essere scritto (campo Rd dell’istruzione) viene anch’esso dallo stadio WB, su cui è stato propagato da ID: difatti non possiamo usare il campo Rd dell’istruzione correntemente in ID
Perché cosi’ facendo scriveremmo erroneamente sulla destinazione dell’istruzione correntemente in ID che non è qiuella di cui staimo seguendo l’evoluzione attraverso la pipeline ma bensi’ quella che la segue di 3 clock (è stata prelevata con 3 clock di ritardo)
Two NOPs MUST replace the 2 unwanted instructions already started SE
Data
IF/ID
ID/EX
EX/MEM
MEM/WB

42. A NOP MUST replace the unwanted instruction already started
Stalls with jump (3/3)
NOTE In this case the jump condition and the new PC act on the MUX in the same period when the condition is detected
Very slow solution ! IF ID EX
MEM WB
if jump
NOP for jump 4 A D N O P PC M U X
DEC
=0?
=0?
INSTR
MEM RF PC M U X
RS1 A L U
RS2
DATA
MEM M U X DR M U X D
I passi in cui viene suddivisa l’esecuzione di un’istruzione DLX sono quelli che abbiamo anticipato precedentemente: click , vengono giù. Come già anticipato, ogni passo
Dell’esecuzione dell’istruzione viene eseguito da un’unità funzionale detta stadio click ed appaiono gli stadi; per consentire agli sia stadi di operarare simultaneamente su istruzioni diverse sia di scambiarsi informazioni fra gli stadi vengono inseriti dei registri, detti pipeline registers. Per semplicità pensiamo che siano dei registri edge-triggered che camponano sui fronti del clock della CPU, anche se è possibile utilizzare dei latch ed una diversa strategia di clocking.
In un generico ciclo di clock ogni stadio elabora le informazioni presenti sul suo registro di ingresso, relative ad una data istruzione K e produce delle nuove informazioni, anch’esse relative all’istruzione K: all’inizio del ciclo successive queste informazioni vengono campionate sul regsitro d’uscita dello stadio, che è il regsistro d’ingresso dello stadio successivo: in questo modo lo stadio successivo esegue il passo che gli compete dell’istruzione K. Lo stadio su cui abbiamo focalizzato la nostra attenzione campionerà invece le informazioni provenienti dallo stadio a valle ed eseguirà il proprio passo sull’istruzione precedente (K-1). In sostanza, grazie ad i registri di pipeliene, in un dato ciclo ogni stadio lavora su informazioni relative ad un’istruzione diversa, e le istruzioni presenti nella pipeline avanzano di uno stadio ad ogni clock.
L’uso dei pipeline regsister non è specifico del datapath dl DLX, ogni CPU in pipeline usa questi registri per trasportare le informazioni relative ad una sequenza di istruzioni attraverso gli stadi della pipeline. Vediamo invece ora come sono fatti gli stadi della pipeline del DLX.
I primi due stadi sono indipendenti dal tipo di istruzione, mentre il tipo di elaborazione che viene eseguito nei 3 stadi successivi dipende dal tipo di istruszione. Ci limiteremo a 2 delle 3 istruzioni che abbiamo introdotto precedentemente: ALU e LOAD. Discuteremo successivamente il caso dei BRANCH.
IF: Il PC fornisce l’indirizzo usato per accedere alla IM e prelevare l’istruzione: simultaneamente il PC viene incrementato al fine di ottenere l’indirizzo che sarà usato
Per prelevare la prossima istruzione. Ignoriamo per ora la presenza del MUX.
ID: l’istruzione prelevata nello stadio IF viene campionata su IF/ID e decodificata nello stadio ID: la rete di decodifica genera i segnali di controllo che vengono propagati verso tutti gli stadi attraverso i regsitri: in ID il decoder genera i segnali che verranno poi utilizzati nei vari stadi man mano che l’istruzione procede nella pipeline.
Quasi tutte le istruzioni del DLX prevedono l’accesso in lettura ad uno o due registri: i campi dell’istruzione che specificano i registri da leggere occupano una posizione fissa nell’istruzione e nettamente separata dall’opcode: è possibile allora utilizzare questi campi per accedere ai regsitri e prelevare gli operandi dell’istruzione simultaneamente alla fase di decodifica: leggiamo gli operandi mentre siamo decodificando l’istruzione, senza sapere bene ancora cosa dovremo fare: poco male, se ci servirà un solo operando, o nessuno non li useremo, ma non ci costa nulla leggerli.
I tre stadi successivi sono dipendenti dall’ istruzione: istruzione ALU: dobbiamo eseguire un’operazione logico/aritmetica sui registri letti in ID: i MUX selezioneranno come ingressi della ALU i valori dei registri provenienti dal regsitro ID/EX i segnali di controllo della ALU, provenienti dallo stadio precedente, selezioneranno l’operazione da eseguire: il risultato sarà pronto all’uscita della ALU alla fine del ciclio di clock e camponato sul regsitri EX/MEM all’inizio del clock successivo.
Se l’istruzione è una LOAD, lo stadio EX è usato per calcolare l’indirizzo: ricordando che la modalità di indirizzamento è displacement, e che il registro che contiene la base dell’indirizzo è già stato letto in ID, quello che è necessario fare è abilitare la via in basso del MUX e come secondo operando abilitare il displacement: questo è contenuto nell’istruzione e viene estratto e cooertito a 32 bit nello stadio ID e passato allo stadio EX mediante il regsisto di pipeline ID/EX.
Quindi dopo lo stadio EX il registro EX/MEM contiene il risultato dell’elaborazione, se è un’istruzione ALU, l’indirizzo se è una LOAD.
MEM: se è una ALU, non bisogna accedere alla memoria: il risultato verrà semplicemente passato allo stadio WB attraverso il registro di pipeline MEM/WB.
se è una LOAD, si accede alla memoria tramite l’indirizzo presente su EX/MEM ed il dato letto viene campionato poi sul registro MEM/WB.
Stadio di WB: è attivo sia per una LOAD sia per un’istruzione di tipo ALU: in entrambi i casi bisogna scrivere sul Register File: nel primo caso il valore
da scrivere è quello proveniente dalla data-memory, nel secondo caso è quello che è stato propagato dallo stadio EX: il MUX consente
di selezionare fra i due valori quello che viene inviato sulla porta di scrittura del RF. L’identificatore del registro che deve essere scritto (campo Rd dell’istruzione) viene anch’esso dallo stadio WB, su cui è stato propagato da ID: difatti non possiamo usare il campo Rd dell’istruzione correntemente in ID
Perché cosi’ facendo scriveremmo erroneamente sulla destinazione dell’istruzione correntemente in ID che non è qiuella di cui staimo seguendo l’evoluzione attraverso la pipeline ma bensi’ quella che la segue di 3 clock (è stata prelevata con 3 clock di ritardo)
A NOP MUST replace the unwanted instruction already started SE
Data
IF/ID
ID/EX
EX/MEM
MEM/WB

43. with “useful” instructions
Delayed branch
Similarly to the LOAD case. In several RISC CPUs the BRANCH instructions hazard is handled by SW thorugh the compiler (delayed branch):
BRANCH instruction
delay slot
The compiler tries to
fill the delay-slots
with “useful” instructions
(worst case: NOP).
delay slot
delay slot
Next instruction

44. Obviously in this instructions group there must be no jumps!!!
Delayed branch/jump
Original
Compiled
Add R5, R4, R3
Sub R6, R5, R2
Or R14, R6, R21
Sne R1, R8, R9 ; branch condition
Br R1, +100
Sne R1, R8, R9 ; branch condition
Br R1, +100
Add R5, R4, R3
Sub R6, R5, R2
Or R14, R6, R21
Obviously in this instructions group there must be no jumps!!!
Executed in both cases
Instead of one or more “postponed” instructions, the compiler inserts NOPs when no suitable instructions are available

45. -------------------------
NOTE: in this case there is only one “stall” since the new value is inserted in the PC on the positive clock edge that ends the ID stage while, in the previous case, it was inserted after the MEM stage, that is, two clock later!!!!!!
To reduce the number of stalls
Independent Adder for BRANCH/JMP IF
IR <- M[PC] ; PC <- PC + 4; PC1 <- PC + 4
A <- RS1; B <- RS2; PC2 <- PC1
ID/EX <- Decode; ID/EX <- Opc ext. ID
BTA <=PC1+ (IR15)16 ## IR15-0 /(IR25)6 ## IR25..0
(New fetch
only one stall)
if Branch: if (RS1 op 0) PC <= BTA
if JMP always PC <= BTA EX
ALU
(additional full adder)
MEM WB

46. Offset and sign extension
BRANCH/JMP – 1 stall
The source of the next PC is selected according to the opcode and the value of the branch test register
Standard increment ID IF
Displacement of the Branch instruction
PC of the Branch instruction M U X A D E R 4 P C 2 P C 1 M U X
DEC ##
Branch PC
Offset and sign extension I R 1 A IM RF B
= 0 ?
NOTE: for “Unconditional Jump” instructions there a similar situation : we need only to provide further inputs to the MUXs of the PC by considering either the RS1 register (JR and JRL) or the 26 less-significant bits of the IR with SE (J and JL) to be added to the instruction PC (not the current PC)
I passi in cui viene suddivisa l’esecuzione di un’istruzione DLX sono quelli che abbiamo anticipato precedentemente: click , vengono giù. Come già anticipato, ogni passo
Dell’esecuzione dell’istruzione viene eseguito da un’unità funzionale detta stadio click ed appaiono gli stadi; per consentire agli sia stadi di operarare simultaneamente su istruzioni diverse sia di scambiarsi informazioni fra gli stadi vengono inseriti dei registri, detti pipeline registers. Per semplicità pensiamo che siano dei registri edge-triggered che camponano sui fronti del clock della CPU, anche se è possibile utilizzare dei latch ed una diversa strategia di clocking.
In un generico ciclo di clock ogni stadio elabora le informazioni presenti sul suo registro di ingresso, relative ad una data istruzione K e produce delle nuove informazioni, anch’esse relative all’istruzione K: all’inizio del ciclo successive queste informazioni vengono campionate sul regsitro d’uscita dello stadio, che è il regsistro d’ingresso dello stadio successivo: in questo modo lo stadio successivo esegue il passo che gli compete dell’istruzione K. Lo stadio su cui abbiamo focalizzato la nostra attenzione campionerà invece le informazioni provenienti dallo stadio a valle ed eseguirà il proprio passo sull’istruzione precedente (K-1). In sostanza, grazie ad i registri di pipeliene, in un dato ciclo ogni stadio lavora su informazioni relative ad un’istruzione diversa, e le istruzioni presenti nella pipeline avanzano di uno stadio ad ogni clock.
L’uso dei pipeline regsister non è specifico del datapath dl DLX, ogni CPU in pipeline usa questi registri per trasportare le informazioni relative ad una sequenza di istruzioni attraverso gli stadi della pipeline. Vediamo invece ora come sono fatti gli stadi della pipeline del DLX.
I primi due stadi sono indipendenti dal tipo di istruzione, mentre il tipo di elaborazione che viene eseguito nei 3 stadi successivi dipende dal tipo di istruszione. Ci limiteremo a 2 delle 3 istruzioni che abbiamo introdotto precedentemente: ALU e LOAD. Discuteremo successivamente il caso dei BRANCH.
IF: Il PC fornisce l’indirizzo usato per accedere alla IM e prelevare l’istruzione: simultaneamente il PC viene incrementato al fine di ottenere l’indirizzo che sarà usato
Per prelevare la prossima istruzione. Ignoriamo per ora la presenza del MUX.
ID: l’istruzione prelevata nello stadio IF viene campionata su IF/ID e decodificata nello stadio ID: la rete di decodifica genera i segnali di controllo che vengono propagati verso tutti gli stadi attraverso i regsitri: in ID il decoder genera i segnali che verranno poi utilizzati nei vari stadi man mano che l’istruzione procede nella pipeline.
Quasi tutte le istruzioni del DLX prevedono l’accesso in lettura ad uno o due registri: i campi dell’istruzione che specificano i registri da leggere occupano una posizione fissa nell’istruzione e nettamente separata dall’opcode: è possibile allora utilizzare questi campi per accedere ai regsitri e prelevare gli operandi dell’istruzione simultaneamente alla fase di decodifica: leggiamo gli operandi mentre siamo decodificando l’istruzione, senza sapere bene ancora cosa dovremo fare: poco male, se ci servirà un solo operando, o nessuno non li useremo, ma non ci costa nulla leggerli.
I tre stadi successivi sono dipendenti dall’ istruzione: istruzione ALU: dobbiamo eseguire un’operazione logico/aritmetica sui registri letti in ID: i MUX selezioneranno come ingressi della ALU i valori dei registri provenienti dal regsitro ID/EX i segnali di controllo della ALU, provenienti dallo stadio precedente, selezioneranno l’operazione da eseguire: il risultato sarà pronto all’uscita della ALU alla fine del ciclio di clock e camponato sul regsitri EX/MEM all’inizio del clock successivo.
Se l’istruzione è una LOAD, lo stadio EX è usato per calcolare l’indirizzo: ricordando che la modalità di indirizzamento è displacement, e che il registro che contiene la base dell’indirizzo è già stato letto in ID, quello che è necessario fare è abilitare la via in basso del MUX e come secondo operando abilitare il displacement: questo è contenuto nell’istruzione e viene estratto e cooertito a 32 bit nello stadio ID e passato allo stadio EX mediante il regsisto di pipeline ID/EX.
Quindi dopo lo stadio EX il registro EX/MEM contiene il risultato dell’elaborazione, se è un’istruzione ALU, l’indirizzo se è una LOAD.
MEM: se è una ALU, non bisogna accedere alla memoria: il risultato verrà semplicemente passato allo stadio WB attraverso il registro di pipeline MEM/WB.
se è una LOAD, si accede alla memoria tramite l’indirizzo presente su EX/MEM ed il dato letto viene campionato poi sul registro MEM/WB.
Stadio di WB: è attivo sia per una LOAD sia per un’istruzione di tipo ALU: in entrambi i casi bisogna scrivere sul Register File: nel primo caso il valore
da scrivere è quello proveniente dalla data-memory, nel secondo caso è quello che è stato propagato dallo stadio EX: il MUX consente
di selezionare fra i due valori quello che viene inviato sulla porta di scrittura del RF. L’identificatore del registro che deve essere scritto (campo Rd dell’istruzione) viene anch’esso dallo stadio WB, su cui è stato propagato da ID: difatti non possiamo usare il campo Rd dell’istruzione correntemente in ID
Perché cosi’ facendo scriveremmo erroneamente sulla destinazione dell’istruzione correntemente in ID che non è qiuella di cui staimo seguendo l’evoluzione attraverso la pipeline ma bensi’ quella che la segue di 3 clock (è stata prelevata con 3 clock di ritardo)
For Branches SE
IF/ID
ID/EX

47. Handling the Control Hazards
Dynamic Prediction: Branch Target Buffer => no stall (almost..) PC
Predicted PC
T/NT
N.B. Here the branch slot is selected during the IF clock cycle that loads IR1 in IF/ID
TAGS =
HIT : Fetch with predicted PC
MISS : Fetch with PC + 4
Correct prediction : no stalls
Wrong prediction : stalls (correct fetch in ID or EX, see before)

48. when last branch occurred.
Prediction Buffer: the simplest implementation uses a single bit that indicates what happened
when last branch occurred.
When the program ends loop2, the prediction fails (branch predicted as taken but actually it is untaken), then it fails again when it predicts as untaken whilst entering once again loop2
Loop1
Loop2
In case of predominance of one prediction, when the opposite situation occurs we have two consecutive errors.

49. Usually two bits. TAKEN UNTAKEN TAKEN TAKEN TAKEN TAKEN UNTAKEN