Lezione di Tutorato Di Architettura degli Elaboratori B 29/04/2005. SOLUZIONI: Cache

Transcript

1 SOLUZIONI: Cache INTRODUZIONE Gerarchie di memoria: CPU Gli elaboratori con architettura alla Von Neumann soffrono del problema del Von Neumann Bottleneck nell accesso alla memoria. Per ovviare a questo problema si strutturata la Liv 1 memoria in maniera gerarchica: Liv.1: memoria più veloce (piccola, costosa). Livello 2 Liv.n: memoria più lenta (grande economica) Il processore indirizza tutta la memoria di Liv.n, ma accede direttamente solo al Liv.1. L obiettivo di questa soluzione è di dare l illusione di avere una memoria veloce come a Liv.1 e Livello n grande come a Liv.n. Questo meccanismo per la risoluzione del problema del Von Neumann bottleneck funziona per il principio di località. Località temporale: nell esecuzione di un programma si tende a riferire elementi di memoria che sono stati riferiti di recente. Località spaziale nell esecuzione di un programma si tende a riferire elementi di memoria vicini a quelli riferiti di recente. La memoria di Liv1 è solitamente chiamata cache, quella di Liv2 memoria principale e quella di Liv3 memoria di massa. TERMINOLOGIA: Hit: (Successo) il blocco cercato a Livello i è presente Miss: (Fallimento) il blocco cercato a Livello i non è presente (compulsory, capacity, conflict) Hit rate (%): percentuale di Hit rispetto ai tentativi di accesso a blocchi del Livello i Miss rate (%): frequenza di Miss rispetto ai tentativi di accesso a blocchi del Livello i Hit Time: latenza di accesso di un blocco al Livello i in caso di Hit Miss Penalty: tempo richiesto per trasferire un blocco dal livello inferiore 1. Per una certa architettura e per un certo compilatore CompA, i CPI medi per le varie classi di istruzioni (senza considerare l effetto della cache) sono i seguenti, distribuiti nella seguente: (vedi tabella). Impiegando un nuovo compilatore, CompB, i CPI medi rimangono invariati, l instruction count (IC) aumenta del 15%, ma varia la distribuzione delle istruzioni. CPI l/s = 2 CPI aritm = 1 CPI fp = 4, CPI b/j = 1,8 CompA Perc l/s = 30% Perc aritm = 40% Perc fp = 10% Perc b/j = 20% CompB Perc l/s = 20% Perc aritm = 60% Perc fp = 10% Perc b/j = 10%. Calcolare quale dei due codici prodotti risulta più veloce, e lo speedup relativo. Considerare infine l effetto della cache sui tempi di esecuzione. In entrambi i casi abbiamo instruction miss rate=2%, data miss rate=5%, e miss penalty=5 cicli. Ricalcolare lo speedup considerando l effetto della cache. Risp.: Calcoliamo i due CPI medi: CPI A = 2 * * * * 0.2 = 1.76 CPI B = 2 * * * * 0.1 = 1.58 Inoltre, sappiamo che IC B = 1.15 * IC A. I tempi di esecuzione nei due casi sono: ExeTime A = IC A * CPI A * T = T * (IC A * 1.76) ExeTime B = IC B * CPI B * T = T * (1.15 * IC A * 1.58) = T * (IC A * 1.82) Quindi il caso A è più veloce, da cui: Speedup = ExeTime B / ExeTime A = 1.82 / 1.76 = Vediamo gli effetti della cache nei due casi: Penalty A =(0.02*IC A * 0.3*IC A )*MissPenalty=( *0.3)*5 * IC A = * IC A Penalty B =(0.02*IC B * 0.2*IC B )*MissPenalty=( *0.2)*5 * 1.15 * IC A = * IC A Quindi: ExeTime A = T * (IC A * IC A * 0.175) = T * IC A * ExeTime B = T * (IC A * IC A * ) = T * IC A * Il caso A è ancora più veloce: Speedup = ExeTime B / ExeTime A = /1.935 =

2 2. Sappiamo che, per certo mix di programmi e senza considerare gli stalli dovuti ai cache miss, il CPI delle istruzioni di lw/sw è 3, mentre il CPI di tutte le altre istruzioni è 2. Le istruzioni di lw/sw sono il 25% di tutte le istruzioni. Valutare le seguenti architetture, per le quali i CPI di sopra rimangono invariati: a) processore 250MHz, data miss rate=5%, instruction miss rate=2%, miss penalty=10 cicli. b) processore 500MHz, data miss rate=3%, instruction miss rate=2%, miss penalty=15 cicli. Quale delle due architetture esegue più cicli? Qual è più veloce e di quanto? Soluzione #cicli no miss = IC * (0.25 * CPI l/w * CPI altro ) = IC * (0.25 * * 2) = IC * 2.25 #cicli a = #cicli no miss + (5%(0.25 * IC) + 2%IC) MissPenalty = = IC * IC* ( ) * 10 = = IC * ( ) = * IC #cicli b = #cicli no miss + (3%(0.25 * IC) + 2%IC) MissPenalty = = IC * IC* ( ) * 15 = = IC * ( ) = IC Quindi l architettura (b) esegue un numero maggiore di cicli. Rispetto al tempo di esecuzione: ExeTime a = * IC * T = * IC * 1/(250 * 10 6 ) = * IC/10 6 s. ExeTime b = * IC * T = * IC * 1/(500 * 10 6 ) = * IC/10 6 s. Da cui l architettura (b) risulta essere più veloce, con speedup: Speedup = ExeTime a / ExeTime b = / = Calcolare il miss penalty, considerando che instruction miss rate=2%, data miss rate=5%, la percentuale di istruzioni di load/store è del 25%, il CPI ideale (ovvero senza i cache miss) è 2, mentre il CPI reale è 2.5. Introducendo una nuova tecnologia di memoria cache, che riduce della metà i penalty, qual è lo speedup ottenibile? CPI reale = (IC * CPI ideale * IC * MissPenalty * 0.25 * IC * MissPenalty) / IC = = CPI ideale * MissPenalty * MissPenalty = = CPI ideale * MissPenalty. Sostituendo CPI reale = 2.5 in: CPI reale = CPI ideale * MissPenalty si ottiene: 2.5 = * MissPenalty Da cui: MissPenalty = Se il miss penalty viene ridotto, abbiamo che CPI reale = CPI ideale * MissPenalty * 0.5= * * 0.5 = Lo speedup è calcolato come il rapporto tra i CPI reali, poiché il ciclo di clock e IC non cambiano: Speedup = CPI reale / CPI reale = 2.5/2.25 = 1.1

3 4. Abbiamo le seguenti misure relative ad un processore a 2 GHz, quando usato per eseguire un certo insieme di programmi: CPI ideale = 2, Perc l/s = 20%, Data miss rate = 30%, Instr miss rate = 5%, CPI reale = 2, 4. Qual `e il valore del Miss penalty? Sappiamo che, portando la frequenza di clock a 2,2 GHz, otteniamo invece un CPI reale = 2,5. Qual `e il valore del Miss penalty in questo caso? Sappiamo che: CPI miss = CPI reale CPI ideale = 2,4 2 = 0,4 CPI miss = ( 0,05 * IC * MissPenalty + 0,3 * 0,2 * IC * MissPenalty )/IC 0, 4 = 0,05 * MissPenalty + 0,06 * MissPenalty Quindi per il processore a 2 GHz abbiamo che: MissPenalty = 3,63 e che: da cui: Per il secondo processore l organizzazione della cache e il codice da eseguire non cambiano, quindi il miss rate rimane invariato, mentre può cambiare il miss penalty. Abbiamo quindi che: CPI miss = CPI reale CPI ideale = 2,5 2 = 0,5 Riprendendo l equazione di sopra, abbiamo che 0, 5 = 0,05 * MissPenalty + 0,06 * MissPenalty Quindi per il processore a 2,2 GHz abbiamo che: MissPenalty = 4, Si consideri l esecuzione di un programma P su di una data CPU. Il CPI ideale è pari a 3, ma considerando i miss della cache si ottiene un CPI reale pari a 3.6. Sapendo inoltre che MissPenalty = 12 cicli e che InstructionMissRate = 4% determinare Data miss rate per il programma considerato, tenendo conto che la Perc l/s è del 40%. Sappiamo che: #cicli = CPI reale * IC = = CPI ideale * IC + (IC * Perc l/s * DataMissRate * MissPenalty) + = (IC * InstructionMissRate * MissPenalty) Applicando l inversa di CPI = #cicli / IC: CPI reale = #cicli / IC = = CPI ideale + Perc l/s * DataMissRate * MissPenalty + + InstructionMissRate * MissPenalty = = * DataMissRate * * 12 = CPI reale = DataMissRate Sostituendo CPI reale si ottiene: 3.6 = * DataMissRate Da cui si ha: DataMissRate = ( ) / 4.8 = cioè 2.5%

4 INTRODUZIONE Dimensionamenti cache: Consideriamo ora i problemi relativi al dimensionamento e organizzazione della memoria cache. Se l indirizzo (memoria principale) è di m bit e la dimensione del blocco è 2 n, allora gli m-n bit più significativi rappresentano l indirizzo del blocco, i rimanenti l offset all interno del blocco. Cache diretta In questa organizzazione di cache ogni blocco di memoria può essere inserito in un unico blocco della cache Cache block index = Mem. block address MOD #(cache blocks) Se #(cache blocks) = 2 k allora il Cache block index è dato dai k bit meno significativi del Mem. block address. Cache n-way associative In questa organizzazione della cache i blocchi di cache sono suddivisi in set (insiemi) di dimensione n. Ogni blocco di memoria può essere inserito in uno degli n blocchi di un set (riducendo così la possibilità di conflitti). Il numero dei set di blocchi in cache è: #(cache sets) = #(cache blocks) / n Mentre, per un dato blocco di memoria, l indice del set nella cache sarà: Cache set index = Mem. block address MOD #(cache sets) Se #(cache sets) = 2 k allora il Cache set index è dato dai k bit meno significativi del Mem. block address. 6. Calcolare il numero di insiemi ed il livello di associatività in una cache set-associative dove siano noti l INDEX, la dimensione (parte dati) della cache, la TAG e la dimensione dell indirizzo fisico. In particolare abbiamo che: Cache size =1 MB, TAG size =13 b, ADDR size = 30 b, INDEX size =11 b. Sappiamo che: Il block offset è uguale a: OFFSET size = ADDR size TAG size INDEX size = 30b 13b 11b = 6b. Quindi la dimensione di ogni blocco è: Block size = 2 OFFSETsize = 2 6 = 64 B Il numero di sets della cache è quindi: #Sets = 2 INDEXsize = 2 11 insiemi Ogni insieme è grande: Sets size = Cache size / #Sets = 2 20 / 2 11 = 2 9 B. = 512 B Ogni insieme contiene quindi. n = Sets size / Block size = 512B / 64B = 2 9 / 2 6 = 2 3 = 8 Per cui la cache è associativa ad 8 vie (8-way associative) 7. Considerare una cache associativa a 4 vie (n = 4), con una parte dati in grado di memorizzare 512 KB, e i cui blocchi sono grandi 32 B. L indirizzo fisico con cui si accede alla cache è di 27 b (ADDR size ). Calcolare la dimensione della TAG della cache. Il numero di blocchi totali della cache è: #Blocks = Cache size / Block size = 512 * 2 10 B / 32 B = 16 * 2 10 = Il numero di insiemi della cache è: #Set = #Block / n = 2 14 / 4 = 2 12 Da cui si può calcolare INDEX size INDEX = log = 12 b. Poiché l OFFSET size = log 2 32 = 5, si ha che TAG size è: TAG size = ADDR size - INDEX size - OFFSET size = = 10b.

5 8. Si consideri il seguente programma assembly, all inizio del loop sia $4=0x1000a0. loop: lw $2, 0($4) sw $2, 4($4) addi $4, $4, 8 bne $4, $5, loop Per semplicità, si consideri che gli indirizzi riferiti dal programma siano tutti fisici, e che questi indirizzi siano usati per accedere una cache dati con le seguenti caratteristiche: diretta, composta di 256 blocchi, da 16 B ciascuno. Qual `e la sequenza di blocchi di cache (identificati dall INDEX) acceduti dal programma? Supponendo che all inizio i blocchi siano tutti non validi, per quali istruzioni abbiamo hit e per quali miss (calcolare il data miss rate)? Il programma scorre un array di interi, e copia ciascun elemento in posizione i nella posizione i + 1. L indice i viene incrementato di 2 ad ogni iterazione (istruzione addi). Date le caratteristiche della cache, abbiamo che: INDEX = log = 8, OFFSET = log 2 16 = 4. La rappresentazione esadecimale dell indirizzo suddiviso in TAG, INDEX e OFFSET è quindi la seguente (esempio per il indirizzo riferito dalla prima lw $4=0x1000a0): TAG INDEX OFFSET a 0 Il programma accede quindi ai blocchi in sequenza a partire dal blocco ox0a = 10dieci, che viene usato per due iterazioni del ciclo, per poi passare al blocco ox0b = 11dieci (1000a0 + 8 = 1000a8 1 iter. e 1000a8+8=1000b0 2 iter.), per poi passare al blocco 0x0c = 12dieci (1000b0 + 8 = 1000b8 1 iter. e 1000b8+8=1000c0 2 iter.), e così via. Il programma esegue la seguente sequenza di istruzioni di accesso alla memoria. A fianco di ogni istruzione abbiamo indicato se si tratta di hit o miss: 1 lw (miss) 2 sw (hit) 3 lw (hit) 4 sw (hit) 5 lw (miss) 6 sw (hit) 7 lw (hit) 8 sw (hit) La prima istruzione di accesso alla memoria (intero da 4B) genera sicuramente un miss ma, una volta risolto, le prossime tre istruzioni che si riferiscono ai 3 interi successivi generano un hit perché ancora dentro allo stesso blocco. Quindi si ha che il 25% degli accessi alla memoria genera un miss e quindi il DataMissRate = 0.25

6 9. Considerare una cache 4-way associative, con parte dati di 8 KB organizzata in blocchi da 32 B. L indirizzo fisico è di 16 bit. a. Determinare la suddivisione dell indirizzo fisico nei campi TAG, INDEX, OFFSET OFFSET size = log 2 Block size = log 2 32 = 5 bit #blocks = Cache size / Block size = 8KB / 32B = 2 13 / 2 5 = 2 8 = 256 blocchi Poiché la cache è 4-way associative si ha: #Sets = #Blocks / n = 2 8 / 2 2 = 2 6 = 64 set Quindi INDEX size = log 2 #Sets = log = 6 bit Quindi TAG size = ADDR size INDEX size OFFSET size = = 5 bit TAG size = 5 bit ; INDEX size = 6 bit ; OFFSET size = 5 bit b. Stabilire se gli indirizzi 0xAFAF e 0xAFB0 sono mappati nello stesso set della cache. TAG INDEX OFFSET 0xAFAF = = xAFB0 = = I due INDEX sono uguali quindi i contenuti dei due indirizzi compaiono nello stesso set. c. Supponendo che il contenuto di 0xAFAF sia nella cache, cosa accade se tentiamo di leggere il contenuto di 0xAFB0? I due indirizzi hanno lo stesso TAG, quindi sono nello stesso blocco. Pertanto se il contenuto di 0xAFAF si trova nella cache, vi sarà anche quello di 0xAFB0 (i due indirizzi sono contigui). d. Che cosa succede invece per gli indirizzi 0xAFAF e 0xA7B0? TAG INDEX OFFSET 0xAFAF = = xA7B0 = = Anche in questo caso, i contenuti dei due indirizzi si trovano nello stesso set. Ma ora i due indirizzi hanno TAG diverso. Quindi, se il contenuto di 0xAFAF è nella cache, non è detto che ci sia anche quello di 0xAFB0 e. E nel caso la cache fosse 2-way associative? #Blocks = 2 8 Dato che la cache è 2-way associative si hanno 2 8 / 2 = 2 7 set e quindi INDEX = 7 bit TAG INDEX OFFSET 0xAFAF = = xA7B0 = = I due indirizzi considerati sono su set diversi! f. Come sono ripartiti i campi TAG, INDEX e OFFSET se invece la cache è completamente associativa? OFFSET size = log 2 Block size = log 2 32 = 5 bit #blocks = Cache size / Block size = 8KB / 32B = 2 13 / 2 5 = 2 8 = 256 blocchi Poiché la cache è completamente associativa vi è un unico set con 2 8 blocchi (n = 2 8 ). #Sets = #Blocks / n = 2 8 / 2 8 = 1 set Quindi INDEX size = log 2 #Sets = log 2 1 = 0 bit Quindi TAG size = ADDR size INDEX size OFFSET size = = 11 bit TAG size = 11 bit ; INDEX size = 0 bit ; OFFSET size = 5 bit