Microarchitettura. Giacomo Fiumara Anno Accademico / 101

Transcript

1 Microarchitettura Giacomo Fiumara Anno Accademico / 101

2 Introduzione 2 / 101

3 Introduzione Il livello di micro-architettura implementa le funzioni del livello sovrastante ISA (Instruction Set Architecture) La progettazione del livello di micro-architettura dipende pertanto dall'isa che si vuole implementare (tenendo in considerazione costi e prestazioni) Alcuni livelli ISA (in particolare le piattaforme RISC) hanno istruzioni semplici che possono essere eseguite in un solo ciclo di clock Altri livelli ISA, come quello del Core i7, possono richiedere più cicli per l'esecuzione di una singola istruzione L'esecuzione di un'istruzione può richiedere (di norma) l'identicazione degli operandi in memoria, la loro lettura, l'esecuzione vera e propria, la memorizzazione dei risultati in memoria 3 / 101

4 Introduzione Il livello ISA è caratterizzato dall'assenza di uno schema generale applicabile a tutte le piattaforme Pertanto è necessario trattare un esempio particolare A tale scopo è stato scelto un sottoinsieme della Java Virtual Machine, in particolare quella preposta alla manipolazione dei numeri interi Questo sottoinsieme prende il nome di IJVM (Integer Java Virtual Machine) 4 / 101

5 Introduzione La micro-architettura in esame conterrà un microprogramma il cui compito consiste nell'eseguire le operazioni di fetch, decode ed execute delle operazioni IJVM Il microprogramma presenta un insieme di variabili, che denisce lo stato del computer, che possono essere accedute da tutte le funzioni: ogni funzione modica almeno una di queste variabili Per esempio, il Program Counter (PC) fa parte dello stato: indica la locazione di memoria contenente la prossima funzione (istruzione ISA) da eseguire 5 / 101

6 Datapath 6 / 101

7 ALU 7 / 101

8 Shifter 8 / 101

9 Sommatore 9 / 101

10 Registro 10 / 101

11 Datapath 11 / 101

12 Datapath Il datapath è quella parte della CPU che contiene la ALU, i suoi input e i suoi output Il datapath dell'architettura in studio è abbastanza simile a quello utilizzato nella maggior parte delle architetture Contiene alcuni registri a 32 bit Alcuni di essi possono inviare i loro contenuti sul bus B, altri ricevono dati dal bus C I dati presenti sul bus C possono essere scritti su più registri contemporaneamente 12 / 101

13 Datapath 13 / 101

14 Datapath: segnali di controllo Segnali di controllo della ALU F0 F1 ENA ENB INVA INC Segnali di controllo dello shifter SLL8 SRA1 14 / 101

15 Datapath Input della ALU Contenuto del registro H Segnale proveniente dal registro B Incremento di SP: Valore di SP sul bus B Disattivare l'input sinistro della ALU Attivare il segnale INC memorizzare il risultato in SP 15 / 101

16 Datapath: temporizzazione 16 / 101

17 Datapath: temporizzazione Impostazione dei segnali per guidare il datapath ( w) Impostazione del registro H e del bus B ( x) Esecuzione delle operazioni nella ALU e nello shifter ( y) Propagazione dei segnali dallo shifter ai registri ( z) 17 / 101

18 Datapath: operazioni della memoria Porte di comunicazione con la memoria Porta a 32 bit (controllata dai registri MAR e MDR) Porta a 8 bit (controllata dal registro PC che legge il byte meno signicativo di MBR) 18 / 101

19 Datapath: operazioni della memoria Registri MAR/MDR: lettura/scrittura parole di dati Registri PC/MBR: lettura programma eseguibile Il registro MBR può contenere istruzioni o dati (da estendere da 8 a 32 bit, con segno o meno) 19 / 101

20 Datapath: operazioni della memoria Il registro MAR contiene indirizzi espressi in parole (i valori 0, 1, 2,... si riferiscono a parole consecutive) il registro PC contiene indirizzi espressi in byte (i valori 0, 1, 2,... si riferiscono a byte consecutivi) 20 / 101

21 Datapath: operazioni della memoria Assegnare il valore 2 al registro MAR e avviare una lettura in memoria signica leggere i byte 811 (la parola 2) e scriverli sul registro MDR Assegnare il valore 2 al registro PC e avviare una lettura in memoria signica leggere il byte 2 dalla memoria e scriverlo sugli 8 bit meno signicativi di MBR 21 / 101

22 Datapath: operazioni della memoria Questa dierenza di comportamento è dovuta al fatto che MAR e PC accedono a parti (semanticamente) dierenti della memoria La combinazione MAR/MDR viene usata per leggere/scrivere parole di dati del livello ISA La combinazione PC/MBR viene usata per leggere il programma eseguibile al livello ISA, che consiste di un usso di byte Tutti gli altri registri che contengono indirizzi si comportano come MAR 22 / 101

23 Datapath: operazioni della memoria Nelle implementazioni reali esiste un solo tipo di memoria (orientata al byte) Per consentire al registro MAR di contare in parole si opera come in gura: Si scartano i due bit più signicativi di MAR Si eettua uno shift verso sinistra di due bit Si inseriscono due zeri nei bit meno signicativi di MAR 23 / 101

24 Datapath: operazioni della memoria I dati letti dalla memoria mediante la port di memoria a 8 bit vengono scritti sul registro MBR Il contenuto di MBR può essere copiato sul registro B con segno o senza segno Con segno: gli 8 bit di MBR possono essere considerati come un numero compreso tra -128 e Il segno (bit più signicativo tra gli 8 di MBR) viene esteso duplicandolo 24 volte Senza segno: i 32 bit scritti sul bus B si compongono degli 8 bit letti da MBR (meno signicativi) e di zeri nei restanti bit più signicativi La scelta se convertire gli 8 bit di MBR in un valore a 32 bit con o senza segno viene determinato da quale dei due segnali di controllo viene settato 24 / 101

25 Microistruzioni Il controllo del datapath richiede 29 segnali: 9 per controllare la scrittura dei dati dal bus C ai registri 9 per controllare la scrittura dei dati sul bus B dai registri 8 per il controllo delle funzioni di ALU e shifter 2 per indicare gli accessi alla memoria (R/W) mediante i registri MAR/MDR 1 per indicare il fetch dalla memoria mediante i registri PC/MBR 25 / 101

26 Microistruzioni Il valore di questi 29 segnali di controllo specica le operazioni di un ciclo del datapath Un ciclo consiste nel: Copiare i valori dai registri sul bus B Propagare i segnali lungo la ALU e lo shifter Dirigerli sul bus C Scrivere i risultati sul/i registro/i appropriato/i 26 / 101

27 Microistruzioni Inoltre, se viene asserito un segnale di lettura dati dalla memoria, l'operazione di lettura viene avviata soltanto al termine del ciclo del datapath, quando l'indirizzo è stato caricato sul registro MAR I dati della memoria sono disponibili al termine del ciclo successivo nel registro MBR o MDR e possono essere usati nel ciclo ancora successivo Questo signica che una lettura dalla memoria avviata al termine del ciclo k produce dati che saranno disponibili soltanto nel ciclo k / 101

28 Microistruzioni 28 / 101

29 Microistruzioni Addr Contiene l'indirizzo di una potenziale prossima istruzione JAM Modalità di selezione della prossima istruzione ALU Selezione della funzione della ALU e dello shifter C Selezione dei registri sui quali copiare il contenuto del bus C Mem Selezione della funzione della memoria B Selezione del registro dal quale scrivere sul bus B 29 / 101

30 Mic-1 30 / 101

31 Controllo delle microistruzioni Quali segnali di controllo debbano essere abilitati ad ogni ciclo viene stabilito da un sequencer Si tratta di un dispositivo incaricato di far avanzare passo-passo la sequenza di istruzioni per l'esecuzione di ogni singola istruzione ISA Il sequencer deve produrre due tipi di informazione ad ogni ciclo: Lo stato di ogni segnale di controllo nel sistema L'indirizzo della prossima microistruzione da eseguire 31 / 101

32 Memoria di controllo La memoria di controllo contiene l'intero microprogramma Si tratta di un dispositivo che contiene 512 parole, ognuna consistenti di una microistruzione di 36 bit, aventi la struttura: 32 / 101

33 Memoria di controllo La memoria di controllo ha bisogno di un registro di indirizzo e di un registro dei dati MPC (MicroProgram Counter), anche se non si tratta di un contatore perché le microistruzioni non possono essere disposte in modo sequenziale MIR (MicroInstruction Register), che contiene la microistruzione corrente i cui bit determinano i segnali di controllo che pilotano il datapath 33 / 101

34 Mic-1 34 / 101

35 Memoria di controllo Ciclo delle operazioni All'inizio di ogni ciclo di clock (sul fronte di discesa), MIR viene caricato dalla parola nella memoria di controllo puntata da MPC (tempo w) Una volta che la microistruzione viene caricata in MIR, i vari segnali si propagano lungo il datapath: il contenuto di un registro viene copiato sul bus B, la ALU sa quale operazione deve essere eseguita 35 / 101

36 Memoria di controllo Ciclo delle operazioni /2 Il tempo necessario ad eseguire queste operazioni è indicato da x; dopo un tempo w + x gli input della ALU sono stabili Dopo un intervallo y sono stabili gli output della ALU, dello shifter e dei valori di N e Z 36 / 101

37 Memoria di controllo Ciclo delle operazioni /3 I valori di N e Z vengono memorizzati in due memorie ad un bit (una coppia di ip-op) Dopo un intervallo z l'output dello shifter raggiunge i registri lungo il bus C 37 / 101

38 Memoria di controllo Ciclo delle operazioni /4 Parallelamente alla guida del datapath, il microprogramma deve determinare la microistruzione successiva da eseguire (che non è necessariamente quella che segue la microistruzione corrente nella memoria di controllo) Il calcolo dell'indirizzo della microistruzione successiva avviene dopo che MIR è stato caricato ed è stabile Dapprima il campo NEXT_ADDRESS viene copiato in MPC Successivamente viene esaminato il campo JAM: se contiene il valore 0 non è richiesto alcun intervento perché la microistruzione successiva sarà quella che segue la microistruzione corrente 38 / 101

39 Memoria di controllo Ciclo delle operazioni /5 Se invece uno o più dei bit di JAM sono settati a 1 si possono vericare diverse azioni Se JAMN è settato, viene calcolato l'or logico con il ip-op N Analogamente, se JAMZ è settato, viene calcolato l'or logico con il ip-op Z Se risultano settati entrambi, si calcola l'or rispetto ad entrambi 39 / 101

40 Memoria di controllo Ciclo delle operazioni /6 40 / 101

41 Memoria di controllo Ciclo delle operazioni /7 F = ( JAMZ AND Z) OR ( JAMN AND N) OR NEXT_ ADDRESS [8] MPC può assumere uno solo dei due possibili valori: NEXT_ADDRESS NEXT_ADDRESS con il bit più signicativo in OR con 1 41 / 101

42 Memoria di controllo Ciclo delle operazioni /8 Quando tutti i bit di JAM valgono zero, l'indirizzo della microistruzione successiva è semplicemente il numero a 9 bit nel campo NEXT_ADDRESS Quando invece JAMN o JAMZ valgono 1, ci sono due potenziali microistruzioni successive: NEXT_ADDRESS oppure NEXT_ADDRESS in OR con 0x / 101

43 Memoria di controllo Ciclo delle operazioni /9 Il terzo bit del campo JAM è JMPC Se è settato, gli 8 bit di MBR vengono posti in OR (bit a bit) con gli 8 bit meno signicativi di NEXT_ADDRESS prelevati dalla microistruzione corrente; il risultato viene inviato a MPC Il dispositivo indicato con O eettua un OR di MBR con NEXT_ADDRESS se JMPC vale 1, ma invia NEXT_ADDRESS a MPC se JMPC vale zero Questo permette di implementare una diramazione, specicando uno dei 256 possibili indirizzi 43 / 101

44 Ciclo delle operazioni /10 44 / 101

45 Stack Praticamente tutti i linguaggi di programmazione supportano il concetto di procedura (con un insieme di variabili locali) Queste variabili possono essere accedute soltanto dalla procedura in cui sono denite e cessano di esistere al termine della procedura La gestione di queste variabili viene eettuata mediante un'area di memoria chiamata stack riservata alle variabili Vi si accede mediante un registro chiamato LV che punta alla base delle variabili locali della procedura corrente, mentre il registro SP punta alla parola in cima allo stack (in eetti contiene l'indirizzo di memoria della variabile il cui contenuto è stato copiato nello stack) 45 / 101

46 Stack /2 46 / 101

47 Stack /3 In Figura (a) viene invocata una procedura, chiamata A, che istanzia tre variabili locali, a 1, a 2 e a 3 Successivamente (Figura (b)), all'interno della procedura A è presente l'invocazione alla procedura B, che istanzia quattro variabili locali, b 1, b 2, b 3 e b 4 47 / 101

48 Stack /4 In Figura (c), all'interno della procedura B viene invocata la procedura C che provvede ad istanziare due variabili locali, c 1 e c 2 Inne (Figura (d)), le procedure C e B hanno completato la loro esecuzione, le loro variabili locali sono state distrutte e all'interno della procedura A è stata invocata una nuova procedura, chiamata D, che ha provveduto ad istanziare le variabili locali d 1, d 2, d 3, d 4 e d 5 48 / 101

49 Stack /5 Stack degli operandi Oltre ad ospitare le variabili locali, lo stack contiene gli operandi delle espressioni aritmetiche Si consideri ad esempio l'operazione a 1 = a 2 + a 3 49 / 101

50 Modello di memoria La memoria della macchina IJVM (4 GB) può essere considerata come un array di byte oppure come un array di parole di 4 byte Al livello ISA, la JVM non rende disponibile alcun indirizzo di memoria assoluto, soltanto degli indirizzi impliciti che forniscono il punto di partenza per dei puntatori: è il caso, per esempio dei puntatori PC (Program Counter), il registro che contiene l'indirizzo dell'istruzione successiva da eseguire 50 / 101

51 Modello di memoria /2 Sono denite le seguenti aree di memoria: Constant pool (porzione costante): contiene costanti, stringhe, puntatori e non è modicabile (vi si può accedere soltanto in lettura) Local variable frame (blocco delle variabili locali): contiene le variabili locali allocate al momento dell'invocazione di una procedura. Contiene anche i parametri con cui il metodo è stato invocato Operand stack (stack degli operandi) Method area (area dei metodi): contiene il programma. Il registro PC contiene l'indirizzo dell'istruzione successiva da prelevare 51 / 101

52 Modello di memoria /3 52 / 101

53 Insieme delle istruzioni IJVM 53 / 101

54 Insieme delle istruzioni IJVM /2 Esempio applicativo 54 / 101

55 Insieme delle istruzioni IJVM /3 Inserimento nello stack di una parola proveniente da: porzione costante di memoria (LDC_W) blocco variabili locali (ILOAD) istruzione stessa (BIPUSH) Inserimento nel blocco delle variabili locali di una parola proveniente da: stack (ISTORE) 55 / 101

56 Insieme delle istruzioni IJVM /4 Operazioni logiche e aritmetiche: IADD, ISUB IAND, IOR sugli operandi che si trovano in cima allo stack (il risultato viene posto in cima allo stack, al posto della penultima parola) Operazioni per i salti: GOTO (salto incondizionato) IFEQ, IFLT, IF_ICMPEQ modicano il valore di PC in base al valore di oset 56 / 101

57 Insieme delle istruzioni IJVM /5 Operazioni sugli operandi in cima allo stack: scambio di due parole (SWAP) duplicazione di una parola (DUP) rimozione di una parola (POP) Invocazione di un altro metodo: INVOKEVIRTUAL [oset] Terminazione di un metodo: IRETURN 57 / 101

58 Insieme delle istruzioni IJVM Invocazione di una procedura La procedura chiamante carica sulla stack un riferimento alla procedura chiamata (OBJREF) Successivamente, carica i parametri della procedura A questo punto viene eseguita INVOKEVIRTUAL 58 / 101

59 Insieme delle istruzioni IJVM Invocazione di una procedura /2 INVOKEVIRTUAL richiede un argomento, disp (displacement) che indica la posizione nel constant pool che contiene l'indirizzo di inizio nell'area dei metodi per la procedura chiamata In eetti l'indirizzo iniziale nell'area dei metodi non coincide con l'indirizzo del primo opcode della procedura I primi due byte (interpretati come un intero a 16 bit) indicano il numero di parametri della procedura Altri due byte indicano la dimensione dell'area delle variabili locali della procedura chiamata (necessaria per il dimensionamento dello stack della procedura chiamata) Il quinto byte dell'area dei metodi contiene il primo opcode da eseguire 59 / 101

60 Insieme delle istruzioni IJVM Invocazione di una procedura /3 60 / 101

61 Insieme delle istruzioni IJVM Invocazione di una procedura /4 Due informazioni fondamentali per il corretto funzionamento di una procedura (chiamante o chiamata) sono contenute nei registri PC e LV E' necessario salvare lo stato di questi registri allo scopo di ripristinare l'esecuzione della procedura chiamante (al termine della procedura chiamata) e avere i corretti riferimenti nello stack I primi quattro byte prelevati dall'area dei metodi della procedura chiamata servono a calcolare la prima parola di memoria libera dello stack può essere usata A partire dalla prima parola libera dello stack vengono salvati i contenuti dei registri PC e LV della procedura chiamante (in quest'ordine) 61 / 101

62 Insieme delle istruzioni IJVM Invocazione di una procedura /5 La parola precedentemente utilizzata per allocare OBJREF viene utilizzata per salvare un puntatore (link) alla parola che contiene il PC della procedura chiamante, e il suo indirizzo viene salvato nel registro LV A partire da adesso indica l'indirizzo iniziale dello stack della 62 / 101

63 Insieme delle istruzioni IJVM Invocazione di una procedura /6 Il valore di SP viene aggiornato alla parola dello stack che contiene il registro LV della procedura chiamante Il valore di PC viene aggiornato al quinto byte dell'area dei metodi (prima vera istruzione della procedura chiamata) 63 / 101

64 Insieme delle istruzioni IJVM Ritorno da una procedura 64 / 101

65 Insieme delle istruzioni IJVM Ritorno da una procedura /2 L'istruzione IRETURN inverte le operazioni di INVOKEVIRTUAL Dealloca lo spazio utilizzato dalla procedura in rientro Ripristina lo stack allo stato precedente l'invocazione della procedura 65 / 101

66 Insieme delle istruzioni IJVM Ritorno da una procedura /3 IRETURN deve ripristinare i puntatori PC e LV al loro valore originario Questo viene eettuato accedendo al puntatore link Il valore di ritorno (solitamente il risultato del calcolo eseguito nella procedura) viene copiato dalla cima dello stack al puntatore link Il registro SP viene aggiornato a puntare a questa locazione Una volta ripristinato il valore originario di PC, l'esecuzione prosegue con la prima istruzione successiva a INVOKEVIRTUAL 66 / 101

67 Microistruzioni Dopo la descrizione della microarchitettura e della macroarchitettura è la volta dell'implementazione Ovvero, bisogna descrivere il programma che viene eseguito sulla microarchitettura e che interpreta la macroarchitettura Le istruzioni potrebbero essere scritte in binario, 36 bit per parola E' decisamente vantaggioso introdurre una notazione sintetica In altre parole: l'elenco dei segnali che devono essere attivati ad ogni ciclo di clock viene sostituito con una istruzione sintetica che illustra l'operazione in corso 67 / 101

68 Microistruzioni Le microistruzioni vengono descritte mediante un linguaggio di alto livello, MAL (Micro Assembly Language), seguendo le convenzioni: Una riga di codice indica tutte le attività che hanno luogo durante un ciclo di clock Durante ogni ciclo: Un registro è collegato al bus B Il registro H è collegato ad uno dei due ingressi della ALU possono essere scritti uno o più registri ad opera del bus C L'operazione da eseguire viene indicata con il simbolo di assegnazione (=) 68 / 101

69 Microistruzioni Per esempio, in un ciclo si desidera incrementare il valore di SP e iniziare una lettura L'istruzione corrispondente può essere scritta come: SP = SP + 1; rd 69 / 101

70 Microistruzioni Operazioni fondamentali di MAL: Assegnazione Inizio lettura/scrittura da/in memoria Istruzioni di salto 70 / 101

71 Microistruzioni 71 / 101

72 Microistruzioni SOURCE può essere uno qualsiasi dei registri MDR, PC, MBR, MBRU, SP, LV, CPP, TOS, OPC DEST può essere uno qualsiasi dei registri MAR, MDR, PC, SP, LV, CPP, OPC, H 72 / 101

73 Microistruzioni Operazioni tipiche MDR = SP (copia del contenuto di SP in MDR) MDR = H + SP (addizione del contenuto di H e SP, scrittura della somma in MDR) Sono lecite soltanto le operazioni che possono essere realizzate tramite il percorso dati MDR = SP + MDR non è valida perché uno dei due operandi deve essere contenuto nel registro H 73 / 101

74 Microistruzioni Operazioni tipiche H = H MDR non è valida perché H può contenere soltanto il sottraendo H = MDR H è valida Il risultato di un'operazione logica o aritmetica può essere assegnato a più registri: SP = MDR = SP / 101

75 Microistruzioni Operazioni tipiche L'inizio di un'operazione di lettura/scrittura si indica con rd/wr Il prelievo di un byte si indica con fetch Le due operazioni possono avveenire in modo simultaneo, ma lo stesso registro non può contenere dati provenienti dalla memoria e dal datapath nello stesso ciclo Assegnazioni e operazioni in memoria possono svolgersi durante lo stesso ciclo, basta indicarle sulla stessa linea di codice (per esempio, MAR = SP; rd) Ogni istruzione contiene esplicitamente l'indirizzo dell'istruzione seguente: di norma istruzioni consecutive vengono eseguite in sequenza (tranne che per le diramazioni) 75 / 101

76 Microistruzioni Operazioni tipiche I salti incondizionati vengono indicati con la notazione goto label I salti condizionati richiedono invece una notazione dierente perché dipendono dallo stato dei bit Z e/o N: se Z = 1, l'output della ALU è zero se N = 1, l'output della ALU è negativo I salti condizionati vengono eettuati se la parola in cima allo stack è negativa oppure nulla. La verica di ciò viene fatta facendo passare la parola dalla ALU: se negativa il bit N risulterà settato, così come verrà settato il bit Z se la parola è nulla L'istruzione che verica se una parola è zero è: Z = TOS 76 / 101

77 Microistruzioni Operazioni tipiche Un salto condizionato al valore di un generico registro R viene eettuato come: Z = R ; if ( Z ) goto label1 else goto label2 N = R, if ( N ) goto label1 else goto label2 Il risultato consiste nell'impostazione dei bit JAMZ oppure JAMN 77 / 101

78 Microistruzioni 78 / 101

79 Implementazione di IJVM con Mic-1 IADD Sostituisce le due parole in cima allo stack con la loro somma Main1 PC = PC + 1; fetch ; goto ( MBR ) iadd1 MAR = SP = SP - 1; rd iadd2 H = TOS iadd3 MDR = TOS = MDR + H ; wr ; goto Main1 79 / 101

80 Implementazione di IJVM con Mic-1 ISUB Sostituisce le due parole in cima allo stack con la loro dierenza Main1 PC = PC + 1; fetch ; goto ( MBR ) isub1 MAR = SP = SP - 1; rd isub2 H = TOS isub3 MDR = TOS = MDR - H ; wr ; goto Main1 80 / 101

81 Implementazione di IJVM con Mic-1 IAND Sostituisce le due parole in cima allo stack con il loro AND logico Main1 PC = PC + 1; fetch ; goto ( MBR ) iand1 MAR = SP = SP - 1; rd iand2 H = TOS iand3 MDR = TOS = MDR and H ; wr ; goto Main1 81 / 101

82 Implementazione di IJVM con Mic-1 IOR Sostituisce le due parole in cima allo stack con il loro OR logico Main1 PC = PC + 1; fetch ; goto ( MBR ) ior1 MAR = SP = SP - 1; rd ior2 H = TOS ior3 MDR = TOS = MDR or H ; wr ; goto Main1 82 / 101

83 Implementazione di IJVM con Mic-1 DUP Duplica la parola in cima allo stack Main1 PC = PC + 1; fetch ; goto ( MBR ) idup1 MAR = SP = SP + 1 idup2 MDR = TOS ; wr ; goto Main1 83 / 101

84 Implementazione di IJVM con Mic-1 BIPUSH BIPUSH byte scrive byte in cima allo stack Main1 PC = PC + 1; fetch ; goto ( MBR ) bipush1 SP = MAR = SP + 1 bipush2 PC = PC + 1; fetch bipush3 MDR = TOS = MBR ; wr ; goto Main1 84 / 101

85 Implementazione di IJVM con Mic-1 ILOAD ILOAD oset scrive in cima allo stack una variabile locale memorizzata in oset Main1 PC = PC + 1; fetch ; goto ( MBR ) iload1 H = LV iload2 MAR = MBRU + H ; rd iload3 MAR = SP = SP + 1 iload4 PC = PC + 1; fetch ; wr iload5 TOS = MDR ; goto Main1 85 / 101

86 Implementazione di IJVM con Mic-1 ISTORE ISTORE oset rimuove dalla cima dello stack una parola e la memorizza nella locazione di memoria assegnata alla variabile locale indicata con oset Main1 PC = PC + 1; fetch ; goto ( MBR ) istore1 H = LV istore2 MAR = MBRU + H istore3 MDR = TOS ; wr istore4 SP = MAR = SP - 1; rd istore5 PC = PC + 1; fetch istore6 TOS = MDR ; goto Main1 86 / 101

87 Implementazione di IJVM con Mic-1 POP POP rimuove la parola in cima allo stack Main1 PC = PC + 1; fetch ; goto ( MBR ) pop1 MAR = SP = SP - 1; rd pop2 pop3 TOS = MDR ; goto Main1 87 / 101

88 Implementazione di IJVM con Mic-1 SWAP SWAP scambia tra loro le due parole in cima allo stack Main1 PC = PC + 1; fetch ; goto ( MBR ) swap1 MAR = SP - 1; rd swap2 MAR = SP swap3 H = MDR ; wr swap4 MDR = TOS swap5 MAR = SP - 1; wr swap6 TOS = H ; goto Main1 88 / 101

89 Implementazione di IJVM con Mic-1 IINC IINC varnum const incrementa di una quantità const il valore della variabile di numero varnum Main1 PC = PC + 1; fetch ; goto ( MBR ) iinc1 H = LV iinc2 MAR = MBRU + H ; rd iinc3 PC = PC + 1; fetch iinc4 H = MDR iinc5 PC = PC + 1; fetch iinc6 MDR = MBR + H ; wr, goto Main1 89 / 101

90 Implementazione di IJVM con Mic-1 GOTO GOTO oset eettua un salto incondizionato. Si noti che oset è una parola di 16 bit che viene prelevata in due operazioni successive di fetch Main1 PC = PC + 1; fetch ; goto ( MBR ) goto1 OPC = PC - 1 goto2 PC = PC + 1; fetch goto3 H = MBR << 8 goto4 H = MBRU OR H goto5 PC = OPC + H ; fetch goto6 goto Main1 90 / 101

91 Implementazione di IJVM con Mic-1 GOTO 91 / 101

92 Implementazione di IJVM con Mic-1 IFLT IFLT oset eettua un salto a oset se e solo se la parola in cima allo stack risulta minore di zero Main1 PC = PC + 1; fetch ; goto ( MBR ) iflt1 MAR = SP = SP - 1; rd iflt2 OPC = TOS iflt3 TOS = MDR iflt4 N = OPC ; if ( N ) goto T ; else goto F T OPC = PC - 1; goto goto2 F PC = PC + 1 F1 PC = PC + 1; fetch F2 goto Main1 92 / 101

93 Implementazione di IJVM con Mic-1 IFEQ IFEQ oset eettua un salto a oset se e solo se la parola in cima allo stack risulta uguale a zero Main1 PC = PC + 1; fetch ; goto ( MBR ) ifeq1 MAR = SP = SP - 1; rd ifeq2 OPC = TOS ifeq3 TOS = MDR ifeq4 Z = OPC ; if ( Z ) goto T ; else goto F T OPC = PC - 1; goto goto2 F PC = PC + 1 F1 PC = PC + 1; fetch F2 goto Main1 93 / 101

94 Implementazione di IJVM con Mic-1 IF_ICMPEQ IF_ICMPEQ oset eettua un salto a oset se e solo se le due parole in cima allo stack risultano uguali Main1 PC = PC + 1; fetch ; goto ( MBR ) if_icmpeq1 MAR = SP = SP - 1; rd if_icmpeq2 MAR = SP = SP - 1 if_icmpeq3 H = MDR ; rd if_icmpeq4 OPC = TOS if_icmpeq5 TOS = MDR if_icmpeq6 Z = OPC - H ; if ( Z ) goto T ; else goto F T OPC = PC - 1; goto goto2 F PC = PC + 1 F1 PC = PC + 1; fetch F2 goto Main1 94 / 101

95 Progettazione del livello di microarchitettura /1 La progettazione di un livello di microarchitettura richiede lo studio di molti aspetti: Velocità Costi Adabilità Facilità di utilizzo Consumi energetici Dimensioni siche Alcuni di questi aspetti sono conittuali fra loro. La soluzione migliore richiede pertanto l'adozione di soluzioni di compromesso, per esempio scegliendo un punto di equilibrio tra velocità e costi 95 / 101

96 Progettazione del livello di microarchitettura /2 L'incremento della velocità di esecuzione può essere raggiunto mediante varie soluzioni: Riduzione il numero di cicli di clock necessari per l'esecuzione di un'istruzione Semplicazione dell'organizzazione per ottenere un ciclo di clock più breve Sovrapposizione dell'esecuzione di più istruzioni (pipelining) 96 / 101

97 Progettazione del livello di microarchitettura /3 Il numero di cicli di clock necessari per l'esecuzione di un insieme di operazioni è noto come path length e può essere ridotto mediante l'impiego di hardware specializzato Una possibilità consiste, per esempio, nell'adozione di un incrementatore (tecnicamente un sommatore con un operando sso a 1) che opera su PC, in modo da evitare che la ALU debba provvedere all'incremento di PC Il costo dovuto all'adozione di un nuovo sommatore non ripaga però in termini di riduzione dei cicli di clock, in quanto in molte istruzioni insieme all'incremento di PC vengono eseguite operazioni di lettura 97 / 101

98 Progettazione del livello di microarchitettura /4 La riduzione dei cicli necessari per il fetch delle istruzioni richiede la sovrapposizione dell'esecuzione di più istruzioni La separazione dei circuiti predisposti al fetch delle istruzioni (porta verso la memoria e registri PC/MBR) è molto più ecace se quest'unità viene resa indipendente dal datapath principale In questo modo il fetch del prossimo opcode (oppure dell'operando) può essere eseguito separatamente dal resto delle microistruzioni, eventualmente in modo asincrono rispetto al resto della CPU. In questo modo potrebbe essere possibile eseguire il fetch di più operazioni in anticipo alla loro esecuzione 98 / 101

99 Progettazione del livello di microarchitettura /5 Una delle fasi più dispendiosa in molte istruzioni consiste ad esempio nel fetch di un oset a 16 bit, nella sua estensione e nella memorizzazione nel registro H Una possibile soluzione consiste nell'aumentare la dimensione della porta della memoria per portarla a 16 bit. Ma questo non risolve i problemi, in quanto la memoria è composta di parole di 32 bit La soluzione più ecace resta in conclusione la sovrapposizione dell'esecuzione delle istruzioni, che può consentire aumenti signicativi della velocità 99 / 101

100 Progettazione del livello di microarchitettura /7 Riduzione della lunghezza del percorso di esecuzione In Mic-1 il ciclo principale consiste in una microistruzione da eseguire all'inizio di ogni istruzione IJVM. In alcuni casi è possibile sovrapporla all'istruzione precedente Infatti, quando Main1 viene eseguito il codice operativo da interpretare è già presente nel registro MBR (prelevato dal precedente ciclo principale oppure durante l'esecuzione dell'istruzione precedente) In alcuni casi è possibile ridurre la microistruzione Main1 può essere inserita nelle microistruzioni precedenti poiché alcune istruzioni non sono completamente utilizzate 100 / 101

101 Progettazione del livello di microarchitettura /8 Riduzione della lunghezza del percorso di esecuzione Versione originale pop1 MAR = SP = SP - 1; rd pop2 pop3 TOS = MDR ; goto Main1 Main1 PC = PC + 1; fetch ; goto ( MBR ) Versione ottimizata pop1 MAR = SP = SP - 1; rd Main1. pop PC = PC + 1; fetch pop3 TOS = MDR ; goto ( MBR ) 101 / 101