Corsi di laurea in Ingegneria Elettronica e Ingegneria Gestionale Architettura dei calcolatori (ex Fondamenti di Informatica II) 16 giugno 2017 - 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 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 esegua in binario su 8 bit in complemento a 2 l’operazione -41
10+ 14
10, discutendo l’eventuale condizione di overflow. Si riportino tutti i passaggi effettuati.
41 20 10 5 2 1 0
:2 1 0 0 1 0 1
00101001
complemento a 2 11010111
14 7 3 1 0 :2
0 1 1
1 00001110
11010111 + 00001110 11100101
11100111 -00011011 = -27
10complemento a 2
Il risultato è corretto in quanto c
n= c
n-1= 0, quindi non si è verificato overflow.
2. (2 punti) Indicare le associazioni ritenute corrette
CRC [ ] compressione [X] controllo errori [ ] correzione errori
singolo bit di parità [ ] compressione [X] controllo errori [ ] correzione errori
distanza di Hamming [ ] compressione [X] controllo errori [X] correzione errori
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);
3. (10 punti) L’effetto caleidoscopico si ottiene ripetendo specularmente un’immagine o una porzione di essa più volte rispetto ad un certo numero di assi. Il presente esercizio richiede di realizzare tale effetto in modo semplice, utilizzando gli assi cartesiani che passano per il centro dell’immagine finale. L’intera immagine sarà quindi riportata identica all’originale nel quadrante in basso a sinistra e replicata specularmente negli altri tre. Di conseguenza, l’immagine risultante
dovrà avere un numero di pixel quadruplo rispetto all’originale (si veda l’esempio a lato).
Si scriva un programma in inguaggio C che riceva sulla riga di comando il nome di due file bitmap e scriva nel
secondo la trasformazione del primo come sopra descritto.
#include <stdio.h>
#include <stdlib.h>
#include "bmp.h"
BITMAP caleidoscopio (BITMAP img);
int main (int argc, char *argv[]) {
FILE *fpin, *fpout, *fptxt;
BITMAP imgin, imgout;
if (argc != 3)
{ printf ("ARGOMENTI: <file in> <file out>\n");
exit (EXIT_FAILURE);
}
if ((fpin = fopen (argv[1], "rb")) == NULL) {
printf ("Error opening input file\n");
exit (EXIT_FAILURE);
}
if ((fpout = fopen (argv[2], "wb")) == NULL) {
printf ("Error opening output file\n");
exit (EXIT_FAILURE);
}
imgin = ReadBitmap (fpin);
fclose (fpin);
imgout = caleidoscopio (imgin);
WriteBitmap (imgout, fpout);
fclose (fpout);
ReleaseBitmapData (&imgin);
ReleaseBitmapData (&imgout);
return EXIT_SUCCESS;
}
BITMAP caleidoscopio (BITMAP imgin) {
BITMAP imgout;
int r, c;
imgout = CreateEmptyBitmap (2 * imgin.height, 2 * imgin.width);
for (r = 0; r < imgin.height; r++) {
for (c = 0; c < imgin.width; c++) {
PIXEL (imgout, r, c ) = PIXEL (imgout, imgout.height - 1 - r, c ) = PIXEL (imgout, r, imgout.width - 1 - c) = PIXEL (imgout, imgout.height - 1 - r, imgout.width - 1 - c) = PIXEL (imgin, r, c);
} }
return imgout;
}
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. (5 punti) Si scriva in linguaggio assembly la funzione SWAP che riceve in R1 e R2 gli indirizzi di memoria di due variabili intere e scambia, in memoria, il loro contenuto. NOTA: si tratta della versione assembly della nota funzione in linguaggio C void wap (int *a_ptr, int *b_ptr).
SWAP: LDWR R10 R1 ; void swap (int *pa, int *pb) LDWR R11 R2
STWR R10 R2 STWR R11 R1 RET
5. (3 punti) Quali istruzioni modificano il valore dello stack pointer?
SPWR, CALL, RET, PUSH, POP
6. (4 punti) La versione assembly del seguente programma è incompleta. La si completi basandosi sulla versione in linguaggio macchina e si scriva il valore del registro R0 al termine dell’esecuzione.
F0 | START: LDWI R15 0E000 10 |
00 | E0 |
F0 | SPWR R15 0E |
00 | C8 |
0C | 00 |
00 | HLT CF |
00 | LDWI R0 0 10 |
00 | 00 |
04 | C2 |
00 | LDWI R0 1 10 |
01 | 00 |
00 | RET C9 |
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)
