Lezione di Tutorato Di Architettura degli Elaboratori B

Lezione di Tutorato Di Architettura degli Elaboratori B
18/05/2005
SOLUZIONI: PIPELINE
Consegna per le domande del compito: (da 3 a 5 domande)
Rispondere alle seguenti domande in maniera sintetica, usando il presente foglio per scrivere le risposte. Non è
possibile consultare libri o appunti.
Tempo a disposizione: 35 min.
Domande:
1.
Quali sono i fattori che influenzano il CPI medio misurato per l’esecuzione di un
insieme di programmi su un’architettura multiciclo? E Su un’architettura pipeline?
2.
Spiegare perché le dipendenze sui dati (RAW) possono provocare criticità
nell’esecuzione pipeline vista a lezione per il processore MIPS.
3.
In cosa si differenziano le parti controllo della CPU multiciclo e pipeline visti a
lezione?
4.
Rispetto all’architettura pipeline vista a lezione, in che cosa consiste il forwarding, e a
cosa serve? (E’ possibile spiegare con un esempio)
5.
Rispetto all’architettura pipeline vista a lezione, in che cosa consiste il delayed branch
e quali sono i suoi vantaggi/svantaggi?
6.
Perché nei processori pipeline moderni è necessario prevedere il salti? Molto
sinteticamente, come viene realizzata la previsione?
7.
Rispetto all’architettura pipeline vista a lezione (con forwarding), in quale caso non
riusciamo ad eliminare lo stallo dopo l’istruzione di lw, e perché?
8.
Verificare (con qualche esempio) come le dipendenze sui dati tra istruzioni aritmetiche
MIPS non provocano stalli nella CPU pipeline a 5 stadi visti a lezione, grazie al
forwarding dei dati e al particolare register file, che nella prima parte del ciclo scrive e
nella seconda parte legge i registri.
Ultima modifica: 18/05/2005
Luca Di Gesù 786959
1
Lezione di Tutorato Di Architettura degli Elaboratori B
18/05/2005
Esercizi:
1. Considerare il seguente programma assembler MIPS:
addi $10, $0, 0
Loop:
add $11, $20, $10
lw $12, 0($11)
addi $12, $12, 128
sw $12, 0($11)
addi $10, $10, 4
bne $10, $21, Loop
Se $20 è un indirizzo di memoria e $21=1024, qual è l’effetto dell’esecuzione ?
Calcolare il CPI del programma rispetto a:
• la CPU pipeline vista a lezione con forwarding e delayed branch (in questo caso,
se necessario, disegnare il diagramma degli stati di un’iterazione del loop);
• la CPU multiciclo vista a lezione.
Risp: Il programma somma 128 agli elementi di un array di 256 elementi interi, dove l’array è puntato da $20.
Il loop è eseguito 256 volte.
Il numero di istruzioni eseguite è quindi:
IC = 1 + 256 * 6 = 1 + 1536 = 1537
• Gli unici stalli sono necessari dopo la lw a causa di una dipendenze RAW sul registro $12, mentre
una nop deve essere inserita dopo la bne a causa del delayed branch.
Quindi il numero di cicli totali, senza considerare i cicli per inizializzare la pipeline, sono:
#Cicli = 1 + 256 * ( 6 + 2 ) = 1 + 2048 = 2049
Da cui si ottiene che il CPI è:
CPI = 2049/1537 = 1.33
• Considerando che tutte le istruzioni impiegano 4 cicli, escluso bne (3 cicli) e lw (5 cicli), per ogni
ciclo del loop si impiegano:
#Cicliiter = 4 * 4 + 3 + 5 = 24 cicli
Quindi i cicli totali per l’esecuzione sono:
#Cicli = 4 + 256 * 24 = 6148
Da cui si ottiene che il CPI è:
CPI = 6148 / 1537 = 4
2. Si individuino le dipendenze RAW (Read After Write) nel seguente codice MIPS:
Compito 17 Giugno 2002)Es3
lw $2, 25($27)
add $1, $2, $3
add $4, $5, $6
add $4, $4, $1
add $4, $4, $28
Si consideri una CPU MIPS a 5 stadi come quella vista a lezione, ma senza forwarding, e
con un register file che nella prima parte del ciclo scrive e nella seconda parte del ciclo legge
i registri. La CPU in questione non ha hazard detection unit, per cui la gestione delle
dipendenze è affidata al software.
Si richiede quindi di inserire le nop opportune nel codice, di verificare il funzionamento con
un diagramma temporale, e di calcolare il #Cicli totali spesi per l’esecuzione.
Continua…
Ultima modifica: 18/05/2005
Luca Di Gesù 786959
2
Lezione di Tutorato Di Architettura degli Elaboratori B
18/05/2005
Continua esercizio 2…
Si consideri inoltre un altra CPU che, rispetto alla prima, sia dotata di forwarding e hazard
detection unit. In questo caso la pipeline viene messa in stallo dinamicamente, dai circuiti
della CPU. Si richiede di disegnare il diagramma temporale di esecuzione, mettendo in
evidenza i forwarding (con delle frecce, da stadio a stadio), e di calcolare il #Cicli totali
spesi per l’esecuzione.
Come sono occupati i 5 stadi della pipeline durante il 4° ciclo di esecuzione?
Risp:
Il diagramma delle dipendenze RAW è il seguente, gli archi sono etichettati con i registri che causano le
varie dipendenze:
Dopo aver inserito le nop opportune, il codice diventa:
lw $2, 25($27)
nop
nop
add $1, $2, $3
add $4, $5, $6
nop
nop
add $4, $4, $1
nop
nop
add $4, $4, $28
che impiega appunto 15 cicli, come si evince dal diagramma temporale seguente:
Continua…
Ultima modifica: 18/05/2005
Luca Di Gesù 786959
3
Lezione di Tutorato Di Architettura degli Elaboratori B
18/05/2005
Continua esercizio 2…
Infine, se la CPU fosse dotata di forwarding, i cicli impiegati per l’esecuzione sarebbero 10, come si
evince dal corrispondente diagramma:
Al 4° ciclo le componenti della CPU sono impiegate come segue:
IF sta eseguendo (ripetendo) la seconda add del programma,
ID sta eseguendo (ripetendo) la prima add,
su EXE sta transitando una bolla (nop),
MEM sta eseguendo lw,
WB non sta eseguendo nessuna delle istruzioni del nostro frammento di programma (quindi WB sta
eseguendo l’eventuale istruzione precedente la lw).
3. Si individuino le dipendenze RAW (Read After Write) nel seguente codice MIPS:
1. lw $2, 25($27)
2. add $4, $2, $6
3. add $1, $27, $3
4. sub $5, $2, $1
5. and $5, $5, $28
Si consideri una CPU MIPS a 5 stadi come quella vista a lezione, ma senza forwarding, e
con un register file normale, che durante un ciclo di clock permette di leggere i vecchi valori
di una coppia di registri, e di modificare un solo registro alla fine dello stesso ciclo.
La CPU in questione non ha hazard detection unit, per cui la gestione delle dipendenze è
affidata al software.
Si richiede quindi di inserire le nop opportune nel codice, di verificare il funzionamento con
un diagramma temporale, e di calcolare il #Cicli totali spesi per l’esecuzione.
Si chiede infine di modificare l’ordine di esecuzione delle istruzioni per ridurre il numero di
cicli impiegati per l’esecuzione del programma. Verificare il risparmio in cicli tramite il
diagramma temporale di esecuzione.
Risp:
Le dipendenze sono:1->2 (reg. $2)
1->4 (reg. $2)
3->4 (reg. $1)
4->5 (reg. $5)
Continua…
Ultima modifica: 18/05/2005
Luca Di Gesù 786959
4
Lezione di Tutorato Di Architettura degli Elaboratori B
18/05/2005
Continua esercizio 3…
Per far rispettare le dipendenze di sopra, istr_i -> istr_j, basta fare in modo che lo stadio ID dell’istruzione
istr_j avvenga successivamente allo stadio WB di istr_i con i<j .
Dopo aver inserito le nop opportune, il nuovo diagramma temporale è il seguente.
Scambiando 2 con 3 abbiamo:
1. lw $2, 25($27)
3. add $1, $27, $3
2. add $4, $2, $6
4. sub $5, $2, $1
5. and $5, $5, $28
Grazie a questa modifica, possiamo ridurre il numero di nop inserite.
4. Solitamente abbiamo ottimizzato il codice in esecuzione su un processore pipeline con
forwarding, riordinando opportunamente le istruzioni. In questo esercizio si chiede invece di
massimizzare il numero di cicli impiegati, riordinando le istruzioni in modo da rispettare le
dipendenze, ma introducendo il massimo numero di stalli. Il codice da peggiorare è il
seguente, dove l’ultima istruzione è stata inserita nel delay slot del branch:
1Ciclo:lw
2
lw
3
add
4
add
5
add
6
sw
7
beq
8
addi
$3,
$4,
$7,
$8,
$10,
$6,
$10,
$5,
0($5)
4($5)
$7,
$8,
$7,
0($5)
$11,
$5,
$3
$4
$8
Ciclo
8
Individuare le dipendenze del codice, e verificare eventuali stalli nello scheduling attuale
delle istruzioni. Peggiorare il codice segnalando gli stalli introdotti.
Continua…
Ultima modifica: 18/05/2005
Luca Di Gesù 786959
5
Lezione di Tutorato Di Architettura degli Elaboratori B
18/05/2005
Continua esercizio 4…
Risp: Il codice peggiorato `e il seguente:
1Ciclo:lw $3, 0($5)
3
add $7, $7,
6
sw $6, 0($5)
2
lw $4, 4($5)
4
add $8, $8,
5
add $10, $7,
8
addi $5, $5,
7
beq $10, 11,
nop
$3
# stallo sul registro $3
$4
$8
8
Ciclo
# stallo sul registro $4
# delay slot non riempito
5. Si consideri il seguente programma:
start : add
lw
addi
sw
addi
bne
nop
end_loop:
...
$t1,
$t2,
$t2,
$t2,
$t0,
$t0,
$s0,
0($t1)
$t2,
0($t1)
$t0,
$s3,
$t0
100
4
start
$s0 contiene l’indirizzo iniziale di un array di interi, $t0 viene usato come indice dell’array,
mentre $s3 (ovvero $s3/4) contiene il numero di elementi dell’array.
• Individuare le dipendenze RAW (Read After Write) nel codice
• Facendo riferimento all’architettura MIPS vista a lezione con pipeline a 5 stadi,
considerando sia il forwarding e sia il delayed branch (vedi nop dopo il branch), si
disegni un diagramma temporale di esecuzione di una singola iterazione del loop,
mettendo in evidenza i vari forwarding necessari per risolvere le dipendenze RAW.
Risp:
Le dipendenze RAW sono illustrate nel seguente diagramma:
Il diagramma di esecuzione del corpo del loop con i relativi forwarding è il seguente:
Ultima modifica: 18/05/2005
Luca Di Gesù 786959
6