ΠΛΕ$027(Μικροεπεξεργαστέςple027/03_assembly.pdfαριθμό!πράξης!(operaon!code!...

ΠΛΕ-‐027 Μικροεπεξεργαστές 3ο μάθημα: γλώσσα μηχανής MIPS, προγραμματισμός assembly

Αρης Ευθυμίου

Πηγές διαφανειών: συνοδευτικές διαφάνειες αγγλικης εκδοσης του βιβλιου

Stored Program Computers

  Αναπαράσταση εντολών ως δυαδικοί αριθμοί, όπως τα δεδομένα

  Εντολές και δεδομένα αποθηκεύονται στη μνήμη –  Τα προγράμματα αλλάζουν εύκολα όπως

και τα δεδομένα

  Προγράμματα μπορούν να επεξεργάζονται προγράμματα –  e.g., compilers, linkers, …

ΠΛΕ 027 Μικροεπεξεργαστές 2011-‐2012 45

Aναπαράσταση εντολών

  Εντολές MIPS –  Κωδικοποιούνται ως 32-‐bit λέξεις –  Μικρός αριθμός από μορφότυπα κωδικοποιούν αριθμό πράξης (operajon code -‐ opcode), αριθμούς καταχωρητών, …

  Αριθμοί καταχωρητών –  $t0 – $t7 κωδικοποιούνται 8 – 15 –  $t8 – $t9 κωδικοποιούνται 24 – 25 –  $s0 – $s7 κωδικοποιούνται 16 – 23 –  ...


Μορφότυπο εντολών R

  Πεδία: –  op: κωδικός πράξης (opcode) –  rs: πρώτος καταχωρητής πηγής (source) –  rt: δεύτερος καταχωρητής πηγής –  rd: καταχωρητής προορισμού/αποτελέσματος (desjnajon) –  shamt: ποσότητα ολίσθησης -‐ για εντολές shiv μόνο, αλλιώς 000002 –  funct:επέκταση κωδικού πράξης (funcjon code)

–  Οι εντολές ολίσθησης δεν χρησιμοποιούν το πεδίο rs

op rs rt rd shamt funct

6 bits 6 bits 5 bits 5 bits 5 bits 5 bits


R-‐format, παράδειγμα

add $t0, $s1, $s2

special $s1 $s2 $t0 0 add

0 17 18 8 0 32

000000 10001 10010 01000 00000 100000

000000100011001001000000001000002 = 0232402016

op rs rt rd shamt funct

6 bits 6 bits 5 bits 5 bits 5 bits 5 bits


Μορφότυπο εντολών I

  Αριθμητικές πράξεις με σταθερά, εντολές load/store, διακλαδώσεις (υπό συνθήκη) –  rs: πρώτος καταχωρητής πηγής –  rt: καταχωρητής προορισμού για load, αριθμητικές πράξεις, 2ος καταχωρητής πηγής για store

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

op rs rt constant or address

6 bits 5 bits 5 bits 16 bits


Διευθυνσιοδότηση διακλαδώσεων   Οι διακλαδώσεις χρησιμοποιούν το μορφότυπο Ι

–  Opcode, δύο καταχωρητές, δεύθυνση στόχου διακλάδωσης   Οι περισσότεροι στόχοι δεν απέχουν πολύ

–  Μπροστά ή πίσω (επαναλλήψεις)

  Η διεύθυνση δίνεται (υπολογίζεται) σχετικά με το PC   PC-‐relajve addressing

  Target address = PC + 4 + offset   offset = address * 4, αφού όλες οι εντολές είναι ευθυγραμισμένες

  Το PC έχει ήδη αυξηθεί κατά 4

  λεπτομέρεια υλοποίησης που περνάει στην αρχιτεκτονική

  Πλεονέκτημα;


Μορφότυπο J

  Διευθυνσιοδότηση αλμάτων   Οι στόχοι αλμάτων (j and jal) μπορούν να είναι

οπουδήποτε στο τμήμα κώδικα (text segment) –  Η πλήρης διεύθυνση κωδικοποιείται στην εντολή

op address

6 bits 26 bits

  Ψεύτο-‐απευθείας διεύθυνση ((Pseudo)Direct addressing)   Στόχος = PC31…28 : (address × 4)


Παράδειγμα στόχων διακλαδώσεων   Βρόγχος από προηγούμενο παράδειγμα: while (save[i] == k) i += 1;

–  Εστω ότι ξεκινάει από τη θέση 80000

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 80012 5 8 21 2

addi $s3, $s3, 1 80016 8 19 19 1

j Loop 80020 2 20000

Exit: … 80024


Μακρινή διακλάδωση

  Αν ο στόχος διακλάδωσης είναι πολύ μακριά για να κωδικοποιηθεί σε 16-‐bit απόκλιση, ο assembler μετατρέπει τον κώδικα

  Παράδειγμα beq $s0,$s1, L1

↓

bne $s0,$s1, L2 j L1

L2: …


Περίληψη τρόπων διευθυνσιοδότησης


addressing mode

Αντιγραφή string στη C

  Copy x[] to y[] char *p, *q; p = &x[0]; /* p = x */

/* set p to address of 1st char of x */ q = &y[0]; /* q = y also OK */

/* set q to address of 1st char of y */

while((*q++ = *p++) != ‘\0’) ;   Σωστό ή λάθος;


Αντιγραφή String σε MIPS Διευθύνσεις των x και y στη μνήμη

p, q στους καταχωρητές: $s1, $s2 lw $t1, Base Address (e.g., BA) lw $s1,0($t1) # $s1 = p lw $s2,4($t1) # $s2 = q Loop: lb $t2,0($s1) # $t2 = *p sb $t2,0($s2) # *q = $t2 addi $s1,$s1,1 # p = p + 1 addi $s2,$s2,1 # q = q + 1 beq $t2,$zero,Exit # if *p == 0, Exit j Loop # go to Loop Exit: # N characters => N*6 + 3 instrucjons


Πίνακες και δείκτες   Χρήση πίνακα απαιτεί

–  Υπολογισμός απόστασης (offset): πολλαπλασιασμός με το μέγεθος στοιχείου

–  Πρόσθεση στη διεύθυνση βάσης του πίνακα   Δείκτες αντιστοιχούν κατευθείαν στις διευθύνσεις μνήμης

–  Μπορούν να αποφύγουν τους περισσότερους υπολογισμούς

Παράδειγμα: μηδενισμός πίνακα

clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; }

clear2(int *array, int size) { int *p; for (p = &array[0]; p < &array[size]; p = p + 1) *p = 0; }

move $t0,$zero # i = 0

loop1: sll $t1,$t0,2 # $t1 = i * 4

add $t2,$a0,$t1 # $t2 =

# &array[i]

sw $zero, 0($t2) # array[i] = 0

addi $t0,$t0,1 # i = i + 1

slt $t3,$t0,$a1 # $t3 =

# (i < size)

bne $t3,$zero,loop1 # if (…) # goto loop1

move $t0,$a0 # p = & array[0]

sll $t1,$a1,2 # $t1 = size * 4

add $t2,$a0,$t1 # $t2 =

# &array[size]

loop2: sw $zero,0($t0) # Memory[p] = 0

addi $t0,$t0,4 # p = p + 4

slt $t3,$t0,$t2 # $t3 =

#(p<&array[size])

bne $t3,$zero,loop2 # if (…)

# goto loop2

Σύγκριση πίνακα -‐ δείκτη

  Ο πολλαπλασιασμός μετατρέπεται (“strength reduced”) σε ολίσθηση

  Ο κώδικας με πίνακα χρειάζεται την ολίσθηση μέσα στο βρόγχο –  αντίθετα, ο δείκτης απλά αυξάνεται

  Ο μεταφραστής μπορεί να κάνει την μετατροπή –  Καλύτερα το πρόγραμμα να είναι εύκολο στην κατανόηση και

ασφαλές

Υπορουτίνες

  Οι υπορουτίνες είναι η βάση της εφαρμογής της ιδέας της αφαιρετικότητας στο λογισμικό

  Οι επεξεργαστές (και οι μεταφραστές, ...) συνεργάζονται για να γίνονται οι κλήσεις και οι επιστροφές πιο γρήγορα –  και το πέρασμα παραμέτρων και επιστροφή τιμών


Κλήση υπορουτινας: 6 βήματα

1.  Τοποθέτηση παραμέτρων σε θέση προσπελάσιμη από την υπορουτίνα

2.  Μεταφορά ελέγχου εκτέλεσης στην υπορουτίνα 3.  Απόκτηση αποθηκευτικού χώρου για ότι χρειάζεται η

υπορουτίνα

4.  Εκτέλεση εργασίας της υπορουτίνας 5.  Τοποθέτηση αποτελέσματος σε θέση προσπελάσιμη από το

πρόγραμμα που κάλεσε την υπορουτίνα και αποκατάσταση καταχωρητών που χρησιμοποιήθηκαν

6.  Επιστροφή στη κατάλληλη εντολή (μια υπορουτίνα μπορεί να κληθεί από πολλά σημεία του προγράμματος)


Συμβάσεις κλήσης υπορουτίνας MIPS

  Χρησιμοποίησε καταχωρητές όσο γίνεται περισσότερο –  είναι πολύ ταχύτερο από προσπέλαση μνήμης

Σύμβαση (convenjon) χρήσης καταχωρητών:   $a0–$a3: 4 καταχωρητές για μεταφορά παραμέτρων

(argument)

  $v0–$v1: 2 καταχωρητές για επιστροφή τιμών (value)   $ra: καταχωρητής διεύθυνσης επιστροφής (return

address) –  jal sub κλήση υπορουτίνας –  jr $ra επιστροφή

Αποκατάσταση τιμών καταχωρητών

  Χρειάζεται μια κατάληλη δομή μνήμης για να κρατάει προηγούμενες τιμές καταχωρητών ώστε να μπορούμε να τις επαναφέρουμε στην επιστροφή –  και να διαγράφουμε τις τιμές (τοπικές μεταβλητές – automajc)

  Χρησιμοποιούμε τη δομή στοίβας (stack: last-‐in-‐first-‐out queue) –  Push: βάλε τα δεδομένα στη στοίβα –  Pop: αφαίρεσε τα δεδομένα από τη στοίβα

  Η στοίβα είναι στη μνήμη. Γιατί;   Χρειάζεται ένας δείκτης:

–  $sp (stack pointer)   Η σύμβαση στο MIPS είναι ότι η στοίβα μεγαλώνει από

μεγάλες προς μικρές διευθύνσεις –  Push μειώνει $sp, Pop αυξάνει $sp

Παράδειγμα τελικής υπορουτίνας

  Τελικές υπορουτίνες (leaf φύλλα) – δεν καλούν άλλες υπορουτίνες –  αυτό ισχύει και για υπορουτίνες βιβλιοθηκών (π.χ. prin�) –  ούτε είναι αναδρομικές

  C κώδικας: int leaf_example (int g, h, i, j) { int f; f = (g + h) - (i + j); return f; } –  παράμετροι g, …, j στους καταχωρητές $a0, …, $a3 –  f στον $s0 (πρέπει να σώσουμε το $s0 στη στοίβα) –  Αποτέλεσμα στο $v0

Παράδειγμα σε MIPS κώδικας MIPS:

leaf_example: addi $sp, $sp, -4 sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra

Save $s0 on stack

Procedure body

Restore $s0

Result

Return

Μη τελικές υπορουτίνες

  Οι περισσότερες υπορουτίνες καλούν άλλες   Αν ακολουθούσαμε τα παραπάνω η διεύθυνση

επιστροφής και οι παράμετροι της καλούσας (caller) υπορουτίνας θα χανόταν

  Πρέπει λοιπόν να σώσουμε στη στοίβα: –  Τη διεύθυνση επιστροφής ($ra) –  Ο,τι παραμέτρους ή προσωρινούς καταχωρητές ($t) θα

χρειαστούν αργότερα

  και να τις επαναφέρουμε μετά την επιστροφή   Γιατί χαλάσαμε την ομοιομορφία;

–  είναι λογισμικό, δεν έχει τόση σημασία η ομοιομορφία! –  είναι πιο γρήγορες οι κλήσεις/επιστροφές

Παράδειγμα μή-‐τελικής ρουτίνας

  Κώδικας C (παραγοντικό – factorial): int fact (int n) { if (n < 1) return f; else return n * fact(n - 1); } –  Παράμετρος n στο καταχωρητή $a0 –  Αποτέλεσμα στο $v0

Παράδειμα, ΜIPS   MIPS code: fact: addi $sp, $sp, -8 # adjust stack for 2 items sw $ra, 4($sp) # save return address sw $a0, 0($sp) # save argument slti $t0, $a0, 1 # test for n < 1 beq $t0, $zero, L1 addi $v0, $zero, 1 # if so, result is 1 addi $sp, $sp, 8 # pop 2 items from stack jr $ra # and return L1: addi $a0, $a0, -1 # else decrement n jal fact # recursive call lw $a0, 0($sp) # restore original n lw $ra, 4($sp) # and return address addi $sp, $sp, 8 # pop 2 items from stack mul $v0, $a0, $v0 # multiply to get result jr $ra # and return

Τοπικά δεδομένα στη στοίβα

  Κατανομή χώρου για τοπικά δεδομένα γίνεται από την καλούμενη υποροτίνα (callee) –  π.χ., «αυτόματες» (τοπικές εκτός από stajc) μεταβλητές C

  Πλάισιο υπορουτίνας (frame / acjvajon record) –  Χρησιμοποιείται από μερικούς μεταφραστές

Σύμβαση χρήσης καταχωρητών

  $a0 – $a3: παράμετροι (reg’s 4 – 7)   $v0, $v1: επιστροφή τιμών (reg’s 2 and 3)   $t0 – $t9: προσωρινές μεταβλητές

–  Δεν διατηρούνται από την καλούμενη υπορουτίνα   $s0 – $s7: διατηρούμενες μεταβλητές (saved)

–  Πρέπει να αποθηκεύονται/επαναφέρονται από την καλούμενη υπορουτίνα

  $gp: δείκτης καθολικών δεοδομένων (reg 28)   $sp: stack pointer (reg 29)   $fp: frame pointer (reg 30)   $ra: return address (reg 31)

Διάταξη μνήμης   Text: κώδικας   Stajc data: καθολικές μεταβλητές –  συμπ. stajc στη C –  Ο $gp αρχικοποιείται στη μέση του χώρου και με ±offsets γίνεται προσπέλαση

  Dynamic data: σωρός –  malloc in C, new in Java

  Stack: automajc storage

Παράδειγμα: ταξινόμηση σε C   Ταξινόμηση bubble sort σε C   Swap procedure (leaf)

void swap(int v[], int k) { int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; }

–  v in $a0, k in $a1, temp in $t0

The Procedure Swap swap: sll $t1, $a1, 2 # $t1 = k * 4

add $t1, $a0, $t1 # $t1 = v+(k*4)

# (address of 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 # return to calling routine

The Sort Procedure in C

  Μή-‐τελική (καλεί τη swap) void sort (int v[], int n) { int i, j; for (i = 0; i < n; i += 1) { for (j = i – 1; j >= 0 && v[j] > v[j + 1]; j -= 1) { swap(v,j); } } } –  v: $a0, k: $a1, i: $s0, j: $s1

Κορμός (body) της υπορουτίνας move $s2, $a0 # save $a0 into $s2

move $s3, $a1 # save $a1 into $s3

move $s0, $zero # i = 0

for1tst: slt $t0, $s0, $s3 # $t0 = 0 if $s0 ≥ $s3 (i ≥ n)

beq $t0, $zero, exit1 # go to exit1 if $s0 ≥ $s3 (i ≥ n)

addi $s1, $s0, –1 # j = i – 1

for2tst: slti $t0, $s1, 0 # $t0 = 1 if $s1 < 0 (j < 0)

bne $t0, $zero, exit2 # go to exit2 if $s1 < 0 (j < 0)

sll $t1, $s1, 2 # $t1 = j * 4

add $t2, $s2, $t1 # $t2 = v + (j * 4)

lw $t3, 0($t2) # $t3 = v[j]

lw $t4, 4($t2) # $t4 = v[j + 1]

slt $t0, $t4, $t3 # $t0 = 0 if $t4 ≥ $t3

beq $t0, $zero, exit2 # go to exit2 if $t4 ≥ $t3

move $a0, $s2 # 1st param of swap is v (old $a0)

move $a1, $s1 # 2nd param of swap is j

jal swap # call swap procedure

addi $s1, $s1, –1 # j –= 1

j for2tst # jump to test of inner loop

exit2: addi $s0, $s0, 1 # i += 1

j for1tst # jump to test of outer loop

Pass params & call

Move params

Inner loop

Outer loop

Inner loop

Outer loop

sort: addi $sp,$sp, –20 # make room on stack for 5 registers

sw $ra, 16($sp) # save $ra on stack

sw $s3,12($sp) # save $s3 on stack

sw $s2, 8($sp) # save $s2 on stack



… # procedure body

…

exit1: lw $s0, 0($sp) # restore $s0 from stack

lw $s1, 4($sp) # restore $s1 from stack

lw $s2, 8($sp) # restore $s2 from stack

lw $s3,12($sp) # restore $s3 from stack

lw $ra,16($sp) # restore $ra from stack

addi $sp,$sp, 20 # restore stack pointer

jr $ra # return to calling routine

Πλήρης ρουτίνα

Συνχρονισμός

  Δύο πυρήνες μοιράζονται μέρος της μνήμης –  P1 γράφει, μετά ο P2 διαβάζει –  Πρόβλημα αν δεν συνχρονιστούν

  Το αποτέλεσμα εξαρτάται από τη σειρά εκτέλεσης   Χρειάζεται βοήθεια από το υλικό

–  αδιαίρετη (atomic) read/write στη μνήμη –  κανείς άλλος δεν πρέπει να αλλάξει την τιμή πριν ολοκληρωθεί η αδιαίρετη προσπέλαση

  Συνήθως είναι μία εντολή –  Π.χ., αδιαίρετη ανταλλαγή (atomic swap) μεταξύ καταχωρητή και θέσης μνήμης

Συνχρονισμός στο MIPS

  Load linked: ll rt, offset(rs)   Store condijonal: sc rt, offset(rs)

–  Πετυχαίνει αν η θέση δεν έχει αλλαχθεί από τότε που εκτελέστηκε η ll   Επιστρέφει 1 στον rt

–  Αποτυγχάνει αν η θέση έχει αλλάξει   Returns 0 in rt

Παράδειγμα

  Υλοποίηση αδιαίρετης ανταλλαγής

try: add $t0,$zero,$s4 #copy exchange value

ll $t1,0($s1) #load linked

sc $t0,0($s1) #store conditional

beq $t0,$zero,try #branch store fails

add $s4,$zero,$t1 #put load value in $s4

  Στο τέλος η $s4 και η τιμή στη θέση μνήμης που δείχνει η $S1 έχουν ανταλαχθεί αδιαίρετα

Πλάνες

  Ισχυρές εντολές ⇒ μεγαλύτερη απόδοση –  πράγματι θέλουμε εκτέλεση λιγότερων εντολών –  αλλά πολύπλοκες εντολές υλοποιούνται δύσκολα

  Μπορεί να αυξήσουν τον χρόνο εκτέλεσης όλων των εντολών

–  Οι μεταφραστές μπορούν να παράγουν καλό κώδικα από απλές εντολές

  Χρησιμοποίηση assembly για μεγαλύτερη απόδοση –  οι σύγχρονοι μεταφραστές είναι καλοί! –  περισσοτερος κώδικας ⇒ περισσότερα λάθη και χαμηλή παραγωγικότητα

Πλάνες   Συμβατότητα προς τα πίσω ⇒ το σέτ εντολών δεν αλλάζει

–  αλλά νέες εντολές προστίθενται

x86 instrucjon set

Παγίδες

  Διαδοχικές λέξεις δεν αντιστοιχούν σε διαδοχικές διευθύνσεις –  Η μνήμη θέλει διευθύνσεις σε byte

  Χρήση δείκτη σε αυτόματη μεταβλητή (στοίβας) μετά από την επιστροφή από την υπορουτίνα –  π.χ. περνώντας δείκτη πίσω σε μια παράμετρο

Περίληψη

  Βασικές εντολές MIPS   Προγραμματισμός σε assembly

–  μετάφραση από C –  κλήση υπορουτινών

  Κωδικοποίηση εντολών

  Επόμενο μάθημα: γλώσσα περιγραφής υλικού Verilog

ΠΛΕ$027(Μικροεπεξεργαστέςple027/03_assembly.pdfαριθμό!πράξης!(operaon!code!...

Documents

Transcript of ΠΛΕ$027(Μικροεπεξεργαστέςple027/03_assembly.pdfαριθμό!πράξης!(operaon!code!...