DLX computer Electronic Computers M

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 silicon 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)

DLX (fixed) instruction format 31 26 25 21 20 16 15 11 10 0 6 bit 5 bit 5 bit 5 bit 11 bit R Op-code Ra Rb Rc Cod. op (11 bit) extension Arithmetic or logic instructions; i.e. Ra  Rb op Rc or Set Conditions between registers Branch instructions I Op-code Ra Rb Immediate operand or offset Data transfer (Load, Store), conditional Branch , JR and JALR (Control transfer via register), Set Condition e ALU with immediate operator. In Load and ALU instructions Ra=destination, in the Store Ra=source. -- Rb content as ALU value for the immediate instructions - Branch instructions 31 26 25 21 20 16 15 0 J Op-code 26 bit (PC relative) offset Direct, unconditional control transfer(J e JAL) 31 26 25 0

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 (- - - +[PC]) BNEQZ Ra, offset (- - - +[PC]) J offset JR Ra JL offset (- - - +[PC]) JLR Ra N.B. Postfix x (set condition) can be LT, GT, LE, GE, EQ, NE JL (via or non via register) -> 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» Value is the immediate within the instruction No STACK registers

DLX ALU operations Two inputs data One output data plus flags Controls 32 S1 S2 OUT ALU Flags 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 !!!

Abstract instruction execution Sequential DLX INSTRUCTION FETCH [REGINSTR] ]<= M [PC] Ready ? INSTRUCTION DECODE [PC] <= [PC] +4 [A ]<= [Ra] [B ]<= [Rb] [C] <= [Rc] [X ]<= num [Ra] [X] number of the destination register PC is the Program Counter REGinstr is the register where the new fetched instruction is stored. Destination register number Data transfer ALU Set Jump Branch INSTRUCTION EXECUTION A and B are two scratchpad internal registers, All these registers are unknown to the programmer This is a synchronous state diagram

Example: LB (LOAD BYTE format I) INSTR <= M [PC] 31 26 25 21 20 16 15 0 Op-code Ra Rb offset [PC] <= [PC] +4 [A ]<= [Ra] [B ]<= [Rb] [C ]<= [Rc] [X ]<= num [Ra] LB Ra, offset(Rb) Instruction bit 15 (sign) is left extended 16 times LOAD Instr15.0. is the instruction offset Address is always 32 bit 31 MBbit 0 LSbit ## => JOIN operator Byte Addr. < =[B] + (Instr15)16 ## Instr15..0 Byte address compute Sign extension !! Example M[Addr]7..0=A7H => (10100111)b Sign extended address <= FFFFFFA7H Sign extension [Ra] < =(M[Addr.]7)24 ## M[Addr.]7..0 Byte in register Next Instruction

Sign extension - example with IR (IR15)16 ## IR15..0 From the Control Unit IR 15 31 31 30…………17 16 15-0 Tri-state devices

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

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

SET instructions (see branch) ex SET instructions (see branch) ex. SLT Ra,Rb,Rc Set Ra=1 if Rb is less than Rc otherwise Ra=0 Register (format R) Immediate (format I) (T is a hidden register unknown to the programmer storing temporary data) [T]<= (Instr15)16 ## Instr15..0] [T]<= [Rc] Register content as signed [Ra] = 1 if [Rb] = [T] SEQ SLT [Ra] = 1 if [Rb] < [T] SGE [Ra] = 1 if [Rb] >= [T] SNE [Ra] = 1 if [Rb]! = [T] SGT [Ra] = 1 if [Rb] > [T] SLE [Ra] =1 if [Rb] <= [T]

[Ra] = 1 [Ra!] = 1 format R Branch Instructions Ex. BNEQZ R5, 100 BEQZ [Ra!] = 1 YES NO Ex. BNEQZ R5, 100 Jump to PC+100 if R5 not equal 0 INIT [PC] <= [PC] + (Instr15)16 ## Instr15..0

JALR JAL JMP JR JAL JALR JAL JALR [T] <= [PC] [T] <= [PC] format J For saving [PC] in R31 JR JALR JALR JAL JMP JAL [T] <= [PC] [T] <= [PC] JUMP Instructions format I J offset (jump address) JR Ra (jump register) JL offset (jump and link address) JLR Ra (jump and link register) [PC] <= [Ra] [PC] <= [PC] + (Instr25)6 ## Instr25..0 JALR JAL [R31 ]<= [T]

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 operate N times on a task Ai producing result Ri : Latency : time occurring between the beginning and the end of task A (TA ). A1 , A2 , A3 …AN S R1 , R2 , R3 …RN Throughput : frequency of each task completion

The Pipelining Principle 1) Sequential System - A new instruction starts when the previous instruction is finished An n-th instruction - Latency (execution time of a single instruction) = TAn Different execution times A1 A2 A3 An t TA 2) Pipelined System (instruction are subdivided in stages – each stage during one nth – 1/4 in this example - of the entire instruction time) Successive instructions stages overlap S A P1 P2 P3 P4 t S1 S2 S3 S4 Si: pipeline stage

The Pipelining Principle TP P1 A2 P2 P3 P4 ty Next cycle A2 terminates at ty etc. TP : pipeline cycle (ideally one clock) For each cycle one instruction terminates In figure A1 terminates at tx A1 P1 P2 P3 P4 P1 A3 P2 P3 P4 P1 A4 P2 P3 P4 An t tx 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. P1 P2 P3 P4

Typical instruction stages IF Instruction fetch (from memory) ID Instruction decode EX Instruction execution (ALU) MEM Data memory access (if needed – registers instructions no need) WB Write-back (if needed – jump no need) N.B. The execution time (latency) of all instructions must be the same, for maintaining the results order. Some stages are not used for some instructions (the stage is a NOP for them) – i.e. the stage MEM for register operations)

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

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

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

Pipeline implementation requirements Each stage is active at each clock cycle. The PC is incremented in the IF stage. 31 2 1 0 PC Always 0 An ADDER should be introduced (PC <=PC+4 – one instruction is 4 bytes) in the IF stage. But instructions are aligned (each one ends to an address multiple of the instruction length in bytes) and therefore a 30 bit only register (a programmable counter for jumps) 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 a register of 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)

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 A D 4 M U X INSTR MEM PC JL and JLR (PC in R31) SE Ra Rb PC DEC Rc RF Num [Ra] M U X A L =0? M U X DATA MEM Data (from reg. or mem or PC per link) destination register number (1-31) DR 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) For operations with immediates Sign extension Number of dest. registers in case of LOAD and ALU instr. IF/ID ID/EX EX/MEM MEM/WB

ID stage (N.B. stage layout different from previous slide!) IF/ID ID/EX IR25-16 (Jump; Jump and Link) 32 I R 26 (J and JL) Ra Rb IR25-21 IR20-16 RF Rc IR15-11 IR15-0 (Offset/Immediate instr. ) Info travelling with the instruction Num Ra, Rb,Rc (see forwarding) DEC IR10-00 (R Istr.) IR31-26 (Opcode) SE IR15 IR25 Sign extension LB SW C A B 32 P C 32 Number of the dest. register (from WB stage) Data (from WB stage) DR D Num Ra Destination register (see above) 5 (31-16) Immed./Branch (31-26) Jump 6 16 Sign extension PC31-0 (JL and JLR) 32

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 EX MEM WB for Branch 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? RF Address =0? PC Ra Rb Rc M U X Data A L U IM I R 1 L M D R Z M U X DR M U X DM D 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) OI Y Z: Computed data or Memory Address or Branch Address I R 2 I R 3 I R 4 Num Ra,Rb,Rc NumRa destination register Y: Computed data from the previous stage IF/ID ID/EX EX/MEM MEM/WB OI: Other Input (immediate field with SE or destination address with SE)

Pipelined execution of an “ALU” instruction The result of each stage is sampled at the end of its cycle IF IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4 ID A <= Ra; B <= Rb;C<=Rc PC2 <= PC1; IR2<=IR1 ID/EX <= Instruction decode; num Ra, Rb, Rc NOTE: IRi bits which are dropped stage by stage when no more needed for all instructions. Z<= B op C or Z <= B op [(IR215)16 ## IR215..0] [PC3 <= PC2] EX [IR3 <= IR2] Decoded opcode travels through all stages MEM Y <= Z (temporary storage for WB) Why ? [IR4 <.= IR3] [PC4 <= PC3] JAL, JALR!! WB Ra <= Y

Pipelined execution of a “MEM” instruction IF IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4 A <= Ra; B <= Rb;C<=Rc PC2 <= PC1; IR2<=IR1 ID/EX <= Instruction decode; num Ra, Rb, Rc ID MAR <= B op (IR215)16 ## IR215..0 SMDR <= A 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 Ra <= LMDR (if LOAD) [Sign ext.]

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

Pipelined execution of a “JR” instruction ID IF IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4 new PC address A <= Ra; B <= Rb;C<=Rc PC2 <= PC1; IR2<=IR1 ID/EX <= Instruction decode; num Ra, Rb, Rc ID Z <= A EX MEM [IR3 <= IR2] [PC4 <= PC3] [PC3 <= PC2] Decoded opcode travels through all stages WB MEM PC <= Z [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?

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

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 <= Ra; B <= Rb;C<=Rc PC2 <= PC1; IR2<=IR1 ID/EX <= Instruction decode; [X]<= num[Ra] ID EX ? MEM ? WB ?

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’t be executed simultaneously. Data Hazards – they are due to instruction dependencies. For example, an instruction that needs to read a RF 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).

Hazards and stalls Ti = 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 Ti = 8 * CLK = (5 + 3) * CLK Ti = 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. Normally the three stalled instructions are transformed in NOPs to avoid clock blocking

Data are read from registers in the ID stage Forwarding Data are read from registers in the ID stage Clk 1 Clk 2 Clk 3 Clk 4 Clk 5 Clk 6 Clk 7 Clk 8 Clk 9 ADD R3, R1, R4 IF ID EX MEM WB SUB R7, R3, R5 hazard ID EX MEM IF WB OR R1, R3, R5 hazard ID MEM WB EX IF LW R6, 100 (R3) hazard ID IF EX MEM WB 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 IF ID EX MEM WB Forwarding allows eliminating almost all RAW hazards of the pipeline without stalling the pipeline. (NOTE: in DLX, registers of the RF are modified only in WB stage)

Forward implementation Combinatorial!! comparison between Ra, Rb, Rc, and Rd1, Rd2 and the Opcodes Rd1, Rd2 destination registers 1-31 A,B,C source registers 1-31 Rd1 (/OpCode) Rd2/OpCode FU Ra, Rb, Rc OpCode IR3 IR4 FD3 Bypass PC RF PC M U X M U X A PC M U X C Mem A L U M U X ALU B M U X M U X M U X Often performed inside the RF It allows “the anticipation” of the register on ID/EX MUX control: IF opcode and comparison of RD with Ra, Rb and Rc numbers Offset FD1 FD2 ID/EX EX/MEM MEM/WB FD3

Forward (simplified) Let’s call X and Y and Z the values of registers Ra, Rb, Rc extracted from the register file. The following combinatorial procedure applies separately for each of these registers. Yes Does the instruction in MEM stage write the register file? No Yes Is the register number in MEM stage identical to Ra, Rb, Rc ? No No Forwarding from MEM Yes Does the instruction in WB stage write the register file? No forwarding Yes Is the register number in WB stage identical to Ra, Rb, Rc ? No Forwarding from WB No forwarding

Forward Unit implementation Does the instruction in the Mem stage want to write a register? Yes Does the instruction in the MEM or WB stage will write a register number which is identical to Ra or Rb or Rc number? No No FD1 FD2 Yes No NO FD1 Does the instruction in EX stage needs the register read in Mem stage? Is the destination register number identical to Ra or Rb or Rc number ? Does the instruction in the WB stage want to write a register? Yes Yes No Yes FD1 FD1 Is the destination register number identical to Ra or Rb or Rc number FD3 No Yes Does the instruction in the WB stage want to write a register? Does the fetched instruction needs the register being written by WB stage? No Yes No FD2 Yes No No Is the destination register number identical to Ra or Rb or Rc number and different from the register which will be written by the MEM stage? FD3 Yes NoFD3 FD2

The first two stages of any instruction are therefore modified IR <= M[PC] ; PC <= PC + 4 ; PC1 <= PC + 4 ID A <= Ra; B <= Rb;C<=Rc PC2 <= PC1; IR2<=IR1 ID/EX <= Instruction decode; num[Ra], num [Rb], num [Rc], saved

Data hazard due to LOAD instructions This slide must be viewed using its .PSM version Data hazard due to LOAD instructions The pipeline needs to be stalled 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!) Transformed in NOP PC-<PC-4 From the end of this stage onwards: standard forwarding IF ID EX MEM WB LW R1,32(R6) ADD R4,R1,R7 IF ID S EX MEM NOP IF ID EX MEM WB ADD R4,R1,R7 IF ID EX MEM (Re-fetch) SUB R5,R1,R8 IF ID EX AND R6,R1,R7 IF ID

with a “useful” instruction Delayed load In many RISC CPUs, the special hazard associated with the LOAD instruction (which would in any case lead to a stall ) is not handled by stalling the pipeline but by software through the compiler (delayed load). In this example R3 is needed by the ADD instruction while it is read from the memory [instruction LW R3, 10(R4)]. Please notice that in any case a hardware forward netwotk is required 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) Forward hardware LOAD Instruction delay slot Next instruction The compiler tries to fill the delay-slot with a “useful” instruction (worst case: NOP).

Next InstructionAddress Control Hazards Next InstructionAddress R4 = 0 : Branch Target Address (taken) R4  0 : PC+4 (not taken) PC BEQZ R4, 200 PC+4 SUB R7, R3, R5 PC+8 OR R1, R3, R5 PC+12 LW R6, 100 (R8) PC+4+200 AND R9, R5, R3 (BTA) New computed PC value (Aluout) New value in PC (one clock after: new value must be clocked onto the PC) 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

DLX Branch or JMP BEQZ R4, 200 IF/ID ID/EX EX/MEM MEM/WB Detailed dapath slide: See DLX Pipelined Datapath Here we assume that the JMP instruction is the Ith instruction NOTE if the feedback signal of the new PC were output directly from the ALU output instead of Z the required stalls would be only two – slower clock! Instruction Fetch ID EX WB MEM BEQZ R4, 200 J M P 4 J M P I + 1 A D M U X J M P I + 1 I + 2 I + 1 J M P I + 3 I + 2 DEC RF =0? DR D Ra Rb Rc =0? PC M U X DM PC A L U IM RF Mem M U X Z M U X ALU When the new PC acts on the IM three instructions have already travelled through the first three stages (EX included) SE Num [Ra] IF/ID ID/EX EX/MEM MEM/WB

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 (BEQZ) has not been yet decoded Real situation Repeated IF PC <= PC - 4 S S S IF Here the new value of PC has been computed 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 NOP If branch taken: flush. They become NOP. No data yet written BEQZ R4, 200 IF ID EX MEM WB IF ID ID EX MEM WB SUB R7, R3, R5 IF ID EX MEM WB OR R1, R3, R5 ID IF ID ID EX MEM WB LW R6, 100 (R8) No problem because no instruction in WB stage

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 Active if jump N O P Jump forced NOP 4 A D M U X PC DEC =0? =0? IM RF DR D Rb Rc Ra PC M U X DM A L U M U X M U X 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 Num [Ra] Data IF/ID ID/EX EX/MEM MEM/WB

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 N O P forced NOP when jump Active if jump 4 A D M U X PC DEC =0? =0? IM RF DR D Rb Rc Ra PC M U X DM 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 Num [Ra] Data IF/ID ID/EX EX/MEM MEM/WB

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 clock solution ! IF ID EX MEM WB Active if jump N O P Becomes NOP if jump 4 A D PC M U X DEC =0? =0? IM RF DR D Rb Rc Ra PC M U X DM A L U DATA MEM M U X M U X A NOP MUST replace the unwanted instruction already started SE Num [Ra] Data IF/ID ID/EX EX/MEM MEM/WB

with “useful” instructions Delayed branch Similarly to the LOAD case. In several RISC CPUs the BRANCH instructions hazard is handled by SW through 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

Obviously in this instructions group there must be no jumps!!! Delayed branch/jump Original Sne R1, R8, R9 ; branch condition Br R1, +100 Add R5, R4, R3 Sub R6, R5, R2 Or R14, R6, R21 Compiled Add R5, R4, R3 Sub R6, R5, R2 Or R14, R6, R21 Sne R1, R8, R9 ; Br R1, +100 branch condition 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

Handling the Control Hazards Dynamic Prediction: Branch Target Buffer => no stall (almost..) PC Predicted PC T/NT T/NT taken/Not taken 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 : 1-3 stalls (correct fetch in ID or EX, see before)

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.

Usually two bits. TAKEN TAKEN TAKEN UNTAKEN TAKEN TAKEN UNTAKEN