ESERCIZIO 1 Si consideri la seguente funzione f (A, B, C, D) non completamente specificata definita attraverso il suo ON-SET e DC-SET:

Transcript

1 Università degli Studi di Milano Corso Architettura degli elaboratori e delle reti Prof. Cristina Silvano A.A. 2004/2005 Esame scritto del 15 luglio 2005 Cognome: Matricola: Nome: Istruzioni Scrivere solo sui fogli distribuiti negli spazi indicati - utilizzando il retro delle pagine in caso di necessità. Non separare questi fogli. È vietato portare all esame libri, eserciziari, appunti e calcolatrici. Chiunque venga trovato in possesso di documentazione relativa al corso anche se non strettamente attinente alle domande proposte vedrà annullata la propria prova. Non è possibile lasciare l aula conservando il tema della prova in corso. ESERCIZIO 1 Si consideri la seguente funzione f (A, B, C, D) non completamente specificata definita attraverso il suo ON-SET e DC-SET: f (A, B, C, D): ON- SET {m5, m8, m12, m13, m15} DC- SET {m0, m2, m10, m14 }. Facendo uso della sua mappa di Karnaugh: AB CD 00 X X 0 X X Calcolare gli implicanti primi: AB, AD, B D, BC D Calcolare gli implicanti primi essenziali: BC D, AB Calcolare una copertura minima della funzione: BC D + A B + AD

2 Calcolare il costo della copertura minima ottenuta (utilizzando come costo il numero di letterali di ciascun termine prodotto): 7 Disegnare lo schema logico della copertura minima trovata: Se la copertura minima trovata non è unica, dire quante altre coperture minime esistono: 1 Se la copertura minima trovata non è unica, calcolare le altre coperture minime: BC D + AB + B D

3 ESERCIZIO 2 Tradurre in un linguaggio ad alto livello a scelta (C, Pascal, Java ecc.) la seguente porzione di codice assembly del processore MIPS. (Si supponga che i registri $t6 e $t7 siano stati inizializzati rispettivamente ai valori 0 e 4N. I simboli BASEA, BASEB, BASEC sono costanti a 16 bit, prefissate. SOLUZIONE BANALE: L1: beq $t6, $t7, EXIT if var6 = var7 go to EXIT lw $t2, BASEA ($t6) var2 <- BASEA[var6] add $t2, $t2, $t2 var2 <- 2 var 2 sw $t2, BASEA ($t6) BASEA[var6] <- var2 lw $t3, BASEB ($t6) var3 <- BASEB[var6] add $t3, $t3, $t3 var3 <- 2 var 3 sw $t3, BASEB ($t6) BASEA[var6] <- var3 add $t4, $t2, $t3 var4 <- var2 + var3 sw $t4, BASEC ($t6) BASEC[var6] <- var4 addi $t6, $t6, 4 var6 <- var6 +1 j L1 go to L1 EXIT : Codice ad alto livello corrispondente: SOLUZIONE: while (i!= N) { BASEA[i] = 2 * BASEA[i]; BASEB[i] = 2 * BASEB[i]; BASEC[i] = BASEA[i] + BASEB[i]; i++; }

4 ESERCIZIO 3 Si scriva in linguaggio assembly del processore MIPS la seguente procedura ricorsiva che calcola la funzione f(n) con n >=0 secondo la seguente definizione: f(0) = 0 f(1) = 1 f(n) = f (n-1) * f(n-2) se n >=2 Usare i registri $a0, ecc per il passaggio dei parametri alla procedura, i registri $t0 ecc. come variabili temporanee mentre il risultato deve essere restituito al chiamante tramite il registro $v0. # $a0 <- n FUNC: addi $sp, $sp, -12 sw $ra, 8($sp) sw $a0, 4($sp) sw $a1, 0($sp) # alloca lo stack # salvo return address # salvo n # salvo f(n-1) bgtz $a0, ONE # se n > 0 salta a ONE add $v0, $zero, $zero # se n==0 ritorna 0 j END ONE: slti $t0, $a0, 2 #set $t0 <-1 se $a0 <2 beq $t0, $zero, CORE # se $t0 == 0 salta a CORE addi $v0, $zero, 1 # se n==1 ritorna 1 j END CORE: addi $a0, $a0, -1 # $a0 <- n-1 jal FUNC # chiama f(n-1) move $a1, $v0 # salva f(n-1) in $a1 addi $a0, $a0, -1 # $a0 <- n-2 jal FUNC # chiama f(n-2) mul $v0, $v0, $a1 # f(n) <- f(n-1) * f(n-2) END: lw $ra, 8($sp) lw $a0, 4($sp) lw $a1, 0($sp) addi $sp, $sp, 12 jr $ra # ripristino return address # ripristino n # ripristino f(n-1) # dealloca lo stack

5 ESERCIZIO 4: Si consideri una cache a set associativa a 4 vie da 256 KByte e blocco da 128 bit (16 Byte) Calcolare il numero di blocchi presenti nella cache: Dim. Cache/ Dim. Blocco = 256 K Byte / 16 Byte = 16 K blocchi Calcolare il numero di insiemi presenti nella cache: Dim. Cache / (Dim. Blocco * 4) = 4 K insiemi Calcolare il numero di blocchi per insieme: 4 blocchi Calcolare il numero di comparatori necessari: 4 Si consideri la struttura dell indirizzo di memoria (32 bit). Calcolare il numero di bit necessari per lo spiazzamento (offset) del byte nella parola: 2 bit Calcolare il numero di bit necessari per lo spiazzamento (offset) della parola nel blocco: 2 bit Calcolare il numero di bit di indice: 12 bit Calcolare il numero di bit per l etichetta (tag): 16 bit

6 ESERCIZIO 5 Sia dato il seguente ciclo di un programma in linguaggio macchina MIPS. Si supponga che i registri $6, e $7 siano stati inizializzati rispettivamente ai valori 0 e 4N. I simboli BASEA, BASEB, e BASEC sono costanti a 16 bit, prefissate. Il ciclo di clock del processore vale 2 ns. Si consideri una singola iterazione del ciclo eseguita dal processore MIPS in modalità pipeline a 5 stadi senza ottimizzazioni. Individuare i conflitti sui dati di tipo RAW (Read After Write) e i conflitti sul controllo presenti nel programma e indicarli nell ultima colonna. Inserire nella prima colonna il numero di stalli da inserire prima di ciascuna istruzione in modo da risolvere i conflitti presenti nel programma. Num. stalli ISTRUZIONE C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12 C13 C14 C15 Tipo di conflitto L1:beq $t6,$t7, EXIT IF ID EX ME WB 3 lw $t2,basea($t6) IF ID EX ME WB C 3 add $t2,$t2,$t2 IF ID EX ME WB D 3 sw $t2,basea($t6) IF ID EX ME WB D lw $t3,baseb($t6) IF ID EX ME WB 3 add $t3,$t3,$t3 IF ID EX ME WB D 3 sw $t3,baseb($t6) IF ID EX ME WB D add $t4,$t2,$t3 IF ID EX ME WB 3 sw $t4,basec($t6) IF ID EX ME WB D addi $t6,$t6,4 IF ID EX ME WB J L1 IF ID EX ME WB 3 EXIT: IF ID EX ME WB C Scrivere il numero totale di stalli inseriti in una singola iterazione del programma: 21 Calcolare il CPI ottenuto asintoticamente (N cicli): CPI AS = (num. stalli + CI) / CI = / 11 = 2,9 Calcolare il Throughput (espresso in MIPS) ottenuto asintoticamente (N cicli): MIPS AS = f CLOCK /(CPI AS * 10 6 ) = (500 * 10 6 ) / (2,9 * 10 6 ) = 172,41

7 Num. stalli ESERCIZIO 6 Si consideri lo stesso programma precedente nel quale sia stato effettuato il riordino (scheduling) delle istruzioni. Si consideri una singola iterazione del nuovo ciclo eseguita dal processore MIPS in modalità pipeline a 5 stadi senza ottimizzazioni. Individuare i conflitti sui dati di tipo RAW (Read After Write) e i conflitti sul controllo presenti nel programma e indicarli nell ultima colonna. Inserire nella prima colonna il numero di stalli da inserire prima di ciascuna istruzione in modo da risolvere i conflitti presenti nel programma. ISTRUZIONE C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12 C13 C14 C15 Tipo di conflitto L1:lw $t2,basea($t6) IF ID EX ME WB lw $t3,baseb($t6) IF ID EX ME WB 2 add $t2,$t2,$t2 IF ID EX ME WB D add $t3,$t3,$t3 IF ID EX ME WB 3 add $t4,$t2,$t3 IF ID EX ME WB D sw $t2,basea($t6) IF ID EX ME WB sw $t3,baseb($t6) IF ID EX ME WB 1 sw $t4,basec($t6) IF ID EX ME WB 1 addi $t6,$t6,4 IF ID EX ME WB 3 bne $t6,$t7,l1 IF ID EX ME WB D 3 EXIT: IF ID EX ME WB C Scrivere il numero totale di stalli inseriti in una singola iterazione del programma: 12 Calcolare il CPI ottenuto asintoticamente (N cicli): CPI AS = (num. stalli + CI) / CI = (12+10) / 10 = 2,2 Calcolare il Throughput (espresso in MIPS) ottenuto asintoticamente (N cicli): MIPS AS = f CLOCK /(CPI AS * 10 6 ) = (500 * 10 6 ) / (2,2 * 10 6 ) = 227,27 Dire se risulta migliore il programma del precedente Esercizio (5) o il programma modificato e calcolare lo speed-up ottenuto: Risulta migliore il programma modificato Speed up = 227,27 /172,41 = 1,32