Οργάνωση Και Σχεδίαση Υπολογιστών Μπέλλας Νικόλαος Πανεπιστήμιο Θεσσαλίας

Οργάνωση και Σχεδίαση Υπολογιστών
Νίκος Μπέλλας
Τμήμα Μηχανικών Η/Υ, Τηλεπικοινωνιών και Δικτύων
Πανεπιστήμιο Θεσσαλίας
Διάλεξη 1
Εισαγωγή στο μάθημα
• Βιβλίο:
– Patterson &Hennessy, Οργάνωση και Σχεδιασμός Υπολογιστών,
4η έκδοση, Εκδόσεις Κλειδάριθμος, Τόμοι Α & Β
– Κεφ. 1-5 και παραρτήματα
– Οι καλύτερη πηγή πληροφόρησης σε θέματα
Αρχιτεκτονικής είναι το Internet
Οργάνωση και Σχεδίαση Υπολογιστών 3
(HY232)
Περιεχόμενο μαθήματος (Curriculum)

• Γενική περιγραφή της οργάνωσης ενός Η/Υ
• Εισαγωγή στη συμβολική γλώσσα μηχανής (assembly)
– Συμβολικές εντολές και ορίσματα (ή τελούμενα) εντολών
– Καταχωρητές και διαχείριση μνήμης
• Αναπαράσταση αριθμητικών δεδομένων στον Η/Υ
– Προσημασμένοι και μη προσημασμένοι ακέραιοι αριθμοί
– Αναπαράσταση σταθερής και κινητής υποδιαστολής (fixed και
floating point)
• Σχεδίαση απλών και προχωρημένων αριθμητικών
μονάδων
– Αθροιστές, πολλαπλασιαστές, διαιρέτες
• Μετρικές απόδοσης ενός προγράμματος
• Γλώσσες περιγραφής υλικού - Verilog

(HY232)
• Αρχιτεκτονική επεξεργαστή ενός κύκλου
– Data Path and Control
• Αρχιτεκτονική επεξεργαστή με διοχέτευση
– Data hazards: bypassing and forwarding
– Control hazards: branch instructions
– Exceptions
– Παραδείγματα υλοποίησης ενός επεξεργαστή με την χρήση της
γλώσσας Verilog
• Ιεραρχία μνήμης
– Βασική λειτουργία κρυφών μνημών (cache memories)
– Μέτρηση και βελτίωση της απόδοσης της μνήμης cache
– Εικονική μνήμη (virtual memory)
• Εισαγωγή στον παραλληλισμό
– Παραλληλισμός εντολών και δεδομένων
• Παραδείγματα πραγματικών επεξεργαστών
– Γλώσσα μηχανής Intel x86
(HY232)

• Εργαστήριο Μαθήματος:
– Α μέρος: εργαστηριακές ασκήσεις προγραμματισμού στην
γλώσσα Assembly
– Β μέρος: εργαστηριακές ασκήσεις υλοποίησης του
επεξεργαστή MIPS σε Verilog
– Εβδομαδιαίες εργασίες (homeworks)
– Θα έχουμε περίπου 10 εργαστήρια
– Εξέταση εργαστηρίων κάθε Παρασκευή 11-7 μμ στο
εργαστήριο Α1

(HY232)
Εργαστηριακές Ασκήσεις
• Οι εργαστηριακές ασκήσεις
περιλαμβάνουν
• προγραμματισμό σε γλώσσα
μηχανής Assembly του
επεξεργαστή MIPS
• σταδιακή υλοποίηση σε Verilog
κομματιών ενός επεξεργαστή και
προσομοίωση
• Οι ασκήσεις θα γίνονται ατομικά

κατά την διάρκεια της εβδομάδας.
• Στο εργαστήριο θα γίνεται
προφορική εξέταση στις ασκήσεις
που έχετε ετοιμάσει.

(HY232)
Φιλοσοφία του μαθήματος (Ι)

• Σ1: Ένα από τα σημαντικότερα μαθήματα του τμήματος
• Το μάθημα θα τελειώσει στο τέλος του εξαμήνου; δεν θα
υπάρχουν εργαστήρια ή homeworks για τον Σεπτέμβριο
• Σ2: Διαβάζετε κατά την διάρκεια του εξαμήνου και όχι

μόνο πριν την πρόοδο ή το τελικό διαγώνισμα
• Ο καλύτερος τρόπος για να μάθετε σωστά και σε βάθος.
• Η πρόοδος και τα εργαστήρια αυτόν τον σκοπό έχουν
• Είναι αδύνατον να περάσετε το μάθημα με διάβασμα μόνο στο
τέλος
• Σ2: Διαβάζετε από το βιβλίο – Οι σημειώσεις είναι κυρίως

για γρήγορες επαναλήψεις
• Ίσως το κορυφαίο βιβλίο για Αρχιτεκτονική Η/Υ
• Σ3: Μην προσπαθείτε να απομνημονεύσετε την ύλη.

Σκεφτείτε το γιατί συμβαίνει κάτι και προσπαθήστε να
βρείτε εναλλακτικές λύσεις
(HY232)
Ας ξεκινήσουμε
Intel Ivy Bridge Processor
NVIDIA GPU

(HY232)
Απρόσημοι δυαδικοί ακέραιοι

(unsigned integers)
• O απρόσημοςδυαδικός αριθμός:
b  bn1bn2 ... b1b0 , bi {0,1}
έχει τιμή: b = bn1 2n1 + bn2 2n2 ++ b1 21 + b0 20
• Εύρος τιμών: 0 έως +2n – 1
• Παράδειγμα
• 0000 0000 0000 0000 0000 0000 0000 10112
= 0 + … + 1×23 + 0×22 +1×21 +1×20
= 0 + … + 8 + 0 + 2 + 1 = 1110
• Χρησιμοποιώντας 32 bits
• 0 έως +4,294,967,295
(HY232)
Προσημασμένοι ακέραιοι στη μορφή
Συμπλήρωμα του 2 (2s-Complement)
• Ένας προσημασμένος δυαδικός αριθμός:
b  bn1bn2 ... b1b0 , bi {0,1}
έχει τιμή: b = bn1 2n1 + bn2 2n2 + + b1 21 + b0 20
 Εύρος: –2n – 1 έως +2n – 1 – 1

 Παράδειγμα
 1111 1111 1111 1111 1111 1111 1111 11002
= –1×231 + 1×230 + … + 1×22 +0×21 +0×20
= –2,147,483,648 + 2,147,483,644 = –410
 Χρησιμοποιώντας 32 bits
 –2,147,483,648 to +2,147,483,647
(HY232)
Προσημασμένοι ακέραιοι στη μορφή

Συμπλήρωμα του 2 (2s-Complement)
Προσημασμένοι αριθμοί
• Το πιό σημαντικό bit (most των 4-bits
significant bit) είναι το πρόσημο Προσημασ. Δυαδικοί
Δεκαδικοί
ενός αριθμού:
-8 1000
– 1 για αρνητικούς αριθμούς -7 1001
– 0 για μη αρνητικούς αριθμούς -6 …
• Ερώτηση: -5 1011
– Ποια η δεκαδική τιμή του 10112? … …
• Απάντηση: -1
0
1111
0000
– Χρειαζόμαστε και επιπλέον 1 0001
πληροφορία σχετικά με το εάν ο
… …
αριθμός είναι προσημασμένος
5 0101
– 1110 (απρόσημος)
6 0110
– -510 (προσημασμένος)
Οργάνωση και Σχεδίαση Υπολογιστών
(HY232)
7 0111
19
Υπολογισμός αντιθέτου
• Αντιστρέψτε και προσθέστε 1
– Αντιστροφή σημαίνει 1 → 0, 0 → 1
x + x = 1111...1112 = 1
x +1 =  x
 Παράδειγμα: το αντίθετο του +2
 +2 = 0000 0000 … 00102
 –2 = 1111 1111 … 11012 + 1
= 1111 1111 … 11102

(HY232)
Μετατροπή Ακεραίου Δεκαδικού σε Δυαδικό

• Είδαμε πώς μετατρέπουμε έναν ακέραιο δυαδικό σε δεκαδικό
αριθμό
b = bn1 2n1 + bn2 2n2 + + b1 21 + b0 20
 Πως μετατρέπουμε έναν ακέραιο δεκαδικό b σε δυαδικό
αριθμό bn1bn2 ... b1b0 , bi {0,1}
Απάντηση:
 Με διαδοχικές ακέραιες διαιρέσεις του τρέχοντος υπολοίπου
με το 2, κρατώντας το υπόλοιπο
 Ποιός είναι ο δυαδικός αντίστοιχος του 55;
 55/2 = 27, Υπόλοιπο = 1
 27/2 = 13, Υπόλοιπο = 1
 13/2 = 6, Υπόλοιπο = 1
 6/2 = 3, Υπόλοιπο = 0
 3/2 = 1, Υπόλοιπο = 1
 1 /2 = 0, Υπόλοιπο = 1
21
 (55)10 = (110111)2Οργάνωση και (HY232)
Σχεδίαση Υπολογιστών
Μετατροπή Κλασματικού Δυαδικού σε Δεκαδικό
 Πως μετατρέπουμε έναν κλασματικό δυαδικό
bn1bn2 ... b1b0 ,b1b2 ... bm , bi {0,1}
στον αντίστοιχο κλασματικό δεκαδικό b
Απάντηση:
b = bn1 2n1 + bn2 2n2 ++ b1 21 + b0 20 b1 2-1 + b2 2-2 ++ bm 2 m
 Ποιός είναι ο δεκαδικός αντίστοιχος του 1001,011 ;
1000,011= 23 2-2 + 2-3  8,375

(HY232)
Μετατροπή Κλασματικού Δεκαδικού σε

Δυαδικού
 Πως μετατρέπουμε έναν κλασματικό δεκαδικό b
στον αντίστοιχο κλασματικό δυαδικό
bn1bn2 ... b1b0 .b1b2 ... bm , bi {0,1}
Απάντηση:
• Το ακέραιο τμήμα του b, ξεχωριστά όπως έχουμε ήδη δείξει
• Το κλασματικό μέρος του b, με διαδοχικούς πολλ/σμούς με το 2,
κρατώντας κάθε φορά το πιο σημαντικό ψηφίο (0 ή 1)
 Ποιά είναι η δυαδική αναπαράσταση του 23,634 ;
 (23)10 = (10111)2
 (0,634)10 = ?
0,634 * 2 = 1,268
0,268 * 2 = 0,536
0,536 * 2 = 1,072 23,634  10111,1010...
0,072 * 2 = 0, 144
κοκ. Οργάνωση και Σχεδίαση Υπολογιστών 23
(HY232)
Μετατροπή Κλασματικού Δεκαδικού σε
Δυαδικού
 Τι γίνεται σε περίπτωση αρνητικού κλασματικού αριθμού b ;
Απάντηση:
• Όπως και πρίν, ξεχωρίζουμε το ακέραιο τμήμα του b, από το κλασματικό
 Ποιά είναι η δυαδική αναπαράσταση του (-23,634)10 με ακρίβεια 4
κλασματικών ψηφίων;
 Βρίσκουμε πρώτα την δυαδική αναπαράσταση του (23,634)10
 (23)10 = (010111)2
 (0,634) 10 = (0,1010…)2
 (23,634)10 = (010111,1010)2
 (-23,634)10 = (101000,0110)2
 Συνεπώς, στην μετατροπή από αρνητικό σε θετικό, θεωρούμε όλον τον
αριθμό (ακέραιο και κλασματικό τμήμα)

(HY232)
Θεμελιώδεις Αρχές των Μοντέρνων Υπολογιστών

• Οι εντολές (instructions) καθώς και
τα δεδομένα (data) κάθε τύπου Memory
(integer, float, char, κοκ)
αναπαριστούνται στην μνήμη σαν Accounting prg
αριθμοί . (machine code)
C compiler
– Υπολογιστές αποθηκευμένου (machine code)
προγράμματος (stored program
computer)
Payroll
• Αυτό σημαίνει ότι τα προγράμματα data
μπορούν να αποθηκευθούν και να
μεταφερθούν σε αρχεία (files) Source code in
C for Acct prg
• Είτε σε μορφή πηγαίου κώδικα (source
code) είτε σε μορφή δυαδικού κώδικα
(binary code)
(HY232)
Θεμελιώδεις Αρχές των Μοντέρνων Υπολογιστών
• Αρχή της σειριακής εκτέλεσης εντολών
• Στην κανονική ροή του προγράμματος οι εντολές
εκτελούνται η μία μετά την άλλη
• Χρήση ενός ειδικού καταχωρητή (32-bits ή 64-bit)
ως μετρητή προγράμματος (Program Counter ή PC),
ο οποίος διατηρεί τη διεύθυνση της τρέχουσας
εντολής στη μνήμη
• Έλεγχος ροής προγράμματος με άλματα και
διακλαδώσεις (σε άλλες διευθύνσεις)

(HY232)
Διάλεξη 2
Οργάνωση μνήμης
Καταχωρητές του MIPS
Εντολές του MIPS 1
Σύνολο Εντολών
• Το ρεπερτόριο των εντολών ενός υπολογιστή
• Διαφορετικοί υπολογιστές έχουν διαφορετικά
σύνολα εντολών
– Αλλά με πολλά κοινά χαρακτηριστικά
• Οι πρώτοι υπολογιστές είχαν πολύ απλά σύνολα
εντολών
– Απλοποιημένη υλοποίηση
• Πολλοί μοντέρνοι υπολογιστές έχουν επίσης απλά
σύνολα εντολών
• Ο σχεδιασμός ενός επιτυχημένου συνόλου εντολών
για έναν επεξεργαστή είναι η σημαντικότερη
δουλειά ενός αρχιτέκτονα υπολογιστών (Computer
Architect)
Οργάνωση και Σχεδίαση Υπoλογιστών 2
(HY232)
Είδη εντολών και τελούμενων (operands)
• Οι μονάδες του υλικού στις οποίες δρούν οι

εντολές τις assembly (δηλ. αποτελούν τα
τελούμενά τους) είναι οι καταχωρητές
(registers) και οι θέσεις μνήμης
– Καταχωρητές: χώρος προσωρινής αποθήκευσης
δεδομένων προς επεξεργασία
– Μνήμη: κύριος χώρος αποθήκευσης των
δεδομένων
– Οι Καταχωρητές και η Κύρια Μνήμη είναι δύο
διαφορετικά πράγματα
(HY232)
Το Σύνολο Εντολών του MIPS
• Ο MIPS χρησιμοποιείται ως παράδειγμα σε όλο το
βιβλίο
• Μεγάλο μέρος της αγοράς ενσωματωμένων
συστημάτων.
– Εφαρμογές σε ηλεκτρονικές συσκευές, εξοπλισμό
δικτύων/αποθήκευσης, φωτογραφικές μηχανές,
εκτυπωτές, ...
• Τυπικό παράδειγμα πολλών μοντέρνων συνόλων
εντολών

(HY232)
Καταχωρητές του MIPS

• 32 καταχωρητές των 32-bits ο καθένας
• 32-bits αποτελούν μια λέξη (word) του Η/Υ
• Ονόματα καταχωρητών: $0 , $1 , … , $31
• Συμβολικά ονόματα καταχωρητών:
$0 $2-$3 $4-$7 $8-$15 $16-$23 $24-$25 $28 $29 $30 $31
$zero $v0-$v1 $a0-$a3 $t0-$t7 $s0-$s7 $t8-$t9 $gp $sp $fp $ra
• Οι καταχωρητές $1 (συμβολικό $at) και $26-$27

(συμβολικά $k0-$k1) δεν είναι προσβάσιμοι στον
προγραμματιστή, ενώ κάποιοι άλλοι επιτελούν ειδικές
λειτουργίες
• Ο καταχωρητής $0 (ή $zero) έχει πάντοτε την τιμή 0

(HY232)
• Η μνήμη είναι οργανωμένη σε bytes
• Διευθυνσιοδότηση μνήμης για κάθε byte ξεχωριστά (byte
addressing)
=> οι λέξεις (32-bits ή 4 bytes) στη μνήμη έχουν
διευθύνσεις που διαφέρουν ανά 4 μεταξύ τους
8-bits 32-bits
0 0
1 4
2 8
...
...
232-1 230-1
• 32-bits διευθύνσεων => 232 bytes ή 230 λέξεις συνολικά

(HY232)
• Η τοποθέτηση των λέξεων στη μνήμη πρέπει να
γίνεται με ευθυγραμμισμένο τρόπο (alignment),
δηλ. η διεύθυνση του πρώτου byte να είναι
πολλαπλάσιo του 4
0 1 2 3
Aligned
Not
Aligned

(HY232)
• Υπάρχουν δύο τρόποι διάταξης των bytes σε μια λέξη της μνήμης
• Το πρότυπο του MIPS ακολουθεί τη διάταξη big endian (αντίθετα με τον
Intel 80x86)
31 24 7 0
0 Οργάνωση 0
23 16 μνήμης 15 8
1 1
15 8 23 16
2 2
7 0 31 24
3 3
big endian
little endian
31 24 23 16 15 8 7 0
καταχωρητής
8
Οργάνωση και Σχεδίαση Υπoλογιστών
(HY232)
0 ΑΑ 0 AA
1 ΒΒ 1 BB
2 CC Οργάνωση 2 CC
μνήμης
3 DD 3 DD
31 24 23 16 15 8 7 0
AA BB CC DD
big endian 31 24 23 16 15 8 7 0
DD CC BB AA
little endian
9
Οργάνωση και Σχεδίαση Υπoλογιστών
(HY232)
Επέκταση προσήμου
• Αναπαράσταση αριθμού με περισσότερα bits
– Διατηρώντας την αριθμητική τιμή του
• Αντιγράψτε το πρόσημο αριστερά
– π.χ. απρόσημες τιμές: επεκτείνονται με μηδενικά
• Παραδείγματα: 8-bit σε 16-bit
– +2: 0000 0010 => 0000 0000 0000 0010
– –2: 1111 1110 => 1111 1111 1111 1110

(HY232)
Μοντέλο μηχανής MIPS

Καταχωρητές
•Είδη εντολών στον MIPS:
–Εντολές πράξεων (ακεραίων ή κινητής
υποδιαστολής) R0 - R31
–Εντολές μεταφοράς δεδομένων (από και
προς την μνήμη)
–Εντολές διακλάδωσης (με ή χωρίς συνθήκη)
PC
–Ειδικές εντολές HI
LO
3 μορφές εντολών του MIPS: όλες 32 bits

op rs rt rd sa funct Μορφή R
op rs rt immediate Μορφή Ι
op jump target Μορφή J
(HY232)
Αναπαράσταση Εντολών
• Οι εντολές αναπαριστούνται στο δυαδικό σύστημα
– Το αποτέλεσμα λέγεται κώδικας μηχανής
• Εντολές MIPS
– Κωδικοποιούνται ως λέξεις (32-bits)
– Υπάρχει μικρός αριθμός από μορφές (formats) που
κωδικοποιούν κώδικες λειτουργίας (opcodes), αριθμούς
καταχωρητών,…

(HY232)
Εντολές πράξεων στον MIPS

• Όλες οι εντολές πράξεων γίνονται αποκλειστικά
μεταξύ καταχωρητών
=> για επεξεργασία θέσεων μνήμης θα πρέπει πρώτα τα
δεδομένα να μεταφερθούν σε κατάλληλους καταχωρητές
• Στις εντολές πράξεων χρησιμοποιούνται

συνήθως οι καταχωρητές $s0-$s7 για τελικά
αποτελέσματα (τα οποία φυλάσσονται ως
μεταβλητές), και οι καταχωρητές $t0-$t9 για
ενδιάμεσα (προσωρινά) αποτελέσματα

(HY232)
Παράδειγμα
• Κώδικας C:
f = (g + h) - (i + j);
– Οι f, g, h, i, j είναι στους $s0, $s1, $s2, $s3, $s4
• Μεταγλωτισμένος κώδικας MIPS:
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1
destination  source1 op source2

• Η επιλογή των καταχωρητών γίνεται είτε από τον
προγραμματιστή σε assembly είτε από τον μεταφραστή
γλώσσας ανωτέρου επιπέδου
(HY232)

• Οι εντολές πράξεων καλύπτουν όλους τους διαφορετικούς
αριθμητικούς τελεστές (arithmetic operators) μιάς γλώσσας
προγραμματισμού
– Όχι πάντα 1-1 αντιστοίχιση
• Παράδειγμα:
C MIPS assembly
+ add, addu, addi,
addiu
- sub, subu
* mult, multu
/ div, divu
<< sll, sllv
& and, andi
| or, ori
(HY232)
Εντολές μεταφοράς
• Αναφέρονται ως εντολές φόρτωσης (load) καταχωρητή και
αποθήκευσης (store) καταχωρητή:
lw $s0,100($s1)  $s0 = Mem[$s1+100]
sw $s0,100($s1)  Mem[$s1+100] = $s0
• Αποτελούν τον μοναδικό τρόπο πρόσβασης στη μνήμη στον MIPS
• Η διεύθυνση πρόσβασης σχηματίζεται από το άθροισμα μιας διεύθυνσης
βάσης που περιέχεται σε έναν καταχωρητή βάσης (base register), και μιας
16-bit σταθεράς μετατόπισης (offset) που δίνεται άμεσα ως όρισμα της
εντολής
...
base register + data
register
...
offset
(HY232)
Εντολές μεταφοράς
• Παράδειγμα προσπέλασης σύνθετης δομής.
Εάν έχουμε έναν integer πίνακα Α (int A[100]) του
οποίου η διεύθυνση βάσης (δηλ. η διεύθυνση του
πρώτου στοιχείου) βρίσκεται στον καταχωρητή
βάσης $s1, τότε η εντολή:
lw $s0,32($s1)
φορτώνει το όγδοο στοιχείο του πίνακα στον
καταχωρητή $s0, ενώ η εντολή:
sw $s0,48($s1)
αποθηκεύει το εν λόγω στοιχείο - από τον $s0 - στη
θέση του δωδέκατου στοιχείου (δηλ. Α[12] = Α[8])
(HY232)
$s3 = &A[0]
Α[0] Α[1] Α[2] Α[3] Α[4] Α[5] Α[6] Α[7] Α[8] Α[9] ….
Απόσταση (Offset)
g = h + A[8];
– Το g είναι στον $s1, το h στον $s2, και η διεύθυνση
(βάση) του A στον $s3
• Μεταγλωττισμένος κώδικας MIPS:
– Η θέση 8 βρίσκεται 32 bytes μετά την αρχή του Α
• 4 bytes ανά λέξη
lw $t0, 32($s3) # load word
add $s1, $s2, Οργάνωση
$t0 και Σχεδίαση Υπoλογιστών
(HY232) 18
Τελεστέοι μνήμης (Memory Operands)

• Η μνήμη χρησιμοποιείται για σύνθετα δεδομένα
– Πίνακες, δομές, δυναμικά δεδομένα
• Για να εφαρμόσετε αριθμητικές πράξεις
– Φορτώστε (load) τις τιμές από τη μνήμη σε καταχωρητές.
– Αποθηκεύστε (store) το αποτέλεσμα από τον καταχωρητή
στη μνήμη.
• Η μνήμη είναι οργανωμένη σε bytes
– Κάθε διεύθυνση προσδιορίζει ένα byte (8 bits)
• Οι λέξεις είναι ευθυγραμμισμένες στη μνήμη.
– Κάθε διεύθυνση πρέπει να είναι πολ/σιο του 4.
• O MIPS είναι Big Endian
– Το πιο σημαντικό byte (most-significant byte) βρίσκεται
στη μικρότερη διεύθυνση
(HY232)
Διάλεξη 3
Εντολές του MIPS (2)
Παράδειγμα (συνέχεια από προηγ. διάλεξη)

&A[8] = 0x00010A0
$s3 = &A[0] = 0x0001080
Α[0] Α[1] Α[2] Α[3] Α[4] Α[5] Α[6] Α[7] Α[8] Α[9] ….
• Κώδικας C: Απόσταση (Offset)

g = h + A[8];
– Το g είναι στον $s1, το h στον $s2, και η διεύθυνση (βάση)
του A στον $s3
– Η θέση 8 βρίσκεται 32 bytes μετά την αρχή του Α
• 4 bytes ανά λέξη
lw $t0, 32($s3) # load word
add $s1, $s2, $t0

(HY232)
Δεκαεξαεδικό (hex)
• Βάση 16
– Περιεκτική αναπαράσταση
– 4 bits για κάθε hex ψηφίο
0 0000 4 0100 8 1000 c 1100
1 0001 5 0101 9 1001 d 1101
2 0010 6 0110 a 1010 e 1110
3 0011 7 0111 b 1011 f 1111
 Παράδειγμα: eca8 6420

 1110 1100 1010 1000 0110 0100 0010 0000
Οργάνωση και Σχεδίαση 3
Υπoλογιστών (HY232)
Εντολές για Bytes/Halfwords

• MIPS byte/halfword load/store
– Συνήθως για διαχείριση συμβολοσειρών (strings)
lb rt, offset(rs) ; Επέκταση προσήμου σε 32 bits στον rt
lh rt, offset(rs)
lbu rt, offset(rs) ; Επέκταση 0 σε 32 bits στον rt

lhu rt, offset(rs)
sb rt, offset(rs) ;Αποθηκεύει το δεξιότερο byte/halfword

sh rt, offset(rs)

(HY232)
Παραδείγματα εντολών μεταφοράς δεδομένων
Ας θεωρήσουμε τις παρακάτω θέσεις μνήμης και τα περιεχόμενα τους
ADDRESS DATA
0x100080A2 0x21
0x100080A3 0x00
Έστω ότι αρχικά: …
0x10008104 0x01
$s0 = 0xAF109043
$s1 = 0x10008100 0x10008105 0x11
0x10008106 0x33
Επίσης ο MIPS είναι 0x10008107 0x80
Little endian.
Εκτελείται η εντολή:
Εκτελείται η εντολή: lw $s0, 5($s1)
lw $s0, 4($s1) ΛΑΘΟΣ (run-time error)
Πρόσβαση σε μη ευθυγραμμισμένη διεύθυνση (μη
Ποια ή νέα τιμή του $s0? πολλαπλάσια του 4).
•Διεύθυνση Πρόσβασης : $s1 + (4)10 =

0x10008104
•Φορτώνουμε 4 bytes ξεκινώντας από την
διεύθυνση 0x10008104
• Τελικά $s0 = 0x80331101
(HY232)
Παραδείγματα εντολών μεταφοράς δεδομένων

Ας θεωρήσουμε τις παρακάτω θέσεις μνήμης και τα περιεχόμενα τους
ADDRESS DATA
0x100080A2 0x21
0x100080A3 0x00
Έστω ότι αρχικά: …
0x10008104 0x01
$s0 = 0xAF109043
$s1 = 0x10008100 0x10008105 0x11
0x10008106 0x33
Επίσης ο MIPS είναι 0x10008107 0x80
Big endian.
Εκτελείται η εντολή:
lb $s0, 7($s1)
Ποια ή νέα τιμή του $s0?
•Διεύθυνση Πρόσβασης : $s1 + (7)10 =

0x10008107
•Φορτώνουμε 1 byte από την διεύθυνση 0x10008107. Πάντα στο Least
Significant Byte του καταχωρητή.
• Κάνουμε επέκταση προσήμου για να γεμίσουμε (fill) τα 3 MSB του $s1
• Τελικά $s0 = 0xFFFFFF80
(HY232)
Προχωρημένες Εντολές Φόρτωσης Δεδομένων
(lwl, lwr) ADDRESS DATA
0 0x01
1 0x02
Έστω ότι αρχικά: 2 0x03
3 0x04
$t0 = 0 4 0xAA
$t1 = 0xFFFFFF 5 0xBB
6 0xCC
O MIPS είναι Little Endian 7 0xDD
$t1: 0xFF 0xFF 0xFF 0xFF $t1: 0xFF 0xFF 0xFF 0xFF
lwl $t1, 1($t0) # Load Word Left lwr $t1, 6($t0) # Load Word Right
$t1: 0x02 0x01 0xFF 0xFF $t1: 0xFF 0xFF 0xDD 0xCC
• lwl και lwr είναι πραγματικές εντολές

• Τα bytes του καταχωρητή που δεν τα πειράζουμε, παραμένουν τα ίδια
• H διεύθυνση δεν χρειάζεται να είναι πολλ/σιο του 4
(HY232)
MIPS Εντολές μορφής R

op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
• Πεδία εντολής
– op: opcode (κώδικας λειτουργίας)
– rs: τελεστέος προέλευσης 1ου καταχωρητή
– rt: τελεστέος προέλευσης 2ου καταχωρητή
– rd: τελεστέος καταχωρητή προορισμού
– shamt: ποσότητα ολίσθησης (shift amount) (00000 για
τώρα)
– funct: κωδικός συνάρτησης (function code)

(HY232)
Παράδειγμα μορφής R
add $t0, $s1, $s2

op $s1 $s2 $t0 0 add
0 17 18 8 0 32
000000 10001 10010 01000 00000 100000
000000100011001001000000001000002 = 0232402016

(HY232)
MIPS Εντολές μορφής I

op rs rt σταθερά ή διεύθυνση
6 bits 5 bits 5 bits 16 bits
• Άμεσες αριθμητικές εντολές ή εντολές μεταφοράς

δεδομένων
– rt: τελεστέος καταχωρητή προέλευσης ή προορισμού
– Σταθερά: –215 έως +215 – 1
– Διεύθυνση: προστίθεται απόσταση (offset) στη διεύθυνση
βάσης που βρίσκεται στο rs

(HY232)
Πεδία του MIPS
• Σχεδιαστική Αρχή : Η καλή σχεδίαση απαιτεί καλούς
συμβιβασμούς
– Η ύπαρξη διαφορετικών μορφών περιπλέκει την
αποκωδικοποίηση αλλα επιτρέπει ομοιομορφία στο μήκος
των εντολών.

(HY232)
Λογικές πράξεις
• Εντολές για χειρισμό ακεραίων σε επίπεδο bit
Operation C Java MIPS

Shift left << << sll
Shift right >> >>> srl
Bitwise AND & & and, andi
Bitwise OR | | or, ori
Bitwise NOT ~ ~ nor
 Χρήσιμες για εξαγωγή ή εισαγωγή

ομάδων από bits σε μια λέξη.
(HY232)
Πράξεις ολίσθησης (shift)
• shamt: ποσότητα (θέσεις) ολίσθησης

• Αριστερή ολίσθηση
– Μεταφορά αριστερά και γέμισμα κενών με 0
– sll κατά i bits πολλαπλασιάζει με 2i
• Δεξιά ολίσθηση
– Μεταφορά δεξιά και γέμισμα κενών με πρόσημο
(sra)
– srl κατά i bits διαιρεί με 2i (μόνο απρόσημα)
(HY232)
Πράξη AND
• Χρήσιμη ως μάσκα ("καλύπτει" κάποια bits
στη λέξη)
– Επέλεξε κάποια bits, κάνε τα υπόλοιπα 0
and $t0, $t1, $t2
$t2 0000 0000 0000 0000 0000 1101 1100 0000
$t1 0000 0000 0000 0000 0011 1100 0000 0000
$t0 0000 0000 0000 0000 0000 1100 0000 0000

(HY232)
Πράξη OR
• Χρήσιμη για να συμπεριλάβει κάποια bits σε
μια λέξη
– Κάνε κάποια bits 1, άσε τα υπόλοιπα ως έχουν
or $t0, $t1, $t2
$t2 0000 0000 0000 0000 0000 1101 1100 0000
$t1 0000 0000 0000 0000 0011 1100 0000 0000
$t0 0000 0000 0000 0000 0011 1101 1100 0000

(HY232)
Άμεσοι Τελεστέοι
• Σταθερά δεδομένα που εμφανίζονται σε μια εντολή
addi $s3, $s3, 4
• Δεν υπάρχει εντολή για άμεση αφαίρεση
– Απλά χρησιμοποιείστε μια αρνητική σταθερά.
addi $s2, $s1, -1
• Ο καταχωρητής $0 του MIPS ($zero) είναι η σταθερά
0
– Η τιμή του καταχωρητή αυτού δε μπορεί να
διαγραφεί/μεταβληθεί
• Χρήσιμος για πολλές πράξεις
– π.χ., μετακίνηση δεδομένων σε άλλο καταχωρητή
add $t2, $s1, $zero
Οργάνωση και Σχεδίαση
Υπoλογιστών (HY232) 16
Σχεδιαστική Αρχή
• Κάντε τη συνηθισμένη περίπτωση γρήγορη.
– Μικρές σταθερές είναι συνήθεις
– Με τη χρήση άμεσων τελεστέων αποφεύγουμε τη
χρήση μιας επιπλέον εντολής load.

(HY232)
Σταθερές των 32-bit

• Οι περισσότερες σταθερές είναι μικρές
– Άμεσοι τελεστέοι των 16-bit επαρκούν
• Για σταθερές των 32-bit:
lui rt, constant (Load Upper Immediate)
– Αντιγράφει τα ανώτερα 16 bits της σταθεράς constant στα
αριστερά 16 bits του rt
– Κάνει 0 τα άλλα 16 bits του rt και μετά μπορούμε να
προσθέσουμε στο rt τα υπόλοιπα 16 bits του constant.
;store the 32-bit constant 0xAABBCCDD to $s0
addi $s0, $0, $0 ; $s0 = 0;

lui $s0, 0xAABB ; $s0 = 0xAABB0000
ori $s0, $s0,0xCCDD ; $s0 = 0xAABBCCDD
(HY232)
Εντολές διακλάδωσης (Ι)
• Μετάβαση σε άλλη εντολή αν η συνθήκη είναι
αληθής
– Διαφορετικά, το πρόγραμμα συνεχίζει στην
επόμενη εντολή
• beq rs, rt, L1
– αν (rs == rt) πήγαινε στην εντολή με ετικέτα L1;
• bne rs, rt, L1
– αν (rs != rt) πήγαινε στην εντολή με ετικέτα L1
• j L1
– διακλάδωση χωρίς συνθήκη πήγαινε στην εντολή
με ετικέτα L1
(HY232)
Μεταγλώττιση εντολών if
• κώδικας C :
if (i==j) f = g+h;
else f = g-h;
– f, g,h… στους $s0, $s1, …
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit: …
Ο assembler (συμβολομεταφραστής)
υπολογίζει τις διευθύνσεις
(HY232)
Μεταγλώττιση βρόχων
int save[100];
while (save[i] == k) i++;

– i στον $s3, k στον $s5, διεύθυνση του save στον
$s6
Loop: sll $t1, $s3, 2 # $t1=4*i
add $t1, $t1, $s6 # $t1=&save[i]
lw $t0, 0($t1) # $t0=save[i]
bne $t0, $s5, Exit
addi $s3, $s3, 1
j Loop
Exit: … Οργάνωση και Σχεδίαση Υπoλογιστών
(HY232) 21
Εντολές διακλάδωσης (2)

• Θέσε το αποτέλεσμα σε 1 αν μια συνθήκη
είναι αληθής, αλλιώς θέσε το σε 0
• slt rd, rs, rt
– if (rs < rt) rd = 1; else rd = 0;
• slti rt, rs, constant
– if (rs < constant) rt = 1; else rt = 0;
• Σε συνδυασμό με τις beq, bne
slt $t0, $s1, $s2 # if ($s1 < $s2) $t0=1
bne $t0, $zero, L # branch to L
• Αντίστοιχη ψευδο-εντολή
blt $s1, $s2, L
(HY232)
Σχεδίαση εντολών διακλάδωσης
• Γιατί δεν υπάρχουν οι πραγματικές εντολές
blt, bge, κτλ?
• Ο υπολογισμός του <, ≥, … είναι πιο αργός
από τον υπολογισμό του =, ≠
– Ο συνδυασμός σύγκρισης με διακλάδωση χρειάζεται
περισσότερη δουλειά ανά εντολή και απαιτεί πιο αργό
ρολόι.
– Αυτό καθυστερεί όλες τις εντολές!
• beq και bne είναι οι πιο συνήθεις εντολές
• Αυτό είναι παράδειγμα συμβιβασμού (trade-
off) Οργάνωση και Σχεδίαση Υπoλογιστών 23
(HY232)
Ψευδοεντολές
• Οι περισσότερες εντολές του συμβολο-
μεταφραστή έχουν μία προς μία αντιστοιχία με
εντολές της γλώσσας μηχανής.
• Ψευδοεντολές: δεν είναι μέρος του συνόλου
εντολών (ISA)
move $t0, $t1 → add $t0, $zero, $t1
blt $t0, $t1, L → slt $at, $t0, $t1
bne $at, $zero, L
– $at ($1): δεν μπορεί να χρησιμοποιηθεί από τον
χρήστη, παρά μόνο από τον συμβολομεταφραστή
(HY232)
Προσημασμένο / Απρόσημο
• Προσημασμένη σύγκριση: slt, slti
• Απρόσημη σύγκριση: sltu, sltui
– $s0 = 1111 1111 1111 1111 1111 1111 1111 1111
– $s1 = 0000 0000 0000 0000 0000 0000 0000 0001
– slt $t0, $s0, $s1 # signed
• –1 < +1  $t0 = 1
– sltu $t0, $s0, $s1 # unsigned
• +4,294,967,295 > +1  $t0 = 0

(HY232)
Διευθυνσιοδότηση διακλαδώσεων
• Οι εντολές διακλαδώσεων προσδιορίζουν:
– Opcode, δύο καταχωρητές, διεύθυνση προορισμού
– Μορφή-Ι
• Ο προορισμός είναι συνήθως κοντά
– Είτε πιο μπροστά είτε πιο πίσω
– Η address δείχνει αριθμό 32-bit words , και όχι bytes
op rs rt constant or address
6 bits 5 bits 5 bits 16 bits
 Διευθυνσιοδότηση σχετική ως προς PC

 Διεύθυνση προορισμού = (PC+4) + constant× 4
 PC είναι η διεύθυνση της εντολής διακλάδωσης
(HY232)
Διευθυνσιοδότηση αλμάτων
• Ο προορισμός ενός άλματος (j ή jal) μπορεί
να είναι οπουδήποτε στο κείμενο
– Χρειάζεται ολόκληρη η διεύθυνση στην εντολή
– Μορφή-J
op address
6 bits 26 bits
• (Ψευδο)απευθείας διευθυνσιοδότηση άλματος

• Διεύθυνση προορισμού = {PC31…28 , address × 4}

(HY232)
• Το Loop αρχίζει στη διεύθυνση 0x80000
Loop: sll $t1, $s3, 2 80000 0 0 19 9 2 0

add $t1, $t1, $s6 80004 0 9 22 9 0 32
lw $t0, 0($t1) 80008 35 9 8 0
bne $t0, $s5, Exit 8000C 5 8 21 2
addi $s3, $s3, 1 80010 8 19 19 1
j Loop 80014 2 20000
Exit: … 80018

(HY232)
Μακρινές διακλαδώσεις
• Αν ο προορισμός μια διακλάδωσης είναι τόσο
μακρυά ώστε 16 bit δεν είναι αρκετά για την
απόσταση, τότε ο assembler μεταβάλει τον
κώδικα
• Παράδειγμα
# L1 more than 215-1 words away
beq $s0,$s1, L1
↓
bne $s0,$s1, L2
j L1
L2: …
(HY232)
Διάλεξη 4
Συναρτήσεις-Διαδικασίες
Διαδικασίες (procedures)
Γνωστές και σαν υπορουτίνες (subroutines)
• Τι πρέπει να προσέξουμε στις διαδικασίες (ή

συναρτήσεις)
1. Η εμβέλεια των μεταβλητών που ορίζονται μέσα στις διαδικασίες
(automatic variables) περιορίζεται στο σώμα των διαδικασιών αυτών
2. Οι μεταβλητές αυτές (automatic variables), “κρύβουν” τον ορισμό των
καθολικών μεταβλητών (global variables) με τις οποίες έχουν το ίδιο
όνομα.
int x; Καθολική μεταβλητή: δεν μπορεί όμως

να προσπελασθεί μέσα στην func() επειδή
έχει το όνομα x.
void func(int a) {
int x; Παράμετρος διαδικασίας
int y;
…. Αυτόματες μεταβλητές: έγκυρες μόνο μέσα στην func()
} Οργάνωση και Σχεδίαση Υπολογιστών 2
(ΗΥ232)
Διαδικασίες (procedures)
Γνωστές και σαν υπορουτίνες (subroutines)
• Η διαδικασία γράφεται σαν ένα ανεξάρτητο πρόγραμμα που
ορίζει και επεξεργάζεται τις δικές της - εσωτερικές -
μεταβλητές ή δεδομένα, κάτι που συνεπάγεται ότι:
– Δεσμεύει δικό της τμήμα δεδομένων στον αντίστοιχο χώρο της
μνήμης
– Έχει τη δυνατότητα να χρησιμοποιήσει τους ίδιους καταχωρητές με
το κυρίως πρόγραμμα για την επεξεργασία των δεδομένων της
• Η χρήση κοινών καταχωρητών σημαίνει ότι εκείνοι που
χρειάζονται από το κυρίως πρόγραμμα θα πρέπει να
αποθηκευτούν σε κάποιο χώρο μνήμης κατά την κλήση της
διαδικασίας, και αργότερα να ανακτηθούν από το χώρο
αυτό με την επιστροφή από τη διαδικασία
– Η δομή μνήμης που χρησιμοποιείται για την αποθήκευση και
ανάκτηση των περιεχομένων Υπολογιστών είναι η στοίβα (stack)
καταχωρητών
Οργάνωση και Σχεδίαση 3
(ΗΥ232)
Υποστήριξη διαδικασιών (procedures)
στον MIPS
• Στον MIPS, ένα πρόγραμμα πρέπει να ακολουθήσει
τα παρακάτω βήματα όταν καλεί μια διαδικασία
(caller calls a callee) :
1. O καλών (caller) τοποθετεί τις παράμετρους της
διεργασίας (callee) κάπου που να μπορεί τις ανακτήσει η
διεργασία αυτή.
• Καταχωρητές ορίσματος $a0-$a3 (argument registers) ($4-$7)
• Για περισσότερα από 4 ορίσματα, ο καλών(caller) χρησιμοποιεί
την μνήμα στοίβας (stack)
2. O καλών μεταβιβάζει τον έλεγχο στη διαδικασία
• Χρησιμοποιώντας μια εντολή αλλαγής ροής χωρίς συνθήκη
(εντολή άλματος και σύνδεσης, jal)

(ΗΥ232)
Υποστήριξη διαδικασιών(procedures)
στον MIPS
3. H διαδικασία (callee) καταλαμβάνει μνήμη στην στοίβα
(stack) που θα χρειαστεί κατά την εκτέλεση της.
• Αυτόματες μεταβλητές (automatic variables) της διαδικασίας
(callee) τοποθετούνται στην στοίβα.
• Επίσης, όσοι καταχωρητές διαγράφονται μέσα στην διαδικασία,
ενώ η παλιά τους τιμή χρειάζεται από τον καλούντα
αποθηκεύονται στην στοίβα από τον καλούντα.
4. H διαδικασία εκτελείται
5. H διαδικασία τοποθετεί το αποτελέσμα σε καταχωρητή
(για να το προσπελάσει η καλούσα διαδικασία)
• Καταχωρητές τιμής $v0-$v1 (value registers) ($2-$3)
6. H διαδικασία επιστρέφει στο σημείο κλήσης
• Χρησιμοποιώντας μια εντολή αλλαγής ροής χωρίς συνθήκη
(jump register, jr)
(ΗΥ232)
Χρήση καταχωρητών
• Κατά την εκτέλεση μιας διαδικασίας, πολλοί από
τους καταχωρητές του MIPS, έχουν ειδική σημασία:
• $a0 – $a3: καταχωρητές παραμέτρων ($ 4 – $7)

• $v0, $v1: καταχωρητές τιμής (ή αποτελεσμάτων) ($ 2 – $3)
• $ra: καταχωρητής διεύθυνσης επιστροφής ($ 31)
• $t0 – $t9: προσωρινοί καταχωρητές ($8-$15, $24-$25)

– Μπορεί να διαγραφούν από τον καλούμενο (callee)
• $s0 – $s7: αποθηκευμένοι καταχωρητές ($ 16- $23)
– Ο καλούμενος πρέπει να τους αποθηκεύει στην αρχή και
να τους επαναφέρει στο τέλος της κλήσης
(ΗΥ232)
Χρήση καταχωρητών
• $gp: καθολικός δείκτης (global pointer) στατικών δεδομένων
($28)
• $sp: δείκτης στοίβας (stack pointer) ($29)
• $fp: δείκτης πλαισίου (30)
• pc: μετρητής προγράμματος (program counter)

(ΗΥ232)
Εντολές κλήσης διαδικασιών
• Κλήση διαδικασίας:
Εντολή άλματος και σύνδεσης (jump and link,
jal, jalr)
– jal L1  $ra = PC+4 ; PC = L1
0x1000: jal L1
0x1004 ....
– Η διεύθυνση της επόμενης εντολής τοποθετείται
στον $ra ($ra = 0x1004)
– Μεταπήδηση στη διεύθυνση προορισμού L1
(ΗΥ232)
Εντολές κλήσης διαδικασιών

• Επιστροφή διαδικασίας:
Εντολή jump register
jr $ra  PC = $ra
– Αντιγράφει το $ra (31) στο μετρητή
προγράμματος (pc = $ra)
– Μπορεί επίσης να χρησιμοποιηθεί για
υπολογισμένα άλματα
• π.χ. για εντολές case/switch που υλοποιούνται με
πίνακα αλμάτων

(ΗΥ232)
Στοίβα (Stack)
• Η στοίβα είναι προσπελάσιμη ως Last In First Out (LIFO)

• Η στοίβα του MIPS «μεγαλώνει» από τις υψηλότερες προς τις
χαμηλότερες διευθύνσεις.
• Ένας δείκτης στοίβας (stack pointer) χρησιμοποιείται για να
δείξει το τελευταίο έγκυρο (valid) στοιχείο στην στοίβα
– Στον MIPS, ο δείκτης στοίβας είναι ο $sp ($29)
(ΗΥ232)
Στοίβα (Stack)
• Κατά την κλήση μιάς διαδικασίας η στοίβα μπορεί να περιέχει τα

παρακάτω πεδία (από υψηλότερες προς χαμηλότερες διευθύνσεις):
– τους επιπλέον καταχωρητές ορισμάτων στην περίπτωση που η διαδικασία
έχει πάνω από 4 ορίσματα. O καλών (caller) πρέπει να τους τοποθετήσει στην
στοίβα
– Την διεύθυνση επιστροφής από την διαδικασία (δηλ. τον $ra). Αυτό χρειάζεται
μόνο εάν η διαδικασία δεν είναι φύλλο, δηλ. θα καλέσει μια άλλη διαδικασία.
– Καταχωρητές που θα διαγραφούν στην διαδικασία αυτή, αλλά η παλιά τους
τιμή χρειάζεται στον καλούντα (caller)
– Τοπικές μεταβλητές, πίνακες, λίστες, (automatic variables only)
(ΗΥ232)
Σύμβαση διαφύλαξης καταχωρητών
• Οι γενικής χρήσης καταχωρητές του MIPS ($s0-$s7 και $t0-$t9) έχουν
διαφορετική αντιμετώπιση ως προς τη διαφύλαξή τους στη στοίβα
και την ανάκτησή τους από αυτή κατά την κλήση μιας διαδικασίας
– Οι καταχωρητές $s0-$s7 (saved registers) θεωρούνται εξ ορισμού ότι
χρειάζονται στο κυρίως πρόγραμμα και μετά το πέρας της διαδικασίας
=> η διαδικασία είναι εκείνη που θα πρέπει να σώσει στη στοίβα
αρχικά, και να ανακτήσει στο τέλος της όσους από τους καταχωρητές
αυτούς μεταβάλλει (καταχωρητές τύπου callee-save)
– Οι καταχωρητές $t0-$t9 (temporary registers) θεωρούνται εξ ορισμού
ότι δεν χρειάζονται στο κυρίως πρόγραμμα μετά από την κλήση και το
πέρας της διαδικασίας
=> το κυρίως πρόγραμμα θα πρέπει να αναλάβει την πρωτοβουλία να
σώσει στη στοίβα πριν από την κλήση, και να ανακτήσει κατά την
επιστροφή όσους από τους καταχωρητές αυτούς χρειάζεται
(καταχωρητές τύπου caller-save)
• Ο καταχωρητής $ra, και πιθανόν οι $a0-$a3, πρέπει να
αποθηκεύονται στην στοίβα εάν η διαδικασία καλεί κάποια άλλη
διαδικασία Οργάνωση και Σχεδίαση Υπολογιστών
(ΗΥ232) 12
Κατανομή μνήμης
• Κείμενο (Text): κώδικας
• Στατικά δεδομένα (static
data segment): καθολικές
μεταβλητές
– πχ., στατικές μεταβλητές C,
πίνακες, συμβολοσειρές
– $gp : επιτρέπει εύκολη
πρόσβαση στο τμήμα
• Δυναμικά δεδομένα: σωρός
(heap)
– π.χ., malloc στη C,
new στη Java
• Τοπικές ματαβλητές: Στοίβα
(Stack)
(ΗΥ232)
Παράδειγμα:
Διαδικασία-φύλλο (Leaf procedure)
int leaf_ex (int g, int h, int i, int j) {

int f;
f = (g + h) - (i + j);
return f;
}
– Διαδικασίες που δεν καλούν άλλες

• O caller πριν καλέσει την leaf_ex θέτει: $a0=g, $a1=h,
$a2=i, $a3=j
• O $s0 χρειάζεται στον caller και άρα πρέπει να σωθεί
στην στοίβα από τον callee
• Αποτέλεσμα γράφεται στον $v0
(ΗΥ232)
Διαδικασίες-φύλλα
int leaf_ex (int g, int h, int i, int j) {
int f;
f = (g + h) - (i + j);
return f;
• κώδικας MIPS: }
leaf_ex:
addi $sp, $sp, -4
Αποθήκευση $s0
sw $s0, 0($sp) στη στοίβα
add $t0, $a0, $a1
add $t1, $a2, $a3 Σώμα διαδικασίας
sub $s0, $t0, $t1
move $v0, $s0 Αποτέλεσμα
lw $s0, 0($sp) Επαναφορά $s0
addi $sp, $sp, 4
jr $ra Επιστροφή

(ΗΥ232)
Παράδειγμα strcpy
• Κώδικας C
void strcpy (char x[], char y[])
{
int i;
i = 0;
while ((x[i]=y[i])!='\0')
i += 1;
}
– Διευθύνσεις των x, y στους $a0, $a1
– Το i στον $s0

(ΗΥ232)
Παράδειγμα (assembly)
• Κώδικας MIPS:
strcpy:
addi $sp, $sp, -4 # ρύθμιση στοίβας για 1 τιμή
sw $s0, 0($sp) # αποθήκευση $s0
li $s0, $zero # i = 0
L1: add $t1, $s0, $a1 # διευθ. του y[i] στον $t1
lb $t2, 0($t1) # $t2 = y[i]
add $t3, $s0, $a0 # διευθ. του x[i] στον $t3
sb $t2, 0($t3) # x[i] = y[i]
beq $t2, $zero, L2 # εξοδος αν y[i] == 0
addi $s0, $s0, 1 # i = i + 1
j L1 # επόμενη επανάληψη
L2: lw $s0, 0($sp) # επαναφορά $s0
addi $sp, $sp, 4 # αφαίρ. τιμής από στοίβα
jr $ra # και επιστροφή

(ΗΥ232)
Ένθετες διαδικασίες
• Διαδικασίες που καλούν άλλες διαδικασίες
– Ή και τον εαυτόν τους (recursive procedures)
• Ο καλών πρέπει να αποθηκεύσει στη στοίβα:
– Τη διεύθυνση επιστροφής (return address)
– Όσες προσωρινές τιμές και παραμέτρους θα
χρειαστούν μετά το τέλος της κλήσης.
• Μετά την ολοκλήρωση της κλήσης, ο καλών
επαναφέρει από τη στοίβα τις αποθηκευμένες
τιμές

(ΗΥ232)
Bubble Sort
Input: Πίνακας από Ν στοιχεία
Α[0] Α[1] Α[2] Α[3] Α[4]
3 4 10 5 3
Output: Ταξινομημένος πίνακας από Ν στοιχεία
Α[0] Α[1] Α[2] Α[3] Α[4]

3 3 4 5 10
Βασική ιδέα:
Τοποθέτησε το εκάστοτε μικρότερο στοιχείο στην αρχή του πίνακα

(ΗΥ232)
Bubble Sort
Α[0] Α[1] Α[2] Α[3] Α[4] Α[0] Α[1] Α[2] Α[3] Α[4]
3 4 10 5 3 3 3 4 10 5
Α[0] Α[1] Α[2] Α[3] Α[4] Α[0] Α[1] Α[2] Α[3] Α[4]
3 4 10 3 5 3 3 4 5 10
Α[0] Α[1] Α[2] Α[3] Α[4] Α[0] Α[1] Α[2] Α[3] Α[4]
3 4 3 10 5 3 3 4 5 10
Α[0] Α[1] Α[2] Α[3] Α[4] Α[0] Α[1] Α[2] Α[3] Α[4]
3 3 4 10 5 3 3 4 5 10
Α[0] Α[1] Α[2] Α[3] Α[4]

3 3 4 10 5

(ΗΥ232)
Παράδειγμα : Bubble Sort

Ο παρακάτω αλγόριθμος , τοποθετεί το μικρότερο στοιχείο
του υπο-πίνακα κάθε φορά στην αρχή.
void sort(int v[], int n) {

int i, j;
for (i = 0; i < n; i++) {
for (j = n-2; j >= i && v[j] > v[j+1]; j--) {
swap(v, j);
}
}
– $a0 = &v[0], $a1 = n

(ΗΥ232)
Η διαδικασία swap
void swap(int v[],int k) {
int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}
swap: sll $t1, $a1, 2 # $t1 = k * 4

add $t1, $a0, $t1 # $t1 = v+(k*4)
# (διεύθυνση του v[k])
lw $t0, 0($t1) # $t0 (temp) = v[k]
lw $t2, 4($t1) # $t2 = v[k+1]
sw $t2, 0($t1) # v[k] = $t2 (v[k+1])
sw $t0, 4($t1) # v[k+1] = $t0 (temp)
jr $ra # επιστροφή στον καλώντα

(ΗΥ232)
void sort(int v[], int n) {
Το σώμα της sort

int i, j;
for (i = 0; i < n; i++) {
for (j = n-2; j >= i && v[j] > v[j+1]; j
swap(v, j);
$a0 = &v[0], $a1 = n, $s0=i, $s1=j
}
}
move $s2, $a0 # αποθ. τον $a0 στον $s2
Move
move $s3, $a1 # αποθ. $a1 στον $s3
params
move $s0, $zero # i = 0
for1tst: Outer loop
bge $s0, $s3, exit1 # go to exit1 if $s0 ≥ $s3 (i ≥ n)
addi $s1, $a1, –2 # j = n-2
for2tst:
blt $s1, $s0, exit2 # go to exit2 if $s1 < $s0 (j < i)
sll $t1, $s1, 2 # $t1 = j * 4
Inner loop
add $t2, $s2, $t1 # $t2 = v + (j * 4)
lw $t3, 0($t2) # $t3 = v[j]
lw $t4, 4($t2) # $t4 = v[j + 1]
bge $t4, $t3, exit2 # go to exit2 if $t4 ≥ $t3
move $a0, $s2 # 1η παράμ. της swap είναι v
move $a1, $s1 # 2η παράμ. της swap είναι j Pass
jal swap # κλήση διαδικασίας swap params
addi $s1, $s1, –1 # j –= 1 & call
j for2tst # προς έλεγχο εσωτερικού βρόχου
Inner loop
exit2: addi $s0, $s0, 1 # i += 1
j for1tst # jump to test of outer loop
Outer loop 23
Ολόκληρη η διαδικασία
sort: addi $sp,$sp, –20 # κάνε χώρο στη στοίβα για 5 κατ/τές
sw $ra, 16($sp) # αποθ. $ra στη στοίβα
sw $s3,12($sp) # αποθ. $s3 στη στοίβα
sw $s2, 8($sp) # αποθ. $s2 στη στοίβα
… # σώμα διαδικασίας
…
exit1: lw $s0, 0($sp) # επαναφορά $s0 από στοίβα
lw $s1, 4($sp) # επαναφορά $s1 από στοίβα
lw $s2, 8($sp) # επαναφορά $s2 από στοίβα
lw $s3,12($sp) # επαναφορά $s3 από στοίβα
lw $ra,16($sp) # επαναφορά $ra από στοίβα
addi $sp,$sp, 20 # επαναφορά stack pointer
jr $ra # επιστροφή στον καλώντα

(ΗΥ232)
Διάλεξη 6
Αναδρομή
Υπολογισμός Παραγοντικού n!
if n<1, 1
n! = 1*2..(n-1)*n =
else, n*(n-1)!
int fact (int n)

{
if (n < 1) return 1;
else return n * fact(n - 1);
}
– Παράμετρος n στον $a0

– Αποτέλεσμα στον $v0

(HY232)
Ένθετες διαδικασίες: Παράδειγμα

jal fact int fact (int n)
{
LLL:: if (n < 1) return 1;
else return n * fact(n - 1);
}
fact:
addi $sp, $sp, -8 # ρύθμιση στοίβας για 2 τιμές
sw $ra, 4($sp) # αποθ. διεύθυνσης επιστροφής
sw $a0, 0($sp) # αποθ. Παραμέτρου
bge $a0, 1, L1 # έλεγχος για το εάν n<1
li $v0, 1 # αν ναι, αποτέλεσμα: 1
addi $sp, $sp, 8 # αφαιρ. 2 τιμών από στοίβα
L1: addi $a0, $a0, -1 # αλλιώς αφαιρ. 1 από το n
jal fact # αναδρομική κλήση
LL: lw $a0, 0($sp) # επαναφορά αρχικού n
lw $ra, 4($sp) # και διεύθυνσης επιστροφής
addi $sp, $sp, 8 # αφαιρ. 2 τιμών από στοίβα
mul $v0, $a0, $v0 # υπολογ. αποτελέσματος
(HY232)
Συμπεριφορά της στοίβας
Έστω ότι η συνάρτηση καλείται με n=3
fact(3)
Πριν την fact:
κλήση
της fact(3) $sp addi $sp, $sp, -8 # ρύθμιση στοίβας για
sw $ra, 4($sp) # αποθ. διεύθυνσης επιστ
$ra(=LLL) sw $a0, 0($sp) # αποθ. Παραμέτρου
$sp $a0(=3)
bge $a0, 1, L1 # έλεγχος για το εάν
li $v0, 1 # αν ναι, αποτέλεσμα: 1

fact(1) addi $sp, $sp, 8 # αφαιρ. 2 τιμών από
L1: addi $a0, $a0, -1 # αλλιώς αφαιρ. 1 από

fact(2) jal fact # αναδρομική κλήση
$ra(=LLL)
LL: lw $a0, 0($sp) # επαναφορά αρχικού
$a0(=3) lw $ra, 4($sp) # και διεύθυνσης επιστρο
$ra(=LLL)
addi $sp, $sp, 8 # αφαιρ. 2 τιμών από
$ra(=LL)
$a0(=3)
$a0 (=2)
$ra(=LL) mul $v0, $a0, $v0 # υπολογ. αποτελέσματος
$ra(=LL) jr $ra # και επιστροφή
$sp $a0 (=2)
$sp $a0 (=1)
Συμπεριφορά της στοίβας (συνεχ.)

fact(0)
fact:
$ra(=LLL) $ra(=LLL) $ra(=LLL) addi $sp, $sp, -8 # ρύθμιση στοίβας

sw $ra, 4($sp) # αποθ. διεύθυνσης
$a0(=3) $a0(=3) $a0(=3) sw $a0, 0($sp) # αποθ. Παραμέτρου
$ra(=LL) $ra(=LL) $ra(=LL)

bge $a0, 1, L1 # έλεγχος για το ε
$a0 (=2) $a0 (=2) $sp $a0 (=2)
li $v0, 1 # αν ναι, αποτέλεσ
$ra(=LL) $ra(=LL) $v0 = 1*1=1 addi $sp, $sp, 8 # αφαιρ. 2 τιμών
$a0 (=1) jr $ra # και επιστροφή
$sp $a0 (=1)
$ra(=LL) L1: addi $a0, $a0, -1 # αλλιώς αφαιρ
$v0 = 1 jal fact # αναδρομική κλήση
$sp $a0 (=0)
LL: lw $a0, 0($sp) # επαναφορά αρχικο
lw $ra, 4($sp) # και διεύθυνσης
addi $sp, $sp, 8 # αφαιρ. 2 τιμών
$sp
$ra(=LLL)
$v0 = 2*3=6 mul $v0, $a0, $v0 # υπολογ. αποτελέσ
$sp $a0(=3) jr $ra # και επιστροφή
Επέστρεψε στην καλούσα συνάρτηση
$v0 = 1*2=2
(HY232)
Παράδειγμα αναδρομής
• Iσχυρή αναδρομική συνάρτηση tak()
int tak(int x, int y, int z) {

if (y < x) {
return 1 + tak(tak(x-1,y,z),
tak(y-1,z,x),
tak(z-1,x,y));
}
else
return z;
}
int main () {
tak (18, 12, 6);
}

(HY232)
if (y < x) {
tak(y-1,z,x),
tak(z-1,x,y));
}
else
return z;
}
int main () {
tak (18, 12, 6);
}
tak:
subu $sp, $sp, 20 # θέσεις για 5 καταχωρητές στην
sw $ra, 16($sp) # στοίβα: $ra, $s0..$s3
sw $s0, 12($sp)
sw $s1, 8($sp)
sw $s2, 4($sp)
sw $s3, 0($sp)
move $s0, $a0 # $s0 = x
move $s1, $a1 # $s1 = y
move $s2, $a2 # $s2 = z
bge $s1, $s0, L1 # if (y >= x) goto L1
addiu $a0, $s0, -1 # κώδικας για y < x
move $a1, $s1
move $a2, $s2
jal tak
move $s3, $v0 # $s3= tak(x-1, y, z)
(HY232)
if (y < x) {
tak(y-1,z,x),
tak(z-1,x,y));
}
else
return z;
}
int main () {
tak (18, 12, 6);
}
addiu $a0, $s1, -1

move $a1, $s2
move $a2, $s0
jal tak # $v0=tak(y-1, z, x)
addiu $a0, $s2, -1
move $a1, $s0
move $a2, $s1
move $s0, $v0
jal tak # $v0=tak(z-1, x, y)
move $a0, $s3
move $a1, $s0
move $a2, $v0 #tak (tak(..), tak(..), tak(..))
jal tak
addiu $v0, $v0, 1
j L2
L1: move $v0, $s2
(HY232)
if (y < x) {
tak(y-1,z,x),
tak(z-1,x,y));
}
else
return z;
}
int main () {
tak (18, 12, 6);
}
L2: lw $ra, 16($sp)

lw $s0, 12($sp)
lw $s1, 8($sp)
lw $s2, 4($sp)
lw $s3, 0($sp)
addiu $sp, $sp, 20
jr $ra
main:
li $a0, 18 # προετοιμασία και κλήση της tak()
li $a1, 12
li $a2, 6
jal tak
move $a0, $v0 # τύπωσε το αποτέλεσμα
li $v0, 1
syscall

(HY232)
Καταχωρητής Πλαισίου ($fp)
• Η προσπέλαση των αυτόματων μεταβλητών στη στοίβα δεν γίνεται εύκολα
μέσω του $sp, επειδή αυτός μεταβάλλεται διαρκώς όσο προστίθενται νέες
και αφαιρούνται παλαιές μεταβλητές
=> συνήθως μια διαδικασία ορίζει το χώρο που καταλαμβάνουν οι σωσμένοι
καταχωρητές και οι αυτόματες μεταβλητές ως το χώρο πλαισίου της
(procedure frame) στη στοίβα, και μαρκάρει τη σταθερή αρχή αυτού με τον
καταχωρητή $fp (frame pointer, $30)
…… High Address
Όρισμα 6
Όρισμα 5
$fp Saved Registers
[$ra, $a0-$a3, $s0-$s7, $fp]
procedure
Automatic frame
variables
$sp
Low Address
(HY232)
Τοπικές μεταβλητές διαδικασιών

• Προσοχή. Μια διαδικασία δεν μπορεί να επιστρέψει στο καλούν
πρόγραμμα έναν pointer σε αυτόματη μεταβλητή που έχει δημιουργηθεί
στη στοίβα (π.χ. σε έναν πίνακα, όπως συχνά συμβαίνει), καθώς ο χώρος
αυτός της μνήμης χάνεται με την επιστροφή από τη διαδικασία και το
ταυτόχρονο pop όλων των αυτόματων μεταβλητών
int *f() { // error !
int local[10];
for (i=0;i<10;i++)
local[i] = i;
return &local[0];
}
=> η επιστροφή ενός πίνακα μπορεί να γίνει μόνο με τη μέθοδο της

δέσμευσης χώρου στη μνήμη από το καλούν πρόγραμμα, και το πέρασμα
της αντίστοιχης διεύθυνσης (pointer) βάσης στους καταχωρητές $a0-$a3
ως παραμέτρου της διαδικασίας
(HY232)
Διάλεξη 6
Αριθμητική Υπολογιστών
Πρόσθεση ακεραίων
• Παράδειγμα: 7 + 6
• Παράδειγμα με πολλαπλούς ακεραίους: 10 + 15 + 23 =

48
0 0 1 0 1 0
0 0 1 1 1 1
+
0 1 0 1 1 1
1 1 0 0 0 0
Οργάνωση και Σχεδίαση Η/Y (HY232) 2
Αφαίρεση ακεραίων
• Προσθέστε το αντίθετο του δεύτερου τελεστέου
• Παράδειγμα: 7 – 6 = 7 + (–6)
+7: 0000 0000 … 0000 0111
–6: 1111 1111 … 1111 1010
+1: 0000 0000 … 0000 0001
• Τόσο η πρόσθεση όσο και η αφαίρεση μπορούν

να οδηγήσουν σε υπερχείλιση αποτελέσματος
(overflow)
Υπερχείλιση (overflow)
• Υπερχείλιση: κατάσταση μη έγκυρου αποτελέσματος (το
αποτέλεσμα μιας πράξης χρειάζεται περισσότερα από τα
διαθέσιμα ψηφία για να αναπαρασταθεί)
• Παράδειγμα μη προσημασμένης πρόσθεσης
– Έστω ότι θέλουμε να προσθέσουμε δύο απρόσημους αριθμούς , και
να τοποθετήσουμε το αποτέλεσμα σε ένα καταχωρητή των 4-bits.
+14: 1110
+ 3: 0011
+17: 10001 
– Το πιο σημαντικό bit δεν χωράει στον καταχωρητή  overflow
– Άρα, όταν το κρατούμενο είναι cn = 1, τότε έχουμε υπερχείλιση στην
πρόσθεση

• Παράδειγμα προσημασμένης πρόσθεσης
– Έστω ότι θέλουμε να προσθέσουμε δύο προσημασμένους,
θετικούς αριθμούς , και να τοποθετήσουμε το αποτέλεσμα σε ένα
καταχωρητή των 5-bits.
+12: 01100
+ 8: 01000
+20: 010100
– O αριθμός είναι αρνητικός  overflow
– Άρα, όταν το κρατούμενο είναι cn <> cn-1, τότε έχουμε υπερχείλιση
στην πρόσθεση προσημασμένων αριθμών. Εδώ cn =0, cn-1 =1
• Παράδειγμα προσημασμένης πρόσθεσης
– Έστω ότι θέλουμε να προσθέσουμε δύο προσημασμένους,
αρνητικούς αριθμούς , και να τοποθετήσουμε το αποτέλεσμα σε ένα
καταχωρητή των 5-bits.
-12: 10100
- 8: 11000
-20: 101100
– Άρα, όταν το κρατούμενο είναι cn <> cn-1, τότε έχουμε υπερχείλιση
στην πρόσθεση προσημασμένων αριθμών. Εδώ cn =1, cn-1 =0
– Δεν μπορούμε ποτέ να έχουμε υπερχείλιση όταν προσθέτουμε έναν
θετικό και έναν αρνητικό αριθμό
– Δεν μπορούμε ποτέ να έχουμε υπερχείλιση όταν αφαιρούμε έναν
θετικό από έναν θετικό αριθμό ή το αντίθετο

• Υπερχείλιση πρόσθεσης Α+Β μη προσημασμένων αριθμών,
n bit:
– Α+Β ≥ 2n  cn = 1 (cn : κρατούμενο εξόδου από το MSB)
• Η αφαίρεση Α-Β ή Β-Α μη προσημασμένων αριθμών δεν
παρουσιάζει υπερχείλιση
• Υπερχείλιση πρόσθεσης Α+Β προσημασμένων αριθμών:
– εάν Α≥0, Β≥0 : A+B ≥ 2n-1 εάν cn = 0 : cn-1 = 1
n-1
εάν Α<0, Β<0 : A+B < -2 εάν cn = 1 : cn-1 = 0
 τότε πάντοτε είναι
εάν Α·Β<0 (περίπτωση χωρίς υπερχείλιση)
cn=cn-1=0 ή cn=cn-1=1 (cn-1 : κρατούμενο εισόδου προς το MSB)
– Συνολική συνθήκη υπερχείλισης: MSB(X) = MSB(Y) ≠ MSB(X+Y)
– Ισοδύναμη συνθήκη υπερχείλισης: (cn xor cn-1) = 1
Αριθμητικές και συγκριτικές πράξεις στον

MIPS
• Αριθμητικές πράξεις μη προσημασμένων αριθμών:
addu $s0,$s1,$s2  $s0 = $s1 + $s2 ; no_overflow
subu $s0,$s1,$s2  $s0 = $s1 - $s2 ; no_overflow
addiu $s0,$s1,100  $s0 = $s1 + 100 ; no_overflow
• Οι addu, subu, addiu παράγουν το ίδιο αποτέλεσμα με τις add, sub, addi αλλά
δεν προκαλούν εξαίρεση σε πιθανή υπερχείλιση
=> χρησιμοποιούνται - εκτός από το χειρισμό μη προσημασμένων δεδομένων,
π.χ. διευθύνσεων - όταν δεν θέλουμε να διακοπεί η ροή του προγράμματος
από το λειτουργικό σύστημα σε περίπτωση υπερχείλισης (τότε η ύπαρξη
υπερχείλισης θα πρέπει να ελέγχεται μέσα από το ίδιο το πρόγραμμα)
• Συγκριτικές πράξεις μη προσημασμένων αριθμών:
sltu $s0,$s1,$s2  $s0 = ($s1 < $s2)u
sltiu $s0,$s1,100  $s0 = ($s1 < 100)u
• Προσοχή. Στις εντολές addiu και sltiu η 16-bit σταθερά είναι προσημασμένη και
λαμβάνει επέκταση προσήμου μέχρι τα 32-bits, και μόνο η τελική πράξη της
πρόσθεσης ή της σύγκρισης αφορά μη προσημασμένους αριθμούς

Πολλαπλασιασμός και Διαίρεση Ακεραίων
Πολλαπλασιασμός Ακεραίων
Μη προσημασμένοι ακέραιοι: ακριβώς όπως και στον
πολλαπλασιασμό στο δεκαδικό σύστημα
πολλαπλασιαστέος
1000 (8)
πολλαπλασιαστής
× 1001 (9)
1000
0000
0000
1000
γινόμενο 01001000 (72)
Το μήκος του γινομένου

είναι όσο το άθροισμα των
μηκών των τελεστέων.
Οργάνωση και Σχεδίαση Η/Y (HY232) Διαφ. 10

Σειριακός πολλαπλασιαστής απρόσημων αριθμών
0110 =6
multiplicand
add
4-bit ALU shift
right
product
multiplier Control
0000 0101 =5
add 0110 0101
0011 0010
add 0011 0010
0001 1001
add 0111 1001
0011 1100
add 0 0 1Οργάνωση
1 1100
και Σχεδίαση Η/Y (HY232) 11
0001 1 1 1 0 = 30
Προσημασμένος πολλαπλασιασμός
• Ο απλούστερος τρόπος να (-8) x (+10) με m=n=5
πολλαπλασιάσουμε δύο
προσημασμένους αριθμούς n 1. Πολλ/σμός (+8)x(+10)
και m bits: 2. 01000 (+8)

1. είναι να τους μετατρέψουμε πρώτα σε 01010 (+10)
θετικούς αριθμούς 00000
2. να κάνουμε τον πολλαπλασιασμό 01000
όπως μεταξύ απρόσημων 00000
3. να μετατρέψουμε το γινόμενο σε 01000
αρνητικό (συμπλήρωμα ως προς 2), 00000
εάν ένας από τους πολλαπλασιαστέο 001010000 (+80)
ή πολλαπλασιαστή είναι αρνητικός
• Tο γινόμενο έχει μέγεθος (n- 3. Μετατροπή σε
1)+(m-1) + 1 = n+m-1 bits -80 = (110110000)2
χρησιμοποιώντας 4+4+1=9
– m-1 είναι το μέγεθος του
bits
πολλαπλασιαστέου (χωρίς το
πρόσημο) Οργάνωση και Σχεδίαση Η/Y (HY232) 12
Προσημασμένος πολλαπλασιασμός
• (-8) x (+10) με m=n=5
• Ο πολλαπλασιασμός με
προσημασμένους μπορεί να γίνει 11000 (-8)
01010 (+10)
και απευθείας με την κατάλληλη 00000
επέκταση προσήμου του 11111000
πολλαπλασιαστέου στα μερικά 00000
111000
γινόμενα (βλ. παράδειγμα Α) 000000
• Επίσης έχουμε διαφορετικό 110110000 (-80)
χειρισμό στην περίπτωση
•(-8) x (-10) με m=n=5
αρνητικού πολλ/στή.
• Στην περίπτωση αυτή, αφαιρούμε 11000 (-8)
10110 (-10)
τον πολλ/στέο από τον πολλ/στη 00000
στο ν-οστό βήμα (βλ. παράδειγμα 11111000
Β) 11111000
00000
001000 (+8)
Οργάνωση και Σχεδίαση Η/Y (HY232)001010000 (+80) 13
Παράλληλος Πολλαπλασιαστής
• Χρήση ενός δέντρου (tree) από αθροιστές
• Όλες οι προσθέσεις γίνονται παράλληλα
• Παράδειγμα: 8x9 = 72
1 0 0 0
1
1 0 0 0
0
0 0 1 0 0 0
0 0 0 1 1
0 1 0 0 1 0 0 0

Πολλαπλασιασμός στον MIPS
• Δύο νέοι καταχωρητές 32-bit για το γινόμενο
– HI: Περισσότερο-σημαντικά 32 bits
– LO: Λιγότερο-σημαντικά 32-bits
• Εντολές
– mult $rs, $rt / multu $rs, $rt
• γινόμενο 64-bit σε καταχωρητές HI/LO
– mfhi $rd / mflo $rd
• Μετακίνηση από HI/LO στο rd
• Μπορεί να ελέγξει την τιμή του HI για να δει αν το γινόμενο
υπερχειλίζει τα 32 bits
– mul $rd, $rs, $rt
• γινόμενο 64-bit σε καταχωρητές HI/LO ΚΑΙ λιγότερο-σημαντικά 32
bits του γινομένου στον $rd
Διαίρεση
Διαιρετέος Διαιρέτης • Έλεγχος για διαιρέτη 0
• Ο κλασσικός αλγόριθμος
– Αν ο διαιρέτης χωράει στο διαιρετέο
1001010 1000 • 1 στο πηλίκο, αφαίρεση
-1000 – Αλλιώς
10 1001
• 0 στο πηλίκο, κατεβαίνει επόμενο ψηφίο
101
1010 • Προσημασμένη διαίρεση
Πηλίκο – Κάνουμε διαίρεση χρησιμοποιώντας
-1000
10 απόλυτες τιμές
– Διορθώνουμε το πρόσημο του πηλίκου και
74 = 8*9 + 2 του υπολοίπου αναλόγως
Υπόλοιπο
• Βασική σχέση της Διαίρεσης:

Διαιρετέος = Πηλίκο*Διαιρέτης + Υπόλοιπο
Προσημασμένη Διαίρεση
• Μετατρέπουμε τον διαιρέτη και διαιρετέο από
αρνητικούς σε θετικούς και κάνουμε απρόσημη
διαίρεση
• Στο τέλος, κάνουμε αρνητικό το πηλίκο, εάν τα
πρόσημα του διαιρέτη και διαιρετέου είναι
διαφορετικά
• Ας δούμε την διαίρεση (+-7)/(+-2)
– 7/2 : Πηλίκο = 3, Υπόλοιπο = 1 (7 = 3*2 + 1)
– -7/2 : Πηλίκο = -3, Υπόλοιπο = -1 (-7 = (-3)*2 + (-1) )
– 7/-2 : Πηλίκο = -3, Υπόλοιπο = 1 (-7 = (-3)*(-2) + 1 )
– -7/-2 : Πηλίκο = 3, Υπόλοιπο = -1 (-7 = 3*(-2) + (-1) )
Διαίρεση στον MIPS

• Εντολές
div $rs, $rt  Lo = $rs / $rt ; Hi = $rs mod $rt
divu $rs, $rt  Lo = ($rs / $rt )u ; Hi = ($s0 mod $rt) u
• O Πολλαπλασιασμός και η Διαίρεση αγνοούν τυχόν

υπερχείλιση
– Το software θα πρέπει να ελέγχει για υπερχείλιση
– Το software θα πρέπει να ελέγχει τον διαιρέτη ώστε να είναι
διάφορος του 0.

Αριθμητική Κινητής Υποδιαστολής
Αναπαράσταση πολύ μεγάλων και πολύ μικρών

αριθμών
• Πως θα μπορούσαμε να αναπαραστήσουμε την μέση ηλικία
της γης?
4.600.000.000 ή 4,6 x 109 έτη
• ή την μονάδα ατομικής μάζας
0,0000000000000000000000000166 or 1,6 x 10-27 Kg
Αυτοί οι αριθμοί δεν μπορούν να αναπαρασταθούν με 32-bit ή
64-bit ακεραίους
• Χρησιμοποιούμε αριθμούς κινητής υποδιαστολής για την
αναπαράσταση πραγματικών αριθμών
– float x, y
– double x, y
Κινητή υποδιαστολή
• Αναπαράσταση μη-ακεραίων
– Καθώς και πολύ μικρών/μεγάλων αριθμών
• Παρόμοιο με επιστημονική σημειογραφεία
Επιστημονική σημειογραφία:
– –+987,02 × 109 Όχι ΕΣ μόνο ένα ψηφίο πρίν την
υποδιαστολή
– 2,34 × 1056 ΕΣ, Κ
Κανονικοποιημένος εάν είναι σε
– +0,002 × 10–4 ΕΣ, Όχι Κ επιστημονική σημειογραφία και το ψηφίο
αριστερά της υποδιαστολής δεν είναι 0.
• Στο δυαδικό σύστημα χρησιμοποιούμε βάση
2: Σημαντικό
Significand
Εκθέτης
Exponent
– ±1,xxxxxxx2 × 2yyyy
– Όταν ο αριθμός είναι κανονικοποιημένος, 1,0 ≤
|significand| < 2,0
– Significand = “1,xxxx…”
IEEE 754 FP Standard

• Οι περισσότεροι υπολογιστές σήμερα χρησιμοποιούν
το standard της ΙEEE 754 για αναπαράσταση αριθμών
κινητής υποδιαστολής
– Τι είναι η IEEE?
• Αριθμός = (-1)Πρόσημο x (1+Κλάσμα) x 2Εκθέτης-Πόλωση
Απλή ακρίβεια : συνολικά 32 bits, Διπλή ακρίβεια : συνολικά 64 bits
Απλή ακρίβεια: 8 bits Απλή ακρίβεια: 23 bits
Διπλή ακρίβεια: 11 bits Διπλή ακρίβεια: 52 bits
Π Εκθέτης Κλάσμα
• Υπάρχει συμβιβασμός μεταξύ μεγέθους (σε bits) του

εκθέτη και του κλάσματος
– Μεγαλύτερος εκθέτης  μεγαλύτερο εύρος τιμών (range)
– Μεγαλύτερο κλάσμα  μεγαλύτερη ακρίβεια (precision)
IEEE 754 FP Standard
Αριθμός = (-1)Πρόσημο x (1+Κλάσμα) x 2Εκθέτης-Πόλωση
• Π: πρόσημο (0  μη-αρνητικός, 1  αρνητικός)

• Κανονικοποίηση του significand: 1.0 ≤ |significand| < 2.0
– Πάντα έχει ένα αρχικό bit 1 οπότε δε χρειάζεται να αποθηκευτεί
(κρυφό bit)
• Εκθέτης: πραγματικός εκθέτης + Πόλωση (Bias)
– Εξασφαλίζει ότι ο εκθέτης είναι απρόσημος
– Απλή ακρίβεια: Πόλωση = 127; Διπλή ακρίβεια: Πόλωση = 1023
Παραδείγματα IEEE 754 FP Standard

Αριθμός = (-1)Πρόσημο x (1+Κλάσμα) x 2Εκθέτης-Πόλωση
• Παραδείγματα (κανονικοποιημένη μορφή)

• Πρώτα πρέπει να γράψουμε τον αριθμό στην μορφή
±1,xxxxxxx2 × 2yyyy
• 0,5 = 1,02 x 2-1 = 1,02 x 2126-127 = 0 01111110 000000000000000000000000

• -0,87510 x 24 = -0,1112 x 24 = -1, 112 x 23 = -1,112 x 2130-127 =
1 10000010 1100000000 00000000000000
• Μικρότερος +: 0 00000001 000000000000000000000000 = 1 x 21-127 = 2-126
• Zero: 0 00000000 00000000000000000000000 = true 0
• Μεγαλύτερος +: 0 11111110 111111111111111111111111 =
(2-2-23) x 2254-127 ~ 2 x 2127 = 2128
Εξαιρέσεις στους αριθμούς κινητής
υποδιαστολής
• Υπερχείλιση (overflow) όταν ο αριθμός που θέλουμε να αναπαραστίσουμε έχει
πολύ μεγάλο θετικό εκθέτη που δεν μπορεί να χωρέσει στο πεδίο του εκθέτη
• Ανεπάρκεια (underflow) όταν ο αριθμός που θέλουμε να αναπαραστίσουμε έχει

πολύ μεγάλο αρνητικό εκθέτη που δεν μπορεί να χωρέσει στο πεδίο του εκθέτη
-∞ +∞
(- largestE) (- largestE)
(+ largestE) (+ largestE)
 Η αριθμητική διπλής ακρίβειας χρησιμοποιεί 64 bits για να αυξήσει τα

bits εκθέτη και κλάσματος και να μειώσει την πιθανότητα overflow ή
underflow
s E (exponent) F (fraction)
1 bit 11 bits 20 bits
F (fraction continued)
Οργάνωση 32
και bits
Σχεδίαση Η/Y (HY232) 25
Παραδείγματα IEEE 754 FP Standard

• Ποιος αριθμός αναπαρίσταται σε απλή
ακρίβεια από το
1 10000001 01000…00
–Π=1
– Κλάσμα = 01000…002
– Εκθέτης = 100000012 = 129
• x = (–1)1 × (1 + ,012) × 2(129 – 127)
= (–1) × 1,25 × 22
= –5,0

IEEE 754 FP Special Encoding
• Ειδικοί κώδικες στον IEEE 754 FP χρησιμοποιούνται
για “ασυνήθιστα» γεγονότα
– +- άπειρο μετά από διαίρεση με 0
– NαN (not a number) για άκυρα αποτελέσματα όπως διαίρεση
0/0
– Το 0 αναπαριστάται με όλα τα bits ίσα με 0 (γιά λόγους
απλότητας)
Απλή ακρίβεια Double Precision Object Represented
E (8) F (23) E (11) F (52)
0 0 0 0 true zero (0)
0 nonzero 0 nonzero ± denormalized
number
1-254 anything 1-2046 anything ± floating point
number
255 0 2047 0 ± infinity
255 nonzero 2047 nonzero not a number (NaN)
Αθροιστής κινητής υποδιαστολής

Παράδειγμα 4-ψήφιου δεκαδικού. Θεωρούμε ότι μόνο
4 σημαντικά ψηφία μπορούν να αποθηκευθούν:
9,999 × 101 + 1,610 × 10–1
1. Ευθυγράμμιση υποδιαστολής
Ολίσθηση αριθμού με μικρότερο εκθέτη
9,999 × 101 + 0,016 × 101
2. Πρόσθεση significands
9,999 × 101 + 0,016 × 101 = 10,015 × 101
3. Κανονικοποίηση αποτελέσματος και έλεγχος
υπερείλισης ή υποχείλισης
10,015 × 101  1,0015 × 102
4. Στρογγυλοποίηση και (αν ξαναχρειαστεί)
κανονικοποίηση
1,002 × 102
Παράδειγμα 4-ψήφιου δυαδικού: (F1  2E1) + (F2 
2E2) = F3  2E3
0,5 + –0,4375 = 1,0002 × 2–1 + –1,1102 × 2–2
1. Ευθυγράμμιση υποδιαστολής
Ολίσθηση αριθμού με μικρότερο εκθέτη (E2) κατά Ε1-Ε2
θέσεις
1,0002 × 2–1 + –0,1112 × 2–1
2. Πρόσθεση significands (F1 + F2 = F3), θεωρώντας

άπειρη ακρίβεια στο κλασματικό μέρος
1,0002 × 2–1 + –0,1112 × 2–1 = 0,0012 × 2–1
Οργάνωση και Σχεδίαση Η/Y 29

(HY232)

overflow/underflow
0,0012 × 2–1 = 0,012 × 2–2 = ... = 1,0002 × 2–4, χωρίς
overlflow/underflow
4. Στρογγυλοποίηση και (αν ξαναχρειαστεί)

κανονικοποίηση
1,0002 × 2–4 (καμμία αλλαγή) = 0,0625

Παραδείγματα
• Α + Β = 2850,0 + -9840,0 = ? σε ΙΕΕΕ FP 754
• Α = 2850,0 = (101100100010,0)2 x 20 = 1,01100100010 x 211
• Β = -9840,0 = -(10011001110000,0)2 = -1,0011001110000 x 213
• Α = 1,01100100010 x 211 = 0,0101100100010 x 213
• Πρόσθεση σημαντικών
0,0101100100010 + -1,0011001110000 = 0,0101100100010 +
10,1100110010000 = 11,0010010110010 = -0,1101101001110
• Sum = A+B = -0,1101101001110 x 213 = -1,101101001110 x 212
• Πραγματικό αποτέλεσμα είναι: 2850,0 + -9840,0 = -6990,0

• Αποτέλεσμα σε IEEE 754 είναι: -1,101101001110 x 212 =
-1,70654296875 x 4096 = -6990,0
• Άρα Error = 0
Εντολές κινητής υποδιαστολής στο MIPS

• Το υλικό κινητής
υποδιαστολής είναι ο
συνεπεξεργαστής 1
– Eπεκτείνει το ISA
• Ξεχωριστοί κατ/τές
– 32 απλής ακρίβειας: $f0,
$f1, … $f31
– Σε ζεύγη για διπλή
ακρίβεια: $f0/$f1, $f2/$f3,

Ακριβής Αριθμητική
• Υπάρχουν άπειροι αριθμοί μεταξύ δύο
οποιονδήποτε πραγματικών αριθμών
• Συνεπώς, οι αριθμοί κινητής υποδιαστολής είναι
απλά προσεγγίσεις ενός αριθμού που δεν μπορεί να
παρασταθεί πραγματικά
• Μικρότερος +: Α = 0 00000001 00000000000000000000000 =
1 x 21-127 = 2-126
• Αμέσως μεγαλύτερος: Β= 0 00000001 00000000000000000000001 =
(1+ 2-23 ) x 2-126
• Δ = Β-Α = 2-23 x 2-126 = 2-149
• Αυτή είναι και η μεγαλύτερη δυνατή ακρίβεια στην αναπαράσταση
μεταξύ διαδοχικών αριθμών απλής ακρίβειας
• Αλλά και πάλι ο αριθμοί : (1+ 2-24 ) x 2-126, (1+ 2-24 +2-25) x 2-126 κοκ. δεν
μπορούν να αναπαρασταθούν
Ακριβής Αριθμητική
• H στρογγυλοποίηση (rounding) χρησιμοποιείται για προσέγγιση
πραγματικών αριθμών από το πεπερασμένο πλήθος των
αριθμών κινητής υποδιαστολής
– Η στρογγυλοποίηση ενδιάμεσων αποτελεσμάτων στην πρόσθεση και
πολλαπλασιασμό μπορεί να επιφέρει χαμηλότερη προσέγγιση
– Υποθέστε μόνο 3 σημαντικά ψηφία στην παρακάτω πρόσθεση
Στρογγυλοποίηση χωρίς extra bits Στρογγυλοποίηση με guard και round bits
για ενδιάμεσα αποτελέσματα
2,56 x 100 + 2,34 x 102 = 2,56 x 100 + 2,34 x 102 =
0,0256 x 102 + 2,34 x 102 (Το 0,0256 0,0256 x 102 + 2,34 x 102 =
πρέπει να στρογγυλοποιηθεί στο 0,02, 2,3656x 102
επειδή τα ψηφία 5,6 χάνονται στην
ολίσθηση) Στρογγυλοποίηση στο 2,37x 102 για 3
Άρα : 0,02 x 102 + 2,34 x 102 = 2,36 x 102 σημαντικά ψηφία

Προσεταιριστικότητα
(Associativity)
• H πρόσθεση κινητής υποδιαστολής ΔΕΝ είναι
προσεταιριστική πράξη
– x + (y+z) != x+(y+z)
– X = -1,5 x 1038
– Y= 1,5 x 1038
– Z = 1,0
x+(y+z) (x+y)+z
Y+Z = 1,5 x 1038 + 1,0 = 1,5 x 1038 X+Y = -1,5 x 1038 + 1,5 x 1038 =
X+(Y+Z) = -1,5 x 1038 + 1,5 x 1038 0,0
= 0,0 (X+Y)+Z = 0,0 + 1,0 = 1,0
Υλοποίηση αθροιστή κινητής υποδιαστολής
• Πολύ πιο
πολύπλοκος από
αθροιστή ακεραίων
• Συνήθως απαιτεί
πολλαπλούς
κύκλους μηχανής
• Τμήμα του Floating
Point Unit (FPU)
του επεξεργαστή

Πολλαπλασιασμός κινητής υποδιαστολής
Παράδειγμα τετραψήφιου δεκαδικού: : (F1  2E1) x (F2  2E2) =
F3  2E3
(1,110 × 1010 ) × (9,200 × 10–5 )
1. Πρόσθεση εκθετών
Νέος Εκθέτης = 10 + –5 = 5
2. Πολλαπλασιασμός significands
1,110 × 9,200 = 10,212  10,212 × 105
overflow/underflow
1,0212 × 106
4. Στρογγυλοποίηση και (αν ξαναχρειαστεί) κανονικοποίηση
1,021 × 106
5. Προσδιορισμός προσήμου με βάση τα πρόσημα των
τελεστέων
+1,021 × 106
Πολλαπλασιασμός κινητής υποδιαστολής

Παράδειγμα τετραψήφιου δυαδικού (δηλ. μπορούμε να
αποθηκέυσουμε μόνο 4 σημαντικά ψηφία σε κάθε χρονική
στιγμή)
0.5 × –0.4375 = 1,0002 × 2–1 × –1,1102 × 2–2
1. Πρόσθεση εκθετών
Χωρίς πόλωση: –1 + –2 = –3
Με πόλωση : –3 + 127 = 124
2. Πολλαπλασιασμός σημαντικών
1,0002 × 1,1102 = 1,110000 = 1,1102  1,1102 × 2–3
overflow/underflow
1,1102 × 2–3 (καμία αλλαγή) γιατί -126 <= -3 <= 127
4. Στρογγυλοποίηση και (αν ξαναχρειαστεί) κανονικοποίηση
1,1102 × 2–3 (καμία αλλαγή)
5. Προσδιορισμός προσήμου + × –  –
–1,1102 × 2–3 = –0,21875
Αριθμητική μονάδα κινητής υποδιαστολής
• Ο πολ/στής είναι παρόμοιας πολυπλοκότητας με
τον αθροιστή
– Αλλά χρησιμοποιεί πολλαπλασιαστή για τα
significands αντί για αθροιστή
• Η αριθμητική μονάδα κινητής υποδιαστολής
συνήθως κάνει:
– Πρόσθεση, αφαίρεση, πολλαπλασιασμό, διαίρεση,
αντίστροφο, ρίζα
– Μετατροπή από πραγματικό σε ακέραιο και το
αντίθετο
• Οι εντολές συνήθως παίρνουν αρκετούς
κύκλους

• Οι εντολές κινητής υποδιαστολής λειτουργούν μόνο
σε καταχωρητές κινητής υποδιαστολής
– Το προγράμματα γενικά δεν κάνουν ακέραιες πράξεις σε
δεδομένα κινητής υποδιαστολής και αντίστροφα.
• Εντολές φόρτωσης και αποθήκευσης αριθμών
Απλή ακρίβεια
lwc1 $f1, 54($s2) # $f1 = Memory[$s2+54]
swc1 $f1, 58($s4) # Memory[$s4+58] = $f1
Διπλή ακρίβεια
ldc1 $f2, 54($s2) # ($f2, $f3) = Memory[$s2+54]
sdc1 $f24, 58($s4) # Memory[$s4+58] = ($f24, $f25)
• Αριθμητική απλής ακρίβειας
– add.s, sub.s, mul.s, div.s
• add.s $f0, $f1, $f6
• Αριθμητική διπλής ακρίβειας
– add.d, sub.d, mul.d, div.d
• mul.d $f4, $f4, $f6
• Σύγκριση απλής & διπλής ακρίβειας
– c.xx.s, c.xx.d (xx είναι eq, lt, le, …)
– Θέτει ή μηδενίζει το το bit κωδικού συνθήκης FP
• c.lt.s $f3, $f4
• Διακλάδωση ανάλογα με τον κωδικό συνθήκης FP
– bc1t, bc1f
• bc1t TargetLabel
• Μετατροπή μεταξύ κινητής υποδιαστολής και ακεραίων
– cvt.w.s # από κιν. Υποδιαστολής απλής ακρίβειας σε
ακέραιο
• cvt.w.s $f0, $f1
Παράδειγμα: °F σε °C
float f2c (float fahr) {
return ((5.0/9.0)*(fahr - 32.0));
}
– fahr στον $f12, αποτέλεσμα στον $f0, σταθερές στο
global memory space
– Αντίθετα με τους καταχωρητές ακεραίων, ο $f0 μπορεί να
περιέχει έναν αριθμό
– Υποθέτουμε ότι ο μεταγλωττιστής τοποθετεί τις τρεις
σταθερές 5, 9, 32 στο .data section για να είναι
προσπελάσιμες από τον καθολικό δείκτη $gp.

Παράδειγμα: °F σε °C
επίσης
li $t0, 5
f2c: lwc1 $f16, const5($gp) mtc1 $t0, $f16
lwc2 $f18, const9($gp) cvt.s.w $f16, $f16
div.s $f16, $f16, $f18
lwc1 $f18, const32($gp)
sub.s $f18, $f12, $f18
mul.s $f0, $f16, $f18
mov.s $f12, $f0
li $v0, 2
syscall
jr $ra
Διάλεξη 7
Χρονισμός και Απόδοση

Υπολογιστικών Συστημάτων
Τι σημαίνει απόδοση;
Αεροσκάφος NYC to Paris Επιβάτες
Boeing 747 6 hours 500
Concorde 3 hours 125
• Ποιος τύπος αεροσκάφους έχει υψηλότερη απόδοση?

• Εάν είσαι επιβάτης : χρόνος πτήσης (πόση ώρα για να γίνει η
εργασία)
– Χρόνος πτήσης, χρόνος εκτέλεσης, χρόνος απόκρισης (latency)
• Εάν είσαι η Αir France: πόσους επιβάτες μπορείς να εξυπηρετήσεις
σε δεδομένο χρονικό διάστημα
– Επιβάτες ανά ώρα, ρυθμός απόδοσης (throughput)
Οργάνωση και Σχεδίαση Η/Υ (ΗΥ232) 2
Μετρικές Απόδοσης
• Χρόνος Απόκρισης (ή Χρόνος Εκτέλεσης)
– Latency (Execution time)
– Πόσος χρόνος απαιτείται για την εκτέλεση μιας εργασίας
• Throughput
– Συνολική ποσότητα εργασίας που διεκπεραιώνεται σε ένα
δεδομένο χρόνο
• πχ εργασίες/ώρα, bytes/sec, κοκ.
• Ο Χρόνος Απόκρισης και το Throughput δεν είναι το
ίδιο σημαντικές μετρικές για διαφορετικά
συστήματα
– Database transaction systems (latency)
– Graphics rendering system (GPU) (throughput)
Συγκριτική Απόδοση
• Ορισμός: Απόδοση = 1 / Χρόνος Εκτέλεσης
• “Το ότι το σύστημα Χ είναι n φορές πιο
γρήγορο από το σύστημα Υ σημαίνει: ”
ΑπόδοσηX ΑπόδοσηY 
Χρόνος Εκτέλεσης Y Χρόνος Εκτέλεσης X  n
 Για παράδειγμα, ο χρόνος εκτέλεσης ενός
προγράμματος:
• 10s on A, 15s on B
• Execution TimeB / Execution TimeA
= 15s / 10s = 1.5
• O A είναι 1.5 φορές γρηγορότερος από τον Β
Μέτρηση Χρόνου Εκτέλεσης

• Παρελθών Χρόνος (Elapsed Time)
– Συνολικός χρόνος εκτέλεσης μιας εργασίας που
περιλαμβάνει: επεξεργασία, Input/Output (πχ
προσπέλαση στον σκληρό δίσκο), κλήσεις στο λειτουργικό
σύστημα, κοκ.
• Χρόνος CPU (CPU time)
– Περιλαμβάνει μόνο τον χρόνο που η CPU
επεξεργάζεται μια διεργασία
• Δεν περιλαμβάνει Input/Output ή χρόνο που η CPU
ασχολείται με άλλες διεργασίες.
– CPU time = User CPU time + System CPU time

Ρολόι CPU
• H λειτουργία κάθε ψηφιακού συστήματος βασίζεται σε ένα
ρολόι που τρέχει με σταθερό ρυθμό και προσδιορίζει πότε
προκύπτουν διάφορα συμβάντα στο hardware
Clock period
Κύκλοι ρολογιού
Μεταφορά Δεδομένων
Και Υπολογισμοί
Αλλαγή Κατάστασης
 Περίοδος Ρολογιού (clock period): o χρόνος για έναν πλήρη κύκλο

ρολογιού
 πχ, 250ps = 0.25ns = 250×10
–12s
 Συχνότητα ρολογιού (clock frequency or rate): κύκλοι ρολογιού ανά

μονάδα χρόνου = 1/ Περίοδος
 πχ, 4.0GHz = 4000MHz = 4.0×10 Hz
9
 Αντιστοιχεί σε περίοδο 1/4GHz = 0.25ns

Το δομικό στοιχείο κάθε ακολουθιακού

κυκλώματος: D flip-flop
Ακμοπυροδότητο D flip-flop:
η είσοδος D περνάει στην έξοδο Q
μόνο την χρονική στιγμή της θετικής
ακμής του ρολογιού.
Σε οποιαδήποτε άλλη χρονική module dff (input D, CLK,
output reg Q);
στιγμή, η είσοδος D αγνοείται
always @(posedge clk)
begin
D Q<=D;
end
endmodule;
CLK
7
Χρονισμός του D flip-flop (I)
t
≤ PD
t
≥ CD
CLK
tPD: maximum propagation delay, CLK  Q
tCD: minimum contamination delay, CLK Q D
tSETUP: setup time

≥T SETUP ≥ t HOLD
Ο χρόνος που πρέπει η είσοδος D να έχει σταθεροποιηθεί πριν
την θετική ακμή του CLK
tHOLD: hold time
Ο χρόνος που πρέπει η είσοδος D να παραμείνει σταθερή
μετά την θετική ακμή του CLK
8
Χρονισμός του D flip-flop (II)
D Q logic D Q
reg1 reg2
CLK
tPD,reg1
CLK
tPD,logic
tCD,reg1
t ≥t
CD,logic SETUP,reg2

Σύγχρονα ακολουθιακά Κυκλώματα ενός
Ρολογιού
Χρόνος CPU
Χρόνος CPU  Αριθμός Κύκλων CPU  Περίοδος Ρολογιού
Αριθμός Κύκλων CPU

Συχνότητα Ρολογιού
• Η απόδοση του συστήματος μπορεί να

βελτιωθεί με το να:
– Μειώσουμε τον αριθμό των κύκλων CPU που
απαιτούνται για να εκτελεσθεί το πρόγραμμα
– Αυξήσουμε την συχνότητα ρολογιού
– Αυτά τα δύο δεν είναι όμως ανεξάρτητα

Παράδειγμα χρόνου CPU
• Υπολογιστής Α: Ρολόι 2GHz, Χρόνος CPU 10s
• Θέλουμε να σχεδιάσουμε έναν Υπολογιστή B
– Στόχος μας να πέσουμε στα 6s xρόνου CPU
– Πιο γρήγορο ρολόι απαιτεί 1.2Χ περισσότερους κύκλους
– Ερώτημα: Πόσο πρέπει να είναι το ρολόι του Υπολογιστή B;
Αριθμός Κύκλων CPU B
ΣυχνότηταB 
Χρόνος CPU B
1.2  Αριθμός Κύκλων CPU Α

6s
Αριθμός Κύκλων CPU A  Χρόνος CPU A  ΣυχνότηταA
 10s  2GHz  20 109
1.2  20 109 24 109
ΣυχνότηταB    4GHz
6s 6s
Με λίγη περισσότερη λεπτομέρεια

ΧρόνοςCPU  Αριθμός Εντολώνστο Πρόγραμμα CPI  ΠερίοδοςΡολογιού
Αριθμός Εντολών CPI

• Αριθμός Εντολών στο Πρόγραμμα

– Εξαρτάται από το πρόγραμμα, την αρχιτεκτονική συνόλου
εντολών (πχ MIPS, x86, ARM) και τον compiler.
• CPI ή Cycles per Instruction
– Πόσες εντολές μπορεί να εκτελέσει ένας επεξεργαστής σε έναν
κύκλο μηχανής.
– Πάντα θεωρούσαμε CPI=1 στο ΗΥ232.
– Πιο πολύπλοκες εντολές μπορεί να έχουν CPI>1

• Δύο υπολογιστές MIPS τρέχουν το ίδιο πρόγραμμα
• Υπολογιστής A: Περίοδος = 250ps, CPI = 2.0
• Υπολογιστής Β : Περίοδος = 500ps, CPI = 1.2
• Ποιος είναι πιο γρήγορος και κατά πόσο;
ΧρόνοςCPU A  Αριθμός Εντολ. CPIA  ΠερίοδοςA
 AE  2.0  250p s  AE  500p s Α πιο
γρήγορος
ΧρόνοςCPUB  Αριθμός Εντολ. CPIB  Cy cleTimeB
 AE  1.2  500p s  AE  600p s
ΧρόνοςCPUB AE  600p s
  1.2 κατά 1.2Χ
ΧρόνοςCPUA AE  500p s
Παράδειγμα Υπολογισμού Mέσου CPI

• Έστω ότι τα προγράμματα MIPS που τρέχουμε
αποτελούνται από τρείς κατηγορίες εντολών Α, Β, C.
Κατηγορία Εντολών A (add, sub) B (lw, sw) C (beq,
bne)
CPI για κατηγορία 1 2 3
ΑΕ στο Προγρ. 1 2 1 2
ΑΕ στο Προγρ. 2 4 1 1
 Πρόγραμμα 1: ΑΕ = 5  Πρόγραμμα 2 : ΑΕ = 6
 Αριθμός Κύκλων  Αριθμός Κύκλων
= 2×1 + 1×2 + 2×3 = 4×1 + 1×2 + 1×3
= 10 =9
 Μέσο CPI = 10/5 = 2.0  Μέσο CPI = 9/6 = 1.5

Παράδειγμα κώδικα MIPS (I)
Συνάρτηση καθαρισμού (clear ) μιάς περιοχής μνήμης
clear1(int array[], int size) { clear2(int *array, int size) {
int i; int *p;
for (i = 0; i < size; i += 1) for (p = &array[0]; p < &array[size];
array[i] = 0; p = p + 1)
} *p = 0;
}
move $t0,$zero # i = 0 move $t0,$a0 # p = & array[0]

loop1: sll $t1,$t0,2 # $t1 = i * 4 sll $t1,$a1,2 # $t1 = size * 4
add $t2,$a0,$t1 # $t2 = add $t2,$a0,$t1 # $t2 =
# &array[i] # &array[size]
sw $zero, 0($t2) # array[i] = 0 loop2: sw $zero,0($t0) # Memory[p] = 0
addi $t0,$t0,1 # i = i + 1 addi $t0,$t0,4 # p = p + 4
slt $t3,$t0,$a1 # $t3 = slt $t3,$t0,$t2 # $t3 =
# (i < size) #(p<&array[size])
bne $t3,$zero,loop1 # if (…) bne $t3,$zero,loop2 # if (…)
# goto loop1 # goto loop2
Αριθμός εντολών που εκτελούνται, clear1: 6N+1, clear2: 4N+3

Παράδειγμα κώδικα MIPS (II)

• Έστω ότι θέλουμε να τρέξουμε τα clear1 και clear2 για Ν=106
σε δύο υπολογιστές MIPS
• Υπολογιστής A (clear1): Συχνότητα = 1 GHz, CPI = 2.0
• Υπολογιστής Β (clear2) : Περίοδος = 500 MHz, CPI = 2.0
• Ποιος τρέχει πιο γρήγορα το πρόγραμμα και κατά πόσο;
ΧρόνοςCPU A  Αριθμός ΕντολώνA  CPIA  ΠερίοδοςA
 (6 *106  1)  2.0  1 ns  12 us Α πιο

γρήγορος
ΧρόνοςCPUB  Αριθμός ΕντολώνB  CPIB  Cy cleTimeB
 (4 *106  3)  2.0  2 ns  16 us
κατά 1.33Χ
ΧρόνοςCPUB 16
  1.33
ΧρόνοςCPUA 12Οργάνωση και Σχεδίαση Η/Υ (ΗΥ232) 17
Διάλεξη 8
Concepts of Digital Design

Introduction to Verilog
The Verilog Language

• A hardware description language (HDL) used for
modeling, simulation and synthesis of digital
electronic systems
• One of the two most commonly-used languages in
digital hardware design (VHDL is the other)
• Virtually every chip (FPGA, ASIC, etc.) is designed in
part using one of these two languages
• Combines structural and behavioral modeling styles
• IEEE standard 1364-1995
• Verilog-2001 extends the initial Verilog-95 specification
Οργάνωση και Σχεδίαση Η/Y (ΗΥ232) 2

Simulation
• Simulation is used to verify the functional
characteristics of models at any level of abstraction
• One of the main uses of Verilog/VHDL is simulation
• To test if the RTL code meets the functional
requirements of the specification, we must see if all
the RTL blocks are functionally correct.
• To achieve this we need to write a testbench, which
generates clk, reset and the required test vectors
• Simulation is needed after every refinement step
– Behavioral, zero-delay gate level, timing, post P&R
simulation
Discrete-event Simulation
• Basic idea: only do work when something changes
• Centered around an event queue
– Contains events labeled with the simulated time at which
they are to be executed
• Basic simulation paradigm
– Execute every event for the current simulated time
– Doing this changes system state and may schedule events
in the future
– When there are no events left at the current time instance,
advance simulated time soonest event in the queue

How Are Simulators Used?
• Testbench generates stimulus and checks
response
• Coupled to model of the system
• Pair is run concurrently
Stimulus
Testbench System Under Test
Response
Result
checker
Timing Simulation
• Timing simulation occurs after
– synthesis and
– after Place and Route (P&R)
• It includes gate and wire delays to make
simulation more realistic
• Before P&R, the simulator uses gate delays
models and (if available) wire delay models
• After P&R, more detailed wire delay
information can be fed back to the simulator
Learn by Example: Combinational Logic
Adder: a circuit that does addition
Here’s an example of binary addition:
Adding two N-bit 1101
numbers produces an
(N+1)-bit result +0101
10010
“Ripple-
carry
adder”
1-bit Adder
Build Truth Table and use Sum of Products (SOP)
Α Β Cin S Cout
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0 Sum: S  A  B  C
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1 Carry Out:
1 1 0 0 1 CO  A'BC  AB'C  ABC'  ABC
1 1 1 1 1  (A'  A)BC  (B'  B)AC  AB(C'  C)
 BC  AC  AB

1-bit Adder
module: Basic unit of description One line comment
// This is a behavioral module of 1-bit adder

module fulladd (Cin, x, y, s, Cout); I/O ports with which the module
input Cin, x, y; communicates externally with other
output s, Cout; modules
assign s = x ^ y ^ Cin;
assign Cout = (x & y) | (x & Cin) | (y & Cin);
endmodule Continuous assignment: the RHS is

evaluated again every time the value
of an operand changes. The LHS is
assigned that value.
This is an example of Behavioral Description

4-bit Adder Structural Description

Multiple lines comment
/* This is a structural module of 1-bit adder
*/
module adder4 (carryin, X, Y, S, carryout);
input carryin;
input [3:0] X, Y;
Instantiation of the module fulladd
output [3:0] S;
output carryout; Arguments correspond to formal
wire [3:1] C; parameters of modules
fulladd stage0 (carryin, X[0], Y[0], S[0], C[1]);

fulladd stage1 (C[1], X[1], Y[1], S[1], C[2]);
fulladd stage2 (C[2], X[2], Y[2], S[2], C[3]);
fulladd stage3 (C[3], X[3], Y[3], S[3], carryout);
endmodule Οργάνωση και Σχεδίαση Η/Y (ΗΥ232) 10

Alternative N-bit Adder
module addern #(parameter n=32) (carryin, X, Y, S, carryout);
input carryin;
input [n-1:0] X, Y; n=32 sets default value for parameter n
output [n-1:0] S;
output carryout; reg is a data type that indicates a
reg [n-1:0] S; driver that can store a value.
reg carryout; If a signal is not reg, it is a wire
reg [n:0] C; An always statement is only triggered at (@) the
integer k; condition in the parenthesis (sensitivity list).
We execute the always statement only when X or Y or
always @(X, Y, carryin) carryin change
begin
C[0] = carryin;
for (k = 0; k < n; k = k+1)
begin
S[k] = X[k] ^ Y[k] ^ C[k];
C[k+1] = (X[k] & Y[k]) | (X[k] & C[k]) | (Y[k] & C[k]);
end
carryout = C[n];
end
endmodule
Behavioral Description
Another one
module addern #(paramtere n=32) (carryin, X, Y, S, carryout, overflow);
input carryin;
input [n-1:0] X, Y;
output [n-1:0] S;
output carryout, overflow;
reg [n-1:0] S; S, X, Y are arrays
reg carryout, overflow;
always @(X or Y or carryin)

begin
S = X + Y + carryin;
carryout = (X[n-1] & Y[n-1]) | (X[n-1] & ~S[n-1]) | (Y[n-1] & ~S[n-1]);
overflow = carryout ^ X[n-1] ^ Y[n-1] ^ S[n-1];
end
endmodule
Behavioral Description
Language Elements and Expressions
Numbers in Verilog
• Integer numbers
– Simple decimal notation
• 32, -15
– Base format notation : [size in bits]’base value
– Base is one of d or D (decimal), o or O (octal), b or B (binary), h
or H (hex). Use s for signed.
• 5’O37 // 5 bit octal number 37
• 4’D2 // 4 bit decimal number 2
• 4’B1x_01 // 4 bit binary number 1x01.
• 7’Hx // 7 bit hex xxxxxxx
• 8’shFF // Signed hex equal to -1
• 4’d-4 // Not legal. The sign is before the size.
• -4’d4 // 4-bit binary number -4. The sign is before the size
• (2+3)d’10 // Not legal. Size cannot be an expression
– The underscore character (_) is legal anywhere in a number
except as the first character, where it is ignored
– When used in a number, the question mark (?) character is the
Verilog alternative for the z character.
Numbers in Verilog
• Real numbers
– Decimal notation
• 32.0, -11.06
• 2. // Not legal. Must have a digit on either side of
decimal
– Scientific notation
• 23.51e2 // 2351.0
• 23_5.1e1 // 2351.0
• 5E-4
Strings in Verilog
• A string is a sequence of chars within double
quotes
– “Verilog is cool!”

Four-valued Data
• Verilog’s nets and registers hold four-valued data
• 0, 1
– Obvious
• Z (high impedance)
– Output of an undriven tri-state driver
– Models case where nothing is setting a wire’s value
• X (unknown or undecided)
– Models when the simulator can’t decide the value
– Initial state of registers
– When a wire is being driven to 0 and 1 simultaneously
– Output of a gate with Z inputs
Two Main Data Types

• Wires represent connections between things
– Do not hold their value
– Take their value from a driver such as a gate or other module
– A signal is wire by default
• Regs represent data storage

– Behave exactly like memory in a computer
– Hold their value until explicitly assigned in an initial or always
block
– Can be used to model latches, flip-flops, etc., but do not
correspond exactly
– Shared variables with all their attendant problems

Nets and Registers
• Wires and registers can be bits, vectors, and arrays
wire a; // Simple wire

wire [15:0] dbus; // 16-bit bus
wire #(5,4,8) b; // Wire with rise delay 5, fall
delay 4, and turn-off delay (hiZ) 8
reg [-1:4] vec; // Six-bit register
integer imem[0:1023]; // Array of 1024 integers
reg [31:0] dcache[0:63]; // A 32-bit mem with 64
entries
Operators
• Arithmetic operators
• X = (A+B)-C // binary plus and minus
• X = -Y // unary minus
• X = Y*Z // multiplication
• X = A/B // division
• X = A%B // modulus is the remainder with
// the sign of the dividend.
// 7%4 = 3, -7%4 = -3, 7%-4 = 3
• X = A**B // exponent (Only in Verilog 2001)

Operators
• Relational operators
– The result is 0 (false), 1 (true), or x (either operand
has an x or z bit)
• 23 > 45 // false (value 0)
• 52 < 8’hxFF // result is x
• ‘b1000 >= ‘b01110 // false. Smaller sized operand is
zero-filled
Operators
• Equality operators.
– 2’b10 == 4’b0010 // true
– ‘b11x0 == ‘b11x0 // unknown because there
is a bit in in either operand which is x (or z)
– ‘b11x0 === ‘b11x0 // true. In case equality, x
and z are compared strictly as values

Operators
• Logical operators.
– A && B // logical AND
– A || B // logical OR
– !A // logical NOT
Operators
• Bit-wise operators
– ~A (unary negation)
– & (binary and)
– | (binary or)
– ^ (binary xor)
– ~^ (binary XNOR)
AND (&) OR (I)
0 1 X Z 0 1 X Z
0 0 0 0 0 0 0 1 X X
1 0 1 X X 1 1 1 1 1
X 0 X X X X X 1 X X
Z 0 X X X Z X 1 X X

Operators
• Reduction operators
• A = ‘b0110, B = ‘b0100, C = ‘b0x1
• &B is 0 // logical AND of all bits
• |B is 1 // logical OR of all bits
• ~&A is 1 // logical NAND of all bits
• ^B is 1 // logical XOR of all bits
• ~^B is 0 // logical XNOR of all bits
• &C is 0 // at least a bit is 0
• |C is 1 // at least a bit is 1
• ^C is x // if any bit is x or z, result is x
Operators
• Shift operators
– A >> B // logical right shift
– A << B // logical left shift
– A >>> B // right shift for signed numbers (Only
Verilog 2001)
– A <<< B // left shift for signed numbers (Only
Verilog 2001)
• Conditional operator
– cond_expr? expr1 : expr2
Operators
• Concatenation and Replication operators
– wire [7:0] Dbus
– wire [11:0] Abus
– assign Dbus = {Dbus[3:0], Dbus[7:4]} //
concatenation: swap nibbles
– Abus ={3{4’b1011}} // 12’b1011_1011_1011
Two ways to express hardware in

Verilog:
Structural and Behavioral Models
Two Main Components of Verilog
• Concurrent, event-triggered processes (behavioral)
– Initial and Always blocks
– Imperative code that can perform standard data
manipulation tasks (assignment, if-then, case)
– Processes run until they delay for a period of time or wait
for a triggering event
• Structure (structural)
– Verilog program built from modules with I/O interfaces
– Modules may contain instances of other modules
– Modules contain local signals, etc.
– Module configuration is static and all run concurrently
• High level modules typically structural
• Low level modules (leaves) typically behavioral
Structural Modeling
• When Verilog was first developed (1984) most
logic simulators operated on netlists
• Netlist: list of gates and how they’re
connected
• A natural representation of a digital logic
circuit
• Not the most convenient way to express test
benches

Behavioral Modeling
• A much easier way to write testbenches
• Also good for more abstract models of circuits
– Easier to write
– Simulates faster
• More flexible
• Provides sequencing
• Verilog succeeded in part because it allowed both
the model and the testbench to be described
together
Multiplexer Built From Primitives

Identifiers not
module mux(f, a, b, sel); explicitly defined
default to wires
output f;
input a, b, sel; Module may contain
Predefined module types structure: instances of
primitives and other
and g1(f1, a, nsel), modules
g2(f2, b, sel);
or g3(f, f1, f2); a f1
nsel g1
not g4(nsel, sel); g4
g3 f
b
endmodule sel
g2
f2

Multiplexer Built With Always
Modules may contain one or
more always blocks
module mux(f, a, b, sel);
output f;
input a, b, sel; Sensitivity list
reg f; contains signals
whose change
triggers the execution
always @(a, b, sel) of the block
if (sel)
f = b;
a
else
f = a; f
b
endmodule sel
Mux with Continuous Assignment

LHS is always set to the value on
the RHS
module mux(f, a, b, sel); Any change on the right causes
reevaluation
output f;
input a, b, sel;
assign f = sel ? b : a;
a
endmodule
f
b
sel

Structural Modeling in more
detail
Modules and Instances

• Basic structure of a Verilog module:
module mymod(port1, port2, … portN);

output port1;
Verilog convention lists
output [3:0] port2; outputs first. This is not
necessary
input [2:0] portN;
…
endmodule

Modules and Instances
• Verilog 2001 allows port direction and data type in
the port list of modules as shown in the example
below
module mymod(output port1,
output [3:0] port2,
…
input [2:0] portN);
…
endmodule
Instantiating a Module
• Instances of
module mymod(y, a, b);
• look like
mymod mm1(y1, a1, b1); // Connect-by-position

mymod (y2, a1, b1),
(y3, a2, b2); // Instance names omitted
mymod mm2(.a(a2), .b(b2), .y(c2)); // Connect-by-name

Gate-level Primitives
• Verilog provides the following keywords for gate
level modeling:
and nand logical AND/NAND

or nor logical OR/NOR
xor xnor logical XOR/XNOR
buf not buffer/inverter
bufif0 notif0 Tristate buf with low enable
bifif1 notif1 Tristate buf with high enable
Switch-level Primitives
• Verilog also provides mechanisms for modeling CMOS
transistors that behave like switches
• A more detailed modeling scheme that can catch some
additional electrical problems when transistors are
used in this way
• Rarely used because circuits generally aren’t built this
way
• More seriously, model is not detailed enough to catch
many of the problems
• These circuits are usually simulated using SPICE-like
simulators based on nonlinear differential equation
solvers

Behavioral Modeling in more
detail
Types of Assignments in Verilog

• Continuous and Procedural Assignments
• Continuous assignments model combinational
behavior only
– They assign a value to a wire (never to a reg)
– assign LHS_target = RHS_expression
– The continuous statement executes every time an event
happens in the RHS expression
– The expression is evaluated
– If the result is different, the new value is assigned to the
LHS target

Continuous Assignment
• Convenient for logical or data path specifications
Define bus widths
wire [8:0] sum;

wire [7:0] a, b; Continuous assignment:
permanently sets the value
wire carryin; of sum to be a+b+carryin
Recomputed when a, b, or
carryin changes
assign sum = a + b + carryin;

Types of Assignments in Verilog

• Procedural assignments model combinational
and sequential behavior
• They appear only within an initial statement or
an always statement
• Two different types of procedural assignments
– Blocking
– Non-blocking

Initial and Always Blocks
• Basic components for behavioral modeling
initial always
begin begin
… imperative statements … … imperative statements …
end end
Runs when simulation starts Runs when simulation starts

Terminates when control reaches the end Restarts when control reaches the end
Good for providing stimulus in testbenches Good for modeling/specifying hardware
Timing Controls
• Two forms of timing control:
– Delay control
– Event control

Delay Controls
• Delay control is of the form
# delay <procedural statement>
It specifies the time units from the time the statement is
initially encountered to the time it is executed
e.g.
#2 input = 4’b0101; // wait for 2 units, and then make
the assignment
input = #1 x // assign to input the value that x will have after
1 time unit. Different than #1 input = x
Event Controls
• Edge-triggered event control is of the form
@ event <procedural statement>
e.g. @ (posedge clk) curr_state = next_state
@ (X or Y) A <= 0; // when X or Y change
• Level-triggered event control is of the form

wait (condition) <procedural statement>
The statement executes only if the condition is true,
else it waits until the condition becomes true.
e.g. wait(DataReady);
Data = Bus
Initial and Always
• Run until they encounter a delay
initial begin
#10 a = 1; b = 0;
#10 a = 0; b = 1;
end
• or a wait for an event
always @(posedge clk) q = d;

always
begin
wait(i); a = 0; wait(~i); a = 1;
end
Blocking Procedural Assignment

• Inside an initial or always block:
sum = a + b + cin;
• Just like in C: RHS evaluated and assigned to LHS

before next statement executes
• RHS may contain wires and regs

– Two possible sources for data
• LHS must be a reg
– Primitives or cont. assignment may set wire values

Imperative Statements
if (select == 1) y = a;
else y = b;
case (op)
2’b00: y = a + b;
2’b01: y = a – b;
2’b10: y = a ^ b;
default: y = ‘hxxxx;
endcase
For Loops
• A increasing sequence of values on an output
reg [3:0] i, output;
for ( i = 0 ; i <= 15 ; i = i + 1 ) begin

output = i;
#10;
end

While Loops
• A increasing sequence of values on an output
reg [3:0] i, output;
i = 0;
while (i <= 15) begin
output = i;
#10 i = i + 1;
end
Blocking vs. Non Blocking Assignments

• Verilog has two types of procedural
assignments
• Fundamental problem:
– In a synchronous system, all flip-flops sample
simultaneously
– In Verilog, always @(posedge clk) blocks run in
some undefined sequence

A Flawed Shift Register
• This doesn’t work as you expect:
reg d1, d2, d3, d4;
always @(posedge clk) d2 = d1;

• These run in some order, but you don’t know

which
Non-blocking Assignments
Nonblocking rule:
RHS evaluated when
• This version does work: assignment runs
reg d1, d2, d3, d4;
always @(posedge clk) d2 <= d1;

LHS updated only after all
events for the current instant
have run. It runs after a Delta
Οργάνωση και Σχεδίαση Η/Y (ΗΥ232)
time 56
Nonblocking Can Behave Oddly
• A sequence of nonblocking assignments don’t
communicate
a <= 1;
b <= a;
a = 1; c <= b;
b = a;
c = b; Nonblocking assignment after δ
time:
Blocking assignment: a=1
a=b=c=1 b = old value of a
c = old value of b
Nonblocking Looks Like Latches

• RHS of nonblocking taken from latches
• RHS of blocking taken from wires
a b c
a = 1; 1
b = a;
c = b;
1 a
a <= 1;
b <= a;
c <= b; b

Sequential Logic and Finite State
Machines in Verilog
Why we need sequential logic?

What if you were given the following design specification:
When the button is What makes this circuit

pushed: different from those
1)Turn on the light if it
is off we’ve discussed
button light
2)Turn off the light if it before?
is on
The light should 1.“State” – i.e. the circuit
change state within a has memory
second of the button
2.The output was
press
changed by a input
“event” (pushing a
button) rather than an
input “value”
Digital State
One model of what we’d like to build
New
Memory
State
Device Current
State Combinational
LOAD Logic
Input Output
Plan: Build a Sequential Circuit with stored digital STATE –

•Memory stores CURRENT state
•Combinational Logic computes
•NEXT state (from input, current state)
•OUTPUT bit (from input, current state)
•State changes on LOAD control input
If Output depends on Input and current state, circuit is called a Mealy machine.
If Output depends only on the current state, circuit is called a Moore machine.
Our building block: the D FF
The edge-triggered D register: on the rising

edge of CLK, the value of D is saved in the
register and then shortly afterwards appears
on Q.
CLK

D-Register Timing
t
≤ PD
t
≥ CD
CLK
tPD: maximum propagation delay, CLK  Q ≥ tSETUP ≥ tHOLD
tCD: minimum contamination delay, CLK Q

tSETUP: setup time
How long D must be stable before the rising edge of CLK
tHOLD: hold time

How long D must be stable after the rising edge of CLK
The Sequential always Block

module dff (input D, CLK, output reg Q);
begin
Q<=D;
end
endmodule;
module CL(input a,b, sel, module SL(input a,b, sel,

output reg out); output reg out);
always @(*) always @(posedge clk)
begin begin
if (sel) out = b; if (sel) out <= b;
else out = a; else out <= a;
end end
endmodule; endmodule;

Finite State Machines and Verilog
Finite State Machines

•Finite State Machines (FSMs) are a useful abstraction for
sequential circuits with centralized “states” of operation
•At each clock edge, combinational logic computes outputs and
next state as a function of inputs and present state
inputs Combinational outputs

Logic
+ +
present state next state
n n
Q D
Registers
CLK

Two types of Finite State Machines
Moore and Mealy FSMs : different output generation
•Moore FSM:
next
state S'D
inputs Comb. Registers
Q
Comb. Outputs
x0...xn
Logic Logic yk = fk(S)
CLK
n
present state S
•Mealy FSM:
next
state S'D
inputs Comb.
Q
Registers Comb. Outputs
x0...xn
Logic Logic yk = fk(S, x0...xn)
CLK
n
present state S
Design Example: Level-to-Pulse
• A level-to-pulse converter produces a

single- cycle pulse each time its input
goes high.
• It’s a synchronous rising-edge detector.
• Sample uses:
–Buttons and switches pressed by
humans for arbitrary periods of time
–Single-cycle enable signals for counters
Level to
L Pulse P
Whenever input L goes Converter ...output P produces a single
from low to high... pulse, one clock period wide.
CLK

Step 1: State Transition Diagram
Level (L) L Level toP Pulse (P)

Pulse FSM
CLK
Step 2: Logic Derivation
+
S0 = L

Moore Level-to-Pulse Converter
Design of a Mealy Level-to-Pulse

Design of a Mealy Level-to-Pulse
Second FSM Example

Step 1A: Block Diagram
Step 1B: State transition diagram

Step 2. Verilog Implementation of the FSM
module lock(input clk, reset, b0, b1, output out);
wire reset;
parameter S_RESET = 0; parameter S_0= 1; // state assignments
parameter S_01 = 2; parameter S_010 = 3;
parameter S_0101 = 4; parameter S_01011 = 5;
always @(*)
begin // First always computes next state
case (state)
S_RESET: next_state = b0 ? S_0 : (b1 ? S_RESET : state);
S_0: next_state = b0 ? S_0 : (b1 ? S_01 : state);
S_01: next_state = b0 ? S_010 : (b1 ? S_RESET : state);
S_01011: next_state = b0 ? S_0 : (b1 ? S_RESET : state);
default: next_state = S_RESET;
endcase
end // always
Step 2. Verilog Implementation of the FSM
always @(posedge clk) // Second always computes next state

if (reset == 1’b1)
state <= S_RESET;
else
state <=next_state;
assign out = (state == S_01011);

endmodule

Modeling FSMs Behaviorally
• There are many ways to do it:
1. Define the next-state logic combinationally

and define the state-holding latches explicitly
1. Define the behavior in a single always

@(posedge clk) block
Testbenches
Writing Testbenches
Inputs to device under test
module test;
reg a, b, sel; Device under test (DUT)
mux m(y, a, b, sel);

$monitor is a built-in event
initial driven “printf”
begin
$monitor($time, “a = %b, b=%b, sel=%b, y=%b”,
a, b, sel, y);
a = 0; b= 0; sel = 0;
#10 a = 1; Stimulus generated by sequence
#10 sel = 1; of assignments and delays
#10 b = 1;
end
endmodule
Writing Testbenches
module first_counter_tb();
// Declare inputs as regs and outputs as wires
reg clock, reset, enable;
wire [3:0] counter_out;
//Initialize all variables

initial
begin
$display ("time\t clk reset enable counter");
$monitor ("%g\t %b %b %b %b",
$time, clock, reset, enable, counter_out);
clock = 1; // initial value of clock
reset = 0; // initial value of reset
enable = 0; // initial value of enable
#5 reset = 1; // Assert the reset
#10 reset = 0; // De-assert the reset
#10 enable = 1; // Assert enable
#100 enable = 0; // De-assert enable
#5 $finish; // Terminate simulation
end
// Clock generator
always begin
#5 clock = ~clock; // Toggle clock every 5 ticks
end
// Connect DUT to test bench

first_counter U_counter ( clock, reset, enable, counter_out );
end module Οργάνωση και Σχεδίαση Η/Y (ΗΥ232) 82

MIPS Arithmetic Logic Unit (ALU)
Αριθμητική και Λογική μονάδα

• Όλες οι αριθμητικές και λογικές πράξεις στον MIPS
γίνονται σε μιά 32-bit Αριθμητική και Λογική μονάδα
(ALU)
– add/addi/addu/addiu
– sub/subi/subu/subiu
– and/andi
– or/ori
– nor
– slt/slti/sltu/sltiu
• Ας προσπαθήσουμε να δούμε πώς υλοποιούνται
όλες αυτές οι εντολές στην ALU του MIPS
– Χρησιμοποιώντας τις γνώσεις σας στην Ψηφιακή Σχεδίαση Ι
Εισαγωγή στους Η/Υ (HY134) 84

1-bit Full adder
Input Output
a b cin cout Sum cout = a·b + a·cin + b·cin
0 0 0 0 0 sum = a xor b xor cin
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1
1-bit ALU
(and, or, add)
32-bit ALU
(ripple-carry configuration)
Αριθμητική και λογική μονάδα
1-bit ALU 1-bit ALU

υλοποιεί a+b και a+b’ (and, or, nor, add, sub)
a-b = a+(-b)=a+b’+1 (a OR b)’ = a’ AND b’
(and, or, add, sub) Implements nor and not (if b==0)
[cin=1 in ALU0 for sub]

(slt)
Για να υλοποιηθεί η slt c, a, b πρέπει να υπολογίσουμε
εάν a< b  a-b < 0. Εάν x=a-b < 0, το κρατούμενο εξόδου
είναι 1 επειδή το x είναι αρνητικός αριθμός
1-bit ALU (ALU0-ALU30) 1-bit ALU (ALU31)

(and, or, nor, add, sub, slt)
[overflow detection]
[Less=0 in ALU1-ALU31]
[Less=(a-b)
Εισαγωγή στους Η/Υ 31 in ALU0]
(HY134) 88
32-bit ALU
(and, or, add, sub, nor, slt)

Για εντολές διακλάδωσης
beq a, b, L
θα πρέπει να δούμε εάν a=b  (a-b
== 0)
Αφαιρούμε a-b στην ALU και
διαπιστώνουμε εάν το αποτέλεσμα
είναι 0 ή όχι.
32-bit ALU
with zero detection
(for beq, bne)
Τα 3 σήματα ελέγχου Ainvert, Bnegate,
Operation καθορίζουν και την λειτουργία της
Αριθμητικής και Λογικής μονάδας (ALU)
Ainvert Bnegate Operation Function

ALU Operation
0_0_00 AND
0_0_01 OR
0_0_10 ADD
0_1_10 SUB
0_1_11 SLT
1_1_00 NOR
Simulating Verilog
Simulation Behavior
• Scheduled using an event queue
• Non-preemptive, no priorities
• A process must explicitly request a context
switch
• Events at a particular time unordered
• Scheduler runs each event at the current time,

possibly scheduling more as a result
Two Types of Events

• Evaluation events compute functions of inputs
• Update events change outputs
• Split necessary for delays, nonblocking
assignments, etc.
Update event writes
new value of a and a <= b + c Evaluation event reads
schedules any values of b and c, adds them,
evaluation events that and schedules an update
are sensitive to a event
change on a signal

Simulation Behavior
• Concurrent processes (initial, always) run until they
stop at one of the following
• #42
– Schedule process to resume 42 time units from now
• wait(cf & of)
– Resume when expression “cf & of” becomes true
• @(a or b or y)
– Resume when a, b, or y changes
• @(posedge clk)
– Resume when clk changes from 0 to 1
Simulation Behavior
• Infinite loops are possible and the simulator does not
check for them
• This runs forever: no context switch allowed, so ready
can never change
while (~ready)
count = count + 1;
• Instead, use
wait(ready);

Simulation Behavior
• Race conditions abound in Verilog
• These can execute in either order: final value

of a undefined:
always @(posedge clk) a = 0;

always @(posedge clk) a = 1;
Verilog and Logic Synthesis

Logic Synthesis
• Verilog is used in two ways
– Model for discrete-event simulation
– Specification for a logic synthesis system
• Logic synthesis converts a subset of Verilog

language into an efficient netlist
• One of the major breakthroughs in designing
logic chips in the last 20 years
• Most chips are designed using at least some logic
synthesis
Logic Synthesis Tools

• Mostly commercial tools
– Very difficult, complicated programs to write well
– Limited market
– Commercial products in $10k - $100k price range
• Major vendors
– Synopsys Design Compiler, FPGA Express
– Cadence BuildGates
– Synplicity (FPGAs)
– Exemplar (FPGAs)
• Academic tools
– SIS (UC Berkeley)

Logic Synthesis
• Takes place in two stages:
• Translation of Verilog (or VHDL) source to a

netlist
– Register inference
• Optimization of the resulting netlist to

improve speed and area
Logic Optimization
• Netlist optimization the critical enabling technology
• Takes a slow or large netlist and transforms it into one
that implements the same function more cheaply
• Typical operations
– Constant propagation
– Common subexpression elimination
– Function factoring
• Time-consuming operation
– Can take hours for large chips

Translating Verilog into Gates
• Parts of the language easy to translate
– Structural descriptions with primitives
• Already a netlist
– Continuous assignment
• Expressions turn into little datapaths
• Behavioral statements the bigger challenge
What Can Be Translated

• Structural definitions
– Everything
• Behavioral blocks
– Depends on sensitivity list
– Only when they have reasonable interpretation as
combinational logic, edge, or level-sensitive latches
– Blocks sensitive to both edges of the clock, changes on
unrelated signals, etc. cannot be synthesized
• User-defined primitives
– Primitives defined with truth tables
– Some sequential UDPs can’t be translated (not latches or
flip-flops)

What Isn’t Translated
• Initial blocks
– Used to set up initial state or describe finite testbench
stimuli
– Don’t have obvious hardware component
• Delays
– May be in the Verilog source, but are ignored by
synthesizer
• A variety of other obscure language features
– In general, things heavily dependent on discrete-event
simulation semantics
– Certain “disable” statements
Register Inference
• The main trick
• reg does not always equal latch
• Rule:
• Combinational if outputs always depend
exclusively on sensitivity list
• Sequential if outputs may also depend on
previous values

Register Inference
• Combinational: Sensitive to changes on all of
the variables it reads
reg y;
always @(a or b or sel)
if (sel) y = a; Y is always assigned
else y = b;
• Sequential:
reg q;
q only assigned when clk is 1
always @(d or clk)
if (clk) q = d;
Register Inference
• A common mistake is not completely specifying a
case statement
• This implies a latch:
always @(a or b)
case ({a, b})
2’b00 : f = 0;
f is not assigned when {a,b} = 2b’11
2’b01 : f = 1;
2’b10 : f = 1;
endcase
Register Inference
• The solution is to always have a default case
always @(a or b)
case ({a, b}) f is always assigned
2’b00: f = 0;
2’b01: f = 1;
2’b10: f = 1;
default: f = 0;
endcase
Inferring Latches with Reset

• Latches and Flip-flops often have reset inputs
• Can be synchronous or asynchronous
• Asynchronous positive reset:
always @(posedge clk or posedge reset)

if (reset)
q <= 0;
else
q <= d;

Inferring Latches with Reset
• Synchronous positive reset:

if (reset)
q <= 0;
else
q <= d;
Simulation-synthesis Mismatches
• Many possible sources of conflict
• Synthesis ignores delays (e.g., #10), but

simulation behavior can be affected by them
• Simulator models X explicitly, synthesis doesn’t
• Behaviors resulting from shared-variable-like
behavior of regs is not synthesized
– always @(posedge clk) a = 1;
– New value of a may be seen by other @(posedge clk)
statements in simulation, never in synthesis

Διάλεξη 9
Επεξεργαστής
Υλοποίηση ενός κύκλου μηχανής
Ti είναι Αρχιτεκτονική και τι Μικροαρχιτεκτονική

• Μικροαρχιτεκτονική: μία από τις πολλές πιθανές
υλοποιήσεις μιας αρχιτεκτονικής
• Παραδείγματα:
• x86 αρχιτεκτονική (Intel),
• Intel Core i7, Core 2 Duo υλοποιήσεις του x86
• Αρχιτεκτονική MIPS
• Μικροαρχιτεκτονική ενός κύκλου μηχανής του MIPS
(κάθε εντολή assembly ολοκληρώνεται σε έναν κύκλο
μηχανής)
• Μικροαρχιτεκτονική πολλαπλών κύκλων μηχανής του
MIPS (κάθε εντολή assembly ολοκληρώνεται σε
πολλαπλούς κύκλους μηχανής)
• Μικροαρχιτεκτονική διοχέτευσης (pipeline) του MIPS
(κάθε εντολή assembly ολοκληρώνεται πολλαπλούς
κύκλους μηχανής, και πολλαπλές εντολές εκτελούνται
ταυτόχρονα)
Οργάνωση και Σχεδίαση Η/Υ (HY232) 2

Υλοποίηση ενός υποσυνόλου εντολών
• Στις επόμενες διαφάνειες θα δείξουμε την σταδιακή

υλοποίηση μερικών βασικών εντολών του MIPS
– Εντολές format-R : and, or, add, sub, slt
– Εντολές προσπέλασης μνήμης: lw, sw
– Εντολές διακλάδωσης: beq
– Extra εντολές: addi, j
• Υλοποίηση σε έναν κύκλο μηχανής
Αρχιτεκτονικά στοιχεία του MIPS

• Τα παρακάτω στοιχεία μνήμης, αποτελούν την Αρχιτεκτονική κατάσταση του
επεξεργαστή MIPS
• Με άλλα λόγια, τα περιεχόμενά τους είναι ορατά στον προγραμματιστή

Αρχιτεκτονικά στοιχεία του MIPS
• Για να τα δούμε με λεπτομέρεια:
PC_new [29]
PC_new [1]
PC_new [31]
PC_new [30]
PC_new [0]
PC_new
………
CLK
always @(posedge CLK or
negedge reset)
PC [31]
PC [30]
PC [29]
PC [1]
PC [0]
if (reset == 1’b0)
PC <= 0;
else
PC <= PC_new Memory (input ren, wen,
input [31:0] addr, din,
output [31:0] dout); // 4k words mem
input ren, wen;
input [31:0] addr, din;
output [31:0] dout;
reg [31:0] data[4095:0];
wire [31:0] dout;
assign dout = ((wen==1'b0) && (ren==1'b1)) ?
data[addr[11:0]] : 32'bx;
always @(din or wen or ren or addr)
begin
if ((wen == 1'b1) && (ren==1'b0))
data[addr[11:0]] = din;
end
Υλοποίηση της πρώτης μας εντολής: lw

op rs rt constant or address
Βήμα 1: Instruction Fetch 6 bits 5 bits 5 bits 16 bits
Το Fetch γίνεται για κάθε εντολή 31..26 25..21 20..16 15..0

100011 11101 01000 1111 1111 1111 1100
lw $t0, –4($sp)
Η’8FA8FFFC

Βήμα 2: Instruction Decode

Διάβασε τους καταχωρητές 31..26 25..21 20..16 15..0
εισόδου από το register file. 100011 11101 01000 1111 1111 1111 1100
lw $t0, –4($sp)
$sp = H’7FFF_EFFC
D’29
Βήμα 3: Sign Extension 31..26 25..21 20..16 15..0

Επέκταση πρόσημου της 100011 11101 01000 1111 1111 1111 1100
σταθεράς lw $t0, –4($sp)
B’1111_1111_1111_1111_1111_1111_1111_1100 =
B’1111_1111_1111_1100
H’FFFF_FFFC

Βήμα 4: Υπολόγισε την

διεύθυνση μνήμης κάνοντας 31..26 25..21 20..16 15..0
πρόσθεση στην ALU 100011 11101 01000 1111 1111 1111 1100
lw $t0, –4($sp)
= H’7FFF_EFFC
H’7FFF_EFF8
H’FFFF_FFFC

Βήμα 5: Διάβασε δεδομένα από
την μνήμη χρησιμοποιώντας την
31..26 25..21 20..16 15..0
διεύθυνση που μόλις 100011 11101 01000 1111 1111 1111 1100
υπολόγισες. lw $t0, –4($sp)
Γράψε τα δεδομένα στο register
file
D’8
H’AB00CD00
Βήμα 6: Βρες την διεύθυνση της
επόμενης εντολής PC <= PC+4
Υλοποίηση της εντολής sw

Με λίγο extra hardware, μπορούμε να υλοποιήσουμε και την sw
sw $t0, –4($sp)

Υλοποίηση εντολών R-format
op rs rt rd shamt func
Διάβασε τους καταχωρητές rs 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
και rt από το register file.
op rs rt address
Κάνε τον υπολογισμό στην ALU. 6 bits 5 bits 5 bits 16 bits
Γράψε το αποτέλεσμα στον rd
Υλοποίηση εντολής beq

• Διάβασε τους καταχωρητές rs και rt και έλεγξε εάν οι τιμές τους είναι
ίδιες.
• Υπολόγισε την διεύθυνση Δ=(PC+4) + 4*(sign extended immediate)
• Εάν rs ==rt, θέσε PC <= Δ, αλλιώς PC <= PC+4

Υλοποίηση του επεξεργαστή ενός κύκλoυ
Μονάδα Ελέγχου (Control Unit)

• ALU Decoder ως ξεχωριστό κομμάτι της μονάδας ελέγχου. Με αυτόν
τον τρόπο διαχωρίζουμε τα δύο πεδία της εντολής opcode[5:0] και
funct[5:0]
3:0

ALU και Μονάδα Ελέγχου
Για να θυμηθούμε την ALU
Ainvert Bnegate Operation Function

ALU Control
0_0_00 AND (A&B)
1-bit ALU
(and, or, add, sub, nor, slt, beq) 0_0_01 OR (A|B)
32-bit ALU
(4 control signals) (and, or, add, sub, nor, slt, beq) 0_0_10 ADD (A+B)
0_1_10 SUB (A-B)
0_1_11 SLT
1_1_00 NOR (A|B)’
ALU και Μονάδα Ελέγχου
• Για μία συγκεκριμένη εντολή η μονάδα

ελέγχου παράγει τα 4 σήματα ελέγχου
ALUControl[3:0]
opcode ALUOp Operation funct ALU ALU control

3:0
function
lw 00 load word XXXXXX add 0010
sw 00 store word XXXXXX add 0010
beq 01 branch equal XXXXXX subtract 0110
R-type 10 add 100000 add 0010
subtract 100010 subtract 0110
AND 100100 AND 0000
OR 100101 OR 0001
set-on-less- 101010 set-on-less- 0111

than
Οργάνωση και Σχεδίαση Η/Υ (HY232) than 18
Κύρια Μονάδα Ελέγχου
Instruction Op5:0 RegWrite RegDst AluSrc Branch MemWrite MemToReg ALUOp1:0
R-type 000000 1 1 0 0 0 0 10
lw 100011 1 0 1 0 0 1 00
sw 101011 0 Χ 1 0 1 Χ 00
beq 000100 0 Χ 0 1 0 Χ 01
Υλοποίηση εντολής or
op rs rt rd shamt func

Υλοποίηση εντολής addi
• Δεν απαιτείται
αλλαγή στο Data
Path
• Πρέπει όμως να
επεκταθεί η
μονάδα ελέγχου
Instruction Op5:0 RegWrite RegDst AluSrc Branch MemWrite MemToReg ALUOp1:0

R-type 000000 1 1 0 0 0 0 1 0
lw 100011 1 0 1 0 0 1 0 0
sw 101011 0 x 1 0 1 x 0 0
beq 000100 0 x 0 1 0 x 0 1
addi 001000 1 0 1 0 0 0 0 0
Copyright © 2007 Elsevier 22
Υλοποίηση εντολής j
000010 address
31:26 25:0

Υλοποίηση εντολής j
Instruction Op 5:0 RegWrite RegDst AluSrc Branch MemWrite MemToReg ALUOp 1:0 Jump
R-type 000000 1 1 0 0 0 0 1 0 0
lw 100011 1 0 1 0 0 1 0 0 0
sw 101011 0 x 1 0 1 x 0 0 0
beq 000100 0 x 0 1 0 x 0 1 0
addi 001000 1 0 1 0 0 0 0 0 0
j 000010 0 x x x 0 x x x 1
Η Απόδοση του υπολογιστή μας
ΧρόνοςCPU  Αριθμός Εντολώνστο Πρόγραμμα CPI  ΠερίοδοςΡολογιού

Αριθμός Εντολών CPI


Η Απόδοση του υπολογιστή μας
• Για αυτόν τον επεξεργαστή CPI=1
• Ας επικεντρωθούμε στην περίοδο του ρολογιού (πχ η εντολή lw).
Περίοδος Ρολογιού
D Q logic D Q
reg1 reg2
CLK
• H περίοδος ρολογιού καθορίζεται από το χειρότερο μονοπάτι μεταξύ δύο flip-

flops σε ένα κύκλωμα. Στον επεξεργαστή μας αυτό το μονοπάτι ΜΑΛΛΟΝ είναι το
παρακάτω:
Tc = tpcq_PC + tmem + max(tRFread, tsext + tmux) + tALU + tmem + tmux + tRFsetup
• Στους περισσότερους επεξεργαστές το λεγόμενο critical path είναι η μνήμη, η ALU,

και οι καταχωρητές.
• Ο καθορισμός του critical path σε πραγματικούς επεξεργαστές είναι μια πολύ
επίπονη εργασία που γίνεται από εξειδικευμένα εργαλεία CAD (Computer-Aided
Design).

Παράδειγμα υπολογισμού περιόδου ρολογιού
Στοιχείο Υλικού Συμβολικός Χρόνος (ps)
Χρόνος
Register clock-to-Q
tpcq_PC 30
Register setup
tsetup 20
Multiplexer tmux 25
ALU tALU 200
Memory read tmem 250
Register file read tRFread 150
Register file setup tRFsetup 20
Tc = tpcq_PC + 2tmem + tRFread + tmux + tALU + tRFsetup

= [30 + 2(250) + 150 + 25 + 200 + 20] ps
= 925 ps ] = 0.925ns
Fc = 1/Tc = 1.08 GHz Οργάνωση και Σχεδίαση Η/Υ (HY232) 27
Παράδειγμα υπολογισμού χρόνου εκτέλεσης

Χρόνος CPU  Αριθμός ΕΕντολώστο ΠΠρόγραμμ CPI  Περίοδος ΡΡολογιο
Αριθμός ΕΕντολώ CPI

Συχνότητα ΡΡολογιο
• Για ένα πρόγραμμα με 100 δις εκτελούμενων εντολών και CPI = 1
Χρόνος CPU = (100 ∗ 109 ) * (1) * (925 *10−12 ) = 92.5 secs

Διάλεξη 10
Διοχέτευση (Pipeline)
Θέματα Απόδοσης
• Αν και απλή, η υλοποίηση ενός κύκλου ρολογιού είναι
πολύ αργή
– Μεγάλη περίοδος ρολογιού
– Ο χρόνος εκτέλεσης είναι ο ίδιος για όλες τις εντολές και ίσος με
τον χρόνο εκτέλεσης της πιο αργής εντολής
• Αυτό παραβιάζει μια βασική σχεδιαστική αρχή
– Βελτιστοποίησε την εκτέλεση της πιο συχνής εντολής
• Η χρήση της διοχέτευσης (pipeline) μειώνει δραστικά την
περίοδο ρολογιού

Pipeline 5 κύκλων
Έστω ότι στον επεξεργαστή ενός κύκλου η περίοδος ρολογιού είναι Τc1 = 800ps
Στον νέο επεξεργαστή με pipeline μπορεί να είναι στην καλύτερη περίπτωση 800/5=160ps.
Ας θεωρήσουμε μια πιο ρεαλιστική προσέγγιση Τc2 = 200ps
Μια νέα εντολή μπορεί να ξεκινήσει κάθε κύκλο μηχανής
Instruction Fetch Instruction Decode Execute Memory Write Back

IF ID EX MEM WB
Γιατί Διοχέτευση;
Κύκλος μηχανής
1 2 3 4 5 6 7 8 9
lw $t0, 4($sp) IF ID EX MEM WB
γέμισμα
• Χρόνος εκτέλεσης σε ένα ιδανικό pipeline (CPI=1):
– Χρόνος να γεμίσει το pipeline με εντολές + ένας κύκλος ανά
εντολή
– Για Ν εντολές χρειαζόμαστε 4+N κύκλους μηχανής.
– Χρόνος pipeline CPU = (4+N)*200ps = 200.8ns για N=1000
• Χρόνος εκτέλεσης σε έναν επεξεργαστή ενός κύκλου
– Χρόνος single-cycle CPU = N*800ps = 800ns
• Επιτάχυνση = 800/200.8 = 4
Οργάνωση και Σχεδίαση Η/Υ
4
(HY232)
Pipelining για τις υπόλοιπες εντολές
• Η εντολή lw χρησιμοποιεί και τα 5 στάδια του pipeline
• Εντολές με R-format δεν χρειάζονται το στάδιο μνήμης MEM, μόνο
τα 4 στάδια IF, ID, EX, και WB
• Τι θα συμβεί εάν βάλουμε στο pipeline την lw με εντολές R-format;
1 2 3 4 5 6 7 8 9
add $sp, $sp, -4 IF ID EX WB
sub $v0, $a0, $a1 IF ID EX WB
or $s0, $s1, $s2 IF ID EX WB

5
(HY232)
Δομικοί κίνδυνοι (structural hazards)

• Κάθε δομικό στοιχείο του επεξεργαστή μπορεί να χρησιμοποιηθεί
μόνο από μία εντολή κάθε κύκλο μηχανής
• Πρόβλημα:
– Η εντολή lw χρησιμοποιεί το Write Port του Register File στο 5ο
στάδιο της
– Η εντολή or χρησιμοποιεί το Write Port του Register File στο 4ο
στάδιο της
Clock cycle
1 2 3 4 5 6 7 8 9
add $sp, $sp, -4 IF ID EX WB
sub $v0, $a0, $a1 IF ID EX WB
or $s0, $s1, $s2 IF ID EX WB

6
(HY232)
Λύση : χρήση εντολών NOP
• Κανόνες:
– Όλες οι εντολές παίρνουν 5 κύκλους να εκτελεσθούν
– Όλες οι εντολές περνάνε από τα ίδια 5 στάδια με την ίδια σειρά.
• Ακόμη και εάν κάποια στάδια δεν κάνουν καμία επεξεργασία
στην εντολή (NOP)
R-type IF ID EX NOP WB
Clock cycle
1 2 3 4 5 6 7 8 9
add $sp, $sp, -4 IF ID EX NOP WB
sub $v0, $a0, $a1 IF ID EX NOP WB
or $s0, $s1, $s2 IF ID EX NOP WB
store IF ID EX MEM NOP

branch IF ID EX NOP NOP

7
(HY232)
Καταχωρητές Διοχέτευσης
• Για να υλοποιήσουμε ένα σύστημα διοχέτευσης, θα

χρησιμοποιήσουμε ενδιάμεσους καταχωρητές στο datapath.
• Όλα τα ενδιάμεσα αποτελέσματα και σήματα ελέγχου πρέπει να
σώζονται στο τέλος κάθε κύκλου στον αντίστοιχο καταχωρητή
διοχέτευσης.
• Ονόματα καταχωρητών διοχέτευσης.
IF/ID ID/EX EX/MEM MEM/WB
• Το τελευταίο στάδιο (Write Back, WB) δεν χρειάζεται καταχωρητές

διοχέτευσης γιατί η εντολή τερματίζεται.
• Είναι οι καταχωρητές διοχέτευσης ορατοί στον προγραμματιστή;

8
(HY232)
Διοχέτευση Δεδομένων
1
PCSrc

4
Add
P Add
C Shift
RegWrite left 2
Read Read
register 1 data 1 MemWrite
ALU
Read Instruction Zero
Read Read
address [31-0] 0
register 2 data 2 Result Address
Write
1 Data
Instruction register MemToReg
memory
memory Registers ALUOp
Write
data ALUSrc Write Read
1
data data
Instr [15 - 0] Sign
RegDst
extend MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

9
(HY232)
Προώθηση δεδομένων
• Οι τιμές των δεδομένων που χρειάζονται σε επόμενα στάδια της
διοχέτευσης πρέπει να μεταφερθούν μέσω των καταχωρητών
διοχέτευσης
• Ο καταχωρητής προορισμού rd είναι ένα χαρακτηριστικό
παράδειγμα.
– To πεδίο rd της εντολής ανακτάται στο πρώτο στάδιο (Instruction Fetch, IF).
Αλλά χρησιμοποιείται μόνο μετά από 5 κύκλους στο στάδιο Write Back, WB.
– Συνεπώς, το πεδίο rd πρέπει να μεταφερθεί από όλους τους καταχωρητές
διοχέτευσης μέχρι το 5ο στάδιο.
• Δεν μπορούμε να το κρατήσουμε σε ένα απλό καταχωρητή εντολής
(instruction register) γιατί σε κάθε κύκλο μηχανής μια νέα εντολή
εισέρχεται στον επεξεργαστή από την μνήμη εντολών.

10
(HY232)
Καταχωρητής Προορισμού
1
PCSrc

4
Add
P Add
C Shift
RegWrite left 2
Read Read
ALU
Read Read
address [31-0] 0
Write
1 Data
memory
Write
1
data data
Instr [15 - 0] Sign
RegDst
extend MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

11
(HY232)
Σήματα Ελέγχου
• H δημιουργία των σημάτων ελέγχου γίνεται ακριβώς όπως στην
περίπτωση του επεξεργαστή ενός κύκλου.
– Μετά το Instruction Fetch η εντολή αποκωδικοποιείται από την μονάδα ελέγχου
και δημιουργούνται τα σήματα ελέγχου.
• Όπως και πριν, κάποια σήματα ελέγχου θα χρειαστούν στα
τελευταία στάδια του pipeline (πχ 4ο ή 5ο)
• Όπως ακριβώς και τα δεδομένα, έτσι και αυτά τα σήματα ελέγχου
θα πρέπει να προωθηθούν μέσω των καταχωρητών διοχέτευσης
στα επόμενα στάδια μέχρι να χρησιμοποιηθούν.

12
(HY232)
Διοχέτευση Σημάτων Ελέγχου και Δεδομένων
1
0
ID/EX
WB EX/MEM
PCSrc
Control M WB MEM/WB
IF/ID EX M WB
4
Add
P Add
C Shift
RegWrite left 2
Read Read
ALU
Read Read
address [31-0] 0
Write
1 Data
memory
Write
1
data data
Instr [15 - 0] Sign
RegDst
extend MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

13
(HY232)
Διοχέτευση Σημάτων Ελέγχου και Δεδομένων

Stage Control signals needed
EX ALUSrc ALUOp RegDst
MEM MemRead MemWrite PCSrc
WB RegWrite MemToReg
0 ID/EX
WB EX/MEM
PCSrc
Control M WB MEM/WB
IF/ID EX M WB
4 Add
P Add
C Shift
RegWrite left 2
Read Read
register 1 data 1 ALUZero MemWrite
Read Instruction Read Read
address [31-0] 0 Result Address
register 2 data 2
Write
Instruction Data MemToReg
register 1
memory Registers ALUOp memory
Write
data ALUSrc Write Read 1
data data
Instr [15 - 0] Sign RegDst
extend MemRead
Instr [20 - 16] 0
0
Instr [15 - 11]
1

14
(HY232)
Μερικές Παρατηρήσεις
• Συνήθως, όταν θέλουμε να γράψουμε σε έναν καταχωρητή (και
μόνον τότε) θέτουμε το αντίστοιχο WriteEnable=1.
– O PC γράφεται σε κάθε κύκλο μηχανής επειδή πάντα πρέπει να
δείχνουμε στην επόμενη εντολή και συνεπως πάντα
WriteEnable=1.
– Το ίδιο και για όλους τους καταχωρητές διοχέτευσης:
WriteEnable=1

15
(HY232)
Παράδειγμα εκτέλεσης εντολών

Διευθύνσεις 1000: lw $8, 4($29)
στο δεκαδικό 1004: sub $2, $4, $5
σύστημα 1008: and $9, $10, $11
1012: or $16, $17, $18
1016: add $13, $14, $0
• Υποθέτουμε ότι:
– Η αρχική τιμή κάθε καταχωρητή $Ν είναι Ν+100. Για παράδειγμα, ο $8
($t0) περιέχει την τιμή d’108.
– Αρχικά, όλες οι θέσεις μνήμης περιέχουν την τιμή 99.
– Το Χ στο διάγραμμα είναι Don’t Care.
– Τα ερωτηματικά ??? σημαίνει ότι η τιμή του σήματος είναι άγνωστη
– Παρατηρείστε ότι οι εντολές είναι ανεξάρτητες; δεν υπάρχουν εξαρτήσεις
μεταξύ καταχωρητών εξόδου μιας εντολής και εισόδου των επόμενων.
• Περισσότερα για αυτό στα επόμενα μαθήματα

16
(HY232)
Κύκλος 1 (γέμισμα)
IF: lw $8, 4($29) ID: ??? EX: ??? MEM: ??? WB: ???
1
0 ID/EX
WB EX/MEM
PCSrc Control M WB MEM/WB
IF/ID EX M WB
4
Add
P _____
Add
C Shift
RegWrite (?) left 2
??? ??? ???

1000 Read Read
register 1 data 1 MemWrite (?)
ALU
Read Instruction ??? ??? Zero
Read Read ??? ???
address [31-0] 0
??? Write ??? MemToReg
1 Data
Instruction register (?)
memory
memory ??? Registers ALUOp (???)
Write
???
data ALUSrc (?) ??? Write Read
1
data data
??? Sign ???
RegDst (?)
extend MemRead (?) ???
0
??? ???
0 ??? ??? ???
??? ???
1
???

17
(HY232)
IF: sub $2, $4, $5 ID: lw $8, 4($29) EX: ??? MEM: ??? WB: ???
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P 1008
Add
C Shift
RegWrite (?) left 2
rs___ ___ ???

1004 Read Read
ALU
Read Instruction rt___ Zero
Read Read ___ ???
???
address [31-0] 0
rd__ Write ??? MemToReg
1 Data
memory
memory ___ Registers ALUOp (???)
Write ???
data ALUSrc (?) ??? Write Read
1
data data
Imm____ Sign ???
RegDst (?) ???
extend MemRead (?)
0
rt____ ???
0 ??? ??? ???
rd____ ???
1
???

18
(HY232)
IF: and $9, $10, $11 ID: sub $2, $4, $5 EX: lw $8, 4($29) MEM: ??? WB: ???
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P 1012
Add
C Shift
RegWrite (?) left 2
4 104 ___
1008 Read Read
ALU
Read Instruction 5 __ Zero
Read Read 105 ???
address [31-0] 0
__
??? Write ___ MemToReg
1 Data
memory
memory ??? Registers ALUOp (___)
Write
??? Write ???
data ALUSrc (___) Read
1
data data
X Sign __
RegDst (___)
extend MemRead (?) ???
0
X __
0 ___ ??? ???
2 __
1
???

19
(HY232)
IF: or $16, $17, $18 ID: and $9, $10, $11 EX: sub $2, $4, $5 MEM: lw $8, 4($29) WB: ???
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P 1016
Add
C Shift
RegWrite (?) left 2
10 110 104
1012 Read Read
register 1 data 1 MemWrite (___)
ALU
Read Instruction 11 105 Zero
Read Read 111 ___
address [31-0] 0
–1
??? Write MemToReg
1 Data
memory
memory ??? Registers ALUOp (sub)
Write
___ ???
data ALUSrc (0) __ Write Read
1
data data
X Sign X
RegDst (1)
extend MemRead (___) ???
0
X X
0 2 ___ ???
9 2
1
???

20
(HY232)
Κύκλος 5
IF: add $13, $14, $0 ID: or $16, $17, $18 EX: and $9, $10, $11 MEM: sub $2, $4, $5 WB:
lw $8, 4($29)
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P 1020
Add
C Shift
RegWrite (___) left 2
17 117 110
1016 Read Read
register 1 data 1 MemWrite (0)
ALU
Read Instruction 18 111 Zero
Read Read 118 -1
address [31-0] 0
__ Write 110 MemToReg
1 Data
Instruction register (___)
memory
memory __ Registers ALUOp (and)
Write
X ___
data ALUSrc (0) 105 Write Read
1
data data
X Sign X
RegDst (1)
extend MemRead (0) ____
0
X X
0 9 2 ___
16 9
1
___

21
(HY232)
Κύκλος 6 (άδειασμα)
IF: ??? ID: add $13, $14, $0 EX: or $16, $17, $18 MEM: and $9, $10, $11 WB: sub
$2, $4, $5
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P ???
Add
C Shift
RegWrite (1) left 2
14 114 117
1020 Read Read
ALU
Read Instruction 0 0 118 Zero
Read Read 110
address [31-0] 0
2 Write 119 MemToReg
1 Data
Instruction register (0)
memory
memory -1 Registers ALUOp (or)
Write
X
1
data data
X Sign X
RegDst (1)
extend MemRead (0)
0
X X
0 16 9
13 16
1

IF: ??? ID: ??? EX: add $13, $14, $0 MEM: or $16, $17, $18 WB: and
$9, $10, $11
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P ???
Add
C Shift
RegWrite (1) left 2
??? ??? 114

??? Read Read
ALU
Read Instruction ??? 0 Zero
Read Read ??? 119
address [31-0] 0
9 Write 114 MemToReg
1 Data
memory
memory 110 Registers ALUOp (add)
Write
X X
1
data data
??? Sign X
RegDst (1)
extend MemRead (0) 110
0
??? X
0 13 16 9
??? 13
1
110

23
(HY232)
IF: ??? ID: ??? EX: ??? MEM: add $13, $14, $0 WB: or $16,
$17, $18
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P ???
Add
C Shift
RegWrite (1) left 2
??? ??? ???

??? Read Read
ALU
Read Read ??? 114
address [31-0] 0
16 Write ??? MemToReg
1 Data
memory
memory 119 Registers ALUOp (???)
Write
X X
data ALUSrc (?) 0 Write Read
1
data data
??? Sign ???
RegDst (?)
extend MemRead (0) 119
0
??? ???
0 ??? 13 16
??? ???
1
119

24
(HY232)
IF: ??? ID: ??? EX: ??? MEM: ??? WB: add
$13, $14, $0
1
0 ID/EX
WB EX/MEM
IF/ID EX M WB
4
Add
P ???
Add
C Shift
RegWrite (1) left 2
??? ??? ???

??? Read Read
ALU
Read Read ??? ???
address [31-0] 0
13 Write ??? MemToReg
1 Data
memory
memory 114 Registers ALUOp (???)
Write
X X
data ALUSrc (?) ? Write Read
1
data data
??? Sign ???
RegDst (?)
extend MemRead (?) 114
0
??? ???
0 ??? ??? 13
??? ???
1
114

25
(HY232)
Προσοχή
Τα πάντα κινούνται από αριστερά στα δεξιά εκτός:
1. Της απόφασης διακλάδωσης
2. Του 1Write Back
0
PCSrc
4 Add
P Add
Shift
C
RegWrite left 2
Read Read
ALU
Read Read
address [31-0] 0
Write
Data
Instruction register 1 MemToReg
Registers ALUOp memory
memory Write
1
data data
Instr [15 - 0] Sign
RegDst
extend MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

26
(HY232)
Πιο συμβολικά
Κύκλος ρολογιού
1 2 3 4 5 6 7 8 9
sub $v0, $a0, $a1 IF ID EX MEM WB
and $t1, $t2, $t3 IF ID EX MEM WB
or $s0, $s1, $s2 IF ID EX MEM WB
add $t5, $t6, $0 IF ID EX MEM WB
Στον κύκλο 5 ο επεξεργαστής έχει γεμίσει: υπάρχουν τόσες εντολές εν

πτήση όσα και τα στάδια της διοχέτευσης
Από εδώ και πέρα θα εξετάσουμε τα προβλήματα που μπορεί να

δημιουργήσει η μέθοδος της διοχέτευσης και πως αυτά επιλύονται.

27
(HY232)
Διάλεξη 11
Προώθηση (Forwarding)
Η μέχρι τώρα μικρο-αρχιτεκτονική του MIPS
1
0
ID/EX
WB EX/MEM
PCSrc
Control M WB MEM/WB
IF/ID EX M WB
4
Add
P Add
C
RegWrite <<2
Read Read
ALU
Read Read
address [31-0] 0
Write
1 Data
memory
Write
1
data data
Instr [15 - 0] Sign
RegDst
extend MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

2
(HY232)
Διάγραμμα Διοχέτευσης
Κύκλοι μηχανής
1 2 3 4 5 6 7 8 9
lw $8, 4($29) IF ID EX MEM WB
sub $2, $4, $5 IF ID EX MEM WB CPI = 1

and $9, $10, $11 IF ID EX MEM WB
or $16, $17, $18 IF ID EX MEM WB
add $13, $14, $0 IF ID EX MEM WB
• Η μικρο-αρχιτεκτονική που έχουμε αναλύσει μέχρι τώρα δείχνει μια

απλουστευμένη κατάσταση.
– Κάθε εντολή χρειάζεται 5 κύκλους εκτέλεσης.
– Μία εντολή ξεκινάει σε κάθε κύκλο μηχανής
– Μία εντολή τερματίζει σε κάθε κύκλο μηχανής (CPI=1)
3
(HY232)
Η σειρά των εντολών είναι πολύ απλή
1000: lw $8, 4($29)

1004: sub $2, $4, $5
1008: and $9, $10, $11
1012: or $16, $17, $18
1016: add $13, $14, $0
• Έχουμε κάνει κάποιες παραδοχές για την ακολουθία των

εντολών που δυστυχώς δεν ισχύουν πάντα
– Δεν υπάρχει εξάρτηση μεταξύ των δεδομένων που γράφει μια
εντολή και των δεδομένων που μια επόμενη εντολή διαβάζει.
– Αυτό είναι ιδανική περίπτωση και δεν συμβαίνει συχνά
– Πολλές ακολουθίες αποτελούνται από εξαρτημένες εντολές

4
(HY232)
Παράδειγμα με εξαρτημένες εντολές

sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
• H πρώτη εντολή (sub)γράφει στον καταχωρητή $2
• Ο καταχωρητής $2 χρησιμοποιείται από εκεί και πέρα ως
είσοδος στις επόμενες εντολές
• Αυτό δεν είναι πρόβλημα στην υλοποίηση ενός κύκλου.
– Κάθε εντολή εκτελείται σε ένα κύκλο και η επόμενη παίρνει τα
δεδομένα κανονικά από τον καταχωρητή $2
• Αλλά τι ακριβώς συμβαίνει στην μικρο-αρχιτεκτονική
διοχέτευσης;

5
(HY232)
Κίνδυνος Δεδομένων (Data Hazards)
1 2 3 4 5 6 7 8 9
sub $2, $1, $3 IF ID EX MEM WB
sw $15, 100($2) IF ID EX MEM WB

• H εντολή sub γράφει στον καταχωρητή $2 στον κύκλο 5. Αυτό
δημιουργεί data hazards στην μικρο-αρχιτεκτονική διοχέτευσης.
– H εντολή and διαβάζει τον καταχωρητή $2 στον κύκλο 3. Αφού η εντολή
sub δεν έχει ακόμα γράψει τον $2, η and θα διαβάσει τα παλιά δεδομένα
του καταχωρητή $2
– H εντολή or διαβάζει τον καταχωρητή $2 στον κύκλο 4, παίρνοντας επίσης
την παλιά του τιμή.
– Από εκεί και πέρα τα πράγματα δουλεύουν εντάξει. Οι επόμενες δύο εντολές
εκτελούνται όταν η sub τελειώσει 6
Οργάνωση και Σχεδίαση Η/Υ (HY232)
Κίνδυνος Δεδομένων (Data Hazards)

1 2 3 4 5 6 7 8 9
sw $15, 100($2) IF ID EX MEM WB
• Τα βέλη δείχνουν την ροή των δεδομένων μεταξύ των εντολών

– Η αρχή του βέλους δείχνει πότε γράφεται ο καταχωρητής $2
– Το τέλος του βέλους δείχνει πότε διαβάζεται ο καταχωρητής $2
• Όταν ένα βέλος δείχνει πίσω στον χρόνο αυτό σημαίνει ότι υπάρχει
κίνδυνος δεδομένων (data hazard).
– Κόκκινα βέλη στο σχήμα
7
(HY232)
Ακόμα ένα διάγραμμα
1 2 3 4 5 6 7 89
IM Reg DM Reg
sub $2, $1, $3
and $12, $2, $5 IM Reg DM Reg
or $13, $6, $2 IM Reg DM Reg
add $14, $2, $2 IM Reg DM Reg
sw $15, 100($2) IM Reg DM Reg

8
(HY232)
Κίνδυνοι δεδομένων
• Είναι αναγκαίο να απαλειφθούν οι κίνδυνοι δεδομένων ώστε οι
εντολές and και or να χρησιμοποιήσουν την πραγματική τιμή
του καταχωρητή $2. Αλλιώς η μικρο-αρχιτεκτονική μας είναι λάθος
• Πότε ακριβώς δημιουργείται η νέα τιμή του καταχωρητή $2 από την
εντολή sub;
– Στο τέλος του σταδίου EX στον κύκλο 3
• Πότε ακριβώς χρειάζεται η νέα τιμή του καταχωρητή $2 από την
εντολές and και or;
– Στο στάδιο EX στους κύκλους 4 και 5
Clock cycle
1 2 3 4 5 6 7

9
(HY232)
Προώθηση δεδομένων (Forwarding)
• Το αποτέλεσμα $1-$3 υπολογίζεται στο τέλος του σταδίου EX στον κύκλο 3 πριν
χρειαστεί στους κύκλους 4 και 5
• Προωθούμε αυτό το αποτέλεσμα στις επόμενες εντολές με την χρήση των
καταχωρητών διοχέτευσης:
– Η and λαμβάνει την τιμή $1-$3 από τον καταχωρητή διοχέτευσης EX/MEM
στον κύκλο 4.
– Η or λαμβάνει την τιμή $1-$3 από τον καταχωρητή διοχέτευσης MEM/WB
στον κύκλο 5.
1 2 3 4 5 6 7
IM Reg DM Reg
sub $2, $1, $3
Προώθηση δεδομένων (Forwarding)

• Οι καταχωρητές διοχέτευσης IF/ID, ID/EX, EX/MEM, MEM/WB
χρησιμεύουν:
– για να αποθηκεύουν ενδιάμεσα αποτελέσματα στο τέλος κάθε σταδίου, ΚΑΙ
– για να προωθούν δεδομένα στις αμέσως επόμενες εντολές πριν αυτά τα
δεδομένα γραφούν σε καταχωρητές
PC ALU output
available here
ALU
Registers
Instruction
memory
Data
memory
Rt 0
0
Rd
1

Μονάδα Προώθησης (Forwarding Unit)
• Η μονάδα προώθησης επιλέγει σε κάθε κύκλο μηχανής την σωστή
είσοδο της ALU στο στάδιο EX:
– Εάν δεν υπάρχει κίνδυνος δεδομένων, οι είσοδοι της ALU προέρχονται από τους
καταχωρητές, όπως έχουμε δει
– Εάν υπάρχει κίνδυνος δεδομένων, ένας ή δύο είσοδοι προέρχονται από τους
καταχωρητές διοχέτευσης EX/MEM ή MEM/WB
• Δύο νέοι πολυπλέκτες χρησιμοποιούνται (ForwardA και ForwardB) για
να επιλέξουν τις εισόδους της ALU
IM Reg DM Reg
sub $2, $1, $3
Datapath με προώθηση δεδομένων
PC
0
1
2
Registers ForwardA
Instruction ALU
memory 0
1 Data
2 memory
1
ForwardB
Rt 0
0
Rd
1

13
(HY232)
Καθορισμός κινδύνων δεδομένων EX/MEM
• Πως καθορίζουμε ότι υπάρχει κίνδυνος δεδομένων;
• Ποιος είναι ο μηχανισμός που χρησιμοποιεί το hardware για να το
ανακαλύψει;
• Κίνδυνος δεδομένων EX/MEM υφίσταται μεταξύ μιας εντολής στο
στάδιο EX (and) και της αμέσως προηγούμενης εντολής (sub) ,
εφόσον:
1. Η αμέσως προηγούμενη εντολή (sub) γράφει σε κάποιον καταχωρητή , και
2. αυτός ο καταχωρητής είναι είσοδος στην ALU της εντολής (and) στο στάδιο
EX.
• Ο συμβολισμός ID/EX.RegisterRt σημαίνει το πεδίο rt στον
καταχωρητή διοχέτευσης ID/EX.
IM Reg DM Reg
sub $2, $1, $3

14
(HY232)
Εξισώσεις EX/MEM
• Εξίσωση για την πρώτη είσοδο της ALU
if (EX/MEM.RegWrite = 1 and
EX/MEM.RegisterRd != 0 and
EX/MEM.RegisterRd = ID/EX.RegisterRs)
then ForwardA = 2
• Εξίσωση για την δεύτερη είσοδο της ALU
if (EX/MEM.RegWrite = 1 and
EX/MEM.RegisterRd != 0 and
EX/MEM.RegisterRd = ID/EX.RegisterRt)
then ForwardB = 2
IM Reg DM Reg
sub $2, $1, $3

15
(HY232)
Καθορισμός κινδύνων δεδομένων ΜΕΜ/WB
• Κίνδυνος δεδομένων MEM/WB μπορεί να υφίσταται μεταξύ μιας εντολής στο
στάδιο EX (sub) και μιας εντολής δύο κύκλους πριν (add).
• Ένα ενδιαφέρον πρόβλημα είναι να γράφουμε έναν καταχωρητή σε διαδοχικές
εντολές
add $1, $2, $3
add $1, $1, $4
sub $5, $5, $1
• Ο καταχωρητής $1 γράφεται από δύο διαδοχικές εντολές. Η τρίτη εντολή (sub)
πρέπει να χρησιμοποιήσει τα δεδομένα της εντολής αμέσως από πάνω (δεύτερη
add)
IM Reg DM Reg
add $1, $2, $3
sub $5, $5, $1 IM Reg DM Reg

16
(HY232)
Εξισώσεις MEM/WB
• Εξίσωση MEM/WB για την πρώτη είσοδο της ALU

if (MEM/WB.RegWrite = 1 and
MEM/WB.RegisterRd != 0 and
MEM/WB.RegisterRd = ID/EX.RegisterRs and
(EX/MEM.RegisterRd ≠ ID/EX.RegisterRs or EX/MEM.RegWrite = 0)
then ForwardA = 1
• Εξίσωση MEM/WB για την δεύτερη είσοδο της ALU

if (MEM/WB.RegWrite = 1 and
MEM/WB.RegisterRd != 0 and
MEM/WB.RegisterRd = ID/EX.RegisterRt and
(EX/MEM.RegisterRd ≠ ID/EX.RegisterRt or EX/MEM.RegWrite = 0)
then ForwardB = 1

17
(HY232)
Απλοποιημένο datapath με προώθηση
PC
0
1
2
ForwardA
Registers
Instruction ALU
memory 0
1 Data
2 memory
1
ForwardB
Rt 0
0
Rd
1 EX/MEM.RegisterRd
Rs ID/EX.
RegisterRt
Forwarding
EX/MEM.RegWrite
Unit MEM/WB.RegisterRd
ID/EX.
MEM/WB.RegWrite
RegisterRs

18
(HY232)
Παράδειγμα εκτέλεσης στην νέα μικρο-

αρχιτεκτονική
sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $15, 100($2)
• Θεωρούμε πάλι ότι η αρχική τιμή κάθε καταχωρητή $Ν είναι

N+100
– Μετά την πρώτη εντολή ο καταχωρητής $2 ισούται με -2
– Οι υπόλοιπες εντολές θα πρέπει να χρησιμοποιήσουν το -2 σαν
μία από τις εισόδους τους

19
(HY232)
Κύκλος 3
IF: or $13, $6, $2 ID: and $12, $2, $5 EX: sub $2, $1, $3
PC
101
2 0
102 101
1
2
5
0
Registers
Instruction ALU
103
memory X 105 0
103
1 -2 Data
X 2 memory
1
0
5 (Rt) 0
0
12 (Rd) 2
2
1 EX/MEM.RegisterRd
2 (Rs) ID/EX.
RegisterRt
Forwarding
3
Unit
ID/EX. 1 MEM/WB.RegisterRd
RegisterRs

20
(HY232)
Κύκλος 4. Προώθηση από

καταχωρητή EX/MEM
IF: add $14, $2, $2 ID: or $13, $6, $2 EX: and $12, $2, $5 MEM: sub $2, $1, $3
PC
102
6 0
106 -2
1
2
2
2
Registers
Instruction ALU -2
105
memory X 102 0
105
1 104
Data
X 2 memory
1
0
2 (Rt) 0
0
12
13 (Rd) 12
1 EX/MEM.RegisterRd
6 (Rs) ID/EX.
RegisterRt
2
Forwarding
5
Unit
2 MEM/WB.RegisterRd
ID/EX.
RegisterRs
-2

21
(HY232)
Κύκλος 5. Προώθηση από
καταχωρητή MEM/WB
IF: sw $15, 100($2) ID: add $14, $2, $2 EX: or $13, $6, $2 MEM: and $12, $2, $5 WB: sub
$2, $1, $3
PC
106
2 0
-2 106
1
2
2
0
Registers
Instruction ALU 104
102
memory 2 -2 0
-2
1 -2
Data
-2 2
-2 memory
X
1
-2
1
2 (Rt) 0
0
13
14 (Rd) 13
1 EX/MEM.RegisterRd 2
2 (Rs) ID/EX.
RegisterRt
12
Forwarding
2 Unit
ID/EX. 6 2 MEM/WB.RegisterRd
RegisterRs
104
-2

22
(HY232)
Η μικρο-αρχιτεκτονική μας μέχρι τώρα

ID/EX
WB EX/MEM
Control M WB MEM/WB
IF/ID EX M WB
PC
Read Read 0
register 1 data 1 1
Addr Instr 2
Read ALU
register 2 Zero
ALUSrc
Write Read Result Address
0
Instruction register data 2
1 0 Data
memory
Write Registers 2 memory
data 1
Write Read
Instr [15 - 0] 1
RegDst data data
Extend
Rt 0
0
Rd
1 EX/MEM.RegisterRd
Rs
Forwarding
Unit
MEM/WB.RegisterRd

23
(HY232)
Τι συμβαίνει με τις εντολές store
• Δύο απλές περιπτώσεις:
1 2 3 4 5 6
1 2 3 4 5 6

24
(HY232)
Προώθηση με την store (I)

EX: sw $4, 0($1) MEM: add $1, $2, $3
PC
Read Read 0
register 1 data 1 1
Addr Instr 2
Read ALU
register 2 2 Zero
ALUSrc
0
1 0 Data
memory
data 1
Write Read
Instr [15 - 0] 1
RegDst data data
Extend
Rt 0
0
Rd
1 EX/MEM.RegisterRd
Rs
1
Forwarding
Unit
ID/EX.
1
RegisterRs
MEM/WB.RegisterRd
Ακριβώς η ίδια
περίπτωση εάν έχουμε
loads (HY232)
25
Προώθηση με την store (IΙ)
EX: sw $1, 0($4) MEM: add $1, $2, $3
PC
Read Read 0
register 1 data 1 1
Addr Instr 2
Read ALU
register 2 Zero
ALUSrc
0
1 0 Data
memory
data 1
Write Read
Instr [15 - 0] 1
RegDst data data
Extend
Rt 2 0
0 0
Rd
1 EX/MEM.RegisterRd
Rs
1
1
Forwarding
Unit
MEM/WB.RegisterRd

26
(HY232)
Τι συμβαίνει με τις εντολές store (III)

• Πιο δύσκολη περίπτωση όταν η store ακολουθεί μια load εντολή:
1 2 3 4 5 6
lw $1, 0($2) IM Reg DM Reg
• Η lw παράγει τα δεδομένα της στο τέλος του σταδίου 4.

• Η sw χρειάζεται τον $1 στην αρχή του σταδίου 5.
• Η lw δημιουργεί συνήθως την ανάγκη οι επόμενες εντολές να
καθυστερήσουν (βλέπε επόμενο μάθημα)
– Σε αυτήν όμως την συγκεκριμένη περίπτωση μπορούμε να το απoφύγουμε
αυτό. Χρειάζεται αλλαγή όμως στο datapath
27
(HY232)
lw $1, 0($2)
Αλληλουχία lw-sw
sw $1, 0($4)
ForwardC
IF/ID ID/EX EX/MEM 0 MEM/WB
PC 1
Read Read 0
register 1 data 1 1
Addr Instr 2
Read ALU
register 2 Zero
ALUSrc
0
1 0 Data
memory
data 1
Write Read
Instr [15 - 0] data data 1
RegDst
Extend
Rt 0
0
Rd
1 EX/MEM.RegisterRd
Rs
Forwarding
Αυτή όμως η Unit
αλληλουχία;
MEM/WB.RegisterRd
lw $1, 0($2)
sw $2, 0($1)
28
(HY232)
Η συνολική εικόνα
• H απλότητα της αρχιτεκτονικής MIPS κάνει το πρόβλημα της
προώθησης πολύ εύκολο.
• Κάθε εντολή MIPS μπορεί να γράψει το πολύ σε έναν καταχωρητή
– Αυτή η ιδιότητα απλουστεύει πολύ την σχεδίαση της μονάδας προώθησης
μιας και υπάρχει μόνο ένας καταχωρητής προορισμού που πρέπει να
προωθηθεί.
• Η προώθηση είναι πολύ σημαντική σε μικρο-αρχιτεκτονικές με
πολλά στάδια διοχέτευσης (super-pipelining)
– Η σύγχρονοι επεξεργαστές έχουν 20+ στάδια διοχέτευσης
– Γιατί τόσα πολλά;

29
(HY232)
Διάλεξη 12
Καθυστερήσεις (Stalls)
Εκκενώσεις Εντολών (Flushing)
Καθυστερήσεις και Εκκενώσεις Εντολών

• Οι δομικοί κίνδυνοι (data hazards), όπως είδαμε, συμβαίνουν
όταν εντολές εξαρτώνται από άλλες εντολές που βρίσκονται
ακόμα προς εκτέλεση στο pipeline.
– Πολλοί τέτοιοι κίνδυνοι μπορούν να επιλυθούν μέσω της προώθησης
δεδομένων από τους καταχωρητές διοχέτευσης στην ALU; Αντί να
περιμένουμε τα δεδομένα αυτά να γραφούν πρώτα στους καταχωρητές .
– Το πλεονέκτημα είναι ότι η προώθηση επιτρέπει ο επεξεργαστής να τρέχει
με πλήρη ταχύτητα.
• Σήμερα θα δούμε κάποια πραγματικά προβλήματα στην
μικρο-αρχιτεκτονική διοχέτευσης που επηρεάζουν την
ταχύτητα του επεξεργαστή .
– Η προώθηση από εντολές load δεν είναι πάντα αποδοτικές.
– Οι εντολές διακλάδωσης επηρεάζουν την εκτέλεση των επόμενων εντολών.
• Σε αυτές τις δύο περιπτώσεις θα πρέπει ίσως να
καθυστερήσουμε την εκτέλεση του προγράμματος ή να
εκκενώσουμε μέρος του pipeline από εκτελούμενες εντολές
2
(HY232)
Κίνδυνος Δεδομένων (Data Hazard)
• Κίνδυνος δεδομένων συμβαίνει εάν μια εντολή χρειάζεται
δεδομένα που δεν είναι ακόμα έτοιμα στους καταχωρητές.
– Οι εντολές and και or χρειάζονται τον καταχωρητή $2 στον 3ο και 4ο
κύκλο, αντίστοιχα.
– Όμως ο $2 γράφεται μόλις στον 5ο κύκλο από την εντολή sub.
1 2 3 4 5 6 7
IM Reg DM Reg
sub $2, $1, $3

3
(HY232)
Προώθηση Δεδομένων
• Η τελική τιμή του καταχωρητή $2 ($1 - $3) έχει ήδη υπολογιστεί
από τον κύκλο 3 (στάδιο EX) , απλά δεν έχει γραφεί ακόμα στον $2.
• Η προώθηση δεδομένων επιτρέπει δεδομένα να τροφοδοτούνται
μέσω των καταχωρητών διοχέτευσης κατευθείαν στην ALU χωρίς
την ανάγκη να διαβαστεί ο καταχωρητής.
1 2 3 4 5 6 7
IM Reg DM Reg
sub $2, $1, $3

4
(HY232)
Εντολές load?
• Τι θα συνέβαινε εάν η πρώτη εντολή ήταν lw;
– Η εντολή lw παράγει δεδομένα στο τέλος του κύκλου 4 στο στάδιο MEM
– Αλλά η and χρειάζεται αυτά τα δεδομένα στην αρχή του ίδιου κύκλου!
• Αυτό είναι ένας πραγματικός κίνδυνος δεδομένων. Δεν μπορούμε
να προωθήσουμε τα δεδομένα μέσω των καταχωρητών
διοχέτευσης, όπως πριν.
Κύκλος Μηχανής
1 2 3 4 5 6
IM Reg DM Reg
lw $2, 20($3)

5
(HY232)
Καθυστέρηση (Stall)
• H λύση είναι να καθυστερήσουμε το pipeline για έναν κύκλο
• Μπορούμε να καθυστερήσουμε την εντολή and με το να τοποθετήσουμε μία
φυσαλίδα (bubble) ενός κύκλου.
• Αυτό θα καθυστερήσει την and και όλες τις εντολές μετά από αυτήν κατά ένα
κύκλο.
1 2 3 4 5 6 7
IM Reg DM Reg
lw $2, 20($3)
• Μετά από αυτό, χρησιμοποιούμε τον καταχωρητή διοχέτευσης MEM/WB για να

στείλουμε τα δεδομένα που διαβάζει η lw από την μνήμη στην ALU.

6
(HY232)
Καθυστέρηση και Προώθηση
1 2 3 4 5 6 7 8
IM Reg DM Reg
lw $2, 20($3)
• Η προώθηση μειώνει τον χρόνο καθυστέρησης από 2 σε 1 κύκλο

μηχανής

7
(HY232)
Η καθυστέρηση αφορά όλο το pipeline

• Η καθυστέρηση της εντολής and σημαίνει και την καθυστέρηση
και της or. Καθώς και όλων των άλλων εντολών που ακολουθούν.
– Δεν μπορούμε να έχουμε δύο εντολές στο ίδιο στάδιο τoυ pipeline.
– Δεν μπορεί επίσης η or να ξεπεράσει την and και να τελειώσει πριν από
αυτήν
1 2 3 4 5 6 7 8
IM Reg DM Reg
lw $2, 20($3)

8
(HY232)
Υλοποίηση καθυστερήσεων
• Υλοποιούμε την καθυστέρηση (stall) με το να μπλοκάρουμε τις εντολές που είναι
στα σταδία ID και ΙF.
Clock cycle
1 2 3 4 5 6 7 8
IM Reg DM Reg
lw $2, 20($3)
and $12, $2, $5 IM Reg Reg DM Reg
or $13, $12, $2 IM IM Reg DM Reg
• Αυτό υλοποιείται με το να:

– αφήσουμε την τιμή του PC την ίδια, ώστε να μην διαβαστεί άλλη εντολή.
– να μην αλλάξουμε την τιμή του καταχωρητή IF/ID, ώστε να μην αλλάξει η εντολή στο στάδιο
ID.

9
(HY232)
Στάδια EX, MEM, WB

• Μένει μόνο να δούμε πως θα υλοποιηθεί η φυσαλίδα. Δηλαδή το στάδιο EX στον
κύκλο 4, το στάδιο ΜΕΜ στον κύκλο 5, και το στάδιο WB στον κύκλο 6.
Κύκλος Μηχανής
1 2 3 4 5 6 7 8
IM Reg DM Reg
lw $2, 20($3)
and $12, $2, $5 IM Reg Reg DM Reg
or $13, $12, $2 IM IM Reg DM Reg
• H φυσαλίδα (bubble) υλοποιείται με το να θέσουμε σε αυτό το στάδιο την εντολή

να είναι nop. Με άλλα λόγια να θέσουμε τα σήματα ελέγχου στο 0, για να
αποκλείσουμε να γίνει κάποια εγγραφή σε καταχωρητή ή μνήμη κατά λάθος.

10
(HY232)
Ανίχνευση Καθυστερήσεων
lw $2, 20($3)
mem\wb
ex/mem
id/ex
and $12, $2, $5
if/id
if/id
IM Reg Reg DM Reg
• H ανίχνευση της καθυστέρησης γίνεται όταν η εντολή lw είναι στο EX στάδιο και η
επόμενη εξαρτώμενη εντολή (and)είναι στο ID στάδιο.
• Καθυστέρηση υπάρχει όταν η εντολή στο EX στάδιο είναι LOAD
ID/EX.MemRead = 1
και ο προορισμός του LOAD είναι ένας από τους καταχωρητές εισόδου της επόμενης
εντολής (στο ID στάδιο).
ID/EX.RegisterRt = IF/ID.RegisterRs
or
ID/EX.RegisterRt = IF/ID.RegisterRt
• Συνοπτικά:
if (ID/EX.MemRead = 1 and
(ID/EX.RegisterRt = IF/ID.RegisterRs or
ID/EX.RegisterRt = IF/ID.RegisterRt))
then stall
H μονάδα ελέγχου κινδύνων (Hazard Unit)

είναι στο στάδιο ID
ID/EX.MemRead
Hazard
Unit ID/EX.RegisterRt
IF/ID Write
ID/EX
PC Write
Rs Rt 0 0 WB EX/MEM
M WB MEM/WB
Control 1
EX M WB
PC
IF/ID
Read Read 0
register 1 data 1 1
Addr Instr 2
Read ALU
register 2 Zero
ALUSrc
0
1 0 Data
memory
data 1
Write Read
Instr [15 - 0] 1
RegDst data data
Extend
Rt 0
0
Rd
1 EX/MEM.RegisterRd
Rs
Forwarding
Unit
MEM/WB.RegisterRd

Μονάδα ελέγχου κινδύνων (Hazard Unit)
• To stall της προηγούμενης εξίσωσης είναι η δημιουργία

τριών επιπλέον σημάτων.
– Δύο νέα σήματα ελέγχου PCWrite και IF/ID Write που ουσιαστικά
είναι Write Enable σήματα του PC και του καταχωρητή IF/ID,
αντίστοιχα.
– Ένα mux select σήμα σε έναν νέο καταχωρητή ο οποίος θέτει όλα
τα σήματα ελέγχου του ID/EX στο 0, όταν γίνει ανίχνευση
καθυστέρησης. Εδώ ουσιαστικά γίνεται η δημιουργία της
εντολής nop.

14
(HY232)
Να μια καλή ερώτηση

• Έστω ότι η προσπέλαση της μνήμης είναι πολύ αργή και
χρειάζεται 2 κύκλους μηχανής.
1 2 3 4 5 6
IM Reg DM Reg
• Ποιες από τις παρακάτω εντολές χρειάζονται προώθηση ή/και

καθυστέρηση;
• Πόσες εισόδους θα έχουν οι πολυπλέκτες στο στάδιο EX;
lw r13, 0(r11) IF ID EX M1 M2 WB
add r7, r8, r9 IF ID EX M1 M2 WB
add r15, r7, r13 IF ID ID EX M1 M2 WB

15
(HY232)
Τι μπορεί να κάνει ο Compiler ή ο
προγραμματιστής assembly
• Χώρισε τις εντολές LOAD από τις εντολές που εξαρτώνται από αυτές με
αρκετές ανεξάρτητες εντολές ώστε να μην υπάρχει πρόβλημα
καθυστέρησης
• Κλασσική βελτιστοποίηση του compiler είναι να προγραμματίσει όλες
τις εντολές LOAD στην αρχή του κώδικα.
lw $t1, 0($t0) lw $t1, 0($t0)

lw $t2, 4($t0) lw $t2, 4($t0)
stall add $t3, $t1, $t2 lw $t4, 8($t0)
sw $t3, 12($t0) add $t3, $t1, $t2
lw $t4, 8($t0) sw $t3, 12($t0)
stall add $t5, $t1, $t4 add $t5, $t1, $t4
sw $t5, 16($t0) sw $t5, 16($t0)
13 κύκλοι 11 κύκλοι
Η μέχρι τώρα μικρο-αρχιτεκτονική

(Προώθηση, Καθυστέρηση, Εκκένωση) ID/EX.MemRead
PC Write
Hazard
Unit ID/EX.RegisterRt
IF/ID Write
ID/EX
Rs Rt 0 0 WB EX/MEM
M WB MEM/WB
Control 1
EX M WB
PC
IF/ID
Read Read 0
register 1 data 1 1
Addr Instr 2
Read ALU
register 2 Zero
ALUSrc
0
1 0 Data
memory
data 1
Write Read
Instr [15 - 0] 1
RegDst data data
Extend
Rt 0
0
Rd
1 EX/MEM.RegisterRd
Rs
Forwarding
Unit
MEM/WB.RegisterRd

17
(HY232)
Η μέχρι τώρα μικρο-αρχιτεκτονική
(Eντολές Διακλάδωσης)
Η μικρο-αρχιτεκτονική μας παίρνει απόφαση για την κατεύθυνση και τον προορισμό
της εντολής beq στο στάδιο MEM στον κύκλο 4.
1
0 ID/EX
WB EX/MEM
PCSrc M WB
Control MEM/WB
IF/ID EX M WB
4 Branch
Add
P Add Zero PCSrc
C
RegWrite << 2
Read Read
register 1 data 1 Zero MemWrite
ALU
Read Instruction Read
address [31-0] register 2 0
Read Result Address
data 2
Write
register Data
Instruction 1 MemToReg
memory Write
data
ALUSrc Write Read
1
data data
Sign
extend RegDst
MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

18
(HY232)
Κίνδυνοι Ελέγχου (Control Hazards)

Η μικρο-αρχιτεκτονική
μας παίρνει απόφαση
για την κατεύθυνση της
εντολής beq στο στάδιο
MEM στον κύκλο 4.
Αλλά πρέπει να ξέρουμε

αυτήν απόφαση πιο
νωρίς για να φέρουμε
την σωστή επόμενη
εντολή.
Αλλιώς, αντί να φέρουμε

την lw εάν η εντολή
beq είναι TAKEN, θα
φέρουμε την and

Καθυστέρηση (Stalling)
• Μία λύση είναι να καθυστερήσουμε το pipeline κατά 3 κύκλους
μέχρι να πάρουμε την απόφαση για το αποτέλεσμα της εντολής
διακλάδωσης
1 2 3 4 5 6 7 8
beq $1, $3, 28 IM Reg DM Reg
? ? ? IM Reg DM Reg
• Στην συγκεκριμένη περίπτωση, θα πρέπει να δημιουργήσουμε 3

εντολές nop ώστε στην συνέχεια να φέρουμε την σωστή εντολή
από την μνήμη.
• Τρείς κύκλοι κάθε φορά που έχουμε εντολή διακλάδωσης είναι
πολλοί. Μπορούμε να τους μειώσουμε;
20
(HY232)
Μείωση των κύκλων καθυστέρησης

• Η εκτέλεση μιας εντολής διακλάδωσης (beq rs, rt, Label) απαιτεί
δύο πράγματα:
• Τον υπολογισμό της διεύθυνσης προορισμού: PC <= Label
• Την απόφαση για το εάν η εντολή διακλάδωσης είναι TAKEΝ ή NOT TAKEN
• Και οι δύο αυτοί υπολογισμοί πρέπει να γίνουν νωρίτερα (δηλ. να
μεταφερθούν πιο πριν στο pipeline) για να μπορέσουμε να μειώσουμε
την ποινή της καθυστέρησης. Θα μεταφέρουμε και τους δύο αυτούς
υπολογισμούς στο στάδιο ID.
• O υπολογισμός της διεύθυνσης προορισμού μπορεί εύκολα να μεταφερθεί από το
στάδιο EX στο στάδιο ID με το να μεταφέρουμε την μικρή ALU και το left shift by 2.
• Η απόφαση για την διακλάδωση μπορεί να γίνει με επιπλέον hardware που απλά θα
ελέγχει εάν οι 2 καταχωρητές rs και rt που μόλις διαβάστηκαν από το register file
είναι ίσοι.
• Αυτό γίνεται απλά με 32 πύλες XOR. Μπορεί όμως να αυξήσει την περίοδο του
ρολογιού.

21
(HY232)
Nέο pipeline για μικρότερο penalty στις εντολές διακλάδωσης
Τι θα γίνει εάν έχουμε τις εντολές
sub $2, $1, $3
beq $4, $2, L
1 Πιο πολύπλοκη πρoώθηση και ένας
Zero
0 ID/EX κύκλος stall!
WB EX/MEM
PCSrc M WB
Control MEM/WB
IF/ID EX M WB
4
Add
P Add
C << 2
RegWrite
Read Read
register 1 data 1
MemWrite
ALU
Read Instruction
address [31-0]
Read
register 2
= 0
Read Result Address
data 2
Write
register Data
memory Write
data
ALUSrc Write Read
1
data data
Sign
extend RegDst
MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1
Πρόβλεψη διακλάδωσης
• Αφού μειώσαμε τους κύκλους καθυστέρησης από 3 σε 1 ας δούμε πως
μπορούμε να μειώσουμε ακόμα περαιτέρω τους κινδύνους ελέγχου
• Μπορούμε να “μαντέψουμε” την απόφαση της διακλάδωσης με διάφορους
τρόπους
– Η πιο απλή προσέγγιση είναι να θεωρήσουμε ότι η διακλάδωση είναι πάντα NOT
TAKEN.
– Απλά αύξησε τον PC<=PC+4 και φέρε την επόμενη εντολή ως σαν να μην είχαμε
διακλάδωση
• Εάν αποδειχθούμε σωστοί, τότε το pipeline προχωράει full speed χωρίς καμία
απολύτως καθυστέρηση.
1 2 3 4 5 6 7
beq $2, $3, Label IM Reg DM Reg
επόμενη εντολή 1 IM Reg DM Reg
IM Reg DM Reg
επόμενη εντολή 2

23
(HY232)
Πρόβλεψη διακλάδωσης
• Εάν η υπόθεσή μας είναι λάθος και η διακλάδωση είναι TAKEN, τότε θα έχουμε
φέρει λάθος εντολή.
1. Θα πρέπει να κάνουμε flush την εντολή αυτή και να βάλουμε στην θέση της μια
εντολή nop. Το flush γίνεται στον καταχωρητή IF/ID
2. Θα πρέπει επίσης να αλλάξουμε τον PC ώστε να αρχίσουμε αμέσως μετά να
διαβάζουμε εντολές από την διεύθυνση μνήμης Label.
• Σε αυτήν την περίπτωση θα έχουμε έναν κύκλο καθυστέρηση
1 2 3 4 5 6 7 8
beq $2, $3, Label IM Reg DM Reg
next instruction 1 IM
flush
Label: ... IM Reg DM Reg

24
(HY232)
Παράδειγμα Λανθασμένης Πρόβλεψης

36: sub $10, $4, $8
40: beq $1, $3, 7
44: and $12, $2, $5
...
72: lw $4, 50($7)

Παράδειγμα Λανθασμένης Πρόβλεψης
Δυναμική Πρόβλεψη Διακλάδωσης

• Στους σύγχρονους επεξεργαστές με μεγάλο αριθμό σταδίων
διοχέτευσης (~20), ο αριθμός των κύκλων μηχανής που πληρώνουμε για
λάθος πρόβλεψης διακλάδωσης είναι πολύ μεγαλύτερος.
– Σημαντικός παράγοντας για την χαμηλή απόδοση του συστήματος.
• Η δυναμική πρόβλεψη της κατεύθυνσης μιας διακλάδωσης προσπαθεί
να “μάθει” από την συμπεριφορά της διακλάδωσης σε προηγούμενες
εκτελέσεις.

Δυναμική Πρόβλεψη Διακλάδωσης
Πρόβλεψη 1-bit
• Ο πιο απλός αλγόριθμος δυναμικής πρόβλεψης: προέβλεψε ότι η
διακλάδωση θα συμπεριφερθεί όπως ακριβώς και στην αμέσως
προηγούμενη εκτέλεση της.
outer: …
…
inner: …
…
beq …, …, inner
…
beq …, …, outer
• Απλή αλλά ασταθής λύση.

• Στο παραπάνω κώδικα η εντολή beq του inner loop θα
προβλεφθεί λάθος 2 φορές για κάθε εκτέλεση του εξωτερικού
loop.
Πρόβλεψη 2-bit
• Χρησιμοποιώντας μια μηχανή πεπερασμένων καταστάσεων
μπορούμε να αποφύγουμε να αλλάζουμε απόφαση την πρώτη
φορά που έχουμε λανθασμένη πρόβλεψη

Υπολογισμός Διεύθυνσης Διακλάδωσης
• Εκτός από την πρόβλεψη για το εάν η διακλάδωση θα είναι TAKEN ή

NOT TAKEN, πρέπει να υπολογίσουμε και την διεύθυνση προορισμού.
• Branch target buffer (προσωρινή μνήμη προορισμού διακλάδωσης)
– Μνήμη cache (μνήμες caches στο επόμενο κεφ.!) που αποθηκεύει
μόνο εντολές διακλάδωσης , πληροφορίες σχετικά με την
προηγούμενη συμπεριφορά της εντολής διακλάδωσης και την
διεύθυνση προορισμού.
– Κάθε φορά που είναι να φέρουμε μια καινούργια εντολή από την
μνήμη, ελέγχουμε ταυτόχρονα και τον branch target buffer
Εάν βρούμε την εντολή διακλάδωσης εκεί, και η διακλάδωση είναι TAKEN,
τότε μπορούμε να φέρουμε την νέα εντολή από την διεύθυνση προορισμού
που μας δείχνει η διακλάδωση
Αποτίμηση της Πρόβλεψης Διακλάδωσης

• Οι εντολές διακλάδωσης είναι ο κυριότερος ένοχος μειωμένης
απόδοσης του συστήματος (μετά ίσως τις εντολές προσπέλασης
μνήμης) .
– Σε επεξεργαστές υψηλής απόδοσης (high performance processors), η
λανθασμένη πρόβλεψη του branch επιφέρει πολλούς κύκλους ποινής.
– Πολλές εντολές θα πρέπει να γίνουν flush σε μια τέτοια περίπτωση.
• Όλοι οι μοντέρνοι επεξεργαστές χρησιμοποιούν δυναμική
πρόβλεψη διακλαδώσεων.
– Ακριβείς προβλέψεις (>95%) της κατεύθυνσης διακλάδωσης είναι
πάρα πολύ σημαντικές για καλή απόδοση ενός επεξεργαστικού
συστήματος υψηλής απόδοσης.
– Για αυτό και όλες αυτές οι CPUs χρησιμοποιούν πολύπλοκα
συστήματα πρόβλεψης διακλάδωσης που “μαθαίνουν” την
συμπεριφορά της εντολής κατά την διάρκεια εκτέλεσης του
προγράμματος.
– Πολύ σημαντικό ερευνητικό θέμα τα τελευταία 20 χρόνια.

31
(HY232)
Διάλεξη 13
Εξαιρέσεις και Διακοπές

(Exceptions and Interrupts)
Γιατί χρειάζονται interrupts σε ένα

υπολογιστικό σύστημα;
• Τα μοντέρνα λειτουργικά συστήματα (Operating Systems, OS)
χρονο-προγραμματίζουν (schedule) διεργασίες χρησιμοποιώντας
pre-emption:
• Κάθε φορά που ένας υπολογιστής θέλει να τρέξει δύο
προγράμματα Α και Β, το λειτουργικό σύστημα περιοδικά
μεταφέρει τον έλεγχο από το ένα στο άλλο. Πιο συγκεκριμένα, το
λειτουργικό:
• Σταματάει το πρόγραμμα Α
• Μεταφέρει τα δεδομένα των καταχωρητών στην κύρια μνήμη
• Μεταφέρει τα δεδομένα του Β από την κύρια μνήμη στους καταχωρητές
• Ξεκινάει τον πρόγραμμα Β
Πως σταματάει ένα λειτουργικό σύστημα το πρόγραμμα Α;
Απάντηση: Χρησιμοποιεί ένα interrupt.
2
Προγραμματισμός Ι/Ο, Interrupts, Exceptions
(Διακοπές και Εξαιρέσεις)
• Οι περισσότερες αιτήσεις για I/O γίνονται από το λογισμικό για να γίνουν
μεταφορές δεδομένων μεταξύ Ι/O περιφερειακών και της κύριας μνήμης
• Οι δύο πιο συνηθισμένοι τρόποι επικοινωνίας με εξωτερικές συσκευές

είναι:
– Memory-mapped I/O
– Isolated I/O
• Οι πιο συνηθισμένοι μέθοδοι για να προγραμματίσουμε την μεταφορά
δεδομένων μεταξύ κύριας μνήμης και I/O περιφερειακών:
– Interrupt-driven I/O
– Programmed I/O
• Η χρήση Interrupt-driven I/O δημιουργεί την ανάγκη να συζητήσουμε:
– Διακοπές (Interrupts)
– Εξαιρέσεις (Exceptions)
3
Επικοινωνία με περιφερειακές συσκευές

• Περιφερειακές συσκευές όπως το
πληκτρολόγιο, ποντίκι, οθόνη, κάρτα
δικτύου κλπ. θεωρούνται από τoν
επεξεργαστή σαν μνήμες.
– Ο επεξεργαστής μπορεί να τις διαβάσει ή
να γράψει σε αυτές όπως ακριβώς κάνει
και σε οποιαδήποτε μνήμη
• Στο παράδειγμα, η κάρτα γραφικών
μπορεί να προσπελαστεί μέσω των
διευθύνσεων 3B0-3BB, 3C0-3DF και
A0000-BFFFF.
• Αυτές οι διευθύνσεις μπορούν να
προσπελαστούν με δύο τρόπους:
– Memory-mapped I/O
– Isolated I/O
4
Memory-mapped I/O
FFFF
• Σύμφωνα με το μοντέλο memory-mapped I/O, ο
Memory
χώρος διευθύνσεων της μνήμης διαιρείται σε 2
τμήματα: I/O
D000
C000
– Ένα τμήμα που αναφέρεται στην φυσική κύρια μνήμη
– Ένα τμήμα που αναφέρεται σε περιφερειακές συσκευές.
• Για παράδειγμα, ο παλιός Apple IIe είχε 16-bit
χώρο διευθύνσεων και μπορούσε να προσπελάσει
64 KB κύριας μνήμης. Memory
– Οι διευθύνσεις C000-CFFF χρησιμοποιούνταν για να
προσπελασθούν οι περιφερειακές συσκευές.
– Η διεύθυνση C010 αναφέρεται στο πληκτρολόγιο ενώ η
C030 αναφέρεται στo ηχείο.
– Μερικές σε περιφερειακές συσκευές χρειάζονται 0000
πολλαπλές θέσεις μνήμης
5
Προγραμματισμός memory-mapped I/O

Control
Address
Data
CPU Memory Hard disks CD-ROM Network Display
• Για να γράψει σε μια περιφερειακή συσκευή, η CPU στέλνει πρώτα την

διεύθυνση που αντιστοιχεί στην συσκευή στον Δίαυλο Διευθύνσεων
(Address Bus). Ταυτόχρονα, στέλνει και τα δεδομένα στο Δίαυλο
Δεδομένων (Data Bus). Για παράδειγμα, για να γράψουμε 0xΑΒΑΒ στο
ηχείο, η CPU θέτει Address Bus = 0xC030 , Data Bus = 0xΑΒΑΒ
• Aπό την πλευρά της, κάθε περιφερειακή συσκευή παρακολουθεί το
Address Bus για να διαπιστώσει εάν είναι ο παραλήπτης μιας
προσπέλασης.
– Το ηχείο αποκρίνεται σε μια εγγραφή μόνο όταν η τιμή C030
εμφανίζεται στο Address Bus.
6
Isolated I/O
• Σε αντιδιαστολή με την προηγούμενη μέθοδο, το FFFFFFFF
isolated I/O, υποστηρίζει διαφορετικούς χώρους
διευθύνσεων για την κύρια μνήμη και τις
περιφερειακές συσκευές. Ειδικές εντολές
assembly χρησιμοποιούνται για την προσπέλαση
αυτή. Main
memory
• H αρχιτεκτονική 8086 έχει 32-bit χώρο
διευθύνσεων:
– Η εντολή MOV χρησιμοποιείται για την
προσπέλαση της κύριας μνήμης RAM.
– Οι ειδικές εντολές IN και OUT για την 00000000
προσπέλαση ενός ξεχωριστού 64KB χώρου
περιφερειακών συσκευών.
0000FFFF
– Η διεύθυνση 0000FFFF μπορεί να αντιστοιχεί I/O
είτε στην κύρια μνήμη είτε σε κάποια devices
περιφερειακή συσκευή 00000000
Μεταφορά Δεδομένων από Περιφερειακές

Συσκευές με Polling CPU sends read
• O επεξεργαστής κάνει αίτηση για request to device
δεδομένα και περιμένει μέχρι η Not ready

περιφερειακή συσκευή να είναι έτοιμη
CPU waits
να διαβάσει ή να γράψει τα δεδομένα for device
– Για μεταφορά μεγάλου όγκου δεδομένων,

αυτή η διαδικασία πρέπει να επαναληφθεί Ready
πολλές φορές CPU reads word

from device
• Αυτό δεν είναι και πολύ έξυπνη
προσέγγιση
CPU writes word
– Εάν η περιφερειακή συσκευή είναι αργή σε to main memory
σχέση με τον επεξεργαστή, ο επεξεργαστής
περιμένει πολύ ώρα.
No
– Ο επεξεργαστής μπλοκάρει περιμένοντας μην Done?
μπορώντας να κάνει τίποτε άλλο
Yes
8
Polling
• Ο συνεχής έλεγχος για να ελέγξουμε εάν CPU sends read
request to device
κάτι έχει λάβει χώρα ονομάζεται polling
• Δεν είναι ο καλύτερος τρόπος για να Not ready
χρησιμοποιήσετε την CPU. CPU waits

for device
– H CPU μπλοκάρει σε ένα while (1) loop
ελέγχοντας συνεχώς εάν η περιφερειακή
Ready
συσκευή είναι έτοιμη να διαβάσει ή να στείλει
δεδομένα.
• Σκεφτείτε να θέλατε να ελέγξετε εάν
έχουν βγει ιατρικά αποτελέσματα από
εξετάσεις που έχετε κάνει
– Me to polling θα παίρνατε τηλ. τον γιατρό
κάθε 1-2 λεπτά.
– Μια καλύτερη ιδέα ήταν να σας τηλεφωνούσε
ο γιατρός όταν τα αποτελέσματα ήταν έτοιμα
9
Interrupt-driven I/O
• Χρησιμοποιώντας διακοπές (interrupts) λύνουμε CPU sends read
request to device
το πρόβλημα τις μη-αποδοτικής χρήσης του
επεξεργαστή
• Μετά την αίτηση σε μια συσκευή, ο CPU does other stuff
επεξεργαστής μπορεί να συνεχίσει ελεύθερα με ...

άλλες εργασίες. Η συσκευή διακόπτει τον CPU receives interrupt
επεξεργαστή όταν τα δεδομένα είναι έτοιμα.
• Η μεταφορά δεδομένων μπορεί να γίνει πάλι
CPU reads word
από τον επεξεργαστή from device
– memcpy()
• Μπορεί όμως να γίνει και με την χρήση DMA CPU writes word
(Direct Memory Access) to main memory
– Υλικό αυτόματης μεταφοράς δεδομένων

μεταξύ Ι/O και μνήμης No
Done?
Yes
10
Διακοπές - Interrupts
• Οι διακοπές (Interrupts) είναι γεγονότα που συμβαίνουν
εκτός του επεξεργαστή και χρειάζονται την προσοχή του.
– Περιφερειακές συσκευές που χρειάζονται να επικοινωνήσουν με τον
επεξεργαστή δημιουργούν interrupts
– Timers (χρονομέτρες) είναι συσκευές που ειδοποιούν ότι έχει περάσει
ένα συγκεκριμένο χρονικό διάστημα.
• Οι διακοπές είναι φυσιολογικές λειτουργίες του συστήματος
– Δεν είναι λάθη
– Όλες οι διακοπές είναι εξυπηρετήσιμες και η κανονική ροή του
προγράμματος συνεχίζει μετά την εξυπηρέτηση της διακοπής
• Το λειτουργικό σύστημα είναι υπεύθυνο για την εξυπηρέτηση
της διακοπής
11
Εξαιρέσεις (Exceptions)
• Oι εξαιρέσεις (exceptions) είναι συνήθως λάθη κατά την
διάρκεια εκτέλεσης ενός προγράμματος από τον επεξεργαστή
– Ο επεξεργαστής προσπαθεί να εκτελέσει μια εντολή με μη-έγκυρο
opcode.
– Overflow σε μια αριθμητική πράξη ή διαίρεση με το 0.
– Μια εντολή load ή store δεν μπορεί να ολοκληρωθεί γιατί η διεύθυνση
που προσπαθεί να προσπελάσει δεν είναι στην μνήμη αλλά στον
σκληρό δίσκο –Εικονική μνήμη (virtual memory) – Θα επανέλθουμε σε
αυτό αργότερα.
• Υπάρχουν δύο πιθανοί τρόποι αντιμετώπισης των εξαιρέσεων
– Εάν το λάθος ΔΕΝ είναι επανορθώσιμο, το λειτουργικό σύστημα
τερματίζει το πρόγραμμα.
– Εάν το λάθος είναι επανορθώσιμο το λειτουργικό σύστημα ή το ίδιο το
πρόγραμμα μπορεί να διορθώσει την κατάσταση.
12
Παράδειγμα εξαίρεσης:
Προσομοίωση εντολών (Instruction emulation)
• Πολλές φορές σύνολα εντολών επεκτείνονται με νέες εντολές
– Πχ. MMX, SSE, SSE2, για τις εντολές 80x86 της Intel
• Προγράμματα που χρησιμοποιούν αυτές τις νέες εντολές δεν
μπορούν να εκτελεσθούν σε παλαιότερους επεξεργαστές
– Αυτό είναι μεγάλο πρόβλημα. Πρόβλημα “forward compatibility”.
• Ειδικό software προσομοίωσης εντολών χρησιμοποιείται για
την εκτέλεση τέτοιων εντολών σε παλαιότερους
επεξεργαστές. Decode inst in software;
Kernel Return from
Perform its functionality exception
User Execute Application Illegal opcode Execute Application

exception
13
Διακοπές και εξαιρέσεις στον ΜΙPS

• Σημαντικότεροι καταχωρητές του συνεπεξεργαστή 0:
Register name Register # Usage
$badvaddr 8 address at which erroneous memory reference occurred
$status 12 interrupt enable and kernel/user bits
$cause 13 exception type and pending interrupts
address of instruction that caused exception
$epc 14
(or that was executing when interrupt occurred)
• Εντολές μεταφοράς δεδομένων από και προς το συνεπεξεργαστή 0:

mfc0 $s0,$epc  $s0 = $epc
mtc0 $s0,$epc  $epc = $s0
lwc0 $epc,100($s1)  $epc = Mem[$s1+100]
swc0 $epc,100($s1)  Mem[$s1+100] = $epc

Διακοπές και εξαιρέσεις στον ΜΙPS
Status register
(6 hard - 2 soft)
Cause register
(6 hard - 2 soft)
Διακοπές και εξαιρέσεις

• Διακόπτουν την κανονική ροή εκτέλεσης του προγράμματος και
εκτελούν άλμα σε μια διαδικασία χειρισμού εξαίρεσης (exception
handler), η οποία βρίσκεται στο χώρο του λειτουργικού συστήματος
(kernel) και όχι στο χώρο του χρήστη (user)
• Βήματα που εκτελούνται από το hardware όταν προκληθεί μια
εξαίρεση/διακοπή:
– Αποθήκευση του PC στον καταχωρητή $epc (ενδεχομένως και της
λανθασμένης διεύθυνσης αναφοράς στον καταχωρητή $badvaddr). Για
παράδειγμα, εάν η εντολή lw $s0, 0($sp) δημιούργησε μιά εξαίρεση,
τότε $badvaddr  0($sp)
– Καταγραφή του κωδικού εξαίρεσης στον καταχωρητή $cause
– Γενική απενεργοποίηση των διακοπών και ανάθεση kernel/user
λειτουργίας σε kernel mode στον καταχωρητή $status
– Εκκένωση του pipeline (flush) από την εντολή που δημιούργησε την
εξαίρεση και όλες τις επόμενες εντολές.
– Άλμα στη δεκαεξαδική διεύθυνση 0x80000180 όπου βρίσκεται ο
exception handler

Διακοπές και εξαιρέσεις
• Βήματα που εκτελούνται από το λειτουργικό σύστημα
όταν προκληθεί μια εξαίρεση/διακοπή:
– Ανάγνωση του καταχωρητή $cause για προσδιορισμό του κωδικού
εξαίρεσης
– Άλμα σε μια ρουτίνα του λειτουργικού συστήματος ανάλογα με τον
κωδικό εξαίρεσης (πιθανόν με τη βοήθεια ενός jump address table)
– Χειρισμός εξαίρεσης (ή εξυπηρέτηση της συσκευής που προκάλεσε
διακοπή)
– Επιστροφή στη ρουτίνα του exception handler
– Eντολή eret (exception return) για επιστροφή στο πρόγραμμα του χρήστη
- εφόσον δεν χρειάστηκε αυτό να τερματίσει κατά το χειρισμό της
εξαίρεσης - η οποία βασικά εκτελεί:
mfc0 $k0,$epc
addi $k0,$k0,4
jr $k0
• Εντολή break n προκαλεί εξαίρεση με τον κωδικό n
Εξαιρέσεις και Αρχιτεκτονική Διοχέτευσης

• Η εντολή που δημιούργησε την εξαίρεση θα πρέπει να εκκενωθεί
(flushed) και μαζί με αυτήν όλες οι μεταγενέστερες εντολές που
έχουν μπει στο pipeline.
• H εκτέλεση θα πρέπει να συνεχιστεί με την ρουτίνα εξυπηρέτησης
εξαίρεσης (handler routine) από μια προκαθορισμένη διεύθυνση
μνήμης
• Εάν η ρουτίνα εξυπηρέτησης καθορίσει ότι το κανονικό πρόγραμμα
μπορεί να συνεχίσει εκεί που διακόπηκε, τότε
– Κάνει τις απαραίτητες διορθώσεις και επιστρέφει
– Αλλιώς τερματίζει το πρόγραμμα και κάνει report το λάθος και τα αίτιά του
• Τι αλλαγές απαιτούνται από την μικρο-αρχιτεκτονική του
επεξεργαστή μας για να εξυπηρετήσουμε εξαιρέσεις;

Εξαιρέσεις και μικρο-αρχιτεκτονική
• Η αντιμετώπιση των εξαιρέσεων είναι όμοια με την αντιμετώπιση
control και data hazards που έχουμε ήδη περιγράψει.
• Ας θεωρήσουμε ένα παράδειγμα πρόσθεσης με υπερχείλιση που
δημιουργεί εξαίρεση στο στάδιο EX του pipeline.
add $1, $2, $1
• Τι πρέπει να γίνει σε αυτήν την περίπτωση;
– H εντολή add πρέπει να γίνει nop για να μην μεταφερθεί η λανθασμένη τιμή
του $1 στους καταχωρητές και στις υπόλοιπες εντολές.
– Όλες οι εντολές πριν την add θα πρέπει να τερματιστούν κανονικά
– Όλες οι εντολές μετά την add και η ίδια η add θα πρέπει να γίνουν flush από το
pipeline (δηλ. nops)
– Ή μικρο-αρχιτεκτονική θα πρέπει να θέσει τους καταχωρητές Cause και EPC με τις
κατάλληλες τιμές
– Η ρουτίνα εξυπηρέτησης εξαίρεσης (handler) θα πρέπει να αρχίζει να εκτελείται
Παράδειγμα εξαίρεσης
• Η εντολή add δημιουργεί εξαίρεση υπερχείλισης

40 sub $11, $2, $4
44 and $12, $2, $5
48 or $13, $2, $6
4C add $1, $2, $1
50 slt $15, $6, $7
54 lw $16, 50($7)
…
• Handler routine
80000180 sw $25, 1000($0)
80000184 sw $26, 1004($0)
…

Παράδειγμα εξαίρεσης (I)
80000180 η standard Extra πολυπλέκτες για να θέτουμε 0 τα
διεύθυνση του handler σήματα ελέγχου (flush)
στο στάδιο ΕΧ και στο στάδιο ID.
Καταχωρητής
EPC που
παίρνει την
τιμή PC+4 όταν
γίνει εξαίρεση
Παράδειγμα εξαίρεσης (II)

Διάλεξη 14
Εισαγωγή στην Ιεραρχία Μνήμης
H Μικρο-αρχιτεκτονική μας
Το data path είναι σε καλή κατάσταση.
Οι μνήμες όμως;
Είναι πολύ πιο πολύπλοκες από ότι
1 φαίνεται στο σχήμα
0 ID/EX
WB EX/MEM
PCSrc M WB
Control MEM/WB
IF/ID EX M WB
4
Add
P Add PCSrc
C Shift
left 2
RegWrite
Read Read
register 1 data 1
MemWrite
ALU
Read Instruction
address [31-0]
Read
register 2
= 0
Read Result Address
data 2
Write
register Data
memory Write
data
ALUSrc Write Read
1
data data
Sign
extend RegDst
MemRead
0
Instr [20 - 16]
0
Instr [15 - 11]
1

Μνήμες σε πραγματικό σύστημα
Core-i7 ιεραρχία μνήμης
Ιεραρχία Μνήμης
Large and Fast
• Έχουμε δει ήδη κάποιες βασικές τεχνικές για να επιταχύνουμε την
επεξεργασία δεδομένων στην CPU (πχ διοχέτευση)
• Δεν έχουμε πει όμως τίποτε για τις μνήμες.
– Χρειαζόμαστε μεγάλες μνήμες για να αποθηκεύσουμε εντολές και δεδομένα
για μεγάλες εφαρμογές όπως βάσεις δεδομένων, video και μουσική, κτλ
– Χρειαζόμαστε γρήγορες μνήμες για να μπορούμε να παρέχουμε εντολές και
δεδομένα με τον ίδιο ρυθμό που μας ζητάει η CPU. Αλλιώς η CPU θα
περιμένει συνέχεια χωρίς να κάνει τίποτα.
• Το μοντέλο ότι έχουμε μια μεγάλη επίπεδη μνήμη η οποία μπορεί
να παρέχει εντολές και δεδομένα σε έναν κύκλο και έχει
ανεξάντλητο μέγεθος δεν ισχύει.
• Σε αυτήν την ενότητα θα δούμε πως μπορούμε να σχεδιάσουμε τις
μνήμες εντολών και δεδομένων ώστε να προσομοιάζει όσο το
δυνατόν το παραπάνω μοντέλο.
– Κρυφές μνήμες (cache memories).
– Εικονικές μνήμες (virtual memories)
4
(HY232)
Είδη μνήμης
• Η τεχνολογία μνημών είναι είτε γρήγορη και ακριβή (SRAMs), είτε αργή και
φθηνή (Magnetic Disks)
• Η πιο γρήγορη μνήμη (SRAM) είναι πολύ ακριβή για να χρησιμοποιηθεί εξ’
ολοκλήρου σε μια CPU .
• Από την άλλη, η δυναμική μνήμη (DRAM) έχει χαμηλότερη ταχύτητα από την
λογική που χρησιμοποιείται στην μικρο-αρχιτεκτονική. Εάν χρησιμοποιηθεί
εξ’ολοκλήρου σε μια CPU, το σύστημα θα πρέπει να καθυστερεί πολλούς κύκλους
για να διαβάζουμε δεδομένα ή εντολές.
Είδος Μνήμης Ταχύτητα Κόστος/MB Χωρητικότητα
Static RAM H πιο γρήγορη Ακριβή Μικρή
Dynamic RAM Αργή Φθηνή Μεγάλη
Hard disks Η πιο αργή Η πιο Φθηνή Η μεγαλύτερη
Είδος Μνήμης Ταχύτητα Κόστος/MB Χωρητικότητα

Static RAM 1-10 cycles ~$5 έως ~4MB
Dynamic RAM 100-200 cycles ~$0.10 128MB-4GB
Hard disks 10,000,000 ~$0.0005 20GB-400GB
cycles
5
(HY232)
Μνήμη Cache
• To ιδανικό λοιπόν είναι να βρούμε μια ισορροπία μεταξύ γρήγορης και
φθηνής μνήμης. Πως μπορούμε να έχουμε τον καλύτερο συνδυασμό CPU
των δύο αυτών κόσμων;
• Η λανθάνουσα μνήμη (cache memory) είναι μια μικρή και γρήγορη
μνήμη που ανταποκρίνεται σε αυτές τις προδιαγραφές. Επειδή είναι
μικρή σε μέγεθος σε σχέση με την κύρια μνήμη δεν είναι πολύ ακριβή.
– Η cache βρίσκεται ανάμεσα στον επεξεργαστή και στην (μεγαλύτερη Μικρή στατική
μνήμη(cache)
και πιο αργή) κύρια μνήμη.
– Κρατάει αντίγραφα των πιο συχνά εκτελούμενων εντολών και
δεδομένων.
• Η προσπέλαση δεδομένων και εντολών μειώνεται με το να κάνουμε την
συχνή περίπτωση πιο γρήγορη. Μεγάλη δυναμική
μνήμη (RAM)
• Η κύρια μνήμη χρειάζεται να προσπελασθεί μόνο για δεδομένα που δεν
είναι στην cache. Αυτά είναι συνήθως δεδομένα που δεν εκτελούνται
τόσο συχνά
Cache (Merriam-Webster online dictionary)

• a hiding place especially for concealing and
preserving provisions or implements
• a secure place of storage Οργάνωση και Σχεδίαση Η/Υ
6
(HY232)
Η αρχή της τοπικότητας των
προσπελάσεων μνήμης
• Η ιεραρχία της μνήμης σε έναν επεξεργαστή βασίζεται σε μία πολύ
βασική εμπειρική αρχή:
– Τα προγράμματα σε κάθε χρονική στιγμή προσπελαύνουν ένα μικρό ποσοστό
των δεδομένων και εντολών τους.
• Η αρχή της τοπικότητας διακρίνεται σε:
– την αρχή της χρονικής τοπικότητας (temporal locality) που λέει
ότι ένα πρόγραμμα που προσπελαύνει μια διεύθυνση μνήμης
έχει αυξημένες πιθανότητες να την προσπελάσει ξανά σύντομα.
– την αρχή της χωρικής τοπικότητας (spatial locality) που λέει ότι
ένα πρόγραμμα που προσπελαύνει μια διεύθυνση μνήμης έχει
αυξημένες πιθανότητες να προσπελάσει σύντομα μια γειτονική
διεύθυνση μνήμης.

7
(HY232)
Χρονική τοπικότητα σε προγράμματα
• Τα loops είναι τυπικά παραδείγματα εμφάνισης χρονικής τοπικότητας

σε προγράμματα.
– Το block του loop εκτελείται πολλές φορές, και συνεπώς κάθε
εντολή στο loop προσπελαύνεται συνεχώς από την μνήμη
• Εάν τοποθετήσουμε τις εντολές του loop σε μια μνήμη cache, θα
μπορούμε να τις προσπελαύνουμε συνεχώς από εκεί και όχι από την
κύρια μνήμη.
Loop: lw $t0, 0($s1)

add $t0, $t0, $s2
sw $t0, 0($s1)
addi $s1, $s1, -4
bne $s1, $0, Loop

8
(HY232)
Χρονική τοπικότητα σε δεδομένα
• Πολλά προγράμματα προσπελαύνουν τις ίδιες μεταβλητές, ειδικά
μέσα σε loops.
– Για παράδειγμα, οι μεταβλητές sum και i προσπελαύνονται συνεχώς.
sum = 0;
for (i = 0; i < MAX; i++)
sum = sum + f(i);
• Τέτοιες μεταβλητές πολλές φορές αποθηκεύονται σε καταχωρητές

και όχι στην μνήμη, για να μπορούν να διαβαστούν χωρίς να
χρειάζεται να φορτωθούν πρώτα από την μνήμη. Αυτό, όμως, δεν
είναι πάντα δυνατόν να γίνει.
– Υπάρχει περιορισμένος αριθμός καταχωρητών σε μια CPU.

9
(HY232)
Χωρική τοπικότητα σε προγράμματα

• Όταν προσπελάσουμε μια εντολή, κατά πάσα πιθανότητα, αμέσως
μετά θα προσπελάσουμε και τις εντολές που έπονται στον χώρο.
Εάν εκτελέσουμε μια εντολή στην διεύθυνση i , είναι πολύ πιθανόν
να εκτελέσουμε μια εντολή στις επόμενες διευθύνσεις.
• Τμήματα κώδικα όπως τα loops χαρακτηρίζονται πολύ συχνά από
χρονική και χωρική τοπικότητα ταυτόχρονα.
sub $sp, $sp, 16

sw $ra, 0($sp)
sw $s0, 4($sp)
sw $a0, 8($sp)
sw $a1, 12($sp)

10
(HY232)
Χωρική τοπικότητα σε δεδομένα
• Πολλά προγράμματα
sum = 0;
προσπελαύνουν δεδομένα που for (i = 0; i < MAX; i++)
είναι αποθηκευμένα σε sum = sum + array[i];
γειτονικές θέσεις μνήμης.
– Οι πίνακες (όπως το array
στον κώδικα) αποθηκεύονται employee.name = “Homer Simpson”;
σε συνεχείς θέσεις στην employee.boss = “Mr. Burns”;
employee.age = 45;
μνήμη.
– Τα πεδία ενός struct ή object
επίσης αποθηκεύονται σε
συνεχείς θέσεις στην μνήμη.
• Άρα και τα δεδομένα σε loops
μπορούν να έχουν χρονική και
χωρική τοπικότητα ταυτόχρονα.

11
(HY232)
Μνήμες Cache και χρονική τοπικότητα

• Στην πρώτη προσπέλαση μιας διεύθυνσης, α) τα
CPU
δεδομένα διαβάζονται από την κύρια μνήμη , και β)
ένα αντίγραφο των δεδομένων μεταφέρεται και
στην cache.
– Με αυτόν τον τρόπο τα δεδομένα μπορούν να διαβάζονται
στην συνέχεια από την γρήγορη cache (1 κύκλος μηχανής) Μικρή στατική
και όχι από την αργή κύρια μνήμη (δεκάδες ή και μνήμη(cache)
εκατοντάδες κύκλοι μηχανής)
– H πρώτη προσπέλαση είναι αργή, αλλά αφού “ζεσταθεί” η
cache με δεδομένα, οι επόμενες προσπελάσεις είναι πολύ
πιο γρήγορες. Μεγάλη δυναμική
μνήμη (RAM)
• Αυτός ο αλγόριθμος εκμεταλλεύεται την χρονική
τοπικότητα. Δεδομένα και εντολές που
προσπελαύνονται συχνά θα βρίσκονται στην cache.

12
(HY232)
Μνήμες Cache και χωρική τοπικότητα
• Oπως μόλις είδαμε, όταν η CPU διαβάζει από CPU

την θέση i της κύριας μνήμης , ένα αντίγραφο
των δεδομένων στην θέση αυτή αποθηκεύεται
στην cache.
• Αντί όμως να αντιγράφουμε μόνο την θέση i Μικρή στατική
αντιγράφουμε και αρκετές άλλες θέσεις μνήμη(cache)
γειτονικές της i; για παράδειγμα τα δεδομένα
στις θέσεις από i μέχρι και i + 3.
– Για παράδειγμα, αντί να διαβάσουμε μόνο ένα
στοιχείο A[i] του πίνακα A, μπορούμε να διαβάσουμε Μεγάλη δυναμική
μνήμη (RAM)
τα στοιχεία Α[i] .. A[i+3] ή και παραπάνω ΠΡΙΝ τα
ζητήσει η CPU.
– Prefetching
– Τα δεδομένα σε αυτές τις θέσεις θα βρίσκονται στην
cache εάν η CPU αργότερα χρειασθεί να τα
προσπελάσει..
13
(HY232)
H ιδέα της cache είναι πολύ γενικότερη

• H ιδέα του να φέρουμε τα δεδομένα που επεξεργαζόμαστε συχνά
κοντά στον τόπο επεξεργασίας είναι μία από τις πιο βασικές αρχές
της επιστήμης υπολογιστών.
• Πάρτε για παράδειγμα τα δίκτυα.
– Δίκτυα όπως το internet έχουν μεγάλο χρόνο απόκρισης
(latency), και συνεπώς το να μεταφέρουμε δεδομένα συνεχώς
δεν είναι επιθυμητό.
– Web browsers όπως Firefox και Chrome αποθηκεύουν σελίδες
που προσπελαύνετε συχνά στον σκληρό σας δίσκο.

14
(HY232)
Mια απλή μνήμη cache
• Οι Caches διαιρούνται σε blocks που αποτελούνται από ένα ή
περισσότερα bytes.
– Ο αριθμός των blocks σε μια cache είναι συνήθως δύναμη του 2.
– Ας πάρουμε την απλή περίπτωση που ένα block έχει μέγεθος ένα
byte. Συνήθως το block έχει πολύ μεγαλύτερο μήκος, αλλά ας το
δεχτούμε αυτό για χάριν απλότητας.
Block
index 8-bit data
000
001
010
011
100
101
110
111
15
(HY232)
Τέσσερεις σημαντικές ερωτήσεις
1. Που ακριβώς στην cache τοποθετείται ένα block

δεδομένων όταν αντιγράφεται από την κύρια μνήμη;
2. Πως ανιχνεύουμε εάν κάποια λέξη είναι ήδη στην cache, ή
θα πρέπει να πρέπει να την φέρουμε από την κύρια μνήμη;
3. Τι κάνουμε όταν γεμίσει η cache με δεδομένα; Για να
φέρουμε καινούργια δεδομένα από την κύρια μνήμη στην
cache, πρέπει να διώξουμε ένα block από δεδομένα που
είναι ήδη στην cache. Πώς επιλέγουμε αυτό το block;
4. Τι κάνουμε όταν θέλουμε να γράψουμε στην μνήμη;

16
(HY232)
1. Που τοποθετούνται νέα δεδομένα
• Μία cache άμεσης απεικόνισης (direct-mapped) ακολουθεί την πιο
απλή προσέγγιση: κάθε διεύθυνση μνήμης μπορεί να απεικονιστεί
σε ένα και μόνο cache block. Memory
Address
• Πχ. Κύρια μνήμη 16 bytes, 0
cache 4 bytes. 1
2
• Οι διευθύνσεις 0, 4, 8 3
και 12 μπορούν να τοποθετηθούν 4 Index
5
ΜΟΝΟ στο block 0 της cache. 6 0
1
• Οι διευθύνσεις 1, 5, 9 7
8 2
και 11 μπορούν να τοποθετηθούν 9 3
ΜΟΝΟ στο block 1 της cache. 10
11
12
13
14
15

17
(HY232)

• Σε μια direct-mapped μνήμη cache μεγέθους 2k blocks, η
διεύθυνση i θα τοποθετηθεί στο cache block
i mod 2k Memory
Address
• Για παράδειγμα, σε μια 0
cache με 4 blocks η διεύθυνση 1
2
14 θα τοποθετηθεί στο block 2 3
4 Index
14 mod 4 = 2 5
6 0
7 1
8 2
9 3
10
11
12
13
14
15
18
(HY232)
• Ένας απλός τρόπος να υπολογίσουμε το i mod 2k είναι να
κοιτάξουμε τα τελευταία k bits της διεύθυνσης i .
• Για την 4-bit cache, ελέγχουμε Memory
τα τελευταία 2 bits. Address
• H διεύθυνσης 14 (1110 δυαδικό) 0000

0001
θα τοποθετηθεί στο cache 0010
block 2 (10 in binary). 0011
0100 Index
0101
0110 00
0111 01
1000 10
1001 11
1010
1011
1100
1101
1110
1111
19
(HY232)
2. Πως βρίσκουμε δεδομένα στην cache

• Πως ανιχνεύουμε εάν κάποια λέξη είναι ήδη στην cache;
• To πρώτο βήμα για να βρούμε
Memory
εάν η διεύθυνση i είναι στην cache Address
είναι να υπολογίσουμε το block 0
όπου θα πρέπει να βρίσκεται 1
η διεύθυνση i 2
3
i mod 2k 4 Index
5
• Όμως πολλές άλλες διευθύνσεις 6 0
7 1
μπορούν να αποθηκευθούν στο ίδιο 8 2
cache block. 9 3
10
• Για παράδειγμα, το cache block 11
2 μπορεί να περιέχει δεδομένα από 12
τις διευθύνσεις 2, 6, 10 or 14. 13
14
• Άρα χρειάζεται επιπλέον πληροφορία 15
20
(HY232)
2. Πως βρίσκουμε δεδομένα στην cache;
Tags!
• Χρησιμοποιούμε ως tags τα υπόλοιπα bits της διεύθυνσης για να
ξεχωρίσουμε μεταξύ διαφορετικών θέσεων μνήμης που τυχαίνει να
πέφτουν στο ίδιο cache block.
• Για να έχουμε match, πρέπει το tag στην cache να είναι το ίδιο με τα
αντίστοιχα bits της διεύθυνσης i.
0000
0001
0010
0011
0100
0101 Index Tag Data
0110 00 00
0111 01 11
1000 10 01
1001 11 01
1010
1011 Tag + Index = Address
1100 00 + 00 = 0000
1101 11 + 01 = 1101
1110 01 + 10 = 0110
1111 01 + 11 = 0111
21
(HY232)
2. Πως βρίσκουμε δεδομένα στην cache;

Valid Bit
• Όταν ξεκινάει να τρέχει ένα πρόγραμμα, η cache είναι άδεια και
περιέχει άκυρα δεδομένα (invalid data).
• Για να ξεχωρίσουμε λοιπόν μεταξύ έγκυρων και άκυρων δεδομένων,
προσθέτουμε ένα valid bit σε κάθε cache block.
• Όταν το σύστημα αρχικοποιείται όλα τα valid bits γίνονται 0.
• Όταν δεδομένα φορτώνονται σε ένα cache block, το αντίστοιχο valid
bit γίνεται 1.
• Για να έχουμε match, πρέπει το tag στην cache να είναι το ίδιο με τα
αντίστοιχα bits της διεύθυνσης i KAI το valid bit του cache block να
είναι 1. Valid Main memory
Index Bit Tag Data address in cache block
00 1 00 00 + 00 = 0000
01 0 11 Invalid
10 0 01 Invalid
11 1 01 01 + 11 = 0111

22
(HY232)
Παράδειγμα λειτουργίας Cache (I)
• 8-blocks, 1 word/block, direct mapped
• Αρχική κατάσταση της cache:
Block V Tag Data

Index
000 N
001 N
010 N
011 N
100 N
101 N
110 N
111 N
Παράδειγμα λειτουργίας Cache (II)

Word addr Binary addr Hit/miss Cache block
(5 bits)
22 10 110 Miss 110
Block V Tag Data

Index
000 N
001 N
010 N
011 N
100 N
101 N
110 Y 10 Mem[22]
111 N
Παράδειγμα λειτουργίας Cache (III)
26 11 010 Miss 010
Index V Tag Data

000 N
001 N
010 Y 11 Mem[26]
011 N
100 N
101 N
110 Y 10 Mem[22]
111 N
Παράδειγμα λειτουργίας Cache (IV)

22 10 110 Hit 110
26 11 010 Hit 010
Index V Tag Data

000 N
001 N
010 Y 11 Mem[26]
011 N
100 N
101 N
110 Y 10 Mem[22]
111 N

Παράδειγμα λειτουργίας Cache (V)
16 10 000 Miss 000
3 00 011 Miss 011
16 10 000 Hit 000
Index V Tag Data

000 Y 10 Mem[16]
001 N
010 Y 11 Mem[26]
011 Y 00 Mem[3]
100 N
101 N
110 Y 10 Mem[22]
111 N
Παράδειγμα λειτουργίας Cache (VI)

18 10 010 Miss 010
Index V Tag Data

000 Y 10 Mem[16]
001 N
010 Y 10 Mem[18]
011 Y 00 Mem[3]
100 N
101 N
110 Y 10 Mem[22]
111 N

Μικρο-αρχιτεκτονική της cache
• Όταν η CPU διαβάζει από την μνήμη, η διεύθυνση στέλνεται
καταρχάς στον ελεγκτή της cache (cache controller).
– Tα λιγότερο σημαντικά k bits της διεύθυνσης χρησιμοποιούνται σαν block
index στην cache.
– Εάν το block είναι έγκυρο (valid bit = 1) και το πεδίο tag είναι το ίδιο με τα
περισσότερο σημαντικά (m - k) bits της m-bit της διεύθυνσης, τότε έχουμε
cache hit και τα δεδομένα στέλνονται στην CPU
Address (32 bits) Index Valid Tag Data

0
1
22 10 2
Index 3
To CPU
...
...
1022
1023
Tag
= Hit

29
(HY232)
Cache Misses
• Μιας και οι μνήμες cache είναι πολύ μικρότερες από την κύρια
μνήμη, είναι αναπόφευκτο να υπάρχουν φορές που δεν βρίσκουμε
τα δεδομένα στην cache (cache miss).
• H κύρια μνήμη είναι μερικά GB, ενώ μια τυπική cache 16-32 ΚΒ
• Το ποσοστό των cache hits ανάμεσα σε όλες τις προσπελάσεις τις
cache, λέγεται hit rate. Το ποσοστό των cache misses λέγεται miss
rate.
• Σε περίπτωση ενός cache miss, η CPU φέρνει τα δεδομένα από την
κύρια μνήμη και ταυτόχρονα τα μεταφέρει και στην cache.
• Θεωρούμε για απλούστευση ότι μέχρι να έρθουν τα δεδομένα στην
cache η CPU κάνει stall. Αυτό το stall μπορεί να διαρκέσει δεκάδες ή
και εκατοντάδες κύκλους μηχανής.

30
(HY232)
Cache Misses
• Τα δεδομένα που έρχονται από την μνήμη μεταφέρονται και στην
cache ως εξής:
– Tα λιγότερο σημαντικά k bits της διεύθυνσης χρησιμοποιούνται σαν block
index στην cache.
– The περισσότερο σημαντικά (m - k) bits της διεύθυνσης αποθηκεύονται στο
πεδίο tag.
– To δεδομένα από την κύρια μνήμη αποθηκεύονται στο πεδίο Data.
– Θέτουμε το valid bit του cache block ίσο με 1.
Address (32 bits) Index Valid Tag Data

0
1
22 10 2
Index 3
...
Tag
...
Data ...
1
31
(HY232)
3. Tί γίνεται εάν γεμίσει η cache
• Τι κάνουμε όταν γεμίσει η cache με δεδομένα; Για να φέρουμε

καινούργια δεδομένα από την κύρια μνήμη στην cache, πρέπει να
διώξουμε ένα block από δεδομένα που είναι ήδη στην cache. Πώς
επιλέγουμε αυτό το block;
• Η απάντηση είναι πολύ απλή.
– Ένα cache miss μεταφέρει καινούργια δεδομένα από την κύρια
μνήμη στην cache. Τα δεδομένα αυτά διαγράφουν οτιδήποτε
ήταν στην cache στο ίδιο block.

32
(HY232)
Τέσσερεις σημαντικές ερωτήσεις
1. Που ακριβώς στην cache τοποθετείται ένα block

δεδομένων όταν αντιγράφεται από την κύρια μνήμη;
2. Πως ανιχνεύουμε εάν κάποια λέξη είναι ήδη στην cache, ή
θα πρέπει να πρέπει να την φέρουμε από την κύρια μνήμη;
3. Τι κάνουμε όταν γεμίσει η cache με δεδομένα; Για να
φέρουμε καινούργια δεδομένα από την κύρια μνήμη στην
cache, πρέπει να διώξουμε ένα block από δεδομένα που
είναι ήδη στην cache. Πώς επιλέγουμε αυτό το block;
4. Τι κάνουμε όταν θέλουμε να γράψουμε στην μνήμη;

33
(HY232)
4. Γράφοντας στην cache

• Η πρώτη περίπτωση είναι να γράψουμε σε μια διεύθυνση που είναι
ήδη στην cache (write hit). Θεωρείστε μια direct-mapped cache.
Index V Tag Data Address Data
... ...
110 1 11010 42803 1101 0110 42803
... ...
• Έστω ότι θέλουμε να γράψουμε νέα δεδομένα στην cache στην

διεύθυνση 1101 0110. Υπάρχουν δύο στρατηγικές οργάνωσης της
cache σε περίπτωση write hit.
Mem[1101 0110] = 21763

... ...
110 1 11010 21763 1101 0110 42803
... ...
34
(HY232)
Write-through caches
• Μια write-through cache γράφει τα δεδομένα εκτός από την cache
ΚΑΙ στην μνήμη, έτσι ώστε η κύρια μνήμη να είναι πάντα
ενημερωμένη με τα τελευταία δεδομένα.
Mem[1101 0110] = 21763

... ...
110 1 11010 21763 1101 0110 21763
... ...
• Αυτό είναι μια απλή λύση, αν και συνήθως δημιουργεί υψηλό overhead
• Δημιουργεί την ανάγκη να στέλνουμε συνέχεια δεδομένα στην κύρια
μνήμη πολλές φορές χωρίς λόγο.

35
(HY232)
Write-back caches
• Σε μια write-back cache γράφουμε μόνο στην cache αμέσως αλλά όχι στην κύρια
μνήμη.
• H κύρια μνήμη ανανεώνεται με τα πιο πρόσφατα δεδομένα μόνο όταν το cache
block το οποίο γράψαμε αντικαθίσταται και πρέπει να γραφεί πίσω στην μνήμη.
• Αυτό σημαίνει ότι για κάποιο χρονικό διάστημα το δεδομένα της κύριας μνήμης
δεν είναι τα σωστά (πρόβλημα ασυνέπειας μνήμης = inconsistency)
• Κάθε μελλοντικό διάβασμα (read) από το ίδιο block θα εξυπηρετηθεί από την
cache.
• Χρειάζεται ένα extra bit (dirty bit) για κάθε block στην cache. Γίνεται 1 όταν η CPU
γράψει οποιαδήποτε byte στο block αυτό.
– Μόνο όταν dirty bit = 1, χρειάζεται να ανανεωθεί η κύρια μνήμη σε
περίπτωση αντικατάστασης ενός block.
Mem[1101 0110] = 21763
Index V Dirty Tag Data Address Data

...
110 1 1 11010 21763 1101 0110 42803
... ...

36
(HY232)
Write-back caches
• Παράδειγμα λειτουργίας μιας write-back cache στις 2 παρακάτω
πράξεις
Mem[11010 110] = 21763 // Write Hit
Read Mem[10001 110] // Read Miss
... 10001110 1225
110 1 1 11010 21763 11010110 42803
... ...

... 10001110 1225
110 1 0 10001 1225 11010110 21763
... ...
37
(HY232)
Write misses
• Η δεύτερη περίπτωση είναι να γράψουμε σε μια διεύθυνση που δεν
είναι στην cache (write miss). Θεωρείστε μια direct-mapped cache.
• Έστω ότι θέλουμε να γράψουμε:
Mem[11010 110] = 21763 // Write Miss
• Πως αντιμετωπίζουμε αυτήν την περίπτωση;

... ...
110 1 00010 123456 11010110 6378
... ...

38
(HY232)
Write Allocate
• Μία στρατηγική είναι να προσκομίσουμε πρώτα το block από την
κύρια μνήμη και στην συνέχεια να το γράψουμε στην cache (write
allocate).
Mem[11010 110] = 21763

... ...
110 1 11010 21763 11010110 21763
... ...
• Τα δεδομένα θα παρέχονται από την cache εάν τα χρειαστούμε πάλι.
• Αυτή η στρατηγική χρησιμοποιείται κυρίως σε συνδυασμό με write-back caches.

39
(HY232)
No Write Allocate
Λειτουργεί καλά αυτή η στρατηγική για τον παρακάτω κώδικα;
for (int i = 0; i < LARGE; i++)

a[i] = i;
Όχι, δεν έχει νόημα να βάζουμε στην cache δεδομένα όπως ο πίνακας a[.]
που δεν θα ξαναχρησιμοποιηθούν για μεγάλο χρονικό διάστημα.
• H δεύτερη στρατηγική είναι να γράψουμε απευθείας στην κύρια

μνήμη, χωρίς να τοποθετήσουμε τα δεδομένα στην cache (no write
allocate). Mem[11010 110] = 21763

... ...
110 1 00010 123456 1101 0110 21763
... ...
40
(HY232)
Διάλεξη 15
Απόδοση της Ιεραρχίας Μνήμης
Βελτιστοποίηση της απόδοσης
Πόσο μεγάλη είναι μια μνήμη cache;

Έστω ότι έχουμε μια μνήμη cache σε ένα 16-bit σύστημα
διευθύνσεων με τα κάτωθι χαρακτηριστικά:
• Η cache είναι direct-mapped
• Κάθε cache block έχει ένα byte
• To block index είναι τα 4 τελευταία bit της 16-bit διεύθυνσης.
Πόσο μεγάλη είναι η cache (σε bytes);
H μνήμη cache αποτελείται από τον πίνακα των δεδομένων, από
τον πίνακα των tags και το valid bit.
Data:
4-bit index -> 24 = 16 blocks
Μέγεθος του tag = 12 bits (16 bit διεύθυνση- 4 bit index)
(12 tag bits + 1 valid bit + 1 dirty bit + 8 data bits) x 16 blocks = 22
bits x 16 = 352 bits

2
(HY232)
Μέτρηση της απόδοσης του συστήματος
Θυμάστε από προηγούμενο μάθημα:
Χρόνος Εκτέλεσης Προγράμματος = Κύκλοι Εκτέλεσης * Περίοδος Ρολογιού
• Οι κύκλοι εκτέλεσης περιλαμβάνουν:

– Τους κύκλους εκτέλεσης στην CPU
• Θεωρώντας 100% caches hit rate
• Περιλαμβάνει τον χρόνο του cache hit
– Τους κύκλους καθυστέρησης στις μνήμες cache από cache misses (stalls)
Χρόνος Εκτέλεσης Προγράμματος =

(Κύκλοι Εκτέλεσης CPU + κύκλοι καθυστέρησης στις μνήμες) * Περίοδος Ρολογιού
όπου
Κύκλοι καθυστέρησης στις μνήμες = Προσπελάσεις στις μνήμες/Πρόγραμμα *
Ρυθμός Αστοχίας * Ποινή αστοχίας σε κύκλους =
Αριθμός Αστοχιών /Πρόγραμμα * Ποινή αστοχίας σε κύκλους =
Εντολές /Πρόγραμμα * Αστοχία/Εντολή * Ποινή αστοχίας σε κύκλους
Μία εντολή μπορεί να έχει maximum 2 misses (I + D-Cache)

Μέτρηση της απόδοσης του συστήματος

Συνεπώς:
Χρόνος Εκτέλεσης Προγράμματος =

(Κύκλοι Εκτέλεσης CPU + Εντολές /Πρόγραμμα * Αστοχία/Εντολή * Ποινή αστοχίας σε κύκλους )
* Περίοδος Ρολογιού
Χρόνος Εκτέλεσης Προγράμματος = Εντολές /Πρόγραμμα *

(CPIex + Αστοχία/Εντολή * Ποινή αστοχίας σε κύκλους ) * Περίοδος Ρολογιού

Παράδειγμα απόδοσης του συστήματος
• Έστω ένας επεξεργαστής A για τον οποίο ισχύουν τα εξής:
– I-cache miss rate = 2%
– D-cache miss rate = 4%
– Ποινή αστοχίας= 100 κύκλοι
– CPIex = 2
– 36% των εκτελούμενων εντολών είναι load & stores
• Πόσο αργότερος είναι ο παραπάνω επεξεργαστής σε σχέση με κάποιον
επεξεργαστή B που έχει τέλεια cache και τρέχει το ίδιο πρόγραμμα;
• Χρόνος Εκτέλεσης Προγράμματος A = Εντολές /Πρόγραμμα *
(CPIex + Αστοχία/Εντολή * Ποινή αστοχίας σε κύκλους ) * Περίοδος Ρολογιού
• Χρόνος Εκτέλεσης Προγράμματος B = Εντολές /Πρόγραμμα *
(CPIex) * Περίοδος Ρολογιού
Επειδή ο αριθμός των εντολών και η περίοδος του ρολογιού είναι οι ίδιες, συγκρίνουμε
μόνο τα CPI.
Για τον A: 2 + (0.02 + 0.04*0.36)*100 = 5.44
Για τον Β: 2
Συνεπώς ο Β είναι 5.44 / 2 = 2.72 φορές πιο γρήγορος από τον Α !
Μέσος Χρόνος Προσπέλασης Μνήμης

Average Memory Access Time
• Μια σημαντική μετρική για το σύστημα ιεραρχίας μνήμης είναι ο μέσος
χρόνος προσπέλασης δεδομένων στην μνήμη (average memory access
time, AMAT).
– Μέσος χρόνος προσπέλασης στην μνήμη : Average memory access time
– Χρόνος Ευστοχίας : Hit Time
– Ρυθμός αστοχίας: Miss Rate
– Ποινή αστοχίας : Miss Penalty
– AMAT = Χρόνος ευστοχίας + Ρυθμός Αστοχίας * Ποινή Αστοχίας σε
Κύκλους = Hit Time (L1) + Miss Rate * Miss Penalty
– CPU με περίοδο ρολογιού 1ns clock, hit time = 1 κύκλος, miss penalty
= 20 κύκλοι, I-cache miss rate = 5%
– AMAT = 1 + 0.05 × 20 = 2ns
• 2 κύκλοι χρειάζονται ανά εντολή ΜΟΝΟ για να διαβάσουμε την εντολή από
την μνήμη
Συμπεράσματα από την μελέτη της απόδοσης
της μνήμης
Απόδοση CPU
Απόδοση εξωτερικής μνήμης

DRAM
• Αν και η απόδοση της κύριας μνήμης DRAM αυξάνεται με τα χρόνια, εν’ τούτοις
αυξάνεται πολύ πιο αργά σε σχέση με την απόδοση του επεξεργαστή.
• Αυτό σημαίνει ότι η ποινή αστοχίας από μερικούς κύκλους την δεκαετία του ‘80, έχει
φτάσει να είναι εκατοντάδες κύκλους τα τελευταία χρόνια.
• Η εξίσωση για το ΑΜΑΤ, μας δείχνει την σημασία να μειωθεί o Ρυθμός Αστοχίας και
Ποινή Αστοχίας σε Κύκλους
Οργάνωση της μνήμης cache

• Από εδώ και πέρα θα εξετάσουμε τρόπους μείωσης αυτών των δύο
παραγόντων (miss rate, miss penalty) μέσω διαφορετικών τεχνικών
οργάνωσης της cache
• Μέχρι στιγμής έχουμε εξετάσει μια απλή οργάνωση της cache, δηλ.
θεωρούμε cache άμεσης απεικόνισης (direct mapped) και με
μέγεθος του cache block ίσο με ένα byte.
• Ας δούμε σήμερα πως μπορούμε να επεκτείνουμε την
αρχιτεκτονική της μνήμης cache για να βελτιώσουμε την απόδοσή
της (να μειώσουμε τον ρυθμό αστοχίας, miss rate).
• Υπάρχουν 2 βασικοί τρόποι
– Βελτίωση της χωρικής τοπικότητας
– Βελτίωση της χρονικής τοπικότητας

8
(HY232)
Βελτίωση της χωρικής τοπικότητας
• Η μνήμη cache με 1 byte block δεν εκμεταλλεύεται

την χωρική τοπικότητα (spatial locality) των
δεδομένων.
• Όχι μόνο αυτό το byte, αλλά και τα άλλα δίπλα του
μπορεί να προσπελαστούν σύντομα από την CPU

9
(HY232)
Βελτίωση της χωρικής τοπικότητας

• Ας κάνουμε το cache block να είναι μεγαλύτερο του ενός byte.
Memory
Address
• Παράδειγμα block
0
των 2 bytes 1
2
• Εάν θέλουμε να 3
προσπελάσουμε την 4 Index
διεύθυνση 12 της μνήμης, 5
6 0
η cache θα διαβάσει από 1
7
την μνήμη την 12 και την 8 2
13 9 3
10
• Αυτός είναι και ο ορισμός 11
των cache blocks: το 12
13
μέγεθος των δεδομένων
14
που μεταφέρονται από την 15
κύρια μνήμη όταν έχουμε
cache miss. Οργάνωση και Σχεδίαση Η/Υ
10
(HY232)
Πως βρίσκουμε διευθύνσεις στην cache
• Θεωρείστε μια μνήμη cache direct-mapped με 2k blocks, και κάθε
block να έχει 2n bytes. Θεωρείστε επίσης μια m-bit διεύθυνση.
• Μπορούμε να καθορίσουμε που τοποθετείται κάθε byte της
κυρίας μνήμης στην cache εξετάζοντας την διεύθυνση και τα
πεδία από τα οποία αποτελείται.
– k bits από την διεύθυνση επιλέγουν ένα από τα 2k cache
blocks.
– Τα n LS bits είναι το block offset και καθορίζει ποιο από τα 2n
bytes στο cache block θα προσπελασθούν.
• Τα υπόλοιπα (m-k-n) bits της m-bit διεύθυνσης είναι το tag.
(m-k-n) bits k bits
n-bit Block
m-bit Address Tag Index Offset

11
(HY232)
Παράδειγμα 1
• Έστω μια direct-mapped μνήμη cache με 64 blocks, 16
bytes/block
– Σε ποιο block θα αποθηκευθούν τα δεδομένα της διεύθυνσης
1200?
• 1200 = 00..001 001011 0000
• Block number = 11
• Block offset = 0
31 10 9 4 3 0
Tag Index Offset
22 bits 6 bits 4 bits

Μικρο-αρχιτεκτονική cache
Tag Index (2 bits)
Address (4 bits) 1 10 1 Block offset
2
Index Valid Tag Data

0
1
2
3
8 8
=
0 1
Mux
Hit Data

13
(HY232)
Tag Index (2 bits)
Address (4 bits) n nn n Block offset
1 2
1
Ποιο byte διαβάζεται για
κάθε μία από τις
παρακάτω διευθύνσεις;
0 1 0 0xCA 0xFE  1010 (0xDE)
1 1 1 0xDE 0xAD  1110 (miss, invalid)
2 1 0 0xBE 0xEF
0 1 0xFE 0xED
 0001 (0xFE)
3
8 8
 1101 (miss, tag mismatch)
=
0 Mux 1
Hit Data

14
(HY232)
Address (32 bits)
0000 .... 0001 1000000000 10
20 10 2

0
1
2
...
512
...
1022
1023
Tag 8 8 8 8
=
Mux
Hit Data
15
(HY232)
Λειτουργία cache block

• Tα υπόλοιπα 3 bytes του cache block προέρχονται από τις γειτονικές
διευθύνσεις. Δηλ. τις 3 διευθύνσεις με το ίδιο index (1000000000)
και το ίδιο tag (00...01).
• Στο παράδειγμά μας, Address (32 bits)

h CPU ζητάει να 0000 .... 0001 1000000000 10
προσπελάσει την 20 10
διεύθυνση 6146
(00..01 1000000000 Index Valid
...
Tag Data
10). 512
...
• Ο cache controller θα Tag 8 8 8 8
φέρει στην cache όλο =
το block (6144-6147) Mux
8
Hit Data

16
(HY232)
Μέγεθος του block και ρυθμός αστοχίας
• Γραφική παράσταση που δείχνει τον ρυθμό αστοχίας συναρτήσει
του μεγέθους του block για μνήμες cache διαφορετικών μεγεθών
– Μικρά blocks δεν εκμεταλλεύονται την χωρική τοπικότητα όπως έχουμε πει.
– Αλλά και πολύ μεγάλα blocks δημιουργούν το πρόβλημα ότι δεν υπάρχουν
πολλά blocks στην cache, με αποτέλεσμα να δημιουργούνται επιπλέον
αστοχίες.
40%
35%
30%
1 KB
25%
Miss rate
8 KB
20% 16 KB
64 KB
15%
10%
5%
0%
4 16 64 256
Block size (bytes)

17
(HY232)
Βελτίωση της χρονικής τοπικότητας

• Οι direct-mapped caches είναι εύκολες να υλοποιηθούν σε
hardware, και είναι απλό να υπολογίσουμε το (μοναδικό) block
που αντιστοιχεί σε κάθε διεύθυνση.
Memory
Address
• Πλην όμως είναι περιοριστικές
στην λειτουργία τους γιατί κάθε 0000
0001
διεύθυνση της μνήμης μπορεί να 0010
αποθηκευθεί σε ένα και μοναδικό 0011
σημείο της cache. 0100 Index
• Για παράδειγμα, εάν ένα 0101
00
πρόγραμμα προσπελαύνει τις 0110
01
διευθύνσεις 2, 6, 2, 6, 2, ..., 0111
10
1000
κάθε προσπέλαση θα είναι miss, 1001 11
αν και η cache είναι κατά τα άλλα 1010
άδεια! 1011
• Θα πρέπει λοιπόν να κάνουμε 1100
κάτι για να αλλάξουμε τον 1101
περιορισμό της μοναδικής 1110
1111
απεικόνισης της direct-mapped
cache. Οργάνωση και Σχεδίαση Η/Υ
18
(HY232)
Πλήρως συσχετιστική μνήμη cache
(fully-associative cache)
• H πλήρως συσχετιστική (fully-associative) cache ακολουθεί την
ακριβώς αντίθετη στρατηγική: τα δεδομένα από την μνήμη
επιτρέπεται να αποθηκευθούν σε ΟΠΟΙΟΔΗΠΟΤΕ block της
cache.
– Με αυτόν τον τρόπο δεν θα υπάρχει ποτέ σύγκρουση μεταξύ δύο η
περισσότερων διευθύνσεων που αποθηκεύονται στο ίδιο cache block.
• Στο προηγούμενο παράδειγμα, η διεύθυνση 2 μπορεί να
τοποθετηθεί στο block 2, και η διεύθυνση 6 στο block 3. Από εκεί
και πέρα θα έχουμε συνέχεια hits και όχι misses.
• To ενδιαφέρον ερώτημα που θα δούμε σύντομα είναι ποιο block
αντικαθιστούμε όταν γεμίσει η cache.

19
(HY232)
Fully-associative cache
• Οι fully-associative caches είναι όμως ακριβές γιατί πιάνει πολύ
χρόνο το να διαπιστώσουμε εάν έχουμε Hit OR Miss.
– Δεν υπάρχει πεδίο index στην διεύθυνση
– Τα δεδομένα μπορούν να είναι παντού στην cache, το οποίο σημαίνει ότι θα
πρέπει να ελέγξουμε τα tags κάθε block για να δούμε εάν δεδομένα είναι
στην cache.
– Αυτό χρειάζεται πολλούς συγκριτές και παίρνει πολύ χρόνο.
Address (32 bits) Index Valid Tag (32 bits) Data

...
...
32 ...
Tag
= Hit

20
(HY232)
Συσχετιστική μνήμη συνόλου
(set-associative cache)
• Μια ενδιάμεση λύση είναι η συσχετιστική μνήμη συνόλου (set-
associative cache).
– Η cache χωρίζεται σε groups από blocks, που ονομάζονται σύνολα (sets).
– Κάθε διεύθυνση μνήμης μπορεί να τοποθετηθεί σε ένα και μόνο σύνολο στην
cache, αλλά σε οποιοδήποτε block μέσα στο σύνολο.
– Εάν ένα σύνολο αποτελείται από X blocks, η cache ονομάζεται συσχετιστική
μνήμη συνόλου X δρόμων (Χ-way set associative cache).
1-way 2-way 4-way 8-way
8 sets, 4 sets, 2 sets, 1 set,
1 block each 2 blocks each 4 blocks each 8 blocks
0
Set Set Set Set
1 0
2 0
1
3
0
4
2
5 1
6 3
7
direct mapped fully associative
21
(HY232)
Πως βρίσκουμε διευθύνσεις στην set

associative cache
(m-s-n) s n
Address (m bits) Tag Set index Block
offset
• Διαίρεση διεύθυνσης μνήμης με 2s σύνολα, και μέγεθος block 2n

bytes
Block Offset = Memory Address mod 2n

Block Address = Memory Address / 2n
Set Index = Block Address mod 2s

22
(HY232)
Υλοποίηση συσχετιστική μνήμη συνόλου
4-way set associative

256 σύνολα
1 cache block έχει 4 bytes
Μέγεθος cache 256*4*4 = 4KB
Παράδειγμα Associativity
• Έστω μια μνήμη cache με 4 blocks
– Direct mapped, 2-way set associative,
fully associative
– Αλληλουχία διευθύνσεων που προσπελαύνουμε: 0, 8, 0, 6, 8
• Direct mapped
Block Cache Hit/miss Cache content after access

address index 0 1 2 3
0 0 miss Mem[0]
8 0 miss Mem[8]
0 0 miss Mem[0]
6 2 miss Mem[0] Mem[6]

• 2-way set associative
Block Cache Hit/miss Cache content after access
address index Set 0 Set 1
0 0 miss Mem[0]
0 0 hit Mem[0] Mem[8]
• Fully associative
Block Hit/miss Cache content after access
address
0 miss Mem[0]
8 miss Mem[0] Mem[8]
0 hit Mem[0] Mem[8]
6 miss Mem[0] Mem[8] Mem[6]
8 hit Mem[0] Mem[8] Mem[6]
• Υποθέστε ότι έχουμε μια μνήμη cache με 8 blocks, 16 bytes/blocks. Σε ποιο cache block
θα τοποθετηθούν τα δεδομένα που βρίσκονται στην διεύθυνση 6195, για κάθε μία από
τις 3 περιπτώσεις οργάνωσης της cache;
• Το 6195 στο δυαδικό σύστημα είναι 00...01100000110011.
• Κάθε block έχει 16 bytes, άρα τα 4 LSB είναι το Block offset.
• Η direct mapped cache έχει 8 sets, και άρα τα επόμενα 3 bits (011) είναι ο set index.
Η 2-way set associative cache έχει 4 sets, και άρα τα επόμενα 2 bits (11) είναι ο set
index.
Η 4-way set associative cache έχει 2 sets, και άρα τo επόμενα 1 bit (1) είναι ο set index.
• Tα δεδομένα μπορούν να μπουν σε κάθε block από τα πράσινα στην cache.
direct mapped 2-way associativity 4-way associativity
8 sets, 1 block each 4 sets, 2 blocks each 2 sets, 4 blocks each
Set Set Set
0
1 0
2 0
1
3
4
2
5 1
6 3
7
26
(HY232)
Αντικατάσταση blocks
• Εάν δεν υπάρχουν άδεια blocks σε ένα σύνολο (set) όταν
προσπαθούμε να φέρουμε ένα νέο block στην cache, o ελεγκτής
της cache (cache controller) θα αντικαταστήσει το block που έχει
να χρησιμοποιηθεί τον περισσότερο χρόνο (Least Recently Used,
LRU).
– Αυτός είναι ο πιο συνηθισμένος αλγόριθμος, αλλά δεν είναι και ο μόνος
Direct mapped 2-way associativity 4-way associativity

8 sets, 1 block each 4 sets, 2 blocks each 2 sets, 4 blocks each
Set Set Set

0
1 0
2 0
1
3
4
2
5 1
6 3
7

27
(HY232)
Παράδειγμα αλγόριθμου LRU

• Υποθέστε ότι έχουμε μια fully-associative cache με μόνο 2 blocks,
και μια σειρά από διευθύνσεις από την CPU
– Πως λειτουργεί ο αλγόριθμος LRU;
addresses 0 Tags 1 LRU
-- -- 0
miss A
Αντικαθιστούμε το A -- 1
LRU block, όταν miss B
υπάρχει miss. A B 0
hit A
Ανανεώνουμε το A B 1
LRU, όταν υπάρχει miss C
hit. A C 0
miss B
B C 1
miss A
B A 0
hit B
B A 1
28
(HY232)
Associativity και ρυθμός αστοχίας
• Μεγαλύτερη cache και μεγαλύτερος βαθμός associativity
βελτιώνουν την ευστοχία της cache(δηλ. μειώνουν το miss rate)
• Όμως μεγαλύτερος βαθμός associativity απαιτεί και μεγαλύτερο
χρόνο εκτέλεσης. Άρα είναι πιθανόν να μειώνει και το Hit Time
(=bad!!)
15%
12%
9%
Miss rate
1 KB
2 KB
4 KB
6% 8 KB
3%
0%
One-way Two-way Four-way Eight-way
Associativity

29
(HY232)
Cache organizations (II)

• Είδαμε δύο βασικές τεχνικές μείωσης του ρυθμού αστοχίας
• Πως μπορούμε να μειώσουμε την ποινή αστοχίας (miss penalty);

30
(HY232)
Μνήμες cache πολλαπλών επιπέδων
• Μπορούμε να μειώσουμε την ποινή αστοχίας με το τοποθετήσουμε
ακόμα μία μνήμη cache για να εξυπηρετεί όλες τις αστοχίες που
προέρχονται από την αρχική μας cache.
– H αρχική cache είναι μικρή (L1 Cache) και γρήγορη
– Μία L1 cache για εντολές (I-Cache), και μία για δεδομένα (D-Cache)
• H L2 Cache είναι μεγαλύτερη και πιο αργή από την L1 Cache.
– Αλλά είναι πολύ πιο γρήγορη από την κύρια μνήμη
• Τα περισσότερα επεξεργαστικά συστήματα έχουν και τρίτο επίπεδο
μνήμης cache (L3 Cache)
– Η L3 Cache εξυπηρετεί όλες τις αστοχίες της L2 Cache
– Οι αστοχίες της L3 Cache εξυπηρετούνται από την κύρια μνήμη
– Δεν υπάρχει L4 Cache (!) σε κανένα σύστημα από ότι ξέρω.
• Η L2 και L3 Caches είναι unified, δηλ. αποθηκεύουν και εντολές
και δεδομένα στον ίδιο χώρο.
– Επίσης έχουν μεγαλύτερο βαθμό συσχετιστικότητας (associativity)
31
(HY232)
Μνήμες cache πολλαπλών επιπέδων

Για την L1 Cache το σημαντικό
είναι το χαμηλό Hit time. Πρέπει
δηλ. να μπορούμε να τις
προσπελαύνουμε σε 1-2 κύκλους
ρολογιού
Έχουν μικρό μέγεθος (16-64
KB) και είναι συνήθως direct-
mapped.
Για τις L2 και L3 Cache το
σημαντικό είναι να έχουν χαμηλό
miss rate, για να αποφύγουμε
προσπέλαση στην κύρια μνήμη
Έχουν μεγάλο μέγεθος (L2
Cache ~ 256KB, L3 Cache 2-3
MB)
Έχουν μεγάλα cache blocks
Έχουν υψηλό associativity.

Παράδειγμα μνημών cache πολλαπλών
επιπέδων (I)
• ΑΜΑΤ = Average Memory Access Time =
Hit Time (L1) + Miss Rate (L1) * Miss Penalty (L1->L2) +
Miss Rate (L1) * Local Miss Rate (L2) * Miss Penalty (L2->
Main Mem)
Local Miss Rate (L2) : ο ρυθμός αστοχίας της L2 Cache από τις
προσπελάσεις που έρχονται από την L1 Cache.
Global Miss Rate (L2) = Miss Rate (L1) * Local Miss Rate (L2): ο
ρυθμός αστοχίας της L2 Cache από τις συνολικές προσπελάσεις
που έρχονται από την CPU

33
(HY232)

επιπέδων (I)
• Έστω ένα σύστημα με τις παρακάτω προδιαγραφές
– CPU base CPI = 1, clock rate = 4GHz
– Miss rate/instruction = 2%
– Χρόνος προσπέλασης κύριας μνήμης = 100ns
• Με μόνο L1 Cache:
– Ποινή αστοχίας σε κύκλους μηχανής = 100ns/0.25ns = 400 cycles
– CPI = 1 + 0.02 × 400 = 9

34
(HY232)
επιπέδων (II)
• Έστω ότι βάζουμε μια L2 Cache στο σύστημά μας
– Χρόνος προσπέλασης της L2 Cache = 5ns
– L2 Global miss rate = 0.5%
• Τα 5ns αντιστοιχούν σε 5ns/0.25ns = 20 cycles. Κάθε φορά που

υπάρχει miss στην L1 Cache, πληρώνουμε 20 κύκλους να
προσπελάσουμε την L2 Cache.
• CPI = 1 + 0.02 × 20 + 0.005 × 400 = 3.4
• Performance ratio = 9/3.4 = 2.6
Γιατί είναι σημαντική η ιεραρχία της μνήμης

• Η ιεραρχία της μνήμης είναι πάρα πολύ σημαντική
στους σύγχρονους επεξεργαστές με πολλούς πυρήνες.
– Συνολικό maximum bandwidth που απαιτείται από την
CPU.
• O Intel Core i7 μπορεί να εκτελέσει μέχρι 2 εντολές load/store σε κάθε
κύκλο μηχανής
• Έχει 4 πυρήνες με ρολόι στα 3.2 GHz
– 2*4*3,2 = 25,6 δισ. 64-bit προσπελάσεις δεδομένων/second +
12.8 δισ. 128-bit προσπελάσεις εντολών/second = 409.6 GB/s!
– To bandwidth της DRAM είναι μόλις 25GB/s (6% αυτού που
απαιτείται!!). Δεν μπορεί να ικανοποιήσει από μόνη της
την CPU.
• Η ιεραρχία της μνήμης λοιπόν είναι πολύ σημαντική.

Που οφείλονται οι αστοχίες της cache;
• Μοντέλο των 3C
• Υποχρεωτικές αστοχίες (Compulsory or Cold misses)
– Πρώτη πρόσβαση σε ένα block. Δεν μπορεί να αποφευχθεί.
• Αστοχίες Χωρητικότητας(Capacity misses)
– Οφείλονται στο ότι η cache δεν είναι αρκετά μεγάλη για να περιέχει όλα τα
blocks που χρειάζονται από την CPU σε κάθε χρονική περίοδο.
– Ένα block αντικαθίσταται και μετά το επαναφέρουμε στην cache
– Είναι ο σημαντικότερος λόγος για αστοχίες cache εκτός εάν η cache είναι
πολύ μεγάλη
• Αστοχίες διένεξης (Conflict misses)
– Συμβαίνουν σε μνήμες cache που δεν είναι fully-associative
– Πολλά blocks ανταγωνίζονται να μπουν στο ίδιο σύνολο της cache
– Δεν θα συνέβαιναν εάν η cache ήταν fully-associative
Διάλεξη 16
Εικονική Μνήμη
(Virtual memory)
Προβλήματα φυσικής μνήμης (1)
• Τι θα συμβεί εάν η μνήμη που χρειάζεται το πρόγραμμά
μας είναι περισσότερη από το μέγεθος της κύριας
μνήμης;
– Θα μπορούσαμε να αποθηκεύσουμε όλο το πρόγραμμα στον
σκληρό δίσκο, και να χρησιμοποιήσουμε την κύρια μνήμη σαν
cache του σκληρού δίσκου
– Αυτό είναι η εικονική μνήμη (virtual memory): μια τεχνική που
επιτρέπει την χρησιμοποίηση της κύριας μνήμης ως cache του
σκληρού δίσκου.
– Πριν την εφεύρεση της εικονικής μνήμης, οι προγραμματιστές
έπρεπε να προνοήσουν να μεταφέρουν προγράμματα και
δεδομένα μεταξύ δίσκου και κύριας μνήμης κάθε φορά που
αυτά δεν χωρούσαν στην κύρια μνήμη.
• Πολύπλοκο, κουραστικό και γεμάτο κινδύνους για λάθη. Οι
προγραμματιστές παλαιότερα έπρεπε να κάνουν πολύ περισσότερα από
το απλώς να γράφουν ένα πρόγραμμα για μια εφαρμογή.
Οργάνωση και Σχεδιάση Η/Y
2
(HY232)
Προβλήματα φυσικής μνήμης (2)

• Τι θα συμβεί εάν θέλουμε να εκτελούμε σε έναν
επεξεργαστή ταυτόχρονα πολλά προγράμματα ή
διεργασίες;
1. Ακόμα και εάν ένα πρόγραμμα χωράει στην κύρια μνήμη, 10
προγράμματα μπορεί να μην χωράνε.
2. Πολλαπλά προγράμματα θέλουν αν γράψουν στην ίδια
διεύθυνση μνήμης; Πρόβλημα!
• Τι θα συμβεί εάν δύο διαφορετικά προγράμματα Α και Β θέλουν πχ να
χρησιμοποιήσουν την θέση μνήμης 0x10000000 ως βάση του stack
τους;
3. Πως μπορούμε να προστατεύσουμε τα δεδομένα ενός
προγράμματος από το να διαβαστούν ή και να γραφούν από
κάποιο άλλο πρόγραμμα;

3
(HY232)
H ιδέα της έμμεσης προσπέλασης
• Η έμμεση προσπέλαση είναι ή δυνατότητα να μπορούμε να
προσπελάσουμε ένα αντικείμενο (πχ μια μεταβλητή)
χρησιμοποιώντας ένα συμβολικό όνομα αντί την τιμή του ίδιου του
αντικειμένου. Αγγλικός όρος indirection.
• Άμεση προσπέλαση
Name
Thing
• Έμμεση προσπέλαση
Name
Thing
Thing
• Παράδειγμα είναι οι pointers στην C

4
(HY232)
Εικονική Μνήμη (Virtual Memory)

• Οι εικονικές διευθύνσεις (virtual addresses) που χρησιμοποιείτε σαν
προγραμματιστές μεταφράζονται σε φυσικές (δηλ. πραγματικές) διευθύνσεις
(physical addresses) στην κύρια μνήμη ή στον σκληρό δίσκο.
• Η μετάφραση αυτή από εικονικές σε φυσικές διευθύνσεις υλοποιεί την ιδέα της
έμμεσης προσπέλασης.
Physical Δηλ., οι διευθύνσεις μεταβλητών

Memory που χρησιμοποιείτε στα
Virtual Address
προγράμματα σας είναι εικονικές,

δεν αντιστοιχούν δηλ. σε
πραγματικές διευθύνσεις στην
μνήμη ή στον σκληρό δίσκο.
Πχ.
Disk int *ptr = (int *)
0x1000FFFF;
Η διεύθυνση 0x1000FFFF είναι
εικονική.

5
(HY232)
Εικονική Μνήμη
• Διαφορετικά προγράμματα έχουν διαφορετική απεικόνιση (mapping) από την
εικονική στην φυσική μνήμη (virtual  physical).
• Αυτό έχει σαν αποτέλεσμα ότι ακόμα και να χρησιμοποιούν δύο προγράμματα
την ίδια εικονική διεύθυνση, αυτή θα απεικονισθεί σε διαφορετικές φυσικές
θέσεις μνήμης.
• Με το να αντιστοιχήσουμε διαφορετικές περιοχές φυσικής μνήμης στο
πρόγραμμα Α και στο B, εμποδίζουμε το να διαβάζουν και να γράφουν το ένα
πρόγραμμα από το άλλο.
Program A Physical Program B
Memory
Virtual Address
Virtual Address
0x1000FFFF
0x1000FFFF
Disk

6
(HY232)
Εικονική μνήμη ως μηχανισμός cache

• Ο μηχανισμός μετάφρασης από εικονική σε φυσική μνήμη μπορεί
να ειδωθεί και ως μηχανισμός cache. Έχουμε τα ίδια προβλήματα
να επιλύσουμε όπως και με την ιεραρχία μνήμης.
– Θέλουμε να έχουμε το μέγεθος του σκληρού δίσκου και την ταχύτητα
προσπέλασης της φυσικής μνήμης.
• Ο μηχανισμός της εικονικής μνήμης κρύβει τον μεγάλο χρόνο
προσπέλασης του σκληρού δίσκου. Και εδώ το πράγματα είναι
πολύ χειρότερα:
– Ενώ ο χρόνος προσπέλασης της κύριας μνήμης είναι 200-400 κύκλοι
μηχανής, ο μέσος χρόνος προσπέλασης του σκληρού δίσκου είναι περίπου
δέκα εκατομμύρια κύκλοι!
– Συνεπώς δεν επιτρέπονται πολλές αστοχίες κατά την μετάφραση

7
(HY232)
Μετάφραση εικονικής διεύθυνσης
• Η CPU και το λειτουργικό σύστημα μεταφράζουν τις εικονικές
διευθύνσεις σε φυσικές.
– Κάθε εικονική διεύθυνση χωρίζεται σε αριθμό σελίδας (virtual page number) και
μετατόπιση σελίδας (page offset).
– Οι σελίδες είναι το αντίστοιχο του block στις caches, πλην όμως πολύ
μεγαλύτερες (αρκετά KB)
– Μόνο ο αριθμός σελίδας μεταφράζεται. Η μετατόπιση είναι η ίδια τόσο στην
εικονική όσο και στην φυσική διεύθυνση
Οργάνωση και Σχεδιάση Η/Y (HY232) 8
Πως βρίσκουμε την κατάλληλη

σελίδα
• Η μετάφραση γίνεται με την χρήση του πίνακα σελίδων (page
table).
– Κάθε διεργασία έχει το δικό της πίνακα σελίδων
– Ο καταχωρητής πίνακα σελίδων (page table register) δείχνει την αρχή του
πίνακα σελίδων για την διεργασία που είναι ενεργή αυτήν την στιγμή
– O πίνακας σελίδων αποθηκεύει την φυσική διεύθυνση της αρχής της σελίδας
– Επίσης και control bits το πιο σημαντικό εκ’ των οποίων είναι το valid bit.

9
(HY232)
Πίνακας σελίδων και μετάφραση
• Κάθε γραμμή του πίνακα σελίδων περιέχει τον αριθμό της φυσικής σελίδας (PPN), και
το valid bit.
• Εάν valid bit = 1, η φυσική σελίδα είναι στην κύρια μνήμη.
• Εάν valid bit = 0, η φυσική σελίδα είναι στον σκληρό δίσκο και προκαλεί σφάλμα
σελίδας (page fault). Παίρνει εκατομμύρια κύκλους μηχανής να φέρουμε την σελίδα
από τον σκληρό δίσκο.
Σύστημα με 220 σελίδες και

μέγεθος σελίδας 4KB.
O πίνακας σελίδων έχει 1M
εισόδους.

10
(HY232)
Υπάρχει όμως ένα πρόβλημα

• Για να κάνουμε την μετάφραση πρέπει να προσπελάσουμε τον
πίνακα σελίδων στην κύρια μνήμη. Μετά γίνεται και η κανονική
προσπέλαση.
• Δηλ. κάθε προσπέλαση μνήμης, είτε εντολές είτε δεδομένα, πρέπει
να προσπελάσει πρώτα την κύρια μνήμη, αχρηστεύοντας την όλη
ιδέα της cache.
• Και δεν έχουμε μιλήσει ακόμα για την χειρότερη περίπτωση, δηλ. η
φυσική σελίδα να είναι στον σκληρό δίσκο και όχι στην μνήμη
• Η λύση είναι να εισάγουμε έναν επιπλέον μηχανισμό cache για να

αποθηκεύουμε τον πίνακα σελίδων

11
(HY232)
Κρυφή μνήμη αναζήτησης μετάφρασης
(Translation-lookaside buffer, TLB)
• Το TLB είναι μια μνήμη cache που αποθηκεύει μέρος του πίνακα σελίδων
• Συνήθως fully-associative, με μικρό μέγεθος 16-512 καταχωρήσεις, μέγεθος block
4-8 bytes και Miss rate πολύ μικρό 0,01-1%
• Είναι χρονικά η πρώτη μνήμη που προσπελαύνει ο επεξεργαστής για εντολές και
δεδομένα
• ITLB και DTLB

12
(HY232)
Σχέση TLB και Caches
• Σε περίπτωση TLB Hit η

διεύθυνση της φυσικής σελίδας
στο TLB μαζί με την μετατόπιση
σελίδας (page offset) αποτελεί
την φυσική διεύθυνση.
• H φυσική διεύθυνση
χρησιμοποιείται για την
προσπέλαση της cache.
• Οι μνήμες cache (όλων των
επιπέδων) είναι virtually -
indexed, physically-addressed.

Σχέση TLB και Caches
• Σε περίπτωση TLB Miss, η
καταχώρηση πρέπει να έρθει από
τον πίνακα σελίδων (page table)
στο TLB. Δηλ. πρέπει να κάνουμε
προσπέλαση στην κύρια μνήμη.
• Το λειτουργικό σύστημα το κάνει
αυτό στον MIPS.
• H χειρότερη περίπτωση είναι η

φυσική σελίδα που ζητάμε να μην
είναι στην κύρια μνήμη, αλλά να
πρέπει να την διαβάσουμε από
τον σκληρό δίσκο. Αυτό είναι το
σφάλμα σελίδας (page fault).
• Το λειτουργικό σύστημα
διακόπτει την εκτέλεση του
προγράμματος μας και
αναλαμβάνει να διαβάσει την
σελίδα από τον σκληρό δίσκο.
Προστασία μνήμης (Memory Protection)

• Μέσω της έμμεσης προσπέλασης, η εικονική μνήμη εμποδίζει μια
διεργασία να διαβάσει και να γράψει το κομμάτι της φυσικής
μνήμη μιας άλλης διεργασίας.
• Για να το εξασφαλίσουμε αυτό θα πρέπει να εμποδίσουμε μία
διεργασία (user process) να μπορεί να αλλάξει τα περιεχόμενα του
πίνακα σελίδων.
• Αυτό επιτυγχάνεται ως εξής:
– Ο επεξεργαστής λειτουργεί σε δύο καταστάσεις (modes): user &
kernel mode.
• To λειτουργικό σύστημα τρέχει πάντα όταν η CPU είναι σε kernel mode.
– H κατάσταση του πίνακα σελίδων μπορεί να αλλάξει μόνο από
μία διεργασία που τρέχει σε kernel mode. Τι μπορεί να αλλάξει
σε kernel mode?
• Πίνακα σελίδων (Page Table)
• Καταχωρητής πίνακα σελίδων (Page Table Base Pointer)
• To TLB
15
(HY232)
Memory Sharing
• Δύο διεργασίες μπορούν να μοιράζονται την ίδια φυσική μνήμη με
το να επιτρέπουν τους πίνακες σελίδων τους να δείχνουν στις ίδιες
φυσικές διευθύνσεις
• Για παράδειγμα, εάν τρέχετε δύο αντίγραφα του ίδιου
προγράμματος, το λειτουργικό σύστημα θα επιτρέψει την
ταυτόχρονη προσπέλαση της ίδιας φυσικής μνήμης.
Program A Physical Program B
Memory
Virtual Address
Virtual Address
Disk

16
(HY232)
Prefetching
• Πολλά συστήματα υψηλής απόδοσης κάνουν aggressive data and
instruction prefetching.
• To prefetching διακόπτεται αμέσως όταν προκαλέσει ένα TLB miss.

– Δεν θέλουμε το prefetch να είναι υπεύθυνο για τόσο μεγάλη
διακοπή της ροής του προγράμματος.
• Οι HW prefetchers φέρνουν δεδομένα μέσα σε μία σελίδα (page).

– Συνήθως δουλεύουν με φυσικές μνήμες και δεν χρησιμοποιούν
το TLB.

17
(HY232)
Intel x86 ISA
RISC vs. CISC

• Η assembly των επεξεργαστών ARM, SPARC (Sun),
και Power (IBM) είναι όμοιες με την assembly του
MIPS.
– Αρχιτεκτονική RISC (Reduced Instruction Set Architectures)
• H assembly της σειράς των επεξεργαστών Intel 80x86

είναι κάπως διαφορετική.
• Αρχιτεκτονική CISC (Complex Instruction Set Architectures)
Οργάνωση και Σχεδίαση ΗΥ 2

(ΗΥ232)
Σύγκριση x86 και MIPS
• Οι δύο αυτές αρχιτεκτονικές έχουν πολλά κοινά
χαρακτηριστικά.
– Έχουν καταχωρητές και byte-addressable μνήμες.
– Οι πιο πολλές εντολές είναι όμοιες (αριθμητικές, λογικές, μεταφοράς,
διακλάδωσης)
• Αλλά και διαφορές (διαφορές του x86, 32 bits ή ΙΑ-32)
– Λιγότεροι καταχωρητές (8) με διαφορετικά ονόματα και λιγότερο
γενικού σκοπού. Ο x86-64 έχει 16 καταχωρητές.
– Η έλλειψη πολλών καταχωρητών έχει ως αποτέλεσμα πολύ
μεγαλύτερη χρήση της στοίβας που είναι τμήμα της αρχιτεκτονικής.
– Ο x86 χρησιμοποιεί 2 I/O operands, ενώ ο MIPS 3
– Πράξεις με έμμεση χρήση της μνήμης: Memory + Reg  Reg. Κύρια
ίσως διαφορά μεταξύ CISC και RISC
– Εντολές διακλάδωσης με χρήση conditional flags
– Εντολές με διαφορετικό μήκος (από 1 μέχρι και 17 bytes)
(ΗΥ232)
Καταχωρητές του IA-32

• Λιγότεροι και ειδικού σκοπού
– 8 καταχωρητές ακεραίων
• eax, ebx, ecx, edx (γενικού σκοπού)
• ebp (frame pointer)
• esp (stack pointer)
• esi (extended source index)
• edi (extended destination index)
– Ειδικού σκοπού
• eip (Instruction Pointer – PC)
• eflags (Conditional Flags)
– Αντίθετα με τον MIPS, δεν μπορούν
όλες οι εντολές να χρησιμοποιήσουν
όλους τους καταχωρητές
(ΗΥ232)
Καταχωρητές του IA-32
• Δεν υπάρχει πολύς χώρος για
temporary values σε πράξεις
– O x86 χρησιμοποιεί κώδικα 2 τελεστέων
(operands)
– op x, y # y = y op x
• Πολύ δύσκολο για τον compiler (ή τον
προγραμματιστή) να αποθηκεύσει
όλες τις μεταβλητές σε καταχωρητές.
• Χρήση της στοίβας για αυτόν τον
λόγο.
• Ο x86-64 έχει 8+8 καταχωρητές των
64 bits
– rax, .., rdi, r8, r15

(ΗΥ232)
H στοίβα στον x86

• Η στοίβα είναι κομμάτι της μνήμης με ειδικό status
• O καταχωρητής esp είναι ο stack pointer
• Εντολές push και pop μόνο για την στοίβα:
– push %eax # ESP = ESP – 4. M[ESP] = EAX
– pop %ecx # ECX = M[ESP]. ESP = ESP + 4
– Όπως ακριβώς και στον MIPS, η στοίβα μεγαλώνει από μεγαλύτερες προς
μικρότερες διευθύνσεις.
• H εντολή call (η αντίστοιχη του jal) σπρώχνει την διεύθυνση επιστροφής
στο stack
– call label # ESP = ESP – 4. M[ESP] = EIP+5. EIP = label
• Η στοίβα χρησιμοποιείται και για να περνούμε παραμέτρους σε
συναρτήσεις
– Δεν υπάρχουν καταχωρητές $a0, $a1, κοκ όπως στον MIPS.
• O καταχωρητής ebp είναι ο frame pointer (ή base pointer) και δείχνει
στην αρχή του frame μιας συνάρτησης
• Χρησιμοποιείται ευρέως γιατί δεν αλλάζει συχνά τιμή όπως ο esp
(ΗΥ232)
Ένα απλό παράδειγμα
int main() {
int one = 123, two = 456;
swap(&one, &two);
...
}
void swap(int *xp, int *yp)

{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}

(ΗΥ232)

int main() { 0x124
int one = 123, two = 456;
swap(&one, &two); 0x120
... 0x11c %ebp,esp
}
0x118
… 0x114
subl $8, %esp 0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x10c
leal -4(%ebp), %eax
pushl %eax
leal -8(%ebp), %eax Key:
pushl %eax sub = subtract
call swap l = long (32-bit operation)
... $8 = literal 8
%esp= stack pointer register
ESP = ESP - 8

(ΗΥ232)
int main() { 0x124
int one = 123, two = 456;
... 0x11c %ebp
}
0x118
0x114 %esp
…
subl $8, %esp 0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x10c
leal -4(%ebp), %eax
pushl %eax
pushl %eax mov = data movement
call swap l = long (32-bit operation)
... $123 = literal 123
-8(%ebp) = base + offset addressing
M[EBP - 8] = 123

(ΗΥ232)

int main() { 0x124
int one = 123, two = 456;
... 0x11c %ebp
}
0x118
123 0x114 %esp
…
subl $8, %esp 0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x10c
leal -4(%ebp), %eax
pushl %eax
leal -8(%ebp), %eax
pushl %eax
call swap
...

(ΗΥ232)
int main() { 0x124
int one = 123, two = 456;
... 0x11c %ebp
}
456 0x118
123 0x114 %esp
…
subl $8, %esp 0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x10c
leal -4(%ebp), %eax
pushl %eax
pushl %eax (push arguments in reverse order)
call swap lea = load effective address
... (don’t do a load, just compute addr.)
EAX = EBP - 4
M[ESP - 4] = EAX
ESP = ESP - 4

(ΗΥ232)

int main() { 0x124
int one = 123, two = 456;
... 0x11c %ebp
}
456 0x118
123 0x114
…
subl $8, %esp 0x118 %esp
0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x10c
leal -4(%ebp), %eax
pushl %eax
leal -8(%ebp), %eax
pushl %eax
call swap
...

(ΗΥ232)
int main() { 0x124
int one = 123, two = 456;
... 0x11c %ebp
}
456 0x118 swap()
parameters.
123 0x114 Inverse
…
subl $8, %esp order
0x118 0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x114 0x10c %esp
leal -4(%ebp), %eax
pushl %eax 0x108
leal -8(%ebp), %eax
pushl %eax 0x104
call swap
... Key:
M[ESP - 4] = next_EIP
ESP = ESP - 4
EIP = swap

(ΗΥ232)

int main() { 0x124
int one = 123, two = 456;
... 0x11c %ebp
}
456 0x118
123 0x114
…
subl $8, %esp 0x118 0x110
movl $123, -8(%ebp)
movl $456, -4(%ebp) 0x114 0x10c
leal -4(%ebp), %eax %esp
pushl %eax RTN ADR 0x108
leal -8(%ebp), %eax
pushl %eax 0x104
call swap
...

(ΗΥ232)
Συνάρτηση swap
swap:
pushl %ebp Πρόλογος
movl %esp,%ebp
pushl %ebx
void swap(int *xp, int *yp) movl 12(%ebp),%ecx
{ movl 8(%ebp),%edx
int t0 = *xp; movl (%ecx),%eax
int t1 = *yp; movl (%edx),%ebx Σώμα
*xp = t1; movl %eax,(%edx)
*yp = t0; movl %ebx,(%ecx)
}
movl -4(%ebp),%ebx
movl %ebp,%esp Επίλογος
popl %ebp
ret

(ΗΥ232)
Πρόλογος swap
{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1; %ebp
*yp = t0; 0x11c
}
456 0x118
123 0x114
swap: 0x118 0x110

pushl %ebp 0x114
movl %esp,%ebp 0x10c
pushl %ebx RTN ADR 0x108 %esp
0x104
Σώζουμε τον παλιό base pointer στην στοίβα

(ΗΥ232)
{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1; %ebp
*yp = t0; 0x11c
}
456 0x118
123 0x114
swap: 0x118 0x110

pushl %ebp 0x114
pushl %ebx RTN ADR 0x108
%esp
0x11c 0x104
Ο παλιός stack pointer γίνεται ο νέος base pointer

(ΗΥ232)
{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1;
*yp = t0; 0x11c
}
456 0x118
123 0x114
swap: 0x118 0x110

pushl %ebp 0x114
%ebp,esp
0x11c 0x104
0x100
Σώζουμε τον καταχωρητή ebx γιατί θα γίνει overwrite στην swap (callee saved).

(ΗΥ232)
{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1;
*yp = t0; 0x11c
}
456 0x118
123 0x114
swap: 0x118 0x110

pushl %ebp 0x114
%ebp
0x11c 0x104
… 0x100
%esp

(ΗΥ232)
Σώμα της swap

{ 456 0x118
int t0 = *xp; Register Variable
int t1 = *yp; 123 0x114
*xp = t1; %ecx yp
0x118 0x110
*yp = t0; %edx xp
} 0x114 0x10c
%eax t1
%ebx t0 RTN ADR 0x108
%ebp
0x11c 0x104
… 0x100
%esp
movl 12(%ebp),%ecx # ecx = yp
movl 8(%ebp),%edx # edx = xp
movl (%ecx),%eax # eax = *yp (t1) %eax
movl (%edx),%ebx # ebx = *xp (t0) %edx
movl %eax,(%edx) # *xp = eax
%ecx 0x118
movl %ebx,(%ecx) # *yp = ebx
%ebx

(ΗΥ232)
{ 456 0x118
int t1 = *yp; 123 0x114
*xp = t1; %ecx yp
0x118 0x110
*yp = t0; %edx xp
} 0x114 0x10c
%eax t1
%ebp
0x11c 0x104
… 0x100
%esp
movl (%ecx),%eax # eax = *yp (t1) %eax
movl (%edx),%ebx # ebx = *xp (t0) %edx 0x114
%ecx 0x118
%ebx

(ΗΥ232)

{ 456 0x118
int t1 = *yp; 123 0x114
*xp = t1; %ecx yp
0x118 0x110
*yp = t0; %edx xp
} 0x114 0x10c
%eax t1
%ebp
0x11c 0x104
… 0x100
%esp
movl (%ecx),%eax # eax = *yp (t1) %eax 456
%ecx 0x118
%ebx

(ΗΥ232)
{ 456 0x118
int t1 = *yp; 123 0x114
*xp = t1; %ecx yp
0x118 0x110
*yp = t0; %edx xp
} 0x114 0x10c
%eax t1
%ebp
0x11c 0x104
… 0x100
%esp
%ecx 0x118
%ebx 123

(ΗΥ232)

{ 456 0x118
int t1 = *yp; 456 0x114
*xp = t1; %ecx yp
0x118 0x110
*yp = t0; %edx xp
} 0x114 0x10c
%eax t1
%ebp
0x11c 0x104
… 0x100
%esp
%ecx 0x118
%ebx 123

(ΗΥ232)
{ 123 0x118
int t1 = *yp; 456 0x114
*xp = t1; %ecx yp
0x118 0x110
*yp = t0; %edx xp
} 0x114 0x10c
%eax t1
%ebp
0x11c 0x104
… 0x100
%esp
%ecx 0x118
%ebx 123

(ΗΥ232)
Επίλογος της swap

{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1;
*yp = t0; 0x11c
}
123 0x118
456 0x114
0x118 0x110
movl -4(%ebp),%ebx 0x114 0x10c
movl %ebp,%esp
popl %ebp RTN ADR 0x108
ret %ebp
0x11c 0x104
… 0x100
%esp
Επαναφέρουμε τον καταχωρητή ebx

(ΗΥ232)
{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1;
*yp = t0; 0x11c
}
123 0x118
456 0x114
0x118 0x110
movl %ebp,%esp
ret %ebp
0x11c 0x104
… 0x100
%esp
esp  ebp

(ΗΥ232)

{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1;
*yp = t0; 0x11c
}
123 0x118
456 0x114
0x118 0x110
movl %ebp,%esp
ret %ebp,esp
0x11c 0x104
… 0x100
Επαναφέρουμε τον καταχωρητή ebp στην παλιά του τιμή

(ΗΥ232)
{ 0x124
int t0 = *xp;
int t1 = *yp; 0x120
*xp = t1; %ebp
*yp = t0; 0x11c
}
123 0x118
456 0x114
0x118 0x110
movl %ebp,%esp
popl %ebp RTN ADR 0x108 %esp
ret
0x11c 0x104
… 0x100
Επιστροφή, και pop της διεύθυνσης επιστροφής από την στοίβα

(ΗΥ232)
Πράξεις με την μνήμη

• Οι περισσότερες εντολές μπορούν να επεξεργάζονται
δεδομένα που είναι στην μνήμη ΧΩΡΙΣ να χρειάζεται να
φορτωθούν πρώτα τα δεδομένα σε καταχωρητές
– addl -8(%ebp), %eax # EAX = EAX + M[EBP - 8]
– incl -8(%ebp) # M[EBP - 8] = M[EBP - 8] + 1
• Πιο πολύπλοκοι τρόποι διευθυνσιοδότησης:

– off(Rb,Ri,S) # Mem[Reg[Rb]+S*Reg[Ri]+ off]
• off: Offset μεγέθους από 1 μέχρι 4 bytes
• Rb: Base register: Οποιοσδήποτε από τους 8 ακεραίους καταχωρητές
• Ri: Index register: Οποιοσδήποτε, εκτός του %esp
• S: Scale: 1, 2, 4, ή 8
– Πολύ χρήσιμος για προσπέλαση πινάκων και structs

(ΗΥ232)
Παραδείγματα υπολογισμού διεύθυνσης
%edx 0xf000
%ecx 0x100
Expression Computation Address
0x8(%edx) 0xf000 + 0x8 0xf008
(%edx,%ecx) 0xf000 + 0x100 0xf100
(%edx,%ecx,4) 0xf000 + 4*0x100 0xf400
0x80(,%edx,2) 2*0xf000 + 0x80 0x1e080

(ΗΥ232)
Διακλαδώσεις
• Ο έλεγχος ροής ενός προγράμματος αποτελείται από δύο
βήματα :
– Θέτουμε ένα condition flag στον καταχωρητή EFLAGS
• Αυτό γίνεται σαν παρενέργεια των περισσότερων αριθμητικών εντολών ή
μέσω της εντολής cmp
– Διακλαδώνουμε βασιζόμενοι στο condition flag
• H συνήθης χρήση είναι μέσω της εντολής cmp

– Είναι ακριβώς σαν την sub, χωρίς να γράφει το αποτέλεσμα
cmp 8(%ebx), %eax # set flags based on (EAX - M[EBX + 8])
jg branch_target # taken if (EAX > M[EBX + 8])

(ΗΥ232)
Παράδειγμα με διακλαδώσεις
int sum(int n) {
int i, sum = 0;
for (i = 1 ; i <= n ; ++ i) {
sum += i;
}
return sum;
}

(ΗΥ232)
Παράδειγμα με διακλαδώσεις
int sum(int n) {
int i, sum = 0;
for (i = 1 ; i <= n ; ++ i) {
sum += i;
}
return sum;
}
sum: pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ecx # n (was argument)
movl $1, %edx # i = 1
xorl %eax, %eax # sum = 0
cmpl %ecx, %edx # (i ? n), sets cond. codes
jg .L8 # branch if (i > n)
.L6:
addl %edx, %eax # sum += i
incl %edx # i += 1
cmpl %ecx, %edx # (i ? n)
jle .L6 # branch if (i <= n)
.L8:

(ΗΥ232)
Εντολές μεταβλητού μήκους
08048344 <sum>:
8048344: 55 push %ebp
8048345: 89 e5 mov %esp,%ebp
8048347: 8b 4d 08 mov 0x8(%ebp),%ecx
804834a: ba 01 00 00 00 mov $0x1,%edx
804834f: 31 c0 xor %eax,%eax
8048351: 39 ca cmp %ecx,%edx
8048353: 7f 0a jg 804835f
8048355: 8d 76 00 lea 0x0(%esi),%esi
...
804835f: c9 leave
8048360: c3 ret
• Οι εντολές έχουν μήκος από 1 μέχρι και 17 17 bytes

– Οι εντολές που χρησιμοποιούνται πολύ συχνά είναι μικρότερες (γιατί;)
• Σε γενικές γραμμές, ο ίδιος πηγαίος κώδικας έχει μικρότερο μέγεθος στον x86
παρά στον MIPS assembly
• Πιο δύσκολη η αποκωδικοποίηση του x86 προγράμματος από το hardware
(ΗΥ232)
Υλοποίηση του IA-32/64

• Το μεταβλητό μέγεθος
των εντολών κάνει
δύσκολο το ΙF, ID και ΕΧ
– Για αυτό, πριν
εκτελεσθούν, οι εντολές
x86 “σπάνε” από το ΗW
σε μικρότερες RISC-like
micro-operations
– Η εκτέλεση των micro-
ops γίνεται όπως και των
εντολών RISC
Διάλεξη 18
Data-Level Parallelism
Linking & Loading
Παραλληλισμός σε εφαρμογές
• Πολλά σημαντικά υπολογιστικά προβλήματα έχουν έμφυτη την
ιδιότητα του παραλληλισμού
• Παραλληλισμός πολλαπλών επιπέδων
• Computer games:
– Γραφικά, ήχος, AI, μπορούν να γίνουν εντελώς παράλληλα μεταξύ τους
– Επίσης, κάθε ένα από αυτά τα κομμάτια έχουν εσωτερικά παράλληλους
υπολογισμούς
• Κάθε Pixel στην οθόνη του υπολογιστή μπορεί να υπολογισθεί και να
απεικονισθεί εντελώς ανεξάρτητα από τα υπόλοιπα
• Η κίνηση αντικειμένων που δεν αλληλοεπιδρούν μπορεί να γίνει εντελώς
παράλληλα
• Stereo sound το ίδιο
• Google queries:
– Κάθε google search μπορεί να γίνει εντελώς παράλληλα με οποιοδήποτε
άλλο
Οργάνωση Η/Y (ECE 232) 2
Data Level Parallelism
• Έστω ο παρακάτω κώδικας C που προσθέτει δύο πίνακες
void
array_add(int A[], int B[], int C[], int length) {
int i;
for (i = 0 ; i < length ; ++ i) {
C[i] = A[i] + B[i];
}
}
• Σε assembly MIPS
lw $t0, 0($a0)
lw $t1, 0($a1)
add $t0, $t1, $t2
sw $t2, 0($a2)

Ένα στοιχείο την φόρα
void
int i;
for (i = 0 ; i < length ; ++ i) {
C[i] = A[i] + B[i];
}
}
Ένα στοιχείο την φόρα
void
int i;
for (i = 0 ; i < length ; ++ i) {
C[i] = A[i] + B[i];
}
}

Μία εντολή επενεργεί σε πολλαπλά δεδομένα
+ + ++ Single Instruction,
Multiple Data (SIMD)
void
int i;
for (i = 0 ; i < length ; ++ i) {
C[i] = A[i] + B[i];
}
}
Μία εντολή επενεργεί σε πολλαπλά δεδομένα
+ + ++ Single Instruction,
Multiple Data (SIMD)
void
int i;
for (i = 0 ; i < length ; ++ i) {
C[i] = A[i] + B[i];
}
}
Intel SSEx εντολές

• Αυτή η επέκταση στο x86 ISA προσέθεσε νέους 128-bit καταχωρητές
(XMM0 – XMM7)
• Ο κάθε ένας μπορεί να αποθηκεύσει:
– 4 single precision FP values (SSE) 4 * 32b
– 2 double precision FP values (SSE2) 2 * 64b
– 16 byte values (SSE2) 16 * 8b
– 8 word values (SSE2) 8 * 16b
– 4 double word values (SSE2) 4 * 32b
– 1 128-bit integer value (SSE2) 1 * 128b
4.0 (32 bits) 4.0 (32 bits) 3.5 (32 bits) -2.0 (32 bits)
+ -1.5 (32 bits) 2.0 (32 bits) 1.7 (32 bits) 2.3 (32 bits)
2.5 (32 bits) 6.0 (32 bits) 5.2 (32 bits) 0.3 (32 bits)

SSE εντολές
Διανυσματικές εντολές (vector instructions) για πρόσθεση,

αφαίρεση, πολλ/μό, διαίρεση, τετραγωνική ρίζα, min, max.
Ακέραιοι ή κινητής υποδιαστολής.
X86 SSE code

mov = data movement %eax = A
%ebx = B
dq = double-quad (128b) %ecx = C
a = aligned A + 4*i
%edx = i
movdqa (%eax,%edx,4), %xmm0 # load A[i] to A[i+3] to %xmm0

movdqa (%ebx,%edx,4), %xmm1 # load B[i] to B[i+3] to %xmm1
paddd %xmm0, %xmm1 # CCCC = AAAA + BBBB
movdqa %xmm1, (%ecx,%edx,4) # store C[i] to C[i+3]
addl $4, %edx # i += 4
(loop control code)
p = packed

Παράδειγμα ΙΙ
unsigned
sum_array(unsigned *array, int length) {
int total = 0;
for (int i = 0 ; i < length ; ++ i) {
total += array[i];
}
return total;
}
Παράδειγμα ΙΙ
unsigned
sum_array2(unsigned *array, int length) {
unsigned total, i;
unsigned temp[4] = {0, 0, 0, 0};
for (i = 0 ; i < length & ~0x3 ; i += 4) {
temp[0] += array[i];
temp[1] += array[i+1];
}
total = temp[0] + temp[1] + temp[2] + temp[3];
for ( ; i < length ; ++ i) {
total += array[i];
}
return total;
}
Linking & Loading
Στάδια μετάφρασης ενός προγράμματος C
Στατική
σύνδεση

Εργασίες συμβολο-μεταφραστή (Assembler)
1. Μετάφραση ψευδοεντολών
• Οι περισσότερες εντολές του συμβολο-μεταφραστή έχουν 1-1
αντιστοιχία με εντολές της γλώσσας μηχανής.
• O συμβολο-μεταφραστήs μετατρέπει τις ψευδοεντολές (pseudo-
instructions) σε συνδιασμούς πραγματικών εντολών
• Οι ψευδοεντολές είναι:
– Βοηθητικές εντολές οι οποίες αντικαθιστούν γνωστούς συνδυασμούς ή
παραλλαγές εντολών της assembly που χρησιμοποιούνται για ειδικούς
σκοπούς
– 32-bit επεκτάσεις των σταθερών 16-bit στις εντολές I-type
move $t0, $t1  add $t0, $zero, $t1
blt $t0, $t1, L  slt $at, $t0, $t1
bne $at, $zero, L
– li $s0,0x0123ABCD  lui $s0, 0x0123
ori $s0,$s0,0xABCD
– $at (καταχωρητής 1): για χρήση απόκλειστικά από τον
συμβολομεταφραστήΟργάνωση Η/Y (ECE 232) 15
Εργασίες συμβολο-μεταφραστή
2. Παραγωγή αντικειμενικών υπομονάδων
• Ο μεταγλωττιστής ή ο συμβολομεταφραστής μετατρέπει το
αρχικό πρόγραμμα σε ένα αντικειμενικό αρχείο (object file)
• Το αντικειμενικό αρχείο περιέχει
– το πρόγραμμα μεταγλωττισμένο σε εντολές γλώσσας μηχανής
– επιπλέον πληροφορίες και δεδομένα που χρειάζονται για την
εκτέλεση του προγράμματος

Παραγωγή αντικειμενικής υπομονάδας
• Το αντικειμενικό αρχείο (*.o) περιέχει
– Επικεφαλίδα (Header): περιγράφει το μέγεθος (σε
bytes) και την θέση στην μνήμη των υπόλοιπων
τμημάτων του αντικειμενικού αρχείου
– Τμήμα κειμένου (Text segment): περιλαμβάνει τον
κώδικα γλώσσας μηχανής
– Τμήμα στατικών δεδομένων (Static data segment):
Δεδομένα που διαρκούν καθ'όλη τη ζωή του
προγράμματος (πχ. static variables). .data, .bss
– Πληροφορίες επανατοποθέτησης (Relocation info):
προσδιορίζουν εντολές και δεδομένα που
εξαρτώνται από απόλυτες διευθύνσεις
– Πίνακας συμβόλων (Symbol table): εξωτερικές
αναφορές και συμβολικές αναφορές
– Πληροφορίες αποσφαλμάτωσης (Debug info): για
την αντιστοίχιση με τον πηγαίο κώδικα όταν κάνουμε
debugging
Εργασίες προγράμματος σύνδεσης (linker)

• Σύνδεση αντικειμενικών υπομονάδων και παραγωγή του
εκτελέσιμου αρχείου (executable) σε 3 στάδια:
1. Τοποθέτηση τμημάτων κώδικα και δεδομένων συμβολικά στη μνήμη
2. Προσδιορισμός διευθύνσεων ετικετών εντολών και δεδομένων
3. Επιδιόρθωση (patching) εσωτερικών κι εξωτερικών αναφορών
(internal and external references)
• To πρόγραμμα σύνδεσης παράγει ένα εκτελέσιμο αρχείο
(executable file)
– Binary file : σειρά από 0 και 1
– Μπορεί να εκτελεσθεί από υπολογιστή
• Ας δούμε ένα παράδειγμα:

Επανάληψη: Κατανομή μνήμης
• Κείμενο (Text): κώδικας
• Στατικά δεδομένα (static data
segment): καθολικές μεταβλητές
– πχ., στατικές μεταβλητές C,
πίνακες, συμβολοσειρές
– $gp : επιτρέπει εύκολη πρόσβαση
στο τμήμα
• Δυναμικά δεδομένα: σωρός
(heap)
– π.χ., malloc στη C,
new στη Java
• Τοπικές ματαβλητές: Στοίβα
(Stack)
Παράδειγμα σύνδεσης προγραμμάτων

AA.c:
int X;
A () {
….
lw $a0, X
call B; AA.o
....
}
BB.c:
int Y;
void B () {
…
sw $a1, Y
call A;
....
}
•Θέλουμε να συνδέσουμε BB.o
(link) τα δύο αντικειμενικά
αρχεία (object files AA and BB)
• Οι εντολές φαίνονται εδώ σε
συμβολική μορφή για να κατανοηθούν
καλύτερα
•Στην πραγματικότητα, οι εντολές θα
ήταν δυαδικοί αριθμοί

Παράδειγμα σύνδεσης προγραμμάτων
• Ο καταχωρητής $gp αρχικοποιείται πάντα με την τιμή

0x10008000
0x10008000 + 0xFFFF8000 = 0x1000 0000
•Τελικό εκτελέσιμο αρχείο (executable file)
Φόρτωση προγράμματος (I)

• Αρχικά το εκτελέσιμο αρχείο βρίσκεται στον σκληρό
δίσκο
• O φορτωτής (loader):
1. Διαβάζει την επικεφαλίδα για να προσδιορίσει το μέγεθος των
τμημάτων
2. Δημιουργεί ένα χώρο διευθύνσεων στην κύρια μνήμη αρκετά
μεγάλο για εντολές και δεδομένα
3. Αντιγράφει εντολές και αρχικοποιημένα δεδομένα στη μνήμη (ο
Loader είναι τμήμα του λειτουργικού συστήματος, Operating
System)

Φόρτωση προγράμματος (II)
• Φόρτωση από το δίσκο στη μνήμη:
4. Αντιγράφει τις παραμέτρους του προγράμματος που δίνει ο χρήστης
στη στοίβα (argc, argv)
5. Αρχικοποιεί τους καταχωρητές (συμπεριλαμβανομένων των $sp, $fp,
$gp) και θέτει τον $sp στην πρώτη ελεύθερη θέση
6. Μεταπηδά στη ρουτίνα εκκίνησης
• Η ρουτίνα αντιγράφει τις παραμέτρους στους $a0, … και καλεί τη main
• Όταν η main επιστρέφει, κάνει κλήση συστήματος για έξοδο (exit syscall)

Οργάνωση Και Σχεδίαση Υπολογιστών Μπέλλας Νικόλαος Πανεπιστήμιο Θεσσαλίας

Uploaded by

Document Information

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

Οργάνωση Και Σχεδίαση Υπολογιστών Μπέλλας Νικόλαος Πανεπιστήμιο Θεσσαλίας

Uploaded by

Copyright:

Available Formats

Οργάνωση και Σχεδίαση Υπολογιστών

Περιεχόμενο μαθήματος (Curriculum)

Οργάνωση και Σχεδίαση Υπολογιστών 9

Περιεχόμενο μαθήματος (Curriculum)

Οργάνωση και Σχεδίαση Υπολογιστών 11

• Οι ασκήσεις θα γίνονται ατομικά

Οργάνωση και Σχεδίαση Υπολογιστών 12

Φιλοσοφία του μαθήματος (Ι)

• Σ2: Διαβάζετε κατά την διάρκεια του εξαμήνου και όχι

• Σ2: Διαβάζετε από το βιβλίο – Οι σημειώσεις είναι κυρίως

• Σ3: Μην προσπαθείτε να απομνημονεύσετε την ύλη.

Intel Ivy Bridge Processor

Οργάνωση και Σχεδίαση Υπολογιστών 16

Απρόσημοι δυαδικοί ακέραιοι

έχει τιμή: b = bn1 2n1 + bn2 2n2 + + b1 21 + b0 20

 Εύρος: –2n – 1 έως +2n – 1 – 1

Προσημασμένοι ακέραιοι στη μορφή

Οργάνωση και Σχεδίαση Υπολογιστών 20

Μετατροπή Ακεραίου Δεκαδικού σε Δυαδικό

Οργάνωση και Σχεδίαση Υπολογιστών 22

Μετατροπή Κλασματικού Δεκαδικού σε

Οργάνωση και Σχεδίαση Υπολογιστών 24

Θεμελιώδεις Αρχές των Μοντέρνων Υπολογιστών

Οργάνωση και Σχεδίαση Υπολογιστών 26

Είδη εντολών και τελούμενων (operands)

• Οι μονάδες του υλικού στις οποίες δρούν οι

Οργάνωση και Σχεδίαση Υπoλογιστών 4

Καταχωρητές του MIPS

• Οι καταχωρητές $1 (συμβολικό $at) και $26-$27

Οργάνωση και Σχεδίαση Υπoλογιστών 5

• 32-bits διευθύνσεων => 232 bytes ή 230 λέξεις συνολικά

Οργάνωση και Σχεδίαση Υπoλογιστών 7

Οργάνωση και Σχεδίαση Υπoλογιστών 10

Μοντέλο μηχανής MIPS

3 μορφές εντολών του MIPS: όλες 32 bits

Οργάνωση και Σχεδίαση Υπoλογιστών 12

Εντολές πράξεων στον MIPS

• Στις εντολές πράξεων χρησιμοποιούνται

Οργάνωση και Σχεδίαση Υπoλογιστών 13

destination  source1 op source2

Εντολές πράξεων στον MIPS

Τελεστέοι μνήμης (Memory Operands)

Παράδειγμα (συνέχεια από προηγ. διάλεξη)

• Κώδικας C: Απόσταση (Offset)

Οργάνωση και Σχεδίαση Υπoλογιστών 2

 Παράδειγμα: eca8 6420

Εντολές για Bytes/Halfwords

lbu rt, offset(rs) ; Επέκταση 0 σε 32 bits στον rt

sb rt, offset(rs) ;Αποθηκεύει το δεξιότερο byte/halfword

Οργάνωση και Σχεδίαση Υπoλογιστών 4

•Διεύθυνση Πρόσβασης : $s1 + (4)10 =

Παραδείγματα εντολών μεταφοράς δεδομένων

•Διεύθυνση Πρόσβασης : $s1 + (7)10 =

• lwl και lwr είναι πραγματικές εντολές

MIPS Εντολές μορφής R

Οργάνωση και Σχεδίαση Υπoλογιστών 8

add $t0, $s1, $s2

000000 10001 10010 01000 00000 100000

Οργάνωση και Σχεδίαση Υπoλογιστών 9

MIPS Εντολές μορφής I

• Άμεσες αριθμητικές εντολές ή εντολές μεταφοράς

Οργάνωση και Σχεδίαση Υπoλογιστών 10

Οργάνωση και Σχεδίαση Υπoλογιστών 11

Operation C Java MIPS