1 Esercizio Un numero relativo è rappresentato in virgola mobile secondo lo standard IEEE 754 su 32 bit nel seguente modo: s = 1 e = 10000111 m = 11011000000000000000000 Ricavare il corrispondente valore decimale. Soluzione Dato che: e = 100001112 = 13510 Si ha: N = ( 1)s 2 (e 127) 1.m = 1 2 135 127 1.11011 = 1 2 8 1.11011 = 1110110002 = (2 8 + 2 7 + 2 6 + 2 4 + 2 3 )10 = 47210 2 Esercizio Convertire i seguenti numeri decimali in virgola mobile in singola precisione secondo lo standard IEEE 754: 1. 23.37510 2. 127.2510 3. +131.510 4. 300.2510 5. 3.610 Procedendo in base alla definizione dello standard e indicando con N 10 in numero originale in base dieci s il segno del numero e l esponente del numero er l esponente rappresentato in floating point m la mantissa della rappresentazione NFP il numero nella rappresentazione in floating point si ha: 1.
N 10 = -23.37510 = -10111.011 2 = -1.0111011 2 2 4 s = = 1 e = 4 er = 4 + 127 = 131 10 = 10000011 2 m = 1.0111011 = 0111011 (con hidden bit) NFP = 1 10000011 0111011000... = C1BB0000 16 2. N 10 = -127.2510 = -1111111.01 2 = -1.11111101 2 2 6 s = = 1 e = 6 er = 127 + 6 = 133 10 = 10000101 2 m = 1.11111101 = 11111101 (con hidden bit) NFP = 1 10000101 111111010000... = C2FE8000 16 3. N 10 = 131.510 = 10000011.1 2 = 1.00000111 2 2 7 s = + =0 e = 7 er = 127 + 7 = 134 = 10000110 2 m = 1.00000111 = 00000111 (con hidden bit) NFP = 0 10000110 00000111000... = 43038000 16 4. N 10 = -300.2510 = -100101100.01 2 = -1.0010110001 2 2 8 s = = 1 e = 8 er = 127 + 8 = 135 = 10000111 2 m = 1.0010110001 = 0010110001 (con hidden bit) NFP = 1 10000111 00101100010... = C3962000 16 5. In questo caso il numero decimale possiede infinite cifre nella rappresentazione binaria. La conversione in binario pu`o essere interrotta una volta ottenute 24 cifre totali (comprensive di parte intera e parte frazionaria, considerando il bit nascosto) oppure una volta ottenuta la precisione desiderata.
N 10 = 3.610 = 11.1001... 2 = 1.11001... 2 2 1 s = = 1 e = 1 er = 127 + 1 = 128 = 100000002 m = 1.11001... = 11001... (con hidden bit) NFP = 1 10000000 11001100110011001100110 = C0666666 16 3 Esercizio Siano dati i seguenti numeri binari in virgola mobile in singola precisione secondo lo standard IEEE 754, espressi in base sedici: 1. BE900000 16 2. 438AA000 16 3. C301A000 16 4. C1FA8000 16 Calcolare il corrispondente valore decimale. 1. NFP = BE900000 16 = 1 01111101 00100000000000000000000 2 m = 0010... (con hidden bit) =1.001 er = 011111012 = 125 10 e = 125 127 = 2 s = 1= N10 = 1.001 2 2 = 0.01001 = (1 2 2 + 1 2 5 ) = 0.2812510 2. NFP = 438AA000 16 = 0 10000111 00010101010000000000000 2 m = 00010101010... (con hidden bit) =1.0001010101 er = 10000111 = 135 10 e = 135 127 = 8 s = 0=+ N10 = +1.0001010101 2 8 = +100010101.01 = +(256 + 16 + 4 + 1 + 0.25) = +277.25 10 3. NFP = C301A000 16 = 1 10000110 00000011010000000000000 2 m = 0000001101... (con hidden bit) =1.0000001101 er = 10000110 = 134 10 e = 134 127 = 7 s = 1= N10 = 1.0000001101 2 7 = 10000001.101 = (128 + 1 + 0.5 + 0.125) = 129.62510 4. NFP = C1FA8000 16 = 1 10000011 11110101000000000000000 2
m = 111101010... (con hidden bit) =1.11110101 er = 10000011 = 131 10 e = 131 127 = 4 s = 1= N10 = 1.11110101 2 4 = 11111.0101 = -(16 + 8 + 4 + 2 + 1 + 0.25 + 0.0625) = -31.3125 10 Siano date le seguenti coppie (a, b) di numeri interi con segno espressi nella rappresentazione decimale: (78, 26); ( 20, 14); ( 12, 24); (78, 82). Calcolare il risultato delle operazioni (a + b) e (a b) in aritmetica binaria tra numeri interi con segno rappresentati in complemento a due su 8 bit. Indicare la presenza di un eventuale overflow. Soluzione: a = (78)10 b = (26)10 R 0 0 0 1 1 1 1 0 a 0 1 0 0 1 1 1 0 + (78)10 + b 0 0 0 1 1 0 1 0 (26)10 a+b 0 1 1 0 1 0 0 0 (104)10 R 1 1 0 0 1 1 1 0 a 0 1 0 0 1 1 1 0 + (78)10 + b 1 1 1 0 0 1 1 0 ( 26)10 a b 0 0 1 1 0 1 0 0 (52)10 a = (-20)10 b = (14)10 R 0 0 0 0 1 1 0 0 a 1 1 1 0 1 1 0 0 + ( 20)10 + b 0 0 0 0 1 1 1 0 (14)10 a+b 1 1 1 1 1 0 1 0 ( 6)10 R 1 1 1 0 0 0 0 0 a 1 1 1 0 1 1 0 0 + ( 20)10 + b 1 1 1 1 0 0 1 0 ( 14)10 a b 1 1 0 1 1 1 1 0 ( 34)10 a = ( 12)10 b = ( 24)10 R 1 1 1 0 0 0 0 0 a 1 1 1 1 0 1 0 0 + ( 12)10 + b 1 1 1 0 1 0 0 0 ( 24)10 a+b 1 1 0 1 1 1 0 0 ( 36)10 R 1 1 1 1 0 0 0 0 a 1 1 1 1 0 1 0 0 + ( 12)10 + b 0 0 0 1 1 0 0 0 (24)10 a b 0 0 0 0 1 1 0 0 (12)10 a = (78)10 b = ( 82)10 R 0 0 0 0 1 1 1 0 a 0 1 0 0 1 1 1 0 + (78)10 + b 1 0 1 0 1 1 1 0 ( 82)10 a+b 1 1 1 1 1 1 0 0 ( 4)10
R 0 1 0 1 1 1 1 0 a 0 1 0 0 1 1 1 0 + (78)10 + b 0 1 0 1 0 0 1 0 (82)10 a b 1 0 1 0 0 0 0 0 overflow 4 Esercizio Siano dati i seguenti due numeri binari in virgola mobile, singola precisione: 0 10000011 01011000000000000000000 0 10000011 10110100000000000000000 Si ricavi la loro somma. Soluzione: Poiché i due numeri hanno lo sesso esponente (131), si possono sommare le mantisse (includendo il bit nascosto), per ottenere: 1.010110 + 1.101101 ---------------- 11.000011 A questo punto il risultato va rinormalizzato, scalando la mantissa, ottenendo: S = 0 E = 10000011 + 1 = 10000100 M = 000011 0 10000100 00001100000000000000000 5 Esercizio Dati due numeri decimali A=0,546875 e B=2,1875. Fornire la codifica completa in virgola mobile a singola precisione di A e B. Effettuare la somma A+B Soluzione: Devo codificare in singola precisione i due numeri. Codifico separatamente la parte intera e la parte decimale. A: I=0 codifica=0 D=0,546875 Per la parte decimale, invece che fare la divisione per 2, moltiplico per 2. Se il risultato supera 1.0, l'uno viene messo nella colonna di sinistra e entra nella mantissa: 546875 -> 0,546886*2= 1,09375 1 + 0,09375 1 093750 0 187500 0 375000 0 750000 1 500000 1 000000 e la mantissa si legge dall'alto verso il basso. Il numero (I.D) risulta: 0.100011, che normalizzato diventa:
1.00011 x 2-1 Segno: 0 Esponente: -1 + 127 = 126 = 01111110 Mantissa: 000011 (ricordarsi di eliminare il bit nascosto) B: Si procede in modo analogo: I=2 codifica 10 D=0,1875 1875 0 3750 0 7500 1 5000 1 0000 Parte decimale =0011 Il numero risulta: 10.0011, che normalizzato diventa: 1.00011 x 2 +1 Segno: 0 Esponente: +1 + 127 = 128 = 10000000 Mantissa: 00011 (ricordarsi di eliminare il bit nascosto) A: 0 01111110 0000110000... B: 0 10000000 0001100000... Ora per sommarli devo portarli ad avere lo stesso esponente: A: -1 B: +1 B ha esponente più grande, quindi traslo A: 1.00011 x 2-1 0.0100011 x 2 +1 Ora posso sommare i due numeri dato che hanno lo stesso esponente, considerando (per B) anche il bit nascosto: 0.0100011 1.0001100 ----------- 1.0101111 Il risultato quindi sarà: 0 10000000 0101111000000 Cioè: Esponente: 10000000 -> 128 -> exp = 128-127 = 1 Numero: 1.0101111 (riaggiungo il bit nascosto) 1.0101111 x 2 +1 = 10.101111 Che, riconvertendo parte intera e parte decimale separatamente diventa: 2.734375 che è il risultato di 0.546875+2.1875
6 Esercizio Dati due numeri decimali A=0,546875 e B=2,1875, effettuare la differenza B-A e A-B: Soluzione: I due numeri hanno la codifica come prima. A: 1.00011 x 2-1 Segno: 0 Esponente: -1 + 127 = 126 = 01111110 Mantissa: 000011 B: 1.00011 x 2 +1 Segno: 0 Esponente: +1 + 127 = 128 = 10000000 Mantissa: 00011 B-A: devo portare i due numeri allo stesso esponente: B ha esponente più grande, quindi traslo A: 1.00011 x 2-1 0.0100011 x 2 +1 ora faccio il complemento a 2 di A (aggiungo un bit di segno): 00.0100011 -> 11.1011101 (partendo da destra, come solito, si fa il complemento a 2) E faccio la solita somma binaria: 01.0001100 + 11.1011101 ------------- 00.1101001 (il primo bit dà il segno del risultato) Quindi il risultato è: 0.1101001 x 2 +1 -> 1.101001 x 2 +0 Il numero in virgola mobile è quindi: Segno: 0 Esponente: 0 -> 0+127 = 127 -> 01111111 Mantissa: 101001 0 01111111 1010010000... Che tradotto in decimale diventa: 1.101001 x 2 +0 -> 1.101001 -> 1.640625 A-B si procede come prima, devo portare i due numeri allo stesso esponente: B ha esponente più grande, quindi traslo A: 1.00011 x 2-1 00.0100011 x 2 +1 A questo punto devo fare il complemento a 2 di B: 01.00011 -> 10.11101 e faccio la somma: 00.0100011 (A, con aggiunto primo bit positivo) 10.1110100 (B in complemento a 2) ------------- 11.0010111 (il primo bit dà il segno del risultato)
Dato che è negativo, devo fare il complemento a 2 (tralasciando il primo bit che è il segno sto operando in complemento a 2): 1.0010111 -> 0.1101001 Quindi il risultato è: 0.1101001 x 2 +1 -> 1.101001 x 2 +0 Il numero in virgola mobile è quindi: Segno: 1 Esponente: 0 -> 0+127 = 127 -> 01111111 Mantissa: 101001 1 01111111 10100100000... Che tradotto in decimale diventa diventa: -1.101001 x 2 +0 -> -1.101001 -> -1.640625 7 Esercizio Per ognuna delle espressioni logiche riportate nelle righe della tabella, assumendo le seguenti dichiarazioni: int a = 8, b = 11; char c= d ; indicare se l espressione è vera o falsa (scrivere V o F nella seconda colonna). (-a==a) && (a < 11) FALSA (c> a c< z ) && (a<7 && b>8) FALSA!(b<10 && a>7) (c!= h && c> a )VERA
8 Esercizio Si consideri la seguente sequenza di dichiarazione di strutture. #define MAX_AUTO_VENDIBILI 1000 typedef char stringa[50]; typedef struct{ int giorno; int mese; int anno; }Data; typedef struct{ stringa tipo; int numeroserie; }Optional; typedef struct{ stringa tipo; /* il tipo di auto */ int numerotelaio; Data datavendita; Optional listaoptional[10]; int numerooptional; /* il numero effettivo di optional di un auto */ } AutoVenduta; typedef struct{ AutoVenduta archauto[max_auto_vendibili]; int numautovendute; /* numero di auto vendute effettivamente dal concessionario */ }ArchivioAutoVendute; void main() { ArchivioAutoVendute a; //......CODICE... } Considerando un occupazione in byte per int(4), char(1), si valuti lo spazio occupato in memoria dall istanza a Soluzione: DIM(Data)=DIM(giorno)+DIM(mese)+DIM(anno)=3*DIM(int)=12; DIM(Optional)=DIM(tipo)+DIM(numeroSerie)= =DIM(stringa)+DIM(int)= =50*DIM(char)+DIM(int)= =50*1+4=54 DIM(AutoVenduta)=DIM(tipo)+DIM(numeroTelaio)+DIM(dataVendita)+DIM(listaOptional)*10+DIM(numeroO ptional) = =DIM(stringa)+DIM(int)+DIM(Data)+DIM(Optional)*10+ DIM(int)= =50*DIM(char)+2*DIM(int)+12+54*10= =50+8+12+540=610 a = DIM(archAuto)* MAX_AUTO_VENDIBILI+DIM(numAutoVendute) DIM(archAuto) = DIM(AutoVenduta)=610 DIM(numAutoVendute)=DIM(int)=4 a = 610*1000+4=610004 Bytes ~= 595,70 KB
9 Esercizio Si consideri il seguente vettore di valori interi non ordinato: 10 C 45 2 N 56 7 34 22 M si sostituisca a C e N il corrispondete codice ASCII decimale della prima lettera (maiuscola) del Cognome e del Nome e ad M la prima cifra non 0 partendo da destra del numero di matricola. C=ASCII(B)=66 N=ASCII(I)=73 M=d101608 10 66 45 2 73 56 7 34 22 8 8 66 45 2 73 56 7 34 22 10 8 10 45 2 73 56 7 34 22 66 8 10 45 2 73 56 7 34 22 66 8 10 45 2 73 56 7 34 22 66 8 7 45 2 73 56 10 34 22 66 8 7 45 2 73 56 10 34 22 66 8 7 10 2 73 56 45 34 22 66 8 7 10 2 73 56 45 34 22 66 8 7 10 2 73 56 45 34 22 66 8 7 10 2 73 56 45 34 22 66 8 7 2 10 73 56 45 34 22 66 8 7 2 10 73 56 45 34 22 66 2 7 8 10 73 56 45 34 22 66 2 7 8 10 73 56 45 34 22 66 2 7 8 10 73 56 45 34 22 66 2 7 8 10 73 56 45 34 22 66 2 7 8 10 73 56 45 34 22 66 2 7 8 10 73 56 45 34 22 66 2 7 8 10 66 56 45 34 22 73
2 7 8 10 66 56 45 34 22 73 2 7 8 10 66 56 45 34 22 73 2 7 8 10 66 56 45 34 22 73 2 7 8 10 66 56 45 34 22 73 2 7 8 10 66 56 45 34 22 73 2 7 8 10 66 56 45 34 22 73 2 7 8 10 22 34 45 56 66 73 2 7 8 10 22 34 45 56 66 73 2 7 8 10 22 34 45 56 66 73 10 Esercizio Si consideri il seguente vettore di valori interi non ordinato: 48 C 45 62 N M si sostituisca a C e N il corrispondete codice ASCII decimale della prima lettera (maiuscola) del Cognome e del Nome e ad M la prima cifra non 0 partendo da destra del numero di matricola. C=ASCII(B)=66 N=ASCII(I)=73 M=d101608
48 66 45 62 73 8 48 66 45 62 73 8 8 66 45 62 73 48 8 66 45 62 73 48 8 48 45 62 73 66 8 48 45 62 73 66 8 48 45 62 73 66 8 48 45 62 73 66 8 45 48 62 73 66 8 45 48 62 73 66 8 45 48 62 73 66 8 45 48 62 73 66 8 45 48 62 73 66 8 45 48 62 73 66 8 45 48 62 73 66 11 Esercizio Come sopra con Merge Sort 48 66 45 62 73 8 48 66 45 62 73 8 48 66 45 62 73 8 48 66 45 62 73 8 48 66 45 62 73 8 45 48 66 8 62 73 8 45 48 62 66 73
12 Esercizio Dato il seguente programma in linguaggio C si valuti il valore stampato al termine dell esecuzione, il costo e la complessità asintotica della funzione somma. #include <stdio.h> #include <stdlib.h> long int somma(unsigned char *m) { long int ris=0; while (*m!= 0xFF) { ris = 100*ris + (*m >> 4) * 10 + (*m & 0x0F); ++m; } return ris; } int main() { /* programma principale */ unsigned char mem[3]; mem[0]=0x56; mem[1]=0x32; mem[2]=0xff; printf("%ld \n",somma(mem)); return 0; } 13 Esercizio Scrivere il codice assembler MIPS che traduce il seguente frammento di codice C: /* calcolo della somma dei valori di un vettore */ int V[32]; int sum; int count; sum = 0; for ( count=0; count<32; count++ ) sum = sum + V[ count ]; Ipotizzare che l'array V sia memorizzato a partire dall'indirizzo 100 incluso e occupi fino all'indirizzo 228 escluso; sum è all'indirizzo 228; la somma è accumulata sul registro $4; l'indice count è mantenuto nel registro $5; la costante 32 è caricata in $6; i valori dell'array sono caricati in $7. addi $10,$0,0; addi $4, $0, 0; addi $5, $0, 0; addi $6, $0, 32; start_loop: slt $1, $6, $5; beq $0, $1, end_loop; muli $10,$5,4; lw $7, 100[$10]; add $4, $4, $7; addi $5, $5, 1; j start_loop;
end_loop: sw $4, 228[$0]; 14 Esercizio Si consideri un array V={1,-1,2,-3,4,5,-6,7,8,-9,10,11,12,13,-14,-15} memorizzato a partire dall'indirizzo 200 di memoria, un array W di 20 elementi nulli a partire dall'indirizzo 400 e una variabile X inizializzata a 0 memorizzata all'indirizzo 800 della memoria. Si valuti sotto tali condizioni l esecuzione della porzione di codice Assembly MIPS indicando lo stato finale del vettore W e della variabile X. addi $1, $0, 0; addi $3, $0, 64; //16*4 start_loop: slt $4, $1, $3; beq $0, $4, end_loop; lw $5, 200[$1]; slt $6, $0, $5; beq $0, $6, continue; sw $5, 400[$1]; continue: addi $1, $1, 4; j start_loop; end_loop: sw $1, 800[$0]; Soluzione: 1) Inizializzazione dei registri $1=0 e $3=16 2) Osservando il codice si individua il costrutto di un ciclo iterativo: la label start_loop definisce l inizio di un ciclo e la label end_loop la terminazione del ciclo. Il registro $i viene utilizzato come variabile di iterazione e utilizzata dalla coppia di istruzioni: slt $4, $1, $3; beq $0, $4, end_loop; per valutare se continuare o meno il ciclo sul test di condizione $i<$3 ovver $i<16. a. Se false si esce e si salta ad end_loop b. Si scrive in X il valore di $1 3) Il ciclo inizia prelevando il valore dalla memoria all indirizzo 200+$1 corrispondente a V*$1+ e scritto nel registro $5. 4) Il registro $5 viene utilizzato dalla coppia di istruzioni slt $6, $0, $5; beq $0, $6, continue; che realizza un test sul segno del valore contenuto in $5. (0<$5 o anche V[$1]>0) a. Si salta a continue se il test è falso ovvero per tutti i V[$1]<=0 b. Altrimenti si procede 5) Si scrive alla locazione 400[$i] il valore in $5 (V[$1]) 6) Si incremena il registro $i di 4 (i dati sono a 32bit quindi si va al valore successivo) 7) Si salta ad inizio ciclo $1=0 (4*0) V[0]=1 1>0 vero W[0]=V[0] W[0]=1 $1=4 (4*1) V[1]=-1-1 >0 falso jump to continue; e W[1]=0; $1=8 (4*2) V[2]=2 2>0 vero W[2]=V[2] W[2]=2 $1=12 (4*3) V[3]=-3-3>0 falso jump to continue; e W[3]=0. $1=60 (4*15)
V[15]=-15-15>0 falso jump to continue; e W[15]=0 Effetto: ricopiare in W i valori positivi di V. Alla fine del ciclo si ha: W={1,0,2,0,4,5,0,7,8,0,10,11,12,13,0,0,0,0,0,0} X = 64 Il codice assembly realizza quindi il codice C: int i=0, k=0, N=16, V[16], W[20]; while ( i < N ) { if ( V[i] > 0) W[i] = V[i]; i++; } 15 Esercizio Scrivere un frammento di programma Assembly MIPS che effettui la somma degli elementi di un vettore di n interi e descritto dal seguente frammento in linguaggio C: somma=0; for(i=0; i<n; i++) somma += x[i]; Assunzioni sui registri: somma $8; i $9; n $2; &x[0] $3; x[i] $10 addi $8,$0,0; addi $9,$0,0; for: slt $1,$9,$2; //$2=n $9=i => $1=1 se i<n beq $1,$0,exit;// si salta se $1=$0=0 lw $10,$0($3); add $8,$8,$10; addi $9,$9,1; addi $3,$3,4; j for; exit:... 16 Esercizio Tradurre in Assembly MIPS il seguente codice C: for (i=0; i<=100; i++) a[i] = b[i] + c; Si assuma che: 1) &a[0] locazione 1500; 2) &b[0] locazione 2000; 3) c $16 4) i $15 Soluzione 1:
Si usa il registro $2 per impostare il limite massimo del ciclo for; l uguaglianza a 100 comporta considerare come massimo valore di iterazione 101. Il registro $3 viene utilizzato per costruire l offset di accesso alla memoria a partire da una locazione di base ed aggiornato con incremento di 4 per tenere conto della rappresentazione a 32 bit dei numeri interi. addi $3,$0,0 addi $15,$0,0; addi $2,$0,101; //l uguaglianza a 100 comporta considerare 101 for: slt $1,$15,$2; //$2=101 $15=i => $1=1 se i<=100 beq $1,$0,exit; // si salta se $1=$0=0 lw $10,2000($3); //si legge b[i] e si carica $10 add $10,$10,$16; // si aggiunge $16 che rappresenta c sw $10,1500($3); //si scrive in memoria a[i] il valore di $10 addi $3,$3,4; // si somma 4 a $3 per il prossimo elemento addi $15,$15,1; // si incrementa $15 di un unità j for; // si ricomincia exit:... Soluzione 2: Per costruire un indice come offset di accesso alla memoria a partire da una locazione di base bisogna aggiornarlo con un incremento di 4 per tenere conto della rappresentazione a 32 bit dei numeri interi. Se si usa il registro $15 come indice e offset, esso va considerato a multipli di 4 ovvero considerare i*4. Il limite massimo del ciclo for prevede l uguaglianza a 100, questo comporta come massimo valore di iterazione 101; se utilizzato per testare l offset di accesso alla memoria esso allora va moltiplicato per 4 e pertanto il nuovo limite diventa 404. Tale limite verrà impostato sul registro $2. addi $15,$0,0; addi $2,$0,404; //Vedi considerazioni for: slt $1,$15,$2; //$2=404 $15=i*4 => $1=1 se i*4<=100 beq $1,$0,exit; // si salta se $1=$0=0 lw $10,2000($15); //si legge b[i] e si carica $10 add $10,$10,$16; // si aggiunge $16 che rappresenta c sw $10,1500($15); //si scrive in memoria a[i] il valore di $10 addi $15,$15,4; // si incrementa $15 di 4 j for; // si ricomincia exit:... 17 Esercizio Si valuti il comportamento del seguente frammento di codice assembly MIPS: addi $11, $12, 100 addi $16, $0, 11 muli $15, $16, 4 lw $14, 1024($15) add $14, $14, $11 subi $15, $15, 4 sw $14, 1024($15) //moltiplicazione con dato immediato //sottrazione con dato immediato Si assuma il seguente stato dei registri e della memoria prima dell esecuzione del blocco di istruzioni: 1. Registri: $12 = 4; 2. Memoria: a partire alla locazione di memoria espressa, in base dieci, 1024 sono memorizzati i seguenti valori espressi a byte:
0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 0x0012 0x0034 0x0033 0x0000 0x1111 0x0F0F 0x1200 0x00FF 0x0001 0x0300 0x0033 0x0000 0x1111 Si calcoli il valore memorizzato dal registro $11 e alla locazione di memoria 1024($15) al termine dell esecuzione del codice. Soluzione: 1) Poichè il registro $12 è caricato col valore 4, $11 viene caricato con la somma di 4+100 e quindi all inizio $11 vale 104. Analizzando il codice, il registro $11 non viene più modificato pertanto il suo valore alla fine è 104. 2) Il registro $16 viene caricato col valore 11, l istruzione muli carica il registro $15 col valore 4*11=44 Il registro $15 viene utilizzato come offset per l accesso alla memoria a partire dalla locazione 1024 e considerando i dati organizzati a 4 byte si deve accedere all 11 gruppo di 4 byte e quindi al valore 0x0000 (esadecimale). Pertanto il registro $14 conterrà il valore 0 (decimale). Ad $14 si somma il contenuto di $11 e quindi si effettua la somma 104+0. $14=104 10. Il registro $15 viene decrementato di 4 e utilizzato da sw come offset per la scrittura del contenuto di $14. L offset è quello del 10 gruppo dei quattro byte. Pertanto si scriverà in memoria il valore 104 10