CEFRIEL Consorzio per la Formazione e la Ricerca in Ingegneria dell’Informazione Politecnico di Milano introduzione alle architetture superscalari Come aumentare le prestazioni introduzione alle architetture superscalari Master in Convergenza William Fornaciari Politecnico di Milano

W.Fornaciari2 Obiettivi e sommario Contenuto della lezione Cenni alle tecniche per incrementare le prestazioni dei processori I fattori rilevanti per le prestazioni Prospettiva storica Il parallelismo nell’esecuzione delle istruzioni Circuiti pipeline Uso del pipeling in un processore Problematiche di conflitti, stalli e scheduling Il parallelismo a livello di istruzione Superscalarità VLIW Conclusioni

W.Fornaciari3 Cicli di clock per istruzione (CPI) CPI = (cicli di ck della CPU per un prog) / numero di istruzioni tempo di CPU = numero istruzioni * CPI * durata del ciclo di clock = = (numero istruzioni * CPI) /f ck Introducendo nella prima formula le unità di misura, si può notare in che relazione stiano le varie componenti

W.Fornaciari4 Fattori che influenzano il tempo CPU ciclo di clock (o frequenza) tecnologia hardware e organizzazione cicli di clock per istruzione organizzazione e architettura set istruzioni numero istruzioni architettura set istruzioni e tecnologia dei compilatori Non è possibile modificare separatamente i vari termini poiché le tecnologie di base cui afferiscono le singole caratteristiche sono interdipendenti

W.Fornaciari5 Prospettiva storica Fino agli anni ’70 si è lavorato principalmente Migliorando le tecnologie elettroniche Potenziando l’insieme delle istruzioni per rendere più breve il compilato  Introduzione istruzioni complesse  Aumentare le modalità di indirizzamento  Tentativo di rendere ortogonali istruzioni e modi di indirizzamento  Dopo gli anni ‘70-80 si sono diffusi  approccio quantivativo al progetto del set di istruzioni abbinato a pipelining  Anni ‘90  Parallelismo a livello istruzione (superscalarità e VLIW)

W.Fornaciari6 Pipelining e ottimizzazione della f ck Il miglioramento delle prestazioni di un generico circuito digitale è legato principalmente alla riduzione della profondità combinatoria Tale riduzione si può ottenere: Ottimizzando le parti puramente combinatorie del circuito Frazionando opportunamente le parti combinatorie per mezzo di registri Un generico data-path è costituito da una sequenza di operazioni eseguite in cascata: questa struttura si presta molto bene al frazionamento Una architettura in cui sono presenti registri con lo scopo di frazionare la computazione viene detta pipeline Nelle architetture dei calcolatori l’introduzione di pipeline aumenta il numero di istruzioni eseguite nell’unità di tempo

W.Fornaciari7 Circuiti pipeline Il diagramma temporale risulta Si consideri il seguente schema a blocchi F() y = F(x)x clk x y = F(x) TxTx TT x1x2x2 x3x3 x4x4 y1y1 y2y2 y3y

W.Fornaciari8 Circuiti pipeline Il blocco funzionale F calcola l’operazione y  F(x): In ingresso a F arriva una successione di dati x i In uscita da F viene prodotta una successione di dati y i  F(x i ) L’ingresso x presenta un ritardo di stabilizzazione pari all’intervallo di tempo  T x Il blocco funzionale F presenta un ritardo di propagazione pari all’intervallo di tempo  T La frequenza massima di funzionamento è:

W.Fornaciari9 Circuiti pipeline Si supponga che la funzione F() possa essere decomposta in due nuove funzioni F 1 () ed F 2 () tali che F 1 () y = F 2 (z) = F(x)x clk L’architettura che corrisponde a tale scomposizione è: F 1 () z = F 1 (x) Si noti che la somma dei ritardi  T 1 e  T 2 relativi alle funzioni F 1 () ed F 2 () è in genere maggiore del ritardo  T della funzione F():

W.Fornaciari10 Circuiti pipeline Questo tipo di decomposizione non porta quindi ad un miglioramento delle prestazioni in quanto le due funzioni parziali vengono comunque calcolate nello stesso ciclo di clock Per aumentare la frequenza di funzionamento si introduce un registro detto registro di pipeline: F 1 () y = F 2 (z out ) = F(x)x F 1 () z in = F 1 (x) R z out = z in In questo modo le funzioni F 1 () e F 2 () vengono calcolate in due cicli di clock successivi La durata di un ciclo di clock può quindi essere ridotta

W.Fornaciari11 Circuiti pipeline Nel primo ciclo di clock: Si deve attendere la stabilizzazione di x Viene calcolata la funzione F 1 (x) Nel secondo ciclo di clock: Il valore z in viene memorizzato nel registro e quindi propagato in z out Viene calcolata la funzione F 2 (z out ) I ritardi nei due cicli di clock sono: Primo ciclo:  T x +  T 1 Secondo ciclo:  T R +  T 2 La frequenza massima di funzionamento è quindi:

W.Fornaciari12 Circuiti pipeline La struttura F scomposta in due fasi F 1 e F 2, disaccoppiate da un registro di pipelining R si chiama pipeline Il funzionamento di una pipeline è il seguente: Il registro di pipelining carica e memorizza il valore z i  F 1 (x i ) sull’ i-esimo fronte di salita del segnale di clock Le operazioni delle due fasi F 1 e F 2, relative allo stesso valore in ingresso x i, vengono svolte nei ciclo di clock i-esimo e (i+1)- esimo, rispettivamente Nel ciclo di clock i-esimo vengono calcolate le funzioni F 1 (x i ) e F 2 (x i-1 ) In ogni ciclo di clock la pipeline elabora due distinti ingressi x i e x i  1, che si trovano in fasi di avanzamento differenti Questi principi di funzionamento si estendono senza difficoltà a pipeline con un numero n  2 di fasi

W.Fornaciari13 Pipelining a due fasi Come già visto una pipeline a due fasi consente una frequenza: Tale valore indica la frequenza reale. Sotto le seguenti ipotesi: Dati stabili e registri efficienti:  T x <<  T 1 ;  T R <<  T 2 Scomposizione efficiente:  T   T 1 +  T 2 Fasi bilanciate:  T 1   T 2 Il valore della frequenza viene detto ideale ed è:

W.Fornaciari14 Pipelining a n fasi E’ naturale estendere la relazione precedente ad una pipeline ad n fasi per la quale valgano le ipotesi già viste: Dati stabili e registri efficienti:  T x <<  T 1 ;  T R,i-1 <<  T i Scomposizione efficiente:  T   T 1 +  T 2 + … +  T n Fasi bilanciate:  T i   T j La frequenza ideale massima di funzionamento diviene: Il guadagno rispetto al caso senza pipelining è:

W.Fornaciari15 Cifre di merito Throghput: quantità di dati elaborati nell’unità di tempo: Latenza: ritardo tra l’ingresso e l’uscita: Si noti che l’introduzione di pipelining è vantaggioso in quanto:

W.Fornaciari16 Applicazioni delle pipeline alle CPU L’esecuzione di una istruzione assembler consiste nello svolgimento di alcune operazioni in sequenza E’ possibile scomporre una istruzione in un numero variabile di operazioni: Una scelta comune consiste nella decomposizione in 5 operazioni Alcune architetture prevedono una decomposizione in 8 operazioni Le architetture moderne arrivano fino a 13 operazioni Le varie operazioni, dette fasi o stadi, possono essere eseguite: Nello stesso ciclo di clock In cicli di clock successivi Nel secondo caso si parla di una architettura pipeline

W.Fornaciari17 Fasi di esecuzione La decomposizione in 5 fasi consiste in Fetch: Lettura dell’istruzione (una o più parole) dalla memoria di programma. L’istruzione viene memorizzata nel registro IR Decode: Scomposizione dell’istruzione in campi (codice operativo, registro, costante, ecc), a seconda del formato e delle modalità di indirazzamento Execute: Esecuzione delle operazioni aritmetico-logiche oppure calcolo dell’indirizzo di destinazione di un salto Memory access: Accesso in lettura o scrittura alla memoria o ad una periferica Write back: Salvataggio del risultato prodotto dall’istruzione nel registro destinazione

W.Fornaciari18 Fasi di esecuzione Si noti che: Non tutte le fasi devono essere sempre presenti. Alcune istruzioni possono necessitare solo di alcune delle fasi descritte Non tutte le fasi devono essere sempre distinte. Alcune istruzioni possono raggruppare due o più fasi in una sola La fase di fetch è sempre presente Fasi diverse possono avere durate diverse Il flusso di operazioni può essere schematizzato come segue: Memory Access Write Back Fetch DecodeExecute

W.Fornaciari19 Istruzioni FetchDecode Execute Memory Write Access Back IR  Instruction PC  [PC]++ Read R2 Read R3 Z  [R2] + [R3] Skip R1  [Z] ADD R1, R2, R3PC  [PC] , R1  [R2]  [R3] FetchDecode Execute Memory Write Access Back IR  Instruction PC  [PC]++ Read R2 Z  15 + [R2]MAR  [Z] Read, WMFC R1  [MDR] LDW R1, 15(R2) PC  [PC] , R1  Mem(15+[R2])

W.Fornaciari20 Istruzioni FetchDecode Execute Memory Write Access Back IR  Instruction PC  [PC]++ Read R1 Z  cmp ( [R2],16 ) Skip CR  [Z] CMPWI R1, 16PC  [PC] , CR  compare([R1], 16) FetchDecode Execute Memory Write Access Back IR  Instruction PC  [PC]++ Read R1 Read R3 Z  15 + [R3]MAR  [Z] MDR  [R1] Write, WMFC Skip STW R1, 10(R3) PC  [PC] , Mem(10+[R3])  R1

W.Fornaciari21 Istruzioni BNE 150PC  [PC] ,PC  [PC]  [CR:EQ]*[R1] FetchDecode Execute IR  Instruction PC  [PC]++ Skip PC  [PC] B 100 PC  [PC] , PC  [PC]+100 FetchDecode Execute IR  Instruction PC  [PC]++ Read R1 Read CR if ( [CR:EQ] == 1 ) then PC  [PC] + [R1]

W.Fornaciari22 Architettura della pipeline intera Le istruzioni aritmetico/logiche e le istruzioni di accesso alla memoria in lettura/scrittura vengono eseguite dalla pipeline intera La pipeline intera consta di tutte e cinque le fasi descritte: Memory Access Write Back Fetch DecodeALU Memory AddressInstruction Registers Op-code Operands Data to write Address Data read Address Register Result Memory ports

W.Fornaciari23 Architettura della pipeline di salto Le istruzioni di salto, condizionato o incondizionato, vengono eseguite dalla pipeline di salto La pipeline di salto consta di tre sole fasi: Fetch DecodeALU Memory AddressInstruction Registers Op-code Operands Address Result

W.Fornaciari24 Esecuzione pipelined Si consideri la sequenza di istruzioni: XORR1, R1, R1 ADDIR2, R1, 54 ADDIR3, R1, 17 L’esecuzione senza pipelining può essere rappresentata mediante il seguente diagramma temporale XOR R1, R1, R1 ADDI R2, R1, 54 ADDI R3, R1, 17 FDEMAWB...

W.Fornaciari25 Esecuzione pipelined: conflitti L’esecuzione pipelined, senza opportuni accorgimenti, può provocare conflitti XOR R1, R1, R1 ADDI R2, R1, 54 ADDI R3, R1, 17 FR1EMAR1 FR1EMAR2 FR1EMAR3... Il registro R1 viene infatti letto ai cicli di clock 3 e 4 ma viene scritto al ciclo di clock 5 I valori letti ai cicli 3 e 4 non sono corretti Questa situazione è dovuta ad una dipendenza tra i dati

W.Fornaciari26 Esecuzione pipelined: stalli Il problema può essere risolto ritardando opportunamente l’esecuzione delle istruzioni I ritardi introdotti vengono detti stalli Il diagramma seguente mostra come l’introduzione di 3 stalli sulla seconda istruzione risolva i conflitti di dipendenza tra i dati XOR R1, R1, R1 ADDI R2, R1, 54 ADDI R3, R1, 17 FR1EMAR1 SR1EMAR2 FR1EMAR3... FSSFSS

W.Fornaciari27 Esecuzione pipelined: stalli Il processore preleva dalla memoria del calcolatore e avvia all’esecuzione un’istruzione a ogni ciclo di clock. Tuttavia: I conflitti obbligano il processore a ritardare l’avvio di alcune istruzioni Per ritardare l’esecuzione di un’istruzione si inseriscono uno o più stalli Gli stalli vanno inseriti subito dopo la fase di fetch dell’istruzione In ogni ciclo di clock il processore contiene più istruzioni che si trovano simultaneamente in stato di esecuzione: Le istruzioni si trovano tutte in fasi di avanzamento differenti Alcuni stadi della pipeline possono essere vuoti, in quanto non usati dall’istruzione oppure in quanto riempiti con uno stallo Una unità di rilevamento dei conflitti e di inserimento degli stalli, provvede a inserire gli stalli quando è necessario

W.Fornaciari28 Esempio Il programma mostrato, costituito da 11 istruzioni, verrebbe eseguito in assenza di pipeline in 55 cicli di clock. L’esecuzione con pipeline richiede 15 cicli di clock ma introduce conflitti tra i dati e tra le istruzioni: XORR1,R1,R1 ADDIR2,R1,54 ADDIR3,R1,17 LWZR4,VA(R1) MULLWR4,R2,R4 ADDR4,R4,R3 STWR4,VB(R1) ADDIR1,R1,1 CMPWICR,R1,100 BLTCR,-7 LWZR4,VA(R1) F R1 E MA R4 F R1 E MA R1 F R1 E MA R2 F R1 E MA R3 F R1 E MA R4 F E MA R4 R2 R4 R3 R4 F E MA R4 F E MA WB R1 R4 F R1 E MA R1 F R1 E MA CR F CR E

W.Fornaciari29 Esempio L’introduzione degli stalli mostrati elimina i conflitti e consente l’esecuzione in 30 cicli di clock L’utlima istruzione non viene ritardata con stalli in quanto viene eseguita solo se la condizione di salto non è verificata XORR1,R1,R1 ADDIR2,R1,54 ADDIR3,R1,17 LWZR4,VA(R1) MULLWR4,R2,R4 ADDR4,R4,R3 STWR4,VB(R1) ADDIR1,R1,1 CMPWICR,R1,100 BLTCR,-7 LWZR4,VA(R1) F R1 E MA R4 F R1 E MA R1 F S S S R1 E MA R2 F R1 E MA R3 F R1 E MA R4 F S S S E MA R4 R2 R4 R3 R4 F S S S E MA R4 F S S S E MA WB R1 R4 F R1 E MA R1 F S S S R1 E MA CR F S S S CR E

W.Fornaciari30 Esecuzione pipelined: scheduling Si consideri il codice seguente, in cui sono evidenziate le dipendenze dai dati che comportano l’inserimento di stalli: LWZR1,B(R0) LWZR2,C(R0) ADDR3,R1,R2 STWR3,A(R0) LWZR4,E(R0) LWZR5,F(R0) SUBR6,R4,R5 STWR6,D(R0) LWZR1,B(R0) LWZR2,C(R0) ADDR3,R1,R2 STWR3,A(R0) LWZR4,E(R0) LWZR5,F(R0) SUBR6,R4,R5 STWR6,D(R0) Introduzione degli stalli

W.Fornaciari31 Esecuzione pipelined: scheduling Alcune istruzioni possono essere spostate senza alterare il programma, si può cioè effettuare uno scheduling delle istruzioni: LWZR1,B(R0) LWZR2,C(R0) ADDR3,R1,R2 STWR3,A(R0) LWZR4,E(R0) LWZR5,F(R0) SUBR6,R4,R5 STWR6,D(R0) LWZR1,B(R0) LWZR2,C(R0) LWZR4,E(R0) LWZR5,F(R0) ADDR3,R1,R2 STWR3,A(R0) SUBR6,R4,R5 STWR6,D(R0) Scheduling Vengono introdotte 2 fasi di Fetch e non vengono introdotte nuove dipendenze tra i dati. Le nuove fasi di Fetch possono sostituire 2 stalli.

W.Fornaciari32 Esecuzione pipelined: scheduling Il nuovo programma ottenuto può essere ulteriormente migliorato tramite il meccanismo di scheduling: LWZR1,B(R0) LWZR2,C(R0) LWZR4,E(R0) LWZR5,F(R0) ADDR3,R1,R2 STWR3,A(R0) SUBR6,R4,R5 STWR6,D(R0) Scheduling L’istruzione SUB introduce un Fetch e nessuna dipendenza tra i dati. Inoltre ritarda di un ciclo di clock la STW di R6 rispetto alla ADD che calcola R6. La nuova fase di Fetch ed il ritardo aggiuntivo tra la ADD e la STW corrispondente riducono di una unita il numero di stalli in ognuna delle istruzioni STW. LWZR1,B(R0) LWZR2,C(R0) LWZR4,E(R0) LWZR5,F(R0) ADDR3,R1,R2 SUBR6,R4,R5 STWR3,A(R0) STWR6,D(R0)

W.Fornaciari33 Architetture pipelined Architettura tipica con 3 pipeline: Floating-point pipeline Integer pipeline Branch pipeline Load Dispatch Hazards Unit Register File Floating-point pipeline - 8 phases Integer pipeline - 5 phases Branch pipeline - 3 phases

W.Fornaciari34 Architetture pipelined tipiche A ogni ciclo di clock l’unità di prelievo, smistamento e soluzione dei conflitti avvia un’istruzione nella pipeline appropriata, se non ci sono conflitti, altrimenti inserisce uno stallo Ogni classe di istruzioni del processore dispone di una pipeline specifica per la classe Classi simili possono, talvolta, condividere la stessa pipeline (magari lasciando qualche fase “vuota”, se non dovesse servire) Pipeline differenti possono avere profondità (misurata in numero di fasi) differenti I registri del processore (banchi di registri di uso generale e registri di uso speciale) sono condivisi tra le varie pipeline presenti

W.Fornaciari35 Ricerca di maggiori prestazioni Con il pipelining si cerca di raggiungere CPI=1, in realtà CPI>1 poichè conflitti sui dati e sul controllo mancanza di dati o istruzioni nella cache necessità di gestire delle eccezioni Possibile soluzione: superpipelininig spingere la profondità di pipelining es. Alpha ha 8 stadi problemi conflitti sui dati: ho in maggior numero di bolle quando si presentano conflitti controllo: con tanti stadi le diramazioni divengono lente (in caso di errata predizione debbo eliminare più istruzioni dalla pipe) fenomeni di clock skew introdotti dai latch limita l’incremento del clock

W.Fornaciari36 Incremento del parallelismo Il superpipelining è utile all’aumentare del “parallelismo” fra le istruzioni (possibilità di esecuzione simultanea) L’estrazione del parallelismo, oltre che dal compilatore è lasciata allo hardware dell’unità di controllo che, analizzando una finestra di istruzioni deve determinare ev. dipendenze dei dati operando uno scheduling dinamico Per spingere oltre le prestazioni concorrenza a livello maggiore della pipeline possibilità di eseguire più istruzioni simultaneamente, (con CPU singola) Una CPU con Instruction Level Parallelism (ILP) deve compiere più accessi simultanei alla memoria eseguire più istruzioni contemporaneamente

W.Fornaciari37 Processori ILP Le prestazioni dipendono pesantemente da compilatore, risorse disponibili durante l’esecuzione, dal progetto del sistema di memoria il compilatore deve ristrutturare il codice per sfruttare meglio il parallelismo intrinseco del programma più unità funzionali debbono essere in grado di operare in parallelo, con associato un opportuno controllo la banda della memoria per istruzioni e dati deve consentire di eseguire i programma alla velocità richiesta Sul mercato esistono macchine ILP multiple-issue macchine superscalari macchine VLIW (Very Long Instruction Word)

W.Fornaciari38 Processori ILP Ricerca di istruzioni con effettui di mutua indipendenza hardware, in fase di esecuzione (dinamicamente) software, in fase di compilazione (staticamente) Macchine con scheduling dinamico (superscalari) l’identificazione è fatta a livello di compilazione, con eventuale riordino del codice, ma la scelta finale delle istruzioni da avviare al’esecuzione è fatta hw dallo stadio di decodifica possibile compatibilità a livello di codice con CPU a singolo pipelining Macchine con scheduling statico (VLIW) - next generation? in compilatore identifica ed assembla pacchetti di istruzioni che verranno eseguite dalla CPU nel codice sono presenti informazioni (implicite o esplice) per la delimitazione dei pacchetti. Codice diverso da quello con pipeline singola

W.Fornaciari39 CPU superscalari Molto diffuse SuperSparc, ALPHA, Pentium, PowerPC, … L’esecuzione delle istruzioni ha inizio in parallelo in base alla disponibilità dei dati e non dell’ordine delle istruzioni Completate le istruzioni, i risultati sono riordinati in modo da aggiornare lo stato della CPU in base all’ordine corretto delle istruzioni (committment)

W.Fornaciari40 Requisiti per CPU superscalare Lettura di più istruzioni simultaneamente, se possibile, con predizione delle istruzioni di salto condizionale per effettuare letture oltre istruzione di salto Metodi per determinare le vere dipendenze di dati, considerando anche i valori dei registri, e meccanismi per comunicare questi valori quando occorrono nel corso dell’esecuzione Metodi per lanciare (issuing) più istruzioni in parallelo Disponibilità di più unità funzionali di tipo pipelined e di gerarchie di memoria capaci di rispondere contemporaneamente più riferimenti Metodi per comunicare valori di dati mediante istruzioni load e store e interfacce di memoria che consentano di gestire prestazioni a volte imprevedibili delle gerarchie di memoria Metodi per operare il commitment dello stato di un processore nell’ordine corretto, offrendo all’esterno l’apparenza di un’esecuzione “in ordine”.

W.Fornaciari41 Dipendenze di controllo Il codice oggetto è statico, la sequenza di istruzioni eseguire è il flusso dinamico Se le istruzioni sono consecutive, le istruzioni statiche divengono il flusso dinamico semplicemente incrementando il PC Dipendenza di controllo una istruzione ha dipendenza di controllo dalle istruzioni dinamiche che la precedono se il flusso di controllo deve prima attraversare tali istruzioni gli aggiornamenti del PC (per incremento o causa salto) originano dipendenze di controllo per ottenere buon parallelismo debbono essere superate

W.Fornaciari42 Esempio di traduzione L2: move r3,r7#r3--> a  i  lwr8, (r3)#load a  i  addr3, r3, 4 #r3 --> a  i+1  lw r9, (r3) #load a  i+1  ble r8, r9, L3#branch a  i  > a  i+1  move r3, r7 #r3 --> a  i  sw r9, (r3) #store a  i  add r3, r3, 4 #r3 --> a  i+1  sw r8, (r3) #store a  i+1  add r5, r5, 1 #change++ L3: add r6, r6, 1 #i+1 add r7, r7, 4 #r4 --> a  i  blt r6, r4, L2 #branch i<last for (i:=0; i<last; i++)  if (a  i  > a  i+1  )  temp= a  i  ; a  i  = a  i+1  ; a  i+1  =temp; change++; 

W.Fornaciari43 Speculazione Il programma è visto come un insieme di blocchi basici (BB); nell’esempio sono i tre rettangoli Quando si esegue la prima istruzione di un BB lo saranno anche tutte le altre (finestra di esecuzione) e possono essere considerate per esecuzione parallela a parte rispetto dip. dai dati BB spesso piccoli modesto parallelismo cerco di considerare anche dipendenze di controllo legate a modifiche PC Quando si incontra salto si effettua predizione sul risultato salto si legge in modo speculativo l’istruzione che si prevede sarà eseguita dopo queste nuove istruzioni entrano a fare parte della finestra di esecuzione

W.Fornaciari44 Speculazione Se la predizione era corretta tolgo etichetta di “speculazione” alle istruzioni lette e aggiorno stato della macchina Se la predizione era sbagliata debbo “tornare indietro” garantendo che lo stato non sia modificato erroneamente per esempio, la ble crea una dipendenza di controllo; se predico di non eseguire il salto, eseguo in modo speculativo le istruzioni successive

W.Fornaciari45 Dipendenze da risolvere Le istruzioni della finestra di esecuzione sono analizzate per scoprire le dipendenze prima di iniziare la loro esecuzione Dipendenze vere (Read-After-Write, RAW) istruzione può usare un dato solo dopo che che sia stato scritto Dipendenze artificiali da esaminare e risolvere Write-After-Read (WAR) :istruzione vuole scrivere dato in registro ri e deve attendere completamento istruzioni precedenti, ancora in fase di esecuzione, che debbono usare il vecchio valore di ri Write-After-Write (WAR, WAW): più istruzioni debbono scrivere i risultati nello stesso registro, debbo garantire l’ordine corretto (del prg statico) WAR e WAW nascono in fase di compilazione registri in numero limitato, cerco di riutilizzarli; si cerca di risparmiare accessi alla memoria; sono provocate da successive iterazioni di un ciclo

W.Fornaciari46 Schedule di esecuzione parallela Risolte le dipendenze vere e artificiali, le istruzioni sono avviate all’esecuzione in parallelo L’unità di controllo crea uno schedule di esecuzione parallela che garantisce il soddisfacimento dei vincoli di dipendenza e disponibilità di risorse hardware Le istruzioni possono terminare in ordine diverso dal programma causa parallelismo e/o diversa latenza delle varie unità funzionali non posso aggiornare subito il register file e la memoria al termine di una istruzione mantengo in memoria temporanea i risultati (accessibile da eventuali istruzioni dipendenti) fino alla fase di committing o retiring dell’istruzione.

W.Fornaciari47 Tecnica di esecuzione parallela

W.Fornaciari48 Tecnica di esecuzione parallela Il fetch include la predizione dei salti e crea il flusso di istruzioni dinamiche Le istruzioni vengono esaminate per identificare se sia possibile rimuovere le dip artificiali (per es con renaming registri) e avviate alla finestra Nella finestra l’ordine non è più sequenziale, ma legato alle dipendenze vere e alle risorse hw disponibili Dopo l’esecuzione è come se le istruzioni venissero logicamente riordinate mano a mano che possono essere committed e i loro risultati usati per aggiornare lo stato del processore

W.Fornaciari49 Architettura tipo di un microprocessore superscalare

W.Fornaciari50 Architetture superscalari Lettura istruzioni La cache istruzioni è una memoria piccola e veloce che contiene le istruzioni più recenti In una CPU superscalare, la fase di lettura legge a ogni ciclo di cache più istruzioni, pari almeno al massimo numero di istruzioni che possono nel caso ottimo essere eseguite contemporaneamente Nel “buffer istruzioni” si registra un certo numero di istruzioni lette; utilizzando questa “riserva” la CPU può continuare il proprio lavoro anche quando la lettura delle istruzioni è bloccata (ad esempio, per un trasferimento da cache) o limitata

W.Fornaciari51 Architetture superscalari Decodifica delle istruzioni Le istruzioni vengono prese dal buffer istruzioni, esaminate sia per una definitiva decodifica sia per identificare dipendenze di dati e di controllo, e preparate per gli stadi successivi di pipeline Si identificano le dipendenze vere (RAW) e si risolvono quelle WAW e WAR legate al riuso dei registri Si distribuiscono le istruzioni inviandole (dispatching) alle unità funzionali opportune Ciascuna unità funzionale ha di fronte dei buffer (stazioni di prenotazione) che mantengono operandi e operazione finchè non e pronta l’unità funzionale

W.Fornaciari52 Architetture superscalari L’unità di smistamento invia ciascuna istruzione, con gli operandi, alla stazione di prenotazione opportuna e inserisce un riferimento entro un buffer di riordino interno all’unità di consegna Una istruzione non può essere considerata se non c’è spazio sia nella stazione di prenotazione, sia nel buffer di riordino Lo spazio per mantenere i risultati si esaurisce rapidamente i processori hanno registri interni replicati (rename buffers) usati per memorizzare i risultati in attesa che l’unità di consegna dia il permesso per scrivere i registri effettivi i registri replicati, assegnati dall’unità di decodifica, riducono la criticità sui registri

W.Fornaciari53 Commitment Problema identificare (e ritrovare) uno stato preciso del processore Soluzioni salvo lo stato della macchina in particolari punti di controllo (checkpoints) in un history buffer, aggiornato durante l’esecuzione delle istruzioni Quando un’istruzione viene finalizzata si cancella la “storia” che non è più necessaria Separo lo stato fisico da quello logico; lo stato fisico si aggiorna non appena l’operazione viene completata, quello logico viene aggiornato solo in ordine sequenziale, mano a man o che le varie speculazioni hanno raggiunto la loro verifica. Si usa il reorder buffer; per finalizzare un’istruzione, il suo risultato viene tolto dal reorder buffer e portato nel registro destinazione, liberando spazio nel reorder buffer

W.Fornaciari54 Alcuni esempi commerciali PowerPC 620 ha sei unità di esecuzione indipendenti, in un ciclo di clock possono essere completate fino a quattro istruzioni ho cache separate per istruzioni e dati, ciascuna da 32Kbyte a 8 vie Intel P6 possono essere completate tre istruzioni per ciclo di clock 2 unità intere, una in virgola mobile le pipe hanno profondità 12 ha due cache, istruzioni e dati, di 8 Kbyte Alpha per ogni ciclo di clock possono essere mandate in esecuzione 2 istruzioni 1 unità intera, 1 unità virgola mobile, 1 unità fetch/salti, 1 unità load/store verso memoria, con profondità pipe compresa fra 7 e10 cache dati e istruzioni di 32Kbyte

W.Fornaciari55 Conclusioni Sia il pipeline, sia l’esecuzione superscalare aumentano il throughput di picco delle istruzioni Lunghe pipeline e versioni superscalari di maggiore ampiezza rendono il compito del compilatore ancora più complesso per sfruttare al meglio le possibilità dello hardware Le dipendenze dei dati, il controllo nei programmi e la latenza delle istruzioni limitano comunque le prestazioni effettive vista la necessità per il processore di dovere attendere per dipendenze non risolte o un salto non previsto correttamente Visitare il mirror italiano del sito SPEC (spec.unipv.it) per le “vere” valutazioni comparative fra vari sistemi