Matricola __________________ Nome _____________________ Cognome __________________

Università degli Studi di Udine

Corsi di laurea in Ingegneria Elettronica e Ingegneria Gestionale Architettura dei calcolatori / Fondamenti di Informatica II 23 settembre 2014 - Prova scritta

Matricola __________________

Nome _____________________

Cognome __________________

ISTRUZIONI (da leggere attentamente)

1) Lo studente è tenuto a scrivere, correggere, compilare ed eseguire su computer (a casa o in laboratorio) gli esercizi di programmazione prima della prova orale. Alla prova orale lo studente deve portare una memoria USB disk contenente i sorgenti dei programmi corretti e le stampe dei relativi file.

2) Non è consentito l’uso di libri, appunti, calcolatrici, telefoni cellulari.

3) Rispondere sinteticamente negli spazi di fianco o seguenti le domande, oppure sul retro del foglio.

1. (3 punti) Si eseguano le seguenti operazioni utilizzando la rappresentazione in complemento a 2 su 8 bit. Si scrivano i risultati in esadecimale e si indichino le eventuali condizioni di overflow. Riportare tutti i passaggi effettuati.

FD

+ AA

= _____

[ ] overflow

-64

- 64

= _____

[ ] overflow

2. (3 punti) In un sistema di trasmissione che fa uso di codici di Hamming a 1 bit viene ricevuta la parola 00111001000

. 1) è corretta?

2) se no, qual è il valore corretto della parola?

(scrivere tutti i passaggi necessari all’elaborazione della risposta)

3. (2 punti) Completare:

Dato un codice con distanza di Hamming pari a 7, è possibile rilevare un massimo di ________ bit errati e correggere un massimo di ______ bit errati.

Si consideri la libreria in linguaggio C per manipolare file bitmap vista a lezione, così definita:

typedef unsigned char byte;

typedef unsigned short int word;

typedef unsigned long int dword;

#define BMPFILETYPE 0x4D42

typedef struct tagCOLORTRIPLE {

byte blue;

byte green;

byte red;

} COLORTRIPLE;

typedef struct tagFILEHEADER {

word ImageFileType;

dword FileSize;

word Reserved1;

word Reserved2;

dword ImageDataOffset;

} FILEHEADER;

typedef struct tagBMPHEADER {

dword HeaderSize;

dword ImageWidth;

dword ImageHeight;

word NumberOfImagePlanes;

word BitsPerPixel;

dword CompressionMethod;

dword SizeOfBitmap;

dword HorizonalResolution;

dword VerticalResolution;

dword NumberOfColorsUsed;

dword

NumberOfSignificantColors;

} BMPHEADER;

typedef struct tagBITMAP {

dword width;

dword height;

COLORTRIPLE *pixel;

FILEHEADER fileheader;

BMPHEADER bmpheader;

} BITMAP;

#define PIXEL(image, row, column) \ image.pixel [(row( * image.width +

(column)]

BITMAP ReadBitmap (FILE *fp);

void WriteBitmap (BITMAP bitmap, FILE *fp);

BITMAP CreateEmptyBitmap

(dword height, dword width);

void ReleaseBitmapData (BITMAP *bitmap);

4. (10 punti) Una semplice tecnica per creare ombreggiature in un’immagine o enfatizzare quelle esistenti consiste nell’aumentare la luminosità dei pixel che sono adiacenti, in una data direzione, a un pixel meno luminoso.

Si scriva un programma in linguaggio C che riceva sulla riga di comando il nome di un file .BMP di ingresso, il nome di un file .BMP di uscita e un numero K. Il programma deve copiare nel file di uscita l’immagine di ingresso

modificandola come sopra descritto, aumentando di un valore percentuale pari a K la luminosità di ogni pixel alla cui destra compare un pixel meno luminoso. Si veda l’esempio nel riquadro a lato (K=40).

(svolgere sul retro)

Immagine originale Immagine modificata

Un elaboratore (il modello didattico SimCPU visto a lezione) dispone di CPU (a 16 bit) con 16 registri di uso generale (R0, R1, ..., R15) più il Program Counter, l’Instruction Register, lo Stack Pointer e 4 flag Z (zero), N (negative), C (carry) e V (overflow). Si ricorda che il linguaggio assembler di tale elaboratore dispone delle seguenti istruzioni:

5. La seguente funzione riceve in ingresso una stringa (rappresentata nello stesso formato del linguaggio C) il cui indirizzo è contenuto, al momento della chiamata, nel registro R1 e restituisce un valore nel registro R0.

A. (3 punti) Si decodifichi il linguaggio macchina traducendolo in linguaggio assembly.

F0 | FNZ: LDBI R15 30 ; codice ASCII 11 | ; del carattere '0' 30 |

00 | LDWI R0 0 10 |

00 | 00 |

21 | LOOP: ___________________

31 |

0C | ______________________________

C2 |

10 | ______________________________

48 |

00 | ______________________________

4A |

F2 | ______________________________

41 |

02 | ______________________________

C2 |

00 | ______________________________

48 |

F0 | ______________________________

C1 |

00 | END: RET C9 |

B. (2 punti) Che valore restituisce la funzione se la stringa di ingresso contiene “110”?

C. (2 punti) Cosa calcola, in generale, la funzione?

6. (2 punti) Dove risiede il page file?

[ ] nella CPU [ ] nella MMU

[ ] nella memoria centrale [ ] nella memoria di massa [ ] nella RAM

[ ] nella ROM

6. (3 punti) Nel seguente foglio elettronico, la cella B1 contiene l’espressione =IF(A1>A$1+1; A1+1; 0) , che viene copiata nel range di celle B1:C5. Si scrivano i valori che vengono visualizzati in tali celle.

assembly inst. name machine code action

LDWI d X load word 00010000dddd0000 DATA(16) d <- X LDWA d A load word 00100000dddd0000 ADDR(16) d <- mem[A]

LDWR d a load word 00110000ddddaaaa d <- mem[a]

LDBI d X load byte 00010001dddd0000 DATA(8) d <- X LDBA d A load byte 00100001dddd0000 ADDR(16) d <- mem[A]

LDBR d a load byte 00110001ddddaaaa d <- mem[a]

STWA s A store word 00100010ssss0000 ADDR(16) mem[A] <- s STWR s a store word 00110010ssssaaaa mem[a] <- s STBA s A store byte 00100011ssss0000 ADDR(16) mem[A] <- s STBR s a store byte 00110011ssssaaaa mem[a] <- s MV s d move 00000100ssssdddd d <- s PUSH s push 00001000ssss0000 push (s) POP d pop 00001001dddd0000 d <- pop () SPRD d read SP 00001101ssss0000 d <- SP SPWR s write SP 00001110ssss0000 SP <- s

ADD s d add 01000000ssssdddd d <- d + s SUB s d subtract 01000001ssssdddd d <- d - s NOT r bitwise NOT 01000010rrrr0000 r <- ~r AND s d bitwise AND 01000011ssssdddd d <- d & s OR s d bitwise OR 01000100ssssdddd d <- d | s XOR s d bitwise XOR 01000101ssssdddd d <- d ^ s INC r increment 01001000rrrr0000 r <- r + 1 DEC r decrement 01001001rrrr0000 r <- r + 1 LSH r left shift 01001010rrrr0000 r <- r << 1 RSH r right shift 01001011rrrr0000 r <- r >> 1

assembly inst. name machine code action

INW d A input word 10000000dddd0000 IN_ADDR(16) d <- read[A]

INB d A input byte 10000001dddd0000 IN_ADDR(16) d <- read[A]

OUTW s A out word 10000010ssss0000 OUT_ADDR(16) out[A] <- s OUTB s A out byte 10000011ssss0000 OUT_ADDR(16) out[A] <- s

TSTI A test input 1000010000000000 IN_ADDR(16) if completed then Z <- 1 else Z <- 0

TSTO A test output 1000010100000000 OUT_ADDR(16) if completed then Z <- 1 else Z <- 0

BR A branch 1100000000000000 ADDR(16) PC <- A JMP F jump 11000001FFFFFFFF PC <- PC + F

JMPZ F jump if zero 11000010FFFFFFFF if (z == 1) PC <- PC + F JMPNZ F jump if not zero 11000011FFFFFFFF if (z == 0) PC <- PC + F JMPN F jump if negative 11000100FFFFFFFF if (N == 1) PC <- PC + F JMPNN F jump if not neg. 11000101FFFFFFFF if (N == 0) PC <- PC + F JMPC F jump if carry 11000110FFFFFFFF if (C == 1) PC <- PC + F JMPV F jump if overflow 11000111FFFFFFFF if (V == 1) PC <- PC + F CALL A subroutine call 1100100000000000 ADDR(16) push (PC); PC <- A RET return from sub. 1100100100000000 PC <- pop() HLT halt 1100111100000000 halt

LEGENDA:

- lettere minuscole = registri; lettere maiuscole = dati numerici - ‘r’ = registro letto e modificato

- ‘s’ = registro soltanto letto - ‘d’ = registro modificato

- ‘a’ = registro il cui contenuto è usato come indirizzo - FFFFFFFF = offset (in complemento a 2)