Università degli Studi di Udine
Corsi di laurea in Ingegneria Elettronica e Ingegneria Gestionale Architettura dei calcolatori (ex Fondamenti di Informatica II) 26 febbraio 2013 - 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 un floppy 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) Ad un messaggio a sette bit è stato aggiunto un codice di Hamming a quattro bit per il controllo e la correzione di errore. Il messaggio poi è stato trasmesso lungo una linea disturbata. Il messaggio ricevuto è il seguente:
1 0 0 1 1 0 0 1 0 0 1
11 10 9 8 7 6 5 4 3 2 1
Si ricostruisca il messaggio originario, indicando i passaggi effettuati
2. (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
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);
3. (10 punti) Nella musica moderna, per arricchire di
armoniche il suono delle chitarre elettriche si utilizza spesso l’effetto overdrive. Si tratta di simulare la curva di
amplificazione non linerare di un amplificatore a valvole in saturazione. Tale curva può essere approssimata dalla seguente funzione, il cui andamento è rappresentato a lato:
⎪⎩
⎪ ⎨
⎧
≥
−
=
<
−
−
=
−
−
0 3
/ ) 1
(
0 )
1 (
3 3
3
x e
y
x e
y
x x
-1.2 -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4
-1.5 -1 -0.5 0 0.5 1 1.5
Naturalmente, la funzione si riferisce a valori normalizzati x del suono di ingresso compresi tra -1 e 1 che, ai fini dell’applicazione su un file WAV, corrispondono al massimo e al minimo valore rappresentabile. Quindi i valori dei campioni dovranno essere calcolati in proporzione. Inoltre, per accentuare l’effetto, si applichi al suono di ingresso, prima della funzione, un’amplificazione di un fattore 3 (cioè si moltiplichino per 3 i valori dei campioni).
Si scriva un programma in linguaggio C che riceva sulla riga di comando il nome di un file WAV, senza estensione , e crei un file di uscita con lo stesso nome, seguito da “_overdrive”, contenente la forma d’onda di ingresso trasformata come sopra descritto.
ESEMPIO:
C:\>overdrive guitar leggo il file guitar.wav
creo il file guitar_overdrive.wav C:\>
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:
4. (8 punti) Un vettore di interi (attenzione: interi, non char) è presente in memoria a partire dall’indirizzo contenuto nel registro R1. La sua lunghezza è contenuta nell’indirizzo R2. Si scriva in linguaggio assembler la funzione CERCAINVET che restituisce in R0 l’indice (attenzione: l’indice, non il puntatore) del valore uguale a quello contenuto nel registro R3. Nel caso in cui più di un valore corrisponda a quello cercato, la funzione deve restituire l’indice del primo.
(svolgere sul retro)
5. (3 punti) Cosa fa il frammento di codice in linguaggio macchina riportato a fianco?
6. (2 punti) Indicare la o le affermazioni VERE.
In un sistema operativo moderno:
[ ] quando un processo termina la time slice viene trasferito sul page file
[ ] i programmi possono coesistere in memoria anche se usano lo stesso spazio di indirizzamento [ ] il page file contiene informazioni di protezione delle pagine
[ ] la page table contiene informazioni di protezione delle pagine
[ ] la page table contiene informazioni relative alla presenza delle pagine nel page file
7. (2 punti) Nel foglio elettronico rappresentato a lato la cella C6 contiene la formula
=D$3+$C2
Il contenuto della cella C6 viene copiato nella cella D7. Che valore verrà calcolato nella cella D7?
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)
B0 81 01 00 00 84 01 00 F6 C3 (svolgere sul retro)
