Esercizi Calcolatori elettronici

Analisi dei conflitti strutturali tra istruzioni standard e istruzioni delta

Istruzioni ALU:

IF ID EX MEM WB_i-1 → IF ID EX MEM WB_i

IF ID EX+MULT MEM MULT MEM2_i+1 → IF ID EX MEM WB

Non si verificano stalli in quanto EX utilizza la ALU mentre MULT utilizza il moltiplicatore aggiuntivo. La fase MEM non crea stalli in quanto nelle istruzioni aritmetiche non viene utilizzato il banco di memoria.

Caso di istruzioni LOAD/STORE:

IF ID EX MEM WB_i-1 → IF ID EX MEM WB_i

IF ID EX+MULT MEM MULT MEM2_i+1 → IF ID EX MEM WB_i+2

IF ID EX MEM WB_i+2 → IF ID EX * MEM

Conflitto tra MEM2 di i e MEM di i+2: conflitto risolto con uno stallo.

Analisi dei conflitti strutturali tra istruzioni delta sovrapposte:

i-1 IF ID

EX+MULT MEM MULT MEM2i IF ID

EX+MULT MEM MULT MEM2i+1 IF ID

EX+MULT MEM MULT MEM2IF

ID EX+MULT MEM MULT MEM2IF

ID EX+MULT MEM MULT

IF ID EX+MULT MEM MULT

MEM2i+5 IF ID

IF ID

EX+MULT MEM MULT

MEM2IF

IF

IF

i+5

I

conflitti sono risolvibili con 2 stalli ogni 4 istruzioni delta in pipeline.

ISTRUZIONE DELTA

L'istruzione deve eseguire la seguente operazione: M[R3 + 68] * M[R2] R1→

Considerazioni

La presenza di un immediato di lunghezza 36 prevede una situazione non standard.

Logica RISC

LOAD RQ R2 (0)

LOAD RT R3 (68)

DMULT R1 RQ RT

CC 1 2 3 4 5 6 7 8

LOAD IF ID EX MEM WB

LOAD IF ID EX MEM WB

DMULT IF ID * EX MEM WB

È presente un conflitto di dato al CC 5 tra la fase MEM della seconda LOAD e la fase EX della DMULT: quest'ultima utilizza il registro RT che viene caricato nella fase precedente e quindi è necessario uno stallo per permettere l'ingresso nell'ALU di MEM/WB.LMD.

Logica CISC

6 bit (0 – 5) codice operativo

• →5 bit (6 - 10) R1

• →5 bit (11 - 15) R2

• →5 bit (16 - 20) R3 //latch aggiuntivo

→11 bit (21 - 31) Immediato

• →Fasi:
1. IFMemIstr[PC] -> IF/ID.IR
2. If(EX/MEM.opcode == branch & EX/MEM.cond ||EX/MEM.opcode == jump)
• {EX/MEM.ALUOUT PC}
3. else {(NPC=PC+4) PC}
4. IDIF/ID.IR -> ID/EX.IR //A = R3
• rarr;Regs[IF/ID.IR ] ID/EX.A16-20 //B = R2
• rarr;Regs[IF/ID.IR ] ID/EX.B11-15
• rarr;Regs[IF/ID.IR ] ID/EX.Imm(16)16-31
• rarr;Regs[IF/ID.IR ] ID/EX.Imm(26)6-31 //aggiunta di un modulo di estensione in
• rarr;Regs[IF/ID.IR ] ID/EX.Imm(11)21-31segno collegato in uscita all’ingresso 2 dell’ALU
5. EX+MEM ->ID/EX.IR EX/MEM.IR //ALUOUT = R3 + 68
• rarr;ID/EX.A + ID/EX.Imm(11) EX/MEM.ALUOUT
• LMD = M[R2]. Aggiunta di un MUX alla porta dati
• rarr;Mem[ID/EX.B] MEM/WB.LMDdella memoria per la scelta in ingresso tra ALUOUT e B
6. MEM1 ->EX/MEM.IR MEM/WB.IR //latch aggiuntivo per propagare LMD. LMD1 = M[R2]
• rarr;MEM/WB.LMD MEM/WB.LMD1 //LMD = M[R3 + 68]
• rarr;Mem[EX/MEM.ALUOUT] MEM/WB.LMD
7. EX1 //latch aggiuntivo per propagare IR
8. rarr;MEM/WB.IR MEM/WB.IR1

//ALUOUT = LMD * LMD1. LMD1→MEM/WB.LMD1 * MEM/WB.LMD EX/MEM.ALUOUTcollegato a uno qualsiasi degli ingress dell’ALU
Alternativa: moltiplicatore aggiuntivo
MULT →MEM/WB.IR MEM/WB.IR1 //MULTOUT = LMD * LMD1. LMD1.→MEM/WB.LMD1 * MEM/WB.LMD EX/MEM.MULTOUTMULTOUT latch aggiuntivo
6. WB //R1 = ALUOUT→EX/MEM.ALUOUT Regs[MEM/WB.IR1 ]6-10
Alternativa: moltiplicatore aggiuntivo
WB //R1 = MULTOUT→EX/MEM.MULTOUT Regs[MEM/WB.IR1 ]6-10
Analisi dei conflitti strutturali tra istruzione ALU e istruzione epsilon:
Senza moltiplicatore aggiuntivo:
• i – 2 IF ID EX MEM WBi – 1 IF ID EX MEM WBi IF ID EX+MEM MEM1 EX1 WBi+1 IF ID EX MEM * WBi+2 IF ID * * EX MEM WBIn questo caso sono necessari due stalli in quanto vanno in conflitto EX1 dell’istruzioneepsilon e la fase EX dell’istruzione i+2 e le WB di epsilon e i+1.
Con moltiplicatore aggiuntivo:
• i–2 IF ID EX MEM WBi–1 IF ID EX MEM WBi IF ID EX+MEM MEM1 MULT WBi+1 IF ID EX MEM * WBi+2 IF ID

EX * MEM WB

Presenza di uno stallo dovuto al conflitto tra le WB di epsilon e i+1.

Analisi dei conflitti strutturali tra istruzione LOAD/STORE e istruzione epsilon:

Senza moltiplicatore aggiuntivo:

• i-2 IF ID EX MEM WB
• i-1 IF ID EX MEM WB
• i IF ID * EX+MEM MEM1 EX1 WB
• i+1 IF * ID EX MEM * WB
• i+2 IF ID * * EX MEM WB

Rispetto al caso delle istruzione ALU, è presente un ulteriore stallo tra epsilon e i-1 dovuto al conflitto tra MEM (i-1) e EX+MEM (i).

Con moltiplicatore aggiuntivo:

• i-2 IF ID EX MEM WB
• i-1 IF ID EX MEM WB
• i IF ID * EX+MEM MEM1 MULT WB
• i+1 IF * ID EX MEM * WB
• i+2 IF ID * * EX MEM WB

Uguale a caso senza moltiplicatore aggiuntivo.

Analisi dei conflitti strutturali tra istruzioni epsilon sovrapposte:

Senza moltiplicatore aggiuntivo:

• i IF ID EX+MEM MEM1 EX2 WB
• i+1 IF ID * * EX+MEM MEM1 EX2 WB
• i+2 IF * * ID EX MEM * WB
• i+3 IF ID * * EX MEM WB
• i IF ID EX+MEM MEM1 EX2 WB
• i+1 IF ID EX MEM * WB
• i+2 IF ID * * EX+MEM MEM1 EX2 WB
• * IF ID * EX MEM WB

1. IF ID EX+MEM MEM1 EX2 WBi+1
2. IF ID EX * MEM WBi+2
3. IF ID * EX+MEM MEM1 EX2 WB
4. Con moltiplicatore aggiuntivo:
• i IF ID EX+MEM MEM1 MULT WBi+1
• IF ID * EX+MEM MEM1 MULT WBi+2
• IF * ID EX MEM * WBi+3
• IF ID EX * MEM WBi
• IF ID EX+MEM MEM1 MULT WBi+1
• IF ID EX MEM * WBi+2
• IF ID EX+MEM * MEM1 MULT WBi+3
• IF * ID EX MEM WBi
• IF ID EX+MEM MEM1 MULT WBi+1
• IF ID EX MEM * WBi+2
• IF ID EX * MEM WBi+3
• IF ID * * EX+MEM MEM1 MULT WB
5. Analisi dei conflitti di dato:
• R1: R1 è destinazione della WB, perciò viene sovrascritto nell'ultima fase e, se presenti opportuni stalli, non si verificano conflitti di dato.
• R2: R2 è un indirizzo di una LOAD; se l'istruzione precedente effettua una LOAD su R2, non c'è alcun conflitto; se l'istruzione precendente è un'operazione ALU che modifica R2 è necessario cortocircuitare EX/MEM.ALUOUT con MEM/WB.LMD.
• R3: R3 è sorgente di una operazione ALU (in particolare una

eEX/MEM.ALUOUTPUT.Logica CISCè necessaria una nuova codifica, in quanto sono previsti 4 registri anziché 3. È inoltrenecessario aumentare la banda passante di accesso ai registri GPR:

• 6 bit (0 – 5) -> codice operativo
• 5 bit (6 – 10) -> R4
• 5 bit (11 – 15) -> R1
• 5 bit (16 – 20) -> R2
• 5 bit (21 – 25) -> R3
• 6 bit (26 – 31) -> immediato //non usati

Fasi:

1. IFMem[PC] -> IF/ID.IR
2. If(EX/MEM.opcode == branch||EX/MEM.opcode == jump & EX/MEM.cond){EX/MEM.ALUOUT -> Mem[PC]}else {Mem[PC] = PC+4}
3. IDIF/ID.IR -> ID/EX.IR //R2 -> ARegs[IF/ID.IR ] -> ID/EX.A16 – 20 //R3 -> BRegs[IF/ID.IR ] -> ID/EX.A21 – 25 //latch aggiuntivo, R1 -> CRegs[IF/ID.IR ] -> ID/EX.C11 – 15Regs[IF/ID.IR ] -> ID/EX.Imm266 - 31Regs[IF/ID.IR ] -> ID/EX.Imm1616 - 31
4. EX + MEMID/EX.IR -> EX/MEM.IRID/EX.A * ID/EX.B -> EX/MEM.ALUOUTMem[ID/EX.C] -> MEM/WB.LMD

EX2EX/MEM.IR -> MEM/WB.IR

MEM/WB.LMD + EX/MEM.ALUOUT -> EX/MEM.ALUOUT

EX/MEM.ALUOUT -> Regs[MEM/WB.IR ]6 – 10

WB //modifica al MUX del WB in modo che

EX/MEM.ALUOUT -> Regs[MEM/WB.IR ]6 – 10

Alternativa 1 (le prime quattro fasi rimangono invariate):

1. /

2. /

3. / //fase di passaggio

4. EX2EX/MEM.IR -> MEM/WB.IR

EX/MEM.ALUOUT -> MEM/WB.ALUOUT

5. WB

MEM/WB.ALUOUT -> Regs[MEM/WB.IR ]6-10

Alternativa 2 (le prime 3 fasi rimangono invariate):

1. /

2. /

3. / //sommatore aggiuntivo

4. SUMEX/MEM.IR -> MEM/WB.IR

MEM/WB.LMD + EX/MEM.ALUOUT -> MEM/WB.ALUOUT

5. WB

MEM/WB.ALUOUT -> Regs[MEM/WB.IR ]6 – 10

Analisi dei conflitti strutturali tra istruzione standard e istruzione gamma:

IF ID EX MEM WB

i-1 IF ID EX MEM WB

i IF ID EX+MEM EX2 WB

i+1 IF ID EX MEM WB

IF ID EX MEM WB

Senza sommatore:

1) L’istruzione i-1 è una LOAD oppure una STORE:

IF ID EX MEM WB

i - 1 IF ID EX MEM WB

i IF ID * EX+MEM EX2 WB

i + 1 IF * ID EX MEM WB

IF ID EX MEM WB

Conflitto risolto con 1

1. L'istruzione i+1 utilizza l'ALU:
• IF ID EX MEM WBi-1
• IF ID EX MEM WBi
• IF ID EX+MEM EX2 WBi+1
• IF ID * EX MEM WB
2. Conflitto risolto con 1 stallo.
3. Con sommatore:
• IF ID EX MEM WBi-1
• IF ID EX MEM WBi
• IF ID EX+MEM SUM WBi+1
• IF ID EX MEM WB
• IF ID EX MEM WBi-1
• IF ID EX MEM WBi
• IF ID * EX+MEM SUM WBi+1
• IF * ID EX MEM WB
4. L'istruzione i-1 è una LOAD o una STORE:
• Conflitto risolto con 1 stallo.
5. Analisi dei conflitti strutturali tra istruzioni gamma sovrapposte:
6. Senza sommatore:
• IF ID EX+MEM EX2 WBi-1
• IF ID EX+MEM EX2 WBi
• IF ID EX+MEM EX2 WBi+1
• IF ID EX+MEM EX2 WB
7. Usando l'ALU in EX2 si ha un conflitto tra due istruzioni consecutive.
8. IF ID EX+MEM