Dispense Calcolatori Elettronici Con Esercizi

Appunti di Calcolatori Elettronici
A.A. 2009/2010
APPUNTI DI CALCOLATORI ELETTRONICI
Appunti e dispense con esercizi redatti da Nicola Pietroleonardo e Fabio Stroppa in base alle lezioni del corso di Calcolatori Elettronici del Prof. Ing. Francescomaria Marino al Politecnico di Bari dellanno accademico 2009/2010. Parte teorica a cura di Nicola Pietroleonardo. Esercizi ed approfondimenti a cura di Fabio Stroppa.
Copyright (c) 2009-2010-2011 Nicola Pietroleonardo e Fabio Stroppa. nicola.pietroleonardo@gmail.com fa88y@msn.com Questo testo pubblicato sotto licenza:
Creative Commons Attribuzione - Non commerciale Condividi allo stesso modo 2.5 Italia http://creativecommons.org/licenses/by-nc-sa/2.5/it/
Il testo della licenza disponibile qui: http://creativecommons.org/licenses/by-nc-sa/2.5/it/legalcode Tutte le versioni di questo testo sono disponibili nell'area download di Desfa.org. Gli autori non forniscono nessuna garanzia sulle nozioni esposte, nonch sulla precisione delle stesse; fermo restando il forte impegno degli autori nel rendere questo documento il pi preciso possibile. Questo testo da intendersi pertanto a puro scopo informativo.
E DI T OR: N ic o la P ie t ro le o n a r d o P ROD UZ I ON E : N ic o la P ie t ro l e o n a rd o , Fa b io S t ro p p a GRA FI C A DI COP E R TI N A : Fa b riz io P . Ba ld in i - h t t p :// w ww . b a ld u s. a lt e r vist a . o rg /
CALCOLATORI ELETTRONICI A.A. 2009/2010
Pagina 2
Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
IND I CE G E NE R AL E PARTE PRIMA .................................................................................................................................. 7

SET DI ISTRUZIONI .................................................................................................................................... 8 ISTRUZIONI DI TRASFERIMENTO DEI DATI ........................................................................................................... 8 ISTRUZIONI DI TIPO M (MOV)........................................................................................................................ 10 ISTRUZIONI DI CALCOLO ................................................................................................................................ 11 ISTRUZIONI DI CONTROLLO ............................................................................................................................ 12 TABELLA SOTTOINSIEME ISTRUZIONI DI MIPS64.............................................................................................. 13
ESECUZIONE DELLE ISTRUZIONI ALLINTERNO DEL PROCESSORE STRUTTURA DEL PROCESSORE ............................... 14
FORMATO DELLE ISTRUZIONI ....................................................................................................................... 14 CODIFICA DELLISTRUZIONE PER UN PROCESSORE NO-PIPELINE........................................................................... 15 STRUTTURA DEL PROCESSORE NO-PIPELINE ..................................................................................................... 16 DESCRIZIONE DETTAGLIATA DI OGNI PASSAGGIO ............................................................................................... 17 1^ FASE 2^ FASE 3^ FASE 4^ FASE 5^ FASE IF INSTRUCTION FETCH............................................................................................... 17 ID INSTRUCTION DECODE ........................................................................................... 17 EX EXECUTION ......................................................................................................... 18 MEM MEMORY ACCESS ............................................................................................. 19 WB WRITE BACK...................................................................................................... 20
RIEPILOGO .............................................................................................................................................. 21 TECNICA PIPELINE TEMPO DI ESECUZIONE DI UN PROGRAMA .......................................................................... 23 STRUTTURA DEL PROCESSORE PIPELINE ........................................................................................................... 26 EVENTI DI CIASCUNO STADIO DELLA PIPELINE DI MIPS....................................................................................... 27
BREVE CENNO SULLE MEMORIE DEL PROCESSORE (CACHE DI 1LIVELLO) A CCESSO ALLA MEMORIA ....................... 29
ALEE STRUTTURALI ALEE DI DATO ........................................................................................................ 31 ALEE STRUTTURALE. ..................................................................................................................................... 31 ALEE DI DATO ............................................................................................................................................. 31 1. 2. 3. ISTRUZIONI ALU ............................................................................................................................... 32 ISTRUZIONI LOAD ............................................................................................................................. 35 ISTRUZIONE BRANCH......................................................................................................................... 36
MIPS PIPELINE OTTIMIZZATO ......................................................................................................................... 37 DELAY SLOT TECNICA STATICA ..................................................................................................................... 38 TECNICA SPECULATIVA TECNICA DINAMICA .................................................................................................... 39 CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 3

A.A. 2009/2010
SROTOLAMENTO DEL LOOP ....................................................................................................................... 41 PIPELINE DA PROGRAMMA ....................................................................................................................... 43
ESERCIZI DI RIEPILOGO ..................................................................................................................................... 45 ESERCIZIO 1 ................................................................................................................................................ 45 ESERCIZIO 2 ................................................................................................................................................ 48 ESERCIZIO 3 ................................................................................................................................................ 51 ESERCIZIO 4 ................................................................................................................................................ 53 ESERCIZIO 5 ................................................................................................................................................ 55
PARTE SECONDA .......................................................................................................................... 62

GERARCHIA DI MEMORIA ....................................................................................................................... 63 MECCANISMO A FINESTRA DEI REGISTRI .......................................................................................................... 63 PRINCIPI FONDAMENTALI DELLA GERARCHIA DI MEMORIA ................................................................................. 63 TRASPERENZA DEI LIVELLI .................................................................................................................. 63 PRINCIPI DI LOCALITA ...................................................................................................................... 64 LOCALITA SPAZIALE ...................................................................................................................... 64 LOCALITA TEMPORALE.................................................................................................................. 64
QUATTRO DOMANDE PER LA CLASSIFICAZIONE DELLE GERARCHIE DI MEMORIE..................................................... 64 MEMORIE CACHE ...................................................................................................................................... 65 UN PO DI STORIA E CURIOSIT.............................................................................................................. 65 STRATEGIE DI ALLOCAZIONE DEI BLOCCHI ................................................................................................ 65 CACHE COMPLETAMENTE ASSOCIATIVA ....................................................................................................... 66 CACHE AD INDIRIZZAMENTO DIRETTO ......................................................................................................... 66 CACHE SET ASSOCIATIVA ........................................................................................................................... 66 1. 2. 3. 1. 2. STRATEGIE DI RICERCA E IDENTIFICAZIONE ............................................................................................... 67 STRATEGIE DI SOSTITUZIONE (FALLIMENTI DI ACCESSO) ............................................................................. 68 METODO RANDOM .......................................................................................................................... 68 METODO LRU (LAST RECENTLY USED) ................................................................................................. 68 METODO FIFO (FIRST IN FIRST OUT) ................................................................................................... 69 STRATEGIE DI SCRITTURA NELLA CACHE ................................................................................................... 70 WRITE THROUGH. ............................................................................................................................ 70 WRITE BACK.................................................................................................................................... 70
FALLIMENTI DI ACCESSO ALLA CACHE LEGGE DELLE TRE C ........................................................................... 69
ELETTRONICA DELLE MEMORIE................................................................................................................. 71 CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 4 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
SRAM. ............................................................................................................................................ 71 DRAM. ........................................................................................................................................... 71 VALUTAZIONE DELLE PRESTAZIONI DELLA MEMORIA CACHE ......................................................................... 72 FUNZIONAMENTO LOGICO DI UNA MEMORIA CACHE .................................................................................. 75 CACHE POWERPC ............................................................................................................................. 75 CACHE MOTOROLA 68000 ................................................................................................................ 77
INTERAZIONE DELLE MEMORIE CACHE IN UN SISTEMA COMPLESSO ............................................................... 78 PROBLEMATICHE RELATIVE ALLI/O..................................................................................................... 78 PROBLEMATICHE RELATIVE AI SISTEMI MULTICORE ............................................................................... 78 MIGLIORAMENTO DELLE PRESTAZIONI DELLA BANDA PASSANTE DI UNA MEMORIA ......................................... 79 BANCHI MULTIPLI DI MEMORIA PARALLELI .................................................................................................. 79 BANCHI MULTIPLI DI MEMORIA INTERLACCIATI............................................................................................. 79 ORGANIZZAZIONE DELLE MEMORIE A SEMICONDUTTORE ............................................................................. 81 ESERCIZI DI RIEPILOGO ................................................................................................................................ 82 ESERCIZIO 1 ............................................................................................................................................ 82 ESERCIZIO 2 ............................................................................................................................................ 82
PARTE TERZA ................................................................................................................................ 84

PROCESSORE FLOATING POINT ................................................................................................................ 85 SCHEDULING DELLE ISTRUZIONI FLOATING POINT .............................................................................................. 88 ALGORITMO DI TOMASULO ....................................................................................................................... 89 APPLICAZIONE ALGORITMO DI TOMASULO - ESEMPIO ................................................................................ 91 VANTAGGI .............................................................................................................................................. 98
PARTE QUARTA ............................................................................................................................ 99

PROCESSORI VLIW ................................................................................................................................ 100 PROCESSORI SUPERSCALARI .................................................................................................................. 103 PROCESSORI VETTORIALI ....................................................................................................................... 104 TABELLA SET ISTRUZIONI VETTORIALI. ............................................................................................................ 105 OPERAZIONI DI LOAD E STORE ..................................................................................................................... 105 LISTRUZIONE LVWS .................................................................................................................................... 106 I REGISTRI VLR E MVLR ............................................................................................................................... 106 PRESTAZIONI ............................................................................................................................................. 107 ANALISI REALE DELLARCHITETTURA DI UNA CPU VETTORIALE CRAY-1 (1976).................................................. 108
Pagina 5
A.A. 2009/2010
SCHEMA LOGICO .................................................................................................................................... 108 IDEE ALLA BASE DELLA ORGANIZZAZIONE VETTORIALE ................................................................................. 109 CODICE VETTORIALE ............................................................................................................................... 109 ESECUZIONE ARITMETICA DELLE ISTRUZIONI ............................................................................................... 110 SISTEMA DI MEMORIZZAZIONE DI DATI VETTORIALI NEI REGISTRI VETTORIALI ................................................. 110 ESECUZIONE ISTRUZIONI VETTORIALI ......................................................................................................... 110 STRUTTURA DELLE UNITA VETTORIALI ...................................................................................................... 111 DIFFERENZA FRA ARCHITETTURA MEMORIA-MEMORIA E ARCHITETTURA A REGISTRI VETTORIALI ....................... 111 VETTORIZZAZIONE AUTOMATICA DEL CODICE ............................................................................................. 112 GESTIONE DI VETTORI CON DIMENSIONE SUPERIORE A MVLR VECTOR STRIPMINING ..................................... 112 PARALLELISMO DELLE ISTRUZIONI VETTORIALI............................................................................................. 114 PENALITA DI AVVIO DELLE CPU VETTORIALI............................................................................................... 115 GESTIONE DELLE CONDIZIONI USO DEL REGISTRO V.MASK ISTRUZIONI MASCHERATE ................................. 115 RIDUZIONE A OPERAZIONI SCALARI ........................................................................................................... 117 ESERCIZIO ............................................................................................................................................. 118 ARCHITETTURA MULTICORE .................................................................................................................... 123 PARALLELISMO A LIVELLO DI THREAD, MULTI-THREAD .................................................................................... 124 1. 2. 3. SIMULTANEOUS MULTI-THREADING .................................................................................................. 124 FINE-GRAINED MULTI-THREADING. .................................................................................................. 124 COARSE-GRAINED MULTI-THREAD. ................................................................................................... 124
MEMORIA CONDIVISA E MEMORIA DISTRIBUITA IN SISTEMI MULTICORE ............................................................ 125
INDICE ANALITICO ................................................................................ 126 BIBLIOGRAFIA ...................................................................................... 127 ESERCIZI SVOLTI ................................................................................... 128
Pagina 6

PARTE PRIMA
A.A. 2009/2010
PARTE PRIMA PROCESSORE SCALARE

ARCHITETTURA INTERA
Pagina 7

SET DI ISTRUZIONI (processore di riferimento: MIPS64)
A.A. 2009/2010
Con una pluralit di dati che si possono trattare, si va a definire un SET DI ISTRUZIONI per un processore che usa questi dati. TIPI DI DATI: Floating point: sia in SINGLE PRECISION che DOUBLE PRECISION, trattandosi di dati a 32 bit e a 64 bit; Interi: in profondit di 8, 16, 32, 64, bit e per questi numeri varr la possibilit di averli o senza segno (UNSIGNED) oppure con segno (SIGNED); Quindi definiti i tipi di dati con cui il processore deve lavorare, vediamo quali sono le istruzioni che su questi dati user il processore. Si deciso che il processore deve lavorare su questi dati perch, dopo aver fatto un po di conti dei transistor a disposizione in un chip, possibile integrare un certo numero di unit di calcolo floating point a 32 o 64 bit e un ALU a che lavora con dati a 64 bit (essendo lALU capace di lavorare con dati a 64 bit pu anche lavorare con dati a profondit pi bassa, opportunamente riempiendo i bit mancanti). Il processore di riferimento di questo corso il MIPS64. Tutte le istruzioni che esegue il MIPS64 appartengono ad uno di questi gruppi: Istruzioni di calcolo; Istruzioni di accesso alla memoria; Istruzioni di controllo; Le istruzioni di calcolo si separano in due famiglie se il calcolo intero (user lALU) oppure se il calcolo floating point (user le unit di calcolo floating point). ISTRUZIONI DI TRASFERIMENTO DEI DATI 1 LETTERA: indica il tipo di operazione L indica unoperazione di tipo load, MEMORIA PROCESSORE; S indica unoperazione di tipo store, PROCESSORE MEMORIA. 2 LETTERA: indica il dato che viene trattato dallistruzione, quanti bit verranno trattati B indica byte, quindi una parola di 8 bit; H indica half (mezzo), quindi mezza parola ossia 16 bit (una parola di 32 bit); W indica word, quindi una parola intera ossia 32 bit; D indica double, quindi una doppia parola ossia 64 bit. 3 LETTERA: indica se loperazione riguarda un dato UNSIGNED (NON SEMPRE PRESENTE) U indica unsigned, quindi unoperazione che riguarda un dato senza segno. Si osservi che nelloperazione di STORE non presente, per nessun dato da trattare, la lettera U, questo perch effettivamente loperazione identica per entrambi i tipi di dati. Invece necessaria specificarla nelloperazione di LOAD (ma non in tutte). La necessit di specificare la terza lettera risale al momento della carica del dato; se questo un dato binario o un dato con segno la carica deve essere fatta in maniera diversa.
Pagina 8
A.A. 2009/2010
Esempio - LOAD DI UN BYTE Questo processore ha i registri interi di 64 bit, quindi quando viene effettuata la LOAD di un byte dalla memoria sar letta una parola di 8 bit che verr scritta in un registro (che come detto di 64 bit); quegli 8 bit verranno messi nella parte meno significativa del registro. 00000101 56bit + 8bit = 64 bit
I restanti 56 bit dovranno essere riempiti opportunamente; si portati a pensare che questi 56 bit potranno essere riempiti con una sequenza di 0, per questo non sempre vero. Si suppone che il numero letto il numero -5; i numeri negativi vengono scritti utilizzando il complemento a 2, quindi: 00000101 Complemento a 1 11111010 + 1 11111011 Il numero ottenuto -5 in binario (complemento a 2). Se invece 11111011 fosse un numero assoluto, ossia senza segno, sarebbe 255 4 = 251. Quindi gli stessi bit possono significare cose diverse a seconda che si consideri un numero binario con o senza segno. Non a caso se sommo 251 a 5 ottengo 256, cio se lo leggo come numero intero o lo leggo in complemento a 2 quando poi vado a fare la somma del numero intero letto pi il valore assoluto del numero in complemento a 2 ottengo sempre 256. Quindi nel momento della load bisogna sapere se il byte che si sta leggendo con o senza segno, perch se senza segno allora riempio i 56 bit con degli 0, altrimenti se un numero che scritto in complemento a 2 bisogner riempirli non sempre con degli 0 ma con quello che il bit di segno del numero stesso, quindi se un numero con segno gli 8 bit saranno riempiti con il numero binario in complemento a 2 mentre i restanti 56 bit con la replica del bit di segno, quindi 1 nel caso esso sia negativo. 111111111111111 56bit + 11111011 8bit = 64 bit
Questa differenza fa si che le istruzioni per caricare un byte in un registro siano diverse. Identico discorso vale nel momento in cui vengono effettuate load di HALF WORD (16 bit) o di un WORD (32 bit). Nel caso della load di una DOUBLE WORD non vi nessun problema poich essa gi di 64 bit.
Pagina 9
A.A. 2009/2010
Esempio - STORE DI UN BYTE Quello che sta scritto negli altri 56 bit del registro non viene preso in considerazione; quindi vengono presi gli 8 bit meno significativi e vengono scritti in memoria. Per questo non presenta la lettera U nellistruzioni di store. Identico discorso vale per le store di HALF WORD o di WORD. ALTRE ISTRUZIONI DI TRASFERIMENTO DEI DATI L.S indica unoperazione di tipo load FLOATING POINT a SINGLE PRECISION (32 bit) L.D indica unoperazione di tipo load FLOATING POINT a DOUBLE PRECISION (64 bit) La differenza che una volta letti questi bit devono copiarsi non nei registri GPR (General Purpose) ma nei registri floating point, che sono simili elettronicamente ai GPR ma non sono collegati (in hardware) allALU, che fa i calcoli in aritmetica intera, bens alle unit di calcolo floating point.
REGISTRI GPR
ALU
REGISTRI FLOATING POINT

UNITA DI CALCOLO FLOATING POINT
I vecchi processori a 32 bit utilizzavano registri GPR e flaoting point a 32 bit trattando questi ultimi nel seguente modo: essendo a 32 bit non creano nessun problema nelle istruzioni L.S, per quando si trovano ad operare con dati floating point double devono lavorare in coppia, cio una parte del dato andr in un registro e laltra in un altro, i quali devono essere adiacenti considerando come primo registro uno che abbia un numero pari; quindi un esempio di adiacenza F0 F1 oppure F2 F3. Questo perch il dato floating point double sar trattato in maniera tale che il primo registro associato terr i bit che riguardano lesponente e una parte della mantissa, mentre laltro conterr i restanti bit della mantissa; in particolare, nellistruzione, sar necessario solamente indicare il registro pari in cui salvare il dato floating point double, poich sottointeso che verr utilizzato anche il registro successivo. In questo corso considereremo per il MIPS64 che ha registri e bus a 64 bit. ISTRUZIONI DI TIPO M (MOV) Sono istruzioni che lavorano su dati che sono gi allinterno del processore. MFC0 indica unoperazione di tipo copia dati dal registro GPR a un registro speciale; MTC0 indica unoperazione di tipo copia dati da un registro speciale ad uno GPR; MOV.S indica unoperazione di tipo copia dati da un registro in virgola mobile a singola precisione in un altro dello stesso tipo; MOV.D indica unoperazione di tipo copia dati da un registro in virgola mobile a doppia precisione in un altro dello stesso tipo;
Pagina 10

A.A. 2009/2010
MFC1 indica unoperazione di tipo copia dati da un registro GPR a un registro FLOATING POINT; MTC1 indica unoperazione di tipo copia dati da un registro FLOATING POINT a un registro GPR.
Lutilit di queste ultime due istruzioni sta nel fatto che se durante lesecuzione i dati hanno riempito tutti i registri GPR e serve un registro per caricare un altro dato sar possibile prendere un dato da un registro GPR e copiarlo in un registro floating point, in modo tale da far posto al nuovo dato. Attenzione il dato che andr nel registro floating point non sar assolutamente elaborato dallunit di elaborazione floating point, perch sar un dato che non avr nessun significato. ISTRUZIONI DI CALCOLO Queste istruzioni iniziano tutte con la lettera D a significare il trattamento di dati DOUBLE. Questo perch lALU progettata a 64 bit. Le altre tre lettere indicano il tipo di operazioni che si vuole fare; la lettera U indica che loperazione deve essere svolta su dati UNSIGNED, operazione che risulta diversa nei dati senza segno, ad esempio si considerino i casi di overflow, i quali sono segnalati da una parte del processore chiamata PSW (Process Status Word) che ha un bit che segnala loverflow. La lettera I indica che uno degli operandi un IMMEDIATO, ossia un dato gi noto nel momento in cui il compilatore scrive il programma eseguibile; si deduce che non necessario salvare questo operando in un registro, ad esempio si considerino le istruzioni per implementare un ciclo for le quali hanno la variabile indice salvata in un registro a cui verr sommato ogni volta un altro valore che per non necessario salvare in un registro (il compilatore sa gi che quel valore 1). Limmediato occupa 16 bit nellistruzione. Si noti che assente la sottrazione con un immediato, questo ovvio perch possibile fare la somma con un immediato con segno meno. Vediamo unistruzione particolare: MADD indica unoperazione di moltiplicazione somma, cio possibile in un'unica istruzione effettuare una moltiplicazione e una somma (ad esempio: + ). Chiaramente questa istruzione deve avere ununit dellALU che operi direttamente su questa istruzione e che quindi cominci a fare la somma appena i bit del prodotto cominciano ad essere calcolati. Quindi lunit di calcolo che fa la MADD non esegue prima la moltiplicazione e poi la somma, perch altrimenti si avrebbe unALU lenta quanto il tempo per fare una moltiplicazione e poi una somma. Poi ci sono le istruzioni per effettuare le operazioni logiche; in particolare istruzioni di AND si usano quando si vogliono fare operazioni di mascheramento, cio quando si vogliono vedere solo alcuni bit di una parola; loperazione di mascheramento si ottiene creando una maschera da mettere in AND con la parola da mascherare, questa maschera permetter di vedere solo alcuni bit del numero. Osserviamo ora la seguente istruzione: LUI indica unoperazione che permette di caricare nella parte alta di un registro il valore di un immediato. La lettera U questa volta non indica unsigned ma sta per UPPER (superiore).
Pagina 11
A.A. 2009/2010
Infine analizziamo le istruzioni di scorrimento (shift) e le istruzioni dimpostazione (set). ISTRUZIONI SHIFT Composte dalle lettere DS e poi da altre due lettere; lo shift pu essere fatto a sinistra o a destra, troviamo per questo una L (left) o una R (right). Inoltre lo shift si caratterizza dal fatto che pu essere sia di tipo logico sia di tipo aritmetico, indicando rispettivamente con le lettere L e A. Lo shift logico fa scorrere i bit in un verso e fa entrare degli zeri; lo shift aritmetico viene usato per fare calcoli aritmetici. In particolare per lo shift a destra bene notare che esiste sia quello di tipo logico che quello di tipo aritmetico: lo shift logico sposta i bit della parola e fa entrare degli zeri, mentre lo shift aritmetico sposta la parola ed estende il bit di segno; per lo shift a sinistra, invece, si considera solo lo shift logico in quanto non essendoci estensione di segno entrano solo degli zeri. Infine pu essere presente la lettera V la quale indica che lo shift avviene di un numero di posizioni variabile. ISTRUZIONI SET Sono istruzioni che vanno ad impostare un registro ad un valore minore di un certo altro valore; la prima lettera S sta per set, la seconda lettera L sta per less, la terza lettera T sta per than, infine potrebbero essere presenti altre lettere tra cui la I (immediate) e la U (unsigned). ISTRUZIONI DI CONTROLLO Sono istruzioni che consentono al programma di eseguire un flusso distruzioni diverso da quello sequenziale, questo perch si potrebbe aver bisogno di dover saltare ad unaltra istruzione. Si distinguono cos due tipi di salti distruzione: SALTO CONDIZIONATO: un tipo di salto che viene effettuato nellesecuzione di un programma se la condizione da verificare vera, altrimenti si prosegue con il normale svolgimento sequenziale del programma. Questo tipo di salto viene chiamato Branch, da qui lutilizzo della lettera B come prima lettera dellistruzione. SALTO INCONDIZIONATO: un tipo di salto che viene effettuato nellesecuzione di un programma il quale deve andare ad eseguire unaltra istruzione, la quale non quella successiva, a prescindere da tutto. Questo tipo di salto viene chiamato Jump, da qui lutilizzo della lettera J come prima lettera dellistruzione.
Pagina 12
A.A. 2009/2010
Di seguito riportata la tabella con un riepilogo di alcune le istruzioni qui sopra presentate pi altre che costituiscono il sottoinsieme di istruzioni di MIPS64.
Tipo di istruzione/codice operativo Trasferimento di dati: trasferisce dati tra i registri e la memoria, oppure tra registri (di tipo intero, virgola mobile o speciale); lunica modalit di indirizzamento della memoria quella con scostamento a 16 bit, cui sommare il contenuto di un GPR LB, LBU, SB LH, LHU, SH LW, LWU, SW LD, SD L.S, L.D, S.S, S.D MFC0, MTC0 MOV.S, MOV.D MFC1, MTC1 DADD, DADDI, DADDU, DADDIU DSUB, DSUBU DMUL, DMULU, DDIV, DDIVU, MADD AND, ANDI OR, ORI, XOR, XORI LUI DSSL, DSRL, DSRA, DSLLV, DSRLV, DSRAV SLT, SLTI, SLTU, SLTIU Controllo: Salti condizionati e non condizionati; relativi al PC o usando un registro BEQZ, BNEZ BEQ,BNE BGTZ, BLTZ BGEZ, BLEZ BC1T,BC1F MOVN, MOVZ J, JR TRAP ERET Significato dellistruzione Carica un byte, carica un byte senza segno, memorizza un byte (da/in registri per interi) Carica mezza parola, carica mezza parola senza segno, memorizza mezza parola (da/in registri per interi) Carica una parola, carica una parola senza segno, memorizza una parola (da/in registri per interi) Carica una doppia parola, memorizza una doppia parola (da/in registri per interi) Carica un SP, carica un DP, memorizza un SP, memorizza un DP Copia da/a un GPR a/da un registro speciale Copia da un registro in virgola mobile a singola o doppia precisione a un altro registro dello stesso tipo Copia da 32 bit in/da registri in virgola mobile da/in registri interi Addiziona, addiziona un valore immediato (tutti i valori immediati sono a 16 bit); con segno e senza segno Sottrai; con segno e senza segno Moltiplica e dividi; con segno e senza segno; moltiplica-e-addiziona; tutte le operazioni richiedono e producono valori a 64 bit Esegui AND, esegui AND con un dato immediato Esegui OR, esegui OR con un dato immediato; esegui OR esclusivo, esegui or esclusivo con un dato immediato Carica nella parte alta un valore immediato, cio scrivi un valore immediato nei bit da 32 a 47 di un registro, poi estendi il segno Scorri; sia in modo immediato (DS__) sia in forma variabile (DS__V); gli scorrimenti sono logico verso sinistra, logico verso destra, aritmetico verso destra Imposta un valore inferiore a, omposta un valore inferiore ad un valore immediato; con segno e senza segno Salta se un GPR /non- uguale a zero; scostamento di 16 bit da PC+4 Salta se i GPR sono/non-sono uguali; scostamento di 16 bit da PC+4 Salta se un GPR maggiore/minore a zero; scostamento di 16 bit da PC+4 Salta se un GPR maggiore/minore o uguale a zero; scostamento di 16 bit da PC+4 Verifica il bit di confronto nel registro di stato per le operazioni in virgola mobile e salta; scostamento di 16 bit da PC+4 Copia un GPR in un altro GPR se il terzo GPR negativo, se zero Salta incondizionatamente; scostamento di 26 bit da PC+4 (J) oppure destinazione in un registro (JR) Trasferisce il controllo al sistema operativo a un indirizzo vettorizzato Torna al codice utente da un gestore di eccezione; ripristina la modalit utente
Logico/aritmetiche: operazioni su numeri interi o su dati di tipo logico contenuti in un GPR; gli overflow di operazioni aritmetiche su numeri con segno vengono segnalati
Il SET-ISTRUZIONI completo del MIPS64 disponibile al seguente link: http://www.mips.com/products/architectures/mips64/
Pagina 13

ESECUZIONE DELLE ISTRUZIONI ALLINTERNO DEL PROCESSORE STRUTTURA DEL PROCESSORE
A.A. 2009/2010
FORMATO DELLE ISTRUZIONI Come gi detto c la possibilit di avere un formato di istruzioni a lunghezza variabile e un formato a lunghezza costante. Il caso che interessa quello a formato di istruzioni a lunghezza costante e quelle che operano in virgola fissa; le istruzioni di questo tipo sono tutte quelle mancanti del punto e sono tutte codificate in un formato a 32 bit.
6 bit dedicati al codice operativo; un numero preciso di bit che riguardano listruzione e quindi dipendono dal suo tipo: o Istruzione di tipo R, cio quellistruzione che richiede operandi che sono dei registri e quindi sono istruzioni che codificano operazioni ALU in cui sia il primo sorgente che il secondo sorgente ed il destinazione sono un registro; in questo caso dovendo specificare tre registri, ciascuno di questi richiede un numero di bit pari a 2 dove n il numero dei registri che il processore possiede (in questo caso sono 32 e quindi ogni registro richiede 5 bit); segue che dopo i 6 bit del c.o. ci sono tre campi ciascuno da 5 bit; ci sono dei campi aggiuntivi che vengono usati per estensioni del tipo di operazione da fare. o Istruzione di tipo I, cio quellistruzione che richiede un immediato e quindi non necessario lutilizzo di un registro per la memorizzazione del valore dellimmediato ( noto dentro listruzione); sia avr: un registro sorgente, un registro destinazione e un immediato di 16 bit; quando poi verr effettuato il calcolo fra il registro sorgente e limmediato, questultimo verr esteso a 32 bit (i 16 bit verranno copiati dallistruzione e verranno messi in ingresso allALU solo dopo averlo espanso a 32 bit, aggiungendo per 16 volte il bit di segno). Questo tipo di istruzione viene utilizzata anche per quelle di tipo BRANCH, la quale richiede un immediato per effettuare un salto condizionato, il quale si verifica indicando lindirizzo dove saltare. Sappiamo per che lindirizzo di 32 bit e quindi non posso avere un indirizzo nellistruzione, per cui si avr un salto che sar sempre relativo al program counter (PC) e quindi si avr un registro che indicher la condizione e il valore, che una volta esteso a 32 bit dovr sommarsi al PC.
Istruzione di tipo Jump, cio quellistruzione che richiede un immediato per effettuare un salto incondizionato, ma non richiede di specificare la condizione; in questo caso listruzione, non dovendo specificare nessun operando, ha a disposizione tutti i restanti 26 bit per indicare dove saltare, questi bit sempre relativi al PC. Quando il processore carica unistruzione non sa che tipo di istruzione e quindi cosa contiene, per cui vedremo che una volta caricata listruzione, andando a leggere i 6 bit del codice operativo, la control unit sapr come interpretare i restanti 26 bit.
Pagina 14
A.A. 2009/2010
CODIFICA DELLISTRUZIONE PER UN PROCESSORE NO-PIPELINE Qualsiasi istruzione inizia la sua esecuzione nello stesso modo, perch chiaro che il processore nelleseguire unistruzione non conoscendone ancora il tipo deve comportarsi con tutte allo stesso modo. Quindi le prime operazioni non dipenderanno dal tipo dellistruzione; successivamente una volta che il processore avr compreso quella che la particolarit dellistruzione che sta processando, eseguir delle operazioni a seconda che listruzione di tipo ALU, LOAD/STORE oppure di DIRAMAZIONE. Il processore ogni volta che esegue unistruzione lo fa eseguendo un programma, definito come microprogramma; questo microprogramma costituito da una serie di microistruzioni. Il microprogramma scritto in una micro memoria; in questa micro memoria sono quindi scritte tutti i passi del microprogramma se la control unit, la quale si preoccupa di comandare la parte di calcolo del processore, stata realizzata con tecnologia MICROPROGRAMMATA. Possiamo immaginare la control unit come un dispositivo che colpo di clock dopo colpo di clock produce delle uscite che servono ad esempio allALU, al banco dei registri o alla memoria per fargli compiere delle operazioni. La control unit realizzabile utilizzando due diverse tecnologie: MICROPROGRAMMATA: ha al suo interno una struttura analoga al processore che esegue dei microprogrammi. Lo svantaggio di questa tecnologia che lenta perch deve accedere ogni volta alla memoria; il vantaggio che aggiungendo funzionalit al processore non bisogner sostituire la control unit, ma bisogner soltanto aggiungere altre microistruzioni alla micro memoria. CABLATA: costituita da un circuito digitale, pensata come una macchina a stati, cio un circuito sequenziale, costituito da flip-flop e porte logiche, con memoria che produce le uscite non solo come funzione degli ingressi ma anche come funzione delle uscite agli istanti precedenti. Il vantaggio di questa tecnologia che la control unit pi veloce rispetto ad unit di controllo basata su microprogrammi; lo svantaggio che se si va a modificare il processore, ad esempio in caso di upgrade, bisogner cambiare completamente la control unit e riprogettarla per adattarla al nuovo processore.
Pagina 15

STRUTTURA DEL PROCESSORE NO-PIPELINE Vediamo ora come unistruzione viene eseguita allinterno di un processore NO-PIPELINE. Di seguito riportato lo schema del processore.
A.A. 2009/2010
Nelle pagine successive verranno analizzati i singoli passaggi per i seguenti tipi di istruzioni: Memory Reference (LOAD/STORE); Register-Register ALU operation; Register-Immediate ALU operation; Branch. COMPONENTI DEL PROCESSORE REGISTRI - PC: Program Counter, registro speciale che contiene lindirizzo della memoria in cui il processore trover listruzione da eseguire; - IR: Istruction Register, registro contenente listruzione correntemente in esecuzione; - REGISTERS - GPR: General Purpose, registri generali indicati con una numerazione progressiva (R0, R1, ), usati per contenere gli operandi e i risultati parziali durante lesecuzione delle istruzioni; - A e B: registri temporanei - IMM: Immediate, registro temporaneo per memorizzare limmediato esteso di segno; - ALU OUTPUT: registro di output dellALU; - LMD: acronimo di Load Memory Data, registro in cui si memorizza il dato in uscita dalla Data Memory; - COND: registro flag di 1 bit per verificare il risultato della condizione. MEMORIE (CACHE DI 1 LIVELLO) - INSTRUCTION MEMORY: memoria contenente le istruzioni da eseguire; - DATA MEMORY: memoria contenente i dati su cui verranno effettuate le operazioni.
Pagina 16
A.A. 2009/2010
ALTRI COMPONENTI - ALU: Arithmetic Logic Unit, si occupa di eseguire le operazioni di tipo aritmetico/logico. - MUX: Multiplexer, dispositivo capace di selezionare un singolo segnale elettrico fra diversi segnali dingresso in base ad un valore specifico determinato dal segnale di controllo. - SIGN EXT: modulo di estensione del segno. - ADD: modulo sommatore.
DESCRIZIONE DETTAGLIATA DI OGNI PASSAGGIO 1^ FASE IF INSTRUCTION FETCH Dopo aver dato all Instruction Memory il contenuto di PC, questa scarica listruzione generata nellInstruction Register (IR). Contemporaneamente il PC va in ingresso al modulo sommatore (ADD) che riceve come altro ingresso un valore costante pari a 4 (4 byte 32 bit istruzione successiva); il risultato salvato in NPC (New PC) sar il nuovo valore del PC. Tutto questo vale se nell Instruction Memory presente listruzione, altrimenti si va in stallo (in attesa). In sintesi: IR MEM[PC] NPC PC + 4
2^ FASE ID INSTRUCTION DECODE Ora che listruzione nellIR, quindi allinterno del processore, viene effettuata la sua decodifica e in contemporanea il processore esegue la precarica dei coefficienti, ossia il prelievo dei bit dallistruzioni che si potrebbero riferire agli operandi e il salvataggio di essi nei GPR; i registri che possibilmente contengono gli operandi saranno messi in registri temporanei A e B, pronti per essere processati dallALU, mentre loperando che potrebbe indicare il registro destinazione verr esteso in segno (portato a 32 bit) e conservato nel registro temporaneo IMM (trattarlo come un immediato non comporta nessun problema). Al termine della decodifica il processore sapr il tipo dellistruzione da eseguire e quindi sapere se i 16 bit si riferivano ad un registro destinazione o ad un immediato e se i registri A e B contengono gli operandi o semplici indirizzi. In sintesi: A Regs[IR6..10] B Regs[IR11..15] Imm ((IR16)16##IR16..31)
Pagina 17
A.A. 2009/2010
3^ FASE EX EXECUTION LALU operer su tutti gli operandi preparati nella fase di decode, effettuando una delle quattro funzioni a seconda del tipo distruzione: Memory Reference (LOAD/STORE) I MUX passano allALU il valore del registro A e il valore del registro IMM; lALU li somma per formare lindirizzo effettivo della memoria. Il risultato viene inserito nel registro ALU OUTPUT; In sintesi:
ALUOUTPUT A + IMM
Register-Register ALU instruction I MUX passano allALU il valore del registro A e il valore del registro B; lALU esegue loperazione specificata dal codice operativo. Il risultato viene inserito nel registro ALU OUTPUT; In sintesi:
ALUOUTPUT A op B
Register-Immediate ALU instruction I MUX passano allALU il valore del registro A e il valore del registro IMM; lALU esegue loperazione specificata dal codice operativo. Il risultato viene inserito nel registro ALU OUTPUT. In sintesi:
ALUOUTPUT A op IMM
Pagina 18

Branch I MUX passano allALU il valore dellNPC e il valore del registro IMM; lALU li somma per calcolare lindirizzo della destinazione del salto. Il risultato viene inserito nel registro ALU OUTPUT. Il valore di A viene utilizzato per determinare se il salto viene effettuato; loperazione di confronto dipende dal codice operativo dellistruzione di branch (ad esempio pu essere listruzione di BEQZ). In sintesi:
A.A. 2009/2010
ALUOUTPUT NPC + IMM Cond ( A op 0 )
4^ FASE MEM MEMORY ACCESS Le uniche istruzioni attive in questa fase sono quelle LOAD, STORE e BRANCH Memory Reference (LOAD) Con lindirizzo calcolato durante la fase precedente e memorizzato nel registro ALUOUTPUT, si accede alla DATA MEMORY. La Data Memory restituisce il dato richiesto che si memorizza nel registro LMD. In sintesi:
LMD Mem[ALUOUTPUT]
Memory Reference (STORE) Con lindirizzo calcolato durante la fase precedente e memorizzato nel registro ALUOUTPUT, si accede alla DATA MEMORY. Il dato del registro B viene scritto nella Data Memory a quellindirizzo. In sintesi:
Mem[ALUOUTPUT] B
Pagina 19

Branch Se la condizione verificata, il segnale proveniente dal registro flag COND fa da controllo, allora il PC viene aggiornato con il valore calcolato nella fase precedente e memorizzato nel registro ALUOUTPUT. In caso contrario il PC verr aggiornato con il valore del registro NPC. In sintesi:
A.A. 2009/2010
if (cond) PC ALUOutput else PC NPC

5^ FASE WB WRITE BACK
Register-Register/Immediate ALU instruction Il MUX passer al banco dei registri GPR il valore del registro ALUOUTPUT. Questo valore andr a salvarsi nel registro identificato dal terzo operando. Lo stesso discorso vale per le istruzioni Register Immediate.
Load instruction Il MUX passer al banco dei registri GPR il valore del registro LMD. Questo valore andr a salvarsi nel registro identificato dalloperando.
Pagina 20
A.A. 2009/2010
Tutto quanto spiegato funziona nellipotesi che il processore esegue unistruzione per volta (NO-PIPELINE); si noti che durante lesecuzione dellistruzione si attraversa il processore a fette, come se fosse un tubo, tralasciando le operazioni effettuate e che quindi non servono pi. Quindi lidea quella di immaginare il processore come un tubo diviso in stadi, da qui PIPELINE; quando unistruzione entra, esegue le sue operazioni nel primo stadio e poi passa al secondo, posso far entrare una nuova istruzione. Questo significa eseguire unistruzione in un tempo approssimativamente pi piccolo; quindi necessario modificare il processore avendo fra uno stadio ed un altro una serie di banchi che eseguiranno delle specifiche operazioni. Per concludere viene riportato uno schema per ogni tipo distruzione. Riepilogo ISTRUZIONE LOAD
ISTRUZIONE ALU GPR op GPR
Pagina 21

ISTRUZIONE ALU GPR op IMM
A.A. 2009/2010
ISTRUZIONE STORE
ISTRUZIONE BRANCH
Pagina 22
A.A. 2009/2010
TECNICA PIPELINE TEMPO DI ESECUZIONE DI UN PROGRAMA La PIPELINE sfrutta la seguente osservazione: quando unistruzione viene eseguita, attraversando il processore a fette, lasciando alle sue spalle parti di esso che lha elaborata; per cui si potrebbero usare queste parti per eseguire unaltra istruzione. Prima di entrare nello specifico della PIPELINE vediamo se effettivamente questa struttura conveniente; supponiamo che unistruzione per essere eseguita da un processore richieda un tempo T, definito tempo medio. Se un programma ha N istruzioni la sua esecuzione richieder un tempo pari a NT, dove N non un numero di istruzioni statico (cio quelle che compongono il listato) ma bens dinamico, cio quelle che effettivamente vengono eseguite. Potendo implementare una struttura a pipeline possiamo far s che la seconda istruzione inizi la sua esecuzione quando la prima istruzione libera la prima parte di processore. Si osservi il seguente grafico:
La prima istruzione dura 5 colpi di clock (CC) T = 5 CC; la seconda istruzione invece di partire al colpo di clock 6, quando terminata la prima istruzione, inizia al colpo di clock 2, questo possibile perch al CC 2 la prima istruzione ha liberato la parte di processore che accede alla IM (Instruction Memory). Anche la seconda durer 5 CC. Invece di durare un tempo pari a NT, il programma durer: + 1 T: tempo di esecuzione della prima istruzione (in questo caso 5 CC) t: tempo di una fase singola (in questo caso 1 CC), contare per N-1 volte. In generale vale: =

nl: numero di livelli pipeline (in questo caso 5 livelli). pp: profondit della pipeline, per profondit si intende il numero distruzione contemporaneamente dentro alla pipeline. Queste ultime due grandezze coincidono, ma concettualmente sono due cose diverse.
Pagina 23

Quindi: + 1 + 1 = + = = +
con
1
A.A. 2009/2010
parametro trascurabile;
Sul termine
possibile fare dei ragionamenti:
si partiti dal presupposto che = , il quale potrebbe essere vero soltanto se il tempo di esecuzione di unistruzione fosse diviso in nl parti di durata uguale (in questo caso la pipeline si dice perfettamente bilanciata), ma non sempre possibile; si deduce che non possibile imporre a piacere il valore di t. Quindi il grafico presentato funzionerebbe correttamente se ciascuna fase durasse il tempo della fase pi lenta, che denominiamo TC; in realt si dovr considerare che nella struttura del processore pipeline fra ogni passo c un blocco (latch - grigio nel disegno della pagina seguente) necessario se il processore lavora su pi istruzioni contemporaneamente, quindi bisogna considerare, oltre al tempo di lavoro netto per effettuare il preciso passo, il tempo di lettura e scrittura dei latch; quindi il tempo di una fase diventer: = + + TL: tempo di lettura del latch TC: tempo di calcolo della fase pi lenta TS: tempo di scrittura del latch Generalmente si pensa la pipeline costituita da 5,6 o 7 stadi, ma possibile pensare la pipeline in altri due modi: UNDER-PIPELINE: numero di stadi ridotto, inferiore a 5; t diventa pi grande comportando la realizzazione di una CU pi semplice. SUPER-PIPELINE: numero di stadi alto, maggiore di 7; t diventa pi piccolo comportando la realizzazione di una CU pi complessa. Ovviamente tutto questo detto fino ad ora si pu considerare in una idealizzazione del funzionamento della pipeline; infatti bisogna considerare le situazioni in cui si perdono dei colpi di clock per effettuare determinate istruzioni. Si pensi alle istruzioni di branch: al primo CC arriva questo tipo di istruzione; al secondo CC per caricare listruzione successiva bisogna conoscere qual questa istruzione da eseguire. La prima istruzione deve calcolare lindirizzo per effettuare il salto e salvarlo nel PC, ma questo verr effettuato in fasi successive quando lALU effettuer le sue operazioni. Per cui partiranno altre istruzioni, ma solamente nel momento in cui verr aggiornato il PC verr eseguita la giusta istruzione; le istruzioni partite saranno bloccate con conseguente perdita di tempo. Per cui bisogner aggiungere al calcolo del tempo i colpi di clock sprecati.
Pagina 24

ESEMPIO
A.A. 2009/2010
La prima un istruzione di tipo R di somma fra i registri R2 e R3 con registro destinazione R1; Regs R1 Regs[R2] + Regs[R3] La seconda istruzione richiede di usare il registro R1 con il registro R5 per fare una differenza e scrivere il risultato nel registro destinazione R4; Regs R4 Regs R1 Regs[R5] evidente che R1 non ancora disponibile o meglio sono solo presenti dei bit che non hanno significato; quindi la CU dovr in qualche modo bloccare listruzione per poi farla ripartire quando R1 sar disponibile. Questo comporta una perdita di colpi di clock. In seguito vedremo opportune soluzioni per risolvere questi problemi. Lobiettivo per cui stato mostrato questo esempio quello di far comprendere che il tempo per eseguire un programma dipende quindi da molti fattori.
Pagina 25

STRUTTURA DEL PROCESSORE PIPELINE Di seguito riportato lo schema del processore.
A.A. 2009/2010
Fondamentalmente rispetto al processore NO-PIPELINE ci sono delle grosse differenze: nel processore NO-PIPELINE sono presenti vari registri temporanei come i registri IR, A, B, IMM, ALUOUTPUT, ecc; mentre nel processore PIPELINE questi registri sono stati inseriti nei latch (blocchi grigi). Questa scelta dovuto al fatto che questo processore esegue pi istruzioni per volta; se per esempio unistruzione si trova nellultima fase quella di WB, il MUX vedendo il codice operativo dellIR sa quale dato far andare nel banco dei registri. Nel caso di un processore no-pipeline non vi erano problemi perch lIR manteneva linformazione per tutta la durata dellesecuzione dellistruzione; nel processore pipeline ogni latch contiene il valore del registro IR che ogni colpo di clock si copia nel latch successivo, questo perch con larrivo di una nuova istruzione lIR viene modificato, per cui si avrebbe una perdita di dati. Quindi tornado allesempio, in cui listruzione si trova nella fase di WB, il MUX prelever il valore del registro IR dal latch che lo precede. Si noti inoltre il MUX che si trova dopo lADD tra il PC e 4. Rispetto al no-pipeline si trova avanti perch importante che il PC sia aggiornato mentre listruzione termina la prima fase, per far si che si possa prelevare la prossima istruzione. Quindi ci sono alcuni registri che sono propagati latch per latch, chiamati sempre allo stesso modo del nopipeline, per per effettuare laccesso bisogna specificare a quale latch ci si riferisce; ad esempio IF/ID.IR per indicare il registro IR che si trova nel latch IF/ID.
Pagina 26

Di seguito sono riportati gli eventi di ciascuno stadio della pipeline di MIPS.
IF/ID.NPC PC+4;
A.A. 2009/2010
IF/ID.PC (if ((EX/MEM.opcode == branch) || (EX/MEM.opcode == jump) & EX/MEM.cond) {EX/MEM.ALUOutput} else {PC+4});
Se listruzione EX/MEM.cond (if Se listruzione EX/MEM.cond (if
una BEQZ (ID/EX.A una BNEZ (ID/EX.A
allora: == 0) {1}); allora: != 0) {1});
Bisogna considerare anche i casi in cui listruzione una BNQ o una BNE;
Vediamo quali azioni dei vari stadi sono caratteristiche dellorganizzazione della pipeline. Nello stadio IF, oltre a reperire listruzione e calcolare il nuovo valore di PC, memorizziamo tale nuovo valore sia in PC sia in un registro di pipeline (NPC) per poterlo usare eventualmente in seguito per il calcolo dellindirizzo di destinazione di un salto. Nello stadio ID reperiamo i registri, estendiamo il segno dei 16 bit meno significativi di IR e trasferiamo allo stadio successivo i valori di IR e NPC. Nello stadio EX eseguiamo unoperazione nella ALU oppure calcoliamo un indirizzo, trasferendo allo stadio successivo il contenuto dei registri IR e B (se si tratta di unistruzione store); inoltre, se listruzione una diramazione e il salto viene effettuato, poniamo uguale a 1 il valore di cond. Nello stadio MEM eseguiamo le azioni riguardanti la memoria, se richiesto scriviamo il registro PC e trasferiamo allo stadio finale i valori che sono ad esso necessari. Infine, nello stadio WB aggiorniamo lopportuno registro, in base al valore calcolato dalla ALU o letto dallistruzione load. Per semplicit trasferiamo sempre lintero IR da uno stadio allaltro, anche se, al procedere dellistruzione allinterno della pipeline, necessaria una porzione sempre pi piccola di tale informazione. Bisogna tener sempre presente che ogni stadio sempre operativo per unistruzione diversa, per cui le operazioni avvengono in contemporanea, per c una tempistica che evita la sovrascrittura dei registri.
Pagina 27
A.A. 2009/2010
Ricapitolando, si visto come questo processore cos strutturato pu eseguire pi istruzioni contemporaneamente e come, quindi, alcune risorse devono essere replicate; idealmente si avr lesecuzione di unistruzione in un numero di fasi costante ma in realt questo non sar vero perch alcune istruzioni o saranno avviate inutilmente oppure dovranno essere bloccate in attesa di un informazione che deve essere prodotta dalle istruzioni precedenti. Si parla quindi di ALEE del processore che possono essere: ALEE DI DATO: unistruzione viene bloccata perch aspetta la disponibilit di un dato. ALEE STRUTTURALI: unistruzione viene bloccata perch aspetta la disponibilit dei componenti del processore. ALEE DI CONTROLLO: unistruzione viene bloccata perch aspetta la modifica del PC, in casi diramazione o salti
Pagina 28
BREVE CENNO SULLE
A.A. 2009/2010
MEMORIE DEL PROCESSORE (CACHE DI 1LIVELLO ) ACCESSO ALLA MEMORIA
Nel processore ci sono due memorie cache di 1 livello distinte perch si ha bisogno di ununit su cui scrivere e leggere le istruzioni e ununit su cui scrivere e leggere i dati; devono essere distinte per evitare un alea strutturale gravissima, che comporterebbe uno spreco di colpi di clock. Questo idea di organizzazione definita come architettura Harvard. Successivamente affronteremo la trattazione della memoria; ora ci soffermiamo su un singolo aspetto che quello dellACCESSO ALLA MEMORIA. La memoria pensata in questa maniera:
PORTA INDIRIZZO
PORTA DATI
PORTA DINGRESSO
PORTA DI USCITA
LOAD: Viene inviato un indirizzo alla porta indirizzo fatto da un certo numero di bit e allinterno individuer una parola, fra 2 parole, che uscir fuori dalla porta dati. STORE: Viene inviato un indirizzo e un dato alla porta dingresso, lindirizzo individuer la locazione su cui andr a scrivere il dato. Un requisito della memoria la profondit di parola: cio la parola in uscita avr una certa quantit di byte che sar un potenza di 2 (per esempio 32 o 64 bit). Supponiamo che i dati siano di 4 byte (32 bit), focalizziamo lattenzione sul seguente tipo di accesso alla memoria: ACCESSO ALLINEATO: i 4 byte verranno scritti/letti in posizioni che sono rigidamente fisse, in questa maniera:
0 3 4 7 8 11
Se si vuole leggere una parola che parte ad esempio dal byte 2 al byte 5 non possibile farlo. Quindi lindirizzo che la memoria riceve e che poi conterr il dato che mander in uscita multiplo dellunit su cui allineata la memoria. Ad esempio se allineata a 4 byte lindirizzo sar multiplo di 4. Quindi non possibile accedere in maniera casuale. Questo tipo di accesso semplifica notevolmente la gestione del lavoro e della circuiteria interna della memoria. Si parla di allineamento 4 byte intendendo che un indirizzo avr gli ultimi due bit nulli: 16 bit punteranno ad una riga altri 16 ad una colonna; la cella di memoria corrispondente potr andare in uscita o ricevere un dato. Bisogna comunque garantire che se per errore si dovesse accedere ad un dato che non allineato, in qualche modo bisogner saperlo leggere.
Pagina 29

Ad esempio si supponga la seguente situazione di LOAD:
12 14 16
A.A. 2009/2010
L O C U
4 byte 4 byte
La parola LOCU non potr essere letta perch lindirizzo non avr gli ultimi due bit uguali a zero, ma solo lultimo. Per leggere la parola devo: 1. LOAD dei primi 4 byte; 2. LOAD dei successivi 4 byte; 3. SHIFT di 16 bit dei primi 4 byte; 4. SHIFT di 16 bit dei successivi 4 byte; 5. operazione di OR per ottenere la parola LOCU.
Si supponga ora la seguente situazione di STORE: Si vuole scrivere la parola LOCU a partire dallindirizzo 15; non si deve per andare a modificare il contenuto degli altri indirizzi.
12 13 14 15 16 17 18 19
O C
U h
4 byte
4 byte
Per scrivere devo: 1. LOAD dei primi 4 byte, quindi a partire dallindirizzo 12; 2. LOAD dei successivi 4 byte, quindi a partire dallindirizzo 16; 3. STORE a partire dallindirizzo 12, dei 4 byte modificati; 4. STORE a partire dallindirizzo 16, dei successivi 4 byte modificati.
Pagina 30

ALEE STRUTTURALI ALEE DI DATO
A.A. 2009/2010
Abbiamo visto, con il concetto di ALEE STRUTTURALI e ALEE DI DATO, che in realt il processore stesso ha comportamenti che lo allontanano da quelli ideali.
ALEE STRUTTURALE: unistruzione viene bloccata perch aspetta la disponibilit dei componenti del processore. Si osservi la figura qui accanto; nel caso il processore non abbia una memoria separata per le istruzioni e per i dati si incorre in un blocco strutturale poich listruzione 3 non pu utilizzare il componente memoria; quindi questa istruzione, cos come tutte quelle seguenti, verr ritardata di un colpo di clock. La soluzione a questo tipo di problema lutilizzo di unarchitettura Harvard.
ALEE DI DATO: unistruzione viene bloccata perch aspetta la disponibilit di un dato. Esistono conflitti di dati che teoricamente possono essere di quattro tipi: 1. READ AFTER WRITE (RAW): generato da dipendenze di dato tra istruzioni sequenziali vicine, cio unistruzione tenta di leggere un registro prima che sia stato scritto; nel processore intero, grazie alla corto circuitazione dellALU questo problema non esiste a meno del caso delle istruzioni di load. Nellaritmetica floating point questo conflitto molto rilevante.
DADD R0, R1, R2; DSUB R2, R0, R3; // Write R0 // Read R0
2. WRITE AFTER WRITE (WAW): si ha quando il valore di un registro viene aggiornato prima dall'istruzione pi recente e poi da quella meno recente. Quindi, la seconda scrittura va persa. In un processore di tipo intero questo problema non esiste perch quando unistruzione nella fase di WB tutte le istruzioni precedenti sono terminate, ed essendo terminate hanno gi fatto la fase di WB. Nellaritmetica floating point questo conflitto molto rilevante.
DADD R1, R0, R2; . . . DSUB R1, R2, R3; // Write R1 // Write R1
3. WRITE AFTER READ (WAR): unistruzione tenta di scrivere un registro prima che sia stato letto; nel processore intero questo problema non esiste perch quando listruzione nella fase di WB tutte le altre saranno terminate e quindi tutto proceder correttamente. Nellaritmetica floating point questo conflitto molto rilevante.
DADD R0, R1, R2; DSUB R1, R2, R3 // Read R1 // Write R1
Pagina 31
A.A. 2009/2010
4. READ AFTER READ (RAR): non una dipendenza. possibile anche invertire lordine di esecuzione. Di seguito sono riportati tre casi in base alle istruzioni schedulate. 1. ISTRUZIONI ALU: si osservi la figura qui accanto; il registro destinazione (R1) della prima istruzione (DADD) un registro sorgente per la seconda istruzione (DSUB) ma anche per la terza istruzione (AND). R1 ospiter effettivamente la somma fra R2 e R3 nel quinto colpo di clock; essendo il programma eseguito in pipeline, la seconda istruzione porter nel quarto colpo di clock in ingresso allALU dei bit che non avranno nessun significato. Lo stesso vale per le altre istruzioni; solo lultima istruzione effettuer regolarmente la sua operazione, poich sar stata effettuata la Write Back. Verr analizzata ora una tecnica per evitare questo tipo di blocco: si consideri la quarta istruzione che parte tre colpi di clock dopo la prima istruzione: R1 viene scritto nel quinto colpo di clock (fase di WB). In questa fase per listruzione OR, R1 verr preso messo nel registro A; bisogner capire se R1 che andr a scrivere in A quello che stato scritto dalla fase di WB. Poich prima avvengono le letture e poi le scritture, in realt non avr leffettivo valore di R1. Si esamini la profondit della pipeline al quinto colpo di clock , e le fasi che la costituiscono: tutte le fasi dureranno quanto la fase pi lenta, che quella di accesso alla memoria. La fase di WB estremamente veloce (legge ALUOutput oppure LMD e scrive in un registro); bisogner comunque eseguire WB in un tempo che comunque legato alla durata della fase pi lenta: per cui se viene garantita una tempistica che esegue la fase WB nella prima met del colpo di clock e la fase di carica dei coefficienti A e B nella seconda met, listruzione non dar nessun problema di esecuzione.
Pagina 32
A.A. 2009/2010
Risolta lalea con la quarta istruzione schedulata, vediamo come risolvere il problema legato alle istruzioni schedulate nel secondo e terzo colpo di clock. In realt per la seconda istruzione non serve che il risultato della somma fra R2 e R3 venga letto direttamente dal registro R1, cio interessa sottrarre a R5 la somma precedente che sar possibile trovare in EX/MEM.ALUOutput. Stesso discorso vale per la terza istruzione: il valore della somma lo trover in MEM/WB.ALUOutput.
Utilizzando questo metodo il processore cambia la sua struttura, dove in ingresso ai MUX, che decidono quale segnale mandare allALU, non si hanno soltanto i registri A e B oppure IMM ma si ha la possibilit di ricevere EX/MEM.ALUOutput oppure anche MEM/WB.ALUOutput. In questo modo non si avranno perdite di colpi di clock e quindi nessun blocco distruzioni. La Control Unit sar un po pi complessa perch dovr controllare i MUX e questo viene fatto attraverso una logica che si basa sui comparatori, il cui compito quello di confrontare i registri. Sono presenti due comparatori per ogni MUX. Nel caso listruzione a un colpo di clock dopo, allingresso del comparatore si ha: 1. il campo *rs+ dellIR dellistruzione che sta in fase di EX; 2. il campo *rd+ dellIR dellistruzione che sta in fase di MEM. Quindi il MUX, allingresso dellALU, far passare EX/MEM.ALUOutput se sono uguali i valori ed verificato il codice operativo. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 33

Nel caso listruzione a due colpi di clock dopo, allingresso del comparatore si ha: 1. il campo *rs+ dellIR dellistruzione che sta in fase di EX; 2. il campo *rd+ dellIR dellistruzione che sta in fase di WB.
A.A. 2009/2010
Quindi il MUX, allingresso dellALU, far passare MEM/WB.ALUOutput se sono uguali i valori ed verificato il codice operativo. Identico discorso vale per il secondo MUX a patto che si consideri il campo rt dellIR e non rs. Se entrambi i comparatori verificano luguaglianza dovr essere dato in ingresso allALU il risultato della seconda operazione, cio quella che ancora fra EX/MEM e quindi il primo caso. Allinterno di questa logica vi anche una rete combinatoria che effettua il test sul codice operativo; questo perch il risultato della comparazione interessante solo se si sta considerando unistruzione ALU in cui i bit che si riferiscono al campo rd sono proprio i bit destinatari del risultato delloperazione ALU. Luscita di questa rete combinatoria di test in AND con il comparatore per verificare se considerare o meno il risultato del comparatore.
Pagina 34

LD R1,0(R2) DSUB R4,R1,R5 AND R6,R1,R7
A.A. 2009/2010
2. ISTRUZIONI LOAD: si osservi ora il caso in cui un registro destinazione di unoperazione di tipo LOAD.
Essendo R1 risultato di unoperazione di LOAD il valore (che andr in R1) sar noto solo dopo la fase di MEM quindi sar presente nel latch MEM/WB.LMD; dal punto di vista temporale questa operazione avviene successivamente rispetto a quando la seconda istruzione si trova nella fase di EX; in questo caso il processore andr in stallo fermando cos tutte le istruzioni successive che richiederanno quel dato. (ved. fig. sotto). Invece se listruzione schedulata due colpi di clock dopo, e in ingresso allALU si vuole il valore di R1, si andr a prendere questo valore da MEM/WB.LMD; questo il terzo ingresso retro azionato che arriva al MUX. Occorrer un altro comparatore (per ogni MUX) che prender il registro sorgente dellistruzione corrente ID/EX.IR*rs+ e lo confronter con il registro destinazione dellistruzione due colpi di clock prima MEM/WB.IR*rd+. Il risultato sar messo in AND con il segnale duscita del circuito combinatorio che effettuer il test su MEM/WB.IR[opcode]. Se si verificano i controlli in ingresso allALU andr MEM/WB.LMD.
possibile evitare lo stallo organizzando, a livello del compilatore, il codice del programma in maniera tale da non avere mai dopo una load unistruzione che vuole come sorgente il destinazione dellistruzione di load. Questa altre tecniche software aiutano il compilatore; dal punto di vista hardware non ci sono soluzioni.
Pagina 35
A.A. 2009/2010
3. ISTRUZIONE BRANCH: se la condizione di salto si verifica (al termine della fase EX) le istruzioni che erano state avviate, poich successive a quella di salto, devono essere abortite per poter proseguire con listruzione ove si saltati. Questo significa che si perderanno dei colpi di clock non per situazioni di stallo ma per aver eseguito istruzioni inutilmente; bisogner cercare di ridurre al minimo questi colpi di clock sprecati. Solo alla quarta istruzione si conoscer il valore del salto da effettuare e quindi pu essere effettuata la fase di IF con il PC corretto. Questo significa che saranno stati persi tre colpi di clock, cio unistruzione di salto come se durasse quattro istruzioni. possibile con una tecnica hardware ridurre i colpi di clock persi; loperazione di calcolo dellindirizzo in cui saltare effettuato nella fase di EX poich li presente lALU. Per si pu accelerare questa operazione pensando di effettuare questo calcolo nella fase ID, perch in fondo per il calcolo serve lo spiazzamento e il PC, dati che in questa fase sono noti. Per effettuare il calcolo non bisogna dimenticare che necessaria lALU, la quale utilizzata da unaltra istruzione; per effettivamente non necessaria unaltra ALU ma un semplice sommatore. Quindi si inserisce un sommatore aggiuntivo nella fase ID che prende limmediato esteso in segno, prende il PC e li somma; se la condizione verificata IF/ID.PC verr aggiornato al valore calcolato. Il processore sar cos modificato in questi termini:
Con questa tecnica si avr la perdita di un colpo di clock invece di due (non considerando listruzione di branch).
Pagina 36

MIPS PIPELINE OTTIMIZZATO
A.A. 2009/2010
Pagina 37
A.A. 2009/2010
DELAY SLOT TECNICA STATICA Si visto come possibile, aggiungendo un sommatore nella fase ID, conoscere se dove saltare gi alla seconda fase dellesecuzione dellistruzione di salto; quindi nel momento in cui listruzione di salto si trova nella terza fase verr caricata nella fase IF listruzione con il PC aggiornato, questo significa che dal momento in cui stata caricata listruzione di salto al momento in cui viene caricata listruzione a cui si saltati, stata caricata unistruzione puntata da PC+4 (quindi non listruzione a cui si doveva saltare); questo significa aver perso un colpo di clock, definito DELAY SLOT; il delay slot quindi il ritardo che si compie nellesecuzione di un programma, ritardo sotto forma di stalli e quindi colpi di clock persi. Questo ritardo deve essere ottimizzato nel modo migliore; le tecniche usate sono le seguenti: PRIMO CASO Si osservi questa situazione: vi unistruzione di salto che controlla luguaglianza a zero di R2 ed effettua un salto ad una certa istruzione. Per ottimizzare il clock perso il compilatore prende unistruzione indipendente proveniente dalla parte di codice precedente il salto e la mette subito dopo listruzione di salto. Quindi viene schedulata unistruzione che va comunque eseguita (DADD R1,R2,R3); il compilatore codifica con un particolare codice operativo listruzione schedulata per far si che anche se la condizione di salto si dovesse verificare deve essere comunque portata a termine. SECONDO CASO Si osservi questa situazione: vi unistruzione di salto che controlla luguaglianza a zero di R1 che destinazione dellistruzione precedente. Questa situazione rende impossibile lo spostamento dellistruzione DADD R1,R2,R3 nel delay slot; quindi questo viene riempito con listruzione destinazione del salto. Si noti che listruzione deve essere copiata e non spostata per rendere possibile la prima iterazione; se il salto si verifica, listruzione, che adesso si trova immediatamente dopo quella di salto, deve essere portata a termine. Questa strategia usata quando il salto ha una probabilit di venire eseguito, come nel salto allinterno di un ciclo. Se la condizione non si verifica listruzione immediatamente dopo il salto deve essere abortita con conseguente perdita di un colpo di clock.
Pagina 38

TERZO CASO
A.A. 2009/2010
Si osservi questa situazione in cui il salto non si verifica spesso, ad esempio il caso del confronto; il codice viene riorganizzato utilizzando istruzioni provenienti dalla sequenza relativa al caso di non esecuzione del salto. Perch lottimizzazione mostrata sia accettabile bisogna che si possa eseguire listruzione OR R7,R8,R9 quando il salto si comporta nel modo non previsto. Per accettabile si intende che il lavoro fatto divenga s inutile, ma che il programma sia eseguito correttamente. Questo succede, ad esempio, se R7 un registro temporaneo non utilizzato quando il salto si comporta nel modo non previsto. Se la condizione si verifica listruzione immediatamente dopo il salto deve essere abortita. TECNICA SPECULATIVA TECNICA DINAMICA Vediamo ora una tecnica speculativa, definita previsione speculativa di salto, che cerca di indovinare mentre si effettua il fetch di unistruzione di salto qual listruzione da eseguire immediatamente dopo, al successivo colpo di clock, senza avere stalli e quindi sprechi di colpi di clock. Essendo una tecnica speculativa la control unit deve basarsi solamente su informazioni che conosce nella fase IF, cio solo il Program Counter. Con questo PC la CU va a leggere la seguente tabella: essa contiene, in una data riga (idealmente corrispondente al valore del PC), il valore dellindirizzo destinazione dellistruzione di salto, che in precedenza si era andati ad eseguire, altrimenti se la prima volta che si accede alla tabella con un dato PC, questa verr aggiornata e quindi non sar possibile effettuare la predizione. La CU quindi invece di far aggiornare il PC con il valore PC+4, scriver in PC il valore corrispondente alla colonna Predicted PC, cio il valore dellindirizzo destinazione dellistruzione di salto, cio lindirizzo a cui si era saltati lultima volta che si era trovata listruzione di salto. Per fare questo per non possibile avere una tabella che contenga tante righe quanti sono i valori possibili del PC; per cui questa tabella costituita da un numero predefinito di righe che sono indirizzate dai 7 bit meno significativi del PC. Per evitare errori di accesso a PC errati questa tabella contiene, nella colonna Look up, i 25 bit pi significativi che costituiscono il PC (lultimo che ha fatto accesso alla tabella); in questa maniera possibile verificare se linformazione cercata si riferisce al PC che ne fa richiesta. Se i PC coincidono si dovrebbe prelevare il Predicted PC corrispondente e andarlo a mettere in PC; per prima ancora di effettuare il prelievo bisogna controllare lultima colonna che contiene un bit di controllo, il quali conferma se lultima volta si effettuato il salto oppure no.
Pagina 39
A.A. 2009/2010
PRESTAZIONI: caso di un loop nel quale si ha un certo numero di istruzioni e unistruzione di salto; la prima volta che si trova listruzione di salto non si ha a disposizione nessuna statistica nella tabella. Quindi nel momento in cui si verifica la condizione verr aggiornata la tabella con lindirizzo destinazione del salto e verr modificato il bit di controllo (posto a 1). La prima volta sar stato eseguito il fetch di unistruzione successiva a quella di salto, che poi sar abortita nel caso il salto si dovesse verificare. Il resto del loop procede correttamente, poich ora la tabella aggiornata e quindi non vi perdita di nessun colpo di clock per attendere il calcolo della destinazione del salto; al momento dellultima iterazione, quando il salto non si verifica, la tabella dar ancora in uscita lindirizzo destinazione del salto e quindi nel PC verr caricato automaticamente il Predicted PC; poi per listruzione verr abortita perch non si verificher la condizione, per cui vi una perdita di un colpo di clock. Quindi con questa tecnica si ha, con N iterazioni, un errore alla prima iterazione, N-1 iterazioni corrette e un altro errore allultima iterazione. Nel caso si ritorni allo stesso loop, accedendo alla tabella si avr il bit a zero nellultima colonna e quindi si scommetter che il salto non si dovr effettuare commettendo cos un errore mandando in fetch unistruzione che poi dovr essere abortita; la tabella dovr essere aggiornata commettendo cos sempre lerrore allultima iterazione; quindi in totale in questa situazione si perdono comunque due colpi di clock. Questa situazione pu essere descritta dal seguente diagramma a stati:
ESEGUITO ESEGUITO
0
NON ESEGUITO
NON ESEGUITO
STATO 0: salto non verificato STATO 1: salto verificato
Quando si nello stato 0 vorr dire che il salto non dovr essere effettuato; se effettivamente la condizione non si verifica si rimane nello stato 0, altrimenti si passa nello stato 1, in cui vale in maniera duale lo stesso discorso. possibile migliorare questa tecnica se si considera anche la storia passata e non solo quello che successo lultima volta; in questa maniera possibile costruire una macchina a quattro stati, cio questo significa avere nellultima colonna della tabella due bit di controllo anzich uno. La seguente figura mostra la macchina a stati che permette di considerare la storia passata.
STATO 00: certezza assoluta di salto non verificato STATO 01: predizione di salto non verificato STATO 10: predizione di salto verificato STATO 11: certezza assoluta di salto verificato
Quando si nello stato 11 vorr dire che il salto dovr essere effettuato; se effettivamente il salto si verifica si rimane sempre nello stesso stato, altrimenti si va nello stato 10, in cui si predice comunque la verifica del salto in base al fatto che le ultime volte il salto si era verificato; quando si in questo stato se effettivamente il salto non si verifica bisogner passare nello stato 00, altrimenti si ritorna nello stato 11. Quando si nello stato 00 vorr dire che il salto non dovr essere effettuato, e vale in maniera duale lo stesso discorso.
Pagina 40
A.A. 2009/2010
Quindi utilizzando due bit anzich uno, un salto condizionato che privilegia la sua esecuzione o la sua nonesecuzione (come accade molto frequentemente) sar soggetto di una previsione errata solamente una volta. I due bit saranno utilizzati per codificare i quattro stati del sistema. Vediamo come a livello del compilatore possibile migliorare lesecuzione dei programmi. Esistono due tecniche di ottimizzazione: srotolamento del loop e pipeline da programma. SROTOLAMENTO DEL LOOP Questa tecnica punta a ridurre le istruzioni non indispensabili durante lesecuzione del loop in modo da rendere il programma pi veloce. Prima di vedere dettagliatamente come funziona questa tecnica, per comprenderla meglio si consideri il seguente codice che implementa un loop per sommare gli elementi di due vettori:
DADDI R6,R0,N LD R4,R1(0) LD R5,R2(0) stallo DADD R4,R4,R5 SD R3(0),R4 DADDI R1,R1,#8 DADDI R2,R2,#8 DADDI R3,R3,#8 DADDI R6,R6,#-1 stallo BNEZ R6,-9 stallo
Istruzioni necessarie
R1 punta al vettore A R2 punta al vettore B R3 punta al vettore C
C[i] = A[i] + B[i]
Istruzioni di gestione
Questo programma dovrebbe durare (9 ) + 1 colpi di clock; ma poich ci sono colpi di clock persi a causa di alcuni stalli provocati da: istruzione di load che ha come destinazione R5 che sorgente dellistruzione successiva; istruzione di controllo su R6 che non ancora disponibile; istruzione BNEZ; il programma dura (12 ) + 1 colpi di clock. Per eliminare i colpi di clock persi possibile spostare istruzioni indipendenti nelle zone del codice che comportano degli stalli, ottenendo cos il seguente codice con (9 ) + 1 colpi di clock:
DADDI R6,R0,N LD R4,R1(0) LD R5,R2(0) stallo DADD R4,R4,R5 SD R3(0),R4 DADDI R1,R1,#8 DADDI R2,R2,#8 DADDI R3,R3,#8 DADDI R6,R6,#-1 stallo BNEZ R6,-9 stallo DADDI R6,R0,N LD R4,R1(0) LD R5,R2(0)
DIVENTA
DADDI R1,R1,#8 DADD R4,R4,R5 SD R3(0),R4 DADDI R6,R6,#-1 DADDI R2,R2,#8 BNEZ R6,-8 DADDI R3,R3,#8
Pagina 41
A.A. 2009/2010
Si noti, comunque, che oltre alle quattro istruzioni necessarie se ne trovano sempre cinque per gestire il loop; allora bisogna cercare di semplificare il loop eliminando quelle istruzioni non indispensabili. possibile pensare di codificare lindirizzi degli elementi di A, B e C in maniera tale che siano espressi in una forma caratterizzata da un certo immediato e un certo registro (che far da spiazzamento). Si noti che le due load e la store sono legate tra di loro dal fatto che tutte e tre le operazioni punteranno sempre ad un identico elemento del vettore (ad esempio: salvo nel quarto di C la somma fra il quarto di A con il quarto di B); quindi possibile pensare di avere un unico registro che permetter di indirizzare il generico i-esimo elemento di un vettore. Quindi lindirizzo delle load e della store espresso in questi termini: limmediato sar lindirizzo del primo elemento del rispettivo vettore, mentre il registro far da indice per gli elementi. Gestendo gli indirizzi in questo modo, da tre comandi per gestire laccesso ai tre dati se ne avr soltanto uno, bisogner lavorare solo su di un registro. Per cui supponendo per esempio che il primo valore di A allindirizzo 1000, il primo di B allindirizzo 2000 e il primo di C allindirizzo 3000 possibile avere il seguente codice:
DADDI R1,R0,N DADDI R1,R1,#-1 DMULI R1,R1,#8 LD R2,R1(1000) LD R3,R1(2000) DADDI R1,R1,#-8 DADD R2,R2,R3 BNEZ R1,-6 SD (3008)R1,R2 //3008 perch R1 stato decrementato
In questa maniera ho per fare quattro istruzioni di calcolo, necessarie, due di gestione; per cui un overhead del 50%. A questo punto per diminuire questo overhead si pu utilizzare la tecnica dello srotolamento del loop. Questa tecnica attua due stratagemmi per raggiungere il suo obiettivo: 1. Ridurre le istruzione di gestione del loop; 2. Mettere a disposizione un numero maggiore distruzioni effettive di calcolo per avere pi opportunit di trovare le istruzioni da inserire al posto degli stalli. Srotolare il loop significa prendere il codice e ricopiarlo per ottenere unaltra iterazione; in realt non si ricopia interamente il loop ma solamente le istruzioni necessarie, quelle di calcolo e utilizzando altri registri per effettuare le operazioni di load e di add. Quindi il loop dellesempio precedente srotolato e ottimizzato il seguente:
LD R2,R1(1000) LD R3,R1(2000) LD R5,R1(992) LD R6,R1(1992) DADD R2,R2,R3 DADD R5,R5,R6 SD (3000)R1,R2 SD (2992)R1,R5 DADDI R1,R1,#-16 BNEZ R1,-10 //utilizzo un altro registro //utilizzo un altro registro
Pagina 42
A.A. 2009/2010
Srotolato il loop ci si ritrova parecchio codice, che pu essere riorganizzato in maniera tale da gestire gli eventuali stalli che si vengono a creare. Come si pu notare questa tecnica ha lo svantaggio di incrementare luso dei registri e del codice. intuibile considerare un numero di registri che sia un sottomultiplo della dimensione del vettore, in modo tale da srotolare il loop senza lasciare residui del vettore. Se non si fa questa considerazione, facile notare che alla fine del loop si processeranno indirizzi di memoria che non sono parte del vettore. PIPELINE DA PROGRAMMA Consideriamo sempre lesempio precedente, la somma tra vettori, per con dati floating point; si consideri per vera questa sintassi:
L.D A(i) L.D B(i) ADD.D C(i),A(i),B(i) S.D C(i)
La pipeline da programma parte dalla seguente osservazione: poich non possibile effettuare subito ADD.D (non si ha ancora a disposizione i dati sorgenti), e poi S.D, allora si effettua la somma dei dati di cui si fatta la load alliterazione precedente; quindi saranno passati diversi colpi di clock, tanti quanti ne sono necessari per avere a disposizioni i valori nei registri. Stesso discorso per la store, andando a salvare il risultato delliterazione ancora precedente a quella che ADD sta gestendo. In questa maniera evito lo spreco dei colpi di clock. Chiarita lidea di funzionamento, vediamo ora come la si implementa modificando il codice in questa maniera:
L.D A(i+2) L.D B(i+2) ADD.D C(i+1),A(i+1),B(i+1) S.D C(i)
Il codice modificato in maniera tale che quando si sta facendo la store delliterazione i-esima si sta memorizzando in memoria il risultato che ADD.D aveva calcolato alliterazione precedente, quindi alliterazione i-1 ADD.D calcola A(i)+B(i) e alliterazione i-esima C(i) viene scritto in memoria. Per chiarire meglio vediamo un esempio: iterazione i = 9; L.D A(9+2=11); L.D B(9+2=11); iterazione i = 10; ADD.D C(10+1=11),A(10+1=11),B(10+1=11); con A e B dati che sono stati caricati nelliterazione precedente i = 9; iterazione i = 11; S.D C(11); calcolato nelliterazione precedente i = 10; Quindi un loop dovr essere fatto per N-2 iterazioni (0N-3). Vediamo ora cosa succede alla prima e allultima iterazione del loop: PRIMA ITERAZIONE: al momento della store si scriver in memoria qualcosa che non sar stato ancora calcolato; CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 43 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
ULTIMA ITERAZIONE: al momento delle load si caricheranno dati che non verranno mai processati. Allora necessario strutturare questa pipeline con un transitorio di riempimento e un transitorio di svuotamento; cio il programma visto come un tubo in cui entrano le istruzioni di iterazioni differenti, in cui vi un transitorio di caricamento nel quale si ha:
L.D A(0) L.D B(0) L.D A(1) L.D B(1) ADD.D C(0),A(0),B(0)
Dopo questo transitorio parte il loop effettivo dove i vale zero e quindi:
L.D A(2) L.D B(2) ADD.D C(1),A(1),B(1) S.D C(0)
Quando si arriva a N-3 sar stata fatta lultima store C(N-3), sar stata calcolata C(N-2) e saranno fatte le ultime load A(N-1) e B(N-1); per cui dopo il loop si dovr fare un transitorio di svuotamento nel quale si ha:
ADD.D C(N-1),A(N-1),B(N-1) S.D C(N-2) S.D C(N-1)
Dove questo transitorio di svuotamento completa il transitorio di caricamento. In tutto vengono fatte le operazioni legate a due cicli, quelli che da 0 a N-3 cicli del loop + due dei transitori portano effettivamente ad aver lavorato da 0 a N-1, cio per N elementi del vettore. Con la pipeline da programma si risolve il problema degli stalli tra unistruzione ed un'altra. Il vantaggio di questa tecnica che continua a tenere impegnati quei registri che si avevano nel caso di loop normale, mentre lo svantaggio rispetto alla srotolamento che non diminuiscono le istruzioni di controllo. Il compilatore utilizzer la tecnica dello srotolamento quando il codice contiene un numero distruzioni di controllo che proporzionalmente rilevante, altrimenti utilizzer la tecnica del pipeline da programma; per cui la scelta della tecnica risulta forzata e dipendente dal numero di istruzioni che costituiscono il codice, o meglio dal numero di istruzioni di calcolo e di controllo che costituiscono il programma.
Pagina 44

ESERCIZI DI RIEPILOGO
ESERCIZIO 1 Scrivere le microfasi della seguente istruzione: S.D 1200(R3), F4 per un MIPS ad architettura pipeline con bus a 32 bit;
A.A. 2009/2010
In pratica questo esercizio richiede come pu essere effettuato il trasferimento di 64 bit (store di un double), con il minor numero di stalli, in cui vi il vincolo della memoria con un bus a 32 bit. chiaro che se si vuole scrivere in memoria 64 bit, mentre ne posso scrivere soltanto 32 bit alla volta, bisogner pensare unistruzione che avr al suo interno due fasi MEM. Listruzione S.D 1200(R3),F4 equivale allistruzione: F4##F5 64 M[1200+R3] Cio:
F4 M[1200+R3] F5 M[1204+R3]
Le fasi IF e ID sono le seguenti: FASE IF

IF/ID.IR Mem[PC] IF/ID.NPC PC + 4
FASE ID
ID/EX.A Regs[IF/ID.IR[rs]] ID/EX.B Regs[IF/ID.IR[rt]] ID/EX.IR IF/ID.IR ID/EX.NPC IF/ID.NPC ID/EX.Imm sign-extend(IF/ID.IR[immediate field]) PC MM[IF/ID.IR[opcode]]
Lultima istruzione permette di effettuare la decodifica dellistruzione; vengono letti i bit del codice operativo come un indirizzo per accedere alla MAPPING MEMORY (MM), nella quale per quel particolare codice operativo si trover un nuovo indirizzo di una micro memoria che alla base dellesecuzione della logica supervisionata dalla control unit. Fin qui non ci sono problemi, poich queste due fasi sono sempre condotte alla stessa maniera per tutte le istruzioni; al termine del decode si conosce listruzione e quindi si intraprendono le operazioni specifiche da eseguire. Vediamo due soluzioni: la prima effettua due fasi EX e due fasi MEM per eseguire listruzione, quindi la si pu ipotizzare come due istruzioni di store distinte, mentre la seconda soluzione cerca di avere una fase EX e due fasi MEM, di cui una incorpora una fase EX per il calcolo dellindirizzo successivo.
Pagina 45

PRIMA SOLUZIONE FASE EXE1
EX/MEM.ALUOUTPUT ID/EX.A + ID/EX.Imm EX/MEM.B ID/EX.B
A.A. 2009/2010
FASE MEM1
Mem[EX/MEM.ALUOUTPUT] EX/MEM.B
FASE EXE2
EX/MEM.ALUOUTPUT EX/MEM.ALUOUTPUT + 4 EX/MEM.B ID/EX.IR[rt+1] //con rt + 1 accedo a F5 (a livello concettuale)
FASE MEM2
Mem[EX/MEM.ALUOUTPUT] EX/MEM.B
Si noti che questo microprogramma, prevedendo 6 fasi, non presenta alcun vantaggio, in termini di prestazioni, rispetto all'esecuzione di 2 distinte istruzioni di store. Senza dire che la fase EXE2 e MEM2 potrebbero causare stalli alle istruzioni successive che nella pipeline competerebbero con questa per l'uso dellALU e della Memoria. SECONDA SOLUZIONE Volendo migliorare le prestazioni, si pu prevedere una duplicazione del EX/MEM.ALUOUTPUT (un secondo registro EX/MEM.ALUOUTPUT2 per referenziare la seconda met della doppia parola) ed una sua strutturazione auto incrementante per svincolare l'ALU. Quindi si pu pensare che la fase EXE2 pu avvenire contemporaneamente alla fase MEM1; questo possibile perch in un primo istante si legge EX/MEM.ALUOUTPUT e poi in un secondo istante, dopo che laccesso a memoria stato eseguito, lo si aggiorna. Lo stesso per EX/MEM.B, il quale viene in un primo momento trasferito in memoria e poi riceve ID/EX.IR[rt+1] In tal caso si avrebbe: FASE EXE1
EX/MEM.ALUOUTPUT ID/EX.A + ID/EX.Imm EX/MEM.B ID/EX.B
FASE MEM1 (comprende anche la fase EXE2)

Mem[EX/MEM.ALUOUTPUT] EX/MEM.B EX/MEM.ALUOUTPUT2 EX/MEM.ALUOUTPUT + 4 EX/MEM.B ID/EX.IR[rt+1]
1* SEMICICLO 2* SEMICICLO
FASE MEM2
Mem[EX/MEM.ALUOUTPUT2] EX/MEM.B
Pagina 46
A.A. 2009/2010
Con questa scrittura, questa istruzione prevedrebbe 5 fasi, sebbene la presenza di MEM2 causerebbe uno stallo alle istruzioni successive, qualora l'istruzione I immediatamente seguente ad essa faccia effettivamente riferimento a memoria durante la sua fase MEM: (SD): IF (I): ID IF EX ID MEM1 MEM2 EXE Stallo MEM WB
Quindi se listruzione I una istruzione di load o di store ci sar uno stallo al momento della sua fase MEM. Si noti per che nel primo semiciclo della fase MEM1 oltre ad accedere alla memoria, si sta utilizzando lALU per calcolare il nuovo indirizzo; per cui listruzione I avrebbe anche la sua fase EXE in stallo. Per cui lo stallo andrebbe messo prima della fase EXE, quindi non si avr poi lo stallo per la fase MEM, cio la situazione diventerebbe la seguente: (SD): IF (I): ID IF EX ID MEM1 MEM2 Stallo EXE MEM WB
Nel secondo caso lo stallo si avrebbe sempre e comunque, perch tutte le istruzioni fanno uso dellALU; mentre nel primo caso, con un opportuna modifica, lo stallo si avrebbe solo se listruzione I effettivamente fa riferimento alla memoria. Per risolvere il conflitto fra MEM1 e la fase EXE dellistruzione I bisogna pensare di modificare parte dellhardware del processore; poich MEM1, oltre allaccesso alla memoria, non fa altro che una somma per il calcolo dellindirizzo successivo, allora possibile aggiungere un sommatore nella fase MEM, il quale ha il compito di determinare il nuovo indirizzo in modo tale che non venga occupata e utilizzata lALU. Il processore eseguir cos in parallelo la fase MEM1 e la fase EXE2; la modifica da apportare e quindi la seguente:
EX/MEM.ALUOUTPUT va in ingresso alla Data memory e ad un sommatore predisposto per calcolare il secondo indirizzo; questultimo dovr essere scritto in EX/MEM.ALUOUTPUT2 e non in EX/MEM.ALUOUTPUT perch usato dallistruzione che in quel momento nella fase EX e che quindi sta usando lALU e il suo risultato andr in EX/MEM.ALUOUTPUT.
Pagina 47
A.A. 2009/2010
Con questa tecnica viene evitato il conflitto fra MEM1 e la EXE dellistruzione I nel caso questa non una load o una store; altrimenti si avr solo uno stallo. Con queste migliorie bisogner leggermente modificare la C.U. e lhardware per gestire il sommatore e il nuovo registro; una soluzione utile nel caso il processore esegue spesso istruzioni di store. ESERCIZIO 2 Relativamente ad una architettura RISC con 5 stadi di pipeline si progetti la circuiteria aggiuntiva da provvedere alla CPU per gestire in una singola istruzione operazioni di accesso ad uno stack di memoria, definendo le micro operazioni da compiere nei 5 stadi della pipeline relativamente allistruzione: POP Rb (Rb registro ricevente il dato prelevato dallo stack). Si preveda il controllo di stack overflow e stack underflow. Bisogna fare delle ipotesi: bisogna considerare se lo stack lavoro con indirizzi crescenti o decrescenti; lindirizzo, che punta allarea di memoria in cui si vuole scrivere o leggere i dati, considerarlo puntatore al primo vuoto oppure allultimo pieno. Innanzitutto bisogna gestire lultima richiesta, cio bisogna controllare le situazioni di overflow e underflow dello stack. Si consideri il seguente modello di stack in cui si hanno tre registri, uno contente lindirizzo di TOP (TS) dello stack, uno contenente lindirizzo di BOTTOM (BS) dello stack e uno contente lindirizzo dello STACK POINTER (SP). Si prevedano inoltre due comparatori che in uscita hanno rispettivamente le seguenti condizioni: Ipotizzando che SP punti alla prima cella vuota dello stack il quale si riempie per indirizzi crescenti si ha:
COND1 che 1 nel caso in cui SP sia maggiore di TS ad indicare loverflow; COND2 che 1 nel caso in cui SP sia uguale a BS ad indicare lunderflow
In queste ipotesi il microcodice diun operazione POP potrebbe essere il seguente: (loperazione POP non una semplice una operazione di load, ma bisogna anche modificare il valore di SP) FASE IF
IF/ID.IR Mem[PC]; IF/ID.NPC PC + 4;
FASE ID
ID/EX.A IF/ID.IR[rs]; ID/EX.B IF/ID.IR[rt]; ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; Pc MM[IF/ID.IR[opcode]];
Pagina 48

FASE EXE
(if (COND2) Pc MM[gestione interrupt stack underflow]); EX/MEM.SP ID/EX.SP - 4;
A.A. 2009/2010
FASE MEM
MEM/WB.LMD Mem[EX/MEM.SP];
FASE WB
Regs[MEM/WB.IR[Rb] MEM/WB.LMD; // con Rb registro ricevente il dato prelevato dallo stack
In una pipeline vista a 5 stadi sembra quindi che il miglior modo di operare con uno stack e quello con SP puntatore al primo vuoto. Questo esercizio richiedeva di analizzare il caso di unistruzione POP; vediamo ora come si complicano le cose nel caso distruzione PUSH. Se SP sempre puntatore al primo vuoto loperazione da effettuare per prima quella di scrittura nello Stack e poi di aggiornamento con incremento di SP; questo significa utilizzare lALU dopo la fase MEM e di conseguenza un peggioramento di prestazioni. Allora pu sembrare non conveniente avere SP puntatore al primo vuoto, ma meglio averlo puntatore allultimo pieno, in maniera tale da incrementare SP e poi accedere alla memoria per scrivere. Per cui bisogna decidere una tecnica che vada bene per un caso e trovare una soluzione per evitare stalli nellaltro caso; questo possibile inserendo, come nellesercizio precedente, un sommatore nella fase MEM che effettui laggiornamento di SP. Bisogna per prestare attenzione, poich stiamo considerando comunque unarchitettura pipeline, ai casi in cui si presentano pi istruzioni PUSH o POP contemporaneamente, ad esempio: 1CASO: istruzione POP seguita da unistruzione POP
prima istr: POP seconda istr: POP
IF ID IF EX ID MEM EX WB MEM WB
Questa situazione non presenta alcun tipo di problema poich nel momento in cui la seconda istruzione effettua la sua fase EX il valore SP sar gi stato aggiornato per cui tutto procede senza problemi. 2CASO: istruzione PUSH seguita da unistruzione PUSH
prima istr: PUSH seconda istr: PUSH
Questa situazione non presenta alcun tipo di problema poich nel momento in cui la seconda istruzione effettua la sua fase EX il valore SP sar gi stato aggiornato dal sommatore, presente nella fase MEM della prima istruzione, per cui tutto procede senza problemi. 3CASO: istruzione POP seguita da unistruzione PUSH
prima istr: POP seconda istr: PUSH
Pagina 49
A.A. 2009/2010
Questa situazione non presenta alcun tipo di problema poich nel momento in cui la seconda istruzione effettua la sua fase EX il valore SP sar gi stato aggiornato per cui tutto procede senza problemi.
4CASO: istruzione PUSH seguita da unistruzione POP

prima istr: PUSH seconda istr: POP
IF ID IF EX ID MEM
stallo
WB EX MEM WB
Questa situazione presenta un stallo della fase EX dellistruzione POP; questo problema dovuto al fatto che soltanto al termine della fase MEM dellistruzione PUSH il sommatore aggiorner SP, per cui non potr essere eseguita contemporaneamente la fase EX dellistruzione POP poich SP non ancora aggiornato. Per evitare questo stallo possibile pensare di eseguire laggiornamento di SP direttamente nella fase EX dellistruzione PUSH; vediamo in dettaglio cosa si dovrebbe fare: Nella fase EX passiamo SP al latch EX/MEM e tramite lALU (quindi non serve pi il sommatore) laggiorniamo e lo passiamo al latch ID/EX; per cui in microcodice si ha: FASE EXE
EX/MEM.SP ID/EX.SP ID/EX.SP ID/EX.SP + 4
In questo modo al termine della fase EXE il valore di SP risulter aggiornato, per cui listruzione POP successiva non dovr pi stallare poich ora il dato sar disponibile.
prima istr: PUSH seconda istr: POP
Pagina 50
A.A. 2009/2010
ESERCIZIO 3 Considerando di voler aggiungere al set di istruzioni del MIPS le istruzioni ADDL e SUBL (la L sta per long, inteso come doppia word intera) scrivere in RTL i microprogrammi utili ad interpretarle, indicando le pi opportune modifiche architetturali. (bisogna supporre che lALU del MIPS possa operare con soli dati da 32 bit e che quindi anche i registri sono a 32 bit). Nel caso non sia possibile compattare listruzione in 5 fasi di pipeline, giustificarne il perch. Verosimilmente loperazione da effettuare sar ad esempio: ADD R10,R4,R6 ADD R11,R5,R7 Quindi dividiamo loperazione in due; ma bisogna prestare attenzione al bit di carry prodotto dalla prima istruzione; per cui la seconda istruzione dovr considerare leventuale bit di carry che si sar propagato e conservato nella PSW (Process Status Word), un registro ausiliario del processore che contiene una serie di flag che tengono traccia di quello che appena successo nellALU. Poich listruzione ADDL sommer operandi in doppia lunghezza utile fare delle considerazioni sui registri: rs e rt rappresentano i registri che contengono i 32 bit meno significativi; rs' e rt' rappresentano i registri che contengono i 32 bit pi significativi; con laccortezza che rs' e rt' non siano scritti da nessuna parte, cio listruzione conterr, considerando lesempio, solo il codice 4 e 6, il sistema poi sapr che si sta facendo riferimento a dei dati in doppia parola e che la seconda parte della parola nei registri adiacenti. Lo stesso vale per il registro destinazione: rd (rd') rappresenta il registro destinazione che conterr i 32 bit meno significativi (pi significativi) del risultato. Le fasi IF e ID sono le seguenti: FASE IF
FASE ID
FASE EXE1 (occorre memorizzare il carry nel bit c della PSW)

EX/MEM.IR ID/EX.IR EX/MEM.ALUOUTPUT ID/EX.A + ID/EX.B ID/EX.A Regs[IF/ID.IR[rs']] ID/EX.B Regs[IF/ID.IR[rt']] PSW[c]
Sfruttando una suddivisione in semicicli, ID/EX.A e ID/EX.B sono letti nel primo semiciclo e scritti nel secondo.
Pagina 51

FASE EXE2 (comprende la fase MEM1)
MEM/WB.IR EX/MEM.IR MEM/WB.ALUOUTPUT EX/MEM.ALUOUTPUT EX/MEM.ALUOUTPUT ID/EX.A + ID/EX.B + PSW[c]
A.A. 2009/2010
Sfruttando una suddivisione in semicicli, EX/MEM.ALUOUTPUT letta nel primo semiciclo, scritta nel secondo. FASE WB1 (comprende la fase MEM2)
Regs[MEM/WB.IR[rd]] MEM/WB.ALUOUTPUT MEM/WB.ALUOUTPUT EX/MEM.ALUOUTPUT
Sfruttando una suddivisione in semicicli, MEM/WB.ALUOUTPUT letta nel primo semiciclo, scritta nel secondo. FASE WB2
Regs[MEM/WB.IR[rd']] MEM/WB.ALUOUTPUT PC 0
Pensata cos listruzione termina in sei fasi; analizziamo ora i conflitti che potrebbe generare:
prima istr: ADDL seconda istr: qualsiasi
IF ID IF EX1 ID EX2 EX WB1 MEM WB2 WB
per la seconda istruzione vi uno stallo nel momento in cui vi la fase EX (avviene in contemporanea con la EX2) e nel momento della fase ID poich provoca incoerenza in quanto EX1 sta scrivendo nei registri A e B e a lo stesso sta facendo ID. Per cui inserendo lo stallo prima della fase ID si ottiene:
prima istr: ADDL seconda istr: qualsiasi
IF ID IF EX1
stallo
EX2 ID
WB1(MEM1) EX
WB2(MEM2) MEM WB
possibile migliorare la situazione considerando che se le operazioni in doppia precisione fossero molto frequenti, potremmo pensare di utilizzare dei latch A, B, ALUOUTPUT capaci di contenere 64 bit, invece di 32, evitando la seconda fase di prelievo degli operandi (nella fase EX1) che obbligano di fatto ad uno stallo l'istruzione successiva, in quanto ne impediscono l'ID. Comunque lALU continuerebbe a processare gli operandi in due tempi ciascuno da 32 bit: avremmo comunque la necessit di avere due fasi di EXE (e conseguente stallo delle istruzioni successive in conflitto strutturale sull'ALU, risolvibile inserendo un sommatore nella fase EX2 in modo tale da non usare lALU). In questo modo bisogner potenziare la C.U. e aggiungere hardware; non si ottiene quindi nessun miglioramento per cui conviene avere unALU a 64 bit. In maniera analoga a quanto appena visto vale per lipotetica istruzione SUBL, considerando il bit di borrow (riporto) della PSW invece del bit di carry.
Pagina 52
A.A. 2009/2010
ESERCIZIO 4 Scrivere in RTL i microprogrammi utili ad interpretare listruzione: LW R1,(#1000,R2) per una architettura MIPS con bus dati a 32 bit, considerando eventuali conflitti che si verrebbero a creare con le istruzioni ad essa successive nell'implementazione pipeline. Per LW R1, (#1000, R2) si intende:
R1 Mem[Mem[1000 + R2]]
Cio verosimilmente si dovrebbero effettuare, per esempio, queste due istruzioni:

LW R6,1000(r2) LW R1,0(R6)
Le fasi per svolgere queste due istruzioni dovrebbero essere le seguenti:

prima istr: LW R6,1000(R2) seconda istr: LW R1,0(R6)
Ci sar bisogno di uno stallo poich la seconda LW deve calcolare R6 + 0 per avere lindirizzo, e quindi la EX della seconda istruzione deve stallare; ma poich essendo zero il secondo addendo della somma, allora con una corto-circuitazione della memoria, in cui luscita della memoria va alla porta indirizzo della memoria stessa, si evita lo stallo. Questa operazione vale solamente in questo caso, poich la seconda load deve effettuare una somma con zero. Quindi bisogner modificare la C.U. Per cui con questi accorgimenti non si hanno stalli e listruzione successiva terminerebbe al colpo di clock 6. Quindi per ottimizzare il microcodice di questa istruzione, che prevede un doppio accesso a memoria, supponiamo nella architettura MIPS, un collegamento dall'uscita dati della memoria al registro EX/MEM.ALUOUTPUT. In tal caso, il microcodice, potrebbe essere: FASE IF
FASE ID
FASE EX
EX/MEM.ALUOUTPUT ID/EX.A + ID/EX.Imm EX/MEM.IR ID/EX.IR
FASE MEM1
EX/MEM.ALUOUTPUT Mem[EX/MEM.ALUOUTPUT] MEM/WB.IR EX/MEM.IR
FASE MEM2 CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 53 Pietroleonardo Nicola Stroppa Fabio

MEM/WB.LMD Mem[EX/MEM.ALUOUTPUT]
A.A. 2009/2010
FASE WB
Regs[MEM/WB.IR[rd]] MEM/WB.LMD
Pensata cos listruzione termina in sei fasi; analizziamo ora i conflitti che potrebbe generare:
prima istr: LW seconda istr: qualsiasi
IF ID IF EX ID MEM1 EX MEM2 MEM WB WB
La fase di MEM2 della prima istruzione provoca un problema con la fase MEM della seconda istruzione solo se questultima unistruzione di load o di store, altrimenti la fase MEM una sola fase di passaggio. Per cui si potrebbe far precedere listruzione LW solo da istruzioni che non effettuano load o store. Il vero problema sorge nel momento in cui la seconda istruzione entra in fase di WB; questo problema semplicemente risolvibile potenziando il canale che porta i dati nei registri.
Pagina 54

ESERCIZIO 5 Progettare un microprogramma in linguaggio RTL da associare ad una istruzione:
RTI (return from interrupt)
A.A. 2009/2010
per una macchina MIPS nei due casi: salvataggio del PC in un registro IAR (Interrupt address return) salvataggio del PC in uno stack, facendo ipotesi su come gestito lo stack. Per semplicit si trascuri il ripristino dei registri e della parola di stato. Listruzione RTI permette di ritornare alla normale esecuzione di un programma dopo che stata servita linterruzione. Il microprogramma ad essa associato pu essere: FASE IF
FASE ID
Consideriamo prima il caso in cui il PC sia stato salvato nellIAR, quindi nei casi di interrupt mascherati, cio nei casi in cui linterrupt non viene interrotto, in maniera tale da non perdere il PC. FASE EXE
EX/MEM.ALUOUTPUT IAR
FASE MEM
MEM/WB.ALUOUTPUT EX/MEM.ALUOUTPUT
FASE WB
PC MEM/WB.ALUOUTPUT PC 0
LIAR viene caricato nel PC per ripristinare il valore del PC quando c stata linterruzione e viene resettato il PC a 0 per fare il fetch della successiva istruzione. Anche se listruzione porta via cinque fasi provocherebbe comunque degli stalli per le prossime istruzioni, perch il fetch non potr essere effettuato in quanto il PC sar disponibile solo dopo la fase di WB. Per cui se si gestisce cos listruzione si avrebbe una situazione del genere:
prima istr: RTI
IF ID IF EX
stallo
MEM
stallo
WB
stallo
seconda istr: (istr. con PC corretto)
IF
ID
EX
MEM
WB
Pagina 55
A.A. 2009/2010
Per cui necessario effettuare il WB il prima possibile; questo si pu ottenere cortocircuitando direttamente IAR con il PC consentendo di ridurre ad uno solo gli stalli (nella fase di EXE si avrebbe direttamente PC IAR). Per cui si ottiene:
prima istr: RTI
IF ID IF EX
stallo
MEM IF
WB ID EX MEM WB
seconda istr: (istr. con PC corretto)
Un ulteriore miglioramento potrebbe essere ottenuto a livello di scheduling, inserendo dopo l'istruzione RTI le ultime due istruzioni di procedura di gestione dellinterrupt, in maniera tale da non sprecare colpi di clock; si ottiene cos questa situazione:
prima istr: RTI seconda istr: istr N-2 terza istr: quarta istr: istr N-1
(istr. con PC corretto)
IF
ID IF
EX ID IF
MEM EX ID IF
WB MEM EX ID WB MEM EX WB MEM WB
dove: N-2 la terzultima istruzione di gestione dellinterrupt; N-1 la penultima istruzione di gestione dellinterrupt Vediamo ora il caso in cui il PC venga salvato nello STACK, quindi nei casi di interrupt non mascherabili, cio nei casi in cui linterrupt pu essere interrotto, e il valore del PC non viene perso poich viene salvato nello stack; al momento del termine delle procedure di gestione degli interrupt, si procede con il prelievo dallo stack dei rispettivi PC. Si suppone che lo STACK risieda in memoria per indirizzi crescenti e che lo Stack Pointer punti allultima locazione piena.
Pagina 56

FASE EXE
EX/MEM.ALUOUTPUT SP SP SP - 4
A.A. 2009/2010
FASE MEM
MEM/WB.LMD Mem[EX/MEM.ALUOUTPUT]
FASE WB
PC MEM/WB.LMD PC 0
Nella fase di EXE avviene il caricamento nel EX/MEM.ALUOUTPUT dello SP e il contemporaneo decremento dello SP per puntare allelemento successivo. Come nel primo caso si ottengono degli stalli che portano listruzione con il PC corretto a cominciare al sesto colpo di clock. Con uno opportuno scheduling dellistruzioni, simile al precedente caso, possibile anche in questo caso evitare i colpi di clock persi.
Pagina 57
A.A. 2009/2010
ESERCIZIO 6 Disegnare la CPU di una architettura ad accumulatore e commentarne le caratteristiche. Inoltre, progettarne il ciclo di esecuzione delle istruzioni, descrivendo in RTL il funzionamento del programma:
LD 1200 ADD 1204 ST 1200
specificando anche qual il suo scopo. Larchitettura ad accumulatore si differenzia perch non ha tutti i registri, ma soltanto un registro, chiamato registro accumulatore (ACC); questo registro contiene loperando sorgente e riceve loperando risultato. Il funzionamento dellarchitettura il seguente; 1. Al registro ACC vengono passati: a) Codice operativo; b) Un operando, che un indirizzo di memoria; 2. Il contenuto del registro ACC diventa il primo operando; 3. Viene letta la memoria il valore viene usato come secondo operando; 4. Calcolo del risultato; 5. Scrittura nel registro ACC. Il programma da descrivere richiede: 1. Caricare il contenuto che si trova in memoria allindirizzo 1200 nel registro ACC;
ACC M[1200]
2. Sommare il contenuto di ACC con il valore contenuto in memoria allindirizzo 1204 (il risultato andr in ACC);
ACC ACC + M[1204]
3. Salvare il risultato, ovvero il contenuto di ACC, allindirizzo di memoria 1200.

M[1200] ACC
Come facile notare questa architettura non permette una gestione in pipeline dellistruzioni.
Pagina 58

Un esempio di processore ad Accumulatore pu essere il seguente:
A.A. 2009/2010
In cui: 1. L'Accumulatore sostituisce il banco di registri General Purpose. 2. Esso vincolato ad uno dei due ingressi dell'ALU (l'ingresso In1; questo consente all'architettura di avere un solo bus sorgente in ingresso all'ALU) e funge inoltre da EX/MEM.A 3. L'Accumulatore anche una destinazione privilegiata per l'uscita dell'ALU (il demux, dal punto di vista funzionale non ha alcuna utilit potendo direttamente connettere sul bus D l'uscita dell'ALU in scrittura e l'ACC in lettura come tutti gli altri registri, ma la sua presenza evidenzia didatticamente il fatto che l'Accumulatore il ricettore privilegiato dei dati in uscita dall'ALU). 4. Il registro speciale SAR (Subroutine Address Return) serve per una gestione semplificata delle procedure e memorizza l'indirizzo di rientro (non sono consentiti annidamenti di procedure). 5. Il registro speciale IAR (Interrupt Address Return) serve per una gestione semplificata degli interrupt e memorizza l'indirizzo di rientro (sono consentiti solo interrupt esterni e a loro volta non interrompibili). Queste caratteristiche determinano anche una semplificazione importante sul formato istruzione della macchina che richiede solo la specifica di un indirizzo di memoria come operando sorgente, essendo l'altro operando sorgente ed il destinazione costituiti di default dall'accumulatore. Si pu quindi supporre un formato istruzione:
4 bit for opcode 28 bit for immediate field
(assumendo che solo 4 bit di CO siano sufficienti per codificare le operazioni ammesse).
Pagina 59
A.A. 2009/2010
Per il ciclo di esecuzione delle istruzioni di questa macchina si possono supporre le seguenti fasi: Instruction Fetch, in cui si preleva l'istruzione e si incrementa il PC:
IR Mem[PC] PC PC+4
Lultima istruzione sarebbe linsieme di queste tre operazioni:

S PC D In0+4 PC D
Addressing e Instruction Decode in cui viene preparato l'indirizzamento alla memoria e decodificata l'istruzione:
MAR IR AND #0FFFFFFF PC MM[IR[opcode]]
La prima istruzione sarebbe linsieme di queste tre operazioni, in cui viene effettuato il mascheramento del codice operativo:
S IR D In0 AND #0FFFFFFF MAR D
Poi a seconda del tipo di operazione si ha: LOAD ALU FASE MEM: FASE MEM:
LMDR Mem[MAR] LMDR Mem[MAR]
STORE FASE MEM:

Mem[MAR] ACC PC 0
BCOND FASE SETPC:

if COND: PC MAR (via ALU) PC 0
FASE EXE/WB:
ACC LMDR+0 PC 0
FASE EXE/WB:
ACC LMDR op ACC PC 0
INT (da sistema) FASE STPC:

IAR PC
RTI FASE SETPC:

PC IAR PC 0
JSUB FASE STPC:

SAR PC
RET (from subroutine) FASE SETPC:

PC SAR PC 0
FASE SETPC:
PC MAR (via ALU) PC 0
FASE SETPC:
PC MAR (via ALU) PC 0
Dove: MEM la fase di accesso alla memoria; EXE/WB la fase di calcolo effettivo e di aggiornamento dell'Accumulatore; STPC (Store PC) la fase in cui viene memorizzato il PC prima di gestire un interrupt o saltare ad una subroutine; SETPC la fase di impostazione (o ripristino istruzioni di return) del PC. La sua codifica in RTL si ottiene banalmente trascrivendo in sequenza opportunamente le microistruzioni relative alle fasi come definito nella prima parte dell'esercizio rispettivamente per una Load, per una operazione ALU (somma) e per una Store. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 60

Per cui si ha:
A.A. 2009/2010
LD 1200
FASE IF
IR Mem[PC] PC PC+4
FASE ADD/ID
FASE MEM
LMDR Mem[MAR] (MAR == 1200)
FASE EXE/WB
ACC LMDR+0 PC 0
ADD 1204
FASE IF
IR Mem[PC] PC PC+4
FASE ADD/ID
FASE MEM
LMDR Mem[MAR] (MAR == 1204)
FASE EXE/WB
ACC LMDR op ACC PC 0 (op == +)
ST 1200
FASE IF
IR Mem[PC] PC PC+4
FASE ADD/ID
FASE MEM
Mem[MAR] ACC PC 0 (MAR == 1200)
Pagina 61

PARTE SECONDA
A.A. 2009/2010
PARTE SECONDA MEMORIE CACHE
Pagina 62

GERARCHIA DI MEMORIA
A.A. 2009/2010
Nella figura qui affianco riportata la struttura gerarchica di un sistema di memorie. Quello che interessante vedere che la dimensione (capacit) dei vari blocchi di memoria aumenta con lallontanarsi dal processore; si osserva anche che allontanandosi dalla CPU diminuisce la velocit di accesso alle informazioni e il costo rapportato al byte.
BREVE CENNO SU :
1 LIVELLO
2 LIVELLO
MECCANISMO A FINESTRA DEI REGISTRI Lideale sarebbe avere una CPU con molti registri, veloci e convenienti; ma mettere a disposizione un numero elevato di registri allinterno del processore non sarebbe conveniente, poich in realt questo porterebbe a reperire informazioni in maggior tempo. Infatti si riesce ad accedere in maniera diretta e veloce ai registri, proprio se questi sono in numero limitato; inoltre poich ogni registro ha un nome identificativo univoco, nel caso in cui si vuole avere un numero molto pi ampio di registri bisognerebbe puntare ad un registro specificando un numero di bit molto pi grande e questo significherebbe avere unistruzione con tre operandi, ciascuno dei quali con un elevato numero di bit; quindi listruzione avrebbe un numero troppo grande per individuare solo i registri. In seguito ci si accorger che quando nel processore si inserisce una memoria cache, in pratica, si riesce a implementare la logica a pi registri attraverso il meccanismo a finestra; il progettista pu decidere di inserire nel processore pi di 32 o 64 registri, ma dando la visibilit alla CPU solo ad un numero ristretto di registri. Questo meccanismo utile nei casi in cui vi una chiamata alla procedura di gestione di un interrupt; la procedura potrebbe utilizzare i registri per scriverci delle informazioni necessarie allesecuzione. Il meccanismo permette di far puntare la CPU ad altri registri, in maniera tale da non far sovrascrivere i dati e inoltre questo meccanismo permette di non effettuare, o comunque limitare, il salvataggio dei registri nello stack ( richiesto solo il salvataggio di PC e del PSW e di un codice che identifica di quanto stata spostata la finestra). PRINCIPI FONDAMENTALI DELLA GERARCHIA DI MEMORIA TRASPERENZA DEI LIVELLI: ogni livello intermedio della gerarchia trasparente al processore e simula il processore per il livello immediatamente inferiore, mentre simula la memoria per il livello immediatamente superiore. Per comprendere meglio questo concetto, si consideri questo esempio: supponiamo che la memoria centrale chiede dei dati ai dischi; dal punto di vista dei dischi come se fosse il processore a richiedere i dati, quindi la memoria per il livello sottostante simula il processore; la cache (livello immediatamente superiore) vista come processore dalla memoria, ma questultima simula la memoria per la cache. Per cui, dal punto di vista del processore tutto ci che sta sotto memoria.
MEMORIA CENTRALE
Costo/byte
Pagina 63
A.A. 2009/2010
PRINCIPI DI LOCALITA: la CPU richiede dati seguendo due principi di localit: - LOCALITA SPAZIALE: quando una cella di memoria viene referenziata, le celle vicine (ad essa contigue) hanno unalta probabilit di essere a loro volta referenziate di l a poco; questo principio si applica bene alle istruzioni di un programma, ma anche ai vettori ed alle matrici; - LOCALITA TEMPORALE: quando una cella di memoria viene referenziata, probabile che presto venga referenziata di nuovo; questo principio si applica bene soprattutto ai dati ed alle variabili.
Questi principi suggeriscono luso dei blocchi; un blocco una quantit dinformazione che ha la caratteristica di essere contigua in memoria, quindi la memoria sar divisa in un numero fisso di locazioni contigue. In questo modo quando una memoria dovr dare alla memoria di livello superiore un dato le passer lintero blocco contenente il dato richiesto; anche se pu sembrare di perdere del tempo, in questo modo vengono rispettati i principi e allo stesso tempo analizzando le prestazioni ci si accorge che questa una scelta ottimale. Supponiamo che un i-esimo livello superiore chieda un dato che si trova ad un qualsiasi indirizzo del livello inferiore. Il tempo, affinch il livello superiore possa avere a disposizione il dato, possibile descriverlo in questo modo: = 1 + Dove: 1 1 Se si sta facendo lettura dal disco il tempo di lettura dipender da tre fattori, quali: tasso di trasferimento, tempo di ricerca e tempo di latenza rotazionale; di cui due sono tempi meccanici, per cui il tempo di accesso pi alto rispetto se la lettura effettuata ad esempio in memoria centrale. Per cui al momento di una lettura di un dato, si effettua un prelievo di un blocco contenente il dato, poich per il principio di localit temporale possibile che il secondo dato, che eventualmente sar richiesto, sia compreso fra quelli prelevati; quindi questa scelta porta ad un minor tempo per la lettura di un insieme di dati, rispetto al tempo per leggere un singolo dato per volta. Questa filosofia applicata alla piramide gerarchica; quando la CPU chiede un dato alla memoria cache, se questa non c lha, lo chieder al livello sottostante insieme ad un blocco di dati. Lo stesso vale per gli altri livelli. Essendo ogni livello pi piccolo del precedente, non si ha una corrispondenza 1 ad 1; per cui bisogna gestire quattro fondamentali problemi. QUATTRO DOMANDE PER LA CLASSIFICAZIONE DELLE GERARCHIE DI MEMORIE I problemi che si presentano quando si mettono in relazione i diversi livelli di una gerarchia di memorie sono bene evidenziati dalle seguenti quattro domande: D1) Dove possibile mettere un blocco nel livello superiore? (allocazione del blocco) D2) Come possibile trovare un blocco quando nel livello superiore? (identificazione del blocco) D3) Quale blocco deve essere sostituito in caso di fallimento di accesso? (sostituzione del blocco) D4) Cosa succede nel caso di una scrittura? (strategia di scrittura) CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 64 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
Consideriamo ora le cache pi in dettaglio esaminando le risposte alle quattro domande sulle gerarchie di memorie.
MEMORIE CACHE
Un po di storia e curiosit La prima cache nella storia dei calcolatori stata descritta in un articolo di Wilkes nel 1965; labstract dellarticolo sostanzialmente cita: si discute dellutilizzo di una memoria veloce, di 32000 parole, supporto di una memoria centrale pi lenta, di 1'000'000 di parole, in modo tale che il tempo di accesso effettivo sia pi vicino a quello di una memoria veloce che a quello di una memoria lenta. Questa idea, al tempo innovativa, porta, solo dopo tre anni, alla realizzazione del primo calcolatore dotato di memoria cache, presso luniversit di Cambridge. Per fare questo occorreva una tecnologia diversa, pi veloce, da quella utilizzata per la memoria centrale, infatti vennero utilizzati i DIODI TUNNEL, per essendo questa tecnologia, allepoca molto ingombrante, potevano essere realizzate memorie di piccole dimensioni. Proprio a causa delle grandi dimensioni famoso laneddoto sulla parola debug: Il 9 settembre del 1945 Grace Murray Hopper (ufficiale e matematico di gran valore) che prestava servizio in Virginia presso la marina militare degli Stati Uniti stava cercando di trovare l'errore che inceppava il computer basato su un sistema Harvard Mark II, quando decise di controllare lo stanzone contenente lintero sistema, trov un insetto che girovagava allegramente (prima di morire) in mezzo ai circuiti e che era la causa del malfunzionamento, dopo aver rimosso linsetto, il tenente lo incoll sui suoi appunti e annot: 1545. Relay #70 Pannello F (falena) nel relay. Primo vero caso di bug trovato>>. Questo registro conservato presso lo Smithsonian National Museum of American History. Da allora il termine "bug" entr nell'informatica per indicare un errore di programmazione. STRATEGIE DI ALLOCAZIONE DEI BLOCCHI Si suppone, per semplicit, che la memoria centrale sia costituita da 32 blocchi e la memoria cache costituita da 8 blocchi; si vuole prelevare un dato, allindirizzo x, dalla memoria centrale e caricarlo in cache. Questo dato interno ad uno dei 32 blocchi che costituiscono la memoria centrale; ad esempio si consideri questa situazione: il blocco contenente il dato x il numero (16)8 . Indirizzo di blocco (memoria centrale)
N. bl oc co
0 1 2 3 4 5 6 7
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
Pagina 65

I vincoli sulla posizione dei blocchi creano tre categorie di cache:
A.A. 2009/2010
CACHE COMPLETAMENTE ASSOCIATIVA Se un blocco pu essere messo ovunque nella cache, in una qualsiasi posto chiamato linea, essa definita completamente associativa. 0 1 2 3 4 5 6 7
CACHE AD INDIRIZZAMENTO DIRETTO Se ogni blocco pu comparire in un'unica linea della cache, allora essa definita a indirizzamento diretto. La linea nella cache si ottiene tramite una operazione di mascheramento ai bit che identificano il blocco; per cui essendo = e dato che la cache di 8 linee, bisogner prendere 3 bit dei 6 che identificano il blocco; quindi se considero i primi 3 bit incorrer sicuramente in sovrascritture, poich nel momento in cui bisogner caricare ad esempio il blocco adiacente, 17, questo andr a scriversi comunque nel blocco 1, determinando la perdita dei dati precedentemente contenuti. Per cui si considerano gli ultimi 3 bit e quindi il blocco 16 viene caricato nella linea = . Questa operazione equivale a: 10 Considerando lesempio si ha: 14 8 = 6 0 1 2 3 4 5 6 7
Questo metodo di allocazione dei blocchi il pi semplice che si possa avere, ma il meno consigliabile dal punto di vista del Principio di Localit Temporale.
CACHE SET ASSOCIATIVA Se un blocco pu essere messo in un insieme ristretto di posizioni nella cache, essa definita set-associativa. Un insieme o set un gruppo di due o pi blocchi della cache. Un blocco viene prima messo in corrispondenza di un insieme e poi pu essere messo in precisa posizione dellinsieme. Di solito, linsieme o set viene individuato dalla seguente operazione: ( ) 10 ( ) Considerando lesempio si ha: 14 4 = 2. Questa operazione equivale a leggere gli ultimi due bit dei 6 che identificano il set: 001110. 0 1 2 3 4 5 6 7
Set. 0 Set. 1 Set. 2 Set. 3
Pagina 66
A.A. 2009/2010
STRATEGIE DI RICERCA E IDENTIFICAZIONE Dallindirizzo di memoria proveniente dalla CPU la cache estrae letichetta e la confronta con tutte le etichette presenti nella Tag Memory della cache, a cui corrisponde una dato nella effettiva memoria dati della cache se la sua organizzazione completamente associativa. Se invece la cache di tipo set-associativo, letichetta estratta viene confrontata con tutte le Tag Memory appartenenti allunico insieme deputato a contenere il blocco ricercato. Infine, nel caso di cache a indirizzamento diretto letichetta estratta viene confrontata con lunica possibile Tag Memory. Le memorie cache di tipo set-associativo ed ad indirizzamento diretto suddividono un indirizzo di memoria in tre campi: Etichetta Indice Spiazzamento nel blocco Etichetta: serve per identificare il blocco ricercato; Indice: serva a individuare il set (set-associativa) o il blocco (indirizzamento diretto); Spiazzamento nel blocco: utilizzato per selezionare il dato (parola) desiderato nel blocco.
Le memorie cache completamente associative suddividono un indirizzo di memoria in due soli campi: Etichetta Spiazzamento nel blocco A questa conclusione si giunge considerando che, se la dimensione totale viene mantenuta, un incremento della associativit comporta un aumento del numero dei blocchi per insieme; di conseguenza diminuisce il numero degli insiemi e aumenta la dimensione delletichetta. Cio il confine tra letichetta e lindice si sposta verso destra via via che si aumenta lassociativit. La necessit che laccesso alla cache sia veloce richiede che i confronti tra le etichette siano fatti in parallelo. Perci nel caso di cache completamente associative vi saranno in parallelo tanti confronti (e quindi tanti comparatori) quanti sono i blocchi in cui suddivisa la cache stessa (nellesempio si avranno 8 comparatori); nel caso di cache set-associative vi saranno in parallelo tanti confronti (e quindi tanti comparatori) quanti sono i blocchi che costituiscono i set in cui suddivisa la cache stessa (nellesempio si avranno 2 comparatori); infine, nel caso di una cache a indirizzamento diretto si avr solo un confronto (e quindi un solo comparatore). Ci deve essere poi un modo per vedere se un blocco nella memoria cache non contiene informazioni valide. Il metodo pi comune consiste nellaggiungere un bit di validit (Validity bit) alletichetta che indica la validit dellindirizzo contenuto nelletichetta stessa. Tale indirizzo non viene considerato se il bit non ha un valore alto.
Pagina 67
A.A. 2009/2010
STRATEGIE DI SOSTITUZIONE (fallimenti di accesso) La CPU chiede alla memoria cache un dato che in essa non presente: allora la memoria deve caricare un blocco che contiene questo dato dal livello sottostante. Nel caso di organizzazione a indirizzamento diretto, lo schema cos semplice che non ci sono alternative: soltanto un blocco viene controllato quando si effettua un accesso alla memoria e solo quel blocco pu essere sostituito. Nel caso di organizzazione completamente associativa e set associativa possibile operare una scelta fra tre metodi: 1. METODO RANDOM: i blocchi candidati alla sostituzione in questo caso vengono scelti in modo casuale. Affinch il metodo sia efficace si deve avere una bassa probabilit di sostituire un blocco appena caricato, cosa che tanto pi garantita quanto maggiore il numero dei blocchi. Questo il motivo per cui tale metodo indicato per le memorie cache completamente associative. Un vantaggio della scelta casuale la semplicit della realizzazione circuitale. 2. METODO LRU (Last Recently Used): il blocco che viene sostituito quando si adotta questo metodo quello che rimasto inutilizzato per il periodo di tempo pi lungo. Tale strategia si basa sul Principio di Localit Temporale: se probabile che le linee usate di recente siano riutilizzate, allora il miglior candidato alla sostituzione la linea che stata usata meno di recente. Per ridurre la possibilit di eliminare informazioni che presto saranno di nuovo necessarie, gli accessi alle linee vengono registrati. Vediamo come considerando lorganizzazione set associativa (le stesse considerazioni sono valide per la completamente associativa): ogni linea allinterno di un set viene dotato di un contatore di utilizzo. Ogni qualvolta si utilizza una linea si azzera il suo contatore e si incrementa di una unit il contatore delle altre linee dello stesso set; in tal modo i contatori delle linee non utilizzate avranno un valore pi elevato. La linea il cui contatore presenta il valore pi alto quello non usata da pi tempo. Nel caso in cui tutte le linee avessero i contatori a zero, si prender allora la prima linea. Questo metodo va bene quando le linee del set sono poche, perch devono essere eseguiti molti confronti. In generale, se n sono le linee del set, avremo ( 1) confronti e quindi sar necessaria una rete di ( 1) comparatori. chiaro allora che quando il numero delle linee da tenere sotto controllo cresce, la strategia LRU diventa sempre pi costosa e, daltra parte, sempre pi di frequente fornisce risultati approssimativi. Si consideri la seguente situazione in cui inizialmente la linea candidata LRU la linea 0 :
LINEA USATA ALLISTANTE LINEA CANDIDATA LRU / 0 3 0 2 0 1 0 0 3 0 3 2 3 3 1 1 0
Pagina 68
A.A. 2009/2010
Non detto che questo metodo convenga sempre; analizzando la tabella qui affianco facile notare infatti che aumentando dimensione e associativit (linee in un set) LRU e RANDOM si uguagliano e questo (la tabella riporta il numero di fallimenti per 1000 istruzioni) avviene per due motivi: - nella scelta fra pi linee, anche casualmente, facile che ne venga selezionata qualcuna che non serve subito; - nella scelta fra pi linee, il metodo LRU diventa meno preciso. 3. METODO FIFO (First In First Out): consiste nel sostituire il blocco che era stato utilizzato N accessi prima, indipendentemente dal fatto che sia stato utilizzato o meno negli ultimi N-1 accessi. In pratica il sistema funziona grazie a uno shift register, ossia un registro a scorrimento costituito da un serie di celle in cui, per ogni colpo di clock, il contenuto di una cella passa alla cella successiva; si osservi questo esempio:
LINEA 3 LINEA 1 LINEA 2 LINEA 5 LINEA 4 LINEA 3 LINEA 1 LINEA 2 LINEA 5
Linea 4
Blocco che verr sostituito
evidente che il metodo non rigoroso dal punto di vista del Principio di Localit Temporale, perch si rischia di sostituire un blocco che stato referenziato di recente. Dal punto di vista dei costi, si pu facilmente notare, che il metodo LRU richiede una complessit di realizzazione superiore al metodo FIFO.
FALLIMENTI DI ACCESSO ALLA CACHE legge delle tre C Un modello intuitivo del comportamento delle memorie cache attribuisce tutti i fallimenti a una delle tre cause che seguono: 1. Obbligatoriet (Compulsory): al primo accesso un blocco non presente nella cache e deve esservi trasferito. Tali fallimenti vengono definiti fallimenti di partenza a freddo (cold start misses) oppure fallimenti di primo accesso (first reference misses). 2. Capacit (Capacity): se la cache non pu contenere tutti i blocchi necessari allesecuzione di un programma, i fallimenti causati dalla capacit sono quelli connessi ai blocchi che devono essere scartati e ripresi pi tardi. 3. Conflitto (Conflict): se la strategia di piazzamento dei blocchi set-associativa oppure a indirizzamento diretto, vi saranno dei fallimenti dovuti ai conflitti (oltre a quelli obbligatori o di capacit) causati dai blocchi che bisogna scartare e recuperare pi tardi perch troppi blocchi devono essere caricati nello stesso insieme. Essi sono detti anche fallimenti per collisione (collision misses).
Pagina 69
A.A. 2009/2010
STRATEGIE DI SCRITTURA NELLA CACHE Innanzitutto bisogna dire che le letture dominano gli accessi alla cache. Tutti gli accessi per le istruzioni sono letture, inoltre molte istruzioni non scrivono in memoria. Sembrerebbe quindi che ottimizzando le operazioni di lettura si migliorerebbero le prestazioni della cache. Ci vero solo parzialmente. La legge di Amdahl stabilisce infatti che progetti mirati a ottenere alte prestazioni non possono trascurare le operazioni di scrittura. Loperazione pi frequente, cio la lettura di una linea, pu essere resa facilmente pi veloce effettuandola contemporaneamente alle operazioni di lettura e verifica delletichetta. Perci la lettura della linea, pu iniziare non appena il suo indirizzo disponibile. Se laccesso riesce, allora la linea viene passata subito alla CPU. Se invece fallisce non c alcun beneficio, ma neppure un danno. Questo non succede per le operazioni di scrittura. Il processore specifica la dimensione del dato da scrivere; solo una particolare parte della linea pu essere modificata. In generale ci significa che sulla linea viene eseguita una sequenza leggi > modifica > scrivi: viene letta la linea originale, ne viene modificata una parte e, infine, viene scritta la linea con il nuovo valore. Oltretutto, la modifica della linea non pu iniziare finch letichetta non stata controllata per verificare la riuscita dellaccesso. Poich la valutazione delletichetta non pu avvenire in parallelo, le operazioni di scrittura richiedono pi tempo di quelle di lettura. Perci la politica di scrittura che distingue molti progetti di memorie cache. Le strategie di scrittura pi tipiche sono due: 1. WRITE THROUGH: linformazione viene scritta sia nel blocco della cache, sia CPU nel blocco del livello inferiore della memoria. Nel caso di politica write through, lo stato in cui si trova la CPU che aspetta il termine di CACHE unoperazione di scrittura prende il nome di stallo di scrittura (write stall), in effetti loperazione di scrittura avviene alla velocit della memoria centrale. MEMORIA I/O Unottimizzazione utilizzata di solito per ridurre il tempo di stallo consiste CENTRALE nellinserimento di un buffer di scrittura che consente al processore di proseguire mentre la memoria viene modificata. Questo buffer costituito nella seguente maniera: essendo un buffer organizzato da un insieme di celle in coda; vi lo spazio non solo per contenere i dati ma anche, per ogni cella, unetichetta che indica in quale indirizzo della memoria il dato deve essere scritto. Inoltre nelletichetta vi anche una sorta di bit di validit, il quale assicura che se nel buffer vi un dato ripetuto ma modificato, viene invalidato quello che deve ancora uscire; in questa maniera il processo di scrittura in memoria centrale velocizzato. Comunque, uno stallo di scrittura possibile anche in presenza di un buffer di scrittura, poich esso di dimensioni limitate. 2. WRITE BACK: linformazione viene scritta solo nel blocco della cache. Il blocco della cache modificato viene scritto nella memoria principale solo quando viene sostituito. Definizione: Un blocco in una cache di tipo Write Back viene definito pulito (clean) o sporco (dirty) a seconda che linformazione immagazzinata nella cache sia uguale o diversa da quella presente nel livello inferiore di memoria.
CPU
CACHE
MEMORIA CENTRALE
I/O
I vantaggi della strategia WT sono: semplice implementazione; cache sempre clean; il livello gerarchico inferiore dispone della copia pi recente dei dati. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 70 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
I vantaggi della strategia WB sono: le operazioni di scrittura avvengono alla velocit della cache; scritture multiple eseguite sullo stesso blocco richiedono una sola operazione di scrittura. Bisogna comunque considerare che larchitettura di un elaboratore prevede anche la presenza dellI/O; per cui necessario analizzare il comportamento di queste due tecniche nelle situazioni in cui vengono effettuati Input e Output di blocchi da e verso lI/O. INPUT (I/O MEM. CENTRALE): in entrambe le tecniche nel caso in cui lI/O vada a modificare un blocco della memoria centrale, in cache si avranno i dati, contenuti in quel blocco, scaduti (se quel blocco stato precedentemente scritto in cache); OUTPUT (MEM. CENTRALE I/O): con la tecnica Write Back lI/O trover dei dati scaduti in memoria centrale, cosa che non succede con la tecnica Write Through. Per ridurre la frequenza delle operazioni di scrittura dei blocchi quando vengono sostituiti viene comunemente utilizzato un bit di modifica (dirty bit). Definizione: Il bit di modifica (dirty bit) un bit di stato che indica se il blocco, durante la sua permanenza nella cache, stato modificato. Se rimasto invariato, il blocco non viene scritto, visto che il livello inferiore di memoria contiene le stesse informazioni della cache.
ELETTRONICA DELLE MEMORIE possibile realizzare memorie utilizzando le seguenti due tecnologie: SRAM (Static RAM): il contenuto mantenuto costante nel tempo (finch c tensione di alimentazione), per cui non necessario il refresh della memoria; la sua realizzazione richiede 6 transistor per ogni cella memorizzante un singolo bit. Questo tipo di realizzazione richiede un maggiore spazio fisico, ma in compenso offre maggiore velocit; tipicamente usata nelle cache allinterno dei processori.
Circuito di una cella di memoria SRAM.
DRAM (Dynamic RAM): il contenuto mantenuto per un periodo che dipende dal tempo di scarica del condensatore, per cui necessario il refresh della memoria; la sua realizzazione richiede 1 transistor e 1 condensatore per ogni cella memorizzante un singolo bit. Questo tipo di realizzazione richiede un minore spazio fisico, ma non offre elevate velocit (causa del refresh); tipicamente usata nelle realizzazioni di memorie centrali.
Circuito di una cella di memoria DRAM.
Pagina 71
A.A. 2009/2010
VALUTAZIONE DELLE PRESTAZIONI DELLA MEMORIA CACHE Prima di valutare le prestazioni, fondamentali per la progettazione di una memoria cache, utile chiarire alcuni concetti fondamentali. La CPU indirizza solo la memoria principale; lindirizzo generato dalla CPU viene per intercettato dalla cache. Se la cache possiede questo indirizzo, laccesso a memoria ha avuto successo (HIT); se non vi questo indirizzo, laccesso a memoria non ha avuto successo (MISS) e la cache invia un segnale al piedino di WAIT del processore per bloccare il clock. La cache realizza un effettivo vantaggio in velocit solo se i dati rispettano i due principi di localit visti in precedenza. Infatti, allaccensione di un computer, questo sar lento, perch deve rispettare lobbligatoriet, cio obbligato a caricare certi dati distanti in memoria tra loro. Di seguito vengono definiti i significati di: Hit Rate, Miss Rate, Hit Time e Miss Penality. HIT RATE: percentuale di tentativi di accesso che hanno avuto successo; MISS RATE: percentuale di tentativi di accesso falliti, per cui: = 1 ; HIT TIME: tempo di accesso al livello inferiore della gerarchia di memoria, che comprende anche il tempo necessario a determinare se laccesso ha successo oppure fallisce; MISS PENALITY (Penalizzazione di fallimento): tempo necessario a sostituire un blocco nel livello superiore con un blocco preso dal livello inferiore pi il tempo impiegato per trasferire le informazioni al centro che li aveva richieste, la CPU. La penalizzazione di fallimento viene a sua volta suddivisa in due componenti: il tempo di accesso, ossia il tempo necessario per accedere alla prima parola del blocco richiesto dopo che stato rilevato il fallimento, ed il tempo di trasferimento, che indica il tempo utilizzato per trasferire le altre parole del blocco. Il tempo di accesso collegato alla latenza del livello inferiore nella gerarchia di memoria, mentre il tempo di trasferimento collegato alla larghezza di banda del canale tra i due livelli di memoria. Vediamo ora come possibile effettuare una misura delle prestazioni di una memoria cache considerando il tempo di CPU, il quale pu essere diviso nei cicli che la CPU spende eseguendo il programma e in quelli che la CPU trascorre in attesa di risposta dal sistema di memoria. Perci:
= = +
Per semplificare la valutazione delle alternative durante il progetto della cache spesso si adotta lipotesi che tutti gli stalli di memoria siano dovuti alla cache. Ci vero per molte macchine; anche in quelle macchine che non verificano tale ipotesi, la cache la causa principale degli stalli, bench questi non siano dovuti esclusivamente ad essa. Per chiarire il senso della formula scritta sopra bisogna stabilire se il ciclo di clock utilizzato per un accesso alla cache debba essere considerato parte dei cicli di CPU in esecuzione o parte dei cicli di stallo di memoria. Entrambe le ipotesi sono plausibili, ma la pi comunemente accettata quella secondo cui i cicli per un accesso riuscito vanno inclusi nei cicli di CPU in esecuzione. I cicli di stallo di memoria possono quindi essere definiti in termini di numero di accessi alla memoria per programma, di penalizzazione di fallimento (misurata in cicli di clock) e miss rate per operazioni di lettura e di scrittura:
= + = =

Pagina 72
A.A. 2009/2010
La relazione che lega la penalizzazione di fallimento alla dimensione del blocco e la relazione che lega il miss rate alla dimensione del blocco sono riportate nelle seguenti figure:
Pollution Point
Queste rappresentazioni si basano sullipotesi che la dimensione del livello superiore della memoria non cambi; osservando il primo grafico si pu notare che la parte della penalizzazione di fallimento correlata al tempo di accesso rimane costante al variare della dimensione del blocco; il tempo di trasferimento, invece, cresce proporzionalmente alla dimensione del blocco. Osservando il secondo grafico si nota che lincremento delle dimensioni di un blocco provoca una diminuzione del miss rate fino a quando la riduzione dei fallimenti collegati alle maggiori dimensioni dei blocchi (localit spaziale) superiore allaumento dei fallimenti collegato con la diminuzione del numero dei blocchi (localit temporale). In pratica, ci che succede che man mano che la dimensione di un blocco cresce, la parte del blocco che non viene utilizzata cos grande da sovrapporsi a informazioni utili presenti in precedenza nella cache; a questo punto il miss rate comincia a crescere. Il punto della curva, sulla destra, in cui il miss rate inizia ad aumentare al crescere delle dimensioni del blocco viene a volte definito punto di contaminazione (pollution point). Per cui si portati a scegliere la dimensione del blocco pari al minimo della curva; effettuando questa scelta si va a minimizzare il Miss Rate, ma lobiettivo del progettista quello di scegliere la dimensione del blocco che permetta di avere il pi piccolo possibile il tempo medio di accesso alla memoria e non del numero di fallimenti; il tempo medio di accesso alla memoria pari a:

= +
Per cui il valore da scegliere approssimativamente il punto minimo preso sulla curva ottenuta dal prodotto dei due grafici:
x Dimensione del blocco da considerare: arrotondare alla potenza di 2 pi vicina
Pagina 73
A.A. 2009/2010
SCHEMA RIASSUNTIVO DEI VANTAGGI/SVANTAGGI DELLE TECNICHE E DEI METODI ANALIZZATI

aumentando
ASSOCIATIVITA
- Minor numero di conflitti - Benefici in cache di medie dimensioni - Maggiori costi: ampiezza delle etichette e aggiunta di comparatori - Politica di sostituzione pi costosa
DIMENSIONE BLOCCHI
- Minor numero di etichette
POLITICA LRU
- Minor Miss Rate per cache a bassa associativit
BUFFER DI SCRITTURA
- Minor stallo di scrittura
VANTAGGI
SVANTAGGI
- Maggior tempo di trasferimento
- Maggior costo hardware
- Maggior costo hardware
Pagina 74

FUNZIONAMENTO LOGICO DI UNA MEMORIA CACHE
A.A. 2009/2010
Per descrivere il funzionamento logico verranno presi in esame due casi reali: la memoria cache del PowerPC e quella del processore Motorola 68000 Cache PowerPC CARATTERISTICHE: - FORMATO ISTRUZIONI: 32 bit - ORGANIZZAZIONE DELLA CACHE: Cache istruzioni e dati separate; - DIMENSIONE DELLA CACHE: 16 Kbyte per ciascuna cache; - ASSOCIATIVITA DELLA CACHE: Set associativa a 4 linee; - SOSTITUZIONE: tecnica LRU; - DIMENSIONE DEI BLOCCHI: 32 Byte (8 word da 4 byte per ogni blocco); - GESTIONE DELLE OPERAZIONI DI SCRITTURA: prevalentemente Write back, ma anche Write Through.
Stando a queste caratteristiche ogni set di 128 Byte; per cui essendo la cache di 16 Kbyte si hanno 128 set, infatti:
16384 128
= 128.
Letichetta di ogni linea oltre a comprendere lindirizzo ha 2 bit (xy) per codificare 4 stati: - 2 stati per codificare il cambio di parola e la validit della linea (CHANGE BIT & VALID BIT); - 2 stati per codificare situazioni particolari quando la cache utilizzata nei sistemi multi processorie. Lindirizzo di 32 bit inviato alla cache viene suddiviso in tre campi: 20 bit 7 bit
32 bit
5 bit
Il campo costituito dai 5 bit meno significativi dellindirizzo serve per puntare ai 32 byte interni al blocco; Il campo costituito dai 7 bit indirizza in maniera diretta uno dei 128 set; Il campo costituito dai 20 bit serve per effettuare il confronto con letichette delle quattro linee del set individuato.
Il confronto avverr in parallelo: i 20 bit vengono inviati in parallelo a quattro comporatori, ciascuno dei quali ricever come secondo operando unetichetta. Se luguaglianza verificata in uscita da uno dei quattro comparatori vi un 1; poi luscita alta del comparatore viene messa in AND con il Valid Bit per assicurare la validit della linea; se la validit verificata il dato quindi presente in cache (HIT). I 7 bit fungono da selettori per dei multiplexer che devono selezionare quale linea deve andare in ingresso al comparatore per il confronto delletichetta. Luscita della AND va in ingresso a un demultiplxer il quale mander sulla linea selezionata il risultato dellintero lavoro, ovvero il dato richiesto dalla CPU.
Pagina 75
A.A. 2009/2010
Di seguito riportata un figura che implementa il funzionamento logico della cache del PowerPC.
xy: codificano se la linea valida o meno; ------- : LINEE 00 ------- : LINEE 01 ------- : LINEE 10 ------- : LINEE 11 = : COMPARATORE : PORTA AND
Pagina 76

Cache MOTOROLA 68000 CARATTERISTICHE: - FORMATO ISTRUZIONI: 32 bit - ORGANIZZAZIONE DELLA CACHE: Cache istruzioni e dati separate; - DIMENSIONE DELLA CACHE: 4 Kbyte per ciascuna cache; - ASSOCIATIVITA DELLA CACHE: Set associativa a 4 linee; - SOSTITUZIONE: tecnica RANDOM; - DIMENSIONE DEI BLOCCHI: 16 Byte (4 word da 4 byte per ogni linea); - GESTIONE DELLE OPERAZIONI DI SCRITTURA: Write back o Write Through
A.A. 2009/2010
Stando a queste caratteristiche ogni set di 64 Byte; per cui essendo la cache di 4 Kbyte si hanno 64 set, infatti:
4096 64
= 64.
Letichetta di ogni linea oltre a comprendere lindirizzo ha 2 bit, uno per identificare la validit (Valid Bit) e uno per identificare la modifica (Dirty Bit, questo bit presente per ogni word); quindi avendo un bit di modifica per ogni parola, nel caso di gestione Word Through, in memoria centrale verr sostituita la sola word interessata e non lintero blocco. Lindirizzo di 32 bit inviato alla cache viene suddiviso in tre campi: 22 bit 6 bit
32 bit
4 bit
Il campo costituito dai 4 bit meno significativi dellindirizzo serve per puntare ai 16 byte interni al blocco; Il campo costituito dai 6 bit indirizza in maniera diretta uno dei 64 set; Il campo costituito dai 22 bit serve per effettuare il confronto con letichette delle quattro linee del set individuato.
Il confronto avverr in parallelo: i 22 bit vengono inviati in parallelo a quattro comporatori, ciascuno dei quali ricever come secondo operando unetichetta. Se luguaglianza verificata in uscita da uno dei quattro comparatori vi un 1; poi luscita alta del comparatore viene messa in AND con il Valid Bit per assicurare la validit della linea; se la validit verificata il dato quindi presente in cache (HIT). I 6 bit fungono da selettori per dei multiplexer che devono selezionare quale linea deve andare in ingresso al comparatore per il confronto delletichetta. Luscita della AND va in ingresso a un demultiplxer il quale mander sulla linea selezionata il risultato dellintero lavoro, ovvero il dato richiesto dalla CPU. La figura che implementa il funzionamento logico della cache del Motorola 68000 simile a quella del PowePC con dovuti accorgimenti vista la minima differenza di funzionamento.
Pagina 77

INTERAZIONE DELLE MEMORIE CACHE IN UN SISTEMA COMPLESSO
A.A. 2009/2010
PROBLEMATICHE RELATIVE ALLI/O Si consideri un sistema in cui la memoria cache ha una tecnica di gestione della scrittura di tipo Write Through; come gi detto con questa gestione la memoria centrale ricever sempre aggiornamenti dalla cache, per cui vi sar sempre coerenza fra i blocchi di cache e di memoria centrale. Il problema sorge quando il modulo I/O effettua operazioni di scrittura in memoria centrale. Questa operazione comporta dei dati scaduti in memoria cache. Quindi il sistema deve essere in qualche maniera modificato per evitare questo tipo di problematica. Innanzitutto impensabile collegare I/O e cache in modo tale da effettuare input direttamente in memoria cache; questa soluzione risolverebbe i problemi relativi ai conflitti ma porta a far diventare la cache il collo di bottiglia dellintero sistema, abbattendo le sue prestazioni. Per cui una soluzione pu essere quella di far monitorare dalla cache linput da parte dellI/O in memoria centrale; questo monitoraggio pu essere fatto sia cambiando il Valid Bit del blocco che eventualmente cambier di valore, soluzione semplice, oppure, poich il dato ancora sul bus, possibile prelevarlo scriverlo allinterlo del blocco interessato aggiornandolo, operando cos una scelta meno dispendiosa ma forse inutile (il blocco potrebbe non essere pi utilizzato). PROBLEMATICHE RELATIVE AI SISTEMI MULTICORE CPU 1 CACHE CPU 2 CACHE CPU 3 CACHE
MEM. CENTRALE
I/O
La memoria centrale condivisa fra pi memorie cache di diverse CPU; la connessione fra una singola cache e la memoria centrale non avviene in maniera indipendente dalle altre connessioni, ma attraverso un bus che osservato e monitorato da tutte le cache, in maniera tale che se la tecnica di gestione Write Through ed una cache sta scrivendo in memoria centrale, le altre cache potranno eventualmente aggiornare i loro blocchi se interessati dalloperazione di scrittura.
Pagina 78
A.A. 2009/2010
MIGLIORAMENTO DELLE PRESTAZIONI DELLA BANDA PASSANTE DI UNA MEMORIA La banda passante della memoria quel parametro che identifica la quantit dinformazione che possibile leggere e scrivere nella data memoria in un determinato tempo: = Essendo un rapporto possibile aumentare la banda passante in due modi: aumentando linformazione oppure dimunendo il tempo. Vediamo due tecniche di architettura che portano ad aumentare linformazione o a diminuire il tempo. Il primo approccio consiste nel realizzare dei Banchi multipli di memoria paralleli: Si consideri una certa tecnologia che fornisce una certa banda passante; semplice ottenere una banda maggiore se si considera ad esempio la seguente situazione. Quattro moduli di memoria da 1Kbyte per formare un memoria di 4Kbyte (dal punto di vista esterno la memoria risulta un unico chip di 4Kbyte); ogni modulo ha una propria banda passante b. Se ad esempio una parola da 4 byte contenuta in un singolo modulo, la si otterebbe in un determinato tempo; per se la stessa parola, la si va ad immaginare divisa in ogni modulo di memoria (1 byte per ogni modulo), si ottiene la stessa banda che aumentata di quattro. Semplicemente ogni byte che compone la parola scritto allo stesso indirizzo; essendo la memoria di 4K sar indirizzata da indirizzi a 12 bit. Questo indirizzo avr la particolarit di avere i due bit meno significativi uguali a zero, i restanti 10 bit vengono mandati alla porta indirizzi di ogni modulo da un 1K. Con questi 10 bit ogni chip individuer un byte che andr in uscita dal chip. Questi 8 bit che escono, da ciascun modulo, messi insieme formano i 32 bit del dato.
10 bit 00
12 bit
1Kbyte
1Kbyte
1Kbyte
1Kbyte
8 bit
8 bit
8 bit
8 bit
4 Kbyte
32 bit
Una tecnica meno semplice quella dei Banchi Interlacciati: questa tecnica permette di ridurre il tempo. Consideriamo ad esempio sempre i 4 moduli distinti i quali in un certo tempo in uscita hanno 32 bit (per cui ogni modulo pu essere pensato come un insieme dei banchi multipli di memoria visti in precedenza). Ogni modulo di 1 Kbyte, per cui ricevono un indirizzo di 10 bit; dovendo tirare fuori 32 bit (parole di 4 byte) dei 10 bit che ne ricevono i due meno significativi sono uguali a zero. Lindirizzo che arriva allintera memoria unindirizzo di 12 bit, di cui i due meno significativi sono uguali a zero; i 10 bit rimanenti, a loro volto sono suddivisi in 2 bit meno significativi e 8 bit pi significativi. La word non sar suddivisa nei vari moduli, ma sar messa per intera in un modulo. Per cui ogni modulo conterr word intere, con questa logica: MODULO 1 MODULO 2 MODULO 3 MODULO 4 WORD 0 WORD 1 WORD 2 WORD 3 Ind. 0 WORD 4 WORD 5 WORD 6 WORD 7 Ind. 1 WORD 8 WORD 9 WORD 10 WORD 11 Ind. 2 Per cui in ingresso ad ogni modulo si hanno gli 8 bit pi significativi dei 12 pi 2 bit uguali a zero. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 79 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
Poi i 32 bit uscenti da ogni singolo modulo vanno in un MUX che user i 2 bit meno significativi dei 12 come selettore per decidere quale indirizzo da 32 bit deve passare. I 10 bit in ingresso ai moduli andranno a cercare la parola richiesta, la quale andr poi in ingresso al MUX per la selezione: ad esempio se i 10 bit richiedono la word che si trova allindirizzo 2, i moduli daranno in uscita rispettivamente: MODULO 1 word 8; MODULO 2 word 9; MODULO 3 word 10; MODULO 4 word 11; Queste word andranno in ingresso al MUX che ne selezioner una grazie ai 2 bit di selezione; la figura che riassume la tecnica dei moduli interlacciati la seguente.
8 bit
00
8 bit
00
8 bit
00
8 bit
00
8 bit
2 bit
00
12 bit
1Kbyte
1Kbyte
1Kbyte
1Kbyte
32 bit
32 bit
32 bit
32 bit
4 Kbyte
32 bit
Con questa tecnica vero che per il prelievo della prima word si impiegher pi tempo, dovuto al selettore (T + ts), ma nel momento in cui si va a chiedere la seconda word, questa sar subito pronta, infatti il tempo di attesa sar solo quello del selettore (ts). Cos via per le altre word. Questa tecnica funziona sicuramente se applicata alla memoria centrale, poich la cache chiede alla memoria centrale blocchi di word consecutive, mentre non si applica alla memoria cache perch la CPU chiede solo word, per cui si vuole realizzare una tecnica pi veloce.
Pagina 80
A.A. 2009/2010
ORGANIZZAZIONE DELLE MEMORIE A SEMICONDUTTORE Le memorie a semiconduttore sono costituite da celle organizzate in righe e colonne che realizzano una geometria quadrata; viene effettuata questa scelta seguendo due considerazioni: 1. La prima considerazione da fare di tipo strutturale: chiaro che un dispositivo costituito da materiale semiconduttore ha una fragilit maggiore rispetto ad un altro materiale, per cui la forma quadrata rende difficoltosa la rottura. 2. La seconda considerazione, che il vero motivo per cui si preferisce una geometria quadrata, prettamente riferita al modo in cui la memoria viene indirizzata: nel momento in cui si forniscono a questo dispositivo dei bit che devono essere codificati per individuare qual la cella interessata, bene che questa decodifica avvenga attraverso la specifica delle rige e delle colonne, nel senso che invece di avere un sistema che riceve, ad esempio per una memoria di un 1 Kbyte, 10 bit di indirizzo e li decodifica per arrivare ad indirizzare una cella, meglio che loperazione di input/output della cella avvenga attraverso due decodifiche simultane ciascuna delle quali prende un certo numero di bit dellindirizzo; la combinazione di queste due decodifiche permette laccesso alla cella. Essendo le decodifiche simultanee allora questo meccanismo funzionerebbe anche nel caso in cui la geometria fosse rettagolare; tuttavia se loperazioni di decodifica non avvengono parallelamente, ma in serie, prima una e poi laltra, allora risulta utile utilizzare una geometria quadrata. Questo perch i due blocchi di decodifica sono identici, ricevono lo stesso numero di bit, per cui immediato pensare di utilizzarne solamente uno il quale prima riceve un numero di bit per individuare la riga e poi riceve i restanti bit per individuare la colonna; allora la memoria sar costituita da un decodificatore che riceve in un primo istante, ad esempio di un indirizzo di 10 bit, solo 5 bit i quali verranno decodificati per individuare la riga. In un secondo istante ricever i restanti 5 bit i quali verranno decodificati per individuare la colonna. La riga individuata, viene mandata su un buffer di riga; su questo buffer andr ad operare il risultato della decodifica per individuare la colonna, e quindi infine si accede alla cella interessata. Sembrerebbe, utilizzando questo metodo, di rendere la memoria lenta e quindi di avere una perdita di prestazioni, invece, non solo si risparmia sul decodificatore e sul numero di piedini che costituiscono la memoria, ma anche sui tempi di accesso ai dati; i dati immediatamente successivi non richiederano la ricodifica della riga, la quale gi presente sul buffer, ma solo la decodifica della colonna. Per cui solo il primo dato farebbe risultare lento questo tipo di organizzazione.
In questa figura riportata una tipica struttura a matrice quadrata (8x8) di una memoria ad accesso casuale (RAM).
Pagina 81

ESERCIZI DI RIEPILOGO
A.A. 2009/2010
ESERCIZIO 1 Dimensionare i campi (etichetta, set, spiazzamento) dellindirizzo a una memori di 4 MByte qualora essa sia associata ad una cache da 256 KB con parole di 4 Byte e blocchi da 16 Byte nel caso di indirizzamento set-associativo (set di 8 blocchi). Per indirizzare una memoria di 4 MB sono sufficienti 22 bit, da suddividere in etichetta (parte pi significativa), set, spiazzamento (parte meno significativa). Il campo spiazzamento, per poter indirizzare uno fra 16 byte deve richiedere 4 bit, di cui gli ultimi 2 impostati a "00", in quanto le parole indirizzate sono di 4 byte. Essendo il numero dei set pari a
256 816
= 211 , 11 bit saranno necessari al campo set per selezionare
in maniera diretta il set di interesse. Quindi, per differenza, i 7 (= 22 11 4) bit pi significativi costituiranno il campo etichetta. INDIRIZZO (22 bit) SET yyy yyyy yyyy
ETICHETTA xxx xxxx
SPIAZZAMENTO zz00
(x, y, z indicano dei bit di valore non specificato). ESERCIZIO 2 Dato uno spazio di indirizzi di 4 GB specificare i campi e le etichette che si strutturano per luso di cache nei seguenti casi: 1. cache set associativa a 4 set da 16 blocchi, ciascun blocco comprendente 64 words 2. cache ad indirizzamento diretto con 128 blocchi da 32 words 3. cache completamente associativa di 16 MB con 256 blocchi. Il processore invia un indirizzo pensando di avere una memoria di 4 GB per cui lindirizzo richiede 32 bit per indirizzare una word (4 Byte). Cache set associativa a 4 set da 16 blocchi con ciascun blocco da 64 words per cui la cache sar cos costituita:
SET 0
SET 1
SET 2
SET 3
Il campo indirizzo, dovendo puntare all'interno di un blocco ad una fra 64 words, utilizzer 8 bit (di cui gli ultimi due pari a 0). Essendo 4 i set, 2 bit saranno nel campo per indirizzare il set, e i rimanenti 32 8 2 = 22 bit pi significativi comporranno l'etichetta. INDIRIZZO (32 bit) ETICHETTA SET SPIAZZAMENTO xx xxxx xxxx xxxx xxxx xxxx yy zzzz zz00 (x, y, z indicano dei bit di valore non specificato). CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 82

Cache ad indirizzamento diretto con 128 blocchi da 32 words;
4 324
A.A. 2009/2010
numero di blocchi in memoria =
= 225 ;
numero di bit necessari per indirizzare un blocco in memoria = 25 bit, di cui la parte meno significativa di 2 (128) = 7 bit sar utilizzata per puntare al blocco in cache e i rimanenti 25 7 = 18 bit di etichetta. INDIRIZZO (32 bit) ETICHETTA LINEA xx xxxx xxxx xxxx xxxx yyy yyyy (x, y, z indicano dei bit di valore non specificato). Cache completamente associativa di 16 MB con 256 blocchi Se la cache completamente associativa allora il blocco pu essere inserito in una qualsiasi posizione della cache; per questo avr bisogno, per letichetta, dellintero indirizzo del blocco, a meno degli N bit meno significativi utili a puntare alla specifica parola all'interno del blocco. Nella fattispecie, si ha: numero di byte di un blocco =
16 256
SPIAZZAMENTO zzz zz00
= 216 byte
Da cui: N = 16 bit (di cui i 2 meno significativi pari a "00" per puntar a parole di 4 byte. INDIRIZZO (32 bit) ETICHETTA SPIAZZAMENTO xxxx xxxx xxxx xxxx zzzz zzzz zzzz zz00 (x, y, z indicano dei bit di valore non specificato).
Pagina 83
A.A. 2009/2010
PARTE TERZA
PARTE TERZA PROCESSORE SCALARE

ARCHITETTURA FLOATING POINT
Pagina 84

PROCESSORE FLOATING POINT
A.A. 2009/2010
Vediamo ora come possibile estendere la pipeline MIPS per gestire operazioni con dati floating point. Le fasi di IF, ID, MEM e di WB sono analoghe a quelle per gestire dati interi; i gruppi di registri saranno diversi da quelli interi, ma comunque elettronicamente identici. Ci che veramente cambia quello che avviene nella fase EX; mentre nellaritmetica intera si ha lALU che in un tempo pi o meno simile effettua una qualsiasi operazione, nellaritmetica in virgola mobile questo non pi vero, infatti le stesse operazioni con dati floating point richiedono tempi abbastanza diversi di esecuzione. Ad esempio si pensi alle operazioni da effettuare per una addizione di due numeri floating point: Confronto degli esponenti; Shift della mantissa del numero che ha esponente minore di un numero di posti pari alla differenza degli esponenti; Somma delle due mantisse; Aggiornamento dellesponente a quello maggiore; Tutto questo, ovviamente, non pu essere fatto in un tempo analogo a quello necessario per una somma di due interi. Essendo quindi la durata delle operazioni significativamente diversa, si hanno di fronte due scelte: una scelta pu essere quella di ridurre la frequenza del clock del sistema andando a dilatare il tempo di una fase rendendolo pari a quella della fase pi lenta, in questo modo il processore eseguir, in pipeline, le sue operazioni sempre in 5 fasi ma con tempi molto pi lunghi, per comunque ogni fase sar sempre in contemporanea ad altre e soprattutto sempre in ordine. Alternativamente per eseguire operazioni con dati floating point possibile pensare di far durare la fase EX non un colpo di clock sufficientemente ampio, ma un numero di colpi di clock quant la durata del clock che si adatta meglio per misurare la singola fase allinterno del processore. In questo modo le istruzioni avranno fasi che durano il minimo indispensabile; nonostante questa tecnica possa sembrare pi vantaggiosa possibile avere il caso in cui unistruzione, che potrebbe durare molto pi dei soliti cinque colpi di clock, ad esempio una divisone floating point che ha la fase EX lunga circa venti colpi di clock, e quindi la fase EX verrebbe dilatata, e se successivamente quando questa ancora in esecuzione dovesse entrare nella pipeline unaltra istruzione che utilizza meno colpi di clock, questa terminerebbe prima. Per cui si ha quello che viene definita TERMINAZIONE DELLE ISTRUZIONI FUORI ORDINE, cio unistruzione successiva ad unaltra termina prima. Finch listruzione successiva lavora con numeri interi non ci sono problemi, questo perch listruzione floating point utilizza dati che si trovano nei registri dedicati ai dati floating point, mentre listruzione intera utilizza dati che si trovano nei registri dedicati ai dati interi. Per se listruzione successiva, operante anchessa con dati floating point termina prima, ad esempio una somma, potrebbero causarsi problemi seri; per cui molto facile il verificarsi dei tre azzardi di dato: RAW, WAR, WAW. Per far fronte a questi problemi la control unit risulter molto pi complessa, poich dovr monitorare attentamente le unit di calcolo che, per una scelta appropriata, non sono tutte assemblate in un unico blocco. Questa scelta alla base per evitare il congelamento dellunit di calcolo da parte di quelle istruzioni che richiedono un fase EX molto ampia.
Pagina 85
A.A. 2009/2010
Di seguito riportata una figura che riassume la logica delle unit di calcolo separata, con i tre blocchi aggiuntivi per le operazioni floating point.
evidente che se unistruzione, come ad esempio una divisione, occupa per molto tempo il divisore, una possibile istruzione successiva che richiede anchessa il divisore andr in stallo finch listruzione precedente non avr rilasciato lunit di elaborazione. Per cui possibile pensare di organizzare in pipeline anche le varie unit di calcolo, in maniera tale da poter far ricevere altri dati, non quando listruzione precedente finisce e libera lunit ma, bens, quando libera la parte iniziale dellunit. La seguente figura riassume la logica della pipeline applicata alle unit di calcolo.
Per cui il processore nella fase EX pensato in maniera diversa.
Pagina 86
A.A. 2009/2010
Qui accanto riportata una figura in cui si vede come le unit di calcolo, non pipeline, interagiscono con il banco dei registri. presente uno Scoreboard il quale un meccanismo logico che regola laccesso ai registri, verificando che non vi siano conflitti precedentemente citati. La presenza di un ulteriore moltiplicatore giustificata dal fatto che statisticamente da un punto di vista della prestazioni non efficiente aspettare sette colpi di clock tra una moltiplicazione ed unaltra. Per cui ad esempio non conveniente aggiungere un sommatore in pi. immediato pensare allora di aggiungere un divisore in pi a questa struttura, visto che unoperazione di divisione porta via circa 24 colpi di clock; in realt questo non stato fatto sia perch statisticamente le divisioni sono operazioni meno frequenti rispetto alle moltiplicazioni e sia perch un divisore, dal punto di vista hardware, notevolmente pi complesso. Di seguito riportata la tabella con un riepilogo di alcune le istruzioni che costituiscono il sottoinsieme di istruzioni di MIPS64.
Tipo di istruzione/codice operativo ADD.D, ADD.S, ADD.PS SUB.D, SUB.S, SUB.PS MUL.D, MUL.S, MUL.PS MADD.D, MADD.S, MADD.PS DIV.D, DIV.S, DIV.PS CVT._._ Significato dellistruzione Addiziona numeri in DP, in SP e coppie di numeri in SP Sottrai numeri in DP, in SP e coppie di numeri in SP Moltiplica numeri in DP, in SP e coppie di numeri in SP Moltiplica e addiziona numeri in DP, in SP e coppie di numeri in SP Dividi numeri in DP, in SP e coppie di numeri in SP Istruzioni di conversione: CVT.x.y converte dal tipo x al tipo y, che possono essere L (interi a 64 bit), W( interi a 32 bit), D(DP) o S(SP). Entrambi gli operandi sono registri in virgola mobile. Confronti tra DP e SP; al posto di __ ci pu essere: LT; GT, LE, GE, EQ, NE; imposta il bit opportuno nel registro di stato per la virgola mobile Copia da 32 bit in/da registri in virgola mobile da/in registri interi
Virgola mobile: operazioni in virgola mobile in formato SP e DP
C.__.D, C.__.S MFC1, MTC1
Pagina 87
A.A. 2009/2010
SCHEDULING DELLE ISTRUZIONI FLOATING POINT Le unit di calcolo floating point hanno una latenza che non simile indipendentemente dalle operazioni; la differenza, in termini di colpi di clock, fra una operazione ad aritmetica intera e una in floating point comincia ad essere significativa. Una scelta semplice sarebbe quella di dimensionare il clock in base alloperazione che richiede pi tempo, facendo s che dilatando la latenza sia possibile effettuare tutte le operazioni; per questo determina uno spreco di tempo soprattutto nei casi in cui un programma fa uso solo ed esclusivamente dellunit in aritmetica intera, poich queste operazioni dovranno durare quanto la pi lunga operazione in floating point. Allora non si dilata il clock ma si garantisce allunit floating point un certo numero di colpi di clock per le operazioni da effettuare, consentendo di eseguire velocemente le istruzioni che non fanno uso delle unit floating point. Il problema che si viene a creare che questi tempi portano inevitabilmente a degli stalli e conflitti precedentemente analizzati; ad esempio una operazione di divisione in aritmetica floating point seguita da una operazione di load, le quali utilizzano uno stesso registro destinazione, terminerebbe dopo questultima, generando evidentemente un conflitto di tipo WAW.
DDIV.D F4 LOAD F4
Per cui queste tipo di problematiche portano a realizzare unit di calcolo pi sofisticate in modo tale da diminuire il tempo sprecato dovuto alla dilatazione del clock. Si utilizza l'algoritmo di Tomasulo, algoritmo sviluppato dal ricercatore dell'IBM Robert Tomasulo per permettere l'esecuzione fuori ordine delle istruzioni. La sua prima implementazione si avuta nell'unit in virgola mobile del IBM 360/91. Questo algoritmo si differenzia dallo scoreboarding per l'utilizzo della rinominazione dei registri. Mentre lo scoreboarding risolve le Write-after-Write (WAW) e le Write-afterRead (WAR) con gli stalli, l'algoritmo di Tomasulo permette l'esecuzione di altre istruzioni. Inoltre l'algoritmo di Tomasulo prevede un bus comune per fornire i valori calcolati a tutte le reservation station. L'algoritmo migliora l'esecuzione parallela delle istruzioni e fornisce prestazioni migliori dello scoreboarding. Lo scheduling delle istruzioni dovr prevedere alcune variazioni: 1. FASE DI DECODIFICA: bisogna fare attenzione affinch non vi siano conflitti di dato effettivi, per cui la fase di decodifica viene scissa in due stadi ben distinti: 1. ISSUE: fase in cui listruzione viene decodificata controllando che non vi siano azzardi strutturali, etichettata come istruzione floating point e inserita in una coda distruzioni floating point, una coda flessibile la quale permette di non stallare in caso di conflitti di struttura, in cui le unit di calcolo sono occupate; le istruzioni possono essere anticipate rispetto ad altre se hanno la relativa unit di calcolo disponibile. 2. READ OPERANDI: fase che legge gli operandi, dopo aver verificato che non vi siano conflitti di dato, in maniera tale che gli operandi siano messi in ingresso alle unit senza generare conflitti. 2. FASE DI ESECUZIONE: esecuzione delle istruzioni in base allo scheduling previsto dallalgoritmo di Tomasulo. 3. SCRITTURA DEI RISULTATI: i risultati, attraversi un bus comune, vengono scritti nel banco dei registri e in quelle unit di calcolo che eventualmente aspettano un risultato per svolgere la propria operazione.
Pagina 88
A.A. 2009/2010
ALGORITMO DI TOMASULO Questo algoritmo si basa su dei buffer, sempre interni al processore, chiamati STAZIONI DI PRENOTAZIONE. Questi buffer, presenti in ingresso per ogni elemento floating point del processore, ricevono gli operandi, quando disponibili, dal banco dei registri floating point (FP Registers) (un po come i registri A, B e Imm presenti nel latch ID/EX per il processore intero). Questi dati sono passati alle stazioni di prenotazione solo quando il secondo stadio della fase di decode ha accertato lassenza di eventuali conflitti di dato; viceversa se il registro non ancora disponibile, poich ad esempio registro destinazione di una operazione ancora in fase di esecuzione, non potr andare nella stazione di prenotazione. Quando il registro sar disponibile sul Common Data Bus (CDB) per andare nel banco dei registri, questo verr intercettato per andare direttamente nella stazione di prenotazione che lo attendeva. Se i dati contenuti nella stazione sono completi allora questi vanno in entrata allunit che effettuer la relativa operazione. Analogamente si ragiona per le operazioni di lettura/scrittura della memoria; lesecuzione gestita in maniera tale che i registri interessati siano disponibili per evitare conflitti.
CAMPI DELLE STAZIONI DI PRENOTAZIONI BUSY OP Vj Vk Qj Qk BUSY: campo di un bit che indica se la stazione di prenotazione disponibile. OP: campo che indica loperazione che dovr essere eseguita. Vj: campo che indica dove contenuto il valore del primo registro sorgente. Vk: campo che indica dove contenuto il valore del secondo registro sorgente. Qj: campo che indica se il primo registro sorgente disponibile o meno; assume valore zero quando disponibile; valori diversi da zero per indicare lunit che sta utilizzando il registro. 6. Qk: campo identico a Qj ma si riferisce al secondo registro sorgente. 7. A: campo che contiene lindirizzo sorgente/destinazione per le operazioni di load/store. importante sottolineare che le stazioni di prenotazione per le unit di load conterranno solo i campi Busy, Op ed A, poich il primo operando dellistruzione un registro destinazione, il cui valore verr eventualmente prelevato dal CDB; mentre le stazioni di prenotazione per le unit di store conterranno i campi Busy, Op, Vj, Qj, A, poich loperando dellistruzione un registro sorgente e va per tanto monitorato. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 89 Pietroleonardo Nicola Stroppa Fabio 1. 2. 3. 4. 5.
A.A. 2009/2010
Quindi se si ha la possibilit di caricare una certa istruzione perch lunit di calcolo interessata disponibile, allora si procede con la fase di licenziamento. Listruzione, che stata prelevata e si trova nella coda di istruzioni floating point, dopo aver terminato lo stadio ISSUE, va nella stazione di prenotazione relativa allunit che dovr usare per eseguire la sua operazione, cominciando cos la fase di esecuzione. Se uno o entrambi gli operandi non sono disponibili allora bisogner aspettare che questi lo diventano sul CDB. Infine dopo un certo numero di colpi di clock avviene la scrittura dei risultati e la stazione di prenotazione diventa libera.
Pagina 90
A.A. 2009/2010
Analizziamo ora un esempio di applicazione dellalgorimto di Tomasulo ad un programma, considerando le seguenti caratteristiche del calcolatore: 1. Numero di colpi di clock per le varie operazioni: 1 colpi di clock per operazioni di somma e sottrazione; 10 colpi di clock per operazioni di moltiplicazione; 40 colpi di clock per operazioni di divisione. 2. Numero di unit di calcolo: 3 unit per operazioni di somma/sottrazione; 2 unit per operazioni di moltiplicazione/divisione. 3. Numero di canali per laccesso alla memoria: 3 canali; Il listato del programma il seguente:
LD LD MULTD SUBD DIVD ADDD F6, F2, F0, 34+, R2 45+, R3 F2, F4
F8, F6, F2 F10, F0, F6 F6, F8, F2
facile notare, come questo listato presenti una serie di conflitti di dato. La situazione iniziale si pu schematizzare con la seguente figura, figura che verr riportata pi volte per spiegare passo passo lo svolgimento delle istruzioni: PARTE SUPERIORE - Sulla sinistra sono riportate le istruzioni, indicando il valore j e k. - Al centro vi una tabella di riepilogo, nella quale sono monitorate le varie fasi di ciascuna istruzione: indicando listante (colpo di clock) in cui listruzione viene decodificata (Issue), completata (Comp) e istante in cui avviene la scrittura dei risultati (Result). - Sulla destra vengono monitorate le risorse per permettere le operazioni di load: disponibilit (Busy), indirizzo (Address). PARTE CENTRALE - riportata la situazione delle Stazioni di Prenotazione (Reservation Stations) indicando il tempo per portare a termine loperazione (Time), il nome della stazione (Name), e i vari campi che caratterizzano queste stazioni. PARTE INFERIORE - indicato il colpo di clock effettivo e lo stato dei registri.
Pagina 91

CLOCK 1
A.A. 2009/2010
Viene decodificata la prima istruzione e viene occupata la Load1 con lindirizzo 34+R2. Nel monitor dei registri viene segnalato che F6 destinazione di una operazione di load, per cui non pronto.
CLOCK 2
Viene decodificata la seconda istruzione e viene occupata la Load2 con lindirizzo 45+R3. Nel monitor dei registri viene segnalato che F2 destinazione di una operazione di load, per cui non pronto.
CLOCK 3
Viene decodifica la terza istruzione e viene occupata la Stazione Mult1 completando i campi che la caratterizzano. Busy: Yes Op: MULTD Vj: non disponibile, bisogna attendere il termine della load, infatti il campo Qj segnala che loperando destinazione di una load. Vk: R(F4) Qj: Load2 Per cui il moltiplicatore occupato ma un sorgente non ancora disponibile. Nel monitor dei registri viene segnalato che F0 destinazione di una operazione svolta da un moltiplicatore, per cui non pronto. Contemporaneamente terminata la load della prima istruzione: attenzione terminata laccesso in CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 92
A.A. 2009/2010
memoria, ma non sono ancora disponibili i risultati, ovvero non stato effettuato il Write Back. Per cui viene riportato listante 3 in corrispondenza di Comp.
CLOCK 4
Viene decodifica la quarta istruzione e viene occupata la Stazione Add1 completando i campi che la caratterizzano. Busy: Yes Op: SUBD Vj: M(A1) Vk: non disponibile, bisogna attendere il termine della load, infatti il campo Qk segnala che loperando destinazione di una load. Qk: Load2 Per cui il sommatore occupato ma un sorgente non ancora disponibile. Nel monitor dei registri viene segnalato che F8 destinazione di una operazione svolta da un sommatore, per cui non pronto. Contemporaneamente terminata la load della seconda istruzione: identico discorso del caso precedente; per cui viene riportato listante 4 in corrispondenza di Comp. Contemporaneamente sono disponibili i risultati della prima load; per cui viene riportato listante 4 in corrispondenza di Result e nel monitor dei registri viene segnalato che F6 disponibile in M(A1) per cui pronto.
CLOCK 5
Viene decodifica la quinta istruzione e viene occupata la Stazione Mult2 completando i campi che la caratterizzano. Busy: Yes Op: DIVD Vj: non disponibile, bisogna attendere il termine della operazione svolta dal moltiplicatore, infatti il campo Qj segnala che loperando destinazione di una operazione svolta da un moltiplicatore. Vk: M(A1) Qj: Mult1 Per cui il moltiplicatore occupato ma un sorgente non ancora disponibile. Nel monitor dei registri viene segnalato che F10 destinazione di una operazione svolta da un moltiplicatore, per cui non pronto. Contemporaneamente sono disonibili i risultati della seconda load; per cui viene riportato listante 5 in corrispondenza di Result e nel monitor dei registri viene segnalato che F2 disponibile in M(A2) per cui pronto.
Pagina 93
A.A. 2009/2010
Tutte le stazioni (Add1 & Mult1) che erano in attesa di usare F2 possono mandare in ingresso alle rispettive unit di calcolo i sorgenti per effettuare loperazione indicata in Op. Le operazioni di calcolo potranno cominciare i rispettivi colpi di clock mancanti alla conclusione sono riportati in corrispondenza del campo Time.
CLOCK 6
Viene decodifica la sesta istruzione e viene occupata la Stazione Add2 completando i campi che la caratterizzano. Busy: Yes Op: ADDD Vj: non disponibile, bisogna attendere il termine della operazione svolta dal sommatore, infatti il campo Qj segnala che loperando destinazione di una operazione svolta da un sommatore. Vk: M(A2) Qj: Add1 Per cui il sommatore occupato ma un sorgente non ancora disponibile. Nel monitor dei registri viene segnalato che F6 destinazione di una operazione svolta da un sommatore, per cui non pronto. Vengono decrementati i valori presenti in corrispondenza del campo Timer.
CLOCK 7
Termina listruzione SUBD; i risultati non sono ancora disponibili, per cui viene riportato listante 7 in corrispondenza di Comp. Vengono decrementati i valori presenti in corrispondenza del campo Timer.
Pagina 94

CLOCK 8
A.A. 2009/2010
Sono disponibili i risultati della SUBD; per cui viene riportato listante 8 in corrispondenza di Result e nel monitor dei registri viene segnalato che F8 disponibile in M-M per cui pronto. Viene decrementato il valore presente in corrispondenza del campo Timer della Mult1. Tutte le stazioni (Add2) che erano in attesa di usare F8 possono mandare in ingresso alle rispettive unit di calcolo i sorgenti per effettuare loperazione indicata in Op. Le operazioni di calcolo potranno cominciare i rispettivi colpi di clock mancanti alla conclusione sono riportati in corrispondenza del campo Time.
CLOCK 9
La situazione resta invariata. Vengono decrementati i valori presenti in corrispondenza del campo Timer.
CLOCK 10
Termina listruzione ADDD; i risultati non sono ancora disponibili, per cui viene riportato listante 10 in corrispondenza di Comp. Vengono decrementati i valori presenti in corrispondenza del campo Timer.
Pagina 95

CLOCK 11
A.A. 2009/2010
Sono disponibili i risultati della ADDD; per cui viene riportato listante 11 in corrispondenza di Result e nel monitor dei registri viene segnalato che F6 disponibile in M-M+M per cui pronto. Viene decrementato il valore presente in corrispondenza del campo Timer della Mult1.
CLOCK 12 13 14
La situazione resta invariata; procede loperazione svolta da Mult1. Vengono decrementati i valori presenti in corrispondenza del campo Timer.
CLOCK 15
Termina listruzione MULTD; i risultati non sono ancora disponibili, per cui viene riportato listante 15 in corrispondenza di Comp.
CLOCK 16
Sono disponibili i risultati della MULTD; per cui viene riportato listante 16 in corrispondenza di Result e nel monitor dei registri viene segnalato che F0 disponibile in M*F4 per cui pronto. Tutte le stazioni (Mult2) che erano in attesa di usare F0 possono mandare in ingresso alle rispettive unit di calcolo i sorgenti per effettuare loperazione indicata in Op. Le operazioni di calcolo potranno cominciare i rispettivi colpi di clock mancanti alla conclusione sono riportati in corrispondenza del campo Time. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 96

CLOCK 17 55
A.A. 2009/2010
La situazione resta invariata; procede loperazione svolta da Mult2. Vengono decrementati i valori presenti in corrispondenza del campo Timer.
CLOCK 56
Termina listruzione DIVD; i risultati non sono ancora disponibili, per cui viene riportato listante 56 in corrispondenza di Comp.
CLOCK 57
Sono disponibili i risultati della DIVD; per cui viene riportato listante 57 in corrispondenza di Result e nel monitor dei registri viene segnalato che F10 disponibile in Result per cui pronto.
Questo programma termina dopo 57 colpi di clock. Si pu notare come il licenziamento avviene in maniera ordinata; lesecuzione e il termine delle istruzioni del tutto imprevedibile, ossia FUORIORDINE dal punto di vista temporale, ma comunque in ordine dal punto di vista logico.
Pagina 97
A.A. 2009/2010
Per concludere si possono quindi mettere in evidenza i vantaggi e gli svantaggi derivanti dalluso di questo algoritmo;
VANTAGGI 1. Eliminazione degli stalli dovuti agli azzardi di tipo WAW e WAR; 2. Se pi istruzioni attendono uno stesso risultato e per esempio listruzione ha disponibile laltro operando, queste istruzioni possono accedere simultaneamente sul CDB per prelevare il risultato senza attendere la scrittura nel registro;
SVANTAGGI 1. Maggiore complessit; 2. Problema legato alle memorie associative, ossia quelle memorie che vengono utilizzate in funzione del contenuto delle memorie stesse, cio si accede alla memoria prelevando i dati fornendo alla memoria stessa informazioni sui dati e non sui loro indirizzi; queste memorie sono richieste per interfacciare le stazioni di prenotazione con il CDB; 3. Accesso multiplo al CDB, poich esso deve servire pi unit contemporaneamente, per cui questo limita le performance; 4. La gestione delle istruzioni fuoriordine complica la gestione degli interrupt.
Pagina 98
A.A. 2009/2010
PARTE QUARTA
PARTE QUARTA ALTRI TIPI DI PROCESSORE

PROCESSORI VLIW PROCESSORI SUPERSCALARI PROCESSORI VETTORIALI MULTICORE
Pagina 99

PROCESSORI VLIW
A.A. 2009/2010
I processori VLIW, acronimo di Very Long Istruction Word, permettono di accedere alla memoria istruzioni prelevando pi istruzioni in un solo colpo di clock; se queste istruzioni usano unit di calcolo distinte, allora possibile farle partire contemporaneamente a gruppi. Ovviamente questa logica richiede una memoria tale da poter conferire in un colpo di clock unistruzione lunga per esempio 128 bit (32 4 ). Il principale vantaggio che un istruzione cos grande va a codificare istruzioni diverse, le quali richiedono unit diverse; listruzione VLIW scompattata in tanti campi quanti sono le unit di calcolo del processore: per cui listruzione VLIW codifica un certo numero distruzioni che prevedono luso di unit funzionali distinte ( chiaro che non vi nessun vantaggio nel prelevare pi istruzioni che usano la stessa unit di calcolo). Quindi, se listruzione VLIW da 128 bit il compilatore codifica unistruzione molto lunga che al suo interno spacchettata in 4 campi da 32 bit, ciascuno dei quali contiene unistruzione particolare. ISTRUZIONE VLIW DA 128 bit: 32 bit
UNITA 1
32 bit
UNITA 2
32 bit
UNITA 3
32 bit
UNITA 4
In ogni campo vi sar unistruzione da 32 bit associata ad una specifica unit di calcolo; il compilatore si preoccupa di scrivere nei campi opportuni le istruzioni. Se in un programma non ci sono istruzioni che fanno uso di una unit funzionale, nel relativo campo verr posta la dicitura NO-OP. Quindi teoricamente con una istruzione VLIW si pu avere lavvio simultaneo di N istruzioni scalari, dove N il numero di unit presenti; per se il compilatore non riesce a gestire in maniera efficiente questa logica, sia per mancanza distruzioni che usano unit funzionali particolari e sia perch ci sono troppe istruzioni che usano una stessa unit, allora questo processore comincia a perdere prestazioni. Il compilatore per cercare di gestire efficientemente il tutto usa tecniche particolari quali, ad esempio, la tecnica dello srotolamento del loop. Si consideri il seguente esempio: Il processore VLIW possiede le seguenti caratteristiche: 2 unit per laccesso a memoria; 2 unit per operazioni FP; 1 unit per operazioni intere e branch; Memoria con banda passante da 160 bit. Per cui essendo 5 le unit funzionali, e la banda passante da 160 bit listruzione VLIW sar costituita da 5 campi, ciascuno dei quali di 32 bit: 32 bit
UNITA ACC. MEM. 1
32 bit
UNITA ACC. MEM. 2
32 bit
UNITA FP 1
32 bit
UNITA FP 2
32 bit
UNITA INTERA/BRANC H
Pagina 100
A.A. 2009/2010
Il listato del programma gi ottimizzato, con la tecnica dello srotolamento del loop eseguita per sette volte, il seguente:
1 LOOP: 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 L.D L.D L.D L.D L.D L.D L.D ADD.D ADD.D ADD.D ADD.D ADD.D ADD.D ADD.D S.D S.D S.D S.D S.D S.D DSUBUI BNEZ S.D F0,0(R1) F6,-8(R1) F10,-16(R1) F14,-24(R1) F18,-32(R1) F22,-40(R1) F26,-48(R1) F4,F0,F2 F8,F6,F2 F12,F10,F2 F16,F14,F2 F20,F18,F2 F24,F22,F2 F28,F26,F2 0(R1),F4 -8(R1),F8 -16(R1),F12 -24(R1),F16 -32(R1),F20 -40(R1),F24 R1,R1,#56 R1,LOOP 8(R1),F28
; 8-56 = -48 per cui S.D -48(R1),F28
Brevemente questo programma somma gli elementi di un vettore, memorizzato a partire da R1, con una costante memorizzata in F2. Riempendo i campi con logica, per ogni singolo colpo di clock, dellistruzione VLIW si ottiene la seguente situazione:
Si nota come alcune VLIW hanno due o tre campi NO OP. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 101 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
possibile ottimizzare ancora di pi il codice spostando la BNEZ al colpo di clock 8, evitando cos lo stallo; questa ottimizzazione richiede anche la modifica logica di altre istruzioni. Nonostante in questo caso unistruzione VLIW permeterebbe di eseguire 5 istruzioni contemporaneamente, si ha solo una media di 2,5 istruzioni per colpo di clock; per cui questo processore starebbe lavorando con una efficienza del 50%, percentuale che dipende quindi dal programma e dal compilatore. Con un processore scalare che svolge le 23 istruzioni in pipeline, si sarebbero ottenuti sette risultati in 23 colpi di clock, oppure 3.3 colpi di clock per ogni iterazione; mentre con il processore VLIW che esegue le 23 istruzioni in 9 colpi di clock, si ottengono sette risultati in 9 colpi di clock, oppure 1.3 colpi di clock per ogni iterazione, quindi vi unaccelerazione di circa il 60%. Concludendo, questo tipo di processore richiede: Una Control Unit non molto complessa rispetto a quella presente nei processori scalari per gestire i floating point: il compilatore che organizza le istruzioni; Un compilatore diverso, capace di gestire questo tipo di assemblamento delle istruzioni; Memoria con una banda maggiore, per permettere di prelevare in un unico colpo di clock unistruzione costiuita da un numero grande di bit; Incremento del codice, dovuto allo strotolamento.
Pagina 102

PROCESSORI SUPERSCALARI
A.A. 2009/2010
Il processore SUPERSCALARE sfrutta, come il VLIW, il fatto che le varie unit funzionali del processore sono ridondanti se pensate a livello della singola istruzione; nei processori scalari se unistruzione sta usando lALU intera non pu esserci una istruzione che vada ad occupare ed ad usare lALU FP. Nei processori superscalari questo parallelismo possibile: UNITA INTERA
MEM. ISTR.
Istruzione intera
Istruzione Floating point
MEM. DATI
UNITA FLOATING POINT
Per cui vi un potenziamento della memoria che prevede la lettura parallela di due istruzioni, una intera ed una floating point; quindi queste istruzioni vengono avviate nella pipeline in contemporanea, poich ognuna andr ad utilizzare lunit di cui necessit. Nel migliore delle ipotesi questo processore permette lavvio di due istruzioni in contemporanea. Il compilatore dovr preoccuparsi di scrivere il programma in maniera tale che le istruzioni siano in coppia, una intera e una floating point, per ottenere una pipeline ideale di questo tipo: Quando vi la fase di fetch saranno letti dalla memoria 64 bit, due istruzioni, sperando che i primi 32 siano relativi ad unistruzione intera e i restanti 32 relativi ad una istruzione floating point. Dopo il prelievo, il Program Counter dovr essere incrementato di 8. Se la coppia distruzioni dello stesso tipo, allora chiaramente, solo la prima istruzione verr processata e laltra verr avviata al colpo di clock successivo. Per possibile prendere listruzione in attesa in coppia con la successiva, sfasando cos tutte le successive coppie; in questo caso il PC dovr essere incrementato di 4 e non di 8.
CC 1 CC 2 CC 3 CC 4 CC 5
Concludendo, questo tipo di processore richiede: Una Control Unit non molto complessa rispetto a quella presente nei processori scalari per gestire i floating point: il compilatore che organizza le istruzioni; Un compilatore diverso, capace di gestire questo tipo di assemblamento delle istruzioni; Memoria con una banda maggiore, per permettere di prelevare in un unico colpo di clock due istruzioni;
Pagina 103

PROCESSORI VETTORIALI
A.A. 2009/2010
Il processore VETTORIALE nasce dallidea di codificare con unistruzione classica una grande mole di lavoro. Questo realizzato estendendo il set delle istruzioni con istruzioni vettoriali, le quali hanno come sorgenti e destinazioni dei vettori. Nei casi di uso dei vettori, cosa che spesso capita nei programmi, invece di avere dei loop, con una sola istruzione vettoriale possibile codificare una determinata operazione (ovviamente nellipotesi che i vettori da trattare abbiano un numero di elementi al massimo pari al numero di elementi che i registri vettoriali possono contenere). Per cui in sinstesi le idee alla base dei processori vettoriali sono: Codifica delle istruzioni per le operazioni vettoriali; Dotare il processore di unit che operino efficientemente con i vettori, cio, ad esempio, lunit di accesso alla memoria deve saper efficientemente prelevare i vettori dalla memoria (la memoria ricever dallALU solo lindirizzo del primo elemento, poi essa stessa dovr automaticamente calcolarsi lindirizzi degli altri elementi); Registri vettoriali idonei in grado di contenere dei vettori: questi registri hanno una dimensione ben definita (decisa in fase di progettazione), per cui le dimensioni dei vettori devono rientrare in quelle dei registri. Per cui quando si devono svolgere operazioni fra vettori, attraverso una codifica molto compatta, si ha la possibilit di rendere esplicita una quantit di calcolo abbastanza ampia, che tra laltro opera su dati che non creano conflitto fra di loro. Di conseguenza si definiscono operazioni vettoriali tutte quelle operazioni che non generano conflitti di dato (somma, sottrazione, moltiplicazione, ecc.), mentre operazioni come media o determinante di una matrice non sono gestite dalla CPU come operazione vettoriale. chiaro che accedere a dati vettoriali richiede una unit di memoria dati ottimizzata; i dati vettoriali devono essere organizzati in una determinata maniera. Il prelievo di unistruzione vettoriale uguale al prelievo di unistruzione classica, poich si accede alla memoria istruzioni; mentre il prelievo dalla memoria dati deve essere ottimizzato. Una esempio distruzione vettoriale il seguente:
ADDV V1,V2,V3
Listruzione ADD seguita dalla lettera V la quale indica che listruzione si riferisce ad una operazione vettoriale. V1,V2,V3 sono registri vettoriali; la CPU avr necessariamente dei registri vettoriali i quali sono costituiti da un numero fisso di registri scalari logicamente uniti, identificati con un unico nome. Per cui i registri vettoriali hanno una ampiezza definita. Bisogna per fare attenzione alle dimensioni da scegliere in fase di progettazione; aumentando/diminuendo il numero dei registri vettoriali e quindi di conseguenza diminuendo/aumentando la dimensione del singolo registro aumentano/diminuiscono i bit utili alla identificazione dei registri allinterno dellistruzione. Inoltre diminuire la dimensione del singolo registro, comporterebbe dei problemi quando si devono gestire vettori con dimensioni maggiori rispetto alla lunghezza dei registri vettoriali, problema che verr comunque gestito, come vederemo in seguito, con una scomposizione in tanti pi piccoli problemi vettoriali in cui i vettori hanno dimensioni minori. Analogalmente se si aumenta la lunghezza dei singoli registri molto probabile che parte del registro rimanga inutilizzata quando si opera con vettori di dimensioni ridotte. Per cui chiaro che bisogna trovare
Pagina 104
A.A. 2009/2010
un compromesso; nel caso preso in esame, la CPU VETTORIALE ha i registri vettoriali costituti da 64 elementi. Di seguito riportata la tabella di alcune tipiche istruzioni vettoriali.
OPERAZIONI DI LOAD E STORE Loperazione di caricamento in un registro vettoriale da memoria definita con la seguente sintassi:
LV [reg],[ind] [reg]: registro in cui si andr ad ospitare il vettore; [ind]: indirizzo da cui parte il vettore in memoria;
Dulamente loperazione di salvataggio in memoria del contenuto di un registro vettoriale definita con la seguente sintassi:
SV [ind],[reg]
Per entrambe le operazioni messo a disposizione un dispositivo simile al noto DMA (Direct Memory Access), il quale ricevuto lindirizzo del primo elemento del vettore calcola gli indirizzi dei restanti elementi; questo dispositivo interno alla memoria dati.
Pagina 105
A.A. 2009/2010
Per cui, grazie a questo dispositivo, possibile avere al termine della fase MEM dellistruzione LOADV il primo elemento del vettore nella corrispondente cella del registro destinazione; per ogni colpo di clock successivo si avr a disposizione, nella specifica cella del registro destinazione, lelemento successivo del vettore. Quindi evidente che se la memoria consente una banda passante maggiore che permette, ad esempio, la lettura di due dati in un solo colpo di clock, al termine della fase MEM saranno disponibili, nelle rispettive celle del registro vettoriale destinazione, i primi due elementi del vettore. Sfruttando la disponibilit di alcuni elementi del vettore ancor prima che questo sia completamente caricato nel registro destinazione, possibile poter eseguire istruzionI che devono elaborare gli elementi, come questo esempio:
LOADV V2, 1cc IF 2cc ID IF 3cc EX ID
stallo
4cc MEM EX IF
5cc WB MEM ID IF
6cc WB EX ID
7cc
8cc
9cc
LOADV V3, ADDV V1,V2,V3 STOREV ,V1
MEM EX
WB MEM
WB
(Considerando idealmente che il sommatore abbia una latenza di 1 cc) Listruzione ADDV V1,V2,V3 potr effettuare la somma degli elementi presenti nelle celle dei registri V2,V3 senza dover attendere lintero caricamento del vettore. Lo stesso vale per la STOREV ,V1 che pu cominciare a memorizzare in memoria gli elementi disponibili nelle celle di V1. Attenzione, questo calcolo non viene eseguito in circa 5 colpi di clock; poich per completare lintera operazione bisogna attendere che tutti gli elementi del vettore vengano processati. Per cui il completamento delloperazione richiesta avverr dopo un numero di colpi di clock dipendenti dal numero di elementi che si devono processare. Tutto questo possibile poich, come descritto precedentemente, le unit di calcolo si basano su logica pipeline. Listruzione LVWS I vantaggi che questa CPU offre sono assicurati se gli elementi sono memorizzati in memoria centrale in maniera sequenziale; infatti in memoria i vettori sono allocati in locazioni consecutive. Questo non avviene quando ad esempio si estrae da una matrice un qualsiasi vettore colonna, essendo le matrici generalmente allocate per righe; per questo caso attraverso ununica istruzione si risolve il problema: vi un numero che dir al famoso modulo simile al DMA di quanto deve saltare per accedere allelemento successivo. Listruzione in esame : LVWS (Load Vector With Stride). I registri VLR e MVLR Supponiamo che il vettore da processare sia costituito da un numero di elementi molto inferiore ai 64 che la CPU in esame mette a disposizione. Il caricamento del vettore avverr in un unico registro vettoriale senza nessun tipo di problema, ma con conseguenti elementi inutilizzati; si nota facilmente che processare questo vettore significherebbe far lavorare la CPU anche su elementi che non hanno nessun significato. Per evitare ci la CPU vettoriale ha un registro particolare chiamato VLR (V ector Length Register): questo registro contiene un numero che il compilatore va ad impostare, in maniera trasparente al programmatore, quando deve operare sui registri vettoriali; questo numero equivale alla dimensione del vettore da processare e al massimo pu valere (in questo caso) 64. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 106
A.A. 2009/2010
Le varie operazioni sul vettore procederanno fino a quando si raggiunger un numero di passi pari al contenuto di VLR. Il compilatore deve per conoscere a priori la dimensione dei registri vettoriali per poter impostare il valore di VLR. Questo possibile attraverso il registro MVLR (Max Vector Length Register): questo registro fondamentale per larchitettura vettoriale. Contiene la dimensione massima dei registri vettoriali della CPU; per cui non un registro impostato dal compilatore, ma impostato al momento della produzione del firmware della CPU. Prestazioni Una CPU vettoriale offre quindi ottime prestazioni, quando si processano dati che eseguono operazioni vettoriali, giocando sui diversi fattori: Riduzione drastica del collo di bottiglia provocato dalla memoria istruzioni. A livello del codice, implicitamente, si eliminano i conflitti di dato. Una Control Unit pi semplice. Lunico svantaggio che non sempre si incontrano operazioni vettoriali comuni, ma operazioni che richiedono una complessit diversa per il loro processo.
Pagina 107

ANALISI REALE DELLARCHITETTURA DI UNA CPU VETTORIALE CRAY-1 (1976) Il primo calcolatore basato su architettura vettoriale fu il CRAY-1 (pesante 5,5 tonnelate!) progettato da Seymour Cray nel 1976. Larchitettura di questo calcolatore prevedeva le unit scalari pi una estensione per operazioni vettoriali; per cui il Cray-1 presentava alcune caratteristiche in pi rispetto a precedenti calcolatori: - Unarchitettura per operazioni di load/store; - Registri vettoriali; - Istruzioni vettoriali; - Un sistema di memoria INTERLEAVED che sostituisce a livello dati le memorie cache;
A.A. 2009/2010
Cray-1 (1976)
SCHEMA LOGICO Di seguito riportato lo schema logico dellarchitettura della CPU vettoriale Cray-1. Osserviamo alcune sue caratteristiche: - 8 registri vettoriali da 64 elementi luno [V0V7]; - 8 registri scalari di tipo S [S0S7]; - 8 registri scalari di tipo A [A0A7]; - Buffer da 4 istruzioni; - 3 unit ad aritmentica floating point; - 4 unit ad aritmetica intera; - 2 unit per le operazioni sugli indirizzi; - Registro V.Mask; - Registro V.Lenght;
Si noti che in questa CPU non presente il divisore: questo sostituito dallunit che effettua il reciproco; tramite il moltiplicatore verr eseguita poi loperazione:
1
Sono presenti inoltre due registri importanti per il corretto e efficiente funzionamento dellarchitettura vettoriale; questi registri sono: Registro V.Mask: serve per operazioni condizionate oppure realtive a vettori o matrici sparse, cio quelli in cui la maggior parte dei loro dati sono degli zeri. La CPU impostando corretamente questo registro evita di operare su valori uguali a zero, in modo tale da diventare pi efficiente. Per cui nel set istruzioni sono presenti particolari istruzioni con maschera che operano solo su dati significativi: ad esempio utili per gestire situazioni di overflow provocati da divisione per zero. Il registro V.MASK un registro vettoriale, costituito da MVLR elementi. Registro V.Lenght: equivale al registro VLR.
Pagina 108

IDEE ALLA BASE DELLA ORGANIZZAZIONE VETTORIALE REGISTRI: 16 registri scalari; 8 registri vettoriali da 64 elementi luno; VLR indica da quanti elementi costituito il vettore da processare. OPERAZIONI ARITMETICHE: Avere a disposizioni tante unit funzionali per processare parallelamente ogni elemento del vettore. OPERAZIONI LAOD/STORE: Accesso (load/store) in memoria tramite gli indici BASE e STRIDE, permettendo cos laccesso efficiente a vettori con elementi non contigui, come ad esempio un qualsiasi vettore colonna di una matrice memorizzata in memoria per righe.
A.A. 2009/2010
CODICE VETTORIALE Di seguito riportato un confronto fra il codice implementato per una cpu scalare e un codice implementato per la cpu vettoriale. Si noti come risulta molto pi breve e semplice utilizzare istruzioni vettoriali. Lesempio consiste nelleseguire una somma fra due vettori. CODICE SORGENTE, C CODICE CPU SCALARE CODICE CPU VETTORIALE
LI R4, 64 for (i=0; i<64; i++) C[i] = A[i] + B[i]; loop: L.D F0, 0(R1) L.D F2, 0(R2) ADD.D F4, F2, F0 S.D F4, 0(R3) DADDIU R1, 8 DADDIU R2, 8 DADDIU R3, 8 DSUBIU R4, 1 BNEZ R4, loop LI VLR, 64 LV V1, R1 LV V2, R2
stallo
ADDV.D V3, V1, V2 SV V3, R3
I vantaggi nelluso di un set con istruzioni vettoriali sono molteplici: - Compattezza: poche istruzioni per eseguire diverse operazioni; - Indipendenza implicita dei dati, per cui assenza di conflitti di dati; - Uso delle stesse unit funzionali, per cui non sono necessarie particolari unit di calcolo; - Accesso a registri disgiunti, quindi come avviene per le non vettoriali; - Accesso a blocchi di memoria contigui (stride unitario), oppure saltando (stride noto a priori); - Riduzione drastica del collo di bottiglia con la memoria. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 109 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
ESECUZIONE ARITMETICA DELLE ISTRUZIONI Lunit funzionale che deve eseguire una certa operazione avr una latenza, definita in fase di progettazione, la quale permette di avere il risultato dopo un certo numero di colpi di clock. Organizzandola in maniera tale che le sue unit logiche siano strutturate in pipeline, possibile migliorare il throughput (rendimento, cio la frequenza con cui loggetto in grado di processare i dati) dellunit di calcolo. Sulla base di queste considerazioni chiaro che possibile migliorare di molto le prestazioni della singola unit funzionale e quindi dellintero sistema; i dati saranno disponibili molto pi velocemente. La possibilit di utilizzare questa tecnica garantita perch gli elementi di un vettore sono indipendenti. La figura affianco mostra come viene effettuato il prodotto fra due registri contenti dati vettoriali, attraverso un moltiplicatore a 6 stadi di pipeline. Supponendo una latenza di 6 colpi di clock il primo risultato lo si ottiene appunto dopo 6 cc. Il secondo risultato lo si otterr al cc 7 e cos via. SISTEMA DI MEMORIZZAZIONE DI DATI VETTORIALI NEI REGISTRI VETTORIALI La CPU del Cray-1 disponeva di una memoria a 16 banchi, il cui schema logico riportato di seguito:
Laccesso ai blocchi avviene in maniera molto intuitiva; un sommatore genera lindirizzo del blocco operando sulla base e sullo stride.
ESECUZIONE ISTRUZIONI VETTORIALI Si supponga di effettuare una operazione di somma fra due vettori:
ADDV C,A,B
Si possono distinguere due casi: 1CASO Una unit funzionale pipeline a 3 stadi
2CASO 4 o pi unit funzionale pipeline a 3 stadi
Aumenta il parallelismo, provocando un aumento del throughput del sistema; la latenza della singola unit rimane invariata. Si noti la disposizione con cui gli elementi entrano nelle unit. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 110 Pietroleonardo Nicola Stroppa Fabio

STRUTTURA DELLE UNITA VETTORIALI La struttura delle unit si basa sulla creazione di CORSIE le quali sono organizzate in maniera tale da ottimizzare al meglio loperazione vettoriale da eseguire. Ogni corsia presenta due unit funzionali che operano sui registri organizzati in maniera logica, per ottenere i risultati in modo consecutivo e il pi velocemente possibile. Come gi detto questa organizzazione migliora il throughput del sistema.
A.A. 2009/2010
Di seguito riportata una immagine reale della struttura del T0 Vector Microprocessor del 1995; esso costituito da 16 unit funzionali.
T0 Vector Microprocessor (1995)
DIFFERENZA FRA ARCHITETTURA MEMORIA-MEMORIA E ARCHITETTURA A REGISTRI VETTORIALI I sistemi basati su architettura memoria-memoria (VMMA Vector Memory-Memory Architectures) operano fondamentalmente considerando i vettori residenti in memoria centrale; quindi il prelievo e la scrittura avviene direttamente in memoria centrale. I primi sistemi che si basavano esclusivamente su architettura memoria-memoria sono ad esempio CDC Star-100 (1973) e il TI ASC (1971); la scelta di questa tecnica era dovuta esclusivamente alla indisponibilit di spazio fisico. Per cui il codice di una macchina memoria-memoria di questo tipo:
ADDV C, A, B SUBV D, A, B ;si usano direttamente gli indirizzi
Cray-1 fu il primo sistema ad utilizzare registri vettoriali; questo implica necessariamente un codice diverso, poich bisogna effettuare le operazioni di load e store. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 111
A.A. 2009/2010
possibile quindi evidenziare le differenze fra queste due tipologie di macchine vettoriali: I sistemi VMMA richiedono una banda maggiore di memoria, perch ogni operando deve essere sempre letto dalla memoria anche se precedentemente utilizzato, problema non presente con lutilizzo di registri vettoriali. Aumento del rischio di dipendenza fra dati nei sistemi VMMA. I sistemi VMMA incorrono in una maggiore latenza di avvio. VETTORIZZAZIONE AUTOMATICA DEL CODICE Si osservi adesso come un codice sorgente, per semplicit consideriamo la somma di due vettori, viene processato da una macchina con istruzioni scalari e da una con istruzioni vettoriali, e quindi i tempi di esecuzione delle singole iterazioni. CODICE SORGENTE
for (i=0; i < N; i++) C[i] = A[i] + B[i];
ISTRUZIONI SCALARI SEQUENZIALI
Ipotizzando la latenza pari a un colpo di clock per ogni singola unit.
ISTRUZIONI VETTORIZZATE
La vettorizzazione permette un parallelismo maggiore e quindi per lo stesso numero di colpi di clock una cpu vettoriale riesce a processare pi dati.
GESTIONE DI VETTORI CON DIMENSIONE SUPERIORE A MVLR VECTOR STRIPMINING Vediamo ora come vengono gestiti i casi in cui il vettore da processare costituito da un numero di elementi maggiori del valore impostato in Max Vector Length Register. Questo tipo di problema viene affrontato suddividendo il vettore in un certo numero di sottovettori; ciascuno di questi sottovettori verr considerato come un vettore di MVLR elementi o comunque di un numero minore. Il vettore viene suddiviso quindi in N sottovettori: per rendere il pi efficiente possibile il sistema, N-1 sottovettori avranno la dimensione massima possibile, consentita dai registri vettoriali, quindi MVLR, mentre un vettore sar costituito dagli eventuali elementi residui. facile capire che se la dimensione del vettore divisibile per MVLR non vi saranno sottovettori residui e quindi la gestione si semplifica; se la dimensione del vettore non divisibile per MVLR, allora bisogner gestire al meglio la presenza del vettore residuo.
Pagina 112
A.A. 2009/2010
Risulta opportuno che il primo sottovettore che deve essere processato sia il sottovettore residuo; in questo modo al di fuori del loop viene processato il residuo e poi dopo aver modificato VLR si procede con i restanti vettori. Questa situazione viene implementata con le seguenti istruzioni:
for (i=0; i<N; i++) C[i] = A[i]+B[i]; 1 ANDI R1, N, 63 # N mod 64
2 MTC1 VLR, R1 # Do remainder 3 loop: LV V1, RA 4 DSLL R2, R1, 3 # Multiply by 8 5 DADDU RA, RA, R2 # Bump pointer 6 7 8 9 10 11 12 13 14 LV V2, RB DADDU RB, RB, R2 ADDV.D V3, V1, V2 SV V3, RC DADDU RC, RC, R2 DSUBU N, N, R1 LI R1, 64 MTC1 VLR, R1 BGTZ N, loop
# Subtract elements # Reset full length # Any more to do?
Analizziamo ora alcune istruzioni, fondamentali per gestire la presenza del vettore Remainder. ISTRUZIONE 1: il valore del residuo viene calcolato attraverso listruzione:
ANDI R1, N, 63
Un residuo di una divisione per un divisore che potenza di 2, come 64, si fa semplicemente andando a considerare gli ultimi n bit (2 ). Per cui essendo 64 = 26 si considerano gli ultimi 6 bit della dimensione del vettore, per ottenere il resto della divisione. Per esempio N = 187: (187)10 = (10111011)2 - Bisogna considerare gli ultimi 6 bit, quindi in AND con 63; 63 10 = 00111111 2 Per cui risulta: (00111011)2 = (59)10 Quindi se la dimensione del vettore da processare di 187 elementi, ci sar un vettore Remainder da 59 elementi e
191 64
2, quindi 2 vettori da 64 elementi.
ISTRUZIONE 2: limpostazione di VLR, essendo un registro speciale, avviene tramite unistruzione speciale:
MTC1 VLR, R1
ISTRUZIONE 4: shift logico verso sinistra di 3 posti, moltiplicando cos per 8 il contenuto di R1, ossia il valore della dimensione del vettore al momento processato;
DSLL R2, R1, 3
In questo modo in R2 contenuto il valore della dimensione in memoria del sottovettore che si sta processando e di conseguenza R2 conterr il valore del salto da effettuare per accedere al sottovettore successivo. Le istruzioni 5 7 10 aggiorneranno i rispettivi indirizzi per accedere al successivo sottovettore. ISTRUZIONE 14: controlla se il valore di N maggiore di zero: BGTZ N, loop Pagina 113 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
PARALLELISMO DELLE ISTRUZIONI VETTORIALI Si supponga una unit costituita 8 corsie e 32 elementi per ogni registro vettoriale, e si ipotizzi idealmente che ogni unit abbia una latenza di 1 colpo di clock; possibile sovrapporre lesecuzione di pi istruzioni vettoriali in questo modo: (considerando lesecuzione su un singolo vettore)
Essendo disponibili 8 corsie verranno caricate nel registro vettoriale i primi 8 elementi del vettore; inoltre essendo le unit pipeline, al colpo di clock successivo (2) si potranno caricare altri 8 elementi e in parallelo eseguire con il moltiplicatore, come in questo esempio, listruzione successiva che processer i dati caricati al colpo di clock 1:
Per cui al colpo di clock successivo (3) saranno caricati altri 8 elementi, e in parallelo oltre al moltiplicatore, si potranno processare, con ad esempio un sommatore, i dati del colpo di clock precedente (2); per cui si ottiene la seguente situazione:
In questo caso si sta eseguendo in parallelo, load-mul-add; Essendo i registri costituiti da 32 elementi, e le corsie disponibili sono 8, la prima istruzione di load terminer al 4 colpo di clock; per cui al 5 cc lunit che effettua operazioni di load/store sar disponibile per eventuali altre load/store; quindi possibile in questo modo avere istruzioni parallele: la seguente figura evidenzia il parallelismo che si ottiene.
In questo modo si completano 6 istruzioni in soli 10 colpi di clock. Ogni istruzione si completa in 4 colpi di clock. Quindi nei casi in cui si ha il massimo parallelismo, cio tutte le unit stanno operando, si eseguono 24 operazioni (8 load 8 mul 8 add). Per cui sono evidenti i vantaggi che porta questo tipo di soluzione. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 114 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
PENALITA DI AVVIO DELLE CPU VETTORIALI Le componenti che incidono sulla penalit di avvio nelle cpu vettoriali sono essenzialmente due: 1. Latenza delle unit funzionali, e quindi il tempo che trascorre per ottenere un risultato; 2. Tempo morto o tempo di recupero, ossia il tempo che trascorre prima che un altro vettore possa utilizzare lunit funzionale, se questa unica e occupata. Per chiarire il concetto di tempo morto si consideri la seguente figura: Unipotetica unit funzionale occupata nel processore da un certo vettore (e potr essere impegnata da un altro vettore solo quando avr terminato di processato il primo vettore); essendo questa unit organizzata in pipeline solamente dopo un certo numero di colpi di clock, pari alla sua latenza, dar in uscita il primo risultato e successivamente tutti gli altri risultati, per ogni colpo di clock successivo. Essendo questa unit unica nel sistema, se un secondo vettore deve essere processato, questo deve attendere che il primo vettore completi lintera operazione e che liberi quindi lunit funzionale. Il tempo che intercorre si definisce tempo morto (Dead Time). Per cui questo tempo morto dipende da due fattori: 1. La dimensione del vettore. 2. Il numero di unit funzionali presenti e quindi il numero di corsie. GESTIONE DELLE CONDIZIONI USO DEL REGISTRO V.MASK ISTRUZIONI MASCHERATE Lobiettivo quello di gestire, attraverso la vettorizzazione, situazioni in cui sono presenti condizioni sugli elementi del vettore. Consideriamo lesempio:
for (i=0; i<N; i++) if (A[i]>0) then A[i] = B[i];
Si vuole sostituire tutti gli elementi del vettore A che sono maggiori di zero, con gli elementi di B. Ad ogni elemento del registro vettoriale viene associato, tramite una particolare istruzione, un elemento del registro V.MASK; gli elementi del registro V.MASK faranno da flag per gli elementi del vettore. Il flag permette di identificare se quellelemento da processare oppure no. Per fare questo bisogna impostare, come gi detto, il registro V.MASK tramite listruzione SGTVS:
SGTVS.D V1, F0
Pagina 115
A.A. 2009/2010
Questa istruzione confronta gli elementi del vettore V1 con uno scalare e, se la condizione verificata, imposta il relativo campo del V.MASK associato al relativo elemento del vettore. Quindi per tutti gli elementi che verificano la condizione verr impostato il flag a 1 per indicare che solo quelli saranno processati successivamente. Quindi per lesempio considerato si ha il seguente codice:
CVM # Turn on all elements LV V1,R1 # Load entire A vector SGTVS.D V1, F0 # Set bits in mask register where A>0 LV V1, R2 # Load B vector into A under mask SV R1,V1 # Store A back to memory under mask
Per cui con lutilizzo delle istruzioni mascherate possibile ulteriormente ottimizzare lesecuzione, e quindi ridurre i tempi; gli elementi verranno processati in questa maniera:
evidente che la verifica del flag relativo ad ogni elemento deve essere effettuata a monte dellunit funzionale, in modo tale da poter processare solo gli elementi con flag a 1.
Temporary Register
Loperazione di mascheramento quindi richiede una fase di compressione dei dati, cio i soli dati processati vengono temporaneamente memorizzati in un registro vettoriale, seguita da un fase di espansione in cui i dati vengono memorizzati nelle relative posizioni del registro destinazione.
Pagina 116
A.A. 2009/2010
RIDUZIONE A OPERAZIONI SCALARI Ci sono operazioni con vettori che non sono definite operazioni vettoriali, poich creano dipendenza tra i dati e quindi conflitti nellesecuzione. possibile ridurre queste operazioni ad operazioni di tipo vettoriale; questa tecnica permette dunque di risolvere questo tipo di problema. Consideriamo questa situazione:
sum = 0; for (i=0; i<N; i++) sum += A[i]; # Loop-carried dependence on sum
Questo codice somma gli elementi del vettore stesso creando per una dipendenza di dati. Ridurre questa situazione a operazioni vettoriali significa dividere a met il vettore e trattarlo come due vettori distinti, per poter eseguire le operazioni vettoriali possibili. Quindi si sommano i rispettivi elementi per ottenere un terzo vettore; a sua volta questo vettore viene diviso a met per operare ancora sui suoi elementi. Quando il numero degli elementi si riduce, diventa molto piccolo o dispari, allora si trattano gli elementi del vettore come degli scalari. Schematicamente la situazione la seguente:
VETTORE A VETTORE A1
4 12 44 10
2
4 12
VETTORE B SCALARE A
48
+
44 10
VETTORE A2
=
22
48
sum
+
22
SCALARE B
70
Pagina 117
A.A. 2009/2010
ESERCIZIO Ottimizzare un loop che calcoli: Y=aX+bY (X e Y vettori, a e b scalari) per una CPU VETTORIALE, cercando di ridurre al minimo il numero di stalli. Essendo la dimensione dei registri vettoriali da 64 elementi, ogni vettore sar spezzettato in un vettore Remainder da 32 elementi e in un vettore da 64 elementi. La situazione si pu riassumere con la seguente figura:
Supponiamo: R1, R2: registri contenenti gli indirizzi dei due vettori, A e B; R3: registro contenente la dimensione (96) dei vettori; R29, R30: registri contenenti rispettivamente gli scalari a e b. Il codice non ottimizzato il seguente:
1 ANDI R4, R3, 63 2 MTC1 VLR, R4 3 LOOP: LV.D V1, R1 4 DSLL R5, R4, 3 5 DADDU R1, R1, R5 6 LV.D V2, R2 7 8 9 10 11 12 13 14 15 DADDU R2, R2, R5 MULTSV.D V1, V1, R29 MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R2 DADD R3, R3, -R4 LI R4, 64 MTC1 VLR, R4 BGTZ R3, LOOP
Pagina 118
A.A. 2009/2010
OTTIMIZZAZIONE Prima di tutto possibile, sfruttando la forma base+spiazzamento, utilizzare un unico registro per lincremento dei registri R1 e R2 evitando cos di utilizzare due istruzioni (5 e 7). Il registro base conterr lindirizzo del primo elemento del vettore, quindi diverso per ogni vettore, mentre lo spiazzamento, comune per tutti i vettori, conterr il valore del salto per accedere al blocco di dati successivo. Per cui possibile riscrivere le load/store nella seguente maniera: La sintassi da seguire : LV.D dest, offset(base)
LV.D V1, R7(R1) LV.D V2, R7(R2) SV.D V2, R7(R2)
Dove R7 il registro contenente lo spiazzamento; per cui baster incrementarlo per accedere al blocco di dati successivo; per cui R7 lunico indice che opera allinterno del loop. In questo modo possibile anche escludere il registro R3 che precedentemente faceva da contatore, ed usare R7 come registro su cui effettuare il controllo. Si ricordi che nel caso scalare, il problema veniva affrontato processando il vettore a partire dallultimo elemento fino ad arrivare al primo, con un decremento dellindice di 8 byte. Nel caso del processore vettoriale, lindice non punter allultimo elemento, ma al primo elemento dellultimo sottovettore, che, per una migliore implementazione, il vettore remainder; per cui lindice ad ogni iterazione verr decrementato di 64 elementi, ossia di 64 8 = 512 byte. Il decremento, sottoforma distruzione, il seguente:
DADDI R7, R7, #-512
Per chiarire quando detto si consideri il seguente esempio: Si supponga un vettore di 140 elementi; questo vettore sar diviso in due sottovettori da 64 elementi e un sottovettore da 12 elementi. Considerando il sottovettore remainder come ultimo blocco, lindice punter al suo primo elemento, per cui attraverso il decremento di 512 byte si avr accesso al primo elemento del secondo sottoblocco e successivamente, con un ulteriore decremento al primo elemento del primo sottoblocco. Le seguenti figure chiariscono la scelta di porre per ultimo il sottovettore remainder.
Lindice punter al primo elemento del primo sottoblocco Lindice punter al primo elemento del R7 secondo sottoblocco Lindice punter al primo elemento R7 dellultimo sottoblocco
R7
Per posizionare R7 bisogna calcolare lindirizzo del primo elemento del sottovettore remainder. Questo possibile attraverso loperazione: 8.
Pagina 119

Fatte queste considerazioni il codice parzialmente ottimizzato il seguente:
1 ANDI R4, R3, 63 2 MTC1 VLR, R4 3 DSUBI R7, R3, R4 4 DMULI R7, R7, #8 5 LOOP: LV.D V1, R7(R1) 6 7 8 9 10 11 12 13 MULTSV.D V1, V1, R29 LV.D V2, R7(R2) MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R7(R2) DADDI R7, R7, #-512 MTC1 VLR, #64 BGEZ R7, LOOP
A.A. 2009/2010
Adesso vediamo come possibile schedulare meglio il loop per eliminare gli eventuali stalli presenti. Dopo le due load ci sar uno stallo con le successive operazioni di moltiplicazione che utilizzano come sorgenti i registri destinazione delle load. Listruzione BGEZ provoca uno stallo: sposto listruzione MTC1 VLR, #64 nel delay slot sotto alla BCEZ. Per concludere il codice ottimizzato il seguente (considerando unitaria la latenza di ciascuna unit funzionale):
1 ANDI R4, R3, 63 2 DSUBI R7, R3, R4 3 MTC1 VLR, R4 4 DMULI R7, R7, #8 5 LOOP: LV.D V1, R7(R1) 6 7 8 9 10 11 12 13 LV.D V2, R7(R2) MULTSV.D V1, V1, R29 MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R7(R2) DADDI R7, R7, #-512 BCEZ R7, LOOP MTC1 VLR, #64
Pagina 120
A.A. 2009/2010
Analizziamo ora i diagrammi temporali delle istruzioni fondamentali per loperazione da effettuare; si consideri per semplicit che la cpu vettoriale sia ad una sola corsia e che la banda passante della memoria dati sia di tre dati per colpo di clock, per cui possibile effettuare tre accessi in memoria. Inoltre si consideri la presenza di due moltiplicatori con una latenza di 4 colpi di clock, per cui dopo 4 cc il moltiplicatore mette a disposizione il primo risultato; due sommatori con una latenza di 2 colpi di clock. LEGENDA Disponibilit 1 elemento: Disponibilit 2 elemento: Disponibilit elementi successivi: Disponibilit ULTIMO elemento:
Per il seguente diagramma VLR impostato al valore 64 COLPI DI CLOCK 1 2 3 4 5 6 7 ISTRUZIONI 8 9 10 11 12 13 14
. 6 6 . 7 8 7 7 7 7 7 2 3 4 5 6
LV.D V1, R7(R1) LV.D V2, R7(R2) MULTSV.D V1, V1, R29 MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R7(R2)
IF
ID IF
EX ID IF
MEM EX ID IF
WB MEM ID IF ID IF ID WB EX EX STALLO EX MEM WB MEM EX STALLO WB MEM WB

MEM
WB
Bisogna quindi aggiungere le ulteriori istruzioni di gestione; il procedimento da seguire analogo a quanto appena fatto. Per cui si completa lintera operazione Y=aX+bY con vettori da 64 elementi dopo 76 colpi di clock, senza contare le istruzioni di gestione fuori e dentro al loop. Chiarito questo, si supponga di avere la stessa cpu vettoriale con la sola differenza che adesso consideriamo 8 corsie. Questo significa che per ogni colpo di clock verranno effettuate 8 operazioni, per ogni istruzione vettoriale, per cui ad esempio una istruzione di load vettoriale caricher in un solo colpo di clock 8 elementi. Per cui si riducono i colpi di clock e ne risulta il seguente diagramma: LEGENDA Disponibilit 1 8 elemento: Disponibilit 9 16 elemento: Disponibilit 17 56 elemento: Disponibilit 57 64 elemento:
Per il seguente diagramma VLR impostato al valore 64 COLPI DI CLOCK 1 2 3 4 5 6 ISTRUZIONI 7 8 9 10 11 12 13 14 1 1 1 1 1 2 5 6 7 8 9 0
LV.D V1, R7(R1) LV.D V2, R7(R2) MULTSV.D V1, V1, R29 MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R7(R2)
IF
ID IF
EX ID IF
MEM EX ID IF
WB MEM ID IF ID IF ID WB EX EX STALLO EX MEM WB MEM EX STALLO WB MEM MEM WB

WB
Per cui si completa lintera operazione Y=aX+bY con vettori da 64 elementi dopo 19 colpi di clock. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 121 Pietroleonardo Nicola Stroppa Fabio

Il diagramma completo per lesercizio assegnato il seguente: si consideri una cpu a 8 corsie.
A.A. 2009/2010
LEGENDA Disponibilit 1 8 elemento del sottovettore: Disponibilit 9 16 elemento del sottovettore: Disponibilit 17 56 elemento del sottovettore: Disponibilit 57 64 elemento del sottovettore:
COLPI DI CLOCK ISTRUZIONI
ANDI R4, R3, 63 ANDI R7, R3, R4 MTC1 VLR, R4 DMULI R7, R7, #8 LV.D V1, R7(R1) LV.D V2, R7(R2) MULTSV.D V1, V1, R29 MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R7(R2) DADDI R7, R7, #-512 BCEZ R7, LOOP MTC1 VLR, #64 LV.D V1, R7(R1) LV.D V2, R7(R2) MULTSV.D V1, V1, R29 MULTSV.D V2, V2, R30 ADDV.D V2, V1, V2 SV.D V2, R7(R2) DADDI R7, R7, #-512 BCEZ R7, LOOP MTC1 VLR, #64
VLR = 64 VLR = 32
1
IF
2
ID
3
EX
4
ME M EX
5
WB ME M EX
1 0
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 0
2 1
2 2
2 3
2 4
2 5
2 6
2 7
2 2 3 3 3 8 9 0 1 2
IF
ID
WB ME M EX
IF
ID
WB ME M EX
IF
ID
WB ME M EX
IF
ID
WB ME M
IF
ID
WB ME M EX
IF
ID
EX
WB ME M EX
IF
ID
WB ME M
IF
ID
STALLO
WB ME M
IF
ID
EX
STALLO ME M EX
WB
IF
ID
EX
WB ME M EX
IF
ID
WB ME M EX
IF
ID
WB ST AL EX ME M
IF
ID
WB ME M EX
IF
ID
STALLO
WB ME M EX
IF
ID
WB ME M STALLO
IF
ID
STALLO
WB M E W B M E W B
IF
ID
STALLO
EX
ID
ID
EX ME M EX
STALLO
IF
ID
EX
WB ME M EX
IF
ID
WB ME M
IF
ID
WB
possibile sovrapporre alcune fasi, poich queste utilizzano unit funzionali diverse, o perch si ipotizzato che alcune unit, come la memoria, possiedono una banda di dati maggiore. Essendo i vettori di 96 elementi il loop sar eseguito due volte, prima con VLR = 32 e poi con VLR = 64; per eseguire loperazione richiesta ci vorranno 37 colpi di clock (la tabella non completa per motivi di spazio).
Pagina 122
A.A. 2009/2010
ARCHITETTURA MULTICORE Fino ad ora si visto come potessero essere migliorate le prestazioni di un calcolatore puntando su architetture ILP (Instruction Level Parallelism), cio quelle architetture basate sul parallelismo delle istruzioni che con una serie di accorgimenti, quali pipeline delle unit funzionali, riduzione dei conflitti, predizione dei salti, ecc., hanno permesso di ottenere la miglior soluzione possibile per lottimizzazione delle prestazioni; inoltre con lutilizzo di hardware particolari (VLIW, Super Scalare, Vettoriale) si contribuito allaumento delle prestazioni, il tutto utilizzando una sola cpu. Quello che emerge che laumento delle prestazioni che possibile ottenere fortemente legato allhardware di controllo, il quale deve gestire al meglio la contemporanea esecuzione delle istruzioni in maniera da evitare conflitti; non sempre per questo porta ad un effettivo ed evidente miglioramento delle prestazioni. Infatti alcune valutazioni hanno evidenziato che insistere in queste direzioni non porta ad avere una effettiva efficienza (generalmente: =
).
Inoltre queste valutazioni hanno evidenziato che possibile mantenere alta lefficienza con un numero di processori maggiori. Seguendo queste valutazioni si arrivati, grazie alla tecnologia a disposizione, a realizzare in un singolo chip pi di un processore. Questa tecnologia risulta interessante, poich ha costi relativamente bassi, in quanto si va replicare il singolo processore e quindi non richiede una riprogettazione complessa. Quindi invece di rinforzare, potenziare una singola caratteristica si va a replicare lintera cpu; il potenziamento di una caratteristica migliora le prestazioni di quella parte di esecuzione del programma che va ad usare quella componente, e quindi non vi un miglioramento globale del sistema. La seguente figura mostra come laumento dei registri, non comporta una miglioramento proporzionale al potenziamento eseguito.
Passando da 32 a 128 registri, quindi quadruplicandone il numero, non si nota un aumento proporzionale delle istruzioni parallele, per cui non sempre il potenziamento si traduce in un effettivo miglioramento. Questo significa che il punto critico diventato un altro aspetto; analogo discorso si potrebbe avere analizzando un miglioramento delle predizioni di salto.
Pagina 123
A.A. 2009/2010
PARALLELISMO A LIVELLO DI THREAD, MULTI-THREAD Per thread si intende un processo indipendente da un altro processo; indipendente nel senso che pu appartenere allo stesso programma, ma che non influenzato dagli esiti determinati dagli altri processi che costituiscono il programma. Ogni thread ha i suoi dati, istruzioni, registri necessari alla sua esecuzione. Fondamentalmente esistono tre tipi di multithread: 1. SIMULTANEOUS MULTI-THREADING: consideriamo una CPU che permette teoricamente di eseguire in simultaneo 8 istruzioni, grazie alla presenza di pi unit funzionali uguali. Lesecuzione di un singolo thread potrebbe generare una situazione del genere: In un colpo di clock dovrebbero essere prelevate 8 istruzioni, ma questo, come si vede, non avviene, poich evidentemente non vi sono istruzioni che usano unit funzionali diverse. Quindi in un colpo di clock saranno processate poche istruzioni, provocando anche eventuali stalli. possibile pensare di utilizzare le unit funzionali inutilizzate usando istruzioni di un altro thread; questo perch per definizione i thread sono indipendenti fra loro, quindi lo saranno anche i loro dati. Ci significa che non vi saranno conflitti di dati: la situazione in presenza di un altro thread rappresentata dalla seguente figura. Per cui i thread partono simultaneamente sfruttando le unit funzionali non utilizzate da un altro thread.
2. FINE-GRAINED MULTI-THREADING: (a grana fina) questa tipologia di multithreading prevede che il processore scambi il thread in esecuzione a ogni ciclo di clock. Questa tipologia di multithreading dovrebbe rimuovere la dipendenza dai dati dei singoli thread e quindi dovrebbe azzerare o comunque ridurre gli stalli della pipeline dovuta alla dipendenza dai dati. Dato che ogni thread dovrebbe funzionare in modo indipendente i singoli thread eseguiranno programmi non correlati e quindi vi saranno poche probabilit che le istruzioni di un thread necessitino dei risultati elaborati da un'istruzione di un altro thread in esecuzione in quel momento. 3. COARSE-GRAINED MULTI-THREAD: (a grana grossa) questa tipologia di multithread prevede che il processore esegua un singolo thread fino a quando questo non viene bloccato da un evento che normalmente ha una elevata latenza (per esempio un cache miss), in questo caso il processore provvede a eseguire un altro thread che era pronto per l'esecuzione. Il thread di rimpiazzo rimane in esecuzione fino a quando termina o viene bloccato da un evento. Per queste ultime due tipologie di multithread bisogna fare delle considerazioni: il multithreading parte dal presupposto che il passaggio tra thread avvenga in modo rapido; queste due tecniche effettuano il passaggio in un ciclo di clock. Al fine di ottenere questo il processore deve replicare alcune componenti per i due thread come i registri interni, il program counter e alcuni registri di stato. Per cui un cambio di contesto ottimizzato fondamentale per avere tempi estremamente bassi. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 124

Di seguito riportato uno schema riassuntivo delle varie tecniche di parallelismo.
A.A. 2009/2010
MEMORIA CONDIVISA E MEMORIA DISTRIBUITA IN SISTEMI MULTICORE
La categoria normalmente utilizzata nelle architetture multicore quella a memoria condivisa; N core, ognuno comprendente una memoria cache, condividono ununica memoria centrale.
Unaltra categoria caratterizzata da memorie locali per ogni core, che sono sincronizzate da una particolare infrastruttura, anche complessa, per mantenere una certa coerenza fra i dati.
Si utilizza una memoria condivisa quando non possibile individuare delle aree dati distinte e indipendenti per ogni singolo thread che ogni core deve eseguire. Per cui questa soluzione ottimale dal punto di vista della coerenza fra i dati. Il problema legato a questa categoria dovuto al fatto che diversi core devono accedervi contemporaneamente; ma questo non possibile, o comunque non in elevate quantit, poich la memoria possiede una banda passante finita, che limita gli accessi ad essa stessa. Per cui evidente che una soluzione a memoria condivisa effettivamente praticabile quando si utilizza un numero di core basso. Per superare quindi questo limite opportuno implementare la categoria a memoria distribuita; limplementazione richiede la realizzazione di una efficiente rete di interconnessione, in modo da ridurre il tempo di comunicazione tra le memorie. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 125
A.A. 2009/2010
In di c e A na l i ti c o
A
ALEE ISTRUZIONI ALU ........................ 31 ISTRUZIONI BRANCH ................. 35 ISTRUZIONI LOAD...................... 34 RAW - WAW - WAR - RAR ......... 30 Amdahl, legge di ............................ 69 Associativa ........ Vedi Memorie Cache
G
Gerarchia di memoria .................... 62
H
HIT RATE ........................................ 71 HIT TIME ........................................ 71
set associativa .......................... 65 Memorie Cache Accesso alla memoria ............... 28 LOAD/STORE disallineata..... 29 MIPS64 Set istruzioni ............................. 12 MISS PENALITY .............................. 71 MISS RATE ..................................... 71 MOTOROLA 68000 ........................ 76 MVLR ..............................Vedi Registri
P B
Banchi interlacciati ........................ 78 Banchi paralleli .............................. 78
I
ID - Instruction Decode .................. 16 IF - Instruction Fetch ...................... 16 Indirizzamento diretto Vedi Memorie cache Istruzioni .......................................... 7 di calcolo ................................... 10 di controllo ................................ 11 di tipo MOV ................................. 9 di trasferimento dei dati ............. 7 Formato delle ............................ 13 fuori ordine ............................... 84 LVWS ....................................... 105 Set, floating point...................... 86 Set, vettoriale .......................... 104 Superscalare............................ 102 Vettoriali Parallelismo ........................ 113 VLIW .......................................... 99 Istruzioni di tipo I .Vedi Formato delle istruzioni Istruzioni di tipo Jump.. Vedi Formato delle istruzioni Istruzioni di tipo R Vedi Formato delle istruzioni
C
Clean Bit ........................................ 69 COARSE-GRAINED MULTI-THREAD ................................................ 123 Codifica dell'istruzione ........................... 14 Completamente Associativa ....... Vedi Memorie cache Componenti del processore NoPipeline ......... Vedi Processore NoPipeline Control Unit Microprogrammata, Cablata .... 14 Corsie ........................................... 110
Pipeline ALEE.......................................... 27 Strutturali, di dato ............... 30 da programma .......................... 42 Microistruzioni ......................... 26 Struttura processore ................ 25 Tecnica ..................................... 22 PowerPC ........................................ 74 Prinicipi di localit ......................... 63 Processore Accumulatore ........................... 57 Floating point ........................... 84 Multicore ................................ 122 No-Pipeline ............................... 15 Pipeline..................................... 25 Ottimizzato .......................... 36 Superscalare ........................... 102 Vettoriale ............................... 103 CRAY 1 ............................... 107 VLIW ......................................... 99
D
Dead Time ................................... 114 Delay Slot ....................................... 37 Dirty Bit.......................................... 70 DRAM ............................................ 70
R
Random, metodo ... Vedi Sostituzione Registri ............................................ 9 V.LENGHT ............................... 107 V.MASK ................................... 107 Vettoriali................................. 109 VLR, MVLR .............................. 105 Ricerca e identificazione ............... 66
L
LRU, metodo .......... Vedi Sostituzione
E
EX - Execution ................................ 17
M
MEM - Memory Access .................. 18 Memorie cache .............................. 64 ad indirizzamento diretto ......... 65 Allocazione dei blocchi .............. 64 Completamnte associative ........ 65 Elettronica ................................. 70 Funzionamento logico delle ...... 74 Organizzazione .......................... 80 Prestazioni .......................... 71; 78 Problematiche ........................... 77 Scrittura .................................... 69
S
Salto Condizionato, Incondizionato ... 11 Scoreboard .................................... 86 Set, istruzioni................................. 11 Shift, istruzioni Logico, Aritmetico .................... 11 SIMULTANEOUS MULTI-THREADING ............................................... 123 Sostituzione ................................... 67 SRAM ............................................. 70
F
FIFO, metodo ......... Vedi Sostituzione FINE-GRAINED MULTI-THREADING ................................................ 123 Finestra dei registri ........................ 62 Floating point Scheduling istruzioni ................. 87
Pagina 126

Stazioni di prenotazione ............. Vedi Tomasulo, algoritmo Strotolamento ............................... 40 Vettoriali ................................. 103 Tomasulo, algoritmo ...................... 88 Trasparenza dei livelli .................... 62
A.A. 2009/2010
VLR .................................Vedi Registri
W T
Tecnica Speculativa ....................... 38 Tipi di dati ........................................ 7 Floating Point .............................. 7 Interi ........................................... 7
V
V.LENGHT ....................... Vedi Registri V.MASK .......................... Vedi Registri uso del registro ....................... 114 VECTOR STRIPMINING ................. 111
Write Back ..................................... 69 Write Through ............................... 69
B I B L I OG R AF I A
1. JOHN L. HENNESSY, DAVID A. PATTERSON, Architettura degli elaboratori, 4a edizione, APOGEO 2. PROF. ING. F. MARINO, G. MASTRONARDI CALCOLATORI ELETTRONICI,
3. DAVID A. PATTERSON, Slide di alcune lezioni scaricabili dal link: http://vlsi.cs.berkeley.edu/cs252-s06/index.php/Lectures, 2006 Supporto Multimediale di Ausilio al Corso di
4. WIKIPEDIA, Lenciclopedia libera
Pagina 127
ESERCIZI DI CALCOLATORI ELETTRONICI
A.A. 2009/2010
A cura di: Fabio Stroppa Nicola Pietroleonardo
Esercizi di Calcolatori Elettronici
A.A. 2009/2010
IND I CE MICROCODICE DELLE ISTRUZIONI FONDAMENTALI ............................... 2 ESERCIZI MICROCODICE ........................................................................ 3

ESERCIZIO 1 - ADDW R1 R2 R3....................................................................................................................... 4 ESERCIZIO 2 - ADDMEM R1 R2 R3 ................................................................................................................. 6 ESERCIZIO 3 ADD3 R1 R2 R3 ....................................................................................................................... 8 ESERCIZIO 4 MAC R1,(R2),R3 ...................................................................................................................... 9 ESERCIZIO 5 SWP R1 R2 ............................................................................................................................ 11 ESERCIZIO 6 SWX R2 R31 R1 ..................................................................................................................... 13 ESERCIZIO 7 LL R6 (#100,R3) ..................................................................................................................... 14 ESERCIZIO 8 SL (#100,R3) R6 ..................................................................................................................... 15 ESERCIZIO 9 SWPM R1 R2 ......................................................................................................................... 16
ESERCIZI ASSEMBLY ............................................................................ 18

ESERCIZIO 1 SOMMA DI DUE VETTORI ..................................................................................................... 19 ESERCIZIO 2 MEDIA DI UN VETTORE ......................................................................................................... 23 ESERCIZIO 3 MINIMO DI UN VETTORE ...................................................................................................... 25 ESERCIZIO 4 LOAD DOUBLE NON ALLINEATA ........................................................................................... 28 ESERCIZIO 5 STORE DOUBLE NON ALLINEATA .......................................................................................... 30 ESERCIZIO 6 SOMMA DI VETTORI PIPELINE DA PROGRAMMA .............................................................. 32
ALGORITMO DI TOMASULO ................................................................ 33

ESERCIZIO 1.................................................................................................................................................. 34 ESERCIZIO 2.................................................................................................................................................. 40
ESERCIZI ASSEMBLY PROCESSORI SUPERSCALARI E VLIW .................. 48

ESERCIZIO 1.................................................................................................................................................. 49
ESERCIZI ASSEMBLY DLXV ................................................................... 55

ESERCIZIO 1 SOMMA VETTORI DA 64 ELEMENTI...................................................................................... 56 ESERCIZIO 2 SOMMA DI VETTORI > 64 ..................................................................................................... 57 ESERCIZIO 3 SOMMA DI MATRICI CON MxN > 64..................................................................................... 59 ESERCIZIO 4 OPERAZIONE Y = (aX + bY)/c ................................................................................................ 60 ESERCIZIO 5 PRODOTTO SCALARE TRA VETTORI DI 64 ELEMENTI............................................................ 62
Pagina 1
A.A. 2009/2010
MICROCODICE DELLE ISTRUZIONI FONDAMENTALI

IF IF/ID.IR Mem[PC]; IF/ID.NPC (if ((EX/MEM.opcode == branch)OR(EX/MEM.opcode == jump) & EX/MEM.cond) {(EX/MEM.ALUOutput)} else{PC+4}); ID ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ISTRUZIONE DI DIRAMAZIONE EX EX/MEM.ALUOutput ID/EX.NPC + (ID/EX.Imm << 2); EX/MEM.cond (ID/EX.A == 0); MEM WB ISTRUZIONE ALU R op R EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A op ID/EX.B; MEM MEM/WB.IR EX/MEM.IR; MEM/WB.ALUOutput EX/MEM.ALUOutput; WB Regs[MEM/WB.IR[rd]] MEM/WB.ALUOutput; ISTRUZIONE ALU R op Imm EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A op ID/EX.Imm; MEM MEM/WB.IR EX/MEM.IR; MEM/WB.ALUOutput EX/MEM.ALUOutput; WB Regs[MEM/WB.IR[rd]] MEM/WB.ALUOutput; ISTRUZIONE LOAD EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A + ID/EX.Imm; MEM MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; WB Regs[MEM/WB.IR[rt]] MEM/WB.LMD; ISTRUZIONE STORE EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A + ID/EX.Imm; EX/MEM.B ID/EX.B; MEM MEM/WB.IR EX/MEM.IR; Mem[EX/MEM.ALUOutput] EX/MEM.B; WB
Pagina 2
A.A. 2009/2010
ESERCIZI MICROCODICE ESERCIZI MICROCODICE
Pagina 3

ESERCIZIO 1 - ADDW R1 R2 R3
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione ADDW R1 R2 R3 che fa R1=M[R2]+M[R3] per un MIPSpipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: LD R4, 0(R2) LD R5, 0(R3) DADD R1, R4, R5 Tale codice presenta uno stallo dopo listruzione di load per conflitto di dati, in quanto il registro operando della somma il registro destinazione della load, la quale al momento della fase exe dellistruzione di somma non ha ancora scritto in tale registro il valore prelevato dalla memoria. Conteggiamo quindi 4 istruzioni, che vengono eseguite in 5+(4-1) = 8 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); In realt lindirizzo a cui fare riferimento in memoria gi presente nei registri R2 ed R3 caricati nei latch ID/EX.A ed ID/EX.B nella fase di ID, dunque non necessario sommare un immediato nullo. LALU non svolge alcuna operazione di somma e la fase EX si limita a propagare il valore di A e B rispettivamente nel latch EX/MEM.ALUOutput e EX/MEM.B. EX1 EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A; EX/MEM.B ID/EX.B; Loperazione di MEM prevede due accessi alla memoria: uno per prelevare il primo dato MEM1 (indirizzo salvato in R2, A) e un altro per prelevare il secondo dato MEM2 (indirizzo salvato in R3, B). Quindi avremo bisogno di due fasi di MEM. utile che, contemporaneamente al salvataggio nei latch del primo operando dalla memoria, venga sostituito il valore di EX/MEM.ALUOutput con il valore di B per contenere il secondo operando, cos da ripetere nel colpo di clock successivo la medesima operazione. In realt, se si utilizza lo stesso latch EX/MEM.ALUOutput si rischia di incorrere in un problema di incoerenza dei dati: listruzione schedulata un colpo di clock dopo quella di interesse si trover in fase EX mentre questa in MEM1 e aggiorner il valore di EX/MEM.ALUOutput con il risultato della sua operazione con lALU, dunque necessario salvare B in un altro latch aggiuntivo che chiamiamo EX/MEM.ALUOutput2. MEM1 MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; EX/MEM.ALUOutput2 EX/MEM.B;
Pagina 4
A.A. 2009/2010
Avendo ora disponibile B in EX/MEM.ALUOutput2 si pu pensare al prelievo dalla memoria di unaltra istruzione, la quale scriver nuovamente in MEM/WB.LMD per contenere il secondo operando. dunque importante salvare il valore del primo operando in MEM/WB.ALUOutput cos da non perdere il dato. Attenzione, stesso problema precedente: nel caso listruzione schedulata nel colpo di clock successivo a quella di interesse sia unoperazione di ALU, la sua fase MEM verr eseguita in contemporanea con la fase MEM2 in quanto tale operazione non far effettivamente uso della memoria e quindi non crea conflitti o stalli; viene per modificato il valore di MEM/WB.ALUOutput al termine della fase di MEM, quindi saggio salvare il primo operando (A) in un altro latch che chiamiamo MEM/WB.ALUOutput2, senza scomodare minimamente MEM/WB.ALUOutupt che sar impegnato (probabilmente) dallistruzione successiva. Il prelievo del dato salvato in memoria nellindirizzo contenuto in EX/MEM.ALUOutput2 (B) viene ora salvato in MEM/WB.LMD, ma loperazione di lettura da memoria e scrittura nel registro pu essere pensata come divisa in due fasi, ciascuna lunga un semiciclo di clock: nel primo semiciclo viene letto il dato in memoria allindirizzo EX/MEM.ALUOutput2 e nel secondo semiciclo viene scritto tale valore nel latch MEM/WB.LMD: non vi alcuna sovrascrittura, in quanto abbiamo gi salvato MEM/WB.LMD in MEMWB.ALUOutput2 durante il primo semiciclo. importante inoltre che lIR dellistruzione continui a propagarsi nella pipeline, e quindi tale valore dovr essere spostato da MEM/WB.IR in quanto tale latch ora ospiter lIR dellistruzione schedulata successivamente quella di interesse. Dunque, salviamo lIR in un nuovo latch che chiamiamo MEM/WB.IR2. MEM2 MEM/WB.IR2 MEM/WB.IR; MEM/WB.ALUOutput2 MEM/WB.LMD; MEM/WB.LMD Mem[EX/MEM.ALUOutput2]; Avendo ora a disposizione entrambi gli operandi, possibile compiere loperazione di somma. Si pensa di aggiungere un sommatore esterno allALU in modo da non creare conflitti con istruzioni schedulate 3 colpi di clock dopo quella di interesse. EX2 MEM/WB.ALUOutput2 MEM/WB.LMD + MEM/WB.ALUOutput2; WB Regs[MEM/WB.IR2[rd]] MEM/WB.ALUOutput2; Listruzione viene eseguita in 7 colpi di clock, risparmiandone 1 rispetto alla sua scissione in 3 istruzioni. Ci saranno stalli obbligatori se listruzione che segue la nostra ADDW una load o store, che fa uso effettivo nella memoria (che sar occupata in quel momento) oppure se la seconda istruzione schedulata dopo la ADDW unistruzione ALU oppure una LOAD, che scrive nei registri durante la fase di write back.
Al progetto del processore pipeline abbiamo aggiunto tre latch ed un sommatore.
Pagina 5

ESERCIZIO 2 - ADDMEM R1 R2 R3
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione ADDMEM R1 R2 R3 che fa Mem[R1]=Mem[R2]+Mem[R3] per un MIPS-pipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: LD R4, 0(R2) LD R5, 0(R3) DADD R6, R4, R5 SD 0(R1), R6 Tale codice presenta uno stallo dopo listruzione di load per conflitto di dati, in quanto il registro operando della somma il registro destinazione della load, la quale al momento della fase exe dellistruzione di somma non ha ancora scritto in tale registro il valore prelevato dalla memoria. Non vi sono stalli dopo listruzione di somma, nonostante il suo registro destinazione sia il registro operando dellistruzione di store successiva se si pensa a cortocircuitare lALU del processore in modo tale da evitare questi conflitti di dati. Conteggiamo quindi 5 istruzioni, che vengono eseguite in 5+(5-1) = 9 colpi di clock. Listruzione da codificare essenzialmente simile allesercizio precedente, con lunica differenza che il risultato della somma non deve essere salvato in un registro ma in memoria, dunque si rende necessaria loperazione finale di store. Le modifiche apportate al processore per loperazione dellesercizio precedente rimangono inalterate. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); EX1 EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A; EX/MEM.B ID/EX.B; MEM1 MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; EX/MEM.ALUOutput2 EX/MEM.B; MEM2 MEM/WB.IR2 MEM/WB.IR; MEM/WB.ALUOutput2 MEM/WB.LMD; MEM/WB.LMD Mem[EX/MEM.ALUOutput2]; Dovendo salvare il risultato in memoria, si rende necessaria la lettura dellindirizzo a cui fare riferimento dal registro in cui contenuto. Si nota una cosa fondamentale: durante la seconda fase di EX si scrive nel CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 6 Pietroleonardo Nicola Stroppa Fabio
A.A. 2009/2010
registro EX/MEM.B: tale operazione pu portare a dei conflitti di dati se listruzione schedulata tre colpi di clock dopo la ADDMEM unoperazione di store:
Nella sua fase di EXE, la store scriver il valore di ID/EX.B in EX/MEM.B per propagare il valore di B, utilizzando quindi il latch EX/MEM.B. Dunque, per evitare problemi di questo tipo, sarebbe consigliabile propagare ulteriormente il valore di B della istruzione di ADDMEM da EX/MEM.B a MEM/WB.B aggiungendo un nuovo registro al latch del processore. In realt, successivamente scopriremo che laggiunta di questo registro nel latch inutile. EX2 MEM/WB.ALUOutput2 MEM/WB.LMD + MEM/WB.ALUOutput2; MEM/WB.B Regs[M/WB.IR2[rd]; } da svolgere nel secondo semiciclo di clock, lettura da registro MEM3 Mem[MEM/WB.B] MEM/WB.ALUOutput2; Listruzione viene eseguita in 7 colpi di clock, risparmiandone 2 rispetto alla sua scissione in 4 istruzioni. Ci saranno stalli obbligatori se listruzione che segue la nostra ADDMEM una load o store, che fa uso effettivo nella memoria (che sar occupata in quel momento). Stesso discorso per listruzione schedulata tre colpi di clock dopo la ADDMEM, che cadr in fase MEM quando la ADDMEM in MEM3.
In base a quanto detto, la terza operazione dopo la ADDMEM, se una store, provocher uno stallo: tornando al discorso in cui si consigliava la presenza del latch MEM/WB.B si nota ora che possibile utilizzare per tale funzione lo stesso registro EX/MEM.B; spostando infatti lo stallo che si trova dopo la fase EX della store prima della EX stessa, non si avranno problemi di sovrascrittura e di conflitti di memoria.
Pagina 7

ESERCIZIO 3 ADD3 R1 R2 R3
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione ADD3 R1 R2 R3 che fa R1=R1+R2+R3 per un MIPS-pipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: DADD R1, R1, R2 DADD R1, R1, R3 Tale codice non presenta stalli se si considera la corto circuitazione dellALU. Conteggiamo quindi 2 istruzioni, che vengono eseguite in 5+(2-1) = 6 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); La fase di EX1 dovr sommare I registri R2 ed R3 e nel frattempo caricare R1 affinch loperazione di somma sia completata al colpo di clock successivo. Possiamo pensare di leggere R1 nella fase di ID aggiungendo un nuovo registro nel latch ID/EX chiamato C e propagarlo anche nel latch EX/MEM, quindi aggiungendo due registri; oppure si pu pensare di potenziare laccesso alla memoria registri in modo tale da poter effettuare pi letture in parallelo, in questo caso inserendo unulteriore fase di ID nella fase EX1 questa non andr in conflitto con la fase ID processata contemporaneamente dal processore per listruzione schedulata un colpo di clock dopo. Si utilizza quindi il gi presente registro EX/MEM.B. EX1 EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A + ID/EX.B; EX/MEM.B Regs[ID/EX.IR[rd]]; EX2 MEM/WB.IR EX/MEM.IR; MEM/WB.ALUOutput EX/MEM.ALUOutput + EX/MEM.B; WB Regs[MEM/WB.IR[rd]] MEM/WB.ALUOutput; Inserendo un sommatore aggiuntivo nella fase di MEM, nominata EX2 per questa istruzione, non si hanno conflitti con listruzione schedulata al colpo di clock successivo. Listruzione viene eseguita in 5 colpi di clock, risparmiandone 1 rispetto alla sua scissione in 2 istruzioni. Non ci sono stalli o conflitti con istruzioni successive.
Pagina 8

ESERCIZIO 4 MAC R1,(R2),R3
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione MAC R1,(R2),R3 che in RTL significa R1<-R1+M[R2]*R3 per un MIPS-pipeline, discutere i conflitti e possibili soluzioni architetturali (non si prevede unarchitettura tale da avere una ALU che svolge listruzione MADD). Equivale alla successione di queste operazioni assembly: LD R4, 0(R2) DMUL R4, R4, R3 DADD R1, R1, R4 Tale codice presenta uno stallo dopo listruzione di load per conflitto di dati, in quanto il registro operando della moltiplicazione il registro destinazione della load, la quale al momento della fase exe dellistruzione di moltiplicazione non ha ancora scritto in tale registro il valore prelevato dalla memoria. Non vi sono stalli tra la mul e la add se si considera la corto circuitazione dellALU. Conteggiamo quindi 4 istruzioni, che vengono eseguite in 5+(4-1) = 8 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); La prima cosa da fare accedere a memoria per caricare il dato dallindirizzo contenuto in R2 (a cui non va sommato alcun immediato). Contemporaneamente, propaghiamo il valore di R3 (contenuto in B) nel latch EX/MEM ma utilizzando un altro registro chiamato B2: questo perch se listruzione schedulata un colpo di clock dopo questa unistruzione di store al termine della sua fase di EX (ovvero nel colpo di clock in cui la MAC in fase di MEM) sovrascriver il valore di EX/MEM.B con il suo rt ed il valore che poi verr successivamente letto dalla MAC per loperazione di moltiplicazione non sar il valore di rt della MAC ma della store che le succede. EX1 EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A; EX/MEM.B2 ID/EX.B; MEM MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; Contemporaneamente alloperazione di moltiplicazione si preleva il terzo operando contenuto in R1. Questo porta ad avere in contemporanea con la fase di EX2 unulteriore fase di ID che creerebbe conflitti con listruzione schedulata tre colpi di clock dopo la MAC: a tal proposito possibile potenziare laccesso alla memoria registri in modo da avere pi letture parallele.
Pagina 9
A.A. 2009/2010
importante inoltre che lIR dellistruzione continui a propagarsi nella pipeline, e quindi tale valore dovr essere spostato da MEM/WB.IR in quanto tale latch ora ospiter lIR dellistruzione schedulata successivamente quella di interesse. Dunque, salviamo lIR in un nuovo latch che chiamiamo MEM/WB.IR2. EX2 MEM/WB.IR2 MEM/WB.IR; MEM/WB.ALUOutput2 MEM/WB.LMD * EX/MEM.B2; EX/MEM.B2 Regs[MEM/WB.IR[rd]]; } svolta nel secondo semiciclo Si aggiunge un MEM/WB.ALUOutput2. Erroneamente si pu pensare che questo registro non serva poich questo registro viene scritto dalle normali istruzioni solo nella fase di MEM e solo da istruzioni ALU; per creare conflitto esse devono avvenire contemporaneamente con la fase EX3 della MAC e quindi con le istruzioni schedulate 2 colpi di clock dopo la MAC. Queste per si troveranno in una situazione di stallo poich cercheranno di usare la ALU nella loro fase EX che gi utilizzata per la moltiplicazione della MAC in EX2; quindi non si presenta la necessit di aggiungere un MEM/WB.ALUOutput2, sbagliando. Tale registro serve perch listruzione schedulata un colpo di clock dopo la MAC scriver in EX/MEM.ALUOutput dopo la sua fase di EX, e quindi se si usa tale registro per contenere il prodotto e poi la somma al momento della fase EX2 si processer un dato sbagliato. In sostanza, se non avete capito niente di ci che scritto qua, pensate solo che c una sovrascrittura su EX/MEM.ALUOutput se utilizziamo tale registro per fare il prodotto! EX3 MEM/WB.ALUOutput2 MEM/WB.ALUOutput2+ EX/MEM.B2; WB Regs[MEM/WB.IR2[rd]] MEM/WB.ALUOutput; Listruzione viene eseguita in 7 colpi di clock, risparmiandone 1 rispetto alla sua scissione in 2 istruzioni. Ci sar inevitabilmente uno stallo con listruzione schedulata due colpi di clock dopo la MAC a meno che non si inserisca nel progetto un moltiplicatore aggiuntivo, ma uno spreco decisamente evitabile considerando la frequenza di utilizzo di unistruzione di questo tipo. Inserendo un sommatore aggiuntivo nella fase EX3 si non si hanno conflitti con listruzione schedulata tre colpi di clock dopo.
Pagina 10

ESERCIZIO 5 SWP R1 R2
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione SWP R1 R2 che fa Mem[R1] = Mem[R2] per un MIPSpipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: LD SD R3, 0(R2) 0(R1), R3
Tale listato presenta uno stallo, evitabile se si apporta una piccola modifica: si cortocircuita luscita della memoria MEM/WB.LMD in ingresso alla memoria stessa per avere nella fase di MEM della store un Mem[MEM/WB.ALUOutput] MEM/WB.LMD. Conteggiamo quindi 3 istruzioni, che vengono eseguite in 5+(2-1) = 6 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); In realt lindirizzo a cui fare riferimento in memoria gi presente nei registri R2 ed R3 caricati nei latch ID/EX.A ed ID/EX.B nella fase di ID, dunque non necessario sommare un immediato nullo. LALU non svolge alcuna operazione di somma e la fase EX si limita a propagare il valore di A e B rispettivamente nel latch EX/MEM.ALUOutput e EX/MEM.B. EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A; EX/MEM.B ID/EX.B; Il registro B che contiene lindirizzo in memoria in cui salvare il dato contenuto ora in ALUOutput devessere propagato anche in questa fase di MEM1, quindi necessario aggiungere un altro registro B al latch MEM/WB. MEM1 MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; MEM/WB.B EX/MEM.B; Nella seconda fase di MEM verr eseguita la store del dato contenuto in LMD. Non necessario propagare lIR in quanto non si richiedono altre informazioni sugli operandi dellistruzione. Supponendo che listruzione successiva alla SWP sia una load, questa scriver nel registro MEM/WB.LMD durante la sua fase di MEM che verr eseguita in contemporanea con questa fase di MEM2 che anchessa usa MEM/WB.LMD: tale registro non sar sovrascritto perch la SWP legge il suo contenuto nel primo semiciclo di clock mentre la LOAD scrive nel registro il valore che preleva in memoria nel secondo semiciclo di clock.
Pagina 11
A.A. 2009/2010
MEM2 Mem[MEM/WB.B] MEM/WB.LMD; Listruzione viene eseguita in 5 colpi di clock, risparmiandone 1 rispetto alla sua scissione in 2 istruzioni. Ci sar inevitabilmente uno stallo con listruzione schedulata un colpo di clock dopo se questa istruzione una load o una store che fa uso effettivo della memoria. In alternativa, si poteva utilizzare al posto del nuovo registro MEM/WB.B lo stesso registro MEM/WB.ALUOutput: quando SWP in fase MEM2 legger il contenuto di questo registro allinizio del primo semiciclo e salver in memoria LMD (a quellindirizzo) per tutto il resto del ciclo di clock; se loperazione successiva alla SWP fosse una ALU starebbe eseguendo la sua fase di MEM in cui ALUOutput viene propagato dai latch EX/MEM e MEM/WB, per MEM/WB.ALUOutput viene scritto solo nel secondo semiciclo. Quindi non c problema di sovrascrittura.
Pagina 12

ESERCIZIO 6 SWX R2 R31 R1
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione SWX R2 R31 R1 che fa Mem[R1+R31] = R2 per un MIPSpipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: DADD R1, R1, R31 SD 0(R1), R2 Tale codice presenta non presenta stalli se si va a considerare la corto circuitazione dellALU. Conteggiamo quindi 2 istruzioni, che vengono eseguite in 5+(2-1) = 6 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); Si pu pensare di potenziare laccesso alla memoria registri in modo tale da poter effettuare pi letture in parallelo, in questo caso inserendo unulteriore fase di ID nella fase EX questa non andr in conflitto con la fase ID processata contemporaneamente dal processore per listruzione schedulata un colpo di clock dopo. Si utilizza quindi il gi presente registro EX/MEM.B. EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A + ID/EX.Imm; EX/MEM.B Regs[IF/ID.IR[rd]]; MEM MEM/WB.IR EX/MEM.IR; Mem[EX/MEM.ALUOutput] EX/MEM.B; Listruzione viene eseguita in 4 colpi di clock, risparmiandone 2 rispetto alla sua scissione in 2 istruzioni. Non vi sono stalli con istruzioni successive.
Pagina 13

ESERCIZIO 7 LL R6 (#100,R3)
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione LL R6 (#100,R3) significa R6 Mem[Mem[100+R3]] per un MIPS-pipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: LD LD R1, 100(R3) R6 , 0(R1)
Tale listato presenta uno stallo, evitabile se si apporta una piccola modifica: si cortocircuita luscita della memoria MEM/WB.LMD in ingresso alla memoria stessa per avere nella fase di MEM della seconda load un MEM/WB.LMD Mem[MEM/WB.LMD]. Conteggiamo quindi 2 istruzioni, che vengono eseguite in 5+(2-1) = 6 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A + ID/EX.Imm; MEM1 MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; MEM2 MEM/WB.LMD Mem[MEM/WB.LMD]; WB Regs[MEM/WB.IR2[rt]] MEM/WB.LMD; Listruzione viene eseguita in 6 colpi di clock, senza alcun risparmio rispetto alla sua scissione in 2 istruzioni. Ci sar uno stallo con listruzione successiva qualsiasi essa sia (tranne i salti) perch verranno contemporaneamente eseguite le fasi MEM e WB delle due istruzioni, e questo ci permette di non utilizzare registri aggiuntivi quali IR2 o LMD2. Mi sa tanto che conviene usare due operazioni al posto di una!!
Pagina 14

ESERCIZIO 8 SL (#100,R3) R6
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione SL (#100,R3) R6 significa Mem[Mem[100+R3]] R6 per un MIPS-pipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: LD SD R1, 100(R3) 0(R1), R6
Tale listato presenta uno stallo, evitabile se si apporta una piccola modifica: si cortocircuita luscita della memoria MEM/WB.LMD in ingresso alla memoria stessa per avere nella fase di MEM della store un Mem[MEM/WB.LMD] MEM/WB.B. Conteggiamo quindi 2 istruzioni, che vengono eseguite in 5+(2-1) = 6 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); EX EX/MEM.IR ID/EX.IR; EX/MEM.ALUOutput ID/EX.A + ID/EX.Imm; EX/MEM.B ID/EX.B MEM1 MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.ALUOutput]; MEM/WB. ALUOutput EX/MEM.B; MEM2 Mem[MEM/WB.LMD] MEM/WB.ALUOutput; Listruzione viene eseguita in 5 colpi di clock, risparmiandone 1 rispetto alla sua scissione in 2 istruzioni. Ci sar uno stallo se listruzione che la segue una load/store che fa uso effettivo della memoria; dunque lutilizzo del registro MEM/WB .LMD nella fase MEM2 non crea problemi poich lunica istruzione che ne fa uso la load, che in questo caso verr stallata.
Pagina 15

ESERCIZIO 9 SWPM R1 R2
A.A. 2009/2010
Scrivere un microprogramma per l'istruzione SWPM R1 R2 significa Mem[R1]Mem[R2] per un MIPSpipeline, discutere i conflitti e possibili soluzioni architetturali. Equivale alla successione di queste operazioni assembly: LD LD SD SD R3, 0(R1) R4, 0(R2) 0(R2), R3 0(R1), R4
Non ci sono stalli. Conteggiamo quindi 4 istruzioni, che vengono eseguite in 5+(4-1) = 8 colpi di clock. IF IF/ID.IR Mem[PC]; IF/ID.NPC PC+4; ID ID/EX.IR IF/ID.IR; ID/EX.NPC IF/ID.NPC; ID/EX.A Regs[IF/ID.IR[rs]]; ID/EX.B Regs[IF/ID.IR[rt]]; ID/EX.Imm sign-extended(IF/ID.IR[immediate field]); Propaghiamo il valore di A e B aggiungendo il registro A al latch EX/MEM. Non utilizziamo EX/MEM.ALUOutput perch poi il valore di A servir nelle fasi successive. EX EX/MEM.IR ID/EX.IR; EX/MEM.A ID/EX.A; EX/MEM.B ID/EX.B; Usiamo un altro registro chiamato MEM/WB.ALUOutput2 per non avere problemi di sovrascrittura con istruzioni ALU successive che faranno uso di questo registro. MEM/WB.LMD invece liberamente utilizzabile, perch lunica operazione che lo usa la LOAD e questa si staller se segue la nostra istruzione in quanto verranno eseguite contemporaneamente due fasi MEM. MEM1 MEM/WB.IR EX/MEM.IR; MEM/WB.LMD Mem[EX/MEM.A]; MEM/WB. ALUOutput2 EX/MEM.B; MEM/WB.A EX/MEM.A; Si sarebbe anche potuto cortocircuitare lo stesso EX/MEM.A, ma tralasciamo ed aggiungiamo il registro anche a MEM/WB. Non pi necessario propagare lIR perch non dovremo pi fare accessi alla memoria registri, visto che abbiamo propagato i valori di rs ed rt rispettivamente in MEM/WB.A e MEM/WB.ALUOutput2. Aggiungiamo il registro LMD2 al latch MEM/WB per salvare il contenuto della cella di memoria indirizzata al valore di rs.
Pagina 16

MEM2 MEM/WB.LMD Mem[MEM/WB.ALUOutput]; MEM/WB. LMD2 EX/MEM.LMD;
A.A. 2009/2010
Non vi sovrascrittura perch la fase di mem dura tutto il colpo di clock, allinizio viene letto il valore di LMD e al secondo semiciclo del clock viene scritto tale valore in LMD2; nel frattempo, LMD potr tranquillamente essere sovrascritto da ci che troviamo in memoria allindirizzo rt. Ricapitolando, ora abbiamo in MEM/WB.LMD ci che si trova in memoria allindirizzo rt ed in MEM/WB.LMD2 ci che si trova in memoria allindirizzo rs. Il valore di rs salvato in MEM/WB.A ed il valore di rt salvato in MEM/WB.ALUOutput. MEM3 Mem[MEM/WB.A]MEM/WB.LMD; MEM4 Mem[EX/MEM.ALUOutput] MEM/WB. LMD2; Listruzione viene eseguita in 7 colpi di clock, risparmiandone 1 rispetto alla sua scissione in 4 istruzioni. Ci saranno stalli con le prossime tre istruzioni solo se queste sono istruzioni LOAD/STORE, ovvero che fanno uso effettivo della memoria.
Pagina 17
A.A. 2009/2010
ESERCIZI ASSEMBLY
ESERCIZI ASSEMBLY
Pagina 18

ESERCIZIO 1 SOMMA DI DUE VETTORI Somma di due vettori in un terzo vettore con processore scalare pipeline MIPS.
A.A. 2009/2010
Si vuole scrivere un programma assembly per un processore MIPS scalare pipeline che sommi due vettori di dati double contenuti in memoria e salvi il risultato in un terzo vettore. Siano A, B e C vettori di N elementi, loperazione da svolgere : for(i=0; i<N; i++) { C[i] = A[i] + B[i]; } Il primo risparmio lo si pu pensare sui registri: lutilizzo di un unico registro come indice che scorre allinterno del vettore man mano che vengono svolte le somme riduce il numero di registri in gioco. Si ipotizza dunque di conoscere le locazioni in memoria dei tre vettori, cio le locazioni in memoria dei primi elementi dei tre vettori: supponiamo A*0+ allindirizzo 1000, B*0+ allindirizzo 2000 e C*0+ allindirizzo 3000.
Utilizziamo il registro R1 come indice, il quale dovr essere incrementato di 8 (operiamo su vettori double) ad ogni iterazione. In realt, se si pensa di inizializzare R1 al valore dellultimo elemento del vettore, possibile usare una BGEZ su R1 come condizione per il loop, cos che se verificata (se R1 maggiore o uguale a 0) si salta allinizio del loop. In questo modo R1 dovr essere decrementato di 8 ad ogni iterazione. R1 dovr dunque essere inizializzato al valore (N-1)*8, essendo questo il valore occupato in memoria da ciascuno dei tre vettori. Dunque le prime tre istruzioni serviranno ad inizializzare il valore di R1 e saranno operazioni esterne al loop. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pagina 19 Pietroleonardo Nicola Stroppa Fabio

DADDI R1, R0, N DADDI R1, R1, #-1 DMULI R1, R1, #8
A.A. 2009/2010
Successivamente, scriviamo il loop. Allinizio del loop mettiamo letichetta loop per identificare la prima operazioni ove si dovr saltare se verificata la condizione di salto. Le prime due operazioni saranno due load per caricare gli elementi dei vettori dalla memoria nei registri: supponiamo R2 sia destinato a contenere A ed R3 sia destinato a contenere B. loop: LD R2, R1(1000) LD R3, R1(2000) Procediamo con la somma dei due elementi. Potremmo utilizzare il registro R4 per contenere C, ma risulterebbe uninutile spreco di registri in quanto sia R2 che R3 non saranno pi utilizzati nel corso delliterazione. Scegliamo dunque di salvare C in R2. DADDI R2, R2, R3 Salviamo C in memoria. SD R1(3000), R2 Procediamo con il decremento dellindice di 8 e con la condizione di salto. DADDI R1, R1, #-8 BGEZ R1, loop Il programma in assembly risulta essere: DADDI R1, R0, N DADDI R1, R1, #-1 DMULI R1, R1, #8 LD R2, R1(1000) LD R3, R1(2000) DADDI R2, R2, R3 SD R1(3000), R2 DADDI R1, R1, #-8 BGEZ R1, loop
loop:
Tale listato decisamente inaccettabile, in quanto ci saranno numerosi stalli. Supponendo che il nostro processore abbia gi le modifiche necessarie alla cortocircuitazione dellALU, e un sommatore aggiuntivo per effettuare il calcolo del PC dove saltare dopo unistruzione di brench/jump perdendo solo un colpo di clock, la situazione la seguente:
Pagina 20
A.A. 2009/2010
Calcoliamo in quanti colpi di clock viene eseguito questo programma in pipeline. Le istruzioni allinterno del loop sono 6 pi 3 stalli, cio 9 istruzioni. Lesecuzione impiegher: Numero di colpi di clock per eseguire 1 istruzione + (numero di istruzioni -1) = 5 + (9-1) = 13 colpi di clock. Questi 13 colpi di clock valgono perun'unica istruzione. Considerando il loop, le 9 istruzioni dovranno essere moltiplicate per il numero di iterazioni, cio N. Quindi ((9*N)-1)+5. A questi, andranno sommati i colpi di clock necessari per eseguire le tre istruzioni precedenti il loop: Numero di colpi di clock per eseguire 1 istruzione + (Numero di istruzioni precedenti il loop 1) + 1 istruzione (la prima del loop) - Numero di colpi di clock per eseguire 1 istruzione = = 5 + (3-1) 5 + 1 = 3 Supponendo vettori di 10 elementi, il programma impiega 3 + 5 + (9*10)-1) = 97 colpi di clock per essere eseguito.
Per ottimizzare il programma quindi necessario spostare alcune istruzioni utilizzando la tecnica del delay slot. Spostiamo il decremento dellindice dopo la seconda load, in questo modo anche lo stallo che segue questistruzione viene eliminato. Spostiamo inoltre la store dopo la bnez, con laccortezza di cambiare lindirizzo da sommare allindice R1, in quanto R1 gi stato decrementato di 8: dunque, per ottenere lo stesso indirizzo di memoria, si incrementa di 8 l'indirizzo nella store
Pagina 21
A.A. 2009/2010
loop:
DADDI R1, R0, N DADDI R1, R1, #-1 DMULI R1, R1, #8 LD R2, R1(1000) LD R3, R1(2000) DADDI R1, R1, #-8 DADDI R2, R2, R3 BGEZ R1, loop SD R1(3008), R2
Il loop viene eseguito in 5 + (6 -1) = 10 colpi di clock, quindi supponendo vettori di 10 elementi, il programma viene eseguito in 3 + 5 + ((6*10)-1) = 67 colpi di clock, 30 in meno rispetto a quelli utilizzati per processare il listato con gli stalli.
Pagina 22

ESERCIZIO 2 MEDIA DI UN VETTORE Scrivere la procedura che calcoli la media di un vettore di dimensione N.
A.A. 2009/2010
Suppongo che il vettore A sia contenuto in memoria a partire dallindirizzo 1000 e alla procedura viene passato questo indirizzo e la dimensione N del vettore che viene considerato come un immediato nel listato. Utilizzo il registro R1 come indice, per contenere la dimensione del vettore in byte e poter scorrere ogni elemento. Utilizzo R2 come registro per contenere la somma degli elementi del vettore, valore che poi verr restituito dalla procedura (non si richiede una store in memoria). Utilizzo R3 come registro temporaneo per caricare da memoria ogni elemento del vettore A. DADDI DADDI DMULI DADDI LD DADD DADDI BGEZ DDIVI R1, R0, #N R1, R1, #-1 R1, R1, #8 R2, R0, #0 R3, R1(1000) R2, R2, R3 R1, R1, #-8 R1, loop R2, R2, #N
loop:
// NB: la DDIVI mi sa che non esiste
Analizziamo gli stalli (ipotizzando che il processore abbia gi le modifiche per la corto circuitazione dellALU). DADDI DADDI DMULI DADDI LD stallo DADD DADDI stallo BGEZ stallo DDIVI R1, R0, #N R1, R1, #-1 R1, R1, #8 R2, R0, #0 R3, R1(1000) R2, R2, R3 R1, R1, #-8 R1, loop R2, R2, #N
loop:
Il primo stallo si ha perch uno degli operandi della DADD (R3) registro di destinazione delloperazione di load precedente. Il corretto valore di R3 lo si avr solo quando questo sar stato salvato in MEM/WB.LMD, quindi dopo la fase di MEM, mentre la somma successiva viene eseguita nella fase di EXE, che non avr ancora il valore di R3. Il secondo stallo si ha perch il registro su cui verificare la condizione di branch destinazione delloperazione precedente, che sar disponibile in EX/MEM.ALUOutput solo dopo la fase di EX; contemporaneamente la branch star eseguendo la ID, fase in cui si verifica la condizione e si calcola il nuovo PC ove saltare. Il terzo stallo si verifica in quanto possibile scoprire dove saltare solo dopo la fase di ID della branch, quindi al secondo colpo di clock; intanto sar partita listruzione successiva che, se il salto si verifica, dovr essere abortita. Quindi c uno stallo.
Pagina 23

Supponendo un vettore di 10 elementi il programma viene eseguito in: loop (5+(7*10)-1)) = 74 colpi di clock 74 + 5 istuzioni fuori dal loop = 79 colpi di clock
A.A. 2009/2010
Per ottimizzare il programma quindi necessario spostare alcune istruzioni utilizzando la tecnica del delay slot.
loop:
DADDI DADDI DMULI DADDI LD DADDI DADD BGEZ LD DDIVI
R1, R0, #N R1, R1, #-1 R1, R1, #8 R2, R0, #0 R3, R1(1000) R1, R1, #-8 R2, R2, R3 R1, loop R3, R1(1000) R2, R2, #N
Supponendo un vettore di 10 elementi il programma viene eseguito in: loop (5+(4*10)-1)) = 44 colpi di clock 44 + 6 istuzioni fuori dal loop = 50 colpi di clock Si noti che dopo lultima iterazione, loperazione di LOAD verr comunque eseguita e verr caricato in R3 un valore di memoria non interessante ai fini del programma. Questo, in ogni caso, non comporta gravi errori. Altrimenti, si pu abortire loperazione di load se il salto non si verifica.
Pagina 24

ESERCIZIO 3 MINIMO DI UN VETTORE Scrivere la procedura che calcoli lelemento minimo di un vettore di dimensione N.
A.A. 2009/2010
Suppongo che il vettore A sia contenuto in memoria a partire dallindirizzo 1000 e alla procedura viene passato questo indirizzo e la dimensione N del vettore che viene considerato come un immediato nel listato. Utilizzo il registro R1 come indice, per contenere la dimensione del vettore in byte e poter scorrere ogni elemento. Utilizzo R2 come registro per contenere lelemento pi piccolo del vettore, valore che poi verr restituito dalla procedura (non si richiede una store in memoria). Utilizzo R3 come registro temporaneo per caricare da memoria ogni elemento del vettore A. Utilizzo R4 come registro temporaneo per la sottrazione tra lelemento i-esimo del vettore A con il minimo memorizzato nel registro R2. Tale operazione utile al fine di verificare se lelemento i-esimo pi piccolo dellelemento finora considerato minimo. DADDI DADDI DMULI LD LD DSUB DADDI BGEZ DADDI BGEZ R1, R0, #N R1, R1, #-1 R1, R1, #8 R2, R1(1000) R3, R1(1000) R4, R3, R2 R1, R1, #-8 R4, if R2, R3, #0 R1, loop
loop:
if:
Analizziamo gli stalli (ipotizzando che il processore abbia gi le modifiche per la corto circuitazione dellALU). DADDI DADDI DMULI LD LD stallo DSUB DADDI BGEZ stallo DADDI BGEZ stallo R1, R0, #N R1, R1, #-1 R1, R1, #8 R2, R1(1000) R3, R1(1000) R4, R3, R2 R1, R1, #-8 R4, if R2, R3, #0 R1, loop
loop:
if:
Il primo stallo si ha perch uno degli operandi della DSUB (R3) registro di destinazione delloperazione di load precedente. Il corretto valore di R3 lo si avr solo quando questo sar stato salvato in MEM/WB.LMD, quindi dopo la fase di MEM, mentre la somma successiva viene eseguita nella fase di EXE, che non avr ancora il valore di R3. Il secondo ed il terzo stallo si verificano in quanto possibile scoprire dove saltare solo dopo la fase di ID della branch, quindi al secondo colpo di clock; intanto sar partita listruzione successiva che, se il salto si verifica, dovr essere abortita.
Pagina 25
A.A. 2009/2010
Supponendo un vettore di 10 elementi, possiamo scindere il calcolo dei colpi di clock in due casi: best case quando il valore minimo del vettore lultimo elemento (e quindi viene schedulato per primo) e i restanti elementi sono tutti maggiori o uguali al primo: in questo caso si risparmia unistruzione in quanto il branch BGEZ R4, if sar sempre verificato; worste case quando il valore minimo del vettore il primo elemento (e quindi viene schedulato per ultimo) e i restanti elementi sono posizionati nel vettore in ordine decrescente, cosicch ad ogni iterazione li-esimo elemento verr sempre considerato come elemento minimo ed il branch BGEZ R4, if non sar mai verificato, eseguendo anche listruzione DADDI R2, R3, #0 di scambio dei registri. BEST CASE 8 istruzioni per ogni loop. 5 + (8*10) -1 = 84 colpi di clock + 4 istruzioni fuori dal loop = 88 colpi di clock. WORSTE CASE 8 istruzioni alla prima iterazione (lultimo elemento di A gi caricato in R2 prima del loop) e 9 istruzioni per il resto delle iterazioni. 5 + 8 + (9*9)-1 = 93 colpi di clock + 4 istruzioni fuori dal loop = 97 colpi di clock. Per ottimizzare il programma quindi necessario spostare alcune istruzioni utilizzando la tecnica del delay slot.
loop:
if:
DADDI DADDI DMULI LD stallo DADDI DSUB DADDI BGEZ DADDI BGEZ LD
R1, R0, #N R1, R1, #-1 R1, R1, #8 R2, R1(1000) R3, R2, #0 R4, R3, R2 R1, R1, #-8 R4, if R2, R3, #0 R1, loop R3, R1(1000)
Nello spostare la load nel delay slot dopo lultima branch e duplicandola prima del loop, si preferito utilizzare una DADDI per copiare il valore di R2 in R3 in quanto lelemento gi stato caricato in memoria. Non possibile riempire il delay slot dopo la LD R2, R1(1000), ma essendo uno stallo fuori dal loop non la si ritiene una grave perdita di prestazioni. importante ricordarsi che: spostando la DADDI R2, R3, #0 nel delay slot dopo la BGEZ R4, if tale istruzione devessere abortita nel caso il salto si verifichi; spostando la LD R3, R1(1000) nel delay slot dopo la BGEZ R1, loop tale istruzione devessere abortita nel caso il salto non si verifichi. Supponendo un vettore di 10 elementi il programma viene eseguito in: BEST CASE = WORSTE CASE i due casi si riducono ad un unico caso in quanto le istruzioni verranno sempre e comunque eseguite tutte, ma alcune verranno abortite nei casi precedentemente illustrati. 6 istruzioni per ogni loop. 5 + (6*10) 1 = 64 colpi di clock + 6 istruzioni fuori dal loop = 70 colpi di clock. CALCOLATORI ELETTRONICI A.A. 2009/2010 Pietroleonardo Nicola Stroppa Fabio
Pagina 26
A.A. 2009/2010
Alternativamente, si pu procedere in questo modo. Invece di settare R2 (valore massimo) pari al primo elemento schedulato, prima di entrare nel loop, lo si pone uguale al massimo numero rappresentabile con un registro a 64 bit. Considerando la notazione del complemento a due per i numeri negativi, c da scartare il primo bit che il bit di segno. Dunque, con 64 bit a disposizione, il numero maggiore rappresentabile : 264-1-1= 9223372036854775807. Assumiamo MAX=264-1-1 come un valore immediato. DADDI DADDI DMULI LD DADDI DSUB DADDI BGEZ DADDI BGEZ LD R1, R0, #N R1, R1, #-1 R1, R1, #8 R3, R1(1000) R2, R0, #MAX R4, R3, R2 R1, R1, #-8 R4, if R2, R3, #0 R1, loop R3, R1(1000)
loop:
if:
Con questa soluzione, il programma viene eseguito in: 6 istruzioni per ogni loop. 5 + (6*10) 1 = 64 colpi di clock + 5 istruzioni fuori dal loop = 69 colpi di clock.
Pagina 27

ESERCIZIO 4 LOAD DOUBLE NON ALLINEATA Scrivere la procedura che esegua una LOAD double non allineata.
A.A. 2009/2010
Si vuole scrivere una procedura che carichi da memoria un dato double da 64 bit il cui indirizzo non multiplo di 8. Il caricamento dei dati da memoria a registro o da registro a memoria avviene a blocchi di 64 bit (8 byte) a partire da indirizzi che sono sempre divisibili per 8. In questo caso, si vuole caricare un dato che contenuto in due blocchi di memoria, allineandolo successivamente poi in un unico registro. Supponiamo che il dato si trovi allindirizzo di partenza IND passato come parametro alla routine. La prima cosa da fare verificare effettivamente se questo indirizzo non il primo di un blocco da 64 che pu essere caricato in un registro con una semplice LOAD. Questa caratteristica imporr allindirizzo, nel caso sia il primo di un blocco allineato, di essere divisibile per 8. Se non lo , ovviamente, procediamo con la routine. Tale verifica eseguibile semplicemente osservando gli ultimi tre bit dellindirizzo. Se questi sono uguali a zero allora il numero sar divisibile per 8. Dunque, sar sufficiente mettere lindirizzo in AND con il numero binario 7 (111) e verificare se tale risultato uguale a zero: se lo , si esce dalla routine e si passa al processo principale; altrimenti, si esegue la load non allineata.
Dopo la and bisogner fare la condizione su R1 per vedere se uguale a zero. Se lo , la routine termina. Quindi, prima di far terminare la routine, necessario aver fatto la load del double nel caso il dato sia allineato. Lindirizzo di partenza non dovr essere IND, ma IND R1 essendo R1 lo scostamento dallindirizzo XXX000 che il primo del blocco da 64 bit che vogliamo caricare. ANDI DSUB LD BEQZ R1, IND, #7 IND, IND, R1 R2, #0(IND) R1, end
Continuando la routine, carichiamo laltro blocco da 8 byte (8 byte = 64 bit!). LD R3, #8(IND) Caricati I due dati da 8 byte in due registri diversi, bisogner ora fare lo shift di questi dati rispettivamente verso sinistra per il primo registro R2 e verso destra per il secondo registro R3 per poi infine fare la OR tra i due registri.
Pagina 28
A.A. 2009/2010
R2 lo shifteremo di tanti posti quanto lo scostamento R1 moltiplicato per 8 bit (quindi R1 byte per 8 bit). R3 lo shifteremo di tanti posti quanto lo scostamento 8 byte R1 moltiplicato per 8 bit (quindi R1 byte per 8 bit). Infine, si procede con lOR tra i due registri.
DMULT DSLLV DADDI DSUB DMULT DSRLV OR end
R4, R1, #8 R2, R2, R4 R4, R0, #8 R1, R4, R1 R4, R1, #8 R3, R3, R1 R2, R2, R3
Il listato completo : ANDI R1, IND, #7 DSUB IND, IND, R1 LD R2, #0(IND) BEQZ R1, end LD R3, #8(IND) DMULT R4, R1, #8 DSLLV R2, R2, R4 DADDI R4, R0, #8 DSUB R1, R4, R1 DMULT R4, R1, #8 DSRLV R3, R3, R1 OR R2, R2, R3 End Lunico stallo quello solito presente dopo la BEQZ, eliminabile spostando la LD R3, #8(IND) nel delay slot. Ovviamente, se la condizione si verifica tale operazione devessere abortita. Il programma viene eseguito (considerando il caso in cui la load non sia allineata) in: 12 istruzioni. 5 + (12 1) = 16 colpi di clock.
Pagina 29

ESERCIZIO 5 STORE DOUBLE NON ALLINEATA Scrivere la procedura che esegua una STORE double non allineata.
A.A. 2009/2010
Si vuole scrivere una procedura che salvi un dato double da 64 in memoria ad un indirizzo che non multiplo di 8.
Supponiamo il che il dato da voler scrivere in memoria si trovi nel registro R10 e che la locazione in memoria ove scriverlo, allindirizzo IND, sia passata come parametro alla routine. ANDI DSUB BEQZ SD R1, IND, #7 IND, IND, R1 R1, end #0(IND), R11
Lo stallo dovuto alla BEQZ viene riempito con la store. Nel caso la BEQZ sia verificata, e lindirizzo IND sia gi allineato in memoria, allora questa store deve essere eseguita; nel caso in cui invece la BEQZ non verificata e lindirizzo IND non un multiplo di 8, questa store deve essere abortita con la perdita di un colpo di clock. Non volendo sovrascrivere il contenuto degli altri indirizzi non interessati alla store, ma che comunque fanno parte dei due blocchi da 64 bit in cui la store dovr operare, necessario andare a caricare nei registri tali valori e porli infine in OR con il dato da voler salvare, opportunamente shiftato. Avremo dunque bisogno, oltre che del registro R10 che contiene il dato, la sua copia nel registro R11, in modo tale da shiftare R10 verso destra (parte alta del dato) ed R11 verso sinistra (parte bassa del dato). Saranno questi i registri da porre in OR con R2 ed R3. LD LD R2, #0(IND) R3, #8(IND)
Copiamo R10 in R11. DADD R11, R10, R0 Pietroleonardo Nicola Stroppa Fabio
Pagina 30

Shift di R10 verso destra. DMULT DSRLV R4, R1, #8 R10, R0, R4
A.A. 2009/2010
Shift di R11 verso sinistra. DADDI DSUB DMULT DSLLV OR logico. OR OR Store dei dati. SD SD end #0(IND), R2 #8(IND), R3 R2, R2, R10 R3, R3, R10 R4, R0, #8 R1, R4, R1 R4, R1, #8 R11, R11, R1
Il listato completo : ANDI R1, IND, #7 DSUB IND, IND, R1 BEQZ R1, end SD #0(IND), R11 LD R2, #0(IND) LD R3, #8(IND) DADD R11, R10, R0 DMULT R4, R1, #8 DSRLV R10, R0, R4 DADDI R4, R0, #8 DSUB R1, R4, R1 DMULT R4, R1, #8 DSLLV R11, R11, R1 OR R2, R2, R10 OR R3, R3, R10 SD #0(IND), R2 SD #8(IND), R3 end Il programma viene eseguito (considerando il caso in cui la store non sia allineata) in: 17 istruzioni. 5 + (17 1) = 21 colpi di clock.
Pagina 31

ESERCIZIO 6 SOMMA DI VETTORI PIPELINE DA PROGRAMMA Somma di vettori con il metodo della pipeline da programma.
A.A. 2009/2010
Suppongo che l'indirizzo del primo elemento del vettore A sia 1000, l'indirizzo del primo elemento del vettore B sia 2000, l'indirizzo del primo elemento del vettore C sia 3000. Suppongo che in R1 mi venga passato come parametro alla procedura la dimensione del vettore che user come indice (dal fondo verso la testa del vettore). Uso R2 ed R3 per salvare gli i-esimi elementi del vettore. Uso R4 ed R5 per salvare gli i-esimi 1 elementi del vettore (partiamo dalla coda). Uso R6 per salvare gli i-esimi elementi della somma tra i vettori. Uso R7 per salvare gli i-esimi 1 elementi della somma tra i vettori. Uso R8 come condizione sul branch ponendolo uguale a 8. Quando lindice arriva a 8 devo uscire dal loop. DADDI R8,R0, #8 DADDI DMULI LD LD LD LD DADD loop: LD R2, LD R3, DADD DADDI DADDI SD DADDI DADDI R1, R1, #-1 R1, R1, #8 R2, R1(1000) R3, R1(2000) R4, R1(992) R5, R1(1992) R6, R2, R3 R1(984) R1(1984) R7,R4,R5 R4, R2, #0 R5, R3, #0 R1(3000), R6 R6, R7, #0 R1, R1, #-8 // scambio dei registri // pongo R8 = 8 // mi posiziono allultimo elemento (N-1)x8byte
// riempimento
// decremento l'indice
BNE R1, R8, loop DADD R7, R4, R5 SD 0(3008), R6 SD 0(3000), R7 // svuotamento
Come facile notare, e come era prevedibile dalla pipeline da programma, non ci sono stalli per via di conflitti di dato. Si considera sempre la corto circuitazione dellALU per DADDI R1, R1, #-1 DMULI R1, R1, #8
Pagina 32
A.A. 2009/2010
ALGORITMO DI TOMASULO
ESERCIZI ALGORITMO TOMASULO
Pagina 33

ESERCIZIO 1
A.A. 2009/2010
Si consideri una CPU con le seguenti unit funzionali: - 3 Sommatori con latenza di 2 colpi di clock; - 2 Moltiplicatori con latenza di 4 colpi di clock sia per la moltiplicazione che per la divisione; - 3 Accessi a memoria con latenza di 2 colpi di clock. Eseguire colpo di clock dopo colpo di clock lalgoritmo di Tomasulo per il seguente programma:
LD LD MULTD DIVD ADDD SUBD
F6 F8 F4 F8
0+ 2+ F8 F8
R1 R2 F2 F0 F4 F0
F10 F10 F2 F8
CLOCK 1
Instruction status:
Instruction LD F6 LD F8 MULTD F4 DIVD F8 ADDD F10 SUBD F2 j 0+ 2+ F8 F8 F10 F8 k R1 R2 F2 F0 F4 F0
Exec Write Issue Comp Result

1 Load1 Load2 Load3
Busy Address
Yes No No 0+R1
Reservation Stations:
Time Name Busy Add1 No Add2 No Add3 No Mult1 No Mult2 No
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
Register result status: Clock

1 FU
F0
F2
F4
F6
Load1
F8
F10
F12
...
Pagina 34

CLOCK 2
A.A. 2009/2010
Instruction status:

1 2 Load1 Load2 Load3
Busy Address
Yes Yes No 0+R1 2+R2
Op
S1 Vj
S2 Vk
RS Qj
RS Qk

2 FU
F0
F2
F4
F6
F8
F10
F12
...
Load1 Load2
CLOCK 3
Instruction status:

1 2 3 3 Load1 Load2 Load3
Busy Address
Yes Yes No 0+R1 2+R2
Time Name Busy Op Add1 No Add2 No Add3 No Mult1 Yes MULTD Mult2 No
S1 Vj
S2 Vk
RS Qj
RS Qk
R(F2) Load2

3 FU
F0
F2
F4
F6
F8
F10
F12
...
Load1 Load2
Pagina 35

CLOCK 4:
A.A. 2009/2010
Al monitor dei registri rimane sempre Load2 su F8, perch effettivamente F8 non ancora disponibile; al colpo di clock successivo F8 sar disponibile, e dal CDB va direttamente alle unit funzionali per far si che possono essere eseguite sia la MULTD che la DIVD; quindi queste due operazioni partiranno CONTEMPORANEAMENTE. Per cui il monitor dei registri viene aggiornato al cc successivo con F8: MULTD
Instruction status:

1 2 3 4 3 4 4 Load1 Load2 Load3
Busy Address
No Yes No 2+R2
Time Name Busy Op Add1 No Add2 No Add3 No Mult1 Yes MULTD Mult2 Yes DIVD
S1 Vj
S2 Vk
RS Qj
RS Qk
R(F2) Load2 R(F0) Load2

4 FU
F0
F2
F4
F6
F8
F10
F12
...
Mult1 M(A1) Load2
CLOCK 5:
Instruction status:
Issue
1 2 3 4 5
Exec Comp
3 4
Write Result
Busy Address
No No No
Time Name Add1 Add2 Add3 4 Mult1 4 Mult2
Busy
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
Mult1
Yes ADDD R(F10) No No Yes MULTD F8 dal CDB R(F2) Yes DIVD F8 dal CDB R(F0)

5
F0
F2
Pagina 36
F4
F6
F8
F10
F12
FU
Mult1 M(A1) Mult2 Add1


CLOCK 6:
A.A. 2009/2010
Instruction status:
Issue
1 2 3 4 5 6
Exec Comp
3 4
Write Result
Busy Address
No No No
Busy
Yes Yes No Yes Yes
Op
ADDD SUBD
S1 Vj
R(F10)
S2 Vk
RS Qj
RS Qk
Mult1
R(F0) Mult2
MULTD F8 dal CDB R(F2) DIVD F8 dal CDB R(F0)

6 FU
F0
F2
Add2
F4
F6
F8
F10
F12
CLOCK 7-8: situazione invariata, decrementati i valori della colonna time CLOCK 9:
Instruction status:
Issue
1 2 3 4 5 6
Exec Comp
3 4 9 9
Write Result
Busy Address
No No No
Busy
Yes Yes No Yes Yes
Op
ADDD SUBD
S1 Vj
R(F10)
S2 Vk
RS Qj
RS Qk
Mult1
R(F0) Mult2
MULTD F8 dal CDB R(F2) DIVD F8 dal CDB R(F0)

9
F0
F2
Add2
Pagina 37
F4
F6
F8
F10
F12
FU


CLOCK 10:
A.A. 2009/2010
Instruction status:
Issue
1 2 3 4 5 6
Exec Comp
3 4 9 9
Write Result
Busy Address
No No No
Time Name Busy Op 2 Add1 Yes ADDD 2 Add2 Yes SUBD Add3 No Mult1 No Mult2 No
S1 Vj
R(F10) M(A4)
S2 Vk
M(A3) R(F0)
RS Qj
RS Qk

10 FU
F0
F2
Add2
F4
F6
F8
F10
F12
M(A3) M(A1) M(A4) Add1
CLOCK 11: situazione invariata, decrementati i valori della colonna time CLOCK 12:
Instruction status:
Issue
1 2 3 4 5 6
Exec Comp
3 4 9 9 12 12
Write Result
Busy Address
No No No
Time Name Busy Op 0 Add1 Yes ADDD 0 Add2 Yes SUBD Add3 No Mult1 No Mult2 No
S1 Vj
R(F10) M(A4)
S2 Vk
M(A3) R(F0)
RS Qj
RS Qk

12
F0
F2
Add2
Pagina 38
F4
F6
F8
F10
F12
FU
M(A3) M(A1) M(A4) Add1


CLOCK 13:
A.A. 2009/2010
Instruction status:
Issue
1 2 3 4 5 6
Exec Comp
3 4 9 9 12 12
Write Result
4 5 10 10 13 13 Load1 Load2 Load3
Busy Address
No No No
Op
S1 Vj
S2 Vk
RS Qj
RS Qk

13 FU
F0
F2
M(A5)
F4
F6
F8
F10
F12
M(A3) M(A1) M(A4) M(A6)
Pagina 39

ESERCIZIO 2
A.A. 2009/2010
Si consideri una CPU con le seguenti unit funzionali: - 3 Sommatori con latenza di 2 colpi di clock; - 2 Moltiplicatori con latenza di 4 colpi di clock per la moltiplicazione e 10 colpi di clock per la divisione; - 3 Accessi a memoria con latenza di 2 colpi di clock. Eseguire colpo di clock dopo colpo di clock lalgoritmo di Tomasulo per il seguente programma:
DIVD ADDD SD SUBD MULTD
F0 F2 F6 F0 F6 0+
F4 F4 R1
F8 F10 F14 F6 F10 F14
CLOCK 1
Instruction status:
Instruction DIVD F0 ADDD F6 SD F6 SUBD F8 MULTD F6 j F2 F0 0+ F10 F10 k F4 F4 R1 F14 F14

1 Store1 Store2 Store3
Busy Address Val

No No No
Time Name Busy Op Add1 No Add2 No Add3 No 10 Mult1 Yes DIVD Mult2 No
S1 Vj
S2 Vk
RS Qj
RS Qk
F2
F4

1 FU
F0
Mult1
F2
F4
F6
F8
F10
F12
...
Pagina 40

CLOCK 2
A.A. 2009/2010
Instruction status:

1 2 Store1 Store2 Store3
Busy Address Val

No No No
Time Name Busy Op Add1 Yes ADDD R(F4) Mult1 Add2 No Add3 No 9 Mult1 Yes DIVD R(F2) R(F4) Mult2 No
S1 Vj
S2 Vk
RS Qj
RS Qk

2 FU
F0
Mult1
F2
F4
F6
Add1
F8
F10
F12
...
CLOCK 3
Instruction status:

1 2 3 Store1 Store2 Store3
Busy Address Val

Yes No No 0+R1 Add1
S1 Vj
S2 Vk
RS Qj
RS Qk

3 FU
F0
Mult1
F2
F4
F6
Add1
F8
F10
F12
...
Pagina 41

CLOCK 4
Instruction status:
Instruction DIVD F0 ADDD F6 SD F6 SUBD F8 MULTD F6 j F2 F0 0+ F10 F10
A.A. 2009/2010
Exec Write
k Issue Comp Result F4 1 F4 2 R1 3 F14 4 F14
Busy Address Val

Store1 Store2 Sotre3 Yes No No 0+R1 Add1
Time Name Add1 2 Add2 Add3 7 Mult1 Mult2
Busy
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
Yes ADDD R(F4) Mult1 Yes SUBD R(F10) R(F14) No Yes DIVD R(F2) R(F4) No

4 FU
F0
Mult1
F2
F4
F6
F8
F10
F12
...
Add1 Add2
CLOCK 5: listruzione MULTD pu partire senza problemi, anche se il destinazione F6 effettivamente non
stato ancora calcolato dalla precedente istruzione ADDD, la quale attende il termine della DIVD. Questo possibile perch la Store1 attender il valore non dal registro F6 ma direttamente dal sommatore Add1 (attraverso il CDB); quindi non vi la necessit di scrivere il risultato prima in F6 e poi di effettuare la store. Detto questo listruzione MULTD pu tranquillamente effettuare la sua operazione e scrivere il risultato in F6, senza provocare incoerenza di dati. Per cui nel monitor dei registri possibile indicare Mult2 ad F6.
Instruction status:

1 2 3 4 5 Store1 Store2 Store3
Busy Address Val

Yes No No 0+R1 Add1
Time Name Add1 1 Add2 Add3 6 Mult1 4 Mult2
Busy
Yes Yes No Yes Yes
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
ADDD R(F4) Mult1 SUBD R(F10) R(F14) DIVD R(F2) R(F4) MULTD R(F10) R(F14)

5
F0
Mult1
F2
F4
F6
F8
F10
F12
...
FU
Mult2 Add2
Pagina 42

CLOCK 6
A.A. 2009/2010
Instruction status:

1 2 3 4 5 Store1 Store2 Store3 6
Busy Address Val

Yes No No 0+R1 Add1
Time Name Add1 0 Add2 Add3 5 Mult1 3 Mult2
Busy
Yes Yes No Yes Yes
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
ADDD R(F4) Mult1 SUBD R(F10) R(F14) DIVD R(F2) R(F4) MULTD R(F10) R(F14)

6 FU
F0
Mult1
F2
F4
F6
F8
F10
F12
...
Mult2 Add2
CLOCK 7
Instruction status:

1 2 3 4 5 Store1 Store2 Store3 6 7
Busy Address Val

Yes No No 0+R1 Add1
Busy
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
Yes ADDD R(F4) Mult1 No No Yes DIVD R(F2) R(F4) Yes MULTD R(F10) R(F14)

7 FU
F0
Mult1
F2
F4
F6
F8
F10
F12
...
Mult2 M(A1)
Pagina 43

CLOCK 8: situazione invariata, decremento colonna timer CLOCK 9
A.A. 2009/2010
Instruction status:

1 2 3 4 5 Store1 Store2 Store3 6 9 7
Busy Address Val

Yes No No 0+R1 Add1
Busy
Op
S1 Vj
S2 Vk
RS Qj
RS Qk
Yes ADDD R(F4) Mult1 No No Yes DIVD R(F2) R(F4) Yes MULTD R(F10) R(F14)

9 FU
F0
Mult1
F2
F4
F6
F8
F10
F12
...
Mult2 M(A1)
CLOCK 10
Instruction status:

1 2 3 4 5 Store1 Store2 Store3 6 9 7 10
Busy Address Val

Yes No No 0+R1 Add1
S1 Vj
S2 Vk
RS Qj
RS Qk

10
F0
Mult1
F2
F4
F6
F8
F10
F12
...
FU
M(A2) M(A1)
Pagina 44

CLOCK 11
A.A. 2009/2010
Instruction status:

1 2 3 4 5 11 Store1 Store3 Store3 7 10
Busy Address Val

Yes No No 0+R1 Add1
6 9
S1 Vj
S2 Vk
RS Qj
RS Qk

11 FU
F0
Mult1
F2
F4
F6
F8
F10
F12
...
M(A2) M(A1)
CLOCK 12
Instruction status:

1 2 3 4 5 11 12 Store1 Store2 Store3
Busy Address Val

Yes No No 0+R1 Add1
6 9
7 10
Time Name Busy Op 2 Add1 Yes ADDD M(A3) R(F4) Add2 No Add3 No Mult1 No Mult2 No
S1 Vj
S2 Vk
RS Qj
RS Qk

12
F0
F2
F4
F6
F8
F10
F12
...
FU M(A3)
M(A2) M(A1)
Pagina 45

CLOCK 13: situazione invariata, decremento colonna timer CLOCK 14
A.A. 2009/2010
Instruction status:

1 2 3 4 5 11 14 6 9 12 Store1 Store2 Store3
Busy Address Val

Yes No No 0+R1 Add1
7 10
Time Name Busy Op 0 Add1 Yes ADDD M(A3) R(F4) Add2 No Add3 No Mult1 No Mult2 No
S1 Vj
S2 Vk
RS Qj
RS Qk

14
F0
F2
F4
F6
F8
F10
F12
...
FU M(A3)
M(A2) M(A1)
CLOCK 15
Instruction status:
Instruction DIVD ADDD SD SUBD MULTD F0 F6 F6 F8 F6 j F2 F0 0+ F10 F10 k F4 F4 R1 F14 F14

1 2 3 4 5 11 14 6 9 12 15 7 10 2 Store1 Store2 Store3
Busy Address Val

Yes No No 0+R1 Add1 dal CDB
Op
S1 Vj
S2 Vk
RS Qj
RS Qk

15 CALCOLATORI ELETTRONICI A.A. 2009/2010
F0
F2
F4
F6
F8
F10
F12
...
FU M(A3)
Pagina 46
M(A2) M(A1)

CLOCK 16: situazione invariata, decremento del timer della Store1
A.A. 2009/2010
CLOCK 17: la store si completa, non bisogna attendere nessun risultato; il buffer Store1 viene liberato al
colpo di clock successivo per poter essere eventualmente utilizzato.
Instruction status:
Instruction DIVD ADDD SD SUBD MULTD F0 F6 F6 F8 F6 j F2 F0 0+ F10 F10 k F4 F4 R1 F14 F14

1 2 3 4 5 11 14 17 6 9 12 15 7 10 0 Store1 Store2 Store3
Busy Address Val

Yes No No 0+R1 Add1 dal CDB
Op
S1 Vj
S2 Vk
RS Qj
RS Qk

17
F0
F2
F4
F6
F8
F10
F12
...
FU M(A3)
M(A2) M(A1)
Pagina 47

ESERCIZI ASSEMBLY PROCESSORI SUPERSCALARI E VLIW
A.A. 2009/2010
ESERCIZI ASSEMBLY PROCESSORI SUPERSCALARI E VLIW
Pagina 48

ESERCIZIO 1 Scrivere il codice srotolato di un programma che faccia il prodotto tra due vettori.
A.A. 2009/2010
Scrivere il codice per una CPU SCALARE, per una CPU VLIW e per una CPU SUPERSCALARE limitandosi prima a 20 registri e poi a 32 registri, riportando in quale caso si ha un miglioramento delle prestazioni (in percentuali). Si consideri un processore con registri a 32 bit e bus a 32 bit. Ogni CPU ha le seguenti caratteristiche: UNITA FUNZIONALI: 2 unit di accesso a memoria; 2 moltiplicatori/divisori; 1 sommatore/sottrattore; LATENZA UNITA: LOAD: 2 colpi di clock MOLTIPLICATORE: 10 colpi di clock DIVISORE: 20 colpi di clock SOMMATORE: 5 colpi di clock Per la CPU VLIW si consideri il seguente formato istruzioni: 2 accessi a memoria; 2 operazioni FP; 1 operazione intera/branch
Pagina 49

Si ipotizzi A*0+ allindirizzo 1000, B*0+ allindirizzo 2000, C*0+ allindirizzo 3000. Si posiziona R1, lindice, allultimo elemento del vettore ((N-1)x8).
A.A. 2009/2010
CPU SCALARE CON 20 REGISTRI FP

1 LOOP: 2 3 4 5 6 7 8 9 10 11 12 13 14 16 17 18 19 20 21 22 23 24 25 26 28 L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D MUL.D MUL.D MUL.D MUL.D MUL.D DADDI F0,R1(1000) F2,R1(2000) F4,R1(992) F6,R1(1992) F8,R1(984) F10,R1(1984) F12,R1(976) F14,R1(1976) F16,R1(968) F18,R1(1968) F0,F0,F2 F4,F4,F6 F8,F8,F10 F12,F12,F14 F16,F16,F18 R1,R1,#-40
;1000 8 byte = 992 ;2000 8 byte = 1992 ;1000 16 byte = 984 ;2000 16 byte = 1984 ;1000 ;2000 ;1000 ;2000 24 24 32 32 byte byte byte byte = = = = 976 1976 968 1968
STALLO STALLO STALLO STALLO

S.D S.D S.D S.D BGEZ S.D R1(3040),F0 R1(3032),F4 R1(3024),F8 R1(3016),F12 R1,LOOP R1(2968),F16
5 risultati in 28 colpi di clock, oppure 5.6 colpi di clock per iterazione.
Pagina 50

CPU VLIW CON 20 REGISTRI FP Mem Reference1
1 LOOP: L.D F0,R1(1000) 2 3 4 5 6 7 8 9 10 11 12 13 14 16 17 18 L.D F4,R1(992) L.D F8,R1(984) L.D F12,R1(976) L.D F16,R1(968) noop noop
A.A. 2009/2010
Mem Reference2
L.D F2,R1(2000) L.D F6,R1(1992) L.D F10,R1(1984) L.D F4,R1(1976) L.D F18,R1(1968) noop noop
FP op1
noop noop MUL.D F0,F0,F2 MUL.D F4,F4,F6 MUL.D F8,F8,F10 MUL.D F12,F12,F14 MUL.D F16,F16,F18
FP op2
noop noop noop noop noop noop noop
Int/branch
noop noop noop noop noop DADDI R1,R1,#-40 noop
STALLO STALLO STALLO STALLO STALLO

S.D R1(3040),F0 S.D R1(3032),F4 S.D R1(3024),F8 S.D R1(3016),F12 S.D R1(2968),F16 noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop BGEZ R1,LOOP noop
CPU SUPERSCALARE CON 20 REGISTRI FP

1 LOOP: 2 3 4 5 6 7 8 9 10 11 12 13 14 16 17 18 19 20 L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D DADDI noop F0,R1(1000) F2,R1(2000) F4,R1(992) F6,R1(1992) F8,R1(984) F10,R1(1984) F12,R1(976) F14,R1(1976) F16,R1(968) F18,R1(1968) R1,R1,#-40 noop noop noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop noop noop noop noop noop F0,F0,F2 F4,F4,F6 F8,F8,F10 F12,F12,F14 F16,F16,F18
STALLO
S.D S.D S.D S.D BGEZ S.D R1(3040),F0 R1(3032),F4 R1(3024),F8 R1(3016),F12 R1,LOOP R1(2968),F16
5 operazioni in 20 colpi di clock, oppure 4 colpi di clock per iterazione. Pietroleonardo Nicola Stroppa Fabio
Pagina 51

CPU SCALARE CON 32 REGISTRI FP
1 LOOP: 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D MUL.D MUL.D MUL.D MUL.D MUL.D MUL.D MUL.D MUL.D DADDI F0,R1(1000) F2,R1(2000) F4,R1(992) F6,R1(1992) F8,R1(984) F10,R1(1984) F12,R1(976) F14,R1(1976) F16,R1(968) F18,R1(1968) F20,R1(960) F22,R1(1960) F24,R1(952) F26,R1(1952) F28,R1(944) F30,R1(1944) F0,F0,F2 F4,F4,F6 F8,F8,F10 F12,F12,F14 F16,F16,F18 F20,F20,F22 F24,F24,F26 F28,F28,F30 R1,R1,#-64 R1(3064),F0 R1(3056),F4 R1(3048),F8 R1(3040),F12 R1(3032),F16 R1(3024),F20 R1(3016),F24 R1,LOOP R1(2944),F24
A.A. 2009/2010
;1000 8 byte = 992 ;2000 ;1000 ;2000 ;1000 8 byte = 1992 16 byte = 984 16 byte = 1984 24 byte = 976
;2000 24 byte = 1976 ;1000 32 byte = 968 ;2000 32 byte = 1968 ;1000 ;2000 ;1000 ;2000 40 40 48 48 byte byte byte byte = = = = 960 1960 952 1952
;1000 56 byte = 944 ;2000 56 byte = 944
STALLO
S.D S.D S.D S.D S.D S.D S.D BGEZ S.D
Pagina 52

CPU VLIW CON 32 REGISTRI FP Mem Reference1
1 LOOP: L.D F0,R1(1000) 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 L.D F4,R1(992) L.D F8,R1(984) L.D F12,R1(976) L.D L.D L.D L.D F16,R1(968) F20,R1(960) F24,R1(952) F28,R1(944)
A.A. 2009/2010
Mem Reference2
L.D F2,R1(2000) L.D F6,R1(1992) L.D F10,R1(1984) L.D F14,R1(1976) L.D L.D L.D L.D F18,R1(1968) F22,R1(1960) F26,R1(1952) F30,R1(1944)
FP op1
noop noop MUL.D F0,F0,F2 MUL.D F8,F8,F10 MUL.D MUL.D MUL.D MUL.D F12,F12,F14 F16,F16,F18 F20,F20,F22 F24,F24,F26
FP op2
noop noop noop noop noop noop noop noop noop
Int/branch
noop noop noop noop noop noop noop noop DADDIR1,R1,#-64
noop
noop
MUL.D F28,F28,F30
STALLO STALLO STALLO

S.D R1(3064),F0 S.D R1(3056),F4 S.D R1(3048),F8 S.D R1(3040),F12 S.D R1(3032),F16 S.D R1(3024),F20 S.D R1(3016),F24 S.D R1(2944),F24 noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop noop BGEZ R1,LOOP noop
Pagina 53

CPU SUPERSCALARE CON 32 REGISTRI FP
A.A. 2009/2010
1 LOOP: 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D L.D DADDI S.D S.D S.D S.D S.D S.D S.D BGEZ S.D
F0,R1(1000) F2,R1(2000) F4,R1(992) F6,R1(1992) F8,R1(984) F10,R1(1984) F12,R1(976) F14,R1(1976) F16,R1(968) F18,R1(1968) F20,R1(960) F22,R1(1960) F24,R1(952) F26,R1(1952) F28,R1(944) F30,R1(1944) R1,R1,#-64 R1(3064),F0 R1(3056),F4 R1(3048),F8 R1(3040),F12 R1(3032),F16 R1(3024),F20 R1(3016),F24 R1,LOOP R1(2944),F24
noop noop noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop MUL.D noop noop noop noop noop noop noop noop F0,F0,F2 F4,F4,F6 F8,F8,F10 F12,F12,F14 F16,F16,F18 F20,F20,F22 F24,F24,F26 F28,F28,F30
8 operazioni in 26 colpi di clock, oppure 3.25 colpi di clock per iterazione.
Pagina 54
A.A. 2009/2010
ESERCIZI ASSEMBLY DLXV
ESERCIZI ASSEMBLY DLXV
Pagina 55

ESERCIZIO 1 SOMMA VETTORI DA 64 ELEMENTI Somma di due vettori da 64 elementi per un DLXV con MVLR = 64. Si vuole realizzare una procedura che esegua C[64] = A[64] + B[64]. Utilizziamo R1 per contenere la dimensione del vettore. Utilizziamo R2 per contenere lindirizzo in memoria del primo elemento del vettore A. Utilizziamo R3 per contenere lindirizzo in memoria del primo elemento del vettore B. Utilizziamo R4 per contenere lindirizzo in memoria del primo elemento del vettore C. DADDI MTC1 LV LV ADDV.D SV R1, R0, #64 VLR, R1 V1, 0(R2) V2, 0(R3) V1, V1, V2 0(R4), V1
A.A. 2009/2010
Lutilizzo di V1 come registro destinazione per contenere il vettore C solo una forma di risparmio in registri. In alternativa allistruzione DADDI R1, R0, #64 si pu utilizzare listruzione LI R1, #64. Il programma presenter uno stallo dopo lultima load perch la sua destinazione operando della add che le succede: la prima delle 64 fasi di EX della ADDV processer gli elementi V1[0] e V2[0], ma in V2[0] non sar ancora stato ospitato leffettivo valore B*0+ presente in memoria in quanto questo viene posto nel registro LDM solo dopo la fase di mem di LV, e successivamente nel registro vettoriale V2. DADDI MTC1 LV LV stallo ADDV.D SV R1, R0, #64 VLR, R1 V1, 0(R2) V2, 0(R3) V1, V1, V2 0(R4), V1
Pagina 56

ESERCIZIO 2 SOMMA DI VETTORI > 64 Somma di due vettori con un numero di elementi >64 per un DLXV con MVLR = 64. Si vuole realizzare una procedura che esegua C[>64] = A[>64] + B[>64]. Utilizziamo R1 per contenere la dimensione del vettore. Utilizziamo R10 come indice per scorrere tra i vari sottovettori. Utilizziamo R2 per contenere lindirizzo in memoria del primo elemento del vettore A. Utilizziamo R3 per contenere lindirizzo in memoria del primo elemento del vettore B. Utilizziamo R4 per contenere lindirizzo in memoria del primo elemento del vettore C.
A.A. 2009/2010
I due vettori avranno dimensioni superiori a MVLR. Si pu dunque pensare di suddividere i due vettori in tanti sottovettori da 64 elementi luno. Il problema principale per che non sappiamo a priori se queste dimensioni sono divisibili per MVLR. Nel caso lo fossero, bisogner semplicemente incrementare lindice di un valore pari a 8 byte x 64 elementi = 512 byte ad ogni iterazione per passare al sottovettore successivo senza modificare mai VLR. Nel caso non lo fossero, e questo il caso generale da usare per risolvere questo tipo di problema, bisogner considerare un vettore residuo. Quindi scomporre il vettore principale in tanti sottovettori da 64 pi un altro con dimensione minore di 64. logico schedulare come primo sottovettore il vettore residuo, in modo tale da non dover verificare ad ogni iterazione se si giunti al penultimo sottovettore e quindi cambiare alla fine il VLR. Si pone quindi VLR uguale al residuo e lo si cambia alla fine di ogni loop ponendolo uguale a 64. Per ottenere la dimensione di questo residuo, si pu utilizzare questa operazione: ANDI R10, R1, #63
Infatti, gli ultimi 6 bit di un numero binario qualsiasi corrispondono proprio al suo residuo se divisi per 64, ed essendo 26=64, ponendo 6 bit a 1 si ottiene il numero decimale 63 che posto in AND con la dimensione del vettore mette a zero tutti i bit pi significativi del sesto. Ipotizzando un vettore di 187 elementi si ha: 187 / 64 = 2,921 64 x 2 = 128 187 128 = 59 (187)10 (10111011)2 (63)10 (111111)2 10111011 AND 111111 = 00111011 (00111011)2 (59)10 Poniamo il valore 64 in un registro qualsiasi (R5) in modo tale da poterlo poi spostare in VLR con listruzione MTC1 quando richiesto. DADDI R5, R0, #64
Considerando lesempio della somma dei vettori per un processore scalare, abbiamo verificato che pi conveniente tenere un indice partendo dal fondo del vettore per arrivare fino in cima. Quindi volendo andare in coda al vettore, lindice da utilizzare non dovr partire da 0 ma da (dimensione del vettore residuo) x 8 byte. Ricordiamoci di settare VLR pari al residuo prima di porre lindice in coda al vettore.
Pagina 57

MTC1 DSUB DMUL VLR, R10 R10, R1, R10 R10, R10, #8
A.A. 2009/2010
Ora si pu iniziare il loop. loop: LV LV ADDV.D SV V1, R10(R2) V2, R10(R3) V1, V1, V2 R10(R4), V1
Alla fine del loop, si decrementa il valore dellindice di una quantit pari ad un sottovettore, quindi di 64 elementi, ognuno da 8 byte, quindi 512 byte. DADDI R10, R10, #-512
Imposto VLR pari a 64, dato che da ora in poi, i sottovettori saranno sempre di dimensioni pari a MVLR. MTC1 VLR, R5
Impongo la condizione che fino a ch lindice maggiore o uguale a zero, literazione deve essere eseguita. BGEZ R10, loop
Il listato completo : ANDI DADDI MTC1 DSUB DMUL LV LV stallo ADDV.D SV DADDI MTC1 BGEZ stallo R10, R1, #63 R5, R0, #64 VLR, R10 R10, R1, R10 R10, R10, #8 V1, R10(R2) V2, R10(R3) V1, V1, V2 R10(R4), V1 R10, R10, #-512 VLR, R5 R10, loop
loop:
Listruzione di salto provoca i soliti stalli. Spostiamo la MTC1 nel delay slot sotto BGEZ per non perdere il colpo di clock. Lo stallo sotto la LV non potr essere evitato.
Pagina 58

ESERCIZIO 3 SOMMA DI MATRICI CON MxN > 64 Somma di due matrici con un numero di elementi MxN >64 per un DLXV con MVLR = 64. Si vuole realizzare una procedura che esegua C[>64][>64] = A[>64] [>64] + B[>64] [>64].
A.A. 2009/2010
Prima di pensare a somme matriciali con due for, uno per riga e uno per colonna, ragioniamo un attimo su come vengono salvate le matrici in memoria per giungere ad una gradevole soluzione. In memoria, le matrici vengono salvate per righe. Questo significa che due blocchi contigui in memoria conterranno elementi successivi della stessa riga. A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[0][5] A*0+*+ Una volta terminata la riga 0, successivamente, in memoria sar allocata tutta la riga 1. Dunque, le matrici in memoria non sono altro che vettori di dimensione MxN. Il programma in assembly identico a quello della somma di due vettori di dimensione >64, con lunica differenza che la dimensione questa volta non sar immediatamente passata come parametro alla routine ma bisogner ricavarsela con una semplice moltiplicazione. Utilizziamo R1 per contenere la M ed R6 per contenere N. DMUL ANDI DADDI MTC1 DSUB DMUL LV LV ADDV.D SV DADDI BGEZ MTC1 R1, R1, R6 R10, R1, #63 R5, R0, #64 VLR, R10 R10, R1, R10 R10, R10, #8 V1, R10(R2) V2, R10(R3) V1, V1, V2 R10(R4), V1 R10, R10, #-512 R10, loop VLR, R5
loop:
Pagina 59

ESERCIZIO 4 OPERAZIONE Y = (aX + bY)/c
A.A. 2009/2010
Y= (aX + bY)/c con X e Y vettori di dimensione >64 e a, b e c scalari per un DLXV con MVLR = 64. Si vuole realizzare una procedura che esegua Y[>64] = (aX[>64] + bY[>64])/c. Utilizziamo R1 per contenere la dimensione del vettore. Utilizziamo R5 per contenere limmediato costante 64. Utilizziamo R10 come indice per scorrere tra i vari sottovettori. Utilizziamo R2 per contenere lindirizzo in memoria del primo elemento del vettore A. Utilizziamo R3 per contenere lindirizzo in memoria del primo elemento del vettore B. Utilizziamo F0 per contenere lo scalare c. Utilizziamo F2 per contenere lo scalare a. Utilizziamo F4 per contenere lo scalare b. ANDI DADDI MTC1 DSUB DMUL LV stallo MULVS.D LV stallo MULVS.D ADDV.D DIVVS.D SV DADDI MTC1 BGEZ stallo R10, R1, #63 R5, R0, #64 VLR, R10 R10, R1, R10 R10, R10, #8 V1, R10(R2) V1, V1, F2 V2, R10(R3) V2, V2, F4 V2, V1, V2 V2, V2, F0 R10(R3), V2 R10, R10, #-512 VLR, R5 R10, loop
loop:
Loperazione MULVS.D V1, V1, F1 e MULVS.D V2, V2, F2 moltiplicano un vettore per uno scalare. Loperazione DIVVS.D V2, V2, F2 divide un vettore per uno scalare. Riordiniamo il programma per eliminare eventuali stalli. Non si sono considerati gli stalli dovuti alla fase EX delle unit floating point, quale moltiplicatore e divisore: il loro output sar ottenuto solo dopo un numero di colpi di clock che varia in base alla latenza di tali unit, ed quindi incalcolabile ad occhio quando questi provocheranno uno stallo. ANDI DADDI MTC1 DSUB DMUL LV LV MULVS.D MULVS.D ADDV.D R10, R1, #63 R5, R0, #64 VLR, R10 R10, R1, R10 R10, R10, #8 V1, R10(R2) V2, R10(R3) V1, V1, F2 V2, V2, F4 V2, V1, V2 Pagina 60 Pietroleonardo Nicola Stroppa Fabio
loop:

DIVVS.D SV DADDI BGEZ MTC1 V2, V2, F0 R10(R3), V2 R10, R10, #-512 R10, loop VLR, R5
A.A. 2009/2010
Un metodo alternativo per risolvere lalgoritmo con, probabilmente, meno colpi di clock quello di dividere prima del loop sia a che b per c. Questo porterebbe essere vantaggioso se le latenze delle unit funzionali non sono unitarie, in quanto supponiamo sia 10 la latenza del divisore e 4 quella del moltiplicatore, loperazione di divisione che dura 10 colpi di clock la si fa una volta allinizio, e non la si ripete 64 volte nel loop per ogni elemento (considerando una sola corsia e una sola unit funzionale per corsia). Se fosse a latenza unitaria, sprecheremmo solo un colpo di clock nel loop contro i due fuori dal loop (perch contemporaneamente a queste 64 divisioni venivano svolte 63 moltiplicazioni la prima moltiplicazione era svolta prima della prima divisione cos come lultima divisione svolta dopo lultima moltiplicazione aggiungendo solo un colpo di clock alla fine), ma ripeterlo 64 volte per 10 colpi di clock dopo le 64 moltiplicazioni per 4 colpi di clock significa un aumento notevole dei colpi di clock per eseguire il programma! ANDI DADDI MTC1 DSUB DMUL DIV.D DIV.D LV LV MULVS.D MULVS.D ADDV.D SV DADDI BGEZ MTC1 R10, R1, #63 R5, R0, #64 VLR, R10 R10, R1, R10 R10, R10, #8 F2, F2, F0 F4, F4, F0 V1, R10(R2) V2, R10(R3) V1, V1, F2 V2, V2, F4 V2, V1, V2 R10(R3), V2 R10, R10, #-512 R10, loop VLR, R5
loop:
Pagina 61

ESERCIZIO 5 PRODOTTO SCALARE TRA VETTORI DI 64 ELEMENTI Prodotto scalare tra due vettori di 64 elementi con il metodo della riduzione a scalare. Si vuole realizzare una procedura che esegua c = A[64] x B[64].
A.A. 2009/2010
Il prodotto scalare tra due vettori si realizza sommando i vari prodotti risultanti dalla moltiplicazione elemento per elemento: c = (A[0] x B[0]) + (A[1] x B[1]) + (A[2] x B[2]) + (A[3] x B[3]) + (A*4+ x B*4+) + (A*5+ x B*5+) + Quindi per ottenere il risultato bisogner innanzitutto moltiplicare i due vettori con loperazione vettoriale MULV.D, successivamente dividere il vettore risultante in due sottovettori e sommarli. Tale divisione e somma devessere ripetuta fino a che non si giunge ad un unico elemento scalare che sar poi il risultato finale (riduzione a scalare). Essendo i due vettori di dimensione 64 non vi sono problemi per quanto riguarda la moltiplicazione iniziale, e non vi bisogno di alcun loop. Utilizziamo R1 per contenere la dimensione del vettore. Utilizziamo R2 per contenere lindirizzo in memoria del primo elemento del vettore A. Utilizziamo R3 per contenere lindirizzo in memoria del primo elemento del vettore B. Utilizziamo R4 per contenere limmediato costante 1, per poi utilizzarlo come condizione di disuguaglianza nel branch. Utilizziamo R5 per contenere limmediato costante 2, per poi fare la divisione a met del vettore risultato della moltiplicazione (loperazione DDIVI non esiste!). Utilizziamo R6 come indice per puntare alla seconda met del sottovettore. DADDI MTC1 LV LV MULV.D SV R1, R0, #64 VLR, R1 V1, 0(R2) V2, 0(R3) V1, V1, V2 0(R2), V1
Impostiamo le costanti 1 e 2: DADDI DADDI R4, R0, #1 R5, R0, #2
Iniziamo il loop. Nel loop dovremo inizialmente dividere il vettore per due, e poi impostare un indice che punti al secondo sottovettore moltiplicando la dimensione dei due sottovettori (nella prima iterazione 64/2=32) per 8 byte. Poi si caricano i vettori, si sommano ed infine store. Ultima istruzione, branch, se il risultato della divisione diverso da 1, allora ripeti il loop, se non lo , hai finito. loop: DDIV MTC1 DMULI LV LV ADDV.D R1, R1, R5 VLR, R1 R6, R1, #8 V1, 0(R2) V2, R6(R2) V1, V1, V2 Pagina 62 Pietroleonardo Nicola Stroppa Fabio

SV BNE 0(R2), V1 R1, R4, loop
A.A. 2009/2010
Lo scalare c sar salvato allindirizzo di memoria R2, che inizialmente conteneva il primo elemento del vettore. Il listato completo : DADDI MTC1 LV LV stallo MULV.D SV DADDI DADDI DDIV MTC1 DMULI LV LV stallo ADDV.D SV BNE stallo R1, R0, #64 VLR, R1 V1, 0(R2) V2, 0(R3) V1, V1, V2 0(R2), V1 R4, R0, #1 R5, R0, #2 R1, R1, R5 VLR, R1 R6, R1, #8 V1, 0(R2) V2, R6(R2) V1, V1, V2 0(R2), V1 R1, R4, loop
loop:
Riordiniamo il programma per eliminare eventuali stalli. Non si sono considerati gli stalli dovuti alla fase EX delle unit floating point, quale moltiplicatore e sommatore: il loro output sar ottenuto solo dopo un numero di colpi di clock che varia in base alla latenza di tali unit, ed quindi incalcolabile ad occhio quando questi provocheranno uno stallo. DADDI R1, R0, #64 MTC1 VLR, R1 LV V1, 0(R2) LV V2, 0(R3) DADDI R4, R0, #1 MULV.D V1, V1, V2 SV 0(R2), V1 DADDI R5, R0, #2 DDIV R1, R1, R5 MTC1 VLR, R1 DMULI R6, R1, #8 LV V1, 0(R2) LV V2, R6(R2) stallo non eliminabile ADDV.D V1, V1, V2 BNE R1, R4, loop SV 0(R2), V1
loop:
Pagina 63

Dispense Calcolatori Elettronici Con Esercizi

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Dispense Calcolatori Elettronici Con Esercizi

Enviado por

Direitos autorais:

Formatos disponíveis

Appunti di Calcolatori Elettronici

APPUNTI DI CALCOLATORI ELETTRONICI

E DI T OR: N ic o la P ie t ro le o n a r d o P ROD UZ I ON E : N ic o la P ie t ro l e o n a rd o , Fa b io S t ro p p a GRA FI C A DI COP E R TI N A : Fa b riz io P . Ba ld in i - h t t p :// w ww . b a ld u s. a lt e r vist a . o rg /

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

IND I CE G E NE R AL E PARTE PRIMA .................................................................................................................................. 7

Appunti di Calcolatori Elettronici

SROTOLAMENTO DEL LOOP ....................................................................................................................... 41 PIPELINE DA PROGRAMMA ....................................................................................................................... 43

PARTE SECONDA .......................................................................................................................... 62

FALLIMENTI DI ACCESSO ALLA CACHE LEGGE DELLE TRE C ........................................................................... 69

Appunti di Calcolatori Elettronici

PARTE TERZA ................................................................................................................................ 84

PARTE QUARTA ............................................................................................................................ 99

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

MEMORIA CONDIVISA E MEMORIA DISTRIBUITA IN SISTEMI MULTICORE ............................................................ 125

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

PARTE PRIMA PROCESSORE SCALARE

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

REGISTRI FLOATING POINT

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

Il SET-ISTRUZIONI completo del MIPS64 disponibile al seguente link: http://www.mips.com/products/architectures/mips64/

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici

ALUOUTPUT NPC + IMM Cond ( A op 0 )

CALCOLATORI ELETTRONICI A.A. 2009/2010

Pietroleonardo Nicola Stroppa Fabio

Appunti di Calcolatori Elettronici