Il linguaggio macchina: Parte 3
Riassumiamo cosa abbiamo visto a proposito dei programmi per risolvere i problemi.
a) Dati e Istruzioni devono stare in memoria centrale MC per poter essere usati/eseguite
b) Le Istruzioni sono espresse come sequenze di bit esprimenti CODICI <---> CIRCUITI della CPU ed indirizzi di operandi.
c) Un programma eseguibile è fatto di una sequenza di istruzioni macchina.
d) Il programma viene eseguito sequenzialmente.
e) Il linguaggio macchina LM ha poche istruzioni e con queste poche noi scriviamo il programma.
Adesso facciamo qualche aggiunta al linguaggio macchina per "arricchirlo" introducendo altre istruzioni:
1) L' istruzione STOP per interrompere il "flusso sequenziale" ossia arresta l'esecuzione del programma.
2) L'istruzione di salto " Alterazione incondizionata" , o Salto incondizionato, modifica l' ordine sequenziale di esecuzione delle istruzioni: " invece di eseguire la prossima istruzione il cui indirizzo è contenuto nel PC esegui quella di un' altra cella"; per cui questa istruzione modifica il valore contenuto nel registro PC, inserendovi l' indirizzo della cella a cui vogliamo saltare.
3) L'istruzione di salto " Alterazione condizionata" , o Salto condizionato del flusso di esecuzione. Talvolta si preferisce che la sequenza di esecuzione non sia quella normale né quella di saltare in assoluto ad una cella prestabilita, ma di saltare ad una certa cella se vale una certa condizione ad esempio vi sono delle istruzioni che realizzano il salto soltanto se il contenuto del registro ACC è positivo.
Le istruzioni di salto agiscono modificando il
contenuto del PC e cancellando gli effetti dell' incremento automatico ossia
la
( PC ) <---- ( PC ) + 1, eseguito dopo il FETCH.
vediamo nella tabella altre istruzioni del linguaggio macchina
Tabella 5.1
Sintassi |
Semantica |
||
Codice operativo |
Operando |
|
|
8 |
IND |
se (ACC) >=0 ( PC ) <--- IND (altrimenti nulla) |
cambia il contenuto del PC solo se il ( ACC) è >= 0 salto condizionato |
7 |
IND |
( PC ) <--- IND |
salto incondizionato |
Consideriamo adesso un esempio di programma che:
dati due numeri,
stampi
il maggiore fra i due.
Analisi
E' semplice. Abbiamo bisogno di due locazioni di memoria per contenere i due numeri letti da Ingresso; dobbiamo confrontare il primo con il secondo numero e stampare il maggiore. Il confronto diretto tra due numeri contenuti in celle di memoria centrale è impossibile.
Algoritmo
Se il primo numero è maggiore del secondo stampare il primo altrimenti stampare il secondo.
Raffinamento
Per vedere se primo>=secondo verifichiamo se primo-secondo>=0
a) leggi il primo numero e memorizzalo
b) leggi il secondo numero e memorizzalo
c) copia il primo in ACC
d) sottrazione ( ACC ) - secondo ed il risultato va in ACC
e) se il ( ACC ) >= 0 continua l'esecuzione con l'istruzione di stampa poiché vuol dire che primo >= secondo , altrimenti esegui l'istruzione successiva a questa
f) stampa il secondo numero
g) prosegui verso la fine senza stampare il primo
h) stampa il primo numero
i) STOP
L'esecuzione è sequenziale ma in alcuni punti non lo è infatti f) ed h) sono alternative. Se vale la condizione in e) viene eseguita l'istruzione h) e poi i), se non vale la condizione e) viene eseguita f) poi g) poi i).
Programmazione
Vogliamo inserire il primo e secondo numero nelle celle di memoria di indirizzo 201 e 202 rispettivamente per cui il programma sarà :
0) ( 201 ) <---- ( UL )
1) ( 202 ) <---- ( UL )
2) ( ACC ) <---- ( 201)
3) ( ACC ) <---- ( ACC ) - ( 202 ) (ACC) <--- {primo-secondo}
4) se ( ACC ) >= 0
prosegui a stampare il primo numero vai in 7) cioè ( PC ) <--- 7, altrimenti continua in sequenza.
5) ( US ) <---- ( 202 ) { stampa del secondo numero }
6) ( PC ) <---- 8
7) ( US ) <---- ( 201 ) { stampa primo numero}
8) STOP
Assumiamo che le informazioni siano caricate in memoria a partire dall'indirizzo 0 ed i dati di input vengano memorizzati nelle celle di indirizzo 201 e 202
Indirizzo |
cod. op. |
operando |
0 |
5 |
201 |
1 |
5 |
202 |
2 |
3 |
201 |
3 |
2 |
202 |
4 |
8 |
7 |
5 |
6 |
202 |
6 |
7 |
8 |
7 |
6 |
201 |
8 |
9 |
............... |
9 |
|
|
10 |
|
|
Complemento alle lezioni sul linguaggio macchina.
1) Leggere due numeri da input, sommarli e stampare il risultato.
indirizzi |
contenuto celle |
operazione |
indirizzi |
contenuto celle |
0 |
(primo numero) |
|
00000000 |
(primo numero) |
1 |
(secondo ") |
|
00000001 |
(secondo ") |
2 |
(risultato) |
|
00000010 |
(risultato) |
3 |
|
|
00000011 |
|
|
|
|
|
|
|
|
|
|
|
99 |
|
|
01100011 |
|
100 |
5 0 |
lettura primo numero |
01100100 |
10100000000 |
101 |
5 1 |
lettura sec. numero |
01100101 |
10100000001 |
102 |
3 0 |
caricamento |
01100110 |
01100000000 |
103 |
1 1 |
somma |
01100111 |
00100000001 |
104 |
4 2 |
memorizzazione |
01101000 |
10000000010 |
105 |
6 2 |
stampa |
01101001 |
11000000010 |
106 |
|
|
01101010 |
|
Il programma precedente è fatto per usare le celle 0, 1, 2 per i dati di input/output. Nelle tabelle seguenti, il programma è riscritto per funzionare usando le celle di indirizzi 10 (00001010 binario), 11 (00001011) e 12 (00001100) per i dati di inp/out.
rappr. decimale di istruzioni e indirizzi rappr. binaria di istruzioni e indirizzi
indirizzi |
contenuto celle |
operazione |
indirizzi |
contenuto celle |
|
|
|
||
|
|
|
||
|
|
|||
|
|
|||
|
|
|
| |
|
|
|
| |
|
|
|
| |
|
|
|||
|
||||
|
||||
|
|
|||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Un pó di numeri (a sinistra) scritti in formato binario (a destra)
0 |
0 |
|
5 |
101 |
|
10 |
1010 |
|
15 |
1111 |
|
20 |
10100 |
|
100 |
1100100 |
1 |
1 |
|
6 |
110 |
|
11 |
1011 |
|
16 |
10000 |
|
30 |
11110 |
|
1000 |
1111101000 |
2 |
10 |
|
7 |
111 |
|
12 |
1100 |
|
17 |
10001 |
|
32 |
100000 |
|
1024 |
10000000000 |
3 |
11 |
|
8 |
1000 |
|
13 |
1101 |
|
18 |
10010 |
|
50 |
110010 |
|
2048 |
100000000000 |
4 |
100 |
|
9 |
1001 |
|
14 |
1110 |
|
19 |
10011 |
|
60 |
111100 |
|
4096 |
1000000000000 |
2) Dati due numeri, stampare il maggiore.
Analisi : ci servono due locazioni di memoria (celle), per contenere i due numeri letti da input.
Dovremo confrontare il 1° con il 2° numero e stampare quello maggiore.
Il confronto diretto tra due numeri contenuti in celle di memoria centrale è impossibile;
osserviamo che 1° >= 2° se e solo se 1° - 2° >= 0. Se facciamo in modo che il numero 1°-2° sia messo nell'accumulatore, potremo usare l'istruzione di codice 8 (che è l'unica che permette un qualche tipo di test.
Sintesi dell'Algoritmo:
0 | 5 201 | (201) <-- (UL) | … | |
1 | 5 202 | (202) <-- (UL) | … | |
2 | 3 201 | (ACC) <-- (201) | … | |
3 | 2 202 | (ACC)<--(ACC)-(202) | 200 | |
4 | 8 7 | se (ACC) >= 0 (PC)<--7 | 201 | |
5 | 6 202 | (US)<--(202) | 202 | |
6 | 7 8 | (PC)<-- 8 | … | |
7 | 6 201 | (US)<-- (201) | … | |
8 | 9 … | STOP | … | |
9 | ||||
… |
Esecuzione simulata, supponendo INPUT = 12 seguito da 7
Inizialmente (quando il programma deve essere eseguito) l'indirizzo della
prima istruzione viene posto nel registro PC della CPU. PC=0
Fetch: (IR) <-- (0) e incremento di (PC)
IR=<5 201> PC=1
| Execute Viene recepito il 12 da UL e copiato in (201) (201)=12
| Fetch: (IR) <-- (1) e incremento di (PC)
IR=<5 202> PC=2
| Execute Viene recepito il 7 da UL e copiato in (202) (202)=7
| Fetch: (IR) <-- (2) e incremento di (PC)
IR=<3 201> PC=3
| Execute Viene caricato in ACC il contenuto della cella 201 (ACC)=12
| Fetch: (IR) <-- (3) e incremento di (PC)
IR=<2 202> PC=4
| Execute Viene sottratto il cont. Della cella 202 da ACC. Ris. In (ACC).
(ACC)=5
| Fetch: (IR) <-- (4) e incremento di (PC)
IR=<8 7> PC=5
| Execute (ACC) è maggiore di 0, quindi (PC) <-- 7
| Fetch: (IR) <-- (7) e incremento di (PC)
IR=<6 201> PC=8
| Execute stampa di (201) sull'unità di OUTPUT
| Fetch: (IR) <-- (8) e incremento di (PC)
IR=<9 > PC=9
| Execute STOP (fine programma) | |
Esecuzione simulata, supponendo INPUT = 4 seguito da 16
Inizialmente (quando il programma deve essere eseguito) l'indirizzo della
prima istruzione viene posto nel registro PC della CPU. PC=0
Fetch: (IR) <-- (0) e incremento di (PC)
IR=<5 201> PC=1
| Execute Viene recepito il 4 da UL e copiato in (201) (201)=4
| Fetch: (IR) <-- (1)
e incremento di (PC)
IR=<5 202> PC=2
| Execute Viene recepito il 16 da UL e copiato in (202) (202)=16
| Fetch: (IR) <-- (2)
e incremento di (PC)
IR=<3 201> PC=3
| Execute Viene caricato in ACC il contenuto della cella 201 (ACC)= 4
| Fetch: (IR) <-- (3)
e incremento di (PC)
IR=<2 202> PC=4
| Execute Viene sottratto il cont. Della cella 202 da ACC. Ris. In (ACC)
(ACC)= -12
| Fetch: (IR) <-- (4) e incremento di (PC)
IR=<8 7> PC=5
| Execute (ACC) è minore di 0, quindi NESSUNA MODIFICA DI PC
| Fetch: (IR) <-- (5)
e incremento di (PC)
IR=<6 202> PC=6
| Execute stampa di (202) sull'unità di OUTPUT
| Fetch: (IR) <-- (6)
e incremento di (PC)
IR=<7 8> PC=7
| Execute Viene modificato PC, in modo che la prossima istruzione sia quella
in cella 8 PC=8
| Fetch: (IR) <-- (8)
e incremento di (PC)
IR=<9 > PC=9
| Execute STOP (fine programma) | |
Algoritmo
1) leggere i tre numeri e memorizzarli in tre celle, di indirizzo DATO1, DATO2, DATO3
2) mettere il maggiore tra il 1o e il 2o nella cella di indirizzo PARZ12;
3) stampare il maggiore tra i numeri in PARZ12 e DATO3
Assumiamo che il programma sia caricato in memoria centrale a partire dall'indirizzo 0, e che DATO1=201, DATO2=202, DATO3=203, PARZ12=204.
Sia il punto 2) che il 3) possono essere risolti sfruttando l'esempio "Stampare il maggiore tra due numeri". Infatti il punto 2) dell'algoritmo è molto simile a quell'esercizio: invece di "stampare il maggiore tra 1° e 2° numero" bisogna "memorizzare in PARZ12 il maggiore tra 1° e 2° numero).
2.5) mettere il contenuto dell'ACC nella cella PARZ12 (ora DATO2 è in PARZ12)
2.6) proseguire oltre le due istruzioni successive
2.7) mettere il contenuto della cella DATO1 nell'ACC
2.8) mettere il contenuto dell'ACC nella cella PARZ12 (ora DATO1 è in PARZ12)
Raffinamento dell'Algoritmo Programmazione
indirizzi |
semantica |
commenti |
istruzioni |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
il 2o in PARZ12 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|||
|
|
||
|
|
||
|
|
||
|
|
Eseguire il programma tre volte, con dati: {12, 3, 20},{19, 13, 2},{32, 33, 1}
tabella linguaggio macchina simbolico