1 Esercizio. 2 Esercizio

Transcript

1 1 Esercizio Un numero relativo è rappresentato in virgola mobile secondo lo standard IEEE 754 su 32 bit nel seguente modo: s = 1 e = m = Ricavare il corrispondente valore decimale. Soluzione Dato che: e = = Si ha: N = ( 1)s 2 (e 127) 1.m = = = = ( )10 = Esercizio Convertire i seguenti numeri decimali in virgola mobile in singola precisione secondo lo standard IEEE 754: 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.

2 N 10 = = = s = = 1 e = 4 er = = = m = = (con hidden bit) NFP = = C1BB N 10 = = = s = = 1 e = 6 er = = = m = = (con hidden bit) NFP = = C2FE N 10 = = = s = + =0 e = 7 er = = 134 = m = = (con hidden bit) NFP = = N 10 = = = s = = 1 e = 8 er = = 135 = m = = (con hidden bit) NFP = = C 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.

3 N 10 = = = s = = 1 e = 1 er = = 128 = m = = (con hidden bit) NFP = = C Esercizio Siano dati i seguenti numeri binari in virgola mobile in singola precisione secondo lo standard IEEE 754, espressi in base sedici: 1. BE AA C301A C1FA Calcolare il corrispondente valore decimale. 1. NFP = BE = m = (con hidden bit) =1.001 er = = e = = 2 s = 1= N10 = = = ( ) = NFP = 438AA = m = (con hidden bit) = er = = e = = 8 s = 0=+ N10 = = = +( ) = NFP = C301A = m = (con hidden bit) = er = = e = = 7 s = 1= N10 = = = ( ) = NFP = C1FA =

4 m = (con hidden bit) = er = = e = = 4 s = 1= N10 = = = -( ) = 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 a (78)10 + b (26)10 a+b (104)10 R a (78)10 + b ( 26)10 a b (52)10 a = (-20)10 b = (14)10 R a ( 20)10 + b (14)10 a+b ( 6)10 R a ( 20)10 + b ( 14)10 a b ( 34)10 a = ( 12)10 b = ( 24)10 R a ( 12)10 + b ( 24)10 a+b ( 36)10 R a ( 12)10 + b (24)10 a b (12)10 a = (78)10 b = ( 82)10 R a (78)10 + b ( 82)10 a+b ( 4)10

5 R a (78)10 + b (82)10 a b overflow 4 Esercizio Siano dati i seguenti due numeri binari in virgola mobile, singola precisione: 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: A questo punto il risultato va rinormalizzato, scalando la mantissa, ottenendo: S = 0 E = = M = Esercizio Dati due numeri decimali A=0, 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, 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: > 0,546886*2= 1, , e la mantissa si legge dall'alto verso il basso. Il numero (I.D) risulta: , che normalizzato diventa:

6 x 2-1 Segno: 0 Esponente: = 126 = Mantissa: (ricordarsi di eliminare il bit nascosto) B: Si procede in modo analogo: I=2 codifica 10 D=0, Parte decimale =0011 Il numero risulta: , che normalizzato diventa: x 2 +1 Segno: 0 Esponente: = 128 = Mantissa: (ricordarsi di eliminare il bit nascosto) A: B: Ora per sommarli devo portarli ad avere lo stesso esponente: A: -1 B: +1 B ha esponente più grande, quindi traslo A: x x 2 +1 Ora posso sommare i due numeri dato che hanno lo stesso esponente, considerando (per B) anche il bit nascosto: Il risultato quindi sarà: Cioè: Esponente: > 128 -> exp = = 1 Numero: (riaggiungo il bit nascosto) x 2 +1 = Che, riconvertendo parte intera e parte decimale separatamente diventa: che è il risultato di

7 6 Esercizio Dati due numeri decimali A=0, e B=2,1875, effettuare la differenza B-A e A-B: Soluzione: I due numeri hanno la codifica come prima. A: x 2-1 Segno: 0 Esponente: = 126 = Mantissa: B: x 2 +1 Segno: 0 Esponente: = 128 = Mantissa: B-A: devo portare i due numeri allo stesso esponente: B ha esponente più grande, quindi traslo A: x x 2 +1 ora faccio il complemento a 2 di A (aggiungo un bit di segno): > (partendo da destra, come solito, si fa il complemento a 2) E faccio la solita somma binaria: (il primo bit dà il segno del risultato) Quindi il risultato è: x > x 2 +0 Il numero in virgola mobile è quindi: Segno: 0 Esponente: 0 -> = 127 -> Mantissa: Che tradotto in decimale diventa: x > > A-B si procede come prima, devo portare i due numeri allo stesso esponente: B ha esponente più grande, quindi traslo A: x x 2 +1 A questo punto devo fare il complemento a 2 di B: > e faccio la somma: (A, con aggiunto primo bit positivo) (B in complemento a 2) (il primo bit dà il segno del risultato)

8 Dato che è negativo, devo fare il complemento a 2 (tralasciando il primo bit che è il segno sto operando in complemento a 2): > Quindi il risultato è: x > x 2 +0 Il numero in virgola mobile è quindi: Segno: 1 Esponente: 0 -> = 127 -> Mantissa: Che tradotto in decimale diventa diventa: x > > 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

9 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= = =610 a = DIM(archAuto)* MAX_AUTO_VENDIBILI+DIM(numAutoVendute) DIM(archAuto) = DIM(AutoVenduta)=610 DIM(numAutoVendute)=DIM(int)=4 a = 610*1000+4= Bytes ~= 595,70 KB

10 9 Esercizio Si consideri il seguente vettore di valori interi non ordinato: 10 C 45 2 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=d

11 Esercizio Si consideri il seguente vettore di valori interi non ordinato: 48 C 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

12 Esercizio Come sopra con Merge Sort

13 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;

14 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)

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: 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:

16 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: 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:

17 x0012 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 e quindi all inizio $11 vale 104. Analizzando il codice, il registro $11 non viene più modificato pertanto il suo valore alla fine è ) 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 $14= 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