G. Frosini Processore Slide 1 STRUTTURA INTERNA DEL PROCESSORE G. Frosini Processore Slide 1

ISTRUZIONI COMPLESSE ED ELEMENTARI Processore PC: istruzioni con formati assai variabili: codificate da 1 a 17 byte; numero di operazioni elementari svolte da un’istruzione assai variabile: istruzioni con entrambi gli operandi nei registri; istruzioni con un operando in un registro e l'altro in memoria: accesso in memoria con molte e complesse forme di indirizzamento. istruzioni assai complesse, come quelle che operano sulle stringhe. forme particolari di parallelismo: sovrapposizione tra fase di chiamata e fase di esecuzione; presenza di due unità logico-aritmetiche, la ALU e la FPU che si sincronizzano con tecniche semplici. G. Frosini Processore Slide 2

TECNICHE DI VELOCIZZAZIONE Velocizzare l'esecuzione dei programmi: sovrapporre nel tempo l'esecuzione di più istruzioni. Due modalità: prima modalità: esecuzione di ogni istruzione scomposta in più fasi, ciascuna delle quali impegna un’unità distinta del processore; quando un’istruzione ha terminato una fase, libera un'unità del processore che può quindi essere usata per far avanzare un'altra istruzione; il processore viene visto come una catena di montaggio (pipeline). seconda modalità: : esecuzione di ogni istruzione fatta iniziare appena possibile; l’ ordine di esecuzione può essere diverso da quello stabilito dal programma, quando ciò non cambia il risultato finale dell'elaborazione (esecuzione fuori ordine). G. Frosini Processore Slide 3

ISTRUZIONI ED E-ISTRUZIONI Praticabilità delle tecniche precedenti: dipende dall'insieme delle istruzioni del processore; è preferibile che le istruzioni siano omogenee tra di loro: dovrebbero avere un formato semplice e uniforme, e richiedere un numero simile di operazioni elementari. Istruzioni omogenee: nuovo insieme di istruzioni (e-estruzioni, istruzioni elementari), non visibile al programmatore: ogni istruzione originaria viene tradotta in una o più e-istruzioni. traduzione: effettuata dal processore, man mano che le istruzioni vengono prelevate; tecniche di pipeline ed esecuzione fuori ordine: applicate al flusso di e-istruzioni. G. Frosini Processore Slide 4

CLASSI DI E-ISTRUZIONI (1) Classi: e-istruzioni operative, e-istruzioni di memoria, e-istruzioni di salto. e-istruzioni operative: op dest, src1, src2 l'operazione op avviene tra gli operandi sorgenti src1e src2 e memorizza il risultato nel registro dest; src1 è un registro, src2 può essere un registro o un operando immediato. il numero dei registri interni, che indicheremo con R0, R1, …, Rn, è molto superiore a quelli visibili al programmatore. e-istruzioni di memoria: op reg, offset(base) op può essere LD (load) oppure ST (store), reg e base sono registri e offset è una costante. avviene la somma fra offset e il contenuto di base e il risultato è l’indirizzo di memoria da cui leggere o in cui scrivere; e-istruzione LD: reg è l'operando destinatario; e-istruzione ST: reg è l'operando sorgente. letture e scritture avvengono sempre su parole lunghe (32 bit). G. Frosini Processore Slide 5

CLASSI DI E-ISTRUZIONI (2) e-istruzioni di salto: op reg, offset confrontano il contenuto del registro reg con 0 e, in base alla condizione espressa da op, saltano all’indirizzo che dista offset rispetto al valore corrente del contatore delle e-istruzioni, oppure proseguono alla e-istruzione successiva. Motivi di semplicità: non sono previste e-istruzioni di salto incondizionato né di tipo CALL/RET. Esempio di istruzione: ADDL 100(%EBX, %ECX, 4), %EAX, Traduzione (ad opera del processore) in e-istruzioni: SHL R1, %ECX, $2 # %ECX*4 (calcolato tramite shift) in R1 ADD R1, R1, %EBX # %EBX + %ECX * 4 in R1 LD R2, 100(R1) # parola lunga di indirizzo 100+R1 in R2 ADD %EAX, %EAX, R2 # R2+%EAX in %EAX G. Frosini Processore Slide 6

G. Frosini Processore Slide 7 PIPELINE (1) Tecnica di pipeline: modo più semplice di sovrapporre nel tempo l'esecuzione di più e-istruzioni; si basa sulla seguente osservazione: le varie fasi dell'esecuzione di una e-istruzione (reperimento, decodifica, prelievo degli operandi, esecuzione vera e propria, scrittura del risultato) sono normalmente gestite da parti fisicamente distinte del processore; mentre una e-istruzione i si trova in una data fase della propria esecuzione (sta usando una data parte del processore), altre e-istruzioni possono usare parti del processore non utilizzate dalla e-istruzione i. Esempio: mentre una e-istruzione i è in fase di decodifica è possibile già prelevare la e-istruzione successiva i+1; quando la e-istruzione i è stata decodificata ed è passata alla fase di prelievo degli operandi, libera il decodificatore, che può essere utilizzato per decodificare la e-istruzione i+1 prelevata nel frattempo; allo stesso tempo è possibile cominciare a prelevare la e-istruzione i+2, e così via. G. Frosini Processore Slide 7

G. Frosini Processore Slide 8 PIPELINE (2) G. Frosini Processore Slide 8

G. Frosini Processore Slide 9 PIPELINE (3) e-istruzione: attraversa successivamente tutti gli stadi del pipeline. Stadio di pipeline: ad ogni istante si occupa di una e-istruzione diversa. Registri di appoggio tra uno stadio e l'altro del pipeline (registri di pipeline): ogni stadio elabora il contenuto dei registri di pipeline che lo precedono e scrive nei registri di pipeline che lo seguono. Ipotesi: l’attraversamento di ogni stadio richiede un ciclo di clock: per ogni ciclo di clock viene completata una nuova e-istruzione (anche se ciascuna e-istruzione richiede più cicli di clock per essere completata). G. Frosini Processore Slide 9

G. Frosini Processore Slide 10 PIPELINE (4) Nota: la e-istruzione i+1 viene prelevata mentre la e-istruzione i deve essere ancora decodificata (e quindi determinata anche la sua dimensione); questo è possibile (almeno nel caso comune in cui la e-istruzione i non sia di salto) se tutte le e-istruzioni hanno la stessa dimensione; è sufficiente sommare un valore costante al contatore di programma (delle e-istruzioni) per passare da una e-istruzione alla successiva; tutti gli stadi, per tutte le e-istruzioni, devono richiedere tempi di elaborazione simili; il ciclo di clock viene scelto in base allo stadio più lento; è preferibile avere e-istruzioni semplici ed omogenee. G. Frosini Processore Slide 10

G. Frosini Processore Slide 11 ALEE (1) Non è possibile iniziare una nuova e-istruzione ad ogni ciclo di clock (alea): ipotesi: alcune e-istruzioni sono già in alcuni stadi del pipeline, e la prossima e-istruzione da iniziare sia la i-ma; tre tipi di alee: alee strutturali: la e-istruzione i dovrebbe usare una risorsa (ALU, registri, etc.) già utilizzata da un'altra e-istruzione già nel pipeline; alee sui dati: la e-istruzione i avrebbe bisogno di un dato non ancora prodotto da una e-istruzione precedente; alee sul controllo: una delle e-istruzioni nel pipeline è una e-istruzione di salto condizionale di cui non è stata ancora calcolata la condizione. se si verifica un’alea, la e-istruzione i e tutte le e-istruzioni successive non possono essere iniziate. Il pipeline si trova in una situazione di stallo: le e-istruzioni già nel pipeline vengono portate avanti, ma nuove e-istruzioni non possono essere iniziate fino a quando l'alea non viene risolta. G. Frosini Processore Slide 11

G. Frosini Processore Slide 12 ALEE (2) Risoluzione dell’alea: avviene sicuramente, man mano che le e-istruzioni già all'interno del pipeline vengono completate. Stallo: causa un degrado delle prestazioni; per alcuni cicli di clock non viene completata alcuna e-istruzione. Alee strutturali: per evitare questo stallo è necessario progettare opportunamente l'insieme di e-istruzioni, in modo da evitare o limitare al minimo i casi di conflitto sull'uso delle risorse. G. Frosini Processore Slide 12

G. Frosini Processore Slide 13 ALEE (3) Alea sui dati: esempio: ADD R1, R2, R3 # R2+R3 in R1 SUB R4, R5, R1 # R5-R1 in R4 stadio esecuzione e stadio scrittura-risultato: la e-istruzione SUB, per poter procedere verso lo stadio esecuzione, ha bisogno del valore del registro R1. la e-istruzione ADD precedente non ha ancora attraversato lo stadio scrittura-risultato, e quindi deve ancora scrivere nel registro R1. la e-istruzione SUB dovrà attendere almeno il ciclo di clock successivo prima di poter leggere il registro R1. Evitare questo stallo: prevedere circuiti di by-pass che riportano l'uscita dello stadio esecuzione all'ingresso dei registri di pipeline che precedono lo stadio stesso; la e-istruzione SUB riceve direttamente il risultato prodotto dalla e-istruzione ADD, senza passare dalla lettura del registro R1. G. Frosini Processore Slide 13

G. Frosini Processore Slide 14 ALEE (4) G. Frosini Processore Slide 14

G. Frosini Processore Slide 15 ALEE (5) Alea sul controllo: JZ R1, avanti # salta all'etichetta “avanti” se R1=0 ADD R2, R3, R4 # R3+R4 in R2 avanti: SUB R5, R6, R7 # R6-R7 in R5 dopo il prelievo della e-istruzione JZ non è disponibile l'indirizzo della prossima e-istruzione da prelevare; la e-istruzione JZ dovrà almeno essere decodificata ed eseguita prima che si possa decidere se è necessario prelevare la e-istruzione ADD (salto non effettuato) o la e-istruzione SUB (salto effettuato). prelievo delle e-istruzioni: sospeso fino a quando la condizione di salto non è stata risolta (questo può richiedere l'attraversamento di diversi stadi, e quindi diversi cicli di clock). Evitare questo stallo: prevedere il risultato della condizione di salto con sufficiente anticipo, e continuare a prelevare e-istruzioni assumendo che la previsione sia corretta. la previsione non può essere mai certa, e il pipeline deve essere organizzato in modo tale da poter disfare gli effetti di una previsione errata. G. Frosini Processore Slide 15

PREVISIONE DEL SALTO (1) e-istruzioni: non hanno effetto sullo stato del processore fin quando non attraversano lo stadio scrittura-risultato. e-istruzioni di salto: calcolano la condizione di salto in uno stadio precedente a quello di scrittura-risultato; se la previsione si rivela errata è allora sufficiente: marcare come errate tutte le e-istruzioni che occupano gli stadi del pipeline precedenti allo stadio attualmente occupato dalla e-istruzione di salto; prevedere che lo stato del processore non possa essere modificato da e-istruzioni marcate come errate; ricominciare a prelevare le e-istruzioni dall'indirizzo corretto. G. Frosini Processore Slide 16

PREVISIONE DEL SALTO (2) Esito del salto: come detto, viene calcolato prima che le e-istruzioni successive alla e-istruzione di salto siano arrivate alla fase di esecuzione; se si permette anche l'esecuzione di e-istruzioni caricate in seguito ad una previsione, si ha una esecuzione speculativa: tecnica discussa più avanti. Previsione dell'esito del salto: può essere effettuata staticamente o dinamicamente. Previsione statica: tipicamente, consiste nel prevedere che i salti verso e-istruzioni con indirizzi minori (tipici dei cicli) verranno effettuati, e che i salti verso e-istruzioni con indirizzi maggiori non verranno effettuati. G. Frosini Processore Slide 17

PREVISIONE DEL SALTO (3) Previsione dinamica (assai migliore): effettuata tramite predittori di salto; questi memorizzano l'esito dei salti incontrati nelle esecuzioni passate per predire l'esito dei salti futuri. Caso semplice: circuiti funzionanti come una cache: alle e-istruzioni di salto del programma, identificate dal loro indirizzo, viene associata una sequenza di bit; esempio: sia B1 B2 … Bn la sequenza di bit associata alla e-istruzione di salto S: il bit B1 varrà 1 se l'ultima volta che la e-istruzione S è stata eseguita il salto è stato effettuato, 0 altrimenti; il bit B2 varrà 1 se la penultima volta che la e-istruzione S è stata eseguita il salto è stato effettuato, 0 altrimenti, e così via. quando si incontra una e-istruzione di salto, il suo indirizzo viene cercato in cache: se la ricerca ha successo, si usano i bit contenuti nella cache per prevedere l'esito della condizione di salto; diversamente, si procede con una previsione statica e l'indirizzo della e-istruzione viene inserito in cache. quando la condizione di salto viene effettivamente calcolata, si aggiorna la cache facendo scorrere la sequenza di bit e aggiungendo in testa il bit corrispondente all'esito calcolato. G. Frosini Processore Slide 18

ESECUZIONE FUORI ORDINE (1) Tecnica di pipeline: le e-istruzioni vengono eseguite: una per volta; nell'ordine in cui le avrebbe eseguite un processore convenzionale (ordine previsto dal programma). Migliorare le prestazioni: ridurre le situazioni di stallo eliminando i due vincoli di cui sopra; eseguire più e-istruzioni per volta, e in un ordine anche diverso da quello previsto dal programma. G. Frosini Processore Slide 19

ESECUZIONE FUORI ORDINE (2) Esempio: MUL R1, R2, R3 SUB R4, R1, R2 ADD R5, R2, R6 ADD R7, R3, R8 la e-istruzione SUB non può procedere prima che la e-istruzione MUL abbia scritto il risultato nel registro R1; la successiva e-istruzione ADD non ha bisogno dei risultati prodotti dalla e-istruzioni MUL; inoltre, per la sua esecuzione, la e-istruzione ADD necessita di risorse hardware (sommatore tra interi) differenti da quelle richieste dalla e-istruzione MUL (moltiplicatore tra interi). tale e-istruzione può essere eseguita in parallelo con la e-istruzione MUL. Nota: la e-istruzione SUB deve essere eseguita dopo la e-istruzione MUL: l'esecuzione della e-istruzione MUL richiederà molto probabilmente un tempo maggiore rispetto all'esecuzione della e-istruzione ADD; la e-istruzione ADD verrà eseguita prima della e-istruzione SUB, che la precede nel programma (esecuzione fuori ordine); è possibile iniziare l'esecuzione della seconda e-istruzione ADD contemporaneamente alla prima (se il processore dispone di due sommatori). G. Frosini Processore Slide 20

ESECUZIONE FUORI ORDINE (3) Esecuzione di una e-istruzione: inizia appena vi sono risorse libere, tenendo conto delle seguenti dipendenze: dipendenze sui dati: una e-istruzione j dipende per i dati da una precedente e-istruzione i se i produce un risultato usato da j la e-istruzione i scrive, la successiva e-istruzione j legge; dipendenze sui nomi: una e-istruzione j dipende per i nomi da una precedente e-istruzione i se entrambe scrivono nello stesso registro o locazione di memoria (per le e-istruzioni che seguono deve rimanere la seconda scrittura e non la prima), oppure se j scrive in un registro o in una locazione di memoria letta da i; la e-istruzione i legge o scrive, la successiva e-istruzione j scrive; dipendenze sul controllo: una e-istruzione j dipende sul controllo da una precedente e-istruzione di salto condizionale i se la e-istruzione j può essere eseguita o meno in base al risultato della condizione presente in i. Dipendenza tra due e-istruzioni i e j: deve essere rispettato l'ordine previsto dal programma. G. Frosini Processore Slide 21

ESECUZIONE FUORI ORDINE (4) Dipendenze sui dati e sul controllo: corrispondono alle alee sui dati e sul controllo viste nel caso del pipeline semplice. Dipendenze sui nomi: sono automaticamente rispettate in un pipeline semplice; la loro violazione è possibile solo in presenza di esecuzione fuori ordine. Esempio di dipendenza sui nomi: ADD R1, R2, R3 SUB R2, R4, R5 MUL R6, R2, R1 la e-istruzione SUB: non usa il risultato della e-istruzione ADD (non c'è una dipendenza sui dati); non può essere eseguita prima della e-istruzione ADD, perché modifica il contenuto del registro R2 che è letto dalla e-istruzione ADD stessa: c'è quindi una dipendenza sui nomi; se la e-istruzione SUB venisse eseguita prima della e-istruzione ADD, quest’ultima calcolerebbe un valore diverso rispetto a quello calcolato rispettando l'ordine del programma. G. Frosini Processore Slide 22

SCHEMA INTERNO PER IL FUORI-ORDINE (1) Per motivi di semplicità, si considerano solo e-istruzioni operative e le e-istruzioni di salto condizionato: op dest, src1, src2 # istruzioni operative, con dest, src1 e src2 registri op reg, offset # istruzioni di salto condizionato (confronto di reg con 0) Esecuzione fuori ordine, tenendo conto delle dipendenze: organizzare opportunamente i seguenti tre stadi di un pipeline: lettura-operandi esecuzione scrittura-risultato aggiungere un nuovo stadio che precede quello di lettura-operandi: emissione. e-istruzione completata: quando termina la fase di scrittura-risultato. G. Frosini Processore Slide 23

SCHEMA INTERNO PER IL FUORI-ORDINE (2) G. Frosini Processore Slide 24

SCHEMA INTERNO PER IL FUORI-ORDINE (3) Processore: contiene più unità ALU/FPU; unità: specializzata per alcuni tipi di operazioni (somma, prodotto, shift, … ). quelle semplici possono richiedere un solo ciclo di clock per completare un’operazione, mentre quelle complesse possono richiedere più cicli di clock per completare un’operazione. Unità ALU/FPU: preceduta da una o più stazioni di prenotazione. Per ogni registro si ha: un flag W, che indica se una qualche e-istruzione emessa e non ancora completata prevede una scrittura in quel registro; un contatore Cont, che conta quante e-istruzioni emesse e non ancora completate hanno bisogno di leggere quel registro. G. Frosini Processore Slide 25

SCHEMA INTERNO PER IL FUORI-ORDINE (4) Stadio di emissione: esamina una e-istruzione per volta, così come arrivano dagli stadi precedenti, nell'ordine previsto dal programma; emette la e-istruzione se rispetta le dipendenze sui nomi e sul controllo (le dipendenze sui dati sono trattate poco avanti): non scrive in un registro letto o scritto da altre e-istruzioni emesse ma non ancora completate (per rispettare le dipendenze sui nomi): W e Cont, per il registro destinatario, devono valere 0; nessuna e-istruzione di salto è stata emessa e non ancora completata (per rispettare le dipendenze sul controllo). l’emissione consiste nell’assegnazione della e-istruzione ad una stazione di prenotazione libera (con posti disponibili), contenente l’unità ALU/FPU che può eseguirla; se non ve ne sono, il pipeline va in stallo (per alea strutturale). G. Frosini Processore Slide 26

SCHEMA INTERNO PER IL FUORI-ORDINE (5) Quando una e-istruzione del tipo op dest, src1, src2 viene emessa: i contatori Cont associati ai registri src1 e src2 vengono incrementati; il flag W associato al registro dest viene posto a 1. Quando la e-istruzione viene completata: i contatori Cont associati ai registri src1 e src2 vengono decrementati: il flag W associato al registro dest viene posto a 0. G. Frosini Processore Slide 27

SCHEMA INTRERNO PER IL FUORI-ORDINE (6) Stazione di prenotazione: memorizza le e-istruzioni che devono essere eseguite dalla corrispondente unità ALU/FPU; in particolare, per ogni e-istruzione, memorizza il nome dei registri contenenti gli operandi; tali registri (uno o entrambi) potrebbero essere destinatari di altre e-istruzioni già emesse, ma non ancora completate; per eseguire una e-istruzione rispetta le dipendenze sui dati: ipotesi: memorizza una e-istruzione op dest, src1, src2; controlla lo stato dei flag W associati ai registri src1 e src2 e attende che entrambi valgano 0; a quel punto legge i registri e fa cominciare l'esecuzione della e-istruzione. la stazione di prenotazione effettua anche la lettura degli operandi. gli operandi possono rendersi disponibili alle varie stazioni di prenotazione in un ordine diverso da quello di emissione delle e-istruzioni (da parte dello stadio di emissione); le e-istruzioni possono entrare nel successivo stadio di esecuzione fuori ordine. G. Frosini Processore Slide 28

ELIMINAZIONE DELLE DIPENDENZE SUI NOMI (1) Dipendenze sui dati: sono proprie dell'elaborazione svolta dal programma. Dipendenze sui nomi: possono essere eliminate tramite la rinomina dei registri. Esempio precedente: ADD R1, R2, R3 SUB R2, R4, R5 MUL R6, R2, R1 risultato della e-istruzione SUB: può anche essere scritto in un registro non utilizzato, per esempio in R7 invece che in R2; deve essere modificata anche la e-istruzione successiva MUL in modo che il primo dei due operandi sia letto da R7 e non da R2; nuova sequenza: SUB R7, R4, R5 MUL R6, R7, R1 non contiene dipendenze sui nomi; le e-istruzioni ADD e SUB possono essere eseguite in qualunque ordine e anche contemporaneamente, se sono disponibili due ALU/FPU. G. Frosini Processore Slide 29

ELIMINAZIONE DELLE DIPENDENZE SUI NOMI (2) Stadio di emissione: ha anche il compito di rinominare i registri prima di emettere una nuova e-istruzione. Rinomina: i registri vengono distinti in registri logici e in registri fisici. Registri logici: quelli che compaiono nelle e-istruzioni prima della rinomina. Registri fisici (più numerosi dei registri logici): quelli effettivamente implementati nel processore; Corrispondenza mediante puntatori: per un dato registro logico, mediante un puntatore viene specificato quale registro fisico contiene il suo valore; G. Frosini Processore Slide 30

ELIMINAZIONE DELLE DIPENDENZE SUI NOMI (3) Emissione di una e-istruzione: corrispondenza esistente fra registri logici sorgente e registri fisici; nuova corrispondenza tra registro logico destinatario e un registro fisico libero. Esempio: emissione della e-istruzione op dest, src1, src2: sostituzione dei registri logici src1 e src2 con i corrispondenti registri fisici F1 ed F2 (corrispondenza già esistente); scelta un registro fisico libero F: corrispondenza di dest con F (modifica dell’eventuale corrispondenza esistente). Campi associati ai registri fisici: oltre al flag W e al campo Cont, si utilizza anche un flag C che stabilisce se esiste una corrispondenza fra un registro logico e quel registro fisico; le tre informazioni C, W e Cont, pur essendo di natura diversa, sono (in questo caso) ridondanti . G. Frosini Processore Slide 31

ELIMINAZIONE DELLE DIPENDENZE SUI NOMI (4) G. Frosini Processore Slide 32

REGISTRI FISICI LIBERI/OCCUPATI Registro fisico F libero (per la scelta di una nuova corrispondenza fra registro logico destinatario e registro fisico F): non vi è nessuna corrispondenza fra un registro logico ed F (flag C a 0); nessuna e-istruzione emessa deve scrivere in F (flag W a 0); nessun e-istruzione emessa deve leggere da F (campo Cont a 0). Gestione dei campi C, W e Cont: emissione di una e-istruzione: incremento del campo Cont dei registri fisici corrispondenti ai registri logici sorgente; nuova corrispondenza tra registro logico destinatario e un registro fisico libero, con il flag C che diviene 0 per il vecchio registro fisico, e i flag C e W che divengono 1 per il uovo registro fisico. completamento di una e-istruzione: decremento del campo Cont dei registri fisici sorgente; azzeramento del flag W del registro fisico destinatario. G. Frosini Processore Slide 33

ESECUZIONE SPECULATIVA (1) Tecnica della rinomina dei registri: se opportunamente estesa; se affiancata alla tecnica della predizione dei salti; permette di aggirare le limitazioni dovute alle dipendenze sul controllo. e-istruzioni dipendenti da e-istruzioni di salto non ancora risolte: possono essere eseguite purché i risultati di queste vengano scritti in registri temporanei e trasferiti nei registri reali solo quando vi è la certezza che le e-istruzioni andavano realmente eseguite. Tecnica detta speculazione. Nota: per le e-istruzioni che scrivono in memoria (non trattate) si rende necessario: accumulare le scritture in un buffer; rimandare le scritture effettive a quando l'esecuzione delle corrispondenti e-istruzioni non è più speculativa. G. Frosini Processore Slide 34

ESECUZIONE SPECULATIVA (2) Nuovo stadio: ritiro delle e-istruzioni. Completamento delle e-istruzioni: scrittura dei risultati solo in registri temporanei; i risultati diventano effettivi solo quando la e-istruzione che li ha prodotti supera lo stadio di ritiro. Stadio di ritiro: fa uso di una coda di descrittori di e-istruzioni, detto buffer di riordino (ROB); quando una e-istruzione viene emessa, il suo descrittore viene anche inserito in fondo alla coda del ROB; i descrittori si trovano nel ROB nell'ordine di emissione, che è anche l'ordine delle corrispondenti e-istruzioni previsto dal programma. Descrittori: ogni descrittore di e-istruzione contiene: il tipo (e-istruzione operativa o di controllo); se è ancora in fase di esecuzione o è stata completata; nel caso di e-istruzioni di controllo, quale è stato l'esito previsto per il salto. nel caso di e-istruzioni operativa, i registri sorgente e il registro destinatario, logici e fisici. e-istruzioni: completate in un ordine qualsiasi; ritirate estraendo i descrittori dalla testa del ROB (e quindi secondo l’ordine previsto dal programma). G. Frosini Processore Slide 35

ESECUZIONE SPECULATIVA (3) e-istruzione il cui descrittore si trova in testa alla coda del ROB: deve essere completata prima di poter essere ritirata . Ritiro di una e-istruzione operativa: il risultato da essa prodotto diventa effettivo e questa viene estratta dalla coda. Ritiro di una e-istruzione di controllo: in caso di previsione dell'esito del salto corretta, non viene effettuata alcuna azione e questa viene estratta dalla coda; in caso di previsione dell'esito del salto sbagliata: il ROB viene svuotato; gli effetti delle e-istruzioni presenti nel ROB vengono annullati (scritture nei registri destinatari e modifica dei campi associati ai registri coinvolti). G. Frosini Processore Slide 36

ESECUZIONE SPECULATIVA (4) Per rendere effettivi o annullare gli effetti delle e-istruzioni: viene estesa la struttura dati che fa corrispondere i registri logici ai registri fisici; per ogni registro logico viene individuato: quale registro fisico contiene il valore calcolato dall'ultima e-istruzione ritirata che lo aveva come destinatario (valore non speculativo); quale registro fisico contiene (o conterrà) il valore corrente (valore speculativo). per ogni registro logico esistono due puntatori, uno non speculativo e uno speculativo. e-istruzione operativa emessa: i registri logici sorgenti vengono rinominati usando i corrispondenti registri fisici individuati dai puntatori speculativi (esistenti); il registro logico destinatario viene associato a un registro fisico libero usando il puntatore speculativo (il corrispondente puntatore non speculativo non viene modificato). e-istruzione operativa completata: le operazioni, che avvengono con i contenuti dei registri fisici sorgente speculativi, provocano la scrittura nel registro fisico destinatario speculativo. e-istruzione operativa ritirata: per l’operando destinatario, il puntatore speculativo viene ricopiato nel campo di quello non speculativo. Svuotamento del ROB: annullamento degli effetti delle e-istruzioni operative completate: per l’operando destinatario, il puntatore non speculativo viene ricopiato nel campo di quello speculativo. G. Frosini Processore Slide 37

CORRISPONDENZE E CAMPI DEI REGISTRI FISICI G. Frosini Processore Slide 38

CAMPI ASSOCIATI AI REGISTRI FISICI Campi C, W e Cont: C: vale 1 se il registro fisico viene selezionato da un puntatore (speculativo o non-speculativo); W: vale 1 se il registro fisico viene utilizzato come destinatario di una e-istruzione emessa (quando W passa a 1, il registro fisico diviene bloccato); Cont: conta il numero di volte che il registro fisico viene letto da e-istruzioni emesse (e non completate). Registro fisico: diviene libero quando C, W e Cont divengono 0; diviene bloccato/sbloccato quando W diviene 1/0. G. Frosini Processore Slide 39

AZIONI EFFETTUATE SUI PUNTATORI E SUI CAMPI C, W e Cont (1) e-istruzione operativa emessa: rinomina dei registri logici utilizzando le corrispondenze speculative: per ogni registro logico sorgente, corrispondenza esistente tra registro logico e registro fisico e incremento di Cont relativo al registro fisico stesso; per il registro logico destinatario, nuova corrispondenza con un registro fisico libero, con C e W che divengono 1; il campo C del vecchio registro fisico diviene 0 o resta 1 a seconda che vi sia una corrispondenza non speculativa con detto registro fisico; le operazioni avvengono quindi sui registri fisici speculativi. e-istruzione operativa completata: aggiornamento di campi relativi ai registri fisici speculativi: decremento di Cont relativo a ogni registro fisico sorgente; azzeramento di W relativo al registro fisico destinatario. G. Frosini Processore Slide 40

AZIONI EFFETTUATE SUI PUNTATORI E SUI CAMPI C, W e Cont (2) e-istruzione operativa ritirata: registro logico destinatario: modifica di C relativamente al registro fisico destinatario non speculativo (diviene 0) (per quello speculativo C resta 1); puntatore-speculativo -> puntatore-non-speculativo. e-istruzione di controllo: se emessa o completata, vengono effettuate le azioni previste nel caso delle e-istruzioni operative per il solo registro fisico sorgente; se ritirata: non viene effettuata nessuna azione (previsione corretta) oppure viene svuotato il ROB (previsione errata). G. Frosini Processore Slide 41

AZIONI EFFETTUATE SUI PUNTATORI E SUI FLAG C, W E SUL CAMPO Cont (2) Svuotamento del ROB: annullamento degli effetti di una e-istruzione operativa non completata: decremento di Cont relativo ai registri fisici sorgente; azzeramento di W relativo al registro fisico destinatario; azzeramento di C del registro fisico destinatario (C poteva essere già 0); per il registro logico destinatario, puntatore-non-speculativo->puntatore-speculativo. annullamento degli effetti di una e-istruzione operativa completata (ultime due azioni precedenti): annullamento degli effetti di una e-istruzione di controllo: vengono effettuate le azioni previste nel caso delle istruzioni operative per il solo registro fisico sorgente. Ricopiamento dei puntatori: l’operazione: puntatore-non-speculativo -> puntatore-speculativo può essere fatta per tutti i registri logici, in quanto per le e-istruzioni operative ritirate i due puntatori sono già uguali. G. Frosini Processore Slide 42

G. Frosini Processore Slide 43 ESEMPI Spezzone di programma: MUL R1, R2, R3 JP R1, avanti # dipendenza sui dati ADD R3, R2, R2 # dipendenza sui nomi SUB R4, R3, R4 # dipendenza sui dati avanti: …. Esempi: il previsore di salto per l’istruzione JP dà risultato negativo (non salto). Esempio 1: previsione errata; Esempio 2: previsione corretta. G. Frosini Processore Slide 43

G. Frosini Processore Slide 44 ESEMPIO 1 (1) G. Frosini Processore Slide 44

G. Frosini Processore Slide 45 ESEMPIO 1 (2) G. Frosini Processore Slide 45

G. Frosini Processore Slide 46 ESEMPIO 1 (3) G. Frosini Processore Slide 46

G. Frosini Processore Slide 47 ESEMPIO 1 (4) G. Frosini Processore Slide 47

G. Frosini Processore Slide 48 ESEMPIO 2 (1) Inizialmente, F2 contiene -3 G. Frosini Processore Slide 48

G. Frosini Processore Slide 49 ESEMPIO 2 (2) G. Frosini Processore Slide 49