Matricola __________________ Nome _____________________ Cognome __________________

Università degli Studi di Udine

Architettura dei calcolatori / Fondamenti di Informatica II (prof. Montessoro) 3 settembre 2018

Prova scritta per studenti di Ing. Elettronica e Ing. Gestionale immatricolati negli anni accademici 2016-17 e precedenti – DURATA DELLA PROVA: 2 ORE

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 memory pen USB 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, dove disponibili, oppure sul retro del foglio o su fogli aggiuntivi.

1. (3 punti) Si converta il numero 22.210 in base 5 riportando nel dettaglio tutti i passaggi.

2. (3 punti) Ricevete il seguente messaggio, comprensivo di CRC: 1001011101. Il polinomio generatore utilizzato è x²+1.

Il messaggio è corretto? Perché? Riportare tutti i calcoli effettuati

3. (2 punti) Nella tecnica di compressione JPEG la matrice di quantizzazione serve per:

[ ] codificare i valori reali in numeri interi con un numero di bit prefissato [ ] ottenere un elevato numero di valori a zero

[ ] ottenere un elevato numero di valori uguali, non nulli

[ ] recuperare le informazioni perse a causa della compressione con perdita

4. (1 punto) Quanti colori possono essere rappresentati in un’immagine bitmap di tipo “true color”?

Si consideri una libreria in linguaggio C per manipolare file audio così definita:

typedef unsigned char byte;

typedef unsigned short int word;

typedef unsigned long int dword;

#define SAMPLE(wave, channel, offset) \ wave.wavedata.sample \ [2 * (offset) + (channel)]

#define FMTPCM 1

#define SAMPLINGRATE 44100

#define CHANNELS 2

#define BITSPERSAMPLE 16

#define LEFT 0

#define RIGHT 1

#define RIFF_ID "RIFF"

#define WAV_ID "WAVE"

#define FMT_ID "fmt "

#define DATA_ID "data"

typedef struct tagRIFFHEADER {

char riffid[4];

dword FileSize;

char waveid[4];

} RIFFHEADER;

typedef struct tagFMTHEADER {

char fmtid[4];

dword fmtsize;

word format;

word channels;

dword SampleRate;

dword BytesPerSecond;

word BlockAlign;

word BitsPerSample;

} FMTHEADER;

typedef struct tagWAVEDATA {

char dataid[4];

dword DataSize;

signed short int *sample;

} WAVEDATA;

typedef struct tagWAVE {

RIFFHEADER riffheader;

FMTHEADER fmtheader;

unsigned long int numofstereosamples;

WAVEDATA wavedata;

} WAVE;

void WriteWave (WAVE wave, FILE *fp);

WAVE ReadWave (FILE *fp);

WAVE CreateEmptyCDaudioWave (unsigned long int numofstereosamples);

void ReleaseWaveData (WAVE *wave);

5. (7 punti) L’effetto di “fade out”, spesso presente alla fine delle canzoni di musica leggera, consiste nel ridurre il volume del suono fino a zero, a partire da alcuni secondi prima della fine del brano. L’andamento della diminuzione del volume può essere lineare, esponenziale, logaritmico o presentare profili complessi. Ai fini dell’esercizio si consideri soltanto l’andamento lineare.

Si scriva un programma in linguaggio C che riceva sulla linea di comando i nomi di due file wave e un numero reale. I due file rappresentano la forma d’onda di ingresso e di uscita, mentre il numero reale rappresenta la durata in secondi dell’effetto di fade out. Il programma deve scrivere nel secondo file la forma d’onda del primo a cui sia applicato tale effetto per il numero di secondi specificato. Se la forma d’onda di ingresso ha durata inferiore al numero di secondi specificato, il programma deve terminare segnalando errore.

Esempio:onda sinusoidale a 20 Hz della durata di 4 secondi (a sinistra) a cui è applicato l’effetto di fade out lineare della durata di un secondo (a destra).

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:

6. (4 punti) Il programma sotto riportato calcola il fattoriale della variabile N (inizializzata a 4) in modo ricorsivo.

Noto che la chiamata della funzione factorial dal main avviene all’indirizzo 000C (indicato con il commento PUNTO A), la chiamata ricorsiva avviene all’indirizzo 001A (PUNTO B) e quella della funzione MUL all’indirizzo 0022 (PUNTO C), si descriva il contenuto dello stack al momento dell’inizio dell’ultima chiamata ricorsiva (cioè quando la funzione factorial viene chiamata con R1 = 0) riportato a destra.

N: word 4

START: LDWI R15 0E000 SPWR R15 LDWA R1 N

CALL FACTORIAL ; PUNTO A HLT

; int factorial (int R1) FACTORIAL: MV R1 R2 JMPZ E_FACT PUSH R1 DEC R1

CALL FACTORIAL ; PUNTO B POP R1

MV R0 R2

CALL MUL ; PUNTO C RET

E_FACT: LDWI R0 1 RET

; int mul (int R1, int R2) MUL: LDWI R0 0 MV R1 R15 L_MUL: JMPZ END_MUL ADD R2 R0 DEC R1 JMP L_MUL END_MUL: RET

MEM[E000]: 10

MEM[E001]: 00 _________________________________________

MEM[E002]: 04

MEM[E003]: 00 _________________________________________

MEM[E004]: 1E

MEM[E005]: 00 _________________________________________

MEM[E006]: 03

MEM[E007]: 00 _________________________________________

MEM[E008]: 1E

MEM[E009]: 00 _________________________________________

MEM[E00A]: 02

MEM[E00B]: 00 _________________________________________

MEM[E00C]: 1E

MEM[E00D]: 00 _________________________________________

MEM[E00E]: 01

MEM[E00F]: 00 _________________________________________

MEM[E010]: 1E

MEM[E011]: 00 _________________________________________

MEM[E012]: 00

MEM[E013]: 00 _________________________________________

7. (4 punti) Si scriva in linguaggio assembler la funzione ISDIGIT che riceve in R1 il codice ASCII di un carattere e restituisce in R0 il valore 1 se il carattere rappresenta una cifra numerica e 0 altrimenti. Si ricorda che il codice ASCII del carattere '0' vale, in decimale, 48.

8. (2 punti) DMA: cosa significa e a cosa serve?

9. (2 punti) Cos’è il polling?

10. (2 punti) Spiegare che differenza c’è in un foglio elettronico, tra i seguenti riferimenti alla cella A1: A1, $A1, A$1, $A$1

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)