Sistemi di elaborazione - diegm - Università degli Studi di Udine

Università degli Studi di Udine
Corsi di laurea in Ingegneria Elettronica e Ingegneria Gestionale
Architettura dei calcolatori / Fondamenti di Informatica II
15 febbraio 2016 - 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.
DA8 + BC9 = 971
(5 punti) La ALU di un processore a 12 bit ha eseguito l’operazione:
a)
Scrivere i valori (decimali) che sono stati sommati e il valore (decimale) che è stato ottenuto, riportando tutti i passaggi
effettuati
b) Scrivere che valore avrà assunto il flag OVERFLOW al termine dell’operazione e come tale valore è stato calcolato
______________________________________________________
c)
2.
Quindi, il risultato dell’operazione è corretto? ___________________
(3 punti) Un codice prevede di inserire due bit di parità per ogni byte: uno pari reativo ai primi
quattro bit del byte e l’altro relativo agli altri quattro bit. Si veda l’ esempio nel riquadro a lato.
Che valore ha la distanza di Hamming di tale codice?
Quanti bit errati può rilevare?
____________________
byte
parità
0000 0000 0 0
0111 0101 1 0
0000 0001 0 1
1111 1101 0 1
1111 1111 0 0
________________________
Quanti bit errati può correggere? ___________________________
Si consideri la libreria in linguaggio C per manipolare file bitmap vista a lezione, così definita:
typedef
typedef
typedef
unsigned char
unsigned short int
unsigned long int
#define BMPFILETYPE 0x4D42
typedef struct tagCOLORTRIPLE
{
byte blue;
byte green;
byte red;
} COLORTRIPLE;
3.
byte;
word;
dword;
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
void
BITMAP
void
ReadBitmap (FILE *fp);
WriteBitmap (BITMAP bitmap, FILE *fp);
CreateEmptyBitmap
(dword height, dword width);
ReleaseBitmapData (BITMAP *bitmap);
(12 punti) Si scriva un programma in linguaggio C che riceva sulla riga di comando il nome di un file bitmap di ingresso e
di uno di uscita e scriva nel file di uscita l’immagine del file di ingresso trasformata come nell’esempio del riquadro.
Come si può osservare, l’immagine risultante è racchiusa in una
cornice ellittica nera (dello spessore di N pixel, con N=10
nell’esempio) e la parte esterna a tale cornice è bianca.
Si ricorda che, detti a e b i due semiassi dell’ellisse e x e y le
coordinate cartesiane con origine nel centro dell’ellisse, i punti
interni all’ellisse soddisfano la proprietà (x/a)2 + (x/b)2 ≤ 1. I
pixel da annerire per disegnare la cornice sono quindi quelli
interni all’ellisse che ha semiassi pari a metà dei lati
dell’immagine ma non interni a quella che ha per semiassi i
medesimi valori diminuiti di N.
originale
modificata
(svolgere sul retro)
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:
assembly
inst. name
machine code
LDWI
LDWA
LDWR
LDBI
LDBA
LDBR
STWA
STWR
STBA
STBR
MV
PUSH
POP
SPRD
SPWR
load word
load word
load word
load byte
load byte
load byte
store word
store word
store byte
store byte
move
push
pop
read SP
write SP
00010000dddd0000
00100000dddd0000
00110000ddddaaaa
00010001dddd0000
00100001dddd0000
00110001ddddaaaa
00100010ssss0000
00110010ssssaaaa
00100011ssss0000
00110011ssssaaaa
00000100ssssdddd
00001000ssss0000
00001001dddd0000
00001101ssss0000
00001110ssss0000
add
subtract
bitwise NOT
bitwise AND
bitwise OR
bitwise XOR
increment
decrement
left shift
right shift
01000000ssssdddd
01000001ssssdddd
01000010rrrr0000
01000011ssssdddd
01000100ssssdddd
01000101ssssdddd
01001000rrrr0000
01001001rrrr0000
01001010rrrr0000
01001011rrrr0000
ADD
SUB
NOT
AND
OR
XOR
INC
DEC
LSH
RSH
d
d
d
d
d
d
s
s
s
s
s
s
d
d
s
s
s
r
s
s
s
r
r
r
r
4.
X
A
a
X
A
a
A
a
A
a
d
d
d
d
d
d
DATA(16)
ADDR(16)
DATA(8)
ADDR(16)
ADDR(16)
ADDR(16)
action
assembly inst. name
machine code
d <- X
d <- mem[A]
d <- mem[a]
d <- X
d <- mem[A]
d <- mem[a]
mem[A] <- s
mem[a] <- s
mem[A] <- s
mem[a] <- s
d <- s
push (s)
d <- pop ()
d <- SP
SP <- s
INW
INB
OUTW
OUTB
TSTI
10000000dddd0000
10000001dddd0000
10000010ssss0000
10000011ssss0000
1000010000000000
d
d
r
d
d
d
r
r
r
r
<<<<<<<<<<-
d + s
d - s
~r
d & s
d | s
d ^ s
r + 1
r + 1
r << 1
r >> 1
d
d
s
s
A
A
A
A
A
input word
input byte
out word
out byte
test input
action
IN_ADDR(16)
IN_ADDR(16)
OUT_ADDR(16)
OUT_ADDR(16)
IN_ADDR(16)
TSTO A
test output 1000010100000000 OUT_ADDR(16)
BR
JMP
JMPZ
JMPNZ
JMPN
JMPNN
JMPC
JMPV
CALL
RET
HLT
branch
jump
jump if zero
jump if not zero
jump if negative
jump if not neg.
jump if carry
jump if overflow
subroutine call
return from sub.
halt
A
F
F
F
F
F
F
F
A
d <- read[A]
d <- read[A]
out[A] <- s
out[A] <- s
if completed then Z <- 1
else Z <- 0
if completed then Z <- 1
else Z <- 0
1100000000000000 ADDR(16) PC <- A
11000001FFFFFFFF
PC <- PC + F
11000010FFFFFFFF
if (z == 1) PC <- PC
11000011FFFFFFFF
if (z == 0) PC <- PC
11000100FFFFFFFF
if (N == 1) PC <- PC
11000101FFFFFFFF
if (N == 0) PC <- PC
11000110FFFFFFFF
if (C == 1) PC <- PC
11000111FFFFFFFF
if (V == 1) PC <- PC
1100100000000000 ADDR(16) push (PC); PC <- A
1100100100000000
PC <- pop()
1100111100000000
halt
X:
Y:
word 0AAAA
word 0BBBB
START:
LDWI R15 0F000
SPWR R15
_________
; R1 = &X
_________
; R2 = &Y
CALL SCAMBIA
; scambia (&x, &y)
HLT
5.
(3 punti) Si completi la traduzione in linguaggio macchina
della funzione STRLEN riportata nel seguito
00
10
00
00
A1
30
__
__
10
48
00
48
__
__
00
C9
| STRLEN:
|
|
|
| LOOP:
|
|
|
|
|
|
|
|
|
| END:
|
6.
(3 punti) Si illustri lo schema di traduzione di indirizzi virtuali in indirizzi fisici in un sistema basato su paginazione
(svolgere sul retro)
LDWR R10 R1
F
F
F
F
F
F
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)
(4 punti) Facendo uso delle indicazioni presenti nei commenti,
si completi il programma in linguaggio assembly riportato a
lato, che scambia il contenuto delle variabili X e Y
LDWI R0 0
+
+
+
+
+
+
SCAMBIA: _____________
_____________
_____________
_____________
RET
;
;
;
;
R11
R12
*R2
*R1
=
=
=
=
*R1
*R2
R11
R12
JMPZ END
INC R1
INC R0
JMP LOOP
RET