Lezione 17 Il Set di Istruzioni (3)

Transcript

1 Lezione 17 Il Set di Istruzioni (3) Vittorio Scarano Architettura Corso di Laurea in Informatica Università degli Studi di Salerno Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I Il concetto di programma memorizzato Istruzioni di scelta istruzioni di branch istruzioni di jump Formato delle istruzioni di scelta formato I per le istruzioni di branch formato J per le istruzioni di jump 2 1

2 Un quadro della situazione Input/Output Sistema di Interconnessione Registri Central Processing Unit Memoria Principale Unità Aritmetico Logica Interconnessione interna alla CPU Cosa abbiamo fatto istruzioni aritmetiche (R) e di trasferimento (I) Dove stiamo andando.. istruzioni di scelta Perché: per poter comprendere il funzionamento e poter progettare la Unità di Controllo Unità di Controllo 3 Le operazioni e gli operandi del MIPS Operazioni: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 2

3 I registri Dimensione di un registro MIPS 32 bit (detta parola) Le caratteristiche dei registri: alta velocità di accesso limitati in numero (32 registri) ($0, $1,..$31) Convenzione MIPS: i registri rappresentati da $s0, $s1,, i registri che contengono variabili $t0, $t1,, i registri di uso temporaneo 5 Le operazioni e gli operandi del MIPS Operazioni: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 6 3

4 Il formato della istruzione add La istruzione add $8, $17, $18 viene rappresentata in una parola di 32 bit: bit 5 bit 5 bit 5 bit 5 bit 6 bit op rs rt rd shamt op Questa codifica viene detta formato della istruzione register (R) 7 I campi del formato R add $8, $17, $ bit 5 bit 5 bit 5 bit 5 bit 6 bit op rs rt rd shamt Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo rd: registro destinazione Campo shamt: scorrimento op 8

5 Le operazioni e gli operandi Operazioni di tipo diverso: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 9 Istruzioni di trasferimento dati: la load-word Memoria lw $8, 1000($19) $8 $19 CPU Indirizzamento indicizzato nel registro $8 va caricato l elemento con indirizzo uguale a il valore in $19 Uso di un registro indice

6 Istruzione di trasferimento dati: la store-word Memoria sw $8, 1000($19) $8 $19 CPU Indirizzamento indicizzato l elemento nel registro $8 va memorizzato nel.. l elemento con indirizzo uguale a il valore in $19 Uso di un registro indice Il formato della istruzione lw La istruzione lw $8, 1000($19) viene rappresentata in una parola: bit 5 bit 5 bit 16 bit op rs rt indirizzo Questa codifica viene detta formato della istruzione Istruction (I) 12 6

7 I campi del formato I lw $8, 1000($19) bit 5 bit 5 bit 16 bit op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro con indice Campo rt: registro destinazione Campo indirizzo: indirizzo partenza 13 Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I Il concetto di programma memorizzato Istruzioni di scelta istruzioni di branch istruzioni di jump Formato delle istruzioni di scelta formato I per le istruzioni di branch formato J per le istruzioni di jump 1 7

8 Il concetto di programma memorizzato Due principi chiave della costruzione: le istruzioni sono rappresentate da numeri i programmi sono in memoria e possono essere letti o scritti, proprio come numeri La memoria può contenere codice sorgente di un programma di elaborazione di testi codice macchina di un programma di elaborazione di testi il testo su cui il programma di elaborazione testi lavora il compilatore che ha generato il codice macchina etc. etc. 15 La memorizzazione di programmi Memoria Processore Programma di gestione bilancio (codice macchina) Programma di elaborazione testi (codice macchina) Compilatore C (codice macchina) Dati del libro paga Testo Codice sorgente C dell elaboratore testi 16 8

9 Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I Il concetto di programma memorizzato Istruzioni di scelta istruzioni di branch istruzioni di jump Formato delle istruzioni di scelta formato I per le istruzioni di branch formato J per le istruzioni di jump 17 Istruzioni di scelta e controllo del flusso La utilità del calcolo automatico: permettere la ripetizione di sequenze di istruzioni in dipendenza dai risultati precedenti Necessarie, quindi: istruzioni che permettano di selezionare la istruzione da eseguire dopo in dipendenza di un valore calcolato Istruzioni di branch del tipo: if condizione then esegui X 18 9

10 Le etichette nei programmi label lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2 Le istruzioni di un programma assembler possono avere delle etichette (label) Le istruzioni di branch permettono di specificare la etichetta della istruzione che deve essere eseguita dopo a seconda del risultato di un test (di uguaglianza o disuguaglianza). 19 Istruzioni di scelta e controllo del flusso Sono necessarie anche: istruzioni che permettano di forzare la esecuzione successiva di una certa istruzione Istruzioni di jump del tipo: esegui X come prossima istruzione Perchè? Vediamo un esempio

11 La necessità dei branch if (a == f) a = b + c; k = p + r; istruzione di branch add $8, $9, $10 L1:add $19, $20, $21 Tipica istruzione di un linguaggio ad alto livello Traduzione in assembler # se a!=f vai a L1 # a = b + c # k = p + r 21 La necessità dei jump if (a == f) a = b + c; else a = b - c; k = p + r; istruzione di branch add $8, $9, $10 istruzione di jump L1:sub $8, $9, $10 L2:add $19, $20, $21 Tipica istruzione di un linguaggio ad alto livello Traduzione in assembler # se a!=f vai a L1 # a = b + c # salta a L2 # a = b - c # k = p + r 22 11

12 La necessità dei jump if (a == f) a = b + c; else a = b - c; k = p + r; istruzione di branch add $8, $9, $10 istruzione di jump L1:sub $8, $9, $10 L2:add $19, $20, $21 Tipica istruzione di un linguaggio ad alto livello Traduzione in assembler # se a!=f vai a L1 # a = b + c # salta a L2 # a = b - c # k = p + r 23 Istruzioni di branch: Branch-on-EQual (1) beq $8, $9, L1 CPU $8 $9 =? se il valore del registro $8 è uguale al valore del registro $9 allora salta alla istruzione con label L1 beq $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2 2 12

13 Istruzioni di branch: Branch-on-EQual (2) beq $8, $9, L1 CPU $8 $9 6 =? se il valore del registro $8 è uguale al valore del registro $9 allora salta alla istruzione con label L1 beq $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2 25 Istruzioni di branch:branch-on-not-equal (1) bne $8, $9, L1 CPU $8 $9 not =? se il valore del registro $8 NON è uguale al valore del registro $9 allora salta alla istruzione con label L1 bne $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $

14 Istruzioni di branch:branch-on-not-equal (2) bne $8, $9, L1 CPU $8 $9 6 not =? se il valore del registro $8 NON è uguale al valore del registro $9 allora salta alla istruzione con label L1 bne $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2 27 Istruzioni di jump: Jump j L1 salta alla istruzione con label L1 CPU. j L1 add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2 28 1

15 Un primo esempio if (a == f) a = b + c; k = p + r; bne $8, $11, L1 add $8, $9, $10 L1:add $19, $20, $21 Tipica istruzione di un linguaggio ad alto livello Traduzione in assembler # se a!=f vai a L1 # a = b + c # k = p + r 29 Un secondo esempio if (a == f) a = b + c; else a = b - c; k = p + r; Tipica istruzione di un linguaggio ad alto livello Traduzione in assembler bne $8, $11, L1 # se a!=f vai a L1 add $8, $9, $10 # a = b + c j L2 # salta a L2 L1:sub $8, $9, $10 # a = b - c L2:add $19, $20, $21 # k = p + r 30 15

16 Un secondo esempio if (a == f) a = b + c; else a = b - c; k = p + r; Tipica istruzione di un linguaggio ad alto livello Traduzione in assembler bne $8, $11, L1 # se a!=f vai a L1 add $8, $9, $10 # a = b + c j L2 # salta a L2 L1:sub $8, $9, $10 # a = b - c L2:add $19, $20, $21 # k = p + r 31 Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I Il concetto di programma memorizzato Istruzioni di scelta istruzioni di branch istruzioni di jump Formato delle istruzioni di scelta formato I per le istruzioni di branch formato J per le istruzioni di jump 32 16

17 I formati delle istruzioni di branch e jump Istruzioni di branch: beq $8, $9, L1 bne $8, $9, L1 formato di istruzione I (uguale a lw/sw) Istruzioni di jump: j L1 formato di istruzione J (nuovo) 33 Il formato I: le istruzioni di branch beq $8, $9, bit 5 bit 5 bit 16 bit op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo indirizzo: indirizzo della label 3 17

18 Il formato I: le istruzioni di branch bne $8, $9, bit 5 bit 5 bit 16 bit op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo indirizzo: indirizzo della label 35 Il formato J: le istruzioni di jump j bit 26 bit op indirizzo Campo op: operazione effettuata Campo indirizzo: indirizzo della label 36 18

19 Riepilogo: i formati delle istruzioni Formato R: add $8,$17,$18 sub $8,$17,$18 op rs rt rd shamt 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit Formato I: lw $8,1000($19) sw $8,1000($19) beq $8, $9, L1 op rs rt indirizzo 6 bit 5 bit 5 bit 16 bit Formato J: op j L1 indirizzo 6 bit 26 bit op bne $8, $9, L1 37 Somma di elementi in un array (1) for (i=0; i < 100; i++) sum = sum + A[i]; i = 0: Loop: sum = sum + A[i]; i = i + 1; if (i!=100) goto Loop; Classico problema: Sommare tutti gli elementi in un array di 100 interi Una soluzione in C Pseudocodice tiene presente il tipo di istruzioni offerti dall assembler niente while, for, etc 38 19

20 Somma di elementi in un array (2) Assunzioni e considerazioni: si assumono le variabili nei registri le variabili sono correttamente inizializzate utilizzo di alcune costanti nel registro $20 c è la costante 1 nel registro $21 c è la costante nel registro $22 c è la costante Come scorrere l array A (1) Memoria A[0] A[1] A[2] A[3] ASTART ASTART + 1 ASTART + 2 ASTART + 3 ASTART + ASTART + 5 ASTART + 6 ASTART + 7 ASTART + 8 ASTART + 9 ASTART + 10 ASTART + 11 ASTART + 12 ASTART + 13 ASTART + 1 ASTART + 15 Array A memorizzato a partire da ASTART Uso del registro $19 per contenere lo spiazzamento dell elemento A[i] Il registro di spiazzamento $19 deve sempre variare di in Una soluzione: con il registro $9 memorizziamo la variabile i da 0 a 99 ad ogni passo, incrementiamo $19 di in. 0 20

21 Come scorrere l array A (2) lw $8, ASTART($19) CPU $9 Indice i $19 Spiazzamento Memoria A[0] A[1] A[2] A[3] ASTART ASTART + 1 ASTART + 2 ASTART + 3 ASTART + ASTART + 5 ASTART + 6 ASTART + 7 ASTART + 8 ASTART + 9 ASTART + 10 ASTART + 11 ASTART + 12 ASTART + 13 ASTART + 1 ASTART Come si descrive un programma Assembler (1) descrizione dell algoritmo utilizzato (a parole e tramite pseudocodice) (2) descrizione dell utilizzo dei registri: variabili indice, registri per lo spiazzamento, registri per uso temporaneo (per istruzioni lw/sw), memorizzazione di costanti. (3) codice Assembler adeguatamente commentato 2 21

22 Il programma per la somma di un array Loop: sum = sum + A[i]; i = i + 1; if (i!=100) goto Loop; $8 = uso temporaneo (lw) $9 = variabile i $17 = variabile sum $19 = spiazzamento A[i] $20 = costante 1 $21 = costante $22 = costante 100 $9,$17,$19 inizializzati a 0 $9 i $19 spiazzam. $21 $20 Loop:lw $8, ASTART($19)# carica A[i] in $8 add $17, $17, $8 # sum = sum + A[i] add $9, $9, $20 # i = i + 1 add $19, $19, $21 # increm. $19 di bne $9, $22, Loop # se i!= 100 goto Loop $17 sum 1 $ CPU 3 Come funziona Loop:lw $8, ASTART($19) add $17, $17, $8 add $9, $9, $20 add $19, $19, $21 bne $9, $22, Loop $20 1 $8 $ $21 CPU $ $ $ A[0] A[1] A[2] A[3] Memoria ASTART ASTART + 1 ASTART + 2 ASTART + 3 ASTART + ASTART + 5 ASTART + 6 ASTART + 7 ASTART + 8 ASTART + 9 ASTART + 10 ASTART + 11 ASTART + 12 ASTART + 13 ASTART + 1 ASTART

23 Problema: le somme parziali Scrivere un programma in Assembler MIPS che partendo da un array A (memorizzato da ASTART) crei un array B (memorizzato da BSTART) tale che: B[i] = A[0]+A[1]++A[i] Si assuma che le costanti che servono sono memorizzate in registri l array A sia correttamente inizializzato (già presente in memoria) 5 Altri problemi E possibile rinunciare alla istruzione BEQ (mantenendo BNE e J)? E possibile rinunciare alla istruzione BNE (mantenendo BEQ e J)? E possibile rinunciare alla istruzione J (mantenendo solamente la BEQ)? 6 23