Testo Esercitazione_1

APSI 04-05
ESERCITAZIONE 1
SEQUENZA DELLE ATTIVITA’
PARTE 1: Simulazione dell’algoritmo MU0_S2 (visto a lezione)
1. Copiare la cartella MU0_S2 in un’altra cartella sempre sul desktop con nome a vostro
piacimento, (tale cartella nel seguito sarà indicata come cartella1). N.B. Possibilmente
evitare di modificare la cartella originale.
2. Aprire Modelsim ed eseguire la simulazione del programma MU0_S2 come visto a lezione.
Il programma è specificato nel seguito.
3. Verificare che l’esecuzione di ciascuna istruzione modifichi il contenuto dei registri interni
del processore e delle locazioni di memoria interessate secondo la specifica dell’instruction
set del processore.
PROGRAMMA MU0_S2: CONTENUTO DELLA MEMORIA
@000 0100 //load M[12'h100]
@001 2101 //add M[12'h101]
@002 1102 //sto M[12'h102]
@003 4005 //j M[12'h005]
@004 1103 //sto M[12'h103]
@005 1104 //sto M[12'h104]
@006 5008 //jge M[12'h008]
@007 1103 //sto M[12'h103]
@008 0100 //load M[12'h100]
@009 3100 //sub M[12'h100]
@00A 3100 //sub M[12'h100]
@00B 5012 //jge M[12'h0D]
@00C 1105 //sto M[12'h105]
@00D 7000 //stop
@100 0005 // A = 16'h5
@101 0003 // B = 16'h3
Salto
incondizionato:
scrive
M[100]+M[101] alla loc. 104 ma
non alla 103
Salto
condizionato
eseguito
(ACC>0) : non scrive alla loc 103
Salto condizionato non eseguito:
scrive alla loc. 105
PARTE 2: Traduzione in linguaggio macchina e simulazione dell’algoritmo MU0_S3 (visto a
lezione)
1. Copiare la cartella MU0_S2 in un’altra cartella sempre sul desktop con nome a vostro
piacimento, (tale cartella nel seguito sarà indicata come cartella2). N.B. Possibilmente
evitare di modificare la cartella originale.
2. Aprire un editor di testo (ad esempio notepad) e codificare il programma MU0_S3 (descritto
nel seguito) in linguaggio macchina usando la definizione dell’IS (descritta nel seguito),
secondo le modalità viste a lezione. Salvare il file con il nome MU0_S3.hex nella directory
/HEX della cartella2.
Contenuto della memoria all’istante 0
// Codice C
S = 0;
for( i=0; i<5;i++ )
if (a[i] >= 0)
S = S + a[i];
S = 2*S;
a[0] @ Mem[12’h100]
a[1] @ Mem[12’h101]
….
a[4] @ Mem[12’h104]
0 @Mem[12’h200]
Contenuto richiesto della memoria alla fine della simulazione
S -> @ Mem[12’h200]
@000 LDA 100; // carica a[0] nell’accumulatore
@001 JGE 003; // se a[0] >= 0 salta all’istruz che scrive a[0] nella loc di mem sulla
// quale accumulo il risultato parziale
@002 J 004;
// altrimenti salta all’istruz che carica a[1] nell’acc
@003 STO 200; // scrive a[0] nella loc di mem sulla quale accumulo il risultato parziale (0x200)
@004 LDA 101; // carica a[1] nell’acc
@005 JGE 007; // se a[1] >= 0 salta all’istruz che lo addiziona al ris parziale
@006 J 009;
// altrimenti salta all’istruz che carica a[2]
@007 ADD 200; // addiziona il ris parziale ad a[1]
@008 STO 200; // scrive il nuovo risultato parziale nella loc di mem 0x200
@009 LDA 102; // carica a[2] nell’acc
@00A JGE 00C; // se a[2] >= 0 salta all’istruz che lo addiziona al ris parziale
@00B J 00E;
// altrimenti salta all’istruz che carica a[3]
@00C ADD 200; // addiziona il ris parziale ad a[2]
@00D STO 200; // scrive il nuovo risultato parziale nella loc di mem 0x200
@00E LDA 103; // carica a[3] nell’acc
@00F JGE 011; // se a[3] >= 0 salta all’istruz che lo addiziona al ris parziale
@010 J 013;
// altrimenti salta all’istruz che carica a[4]
@011 ADD 200; // addiziona il ris parziale ad a[3]
@012 STO 200; // scrive il nuovo risultato parziale nella loc di mem 0x200
@013 LDA 104; // carica a[4] nell’acc
@014 JGE 016; // se a[4] >= 0 salta all’istruz che lo addiziona al ris parziale
@015 J 018;
// altrimenti salta all’istruz che carica il risultato finale della somma nell’acc
@016 ADD 200; // addiziona il ris parziale ad a[4]
@017 STO 200; // scrive il risultato finale della somma nella loc di mem 0x200
@018 LDA 200; // carica il risultato finale della somma nell’accumulatore
@019 ADD 200; // addiziona il risultato finale della somma a se stesso
@01A STO 200; // scrive il valore finale di S nella loc di mem 0x200
@01B STP; // stoppa la simulazione
Istruzione
LDA S
Opcode Opcode
(HEX) (BIN)
0
0000
Descrizione
ACC = mem[S]
STO S
1
0001
mem[S] = ACC
ADD S
2
0010
ACC = ACC + mem[S]
SUB S
3
0011
ACC = ACC - mem[S]
JMP S
4
0100
PC = S
JGE S
5
0101
if (ACC >= 0) PC = S
JNE S
6
0110
if (ACC != 0) PC = S
STP
7
0111
stop
3. Aprire Modelsim, modificare opportunamente il testbench ed eseguire la simulazione del
programma MU0_S3.
4. Verificare che l’esecuzione di ciascuna istruzione modifichi il contenuto dei registri interni
del processore e delle locazioni di memoria interessate secondo la specifica dell’instruction
set del processore.
PARTE 3: Codifica assembly, traduzione in linguaggio macchina e simulazione dell’algoritmo
MU0_S4
1. Copiare la cartella MU0_S2 in un’altra cartella sempre sul desktop con nome a vostro
piacimento, (tale cartella nel seguito sarà indicata come cartella3). N.B. Possibilmente
evitare di modificare la cartella originale.
2. Codificare in assembly il programma MU0_S4 specificato nel seguito
// Codice C
S1 = 0; S2 = 0;
for( i=0; i<5;i++ )
if (a[i] >= 0)
S1 = S1 + a[i];
S1 = 2*S1;
for( i=0; i<3;i++ )
if (b[i] >= S1)
S2 = S2 + b[i] - a[i];
Contenuto della memoria all’istante 0
a[0] @ Mem[12’h100]
a[1] @ Mem[12’h101]
a[2] @ Mem[12’h102]
a[3] @ Mem[12’h103]
a[4] @ Mem[12’h104]
b[0] @ Mem[12’h105]
b[1] @ Mem[12’h106]
b[2] @ Mem[12’h107]
0
@Mem[12’h200]
Contenuto richiesto della memoria alla fine della simulazione
S1 -> @ Mem[12’h201]
S2 -> @ Mem[12’h202]
3. Aprire un editor di testo (ad esempio notepad) e codificare il programma MU0_S4 in
linguaggio macchina usando la definizione dell’IS, secondo le modalità viste a lezione.
Salvare il file con il nome MU0_S4.hex nella directory /HEX della cartella3.
5. Aprire Modelsim, modificare opportunamente il testbench ed eseguire la simulazione del
programma MU0_S3.
6. Verificare che l’esecuzione di ciascuna istruzione modifichi il contenuto dei registri interni
del processore e delle locazioni di memoria interessate secondo la specifica dell’instruction
set del processore.