Per eseguire una macroistruzione, la CPU attraversa tre fasi: FETCH, preleva il comando dalla memoria; DECODE, interpreta il codice operativo e l’operando; EXECUTE, compie l’operazione richiesta. Questo processo costituisce il ciclo macchina e si ripete per le istruzioni successive, fino all’arresto del programma.
1. Le tre fasi del ciclo macchina
Ogni macroistruzione viene elaborata attraverso FETCH, DECODE ed EXECUTE.
Ogni macroistruzione viene elaborata attraverso le tre fasi del ciclo macchina:
- FETCH — prelievo: la CPU legge la macroistruzione dalla RAM e la carica nel registro istruzione.
- DECODE — decodifica: interpreta il codice operativo e l’operando per individuare l’operazione richiesta.
- EXECUTE — esecuzione: compie l’operazione indicata dalla macroistruzione.
In Johnny Simulator queste fasi sono realizzate attraverso una sequenza di microistruzioni: operazioni elementari che trasferiscono valori, eseguono calcoli o aggiornano i contatori. Una fase non corrisponde necessariamente a un solo clic.
Segui prima TAKE già svolta, poi consulta il significato delle microistruzioni e ricostruisci autonomamente il ciclo di ADD nel laboratorio.
| Sigla | Nome completo | Funzione |
|---|---|---|
| PC | Program Counter — contatore del programma | Indica la cella RAM da cui prelevare il comando. |
| AB | Address Bus — bus degli indirizzi | Seleziona la cella RAM coinvolta nel trasferimento. |
| DB | Data Bus — bus dei dati | Trasporta il contenuto letto o da scrivere. |
| INS | Instruction Register — registro istruzione | Conserva il comando prelevato, con codice operativo e operando. |
| MC | Microcode Counter — contatore del microcodice | Indica la prossima riga da eseguire nella memoria del microcodice. |
| ACC | Accumulator — accumulatore | Conserva il dato di lavoro e il risultato delle operazioni. |
La freccia indica la direzione della copia: pc->ab significa “copia il valore del Program Counter nel bus degli indirizzi”. Non sposta il contenuto cancellando la sorgente. Nelle tabelle, l’indirizzo MC identifica una riga del microcodice, non una cella RAM.
Che cosa fa la decodifica in Johnny?
Nel modello di Johnny, la microistruzione ins->mc usa il codice operativo contenuto nel registro istruzione INS per scegliere da quale riga della memoria del microcodice iniziare la sequenza di esecuzione.
Se INS contiene 01 006, il codice operativo 01 identifica TAKE e imposta MC = 010, prima riga del microprogramma TAKE. L’operando 006 resta in INS: sarà usato durante EXECUTE per selezionare la cella del dato.
Il codice operativo sceglie la sequenza da eseguire; l’operando indica su quale cella lavorare. MC è il contatore che indica la prossima riga del microcodice, mentre INS conserva il comando.
In questa rappresentazione associamo DECODE al solo passo ins->mc. Johnny lo include nella sequenza iniziale chiamata fetch: la separazione in tre fasi chiarisce la funzione dei passi. Non è una regola universale delle CPU.
2. TAKE: caricare un dato
La lettura del comando è seguita dalla lettura del numero da caricare.
Operazione: caricare nell’accumulatore il contenuto della cella 006. Considera TAKE 006 nella cella 000 e il dato 3 nella cella 006. Prima del comando: PC = 000, MC = 000 e ACC = 0. Il prelievo caricherà in INS 01 006.
Una macroistruzione, più microistruzioni
| Fase | Indirizzo MC | Microistruzione | Che cosa fa |
|---|---|---|---|
| FETCH | 000 | pc->ab | Copia il Program Counter (PC) nel bus degli indirizzi (AB), selezionando la cella del comando. |
| FETCH | 001 | ram->db | Copia il contenuto della cella RAM selezionata nel Data Bus (DB, bus dei dati), senza modificarla. |
| FETCH | 002 | db->ins | Copia DB nell’Instruction Register (INS): il registro riceve il comando e il suo operando. |
| DECODE | 003 | ins->mc | Riconosce il codice operativo 01 di TAKE e porta MC a 010. L’operando 006 resta in INS per selezionare il dato. |
| EXECUTE | 010 | acc:=0 | Azzera l’Accumulator (ACC, accumulatore), preparando il caricamento tramite somma. |
| EXECUTE | 011 | ins->ab | Copia l’operando 006 da INS ad AB: seleziona la cella RAM[006]. |
| EXECUTE | 012 | ram->db | Copia il dato 3 dalla cella 006 nel bus dati. La cella conserva 3. |
| EXECUTE | 013 | plus | Somma DB ad ACC: 0 + 3 = 3. Il risultato resta in ACC. |
| EXECUTE | 014 | pc++ | Conclude la sequenza avanzando PC da 000 a 001, indirizzo del prossimo comando. |
| EXECUTE | 015 | mc:=0 | Riporta MC a 000, per iniziare il prelievo successivo. |
Stato finale: ACC = 3, PC = 001, MC = 000. RAM[006] conserva 3.
3. Le microistruzioni: tabella di riferimento
Consulta il significato delle operazioni prima di ricostruire una nuova sequenza.
La tabella elenca le operazioni disponibili, non il loro ordine di esecuzione. La sequenza necessaria dipende dalla macroistruzione. Per il laboratorio scegli le operazioni osservando il microcodice di Johnny.
| Microistruzione | Che cosa fa |
|---|---|
pc->ab | Copia il valore del Program Counter (PC) nel bus degli indirizzi (AB), selezionando la cella RAM del comando. |
ram->db | Copia il contenuto della cella RAM indicata da AB nel bus dei dati (DB). La cella conserva il valore. |
db->ins | Copia il contenuto di DB nel registro istruzione (INS). |
ins->mc | Usa il codice operativo in INS per selezionare la prima riga del microprogramma. Per ADD, codice 02, MC diventa 020. |
ins->ab | Copia l’operando di INS nel bus degli indirizzi AB, selezionando la cella del dato. |
db->acc | Copia il contenuto di DB nell’accumulatore (ACC), sostituendone il valore precedente. |
acc->db | Copia il valore dell’accumulatore nel bus dei dati. ACC conserva il valore. |
db->ram | Copia il contenuto del bus dati nella cella RAM indicata da AB, sostituendone il contenuto. |
acc:=0 | Azzera direttamente l’accumulatore, senza trasferire dati su DB. |
plus | Somma il valore già presente sul bus dati al contenuto dell’accumulatore; il risultato resta in ACC. |
minus | Sottrae il valore del bus dati dal contenuto dell’accumulatore; il risultato resta in ACC. |
acc++ | Incrementa direttamente ACC di uno, senza passare per DB. |
acc-- | Decrementa direttamente ACC di uno, senza passare per DB. |
pc++ | Incrementa il Program Counter di uno, senza trasferire il valore su DB. |
ins->pc | Copia l’operando di INS nel Program Counter, impostando l’indirizzo da cui proseguirà il programma. |
=0:pc++ | Incrementa PC soltanto se l’accumulatore contiene zero. |
mc:=0 | Azzera direttamente il contatore del microcodice per tornare all’inizio del prelievo. |
stopp | Arresta l’esecuzione del simulatore. |
Nel modello numerico di Johnny, i valori restano nell’intervallo 0–19999: le operazioni non producono valori sotto zero o sopra il limite.
LABORATORIO
Ricostruire il ciclo macchina di ADD
Tempo: 20 minuti.
Dopo aver seguito TAKE già svolta, ricostruisci il prelievo, la decodifica e l’esecuzione di ADD 007. Usa la tabella di riferimento e osserva i cambiamenti nel simulatore.
1. Preparare programma e dati
| Cella RAM | Contenuto | Ruolo |
|---|---|---|
| 000 | TAKE 006 | Carica il primo dato. |
| 001 | ADD 007 | Somma il secondo dato all’accumulatore. |
| 002 | HLT 000 | Termina il programma. |
| 006 | 3 | Primo dato. |
| 007 | 4 | Secondo dato. |
- Inserisci programma e dati, poi premi Reset.
- Esegui TAKE con un macro passo. Prima di iniziare ADD verifica ACC = 3, PC = 001 e MC = 000.
- Seleziona Ctrl per mostrare l’unità di controllo.
- Prosegui con un micro passo alla volta, fino alla conclusione di ADD. Fermati quando MC torna a 000 e PC vale 002, prima del prelievo di HLT.
2. Completare la tabella
Per ciascuna riga scrivi la microistruzione eseguita e il suo effetto, come nell’esempio TAKE. La riga gialla indica il passo ancora da eseguire: annotalo, eseguilo e osserva il cambiamento.
| Fase | Indirizzo MC | Microistruzione | Che cosa fa e quale valore cambia |
|---|---|---|---|
| FETCH | 000 | ________________ | ________________ |
| FETCH | 001 | ________________ | ________________ |
| FETCH | 002 | ________________ | ________________ |
| DECODE | 003 | ________________ | ________________ |
| EXECUTE | 020 | ________________ | ________________ |
| EXECUTE | 021 | ________________ | ________________ |
| EXECUTE | 022 | ________________ | ________________ |
| EXECUTE | 023 | ________________ | ________________ |
| EXECUTE | 024 | ________________ | ________________ |
3. Controllare il risultato
- Prevedi il valore finale di ACC e confrontalo con quello ottenuto.
- Controlla che le celle 006 e 007 conservino i dati iniziali.
- Indica quali passi hanno usato DB e quali hanno aggiornato direttamente un registro.
- Confronta TAKE e ADD: quali passi ritrovi? Quali differenze osservi nell’esecuzione?
Completa queste frasi dopo l’osservazione: FETCH serve a…; DECODE serve a…; EXECUTE, nel caso di ADD, serve a…