02 ILP Spring2021

Διάλεξη:
Διασωλήνωση και
Παραλληλία Επιπέδου Εντολών
ΕΠΛ325 Παράλληλη Επεξεργασία
Σήμερα θα θυμηθούμε (από το ΕΠΛ221)…

• Πώς οι CPU εκμεταλλεύονται το ILP για να επιταχύνουν τον κώδικα
• Βασικές ιδέες:
• Pipelining & Superscalar: Εργάσου σε πολλές εντολές ταυτόχρονα
• Out-of-order execution: Χρονοπρογραμμάτισε δυναμικά εντολές όποτε είναι
«έτοιμες»
• Speculation: Μάντεψε τι θα κάνει το πρόγραμμα στη συνέχεια για να ανακαλύψεις
μια πιο ανεξάρτητη δουλειά, "επαναφέροντας" λανθασμένες εικασίες
• Οι επεξεργαστές πρέπει να κάνουν όλα αυτά διατηρώντας παράλληλα την

ψευδαίσθηση ότι οι εντολές εκτελούν σε σειρά, μία προς μία
Παράδειγμα: Υπολογισμός πολυωνύμου
int poly(int *coef,

int terms, int x) {
int power = 1;
int value = 0;
for (int j = 0; j < terms; j++) {
value += coef[j] * power;
power *= x;
}
return value;
}

• Μεταγλώττιση για επέκταση MIPS (mla και mul)
int poly(int *coef, poly: $4: coef
int terms, int x) { sll $5,$5,2 $5: terms
int power = 1; add $5,$4,$5 $6: x
int value = 0; ori $9,$0,1 $8: value
for (int j = 0; j < terms; j++) { xor $8,$8,$8 $9: power
value += coef[j] * power; $L2: $10: *coef
power *= x; lw $10,0($4)
} mla $8,$9,$10,$8
return value; mul $9,$9,$6
} addi $4,$4,4
bne $4,$5,$L2
add $2,$8,$0
j $31
4
int poly(int *coef, poly: $4: coef
int terms, int x) { sll $5,$5,2 $5: terms
Πρόλογος
int power = 1; add $5,$4,$5 $6: x
int value = 0; ori $9,$0,1 $8: value
for (int j = 0; j < terms; j++) { xor $8,$8,$8 $9: power
value += coef[j] * power; $L2: $10: *coef
power *= x; lw $10,0($4)
Επανάληψη
} mla $8,$9,$10,$8
return value; mul $9,$9,$6
} addi $4,$4,4
bne $4,$5,$L2
Επίλογος
add $2,$8,$0
j $31
5

for (int j = 0; j < terms; j++) { $4: coef
value += coef[j] * power; $5: terms
power *= x; $6: x
} $8: value
$9: power
$10: *coef
$L2:
lw $10,0($4) # $10 <– *coef
mla $8,$9,$10,$8 # value += $10 * power (mul + add)
mul $9,$9,$6 # power *= x
addi $4,$4,4 # coef += 4
bne $4,$5,$L2 # repeat
6
• Εκτέλεση poly(A, 3, x)
sll $5,$5,2
add $5,$4,$5
ori $9,$0,1
xor $8,$8,$8
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

sll $5,$5,2
Πρόλογος
add $5,$4,$5
ori $9,$0,1
xor $8,$8,$8
lw $10,0($4)
i=0 επανάληψη
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
8
sll $5,$5,2 ...
Πρόλογος
add $5,$4,$5 lw $10,0($4)
ori $9,$0,1 mla $8,$9,$10,$8
xor $8,$8,$8 mul $9,$9,$6
lw $10,0($4) addi $4,$4,4
mla $8,$9,$10,$8 bne $4,$5,$L2
lw $10,0($4)
mul $9,$9,$6
addi $4,$4,4 mla $8,$9,$10,$8
bne $4,$5,$L2 mul $9,$9,$6
... addi $4,$4,4
bne $4,$5,$L2
add $2,$8,$0
Επίλ
j $31
9

sll $5,$5,2 ...
Πρόλογος
add $5,$4,$5 lw $10,0($4)

ori $9,$0,1 mla $8,$9,$10,$8
xor $8,$8,$8 mul $9,$9,$6
lw $10,0($4) addi $4,$4,4
mla $8,$9,$10,$8 bne $4,$5,$L2

lw $10,0($4)
mul $9,$9,$6
addi $4,$4,4 mla $8,$9,$10,$8
bne $4,$5,$L2 mul $9,$9,$6
... addi $4,$4,4
bne $4,$5,$L2
add $2,$8,$0
Επίλ
j $31
10
Η διεπαφή λογισμικού-υλικού
• Η αρχιτεκτονική συνόλου εντολών (instruction set architecture - ISA)
είναι το λειτουργικό συμβόλαιο μεταξύ υλικού και λογισμικού
• Λέει τι κάνει κάθε οδηγία, αλλά όχι πώς
• Παράδειγμα: Διαταγμένη ακολουθία εντολών MIPS
• Η μικροαρχιτεκτονική ενός επεξεργαστή είναι η υλοποίηση της ISA
• Αρχιτεκτονική: 𝜇Arch :: Διεπαφή: Υλοποίηση
Απλό μοντέλο CPU

• Εκτελεί εντολές (instructions) με τη σειρά προγράμματος
• Χωρίζει την εκτέλεση εντολών σε στάδια, π.χ.

• 1. Fetch - λαμβάνει την επόμενη οδηγία από τη μνήμη
• 2. Decode - βρίσκει τι να κάνει και διαβάζει τις εισόδους
• 3. Execute - εκτελεί τις απαραίτητες λειτουργίες
• 4. Commit - γράφει τα αποτελέσματα πίσω στους καταχωρητές / μνήμη
• (Οι πραγματικοί επεξεργαστές έχουν πολλά ακόμη στάδια)

Υπολογισμός πολυωνύμου στο
απλό μοντέλο CPU
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
bne $4,$5,$L2 Fetch Decode Execute Commit
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 1. Διάβασε "lw $10,0($4)”
από τη μνήμη
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 2. Αποκωδικοποίησε "lw $10,0($4)” και
διάβασε τους καταχωρητές εισόδου
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 3. Διάβασε τη θέση
μνήμης 0($4)
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 4. Γράψε τιμή στον
καταχωρητή $10
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mla
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mla
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mla
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mla
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mul
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
απλό μοντέλο CPU Πόσο γρήγορος είναι αυτός ο επεξεργαστής?
1 ns
ΧΡΟΝΟΣ Latency? Throughput?
Fetch lw mla mul
Decode lw mla mul
Execute lw mla …
Commit lw mla
Latency = 4 ns / instr Throughput = 1 instr / 4 ns
Απλός CPU είναι πολύ σπάταλος

1 ns
ΧΡΟΝΟΣ
Fetch lw mla mul
Decode lw mla mul

Αδρανές
Υλικό …
Execute lw mla
Commit lw mla
Διασωλήνωση (Pipelining)
Η διασωλήνωση διατηρεί την CPU απασχολημένη

μέσω παραλληλίας επιπέδου εντολών
• Ιδέα: Ξεκίνησε αμέσως την επόμενη εντολή
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mla lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mul mla lw

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) addi mul mla lw

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) bne addi mul mla

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw bne addi mul

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
Υπολογισμός πολυωνύμου
σε pipelined CPU Πόσο γρήγορος είναι αυτός ο επεξεργαστής?
1 ns
ΧΡΟΝΟΣ Latency? Throughput?
Fetch lw mla mul addi bne lw mla add mul addi
Decode lw mla mul addi bne lw mla add mul
Execute lw mla mul addi bne lw mla add …
Commit lw mla mul addi bne lw mla
Throughput = 1 instr / ns
Latency = 4 ns / instr
4X speedup!
H επιτάχυνση που επιτυγχάνεται μέσω
παραλληλίας διασωλήνωσης
ΧΡΟΝΟΣ Ο επεξεργαστής εργάζεται σε 4 εντολές κάθε φορά
Fetch lw mla mul addi bne lw mla add mul addi
Decode lw mla mul addi bne lw mla add mul
Execute lw mla mul addi bne lw mla add …
Περιορισμοί διασωλήνωσης
• Ο παραλληλισμός απαιτεί ανεξάρτητη εργασία
• Ε: Είναι ανεξάρτητες οι εντολές;
• Α: Όχι! Πολλοί πιθανοί κίνδυνοι περιορίζουν τον παραλληλισμό…

Κίνδυνοι δεδομένων (data hazards)
lw ra,0(rb) # ra <- Memory[0 + rb]
mla rc,rd,re,rf # rc <- rd * re + rf
Ε: Πότε μπορεί η CPU να διοχετεύσει το mla πίσω από το lw;
Fetch lw mul ... ... ... ... • Α: Όταν χρησιμοποιούν

διαφορετικούς καταχωρητές
Decode lw mul ... ... ... • Συγκεκριμένα, όταν το mla δεν
διαβάζει δεδομένα γραμμένα
από το lw
Execute lw mul ... ...
• Π.χ., ra != rd &&
ra != re &&
Commit lw mul ...
ra != rf
Αντιμετώπιση κινδύνων δεδομένων:

Στάση διασωλήνωσης
• Δεν είναι δυνατή η διοχεύτεση του mla (lw γράφει $10)
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) lw
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) mla lw
mla $8,$9,$10,$8 ??
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 Εισήγαγε μία “φυσαλίδα” (NOP)
στη διασωλήνωση
...

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
lw $10,0($4) addi mul mla

mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 Το mla προχωρά όταν το lw
... έχει επικυρωθεί (committed)
Η στάση μειώνει την απόδοση
ΧΡΟΝΟΣ Ο επεξεργαστής εργάζεται σε 3 εντολές κάθε φορά
Fetch lw mla mul mul addi bne lw mla mul addi
Decode lw mla mla mul addi bne lw mla mul
Execute lw mla mul addi bne lw …
Commit lw mla mul addi bne lw
• Αλλά μερικές φορές η στάση είναι αναπόφευκτη

• Π.χ., εντολές μακράς καθυστέρησης (διαίρεση, cache miss)

Προώθηση δεδομένων (data forwarding)
• Παρατήρηση: τα δεδομένα είναι διαθέσιμα μετά την εκτέλεση!
CPU
Fetch Decode Execute Commit
$10
addi
mul mla lw
• Η προώθηση εξαλείφει πολλές (όχι όλες) στάσεις διασωλήνωσης

Η διασωλήνωση δεν είναι δωρεάν!
• Ε: Πόσο καλά κλιμακώνει (scale) η προώθηση;

• Α: Όχι καλά… πολλές διαδρομές προώθησης σε βαθιές και περίπλοκες
διασωληνώσεις
CPU
Fetch Decode Execute Execute Commit
Mem
Κίνδυνοι ελέγχου + Speculation

• Τα προγράμματα πρέπει να φαίνεται να εκτελούνται στη σειρά
προγράμματος
→ Όλες οι εντολές εξαρτώνται από προηγούμενες
• Οι περισσότερες εντολές συνεχίζουν σιωπηρά στην επόμενη…

• Αλλά οι διακλαδώσεις (branches) ανακατευθύνουν την εκτέλεση σε νέα
τοποθεσία
Αντιμετώπιση κινδύνων ελέγχου:
Εκκένωση (flushing) διασωλήνωσης
• Τι γίνεται αν λαμβάνουμε (fetch) πάντα την επόμενη εντολή;
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
add $2,$8,$0
j $31 addi mul add mul
Στατική ακολουθία εντολών

(δηλ., διάταξη προγράμματος στη μνήμη)

lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
add $2,$8,$0
j $31 add bne addi mul

(δηλ., διάταξη προγράμματος στη μνήμη)
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
add $2,$8,$0
j $31 jr add bne addi

(δηλ., διάταξη προγράμματος στη μνήμη) Ωχ! Λάβαμε λάθος εντολές!
(Ο βρόχος δεν τελείωσε)

ενη )
πόμ ηψη
(Ε νάλ
α lw $10,0($4)
επ
mla $8,$9,$10,$8
mul $9,$9,$6 CPU
addi $4,$4,4
add $2,$8,$0
j $31 lw bne

(δηλ., διάταξη προγράμματος στη μνήμη) Ωχ! Λάβαμε λάθος εντολές!
(Ο βρόχος δεν τελείωσε)
Εκκένωση διασωλήνωσης μειώνει απόδοση
Ο επεξεργαστής εργάζεται σε 2 ή 3
ΧΡΟΝΟΣ εντολές κάθε φορά
Fetch lw mla mul addi bne lw mla mul
Decode lw mla mul addi bne lw mla
Execute lw mla mul addi bne lw …
Commit lw mla mul addi bne
• Η ποινή (penalty) αυξάνεται με βαθύτερες διασωληνώσεις

Speculation
• Οι επεξεργαστές δεν περιμένουν την εκτέλεση των διακλαδώσεων
• Αντ 'αυτού, “μαντεύουν” (υποθέτουν/speculate) πού να πάνε στη

συνέχεια + ξεκινούν τη λήψη
• Οι σύγχρονοι επεξεργαστές χρησιμοποιούν πολύ εξελιγμένους

μηχανισμούς
• Π.χ., υποθέτουν στο στάδιο Fetch - πριν ο επεξεργαστής ξέρει ότι η εντολή είναι
διακλάδωση!
• > 95% ακρίβεια πρόβλεψης
• Ακόμα, η εσφαλμένη υπόθεση είναι μείζον πρόβλημα
Περίληψη διασωλήνωσης
• Η διασωλήνωση είναι ένας απλός, αποτελεσματικός τρόπος για τη
βελτίωση της απόδοσης
• Διασωλήνωση Ν-σταδίων επιτυγχάνει εώς και 𝑁× επιτάχυνση
• Η διασωλήνωση έχει όρια

• Είναι δύσκολο να διατηρηθεί ο αγωγός απασχολημένος λόγω κινδύνων
• Η προώθηση είναι ακριβή σε βαθιές διασωληνώσεις
• Η εκκένωση (flush) αγωγού είναι ακριβή σε βαθιές διασωληνώσεις
• Η διασωλήνωση είναι ευρέως χρησιμοποιούμενη, αλλά δεν ξεπερνά

το 𝑁≈15
Εκτέλεση εντολών εκτός σειράς

(out-of-order execution)
Αύξηση παραλληλισμού μέσω ροής δεδομένων
(dataflow)
• Ο παραλληλισμός περιορίζεται από πολλές ψευδείς εξαρτήσεις (false
dependencies), ιδιαίτερα από την ακολουθιακή σειρά προγράμματος
• Η ροή δεδομένων καταγράφει τον τρόπο με τον οποίο οι εντολές

εξαρτώνται πραγματικά από την άλλη
• Πραγματική εξάρτηση (true dependence): ανάγνωση-μετά-από-εγγραφή (read-
after-write / RAW)
Η ροή δεδομένων αυξάνει τον παραλληλισμό

με την εξάλειψη των περιττών εξαρτήσεων
Παράδειγμα: Εξαρτήσεις δεδομένων στο

πολυώνυμο
lw
mla
$10,0($4)
$8,$9,$10,$8
Read-after-write (RAW) – πραγματική εξάρτηση
mul $9,$9,$6 Write-after-read (WAW) – ψευδής εξάρτηση
addi $4,$4,4 Write-after-write (WAW) – ψευδής εξάρτηση
bne $4,$5,$L2
Εξαρτήσεις μεταξύ επαναλήψεων
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
Παράδειγμα: Ροή δεδομένων στο πολυώνυμο
Επανάληψη βρόχου
addi lw mul
lw $10,0($4)
mla $8,$9,$10,$8 bne mla
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
...
addi lw mul
Παράδειγμα: Ροή δεδομένων

bne mla
στο πολυώνυμο
Επανάληψη βρόχου
addi lw mul
lw $10,0($4)
mla $8,$9,$10,$8 bne mla
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2 addi lw mul
lw $10,0($4)
bne mla
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
addi lw mul
bne $4,$5,$L2
...
bne mla
Παράδειγμα: Εκτέλεση ροής δεδομένων στο
πολυώνυμο
• Μόνο εκτέλεση, με τέλειο χρονοπρογραμματισμό και απεριόριστες
μονάδες εκτέλεσης
• lw, mul εκτελείται σε 2 κύκλους
• addi, bne εκτελείται σε 1 κύκλο
• mla εκτελείται σε 3 κύκλους
• Ε: Η ροή δεδομένων επιταχύνει την εκτέλεση; Πόσο;
• Ε: Ποια είναι η συμφόρηση απόδοσης (performance bottleneck);
1 lw $10,0($4)
lw mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
mul $9,$9,$6
3
addi $4,$4,4
4 bne $4,$5,$L2
5
6
7
8
9
10
11
12
13
14
15
16
1 lw $10,0($4)
lw mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
mul $9,$9,$6
3
addi $4,$4,4
4 mla bne $4,$5,$L2
5
6
7
8
9
10
11
12
13
14
15
16
1 lw $10,0($4)
lw mul mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
mul $9,$9,$6
3
addi $4,$4,4
4 mla bne $4,$5,$L2
5
6
7
8
9
10
11
12
13
14
15
16
1 addi lw $10,0($4)
lw mul mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
mul $9,$9,$6
3
addi $4,$4,4
4 mla bne $4,$5,$L2
5
6
7
8
9
10
11
12
13
14
15
16
1 addi lw $10,0($4)
lw mul mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
bne
mul $9,$9,$6
3
addi $4,$4,4
4 mla bne $4,$5,$L2
5
6
7
8
9
10
11
12
13
14
15
16
1 addi lw lw $10,0($4)
mul mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
bne addi
lw mul $9,$9,$6
3 bne
mul addi $4,$4,4
4 mla bne $4,$5,$L2
5 lw $10,0($4)
6 mla $8,$9,$10,$8
mul $9,$9,$6
7 mla
addi $4,$4,4
8 bne $4,$5,$L2
9
10
11
12
13
14
15
16
1 addi lw lw $10,0($4)
mul mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
bne addi lw
mul $9,$9,$6
3 bne addi
lw mul addi $4,$4,4
4 bne mla bne $4,$5,$L2
5 lw $10,0($4)
mul
6 mla $8,$9,$10,$8
mul $9,$9,$6
7 mla
addi $4,$4,4
8 bne $4,$5,$L2
9 lw $10,0($4)
10 mla mla $8,$9,$10,$8
11 mul $9,$9,$6
addi $4,$4,4
12
bne $4,$5,$L2
13
14
15
16
1 addi lw lw $10,0($4)
mul mla $8,$9,$10,$8
2
ΧΡΟΝΟΣ
bne addi lw
mul $9,$9,$6
3 bne addi lw
mul addi $4,$4,4
4 bne addi lw mla bne $4,$5,$L2
5 bne addi lw lw $10,0($4)
mul
6 bne addi lw mla $8,$9,$10,$8
mul $9,$9,$6
7 bne addi lw mla
mul addi $4,$4,4
8 bne addi lw bne $4,$5,$L2
9 bne addi lw lw $10,0($4)
mul
10 bne addi lw mla mla $8,$9,$10,$8
11 bne addi lw mul $9,$9,$6
mul addi $4,$4,4
12 bne addi lw
bne $4,$5,$L2
13 bne addi lw mla lw $10,0($4)
mul
14 bne addi lw mla $8,$9,$10,$8
15 bne addi lw mul $9,$9,$6
mla mul addi $4,$4,4
16 bne addi lw
bne $4,$5,$L2
lw $10,0($4)
mla $8,$9,$10,$8
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
Παράδειγμα: Εκτέλεση ροής δεδομένων στην

αύξηση στοιχείων πίνακα
• Επιταχύνει την εκτέλεση η ροή δεδομένων; Πόσο;
• Ναί! 3 κύκλοι / επανάληψη βρόχου
• Εντολές ανά κύκλο (IPC) = 5/3 ≈ 1.6
(έναντι 1 για τέλεια διασωλήνωση)
• Ε: Ποια είναι η συμφόρηση απόδοσης (performance bottleneck);

• mla: Κάθε mla εξαρτάται από το προηγούμενο mla και διαρκεί 3 κύκλους
• Αυτό το πρόγραμμα είναι latency-bound
Εκτέλεση εντολών εκτός σειράς χρησιμοποιεί
ροή δεδομένων για αύξηση παραλληλισμού
• Ιδέα: Εκτέλεσε προγράμματα με σειρά ροής δεδομένων, αλλά δώσε την
ψευδαίσθηση της ακολουθιακής εκτέλεσης (sequential execution)
• Αυτό είναι ένα μοντέλο "περιορισμένης ροής δεδομένων"

• Περιορίζεται σε εντολές κοντά σε εκείνες που επικυρώνονται αυτήν τη στιγμή
• (Υπάρχουν επίσης επεξεργαστές αμιγώς ροής δεδομένων που εκθέτουν τη ροή
δεδομένων σε λογισμικό)
Μικροαρχιτεκτονική εκτέλεσης εκτός σειράς

(Out-of-order execution / OoO)
CPU
Instruction Buffer
Fetch Decode Commit

Execute
Εντός-σειράς Εκτός-σειράς Εντός-σειράς

(In-order) (Out-of-order) (In-order)
Το OoO κρύβεται πίσω από in-order frontend &
commit
CPU
Instruction Buffer
Fetch Decode Commit
B
A
C
Execute
• Οι εντολές εισέρχονται και αφήνουν τον instruction buffer με τη σειρά

προγράμματος
Παράδειγμα: Εκτέλεση εκτός σειράς στον

υπολογισμό πολυωνύμου
• Ε: Επιταχύνει την εκτέλεση η OoO; Πόσο;
• Ε: Ποιά είναι η συμφόρηση απόδοσης;
• Ας υποθέσουμε τέλεια προώθηση και πρόβλεψη διακλάδωσης

Παράδειγμα: Διάγραμμα χρονισμού διασωλήνωσης
στην εκτέλεση εκτός σειράς πολυωνύμου
ΧΡΟΝΟΣ
Fetch &
lw
Decode
Execute lw
Commit lw

ΧΡΟΝΟΣ
Fetch &
lw mla
Decode
Execute lw mla
Commit lw mla
ΧΡΟΝΟΣ
Fetch &
lw mla mul
Decode
Execute lw mla mul
Commit lw mla mul

ΧΡΟΝΟΣ
Fetch &
lw mla mul addi
Decode
Execute lw mla mul addi
Commit lw mla mul addi

ΧΡΟΝΟΣ
Fetch &
lw mla mul addi bne
Decode
Execute lw mla mul addi bne
Commit lw mla mul addi bne

ΧΡΟΝΟΣ
Fetch &
lw mla mul addi bne lw mla mul addi bne lw mla mul addi bne lw
Decode
Execute lw mla mul addi bne lw mla mul

ΧΡΟΝΟΣ
Fetch &
lw mla mul addi bne lw mla mul addi bne lw mla mul addi bne lw
Decode
Execute lw mla mul addi bne lw mla mul
• Παρατήρηση: Αυτό δεν είναι εκτέλεση εκτός σειράς… ή πιο γρήγορο

από μία απλή διασωλήνωση!
• Ε: Τι πήγε στραβά;
• Α: Περιοριζόμαστε από την ρυθμαπόδοση (throughput-limited):
μπορούμε να εκδώσουμε (issue) μόνο 1 εντολή
Μικροαρχιτεκτονική υπερβαθμωτής εκτέλεσης

εκτός σειράς (superscalar out-of-order)
• Πρέπει να αυξήσουμε το πλάτος διασωλήνωσης για να αυξήσουμε ILP > 1
CPU
Instruction Buffer
Fetch Decode Commit

Execute Execute Execute
Fetch Decode Commit
Εντός-σειράς Εκτός-σειράς Εντός-σειράς

(In-order) (Out-of-order) (In-order)
στην εκτέλεση-εκτός-σειράς πολυωνύμου
ΧΡΟΝΟΣ
lw $10,0($4)
lw
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla
addi $4,$4,4
bne $4,$5,$L2
lw $10,0($4)
mla $8,$9,$10,$8
Execute
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
Commit

ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw $10,0($4)
mla $8,$9,$10,$8
Execute
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
Commit
ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw
lw $10,0($4)
mla $8,$9,$10,$8
Execute
mul $9,$9,$6
addi $4,$4,4
bne $4,$5,$L2
Commit

ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw
lw $10,0($4)
mla $8,$9,$10,$8
Execute mul
mul $9,$9,$6
addi addi $4,$4,4
bne $4,$5,$L2
Commit
ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw mla
lw $10,0($4)
mla $8,$9,$10,$8
Execute mul
mul $9,$9,$6
addi bne addi $4,$4,4
bne $4,$5,$L2
Commit

ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw mla
lw $10,0($4)
mla $8,$9,$10,$8
Execute mul lw
mul $9,$9,$6
addi bne addi $4,$4,4
bne $4,$5,$L2
Commit
ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw mla mla
lw $10,0($4)
mla $8,$9,$10,$8
Execute mul lw addi bne
mul $9,$9,$6
addi bne mul addi $4,$4,4
bne $4,$5,$L2
Commit

ΧΡΟΝΟΣ
lw $10,0($4)
lw mul bne mla addi
Fetch & mla $8,$9,$10,$8
Decode mul $9,$9,$6
mla addi lw mul bne
addi $4,$4,4
bne $4,$5,$L2
lw mla mla
lw $10,0($4)
mla $8,$9,$10,$8
Execute mul lw addi bne
mul $9,$9,$6
addi bne mul addi $4,$4,4
bne $4,$5,$L2
lw mla addi lw mla addi
Commit
mul bne mul bne
ΧΡΟΝΟΣ
lw mul bne mla addi • Παρατηρήστε:

Fetch &
Decode
• Front-end και
mla addi lw mul bne commit εντός σειράς
(δηλ., αριστερα-
lw mla mla
προς-δεξιά)
Execute mul lw addi bne • Εκτέλεση εκτός
σειράς
addi bne mul
lw mla addi lw mla addi

Commit
mul bne mul bne

ΧΡΟΝΟΣ
lw mul bne mla addi lw mul bne mla addi lw mul bne mla addi lw
Fetch &
Decode
mla addi lw mul bne mla addi lw mul bne mla addi lw mul bne mla
lw mla mla mla mla mla
Execute mul lw addi bne mul lw addi bne mul
addi bne mul lw addi bne mul lw addi bne
lw mla addi lw mla addi lw mla addi lw mla

Commit
mul bne mul bne mul bne mul
One loop iteration / 3 cycles !

Δομικοί κίνδυνοι: Περιορίζουν ρυθμαπόδοση
• Οι μονάδες εκτέλεσης είναι εξειδικευμένες
• Floating-point (add/multiply)
• Integer (add/multiply/compare)
• Memory (load/store)
• Οι σχεδιαστές επεξεργαστών πρέπει να επιλέξουν ποιες μονάδες

εκτέλεσης θα συμπεριλάβουν και πόσες
• Δομικός κίνδυνος: Τα δεδομένα είναι έτοιμα, αλλά δεν μπορούν να

προβληθούν επειδή δεν υπάρχει διαθέσιμο υλικό
Παράδειγμα: Δομικοί κίνδυνοι μπορούν να

περιορίσουν σημαντικά την απόδοση
ΧΡΟΝΟΣ
lw mul bne mla addi lw mul bne mla addi lw mul bne mla addi lw
Fetch &
Decode
mla addi lw mul bne mla addi lw mul bne mla addi lw mul bne mla
Mem lw lw lw lw lw lw
Execute
Int addi bne addi bne addi bne addi bne addi bne addi
Execute
Mult mul mla mul mla mul mla
Execute
lw mla addi lw mla addi lw

Commit
mul bne mul bne
One loop iteration / 5 cycles L

Ο υπερβαθμωτός χρονοπρογραμματισμός είναι
πολύπλοκος και δύσκολο να κλιμακωθεί
• Ε: Πότε είναι ασφαλές να εκδώσετε δύο εντολές;
• Α: Όταν είναι ανεξάρτητες
• Πρέπει να συγκρίνετε όλα τα ζεύγη των καταχωρητών εισόδου και εξόδου
• Κλιμακωσιμότητα: 𝑂(𝑊2) συγκρίσεις όπου 𝑊 είναι το πλάτος έκδοσης

(issue width)
OoO x86: Microcoding

• Κάθε εντολή x86 περιγράφει διάφορες λειτουργίες
• E.g., add [esp+4], 5 σημαίνει:
1. Φόρτωσε Mem[esp+4]
2. Πρόσθεσε 5
3. Αποθήκευσε αποτέλεσμα στη θέση Mem[esp+4]
• Αυτό είναι πάρα πολύ για (γρήγορο) υλικό
• Αντ 'αυτού, το υλικό αποκωδικοποιεί εντολές σε μικροεντολές (micro-ops)

→ Το υπόλοιπο της διασωλήνωσης χρησιμοποιεί micro-ops
Θέματα που δεν συζητήσαμε...
• Πώς να εξαλείψετε τις ψευδείς εξαρτήσεις
• Π.χ., write-after-read / write-after-write
• Πώς να παρακολουθείτε τις εξαρτήσεις μέσω της μνήμης

• Π.χ., προώθηση store → load
• Πώς να επαναφέρετε λανθασμένες εικασίες (rollback mis-speculations)
Υπενθύμιση από την τελευταία φορά:

Η ILP σημείωσε επιβράδυνση… γιατί;
Περιορισμοί ILP
• Η ILP λειτουργεί υπέροχα! … Αλλά είναι πολύπλοκη + δύσκολη να κλιμακωθεί
• 4-wide superscalar × 20 σταδίων διασωλήνωση = 80 εντολές κατά την πτήση
• Επεξεργαστές OoO υψηλής απόδοσης φορτώνουν εκατοντάδες εντολές
• Οι διασωληνώσεις μπορούν να πάνε τόσο βαθιά

• Αυξάνεται η ποινή ανακριβείας πρόβλεψης διακλάδωσης
• Η συχνότητα (GHz) περιορίζεται από την ισχύ
• Τα προγράμματα έχουν περιορισμένο ILP
• Ακόμα και με τον τέλειο χρονοπρογραμματισμό, 8-wide issue δεν βοηθά
• Το κόστος (overhead) δυναμικού χρονοπρογραμματισμού είναι σημαντικό
• Χρονοπρογραμματισμός εκτέλεσης-εκτός-σειράς είναι ακριβός
Περιορισμοί ILP → Πολυπύρηνος (multicore)

• Η ILP λειτουργεί υπέροχα! … Αλλά είναι πολύπλοκη + δύσκολη να
κλιμακωθεί
• Από την άποψη του υλικού, ο πολυπύρηνος επεξεργαστής είναι πολύ
πιο αποτελεσματικός, αλλά…
• Το παράλληλο λογισμικό είναι δύσκολο!

• Η βιομηχανία αντιστάθηκε στον πολυπύρηνο για όσο το δυνατόν περισσότερο
• Όταν συνέβη τελικά ο πολυπύρηνος, η μικροαρχιτεκτονική CPU απλοποιήθηκε
→ περισσότερους πυρήνες
• Πολλά προγράμματα δυσκολεύονται να χρησιμοποιήσουν τον πολυπύρηνο
επεξεργαστή αποτελεσματικά

02 ILP Spring2021

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

02 ILP Spring2021

Uploaded by

Copyright:

Available Formats

Διάλεξη:

Σήμερα θα θυμηθούμε (από το ΕΠΛ221)…

• Οι επεξεργαστές πρέπει να κάνουν όλα αυτά διατηρώντας παράλληλα την

int poly(int *coef,

Παράδειγμα: Υπολογισμός πολυωνύμου

Παράδειγμα: Υπολογισμός πολυωνύμου

Παράδειγμα: Υπολογισμός πολυωνύμου

Παράδειγμα: Υπολογισμός πολυωνύμου

add $5,$4,$5 lw $10,0($4)

mla $8,$9,$10,$8 bne $4,$5,$L2

• Η μικροαρχιτεκτονική ενός επεξεργαστή είναι η υλοποίηση της ISA

• Αρχιτεκτονική: 𝜇Arch :: Διεπαφή: Υλοποίηση

Απλό μοντέλο CPU

• Χωρίζει την εκτέλεση εντολών σε στάδια, π.χ.

• (Οι πραγματικοί επεξεργαστές έχουν πολλά ακόμη στάδια)

Υπολογισμός πολυωνύμου στο

Υπολογισμός πολυωνύμου στο

Υπολογισμός πολυωνύμου στο

Υπολογισμός πολυωνύμου στο

Υπολογισμός πολυωνύμου στο

Fetch lw mla mul

Decode lw mla mul

Latency = 4 ns / instr Throughput = 1 instr / 4 ns

Απλός CPU είναι πολύ σπάταλος

Fetch lw mla mul

Decode lw mla mul

Η διασωλήνωση διατηρεί την CPU απασχολημένη

Η διασωλήνωση διατηρεί την CPU απασχολημένη

lw $10,0($4) mul mla lw

lw $10,0($4) addi mul mla lw

Η διασωλήνωση διατηρεί την CPU απασχολημένη

lw $10,0($4) bne addi mul mla

lw $10,0($4) lw bne addi mul

Fetch lw mla mul addi bne lw mla add mul addi

Decode lw mla mul addi bne lw mla add mul

Execute lw mla mul addi bne lw mla add …

Commit lw mla mul addi bne lw mla

Fetch lw mla mul addi bne lw mla add mul addi

Decode lw mla mul addi bne lw mla add mul

Execute lw mla mul addi bne lw mla add …

Commit lw mla mul addi bne lw mla

• Ε: Είναι ανεξάρτητες οι εντολές;

• Α: Όχι! Πολλοί πιθανοί κίνδυνοι περιορίζουν τον παραλληλισμό…

Fetch lw mul ... ... ... ... • Α: Όταν χρησιμοποιούν

Αντιμετώπιση κινδύνων δεδομένων:

Αντιμετώπιση κινδύνων δεδομένων:

lw $10,0($4) mul mla lw

lw $10,0($4) mul mla lw

Αντιμετώπιση κινδύνων δεδομένων:

lw $10,0($4) addi mul mla

Fetch lw mla mul mul addi bne lw mla mul addi

Decode lw mla mla mul addi bne lw mla mul

Execute lw mla mul addi bne lw …

Commit lw mla mul addi bne lw

• Αλλά μερικές φορές η στάση είναι αναπόφευκτη

Αντιμετώπιση κινδύνων δεδομένων:

• Η προώθηση εξαλείφει πολλές (όχι όλες) στάσεις διασωλήνωσης

• Ε: Πόσο καλά κλιμακώνει (scale) η προώθηση;

Κίνδυνοι ελέγχου + Speculation

• Οι περισσότερες εντολές συνεχίζουν σιωπηρά στην επόμενη…

Στατική ακολουθία εντολών

Αντιμετώπιση κινδύνων ελέγχου:

Στατική ακολουθία εντολών