Progetto CPU (multiciclo)

Microsoft PowerPoint - progetto-multiProgetto CPU (multiciclo)
Problemi con pro getto a sin golo ciclo
• Problemi del singolo ciclo – Ciclo di clock lungo – Istruzioni potenzialmente più veloci sono rallentate
• impiegano lo stesso tempo dell’istruzione più lenta
– Unità funzionali e collegamenti del Datapath sono replicati • dobbiamo poter computare in parallelo tutti i passi computazionali necessari
per l’esecuzione di qualsiasi istruzione dell’ISA
• Possibile soluzione: – datapath “multiciclo” – usiamo un ciclo più corto – istruzioni differenti impiegano un numero di cicli diversi – unità funzionali possono essere usate più volte per eseguire la stessa
istruzione ⇒ meno replicazione • basta usarle in cicli differenti
– registri aggiuntivi • usati per memorizzare i risultati parziali nell’esecuzione delle istruzioni
Arch. Elab. - S. Orlando 3
Esempio di riduzione del ciclo di clock
• Effettua un taglio su grafo delle dipendenze corrispondente al circuito combinatorio, e inserisci un registro nel mezzo
• Fai lo stesso lavoro di prima in 2 cicli più veloci, invece che in singolo ciclo più lento
elemento di memoria
Logica Combinatoria Aciclica
elemento di memoria
elemento di memoria
Datapath multiciclo
• Registri interni addizionali usati per memorizzare valori intermedi, da usare nel ciclo di clock successivo per continuare l’esecuzione della stessa istruzione – IR, MDR, A, B, ALUOut
• Riuso di unità funzionali – ALU usata anche per calcolare gli indirizzo dei salti e incrementare il PC – Memoria usata sia per leggere le istruzioni e per leggere/scrivere i dati
Registri addizionali
Addr dati
Suddivisione in passi del Datapth
• Nell’inserire i registri addizionali, abbiamo pensato di spezzare l’esecuzione delle istruzioni in passi – ogni passo da eseguire in un ciclo di clock (ciclo più corto rispetto alla
CPU a ciclo singolo ) – importante il bilanciamento della quantità di lavoro eseguito nei vari passi,
perché dobbiamo fissare un ciclo di clock unico • determinato sulla base del passo più lungo, ovvero più costoso dal punto di
vista computazionale
• Al termine di ogni ciclo i valori intermedi, da impiegare nei cicli successivi, sono memorizzati nei registri interni addizionali
• Register File e PC sono invece impiegati per memorizzare valori da usare per l’esecuzione di una nuova istruzione
Sequenza dei cinque passi di esecuzione
• Fetch dell’istruzione
• Decodifica dell’istruzione e Lettura dei re gs. (e Addr. Branch)
• R-type exe o Calcolo Indirizzo Memoria o Completa Branch o Completa Jump
– dipende dal tipo di istruzione
• Accesso alla memoria o Completa R-t ype (scrittura re gs)
– dipende dal tipo di istruzione
• Write back (scrittura re g: solo LW)
OGNI PASSO ESEGUITO IN UN CICLO DI CLOCK LE ISTRUZIONI IMPIEGANO DA 3 A 5 CICLI
Inseriamo i multiplexer
Altri 2 ingressi, da sommare con PC: PC = PC + 4
PC = PC + (sign_ext(imm16) << 2)
Controllo
• I segnali di controllo alle varie unità funzionali e ai multiplexer non dipendono solo dal tipo istruzione da eseguire – es.: rispetto ad una sub , l’ALU dovrà essere usata, in cicli di clock
differenti, per • PC = PC + 4; (somma) • R[rd] <– R[rs] – R[rt]; (sottrazione)
• Quindi i segnali di controllo dovranno essere diversi durante i vari passi (cicli di clock) necessari per l’esecuzione dell’istruzione
• Il controllo sarà infatti implementato come circuito sequenziale – l’output del circuito (segnali di controllo) dipenderanno dallo stato interno
al circuito al tempo t i
– stato del circuito sequenziale = passo di esecuzione di una istruzione
Datapath e Controllo multi-ciclo
Segnali di controllo di 1 bit
Segnale Effetto se uguale a 0 Effetto se uguale a 1
RegDest Reg. dest. proviene da rt Reg. dest. proviene da rd
Reg Write Nessuno Scrittura in Reg. File
AluSrcA 1^ ingresso dell'ALU è PC 1^ ingresso dell'ALU è reg. A
MemRead Nessuno Lettura da Mem. in reg. MDR
MemWrite Nessuno Scrittura in Mem.
MemtoReg Reg. scritto proviene da ALUOut Reg. scritto proviene da MDR
IorD Addr.della Mem. proviene da PC Addr.della Mem. proviene da ALUOut
IRWrite Nessuno Scrittura in IR (proviene da Mem. ) PCWrite Nessuno Scrittura in PC
PCWriteCond Nessuno PC viene scritto se è anche vero che Zero = 1 (beq)
Per istruzioni di beq : PCWriteCond=1 e PCWrite=0 Il segnale di scrittura di PC è infatti calcolato come:
PCWrite + (PCWriteCond ⋅ Zero)
Segnali di controllo di 2 bit
S e g na le V alore E ffetto
00 A LU c alc ola s om m a ( lw , sw , PC + … )
ALUO p 01 A LU c alc ola s ottraz ione ( beq )
10 A LU c alc ola l'operaz ione determ inata da funct
00 2^ ingres s o dell'A LU è reg . B
ALUS rcB 01 2^ ingres s o dell'A LU è costante 4
10 2^ ingres s o dell'A LU è si g n_ext(im m 16) ( lw /sw )
11 2^ ingres s o dell'A LU è si g n_ext(im m 16) << 2 ( beq )
00 In P C viene s c rit to l'us c ita dell'A LU ( PC+4 )
P CS ource 01 In P C viene s c rit to A LUOut ( beq )
10 In P C viene s c rit to PC[31-28] || si g n_ext(im m 26) << 2 ( jum p )
Passo 1: Fetch dell’istruzione
• Usa PC per prelevare l’istruzione dalla memoria e porla nell’Instruction Register (IR)
• Incrementa PC di 4, e rimetti il risultato nel PC • Passo identico per tutte le istruzioni
• Usando la notazione RTL: IR = M[PC]; PC = PC + 4;
• Durante questo passo (stesso ciclo di clock) usiamo: – Memoria – ALU
• Vediamo in dettaglio i valori dei segnali di controllo
Passo 1: Fetch dell’istruzione
• IR = M[PC]; – MemRead ← 1 – IRWrite ← 1 – IorD ← 0
• PC = PC + 4; – ALUSrcA ← 0 ALUSrcB ← 01 – ALUOp ← 00 (somma) – PCWrite ← 1 PCSource ← 00
Passo 2: Decodifica istruzione & Lettura re gistri
• Leggi i registri rs e rt , e calcola l’indirizzo del salto del beq • IR (op) viene inviato al controllo per la decodifica e la determinazione dei
passi successivi ⇒ Decodifica dell’istruzione • RTL:
A = Reg[ IR[25-21] ]; B = Reg[ IR[20-16] ]; ALUOut = PC + (sign-ext( IR[15-0] ) << 2);
• Passo identico per tutte le istruzioni , ma potremmo anticipare del lavoro non necessario. – per certe istruzioni, i due campi ( rs , rt ) potrebbero essere non significativi – calcoliamo l’indirizzo a cui saltare, come se l’istruzione fosse beq, ma il
campo imm16 potrebbe essere non significativo • Quali i vantaggi di questo lavoro anticipato?
• Durante questo passo (stesso ciclo di clock) usiamo: – Register File – ALU
• Vediamo i valori dei segnali di controllo
Passo 2: Decodifica istruzione & Lettura re gistri
• A = Reg[ IR[25-21] ]; B = Reg[ IR[20-16] ]; – A e B sovrascritti per
ogni tipo di istruzioni
• ALUOut = PC + (sign-ext( IR[15-0] ) << 2) – ALUSrcA ← 0 ALUSrcB ← 11 – ALUOp ← 00 (somma)
Passo 3: (dipende dall’istruzione)
• Usiamo l’ALU in dipendenza del tipo di istruzione
• Il controllo , avendo già decodificato l’istruzione letta al passo precedente, può già decidere i se gnali da inviare al Datapath in relazione al tipo di istruzione
• R-type exe: ALUOut = A op B;
• Calcolo Indirizzo Memoria (load/store) ALUOut = A + sign-ext( IR[15-0] );
• Completa Branch if (A == B) then PC = ALUOut;
• Completa Jump PC = PC[31-28] II (IR[25-0] << 2);
R-type exe: ALUOut = A op B;
ALUSrcA ← 1 ALUSrcB ← 00 ALUOp ← 10 (campo FUNCT) ALUOut riscritto ad ogni ciclo
LOAD / STORE: ALUOut = A + sign-ext( IR[15-0] );
ALUSrcA ← 1 ALUSrcB ← 10 ALUOp ← 00 (somma)
Completa Branch if (A == B) then PC = ALUOut;
ALUSrcA ← 1 ALUSrcB ← 00 ALUOp ← 01 (sottr.) (sottrazione registri A e B, check salto sulla base di Zero)
Per abilitare la scrittura nel PC del valore precedentemente calcolato (ALUOut), necessari altri segnali di controllo non illustrati:
PCWrite ← 0 PCWriteCond ← 1 PCSource ← 01
Completa Jump PC = PC[31-28] II (IR[25-0] << 2);
Per abilitare la scrittura nel PC, i segnali di controllo, non illustrati in figura, sono:
PCWrite ← 1 PCSource ← 10
• LOAD e STORE accedono alla memoria
MDR = Memory[ALUOut]; or
• Vediamo i segnali di controllo
Load: MDR = Memory[ALUOut];
IorD ← 1 MemRead ← 1
Store: Memory[ALUOut] = B;
IorD ← 1 MemWrite ← 1
RegDest ← 1 RegWrite ← 1 MemtoReg ← 0
Passo 5: Write-back (LOAD)
RegDest ← 0 RegWrite ← 1 MemtoReg ←1
NOTA: Le altre istruzioni non giun gono al passo 5
Riassumendo
instructions Action for memor y -reference
instructions Action for branches
Action for jum p s
Ins truction fe tch IR = M em ory[P C ] P C = P C + 4
Instruction decode / A = Reg [IR[25-21 ]] reg iste r fe tch/ B = Reg [IR[20-16 ]]
b ranch addr. com p. A LUOut = P C + (s ign-extend (IR[15 -0 ]) << 2)
E xecution, address A LUOut = A op B A LUOut = A + s ign-extend if (A ==B ) then P C = P C [31 -28 ] II com puta tion, b ranch/ (IR[15-0 ]) P C = A LUOut (IR[25-0 ]<<2 ) jum p com ple tion
M em ory access or R-type Reg [IR [15-11 ]] = Load: M D R = M em ory[A LUOut] com ple tion A LUOut or
S to re : M em ory [A LUOut] = B
M em ory read com ple tion Load: Reg[IR[20-16 ]] = M D R
Alcune semplici domande
• Quanti cicli sono necessari per eseguire questo codice?
lw $t2, 0($t3) lw $t3, 4($t3) beq $t2, $t3, Label #assume not add $t5, $t2, $t3 sw $t5, 8($t3)
Label: ...
• Cosa accade durante l’8 o ciclo di esecuzione?
• In quale ciclo avviene effettivamente la somma tra $t2 e $t3 ?
5 5 3 4 4 21
• Calcolo dell’indirizzo della 2 a lw
• Nel 16-esimo ciclo
Definizione controllo
• Possiamo implementare il controllo della CPU come un circuito sequenziale di Moore , modellabile come un automa a stati finiti
• Automa – ogni nodo corrisponde a un stato differente del circuito, in corrispondenza
di un certo ciclo di clock – gli output del controllo (segnali di controllo) dipendono dallo stato
corrente – da 3 a 5 stati devono essere attraversati (ovvero, da 3 a 5 cicli di clock)
Fetch
Inizio
Automa completo
segnali che il Controllo deve inviare al Datapath
• Etichette sugli archi – dipendono dagli input
del Controllo – ovvero, dal valore di del
campo Op dell’istruzione letta
• 10 stati – ogni stato associato
con un’etichetta mnemonica, e anche con un identificatore numerico
– quanti bit sono necessari per il registro di stato ?
Componenti CPU (Datapath+Control) e Memoria
• Nota: tra i segnali provenienti dal Datapath, solo Op è usato per selezionare il prossimo stato
RegWrite
PCSource
MemRead
MemWrite
IorD
IRWrite
Dimensionamento ciclo di clock
• Ipotizziamo gli stessi costi precedenti (in ns) per le varie componenti – Mem. Istr/Dati: 2 ns Reg. File: 1 ns ALU: 2 ns – non li usiamo mai in sequenza ⇒ possiamo ipotizzare un ciclo di 2 ns
• Più in dettaglio, per determinare il ciclo ci clock, consideriamo il diagramma di sotto, che si riferisce al 3 o passo della BEQ
– poiché il controllo è di Moore, l’output (controlli) dipende solo dallo stato (veloce) • decodifica del controllo dell’ALU più complessa (2 livelli):
Operation = f(AluOp, Funct) – l’input del controllo, importante per la transizione di stato, è Op
• Op è un campo del registro IR del Datapath (non necessario calcolarlo)
– il segnale di Zero è importante nel caso di BEQ ...
Controllo
al
Esempio di dia gramma temporale per il 3 o passo di esecuzione di un’istruzione
Costo istruzioni
• Per le varie istruzioni, possiamo impiegare un numero differente di cicli – introduciamo il concetto di CPI (no. di cicli per istruzione)
• Quant’è il CPI delle varie istruzioni rispetto all’architettura multi-ciclo ? – R-type, sw: 4 cicli (tempo: 8 ns) – lw: 5 cicli (tempo: 10 ns) – beq, jump: 3 cicli (tempo: 6ns)
• Nota che l’istruzione di lw impiega ben 10 ns invece degli 8 ns dell’architettura a singolo ciclo – purtroppo ciò è dovuto alla necessità di fissare il ciclo di clock abbastanza
lungo da permettere l’esecuzione di uno qualsiasi dei passi previsti per le varie istruzioni
– il 5o passo della lw, anche se usa solo il Register File (latenza 1 ns), viene comunque eseguito in un ciclo di clock da 2 ns
• Abbiamo ottenuto un risparmio solo per le istruzioni di beq e jump – se avessimo considerato istruzioni molto più lunghe (come quelle FP), non
avremmo osservato questa apparente decadimento di prestazione nel passare all’architettura multi-ciclo
– in quel caso, la scelta del ciclo singolo ci avrebbe costretto ad allungare a dismisura il ciclo di clock per eseguire l’istruzione FP
Circuito sequenziale che implementa il controllo
• Nota – blocco combinatorio per calcolare NEXT_STATE & OUTPUTS – state register per memorizzare stato corrente
• Controllo a due livelli – ALUOp calcolato sulla base
di Op, combinato con Funct (IR[5:0]) per generare il segnale a 3 bit ( Operation ) da inviare all’ALU
• PCWrite e PCWriteCond usati assieme a Zero proveniente dal Datapath, per generare il segnale a 1 bit che permette la scrittura di PC
Implem. cablata (a lo gica sparsa) del Controllo
• Blocco combinatorio all’interno del circuito sequenziale che implementa il controllo della CPU può essere implementato con logica digitale a 2 livelli – PLA
• Numero minimo di porte logiche, e quindi di transistor
• Implementazione ottima, ma non modificabile – poca flessibilità
• Efficiente finché il numero di stati del circuito è abbastanza piccolo
Circuiti combinatori e ROM
• ROM = "Read Only Memory" – i valori delle varie celle di memoria sono fissate in anticipo
• ROM usata per memorizzare una tabella di verità = il circuito combinatorio necessario per implementare il controllo della CPU – se l’indirizzo è di m bit, possiamo indirizzare 2m celle della ROM – gli output della ROM corrispondono al contenuti delle varie celle
indirizzare dai m bit dell’indirizzo
• Tabella di verità con m variabili in input e n in output – sufficiente una ROM di 2m x n bit
m n
0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 1 1 1 0 0 0 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
ROM
Implementazione del controllo tramite ROM
• Quanti sono gli input del blocco combinatorio interno al controllo ? – 6 bit per Opcode , 4 bit per lo Stato – < Opcode , Stato >= 10 linee di indirizzo – 210 = 1024 indirizzi differenti
• Quanti sono gli output ? – 16 bit per i vari segnali di controllo del Datapath – 4 bit per lo Stato – 20 bit in output
• ROM è 210 × 20 = 20K bits (dimensione non usuale)
• Soluzione che spreca molte risorse, poiché molte celle della ROM (e i corrispondenti output della ROM) sono identiche o quasi identiche
• Poiché il circuito sequenziale è di Moore , i 16 bit dell’Output (relativi ai segnali di controllo) dipendono solo dallo Stato – per gli indirizzi < X, Stato > le celle della ROM sono quasi identiche
• Da certi Stati , la transizione (i 4 bit di Output del Next State) avviene indipendentemente dall’ Opcode – per alcuni indirizzi < X, Stato > le celle sono identiche
ROM vs. PLA
• Spezziamo la tabella di verità in due parti (OUTPUTS e NEXT_STATE)
– i 4 bit di Stato determinano i 16 Outputs ⇒ ROM di 24x16 b = 28 b = 0.25 Kb
– i 10 bits ( Opcode , Stato ) determinano i 4 bit del prossimo Stato ⇒ ROM di 210 x 4 b = 4 Kb
– Totale: ROM di 4.25 Kb (invece di 20 Kb)
• La PLA risulta sempre più piccola
– molti prodotti sono condivisi
– i DON’T CARE sono tutti considerati attentamente per ridurre il numero di prodotti o il numero di fattori in ogni prodotto
• Il numero di celle PLA (porte AND e OR) sono:
– (#inputs × #product-terms) + (#outputs × #product-terms)
– nel nostro caso: (10x17)+(20x17) = 460 celle PLA
• Dimensione (in spazio e numero di transistor) delle celle PLA è simile alla dimensione delle celle ROM (celle PLA un po’ più grandi)
Un altro stile di implementazione
• Spesso NEXT_STATE corrisponde a current state + 1 – vedi, rispetto al nostro automa, le transizioni di stato 0→1, 3→4 o 6→7
AddrCtl
Outputs
IRWrite
Sequenzializzatore in detta glio
State number Address-control action Value of AddrCtl 0 Use incremented state 3 1 Use dispatch ROM 1 1 2 Use dispatch ROM 2 2 3 Use incremented state 3 4 Replace state number by 0 0 5 Replace state number by 0 0 6 Use incremented state 3 7 Replace state number by 0 0 8 Replace state number by 0 0 9 Replace state number by 0 0
Dispatch ROM 1 Dispatch ROM 2 Op Opcode name Value Op Opcode name Value
000000 R-format 0110 100011 lw 0011 000010 jmp 1001 101011 sw 0101 000100 beq 1000 100011 lw 0010 101011 sw 0010 Fetch (0)
Stato++
Micropro grammazione
• Rappresentazione tramite automi a stati finiti diventa improponibile quando dobbiamo trattare un numero elevato di stati – un foglio non basta più se si considerano tutte le istruzioni MIPS (> 100) e
il numero di cicli necessari per i le istruzioni più complesse (oltre 20 cicli) • Microprogrammazione
– idea prese in prestito dal campo della programmazione (dallo stile grafico a quello testuale: dagli automi ai microprogrammi)
– scopo di una microistruzione è quello di specificare (simbolicamente) i segnali di controllo da affermare nel Datapath ad un certo istante
– eseguire la microistruzione (Moore) avrà l’effetto di affermare alcuni segnali di controllo per l’esecuzione di una certa istruzione macchina
– ogni microistruzione dovrà specificare quale sarà la prossima microistruzione da eseguire, ovvero il prossimo stato del controllo
• la prossima microistruzione da eseguire potrà essere sempre univocamente determinata
– es. sempre la successiva secondo l’ordine lessicografico del micoprogramma, oppure una determinata altra microistruzione
• la scelta della prossima microistruzione potrà dipendere dagli input ( Op code )
Formato microistruzione
Field name Value Signals active Comment Add ALUOp = 00 Cause the ALU to add.
ALU control Subt ALUOp = 01 Cause the ALU to subtract; this implements the compare for branches.
Func code ALUOp = 10 Use the instruction's function code to determine ALU control. SRC1 PC ALUSrcA = 0 Use the PC as the first ALU input.
A ALUSrcA = 1 Register A is the first ALU input. B ALUSrcB = 00 Register B is the second ALU input.
SRC2 4 ALUSrcB = 01 Use 4 as the second ALU input. Extend ALUSrcB = 10 Use output of the sign extension unit as the second ALU input. Extshft ALUSrcB = 11 Use the output of the shift-by-two unit as the second ALU input. Read Read two registers using the rs and rt fields of the IR as the register
numbers and putting the data into registers A and B. Write ALU RegWrite, Write a register using the rd field of the IR as the register number and
Register RegDst = 1, the contents of the ALUOut as the data. control MemtoReg = 0
Write MDR RegWrite, Write a register using the rt field of the IR as the register number and RegDst = 0, the contents of the MDR as the data. MemtoReg = 1
Read PC MemRead, Read memory using the PC as address; write result into IR (and lorD = 0 the MDR).
Memory Read ALU MemRead, Read memory using the ALUOut as address; write result into MDR. lorD = 1
Write ALU MemWrite, Write memory using the ALUOut as address, contents of B as the lorD = 1 data.
ALU PCSource = 00 Write the output of the ALU into the PC. PCWrite
PC write control ALUOut-cond PCSource = 01, If the Zero output of the ALU is active, write the PC with the contents PCWriteCond of the register ALUOut.
jump address PCSource = 10, Write the PC with the jump address from the instruction. PCWrite
Seq AddrCtl = 11 Choose the next microinstruction sequentially. Sequencing Fetch AddrCtl = 00 Go to the first microinstruction to begin a new instruction.
Dispatch 1 AddrCtl = 01 Dispatch using the ROM 1. Dispatch 2 AddrCtl = 10 Dispatch using the ROM 2.
Micropro gramma relativo alla nostra CPU
• Un’implementazione diversa di questa stessa ISA avrebbe lo stesso microcodice?
• Cosa dovrebbe un microassembler ?
Labe l ALU
con tro l SRC 1 SRC 2 Reg is te r con tro l M em or y
PC Write con tro l Se q uenc in g
F e tc h A d d P C 4 R e ad P C A L U S e q A d d P C E xts hf t R e ad D is p atc h 1
Me m 1 A d d A E xte nd D is p atc h 2 L W 2 R e ad A L U S e q
W rite MD R F e tc h S W 2 W rite A L U F e tc h R fo rm at1 F unc c o d e A B S e q
W rite A L U F e tc h B E Q 1 S ub t A B A L UO ut-c o nd F e tc h J UMP 1 J um p ad d re s s F e tc h
• Microprogramma completo della nostra semplice unità di controllo – nota che per la corretta sequenzializzazione delle istruzioni, in 2 casi
rimanda ad una specifica tabella di smistamento
Implementazione del micropro gramma
• Microprogramma ≡ Rappresentazione alternativa all’automa a stati finiti – rappresenta il comportamento di
un circuito sequenziale • Per l’implementazione, possibili tutte
le alternative viste per gli automi – PLA o ROM – circuiti distinti per calcolare
sequenzializzazione (NEXT_STATE) e output del circuito sequenziale
• Storicamente, le implementazioni del controllo microprogrammato impiegano
– ROM per memorizzare microistruzioni – incrementatore esplicito e logica di
sequenzializzazione per determinare la prossima microistruzione
– Label della microistruzione ≡ Registro di controllo ≡ Contatore di microprogramma
Micropro grammazione: pro e contro
• Specifica del controllo tramite microprogramma
– Pro
• possiamo progettare l’architettura e il codice assieme
• Implementazione del controllo tramite ROM off-chip (macchine anni ‘60-’70)
– Pro
– basta sostituire la ROM
– Contro
– controllo implementato sullo stesso chip del processore (microprocessori)
– la ROM non è più (come un tempo) più veloce della RAM
• fetch di una microistruzione per inviare i controlli al Datapath sarebbe
costoso come effettuare il fetch di una istruzione macchina
– non c’e’ più necessità di riprogettare ISA, correggere errori, o apportare cambi al
microcodice
Eccezioni e interruzioni
• Il progetto del controllo del processore si complica a causa della necessità di considerare, durante l’esecuzione delle istruzioni, il verificarsi di eventi inattesi , quali: – interruzioni ed eccezioni
• Eccezione
– evento sincrono , generato all’ interno del processore, e provocato da problemi nell’esecuzione di un’istruzione
• es.: overflow, istruzione non valida
Control
Datapath
Processore
Memoria
• Interruzione – evento asincrono , che giunge
dall’ esterno del processore – segnale che giunge da un’unità di
I/O, utilizzato per comunicare alla CPU il verificarsi di certi eventi
• es.: la terminazione di un’operazione di I/O la cui esecuzione era stata richiesta in precedenza dalla CPU
Gestione di eccezioni e interruzioni
• Il controllo di ogni processore deve essere predisposto per gestire il verificarsi di eventi inattesi
• Tutti i processori, quando si verifica un evento di eccezione/interruzione , la gestiscono secondo lo schema seguente: – interruzione dell’esecuzione del programma corrente – salvataggio di parte dello stato di esecuzione corrente (almeno PC) – salto ad una routine del codice che costituisce il Sistema Operativo (SO)
• il SO è stato caricato in memoria al momento del boot del sistema • il salvataggio dello stato del programma interrotto serve al SO per poter
riprenderne eventualmente l’esecuzione, successivamente e se necessario
• Nota che le routine del SO possono essere invocate esplicitamente dai programmi (es.: invocazione routine di I/O) – nel MIPS abbiamo l’istruzione syscall
– esecuzione della syscall interpretata dal controllo come una particolare eccezione interna
Gestione di eccezioni e interruzioni
• Problema: – l’handler del SO deve essere in grado di capire quale evento si è verificato
• Soluzioni alternative: 1 il controllo della CPU, prima di saltare all’ handler predisposto dal SO (ad
un indirizzo fisso), deve salvare in un registro interno un identificatore numerico del tipo di eccezione/interruzione verificatosi. L’handler accederà al registro interno per determinare la causa dell’eccezione/interruzione
2 interruzioni vettorizzate : esistono handler diversi per eccezioni/interruzioni differenti. Il controllo della CPU deve scegliere l’handler corretto, saltando all’indirizzo corretto. A questo scopo, viene predisposto un vettore di indirizzi, uno per ogni tipo di eccezioni/interruzioni, da indirizzare tramite il codice numerico dell’eccezione/interruzione
• Nel MIPS viene adottata la 1 a soluzione, usando un registro, denominato Cause, per memorizzare il motivo dell’eccezione/interruzione
• Il PC corrente viene invece salvato nel registro EPC
Gestione eccezioni nel MIPS
• Il Controllo (ma anche il Datapath corrispondente) deve essere progettato per – individuare l’evento inatteso – interrompere l’istruzione corrente – salvare il PC corrente (nel registro interno EPC = Exception PC) – salvare la causa dell’interruzione nel registro Cause
• consideremo solo le eccezioni di overflow e istruzione non valida 0 = istruzione non valida 1=overflow
– saltare ad una routine del SO ( exception/interrupt handler ) ad un indirizzo fisso: 0xC0000000
• Il MIPS non salva nessun altro registro oltre PC – è compito dell’handler salvare altre porzioni dello stato corrente del
programma (es. tutti i registri generali), se necessario • approccio RISC
– esistono CPU dove questo salvataggio esteso dello stato viene sempre effettuato prima di saltare all’interrupt handler
• salvataggio garantito dal microcodice • approccio CISC
Rilevamento eccezione
• Overflow – segnale che arriva al controllo dall’ALU
• Istruzione non valida – controllo lo deve rilevare sulla base del campo op dell’istruzione
• Dobbiamo aggiungere 2 nuovi stati al nostro automa – a partire dallo stato Instruction Decode , dobbiamo poter transire nel nuovo
stato Invalid Instruction • solo se giunge un Op non valido
– a partire dallo stato R-type Completion , dobbiamo poter anche transire nello stato Overflow
• solo se giunge un segnale di overflow dal Datapath (ALU) • questa transizione si potrebbe anticipare allo stato Execution
– Problema : next state da calcolare in base ad un segnale calcolato dal Datapath durante lo stesso ciclo di clock
• I nuovi stati che gestiscono le eccezioni dovranno occuparsi – di salvare in EPC il PC corrente (ovvero PC - 4) – di salvare 0/1 in Cause – di memorizzare 0xC0000000 in PC
• Il prossimo stato sarà il Fetch (ma della prima istruzione dell’ handler )
Nuovo controllo
Invalid Instruction
Nuovo Datapath

Progetto CPU (multiciclo)

Documents

Transcript of Progetto CPU (multiciclo)

3° examen cpu resuelto

Trigonometria Cpu

Quick Start Guide ARM7 CPU SlimLine e Netlog III

La CPU Intel 8086: Architettura e Programmazione Assembly · La CPU Intel 8086: Architettura e Programmazione Assembly Alberto BROGGI Dipartimento di Ingegneria dell’Informazione

Set di operazioni per l’S7--200...Set di operazioni per l’S7--200 Capitolo 6 75 Tabella 6-2 Aree degli operandi delle CPU S7--200 Modo di accesso CPU 221 CPU 222 CPU 224 CPU 224XP

Sistemi Operativi: CPU Scheduler - Lezione 09

Modello di von Neumann: la memoria centralewebuser.unicas.it/tortorella/elinf/PDF/architettura.pdf · Modello di von Neumann: la CPU CPU Memoria Centrale Memorie di Massa Bus di sistema

Cpu Economia

Caratteristiche Principali PLC Siemens - …Simatic 300 CPU 3xxx Simatic 400 CPU 4xxx Simatic 1200 CPU 12xxx Simatic 1500 CPU 15xxx ... Notazione S7 Immagine di processo delle uscite

ESERCIZIARIO - dei.unipd.itsatta/teach/java/page/materiale/eserciziario.pdf · • Java Virtual Machine: Æ CPU ideale, simulata da un programma in esecuzione sulla CPU effettiva.

Scheduling della CPU - unibo.it

Architettura di una CPU Architettura ...corsiadistanza.polito.it/corsi/pdf/9030N/pdf/ese01.pdf · Architettura di una CPU M. Violante 1.3 Architettura di una CPU 5 Unità di misura

Compendium [G.Marciani] - Sistemi Operativi, Scheduling Della CPU

Sistema di automazione S7-300 Funzione integrate CPU 312 ... · Manuale Sistema di automazione S7-300, Configurazione Dati delle CPU Manuale di riferimento Sistema di automazione

Architettura delle CPU - Università degli Studi di Roma ... · Struttura della CPU ... agevole la gestione; la lunghezza del registro indica il numero di ... individuata dal registro

SCHEDULING DELLA CPU - people.unica.it · DELLA CPU Multiprocessor Multicore Real-Time SISTEMI OPERATIVI Classificazione dei Sistemi Multiprocessore ... 0 1 2 Single processor Dual

Capitolo 5: Scheduling della CPU

Calcolatori Elettronici - Unife · Classificazione dei calcolatori elettronici ... gli aspetti di progetto di alto livello ... la struttura interna della CPU…) Hardware il progetto

S7-300 CPU 31xC e CPU 31x: Dati tecnici - Siemens AG S7-300 CPU 31xC e CPU 31x: Dati tecnici CPU 31xC e CPU 31x: Dati tecnici 4 Manuale del prodotto, Edizione 06/2008, A5E00105478-08

Progetto di Stazioni Meteo integrate MeteoICS · La scheda di controllo della stazione meteorologica è una FOXG20 della ACME ... basata su CPU Atmel AT91SAM9G20 ... Card possono