Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out

Computer Organization _ Design

VIEWS: 4 PAGES: 85

									Architetture dei Calcolatori
          (Lettere j-z)

      Il Processore (2)


     Ing. Davide D’Amico
Approccio Multiciclo


 q   Suddividere l’esecuzione di una istruzione in piu’
     passi (steps)
     m   Fetch, Decode, Execute, Memory Access, Write Back
     m   Ogni passo richiede un ciclo di clock
     m   Istruzioni diverse possono richiedere un numero
         diverso di passi (cicli)
     m   I passi scelti in modo da bilanciare il carico di lavoro
          ü In modo da minimizzare la durata del ciclo di clock
 q   Assunzione: in un passo/ciclo di clock si puo’
     effettuare una sola operazione tra:
     m   Accesso in memoria
     m   Accesso al banco dei registri (lettura o scrittura)
     m   Operazione ALU
                                                                  CPU (2)   2
Approccio Multiciclo

q   Alla fine di ogni ciclo
    m   Bisogna memorizzare i valori richiesti dai cicli successivi
        dell’istuzione corrente
    m   Richiede l’impiego di registri addizionali interni (invisibili al
        programmatore):
         ü IR:    Instruction Register
         ü MDR: Memory Data Register
         ü A & B: Valori letti dai registri
         ü ALUout: Registro che memorizza il risultato delle operazioni
           ALU




                                                                  CPU (2)   3
Approccio Multiciclo

q   Vantaggi
    m   Unita’ funzionali che devono essere usata piu’ volte per la
        stessa istruzione non devono essere replicate se
        impiegate in passi diversi
         ü Una sola memoria per dati e istruzioni
         ü Una sola ALU (no adder)
    m   Tempo di ciclo piu’ breve
    m   Tempi di esecuzione inferiori
         ü Istruzioni usano il solo tempo (cicli) necessario alla loro
           esecuzione




                                                                     CPU (2)   4
Unità di elaborazione a ciclo multiplo: una
vista astratta
                                          Contiene
                                        l’istruzione


                                                Dati dal primo
                                                  registro




                                               Risultato
                                               della ALU
                           Dati dalla
                           memoria            Dati dal secondo
                                                  registro
                                                   CPU (2)       5
Una vista più dettagliata

q Poiché le unità funzionali sono condivise, occorre aggiungere dei
  multiplexer ed ampliare quelli già esistenti nel ciclo singolo
q Unica Memoria per dati e istruzioni
    m   Si aggiunge un multiplexer per selezionare il PC o ALUOut come
        indirizzo della memoria da leggere/scrivere
q Dovendo condividere la ALU
    m   Si aggiunge un multiplexer per il primo ingresso della ALU per
        selezionare il registro A (primo registro) oppure il PC (per il calcolo
        dell’indirizzo dell’istruzione successiva)
    m   Il multiplexer a 2 vie sul secondo ingresso della ALU viene ampliato
        a 4 vie
         ü Una per il valore 4 (per il calcolo dell’indirizzo dell’istruzione successiva)
         ü Una per il valore dell’indirizzo (16 bit, estesi in segno a 32 e traslati a
           sinistra)




                                                                             CPU (2)        6
Una vista più dettagliata (2)

                           Mux su primo
         Indirizzo da PC   ingresso ALU
            o da ALU




                           Mux su secondo
                            ingresso ALU    CPU (2)   7
I segnali di controllo

q   Nell’unità a ciclo multiplo occorre cambiare anche
    l’insieme dei segnali di controllo
    m   Gli elementi di memoria visibili al programmatore (il PC, la
        memoria ed i registri) e l’IR hanno bisogno di un segnale
        di controllo per la scrittura
    m   La memoria ha anche bisogno di un segnale di controllo
        per la lettura
    m   Ciascuno dei due multiplexer a due vie aggiunti ha bisogno
        di un segnale di controllo a 1 bit
    m   Il multiplexer a quattro vie ha bisogno di un segnale di
        controllo a 2 bit




                                                              CPU (2)   8
L’unità con i segnali di controllo




                                     CPU (2)   9
Implementazione dei salti

q Per le istruzioni di jump e branch, ci sono tre possibili sorgenti
   per il valore da scrivere in PC
    m   L’output della ALU, con il valore PC+4 calcolato durante la fase di
        fetch dell’istruzione
    m   Il registro ALUOut, dove è memorizzato l’indirizzo del branch una
        volta che è stato calcolato
    m   I 26 bit meno significativi dell’IR traslati a sinistra di 2 e
        concatenati con i 4 bit più significativi del PC incrementato, se
        l’istruzione è di jump




                                                                 CPU (2)      10
Implementazione dei salti: jump
                                  Prelievo dei 26 bit
                                       per jump




                                      Scelta del valore
                                      da scrivere in PC:
                                      0: PC+4
                                      1: indirizzo del
                                      salto condizionato
                                               CPU di
                                      2: indirizzo(2) jump 11
Implementazione dei salti: beq
In OR con PCWrite          Zero (dalla
per indicare la            ALU) AND
scrittura di PC           PCWriteCond




                                          Scelta del
                                         valore in PC




                                               CPU (2)   12
Il controllo della ALU
                               ALUOp come
                                  input




                                       3 bit di controllo alla
                                         ALU come output



                                      Unità di controllo
              6 bit di funct              della ALU
               come input                    CPU (2)       13
L’unità di elaborazione multi-ciclo




                                      CPU (2)   14
I segnali di controllo ad 1 bit
  Segnale         Effetto quando vale 0                    Effetto quando vale 1

RegDst        Registro destinazione = rt           Registro destinazione = rd
RegWrite      Nessuno                              Nel registro indicato sull’ingresso Write
                                                   register viene scritto il valore Write data
ALUSrcA       Il primo operando di ALU è PC        Il primo operando di ALU è registro A

MemRead       Nessuno                              Lettura della locazione di memoria
                                                   indicata da Address
MemWrite      Nessuno                              Scrittura della locazione di memoria
                                                   indicata da Address
MemtoReg      Il valore in Write data (registri)   Il valore in Write data (registri) viene da
              viene da ALUOut                      MDR

IorD          L’indirizzo proviene da PC           L’indirizzo proviene da ALUOut
IRWrite       Nessuno                              Uscita memoria scritta in IR

PCWrite       Nessuno                              Scrittura in PC: provenienza da PCSource


PCWriteCond   Nessuno                              Scrittura in PC se Zero di ALU è 1



                                                                                  CPU (2)        15
I segnali di controllo a 2 bit
 Segnale    Val   Effetto
 ALUOp      00    L’ALU calcola la somma
            01    L’ALU calcola la sottrazione
            10    Operazione determinata dal campo funct
 ALUScrB    00    Il secondo ingresso della ALU: proviene da reg. B
            01    …: è la costante 4
            10    …: il valore dei 16 bit meno sign. di IR, estesi a 32
            11    …: il valore dei 16 bit meno sign. di IR, estesi a 32,
                  traslati a sinistra di 2 bit
 PCSource   00    In PC viene scritta l’uscita della ALU (PC+4)
            01    In PC viene scritto ALUOut (indirizzo di beq)
            10    In PC viene scritto l’indirizzo di jump (26 bit meno
                  sign. di IR, traslati a sinistra di 2 bit e concatenati
                  con i 4 bit più sign. di PC)


                                                                CPU (2)     16
Esecuzione di una istruzione in più cicli

q   Obiettivo:
    m   Decomporre le istruzioni in modo da bilanciare il carico di
        lavoro in ogni ciclo (e minimizzare la durata del ciclo di
        clock)
q   Suddividiamo le istruzioni in una serie di passi
    m   Ogni passo coincide con un ciclo di clock
    m   Ogni passo comprende al più:
         ü Un’operazione con la ALU
         ü Un accesso al banco dei registri
         ü Un accesso alla memoria
q   In questo modo, la durata del ciclo di clock sarà
    pari alla durata della più lenta di queste tre
    operazioni

                                                            CPU (2)   17
Alla fine di ciascun ciclo di clock

q   Tutti i valori che sono necessari al passo
    successivo/Istruzione
    m   Sono memorizzati in qualche componente
q   Ad esempio
    m   Il Program Counter
    m   Il banco dei registi
    m   La memoria
    m   Uno dei registri addizionali
         ü A, B, MDR oppure ALUOut
         ü IR (dotato di segnale di controllo per la scrittura)
             – IR è l’unico tra i registri addizionali a contenere lo stesso
               dato (l’istruzione) per tutti i passi di esecuzione di una
               istruzione


                                                                   CPU (2)     18
Suddivisione in Passi

q Si suddividono le istruzioni nei seguenti passi potenziali – non
  tutte le istruzioni le richiedono tutte
m Prelievo Istruzione e Incremento del PC (IF)
   m   Si preleva l’istruzione in base a PC e si salva in IR. PC e’
       incrementato di 4
n Decodifica Istruzione e Prelievo Registri (ID)
   m   Si leggono i registri rs e rt in caso servano
   m   Si calcola l’indirizzo di salto (nel caso l’istruzione sia di salto).
n Esecuzione, Calcolo Indirizzo di Memoria, o completamento
  salto (EX)
   m   ALU esegue una delle seguenti funzioni in base al tipo di
       istruzione
        ü memory reference
        ü R-type
   m   branch (Istruzione Completata)
   m   jump (Istruzione Completata)

                                                                       CPU (2)   19
Suddivisione in Passi

4.   Accesso in Memoria e Completamento Istruzione R (MEM)
     m   In base al tipo di istruzione
         ü Legge dalla memoria
         ü Scrive in memoria (Istruzione Completata)
         ü Scrittura nel Registro Destinazione (Istruzione Completata)
5.   Completamento lettura da Memoria (WB)
     m   Il dato letto dalla memoria in 4 viene scritto nel registro Destinazione
         (Load completato)


q    Le istruzioni MIPS richiedono da 3 a 5 cicli di clock
     m   Jump e branch: 3 cicli
     m   Formato R, store: 4 cicli
     m   Write:            5 cicli




                                                                          CPU (2)   20
Prelievo dell’Istruzione (IF)


         IR = M[PC];
         PC = PC + 4;




PC + 4
                                4




                                    CPU (2)   21
Decodifica Istruzione e Lettura Registri (ID)



         A = Reg[IR[25-21]];           (A = Reg[rs])
         B = Reg[IR[20-15]];           (B = Reg[rt])
         ALUOut = (PC + sign-extend(IR[15-0]) << 2)




                                                       Branch
                                             Reg[rs]
                                                       Target
                                                       Address


PC + 4

                                            Reg[rt]



                                                       CPU (2)   22
Formato R: (EX) – Esecuzione ALU

ALUOut = A op B




                            Reg[rs]
                                       R-Type
                                       Result


PC + 4

                            Reg[rt]




                                      CPU (2)   23
Formato R: (MEM) – Scrittura Registro Dest.

Reg[IR[15:11]] = ALUOUT




                            Reg[rs]
                                         R-Type
                                         Result


PC + 4

                            Reg[rt]




                                        CPU (2)   24
Decodifica Istruzione e Lettura Registri (ID)



         A = Reg[IR[25-21]];           (A = Reg[rs])
         B = Reg[IR[20-15]];           (B = Reg[rt])
         ALUOut = (PC + sign-extend(IR[15-0]) << 2)




                                                       Branch
                                             Reg[rs]
                                                       Target
                                                       Address


PC + 4

                                            Reg[rt]



                                                       CPU (2)   25
Branch: (EX) – Aggiornamento PC

if (A == B) PC = ALUOut;




                                      Branch
                            Reg[rs]
                                      Target
                                      Address


Branch
Target
Address
                            Reg[rt]




                                      CPU (2)   26
Decodifica Istruzione e Lettura Registri (ID)



         A = Reg[IR[25-21]];           (A = Reg[rs])
         B = Reg[IR[20-15]];           (B = Reg[rt])
         ALUOut = (PC + sign-extend(IR[15-0]) << 2)




                                                       Branch
                                             Reg[rs]
                                                       Target
                                                       Address


PC + 4

                                            Reg[rt]



                                                       CPU (2)   27
Jump: (EX) – Aggiornamento PC

PC = PC[31-28] concat (IR[25-0] << 2)




                                                   Branch
                                        Reg[rs]
                                                   Target
                                                   Address


 Jump
Address
                                        Reg[rt]




                                                  CPU (2)    28
Decodifica Istruzione e Lettura Registri (ID)



         A = Reg[IR[25-21]];           (A = Reg[rs])
         B = Reg[IR[20-15]];           (B = Reg[rt])
         ALUOut = (PC + sign-extend(IR[15-0]) << 2)




                                                       Branch
                                             Reg[rs]
                                                       Target
                                                       Address


PC + 4

                                            Reg[rt]



                                                       CPU (2)   29
Store: (EX) Calcolo Indirizzo

ALUOut = A + sign-extend(IR[15-0]);




                                      Reg[rs]    Mem.
                                                Address



PC + 4

                                      Reg[rt]




                                                CPU (2)   30
Store: (MEM) Scrittura in Memoria

M[ALUOut] = B;




                            Reg[rs]




PC + 4

                            Reg[rt]




                                      CPU (2)   31
Decodifica Istruzione e Lettura Registri (ID)



         A = Reg[IR[25-21]];           (A = Reg[rs])
         B = Reg[IR[20-15]];           (B = Reg[rt])
         ALUOut = (PC + sign-extend(IR[15-0]) << 2)




                                                       Branch
                                             Reg[rs]
                                                       Target
                                                       Address


PC + 4

                                            Reg[rt]



                                                       CPU (2)   32
Load: (EX) Calcolo Indirizzo

ALUOut = A + sign-extend(IR[15-0]);




                                      Reg[rs]    Mem.
                                                Address



PC + 4

                                      Reg[rt]




                                                CPU (2)   33
Load: (MEM) Lettura in Memoria

MDR = M[ALUOut];




                            Reg[rs]    Mem.
                                      Address



PC + 4

                   Mem.     Reg[rt]
                   Data




                                      CPU (2)   34
Load: (WB) – Scrittura nel Registro Dest.

Reg[IR[20-16]] = MDR;




                               Reg[rs]
                                             Mem.
                                            Address


PC + 4

                        Mem.   Reg[rt]
                        Data




                                            CPU (2)   35
        Schema Riassuntivo Implementazione Multiciclo




Step                               Action for R-type   Action for memory-reference      Action for        Action for
                Step name            instructions               instructions            branches            jumps
1: IF   Instruction fetch                                              IR = M[PC]
                                                                       PC = PC + 4
        Instruction                                                A = Reg [IR[25-21]]
2: ID   decode/register fetch                                      B = Reg [IR[20-16]]
                                                       ALUOut = PC + (sign-extend (IR[15-0]) << 2)
         Execution, address        ALUOut = A op B      ALUOut = A + sign-extend     if (A ==B) then PC = PC [31-28] II
3: EX    computation, branch/                                 (IR[15-0])              PC = ALUOut      (IR[25-0]<<2)
         jump completion
         Memory access or R-type   Reg [IR[15-11]] =     Load: MDR = M[ALUOut]
4: MEM   completion                    ALUOut                      or
                                                          Store: M[ALUOut] = B
5: WB    Memory read completion                        Load: Reg[IR[20-16]] = MDR




                                                                                                     CPU (2)           36
Controllo

q L’Unita di Controllo deve generare:
   m   I segnali di controllo dell’ALU
                                                      Opcode               Read/Write
   m   I segnali di controllo dei vari multiplexer                           Memorie
                                                          6
   m   I segnali di abilitazione alla scrittura/lettura                     Controllo MUX
       dei diversi elementi di memoria                         Controllo
                                                      Funct
q In funzione del…
                                                          6                Controllo ALU
q Tipo di Istruzione da eseguire (Ingresso)
   m   I bit del campo opcode (e funct nel caso del
       formato R) dell’istruzione
2. Step dell’istruzione


Þ Una rete combinatoria non e’ sufficiente ad
  implementare il controllo multiciclo



                                                                      CPU (2)              37
Controllo Multiplo Ciclo: Rete Sequenziale

q Il controllo sara’ realizzato da                Opcode                         Read/Write

  una rete sequenziale                                                             Memorie
                                                       6
   m   Automa a Stati finiti                                                      Controllo MUX
                                                             Controllo
   m   Micropragramma                              Funct

                                                       6                         Controllo ALU
q Per semplificare la
  progettazione/circuito del
                                        Opcode
  controllo suddivideremo l’unita’                           Read/Write
                                                                 Memorie
  di controllo in                          6

   m   Unita’ di Controllo Principale            Controllo       Controllo MUX


   m   Unita’ di Controllo ALU
                                                                  ALUOp

                                                             2
q Per il controllo dell’ALU                                                 ALU           Controllo ALU

  useremo la stessa rete                                         Funct     Control
  combinatoria vista per                                              6
  l’implementazione singolo ciclo
                                                                            CPU (2)               38
Implementazione Unita’ di Controllo Principale

q   Possiamo implementare l’Unita’ di Controllo come una
    rete sequenziale di Moore
    m   Stato: passo di esecuzione dell’istruzione corrente
         ü IF, ID, Ex-Formato R, Ex-beq, etc…
    m   Ingressi: Opcode Istruzione
    m   Uscite: Segnali di Controllo verso DataPath
                        Opcode
                                    Rete
                            6    Combinatoria

                                                Read/Write Memorie
                                    Stato       Controllo MUX
                                                    ALUOp
                                                2
q   Bisogna Specificare
    m   Funzione Prossimo Stato: Stato(n+1)=F(Stato(n),Ingressi(n))
    m   Funzione Uscita: Uscite(n)=G(Stato(n))
         ü Perche’ e’ un automa di Moore
                                                                     CPU (2)   39
  Struttura dell’Automa a Stati Finiti

    q I primi due passi sono indipendenti dall’istruzione
    q I restanti passi sono differenziati a seconda dell’operazione
    q Ciascuna porzione della macchina a stati finiti può essere
          composta da più stati
                                       Inizio


                                     Fetch

                             Decode, Fetch Reg, beq



  Calcolo Indirizzo      R-type EXE             Beq EXE (PC update)   Jump EXE (PC update)


M-Read       M-Write       R-Write


R-Write




                                                                                CPU (2)      40
    Segnali di Controllo: (IF)

    IR = M[PC];              PC = PC + 4;
    - MemRead=1              -  ALUSrcA=0, ALUSrcB=01
    - IRWrite=1              -  ALUOp=00
    - IorD=0                 -  PCWrite=1, PCSource=00
                  1



1
      0      0                                 0
                                        X          010

                                                                   0


                       X
             1               0
                                               1

                                                         CPU (2)   41
    Segnali di Controllo: (ID)

A   =    Reg[IR[25-21]]; (A = Reg[rs])   ALUOut = (PC + sign-extend(IR[15-0]) << 2);
B   =    Reg[IR[20-15]]; (B = Reg[rt])   -  ALUSrcA=0, ALUSrcB=11
-   A    e B sempre sovrascritti         -  ALUOp=00
        (nessun segnale di controllo)



                        0


0
         X                                                   0
                  0                                   X          010


                                                                                  X


                                   X
                  0                       0
                                                             3
                                                                       CPU (2)    42
    Segnali di Controllo: (EX) Formato R - ALU

    ALUOut = A op B;
    - ALUSrcA=1, ALUSrcB=00
    - ALUOp=10 (Operation dipende da Funct)
                     0
    - ALUOut riscritto ad ogni ciclo)




0
     X                                            1
             0                                X       ???


                                                                      X


                            X
             0                    0
                                                  0


                                                            CPU (2)   43
        Segnali di Controllo: (MEM) Formato R –
        Scrittura Registro Destinazione
        Reg[IR[15:11]] = ALUOut;                                     (Reg[Rd] = ALUOut)
        - RegDest=1
        - ReWrite=1
        - MemtoReg=0
                          0         IRWrite




                                       I      Instruction I                                          jmpaddr               28                   32
  0
PCWr*
                                       R
                                                               rs         rt
                                                                                        5
                                                                                                rd
                                                                                                     I[25:0]       <<2                CONCAT


         X                                    32                    5          5
                                                                                   0
                                                                                   MUX
                                                                                            1        RegDst
                                                                                                                      X
                                                                                                                                                        2
                                                                                                                                                            M
         IorD
                        0                                                               5              1           ALUSrcA
                                                                                                                                XXX
                                                                                                                                                        1U
                                                                                                                                                            X
 PC                                                                                                                        Operation                    0
                   MemWrite                                     RN1        RN2     WN                                            3
         0M                                                                                                          0M
          U     ADDR                   M                                                                              U                              PCSource
         1X                                                         Registers                                                          Zero
                     Memory            D            1M                                  RD1           A              1X
                               RD      R             U
                                                    0X
                                                              WD                                                                ALU
                                                                                                                                               ALU
                                                                                                                                                        X
                                                                                                                                               OUT
                WD                                                                      RD2           B              0
                     MemRead                   MemtoReg                                                        4     1M
                                                                                                                       U
                                                                                                                     2X
                                                     0          RegWrite                                             3

                        0                                               1      E
                                                                                                                   ALUSrcB
                                                   immediate         16        X   32
                                                                               T
                                                                               N
                                                                                                 <<2
                                                                                                                     X
                                                                               D


                                                                                                                                          CPU (2)           44
    Segnali di Controllo: (ID)

A   =    Reg[IR[25-21]]; (A = Reg[rs])   ALUOut = (PC + sign-extend(IR[15-0]) << 2);
B   =    Reg[IR[20-15]]; (B = Reg[rt])   -  ALUSrcA=0, ALUSrcB=11
-   A    e B sempre sovrascritti         -  ALUOp=00
        (nessun segnale di controllo)



                        0


0
         X                                                   0
                  0                                   X          010


                                                                                  X


                                   X
                  0                       0
                                                             3
                                                                       CPU (2)    45
   Segnali di Controllo: (EX) Branch – Agg. PC
   if (A == B) PC = ALUOut;
   - ALUSrcA=1, ALUSrcB=00
   - ALUOp=01
   - PCWrite=0, PCWriteCond=1, PCSource=01

                     0


 1 if
Zero=1
      X                                          1
             0                               X       110


                                                                     1


                           X
             0                    0
                                                 0

                                                           CPU (2)   46
    Segnali di Controllo: (ID)

A   =    Reg[IR[25-21]]; (A = Reg[rs])   ALUOut = (PC + sign-extend(IR[15-0]) << 2);
B   =    Reg[IR[20-15]]; (B = Reg[rt])   -  ALUSrcA=0, ALUSrcB=11
-   A    e B sempre sovrascritti         -  ALUOp=00
        (nessun segnale di controllo)



                        0


0
         X                                                   0
                  0                                   X          010


                                                                                  X


                                   X
                  0                       0
                                                             3
                                                                       CPU (2)    47
    Segnali di Controllo: (EX) Jump – Agg. PC

    PC = PC[21-28] concat (IR[25-0] << 2);
    - PCWrite=1, PCSource=10

                      0



1
     X                                           X
             0                               X       XXX


                                                                     2


                            X
             0                     0
                                                 X


                                                           CPU (2)   48
    Segnali di Controllo: (ID)

A   =    Reg[IR[25-21]]; (A = Reg[rs])   ALUOut = (PC + sign-extend(IR[15-0]) << 2);
B   =    Reg[IR[20-15]]; (B = Reg[rt])   -  ALUSrcA=0, ALUSrcB=11
-   A    e B sempre sovrascritti         -  ALUOp=00
        (nessun segnale di controllo)



                        0


0
         X                                                   0
                  0                                   X          010


                                                                                  X


                                   X
                  0                       0
                                                             3
                                                                       CPU (2)    49
    Segnali di Controllo: (EX) Store – Calc. Indirizzo

    ALUOut = A + sign-extend(IR[15-0]);
    - ALUSrcA=1, ALUSrcB=10
    - ALUOp=00
                      0



0
      X                                        1
             0                            X        010


                                                                   X


                            X
             0                     0
                                               2


                                                         CPU (2)   50
    Segnali di Controllo: (MEM) Store – Scr. in Memoria

    Memory[ALUOut] = B;
    - IorD=1
    - MemWrite=1

                          0


0
      1                                      X
             1                         X         XXX


                                                                 X


                              X
             0                    0
                                            X


                                                       CPU (2)   51
    Segnali di Controllo: (ID)

A   =    Reg[IR[25-21]]; (A = Reg[rs])   ALUOut = (PC + sign-extend(IR[15-0]) << 2);
B   =    Reg[IR[20-15]]; (B = Reg[rt])   -  ALUSrcA=0, ALUSrcB=11
-   A    e B sempre sovrascritti         -  ALUOp=00
        (nessun segnale di controllo)



                        0


0
         X                                                   0
                  0                                   X          010


                                                                                  X


                                   X
                  0                       0
                                                             3
                                                                       CPU (2)    52
    Segnali di Controllo: (EX) Load – Calc. Indirizzo

    ALUOut = A + sign-extend(IR[15-0]);
    - ALUSrcA=1, ALUSrcB=10
    - ALUOp=00
                      0



0
      X                                        1
             0                            X        010


                                                                   X


                            X
             0                     0
                                               2


                                                         CPU (2)   53
    Segnali di Controllo: (MEM) Load – Lett. in Memoria

    MDR = Memory[ALUOut];
    - IorD=1
    - MemRead=1

                        0


0
      1                                      X
             0                          X        XXX


                                                                 X


                            X
             1                  0
                                             X


                                                       CPU (2)   54
        Segnali di Controllo: (WB) Load – Scr. Registro di
        Destinazione

        Reg[IR[20-16]] = MDR;
        - RegDest=0
        - RegWrite=1
        - MemtoReg=0
                                    IRWrite   0

                                       I      Instruction I                                                                28                   32
  0                                    R                                                5
                                                                                                     jmpaddr
                                                                                                     I[25:0]       <<2                CONCAT
PCWr*                                                          rs         rt                    rd
          X                                                                        0        1        RegDst
                                                                                                                      X                                 2
         IorD           0                     32                    5          5   MUX
                                                                                        5              0           ALUSrcA      XXX                     1U
                                                                                                                                                            M

                                                                                                                                                            X
 PC                                                                                                                       Operation                     0
                   MemWrite                                     RN1        RN2     WN                                            3
         0M                                                                                                          0M
          U     ADDR                   M                                                                              U                              PCSource
         1X                                                         Registers                                                          Zero
                                       D                                                              A              1X
                     Memory
                               RD      R
                                                    0M
                                                     U
                                                    1X
                                                              WD
                                                                                        RD1
                                                                                                                                ALU                     X
                                                                                                                                               ALU
                                                                                                                                               OUT
                WD                                                                      RD2           B              0
                     MemRead                   MemtoReg                                                        4     1M
                                                                                                                       U
                                                                                                                     2X
                                                     0          RegWrite                                             3
                        0
                                                   immediate         16
                                                                        1      E
                                                                               X   32
                                                                                                                   ALUSrcB
                                                                               T
                                                                               N
                                                                                                 <<2                 X
                                                                               D



                                                                                                                                          CPU (2)           55
  Struttura dell’Automa a Stati Finiti

    q I primi due passi sono indipendenti dall’istruzione
    q I restanti passi sono differenziati a seconda dell’operazione
    q Ciascuna porzione della macchina a stati finiti può essere
          composta da più stati
                                       Inizio


                                     Fetch

                             Decode, Fetch Reg, beq



  Calcolo Indirizzo      R-type EXE             Beq EXE (PC update)   Jump EXE (PC update)


M-Read       M-Write       R-Write


R-Write




                                                                                CPU (2)      56
   L’Automa a stati finiti completo

qTutti  i segnali di
scrittura che non
appaiono sono pari a 0
qTutti  i segnali di
controllo dei mux che non
appaiono sono pari ad X




                                      CPU (2)   57
 Unita’ di Controllo: Funzione di Uscita

  Outputs                 Input Values (Current State[3-0])
              0000 0001   0010   0011   0100   0101   0110   0111   1000   1001
PCWrite        1    0      0      0      0      0      0      0      0        1
PCWriteCond    X    0      0      0      0      0      0      0      1        X
IorD           0    X      X      1      X      1      X      X      X        X
MemRead        1    0      0      1      0      0      0      0      0        0
MemWrite       0    0      0      0      0      1      0      0      0        0
IRWrite        1    0      0      0      0      0      0      0      0        0
MemtoReg       X    X      X      X      1      X      X      0      X        X
PCSource      00   XX     XX     XX     XX     XX     XX     XX     01        10
ALUOp         00    00    00     XX     XX     XX     10     XX     01        XX
ALUSrcB       01    11    10     XX     XX     XX     00     XX     00        XX
ALUSrcA        0    0      1      X      X      X      1      X      1        X
RegWrite       0    0      0      0      1      0      0      1      0        0
RegDst         X    X      X      X      0      X      X      1      X
                                                                    CPU (2)   X    58
Unita’ di Controllo: Funzione Prossimo Stato

Current           Inst[31-26]    (Op[5-0])
 State 000000 000010 000100     100011   101011    Any
 [3-0]   (R-   (jmp)    (beq)    (lw)     (sw)    other
        type)
 0000    0001   0001   0001     0001     0001      0001
  0001   0110   1001   1000     0010     0010     illegal
  0010   XXXX   XXXX   XXXX     0011     0101     illegal
  0011   XXXX   XXXX   XXXX     0100     XXXX     illegal
  0100   XXXX   XXXX   XXXX     0000     XXXX     illegal
  0101   XXXX   XXXX   XXXX     XXXX     0000     illegal
  0110   0111   XXXX   XXXX     XXXX     XXXX     illegal
  0111   0000   XXXX   XXXX     XXXX     XXXX     illegal
  1000   XXXX   XXXX   0000     XXXX     XXXX     illegal
  1001   XXXX   0000   XXXX     XXXX     XXXX     illegal
                                                  CPU (2)   59
Diagramma a blocchi della CPU (Datapath e Control) e
Memoria




                                                          Registro di Stato

                                            CONTROLLO
                 Operation=f(ALUOp,funct)   PCWrite+(Zero*PCWriteCond)   IorD IRWrite
                   PCSoruce    RegDstALUSrcA/B MemtoReg      MemWr MemRd   RegWr



               Opcode                                                                 Zero
                   Funct      A
                                     ALU      ALUOut
                 IR            B            DATAPATH                       Register
                                                                             file
      Addr

Memoria          PC           MDR




                                                                              CPU (2)        60
Implementazione dell’unità di controllo
dall’Automa a Stati Finiti
q La macchina a stati
  finiti può essere
  implementata usando
   m   Un registro
       temporaneo che
       memorizza lo stato
       corrente
   m   Un blocco di logica
       combinatoria che
       determina i segnali e
       lo stato futuro
        ü Realizzabile tramite
          PLA o ROM




                                          CPU (2)   61
Implementazione Controllo Tramite PLA

q Blocco combinatorio della rete
  sequenziale puo’ essere
  implementato con logica
  digitale a 2 livelli
   m   PLA
q Numero minimo di porte
  logiche
q # celle=
   m   #ingresso*#termini
       prodotto+#uscite*termini
       prodotto
   m   10*17+20*17=510 celle PLA
q Non modificabile
   m   Poco flessibile
q Soluzione efficiente per
  piccoli circuiti

                                        CPU (2)   62
Reti Combinatorie e ROM

 q ROM (Read Only Memory)
     m   I valori delle varie celle di memoria sono fissati
 q Le ROM possono essere usate per implementare Tabelle
    di Verita’=Reti Combinatorie
     m   Se l’indirizzo e’ di m-bit, possiamo indirizzzare 2m celle della
         ROM
     m   Le uscite della ROM corrispondono ai contenuti della varie
         celle indirizzate dai m bit dell’indirizzo
 q Tabella di Verita’ con m variabili in ingresso e n di output
     m   Sufficiente una ROM di 2mxn bit
            Input    Output
               =           =
           indirizzo Contenuto celle

              0   0   0   0   0   1   1
                                               m              n
              0   0   1   1   1   0   0
              0   1   0   1   1   0   0               ROM
     m = 3    0   1   1   1   0   0   0
     n = 4    1   0   0   0   0   0   0
              1   0   1   0   0   0   1
              1   1   0   0   1   1   0
              1   1   1   0   1   1   1                              CPU (2)   63
Implementazione del Controllo tramite ROM

q Rete combinatoria dell’unita’ di controllo ha:
   m   10 linee in ingresso                        Stato   __Uscita (Linee di Controllo)
        ü 6 bit opcode                             0000     1001010000001000
        ü 4 bit stato                              0001     0000000000011000
        ü Indirizzo=<Opcode,Stato>                 0010     0000000000101000
   m   20 linee di output                          0011     0011000000000000
        ü 16 bit di segnali di controllo           0100     0000001000000010
        ü 4 bit di stato                           0101     0010100000000000
                                                   0110     0000000001000100
q Realizzazione ROM richiede                       0111     0000000000000011
  210x20=20Kbits                                   1000     0100000010100100
                                                   1001     1000000100000000
q Soluzione inefficiente
   m   16 bit di uscita (segnali di controllo) dipendono solo dai
       4 bit dello stato
        ü Automa di Moore
   Þ indirizzi <XXX,Stato>, al variare di XXX i 16 bit relativi
     alle linee di controllo sono identici
   m Per molti stati le transizioni non dipendono dall’opcode
   Þ Per molti indirizzi <XXX,Stato>, al variare di XXX i
     contenuti delle celle spesso sono identici                        CPU (2)         64
Implementazione del Controllo tramite ROM

q   Implementare separatamente le                  Stato   __Uscita (Linee di Controllo)
    tabelle di verita’ delle funzioni F            0000     1001010000001000
    (uscita) e G (prossimo stato)                  0001     0000000000011000
                                                   0010     0000000000101000
    m   F: 4 bit di stato determinano le 16        0011     0011000000000000
        uscite (di controllo)                      0100     0000001000000010
         ü ROM di 24x16b=0.25Kb                    0101     0010100000000000
    m   G: 10 bit (4 stato+6 opcode)               0110     0000000001000100
                                                   0111     0000000000000011
        determinano il prossimo stato              1000     0100000010100100
         ü ROM di 210x4b=4Kb                       1001     1000000100000000
    m   Totale 4.25Kbit >> numero celle PLA
         ü PLA ottimizza la rete grazie ai molti
           DON’T CARE

    m   Data la struttura degli automi di            Si puo’ semplificare
        Moore, la dimensione della ROM e’             l’implementazione
        dominata dalla funzione G                        sfruttando la
         ü 4Kb vs 0.25Kb                                struttura di G?
                                                                       CPU (2)         65
Altro Stile di Implementazione

q    Implementare F come prima
q    Per G osservare che:
q    Spesso la funzione stato
     successivo e’:
     Stato(n+1)=Stato(n)+1
     m   0->1     IF->ID
     m   3->4     lw(MEM)->lw(WB)
     m   6->7     f. R(EX)->f. R(MEM)
2.   o semplicemente a fine
     istruzione:
     Stato(n+1)=0
3.   Tuttavia alcune volte
     Stato(n+1)=G(Stato(n),Opcode)
     m   Stato 1 e 2

                                        CPU (2)   66
Implementazione con un Sequenzializzatore

q   Inserire:
    m   Contatore
        ü Incremento Stato
    m   Logica selezione prossimo
        stato
        ü Per i “salti”
q   Aggiungere un segnale
    di controllo AddrCtrl
    che controlla come si
    determina il prossimo
    stato:
    m   Stato(n)+1
    m   0
    m   In base a
        Stato(n)+Opcode                CPU (2)   67
Sequenzializzatore in
dettaglio


                        Rom




                              CPU (2)   68
Sequenzializzatore: Contenuto della Memoria di Controllo
                 Stato            Uscita
                          Linee di Controllo   AddrCtl

                 0000    1001010000001000         11
                 0001    0000000000011000         01
                 0010    0000000000101000         10
                 0011    0011000000000000         11
                 0100    0000001000000010         00        Funzione G
                 0101    0010100000000000         00
  Funzione F     0110    0000000001000100         11
                 0111    0000000000000011         00
                 1000    0100000010100100         00
                 1001    1000000100000000         00




                                                         CPU (2)    69
Microprogrammazione

q   Unita’ di Controllo e’ la parte piu’ complessa del
    Processore
    m   DataPath ha struttura regolare
    m   Controllo di un set completo ISA ha centinaia/migliaia di stati
q Rappresentazione Grafica dell’Unita’ di Controllo
  estramamente complessa
q Necessita’ Strumento Progettuale piu’ Efficace:
  Microprogrammazione
q Obiettivo: Impiegare una Rappresentazione Simbolica
  dell’Unita’ di Controllo – Microprogramma
    m   Richiama il formato di un programma
    m   La logica di controllo si ottiene sintetizzando il
        microprogramma con prodotti CAD

                                                             CPU (2)      70
    Microprogrammazione

q Idea: Considerare i segnali di controllo
  che devono essere affermati ad un           Stato               Uscita
  certo passo come una (micro)istruzione                  Linee di Controllo   AddrCtl


  da far eseguire dal DataPath                0000
                                              0001
                                                        1001010000001000
                                                        0000000000011000
                                                                                  11
                                                                                  01
q “Eseguire” una microistruzione              0010      0000000000101000          10
                                              0011      0011000000000000          11
  significa affermare i segnali di            0100      0000001000000010          00
  controllo specificati dalla                 0101
                                              0110
                                                        0010100000000000
                                                        0000000001000100
                                                                                  00
                                                                                  11
  microistruzione                             0111      0000000000000011          00
                                              1000      0100000010100100          00
q Microistruzione specifica:                  1001      1000000100000000          00
    m   I segnali di controllo da affermare
    m   La prossima microistruzione
q Microistruzione corrisponde ad uno                  microistruzione
  Stato dell’Automa di Controllo
q Microprogramma: Sequenza di
  Microistruzioni in forma simbolica
                                                                 CPU (2)            71
Microprogrammazione: Formato Microistruzioni

q Rappresentazione simbolica delle microistruzioni
   m   Etichetta, Campo1, Campo2, Campo3,…, Sequenza
        ü Etichetta specifica locazione (in memoria) della microistruzione
        ü Sequenza specifica come scegliere la prossima microistruzione
        ü Segnali di controllo sono raggruppati in Campi (field)
           – Segnali di uno stesso campo hanno funzioni tra loro collegate


q Progettazione Formato Microistruzioni
   m   Individuare Segnali di Controllo
   q   Raggruppare i segnali in Campi
        ü Segnali che svolgono funzioni fra loro collegate
   q   Ordinare i Campi
   q   Creare una Tabella del Formato Microistruzioni che mostri
        ü Nomi dei campi
        ü Valori assumibili da ciascun campo e relativa funzione svolta
        ü Relativi impostazioni dei segnali di controllo
                                                                          CPU (2)   72
   Campi Microistruzioni (Passi 1-3)

Campo        Segnali di    Funzione
             Controllo
ALU          ALUOp         Operazione compiuta da ALU; risultato in ALUOut
control
SRC1         ALUSrcA       Provenienza primo operando ALU

SRC2         ALUSrcB       Provenienza secondo operando ALU

Register     RegWrite,     Lettura o scrittura dei registri nel banco e
control      RegDest,      provenienza dei valori in caso di scrittura
             MemtoReg
Memory       MemRead,Mem   Lettura o scrittura della memoria e provenienza dei
             Write, IorD   dati; in caso di lettura specifica il registro di
                           destinazione
PCWrite      PCWrite,      Modalità di aggiornamento di PC
control      PCSource,
             PRWriteCond
Sequencing   AddrCtl       Modalità di scelta dell’istruzione successiva (2)
                                                                     CPU         73
Campi Istruzione (Passo 4) -1




                                CPU (2)   74
Campi Istruzione (Passo 4) -2




                                CPU (2)   75
Microprogramma di Controllo Completo




          Dispatch ROM 1
   Op      Opcode name      Value
                                               Dispatch ROM 2
 000000       R-format     Rformat1
                                        Op      Opcode name      Value
 000010         jmp        JUMP1      100011         lw          LW2
 000100         beq        BEQ1       101011         sw          SW2
 100011          lw        Mem1
 101011          sw        Mem1


                                                                CPU (2)   76
Implementazione

q Il Microprogramma e’ una
  rappresentazione
  alternativa di un automa a
  stati finiti
   m   Implementabile secondo lo
       schema con
       sequenzializzatore visto
       prima dove
q ROM<-> Memoria
  Microcodice
q Stato<-> Contatore di
  Microprogramma




                                   CPU (2)   77
Unita’ di Controllo Microprogrammata

q   Il Processore “interpreta” le istruzioni macchina in
    memoria
    m   Legge istruzioni in memoria (scritte in L2)
    m   Ne simula il comportamento passo passo “eseguendo” una
        sequenza di microistruzioni (in L1)
         ü L’Unita’ di Controllo genera i segnali di controllo e determina
           il sequenziamento
         ü Il Datapath realizza le operazioni ed il trasferimento fra
           registri secondo i segnali di controllo
q   Il Microprogramma dell’Unita’ di Controllo (scritto
    in L1) e’ l’interprete del linguaggio macchina (L2)




                                                                    CPU (2)   78
Riassunto Metodi Alternativi per Specificare ed
Implementare l’Unita’ di Controllo


      Rappresentazione     Automa a
                          Stati Finiti       Microprogramma
          Iniziale

                         Funzione pross.
       Controllo del                           Contatore+
                         Stato in forma
      Sequenziamento                        Tabelle di dispatch
                            esplicita

      Rappresentazione
           Logica      Equazione booleane    Tabelle di Verita’



      Implementazione
                             PLA                 ROM


                         Controllo              Controllo
                          Cablato           Microprogrammato

                                                                  CPU (2)   79
Microprogrammazione: Pro e Contro

 q Vantaggi nella Progettazione
    m   Semplicita’ nella progettazione e scrittura
    m   Design congiunto dell’architettura e del microprogramma
 q Vantaggi nell’Implementazione
    m   Facile da modificare (implementazione su off-chip ROM – anni
        ’60-’70)
    m   Permette l’emulazione di altre ISA
 q Svantaggi dell’Implementazione
    m   Controllo e’ oggi sullo stesso chip del processore
    m   ROM e’ oggi (relativamente) lenta rispetto alle altre memorie
    m   Non c’e’ piu’ necessita’ di cambiare il microprogramma di
        controllo
         ü Computer general purpose

                                                                    CPU (2)   80
Eccezioni

q La gestione delle eccezioni e degli interrupt è una delle parti più
  difficili del controllo
q Eccezione: un evento non atteso, interno al processore, che
  interrompe l’esecuzione del programma
   m   Esempi: overflow aritmetico, istruzione non definita
q Interrupt: un evento non atteso,     esterno al processore, che
  interrompe l’esecuzione del programma
   m   Esempi: richiesta di un dispositivo di I/O, malfunzionamento
       hardware
q Nella terminologia MIPS: interrupt ¹ eccezione
q Nella terminologia IA-32: non c’è distinzione tra interrupt ed
  eccezione




                                                                CPU (2)   81
Gestione delle eccezioni

q Quando avviene un’eccezione occorre
   m   Salvare nel registro EPC (Exception Program Counter) l’indirizzo
       dell’istruzione che ha causato l’eccezione
   m   Trasferire il controllo al sistema operativo a qualche indirizzo
       specifico per la gestione dell’eccezione
   m   Il sistema operativo, dopo aver eseguito le azioni necessarie, può
       terminare il programma o continuarne l’esecuzione usando EPC per
       determinare da dove riprendere l’esecuzione
   m   Oltre a EPC, il sistema operativo deve conoscere la ragione
       dell’eccezione; esistono due meccanismi
        ü Registro di stato (Cause register nel MIPS): contiene un campo che
          indica la causa dell’eccezione
        ü Interrupt vettorializzato: l’indirizzo a cui trasferire il controllo è
          determinato dalla causa dell’eccezione
q Consideriamo due tipi di eccezioni nell’implementazione a ciclo
  multiplo
   m   Esecuzione di un’istruzione non definita
   m   Overflow aritmetico
                                                                         CPU (2)   82
Gestione delle eccezioni (2)

q Per gestire le eccezioni nel MIPS occorre aggiungere
    nell’unità di elaborazione
     m   Registro EPC a 32 bit
     m   Registro Cause a 32 bit
          ü Istruzione non definita: Cause = 0
          ü Overflow aritmetico: Cause = 1
q Aggiungiamo due segnali di controllo per abilitare la scrittura
    dei registri EPC e Cause: EPCWrite e CauseWrite
q   Aggiungiamo un altro segnale di controllo per settare il bit
    meno significativo del registro Cause: IntCause
q   Occorre scrivere in PC l’indirizzo di eccezione (punto di
    ingresso del sistema operativo per gestire le eccezioni)
     m   Nel MIPS, l’indirizzo di eccezione è (8000 0180)16
     m   Modifichiamo il multiplexer in ingresso a PC da tre a quattro vie
          ü PCSource = 11 per abilitare l’indirizzo di eccezione



                                                                   CPU (2)   83
L’unità a ciclo multiplo con la gestione delle
eccezioni
                                          Indirizzo di
                                           eccezione


                                                EPC: usiamo
                                                 ALU per
                                               sottrarre 4 a
                                                    PC




                                               CPU (2)     84
La macchina a stati finiti con la gestione delle
eccezioni




                                           CPU (2)   85

								
To top