
Sommario del Cap. 12 del Katz sul controllore di un processore

Sezione 12.1
Realizzazione con logica specifica (non strutturata oppure regolare come 
PLA e ROM).
In Fig. 12.1 si mostra la macchina a stati di Moore (mentre in Fig. 11.23 
si mostra la macchina a stati di Mealy).
In Fig. 12.4 si mostra una codifica della macchina a stati di Moore 
(mentre in Fig. 11.23 si mostra la macchina a stati di Mealy).
Dimensioni delle ROM:
  (macchina di Moore) 512x4 (stati fut.) + 16x18 (uscite) = 2336 bit
  (macchina di Mealy) 512x22 (stati fut. + uscite) = 11264 bit

Sezione 12.2
Realizzazione a partire dalla macchina di Moore con macchina decomposta 
in componenti funzionali (macchina a stati del tempo, macchina a stati 
delle istruzioni, macchina a stati delle condizioni)

Da qui in poi si passa a realizzazioni con componenti speciali
(contatori, ROM, selettori, etc.)

Sezione 12.3
Realizzazione con contatori semplici e ibridi
- includono una ROM per memorizzare lo stato futuro da caricare
  (quando non si azzera o incrementa il contatore)
  - la ROM e' indirizzata dallo stato presente nei contatori semplici
  - la ROM e' indirizzata dallo stato presente e da alcuni ingressi
    nei contatori ibridi
- segnali di controllo generati usando gli stati decodificati e gl'ingressi
In Fig. 12.16 si mostra l'assegnamento degli stati di un contatore a salto
ibridi che realizza una macchina di Mealy. 

Idea: perche' non passare alla soluzione radicale di realizzare
TUTTA la logica di stato futuro (e di generazione delle uscite)
con una ROM monolitica ?
Problema: ROM troppo grossa, raddoppia la dimensione per ogni ingresso
          che s'include
   Ad esempio, se si aggiungono alla ROM di salto dell'esempio le tre 
   nuove uscite CNT, CLR, LD la sua parola diventa di 7 bit (4 bit di 
   stato + 3 bit CNT, CLR, LD) e se si aggiungono all'indirizzo i 4 bit 
   di stato e un bit per Wait il suo numero di parole si moltiplica 
   per 2^5=32 volte. 
Soluzione di compromesso:
Sezione 12.4
Realizzazione con sequenzializzatore di salti
Fatto: lo stato futuro di un dato stato presente dipende solo da pochi ingressi
Proposta: dato uno stato presente, selezionare il sottoinsieme d'ingressi 
          necessari per determinare lo stato futuro
          indirizzo ROM = stato presente + ingressi corrispondenti
          contenuto ROM = stato(i) futuro(i) 
                          [devono essere in numero = 2^{numero_ingressi}]
In Fig. 12.19 si mostra lo schema di un sequenzializzatore a 4 vie che realizza
una macchina di Mealy: 
- indirizzo ROM = stato presente + coppia ingressi alfa e beta
- dato uno stato presente, un selettore sceglie quali due ingressi
  costituiscono la coppia alfa e beta del dato stato presente
- si puo' generalizzare da 2^2 a 2^N vie scegliendo N ingressi per
  stato presente 
In Fig. 12.20 e' riportato il contenuto della ROM per l'esempio 
- indirizzo: 7 bit = RESET + 4 stato presente + 2 segnali alfa e beta         
- contenuto: 4 bit stato futuro + segnali di controllo       

Si puo' considerare il precedente un sequenzializzatore di salti
in verticale
Osservazione: i selettori hanno molti segnali d'ingresso (16 ciascuno
              nell'esempio, mentre i segnali d'ingresso sono 4 in tutto),
              ma se ci sono pochi ingressi e molti stati si possono usare
              selettori con pochi ingressi 
Proposta: organizzazione orizzontale del sequenzializzatore di salti
- selettori controllati da segnali codificati provenienti dalla ROM
  che sono funzione solo dello stato 
- ROM indirizzata solo dallo stato presente
  nell'esempio si passa da una ROM con 2^6 parole a una con 2^4 parole
- stati futuri memorizzati orizzontalmente nella ROM
- si realizza una macchina di Moore
In Fig. 12.22 si mostra lo schema di un sequenzializzatore a 4 vie 
in orizzontale che realizza una macchina di Moore: 
Il passaggio dal verticale all'orizzontale si traduce nei seguenti
cambiamenti di dimensione delle ROM
2^6 x (4+14) = 1152 bit ---> 2^4 x (2+16+14) = 512 bit

Sezione 12.5
Microprogrammazione
Riguarda la generazione dei segnali di controllo
Microprogrammazione orizzontale
In Fig. 12.24 e' riportato il contenuto della ROM (inclusi i segnali 
di controllo) per l'esempio di sequenzializzatore orizzontale che realizza 
una macchina di Moore
Problema: parola troppo lunga (puo' superare centinaia di bit)
Soluzione parziale: codificare gruppi di segnali di uscita (vedi es. in Fig.
                    12.25)
Soluzione completa: microprogrammazione verticale = 
                    eseguire una microistruzione orizzontale lunga 
                    con una sequenza di microistruzioni brevi
                    svantaggi:
                    - ciclo piu' lungo (decodificatori, meno parallelismo)
                    - piu' cicli macchina
                    = esecuzione piu' lenta
                    vantaggi:
                    realizzazione controllore ridotta a programmare 
                    microistruzioni in analogia a programmare in linguaggio 
                    macchina
Microprogrammazione verticale
- definizione dei formati delle microistruzioni
  nell'esempio s'introducono le microistruzioni di salto e di controllo registri
  - microistruzioni di salto
    1 bit = 1 tipo istruzione
    2 bit condizione di selezione 
          [00 = Wait, 01 = AC<15>, 10 = IR<15>, 11 = IR<14>]
    1 bit condizione di confronto
    6 bit indirizzo a cui saltare
  - microistruzioni di controllo registri
    1 bit = 0 tipo istruzione
    3 bit controllo sorgenti
    3 bit controllo destinazioni
    3 bit controllo operazioni
In Fig. 12.27 e' riportato il contenuto della ROM (inclusi i segnali 
di controllo) per l'esempio di microprogramma verticale che realizza 
una macchina di Moore.
Il passaggio dalla microprogrammazione orizzontale alla verticale 
si traduce nei seguenti cambiamenti di dimensione delle ROM
2^4 x 38 = 608 bit ---> 31 x 10= 310 bit
[38 dovrebbe essere o 33 - orizzontale efficiente (da' 528 bit) 
o 40 - orizzontale inefficiente (da' 640 bit)]
l'efficienza e' dovuta al risparmio nel generare lo stato futuro
(si deve saltare raramente).
La realizzazione e' ottenuta con un microcontatore di programma
che avanza di 1 o carica un nuovo indirizzo a seconda della logica
di condizione.

Il microcodice puo' migrare dalla ROM alla RAM (almeno parzialmente)
per essere riscrivibile (permette correzioni, estensioni).

