Mic-1

Microarchitecture Dal Tanenbaum

Implementazione hardware di un interprete del linguaggio ISA IJVM

Composto da:

Data Path
Control Unit

Data Path

temporizzazione

Input NOR Not(Input)

Input NOR InRitardato
il ritardo introdotto diventa l'intervallo alto del Clock

rd/wr/fetch

richiesta di lettura di memoria nel ciclo k –> ricevuta dei dati al ciclo k+2

Control Unit

Control Store

512

2^9 parole da 36 bit

NB MPC e MIR sono logicamente divisi dal Data Path
- fanno parte della Control Unit

MIR

Micro Instruction Register

36 bit

definiscono le configurazioni della ALU

Addr JAM ALU C Mem B /

9 3 8 9 3 4 bit
- Address
  - 0x100
- JAM - controlla la Highbit Network
  - 000
    - goto(Addr)
      
      implicito tra ogni microistruzione, sottointeso in MAL
  - JMPC - salto incondizionato
    - Ogni opcode e' l’indirizzo della sua prima microistruzione nel suo microprogramma
    - Questo semplifica molto l’architettura
    - L’unica connessione hardware da MBR e' verso MPC
    - JMPC implementa il goto(MBR), usato nella fase di fetch nel Main1
  - JAMZ/JAMN - salto condizionato
    
    Il bit Addr[8], piu' significativo, passa attraverso la la High-bit network
    - 000
      - passa senza cambiamenti
    - 010/001
      - high-bit utilizza Z/N
        
        (JAMZ AND Z)OR(AMN AND N)OR(Addr[8])
        
        un OR a 3 ingressi e 2 AND 5 IN, 1 OUT
    - La Highbit Network decide il bit alto di MPC
      - es. JAMZ=1, JAMN=0, Addr[8]=0 Highbit = Z <==> 1 se cio' che e' risultato dalla ALU = 0 quindi MPC = Addr O Addr+0x100 +256
    - In questo modo non si usano 2 Registri per i salti (Addr1 e Addr2)
      - inefficiente, la maggior parte delle volte il secondo indirizzo non sarebbe usato
      - quindi usiamo il formato:
        
        X e X+k
        
        utilizzando dei semplici segnali di controllo
- Shifter + ALU
  - SLL8
    
    shift sinistra logico
    - utilizzato per la consecuzione di 2 Byte
  - SRA1
    
    shift destra aritmetico
    - moltiplicazione per 2
  - ALU
    
    a 32 bit
    - f0
    - f1
    - EnA
    - EnB
    - InvA
    - Inc
- Controllo del Bus C
  - segnali indipendenti
  - controllano individualmente i 9 registri scritti dal bus C
    - tutti tranne MBR
- Memoria
  - rd
  - wr
    - riguardanti MAR e MDR
  - fetch
    - riguardante PC e MBR
- Controllo del Bus B
  - controlla un decoder a 4 bit, 2^4 uscite
    - utilizziamo 9 delle 16 possibili uscite
      - le uscite in piu' ci permettono una decima configurazione che sara' il segnale per la selezione di nessun registro
      - tutti tranne MAR
      - ho due configurazioni per MBR:
        
        signed - MBR
        
        unsigned - MBRU (in MAL)
    - al piu' un registro e' attivato e scritto sul bus B
    - le uscite dei registri sono in OR logico tra loro
      - vedi 8-bit Memory
      - implementato con: Wired OR Connection
        
        usando diodi e la terra, l’intersezione dei bit In rappresenta il valore logico dell’Out

Addr	JAM	ALU	C	Mem	B	/
9	3	8	9	3	4	bit

MPC

OR

tra le entrate del registro (escluso highbit)
- Addr
- MBR
–> controllo: JMPC
- JMPC=1 Addr OR MRB ~ dove Addr=0x000/0x100
- goto(Addr)
  
  JMPC = 0 = JAMZ = JAMN
- goto(MBR OR Addr)
  
  JMPC = 1 NB il bit piu' significativo di Addr sara' comunque indipendentemente deciso dal Highbit Network
- salti condizionati
  
  ~ if(N) goto(Addr+0x100) else goto(Addr)
  
  ~ if(Z) goto(Addr+0x100) else goto(Addr)

Registri virtuali

MPC

effettivamente un registro vero e proprio, come PC o LV…
- sono flip-flop (9 nel caso specifico)
- infatti per motivi di temporizzazione MPC deve essere caricato DOPO il fronte ascendente del ciclo di clock, perche' ha bisogno di tutti i registri caricati alla fine del ciclo di datapath
  - viene impostato nella finestra alta
    - sara' cosi' pronto per impostare il MIR durante il fronte discendente subito successivo

MIR

non e' un registo, piuttosto una astrazione per motivi didattici
- e' semplicemeente l’uscita della memoria ROM Control Store

Micro Assembly Language

MAL un linguaggio mnemonico che permette una microprogrammazione che sia piu' semplice per un umano

configurazioni del Data Path

SOURCE{…}

DEST{…}

<<

>>

Z=TOS if(Z)

N=TOS if(N)

goto(MBR)

Limiti

Approcci per migliorare la velocita' di esecuzione

sempre con il riferimento dell'equilibrio costo/beneficio

limiti fisici
- tempo di transizione tra livelli logici
- limite di velocita' della propagazione dei segnali
- rallentamento dovuto ai transistor nei circuiti implementati

Ridurre il numero di cicli di Clock necessari per un’istruzione

Fusione del ciclo di esecuzione dell’interprete (goto Main1)
- introdurre il ciclo dell’interprete all’interno dei ogni microprogramma
  - pop2 e' un ciclo di attesa
    - qui possiamo fondere un Main1.pop
  - questo non e' possibile con molte miscroistruzioni
Cambiare il DataPath
- H unico ingresso A della ALU
  - rallentamento nel dover sempre inserire un registro in H per eseguire algerbra
- introdurre un terzo Bus A
  - DataPath Mic-2
  - permette operazioni piu' flessibili al prezzo di piu' del doppio della complessita'
Introduzione di una Instruction Fetch Unit aka IFU
- INC sempre dello stesso registro PC
- Pre-Fetching

un incrementatore dedicato al PC

16 bit per la porta della memoria di lettura di offset a 2 byte

Semplificare l’organizzazione

rendendo il ciclo di clock piu' breve

Decoder per il bus B
- la scrittura su B avviene molto spesso
- diviene un collo di bottiglia

Risolvibile estendendo il campo B in MIR da 4 bit a 9 bit

Sovrapporre l’esecuzione delle istruzioni

Pipelining

spezzare microistruzioni in sottocicli tra loro paralelizzabili

semplificando il ciclo fetch-decode-execute
- sovrapporre l’esecuzione delle istruzioni
- il datapath mic-2 e' strettamente sequenziale
  
  3 operazioni (sottocicli) che dipendono l’una dall’altra temporalmente
- introduciamo 3 latch
  
  scritti ad ogni ciclo
  - A latch
  - B latch
  - C latch
- microstep
  
  ora il datapath precedente la ALU e il datapath successivo sono indipendenti Ora abbiamo 3 microstep (micropassi)
  1. I registri scrivono sui latch A e B
  2. ALU legge i latch A e B, scrive nel latch C il risultato
  3. leggere dal latch C e scrivere sui registri abilitati
- parallelismo
  
  Abbiamo guadagnato parallelismo Potremmo immaginare di triplicare il clock, ad ogni ciclo eseguiamo 1 microstep
  
  Non acceleriamo la velocita' di una microistruzione, il tempo lo guadagnamo iniziando il primo microstep della microistruzione successiva contemporaneamente al secondo microstep della precedente
  
  Puo' crearsi uno stallo se il esiste una condizione che constringe le microistruzioni ad operare sequenzialmente
  - es: aspettare il risultato di una read

NB

c’e' sempre da tenere in conto la compatibilita' con il passato nella realta'

Dan's Brain