Cioè che esegue una istruzione in un (solo) ciclo di clockVantaggi: semplicità di progettazione, CPI bassoSvantaggi: tempo di ciclo lungo, limitato dall’istruzione più lenta.

(1)

Università degli Studi dell’Insubria Dipartimento di Scienze Teoriche e Applicate

Architettura degli elaboratori

CPU a ciclo singolo

Marco Tarini

Dipartimento di Scienze Teoriche e Applicate [email protected]

Progettazione di una macchina

Criterio di progettazione di una CPU: prestazioni Le prestazioni di una macchina sono determinate da:

Numero di istruzioni da eseguire Durata del ciclo di clock

Numero di cicli per istruzione (CPI) Le ultime due determinate dal processore

design del datapathe dell’unità di controllo tecnologia usata!

Progettiamo un processore a ciclo singolo

Cioè che esegue una istruzione in un (solo) ciclo di clock Vantaggi: semplicità di progettazione, CPI basso

Svantaggi: tempo di ciclo lungo, limitato dall’istruzione più lenta.

- 2 -

(2)

Procedura passo-passo per il progetto di un processore

1. L’instruction setfornisce i requisiti per il datapath sematica delle istruzioni = cosa fanno.

Es. una data istruzione opera su i registri facendo:

R[rd] <– R[rs] + R[rt];

Il datapath deve essere in grado di relizzare ciascuna istruzione 2. Scegliere i componenti del datapath

e la metodologia di temporizzazione (clocking) 3. Progettare il datapath in modo da soddisfare i requisiti

4. Analizzare il datapath per identificare i controlli che determinano il trasferimento tra registri.

5. Progettare la logica di controllo (Control Unit)

- 3 -

Procedura passo-passo per il progetto di un processore

1. L’instruction set fornisce i requisiti per il datapath 2. Scegliere i componenti del datapath e la metodologia di

temporizzazione (clocking)

3. Progettare il datapath in modo da soddisfare i requisiti

5. Progettare la logica di controllo

(3)

Il formato delle istruzioni MIPS

Tutte le istruzioni sono lunghe 32 bit. Tre formati:

- 5 -

op target address

0 26 25

31

6 bits 26 bits

op rs rt rd shamt funct

6 5 0 11 10

16 15 21 20

26 25 31

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

op rs rt address / immediate

0 16 15

21 20 26 25

31

6 bits 5 bits 5 bits 16 bits

R-type

I-type

J-type

op: codice operativo (quale operazione esegue l’istruzione) rs, rt, rd: indicano registri degli operandi e del risultato shamt: shift amount

funct: indica varianti dell’operazione indicata da op

address / immediate: indirizzo (spiazzamento) o valore immediato target address: indirizzo destinazione di un’istruzione di salto

Un sottoinsieme delle istruzioni MIPS

Per progettare il grosso del datapath ci basta un sottoinsieme rappresentativo delle istruzioni MIPS.

ADDe SUB addurd, rs, rt suburd, rs, rt OR Immediate:

ori rt, rs, imm16 LOADe STORE

lwrt, rs, imm16 swrt, rs, imm16 BRANCH:

beqrs, rt, imm16

- 6 -

0 6 5 11 10 16 15 21 20 26 25 31

op rs rt immediate

0 16 15

21 20 26 25

31

op rs rt immediate

0 16 15

21 20 26 25 31

alias address

op rs rt immediate

0 16 15

21 20 26 25

31

(4)

Instruction fetch

- 7 -

MEM[PC]

Prima di eseguire una istruzione (di qualsiasi tipo) è necessario eseguire il suo fetch(lettura da memoria)

R-type

I-type

J-type

op target address

0 26 25

31

6 bits 26 bits

6 5 0 11 10 16 15 21 20 26 25 31

op rs rt address / immediate

0 16 15

21 20 26 25 31

Semantica delle istruzioni

espressa con «RTL» (Register Transfer Logic)

Istruzione Effetto su registri e memoria Effetto su PC

addu R[rd]  R[rs] + R[rt] PC  PC + 4

subu R[rd]  R[rs] – R[rt] PC  PC + 4

ori R[rt]



R[rs] OR zero_ext(imm16)

PC  PC + 4

lw R[rt]



MEM[R[rs] + sign_ext(imm16)]

PC  PC + 4 sw MEM[R[rs] + sign_ext(imm16)]

 R[rt]

PC  PC + 4

beq if(R[rs]==R[rt])

then PC  PC + 4 +

sign_ext(imm16)||00

Aggiungere 2 zeri nelle posizioni meno

significative

= moltiplicare x 4.

Serve per indirizzare parole da 32 bit.

(5)

Estensione con zeri (zero-extension)

Dato un numero naturale su 16 bit, voglio rappresentarlo su 32 bit.

Banale: basta aggiungere 16 zeri nei bit più significativi

(aggiungere zeri nelle posizioni più significative non cambia il valore denotato)

b₁₅b₁₄b₁₃b₁₂b₁₁b₁₀b₉b₈b₇b₆b₅b₄b₃b₂b₁b₀

- 9 -

0 Si usa per numeri

naturali e sequenze di bit

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 16 31

b₁₅b₁₄b₁₃b₁₂b₁₁b₁₀b₉b₈b₇b₆b₅b₄b₃b₂b₁b₀ 15

Estensione con zero

Estensione in segno (sign-extension)

Dato un numero intero in complemento a 2 su 16 bit, rappresentarlo –sempre in complemento a 2– su 32 bit.

Numero positivo (MSB=0): basta aggiungere 16 zeri

Numero negativo (MSB=1): basta aggiungere 16 uni 0000000000000000 0 . . . .

- 10 -

1111111111111111 1 . . . .

Denota N = -2¹⁵+k k (2¹⁶-1) * 2¹⁵

0 15

16 31

Denota -2³¹+ 2¹⁵* (2¹⁶-1) + k = -2³¹+ 2³¹- 2¹⁵+ k = -2¹⁵+ k = N 0

15 16 31

(6)

Sign-extension Vs zero extension

In binario

Su 4 bit:

1101

denota tredici;

allora su 8 bit 00001101

denota ancora tredici (banale)

Basta aggiungere tanti 0 a sx

In complemento a 2

Su 4 bit,

per i positivi: 0101 denota tre;

allora su 8 bit: 00000101 denota ancora tre per i negativi: 1101 denota meno cinque;

allora su 8 bit: 11111101 denota ancora meno cinque Basta ripetere il MSB a sx

Architettura degli elaboratori - Luigi Lavazza - 11 -

Procedura passo-passo per il progetto di un processore

(7)

Requisiti per l’esecuzione delle istruzioni

Memoria Istruzioni Dati

Registri (32 bit) Lettura rs

Lettura/scrittura rt Scrittura rd

Lettura/scrittura PC

Estensione (sia in segno e con zeri)

Somma, sottrazione, or-bitwise di registri (32 bit) o di immediato (esteso a 32 bit)

Il confronto richiesto da BEQ è una sottrazione di cui guardiamo se il risultato è nullo

Somma del valore 4 oppure di un immediato (esteso e shiftato) al PC

- 13 -

Requisiti per l’esecuzione delle istruzioni

Memorie Istruzioni Dati

Separate, perché dobbiamo leggere l’istruzione da eseguire e leggere o scrivere dati nello stesso ciclo di clock

Nota: dalla memoria di istruzioni, non si scrive mai, si legge e basta (e sempre all’indirizzo indicato dal PC)

- 14 -

32 Instruction Instruction

Memory Instruction Address

32 Data Memory

Data In Rd/Wr Address

Data Out 32

32 32

(8)

Requisiti per l’esecuzione delle istruzioni

Register File:

32 registri da 32 bit Due bus di uscita

BusA e BusB Un bus di input

BusW

Ingressi:

RA e RB selezionano i registri da riversare su BusA e BusB RW seleziona il registro in cui verranno scritti i dati provenienti da busW quando Write è 1

Clock: significativo solo in scrittura. In lettura il circuito si comporta in modo combinatorio: su BusA e BusB ci sono sempre i valori contenuti nei registri indicati da RA e RB

- 15 -

Register File

Clock Data In RB

Data Out B 5

32

32 Data Out A

32

5 RW RA

5 Bus A

Bus B WrEnable Write

Bus W

Requisiti per l’esecuzione delle istruzioni

Program Counter:

un registro speciale in più, separato E’ preposto ad un unico scopo:

memorizzare l’indice dell’istruzione corrente (in memoria istruzioni).

Il ciclo delle istruzioni comincia dal fetch: cioè quando

il PC assume il valore della prossima istruzione, e viene usato per leggerla (nota: la semantica di ogni istruzione specifica cosa succede al PC al nella prossima istruzione –

di solito, aumenta di 4 unità) Clock

Data In

32 32

Data

PC

Out

(9)

Requisiti per l’esecuzione delle istruzioni

Estensione con zero

- 17 -

Estensione in segno Estensione a scelta

E xt Z e ro

16 32

E xt S ig n

16 32

E xt e n d e r

16 32

se 0: con zero se 1: in segno

Tre circuiti combinatori MOLTO semplici…

Requisiti per l’esecuzione delle istruzioni

Estensione con zero

- 18 -

Estensione in segno

0

Estensione a scelta

0 : con zero 1: in segno i0

i₁₅

o0

o₃₁

i₀

i₁₅

o0

o₃₁

i₀

i₁₅

o0

o₃₁

(10)

Requisiti per l’esecuzione delle istruzioni

Somma, sottrazione, or bitwise

di registri o di immediato (una volta esteso a 32 bit) Confronto di registri (richiesto da beq)

Ipotizziamo di avere molte altre op e varianti nella ALU, qui 2⁷= 128

- 19 -

A B

ALU

32

32 Result

ALU

Codice operaz.

7 Uguale?

Requisiti per l’esecuzione delle istruzioni

Somma del valore 4 di un immediato (esteso e shiftato) al PC Deve essere fatta da un circuito diverso dall’ALU

Per lo stesso motivo per cui abbiamo due memorie separate:

l’incremento del PC va fatto nello stesso ciclo di clock in cui l’ALU fa le operazioni richieste dall’istruzione (somma, sottrazione, ecc.)

PC B

Adder

32

32 PC+B

Adder

CarryIn = 0

(11)

PC - Program Counter

(indirizzo della istruzione corrente)

Ottimizzazione:

ilPC come definito nella semantica è un indirizzo di byte.

memorizziamo invece ilPC’ come indirizzo di word PC’ = i 30 bit più significativi del PC

(i 2 bit meno significativi,l’offset del byte,assumiamo siano 00) PC = PC + 4 diventa PC’ = PC’ + 1

PC = PC + 4 + Imm16||00 diventa PC’ = PC’ + 1 + Imm16

Porte logiche Architettura degli elaboratori - Luigi Lavazza - 23 -

Clock Data

In

30 30

PC’ PC

00

2 ³²

Altri blocchi funzionali (combinatori) del datapath

I MUX:

necessari in tutti i casi è in cui è necessario fare delle scelte Tipicamente, pilotati da segnali di controllo provenienti dalla Control Unit

- 24 -

n

MUX

Control Unit

op …

n possibilità A

possibilità B

A o B, a seconda di op Istruzione corrente

(12)

Altri blocchi funzionali (combinatori) del datapath

I MUX:

necessari in tutti i casi è in cui è necessario fare delle scelte Nota:

è del tutto influente cosa entra dai cavi della possibilità NON scelta (possiamo comodamente disinteressarcene)

- 25 -

n

MUX ⁿ

possibilità A

possibilità B (inutilizzato)

A scegli

A

MUX

Altri blocchi funzionali (combinatori) del datapath

Moltiplicatori da un bit (reminder:

mette ciascun input in AND con il bit di controllo) Ottimizzazione di un MUX a 2 vie quando una delle due alternative è banalmente tutti zero

n

n possibilità A n

0 …. 0

A o 0…0 1 oppure 0

n n

possibilità A A o 0…0

1 oppure 0

*

0 1

(13)

Temporizzazione

Abbiamo la necessità di leggere e scrivere lo stesso registro nello stesso ciclo di clock.

Ad es. per fare ADD r9, r8, r9

- 28 -

ALU

Register file

Clock

Scrittura nei reg.

I nuovi valori sono su BusA

e BusB

I valori sono all’ingresso

dell’ALU

Il risultato dell’ALU è

stabile

Scrittura nei reg.

Temporizzazione: scelte

Tutte le scritture in qualsiasi memoria sono sincronizzati I 32 registri

Il PC

La memoria centrale

Usiamo lo stesso segnale di clock per tutti Sincronizzazione sul fronte in discesa:

quando il clock passa da alto a basso, il segnale in attesa nell’ingresso viene memorizzato (se la lettura è abilitata) – non prima

Importante: per quando cio’ avviene, il segnale deve essere pronto!

In lettura, tutti i circuiti di memoria si comportano invece in maniera completamente combinatoria:

Si mette l’indirizzo, e (dopo il tempo di commutazione) appare la parola letta in output

Nota: la mem istruzioni non ha scritture e quindi neanche il clock Nota: in tutte le mem quando non scrivo il clock non ha effetto

(14)

Procedura passo-passo per il progetto di un processore

- 31 -

Passo 3

Requisiti su trasferimento registri  Datapath Design

Fetch Istruzione

Decodifica istruzioni e lettura operandi Esecuzione dell’operazione

Scrittura del risultato

Progettiamo i circuiti che risolvono ciascun sottoproblema Fetch

Addu ORI ...

(15)

Instruction Fetch Unit

Instruction Fetch: lettura di mem[PC]

Aggiornamento del program counter:

Se si va in sequenza: PC  PC + 4

In caso di salto: PC  “indirizzo indicato nell’istruzione”

- 33 -

Code memory PC

Clock

Datapath instruction

Next address

logic (dice se è un ^Cod.op.:

branch)

Zero o uno (condizione

di salto) Op

6 Imm 16

Control Unit

32 32

32

Gestione del PC

Clk PC

CInSUM 1

30 30

00

30 30

Istruzione corrente 32

32 Instrucntion

Memory Addr

Out

X PC corrente

(in bytes)

PC corrente (in words)

Prossimo PC (in words):

quello precedente +1 + X.

(quando e non c’e’

salto, X = 0) Texture

Fetch

(16)

Datapath: partenza!

Assembliamo tutti i blocchi funzionali per ottenere un unico datapath Agiremo in modo incrementale:

Prima costruiamo un datapath per gestire una istruzione dell’istruction set

Consideriamo una alla volta le altre istruzioni del set,

e ogni volta modifichiamo il datapath in modo che gestisca quella istruzione, continuando a gestire anche le precedenti

(ogni volta, aggiungiamo alcuni controlli che la Control Unit dovrà computare)

Il primo datapath gestisce l’istruzioni R-Type del tipo:

addu rd, rs, rt (“add unsigned”)

(semantica: R[rd]  R[rs] + R[rt] , considerando i due operatori come interi senza segno)

- 35 -

Somma e sottrazione

addu rd, rs, rt R[rd]  R[rs] op R[rt]

0 6

11 16

21 26

31

32 Result ALUctr

Clk busW

RegWr

32

busA 32

busB 32

5 5 5

Rw Ra Rb 32x32-bit Registers

Rs Rt Rd

7

Control logic

12

ALU

Specifica di eseguire add o sub, a seconda di

funct Abilita

scrittura

(17)

Operazioni logiche con operando immediato

ori rt, rs, imm16 R[rt] <- R[rs] or ZeroExt[imm16]

- 37 -

op rs rt immediate

0 16

21 26

31

6 bits 5 bits 5 bits 16 bits Prima la destinazione

era rd. Ora è rt!

Prossima operazione da aggiungere:

Or logico con operando immediato

- 38 -

32 Result ALUctr

Clk busW

RegWr

32

32 busA

32 busB

5 5 5

Rw Ra Rb 32 32-bit Registers

Rs Rd

ALU

7

Rosso: da Istruz.

Blu: da U.C.

Rt

R[rt] = R[rs] OR ZeroExt[imm16]

Datapath fin’ora:

(18)

Operazioni logiche con operando immediato

- 39 -

32 Result ALUctr

Clk busW

RegWr

32

32 busA

32 busB

5 5 5

Rw Ra Rb 32 32-bit Registers

Rs Rt Rd RegDst

ZeroExt Mux Mux

16 32 imm16

ALUSrc

ALU

7

Specifica di eseguire OR

Specifica di selezionare ingresso

immediato esteso Specifica di

selezionare rt

Specifica di scrivere in Rw

Rosso: da Istruz.

Blu: da U.C.

Verde: usato Grigio: non usato

Rt

Load (caricamento da memoria)

lw rt, rs, imm16

lw sta per load word (32 bit) R[rt]  Mem[R[rs] + SignExt[imm16]]

Viene letta la cella di memoria avente l’indirizzo dato dal contenuto del registro rs, incrementato del valore immediato

Ad es. se rs contiene 1000 e imm16 = -67, viene letta la cella di indirizzo 933

Il valore immediato a 16 bit è esteso in segno perché potrebbe essere negativo.

op rs rt immediate

0 16

21 26

31

(19)

Prossimo commando da aggiugnere: Load R[rt]  Mem[R[rs] + SignExt[imm16]]

- 41 -

32 ALUctr

Clk busW

RegWr

32

busA 32

busB 32

5 5 5

Rw Ra Rb 32x32 Registers

Rs Rt Rd RegDst

Zero Ext

32 imm16 16

ALUSrc 7

Rosso: da Istruz.

Blu: da U.C.

Mux

ALU

Clk

Address Data Memory WrEn

Datapath fin’ora:

Mux

Load Word

(caricamento da memoria)

- 42 -

32 ALUctr

Clk busW

RegWr

32

busA 32

busB 32

5 5 5

Rs Rt Rd RegDst

Extender

32 imm16 16

ALUSrc ExtOp

Clk

Address Data Memory

32

MemToReg 7

Rosso: da Istruz.

Blu: da U.C.

WrEn MemWr 0:

«non scrivere»

1: scrivere in Rw selezionare

Rt

Immette su BusW il valore

letto da mem

Estensione

in segno Seleziona

l’immediato

Verde: usato Grigio: non usato

Mux

ALU

(20)

Operazioni di store (scrittura in memoria)

sw rt, rs, imm16

sw sta per store word (32 bit) Mem[ R[rs] + SignExt[imm16] ] <- R[rt]

Il valore contenuto nel registro rt viene scritto nella cella di memoria avente l’indirizzo dato dal contenuto del registro rs, incrementato del valore immediato

Ad es. se rt contiene 49, rs contiene 1000 e imm16 = -67, nella cella di indirizzo 933 viene scritto il valore 49

Il valore immediato a 16 bit è esteso in segno perché potrebbe essere negativo.

- 43 -

op rs rt immediate

0 16

21 26

31

Prossima op: store

Mem[ R[rs] + SignExt[imm16] ] <- R[rt]

32 ALUctr

Clk busW

RegWr

32

busA 32

busB 32

5 5 5

Rs Rd Rt

RegDst

Extender

32 imm16 16

Clk

Address Data Memory

32

MemToReg 3

Rosso: da Istruz.

Blu: da U.C.

WrEn MemWr

Mux

ALU

Situazione precendente…

Rt

Mux

Out In

(21)

Datapath per istruzione Store

- 45 -

32 ALUctr

Clk busW

RegWr

32

busA 32

busB 32

5 5 5

Rs Rd Rt

RegDst

Extender

32 imm16 16

ALUSrc ExtOp

Clk

Address Data Memory

32

MemToReg 3

Rosso: da Istruz.

Blu: da U.C.

WrEn MemWr

Mux

ALU

Rt

Mux

Out In

0

1 SUM

sign imm

Istruzione di salto condizionato (branch)

beq rs, rt, imm16

Sequenza logica di esecuzione

Instruction  mem[PC] // Fetch dell’istruzione da mem.

COND  R[rs] == R[rt] // Calcolo della condizione di salto PC  PC + 4

if (COND == 1)

PC  PC + 4 + ( SignExt(imm16) x 4 )

- 47 -

op rs rt immediate

0 16

21 26

31

Spiazzamento in parole, indirizzo in byte

(22)

Prossima op: Beq

if (R[rs] == R[rt]) then PC = PC+4+SingExt(imm16)x4

- 48 -

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt RegDst

16 32 imm16

ALUSrc ExtOp

Clk

Adr Data Memory

32 MemToReg 7

WrEn MemWr

Mux

In Out

ALU

=

Rosso: da Istruz.

Blu: da CU

Extender

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

0…0

Prossima op: Beq

if (R[rs] == R[rt]) then PC = PC+4+SingExt(imm16)x4

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt

RegDst

Extender

16 32 imm16

Clk

Adr Data Memory

32 MemToReg 7

WrEn MemWr

Mux

Out

*

In

30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

(23)

Il datapath: quadro complessivo

- 50 -

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt RegDst

Extender

16 32 imm16

ALUSrc ExtOp

Clk

Adr Data Memory

32 MemToReg 7

WrEn MemWr

Mux

In Out

*

nPC_sel 30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

Procedura passo-passo per il progetto di un processore

3. Progettare il datapath in modo da soddisfare i requisiti 4. Analizzare il datapath

per identificare tutti i controlli che determinano il datapath.

- 52 -

(24)

Dal Datapath all’unità di controllo

- 53 -

ALUctr

RegDst ExtOpALUSrc MemWr MemToReg

Equal Imm16

Rd Rt Rs

nPC_sel Instruction

Memory

DataPath Control Unit

Op Fun

RegWr

Instruction[31:0]

[21:25] [16:20] [11:15] [0:15]

[26:31] [0:5]

Op Fun

Rs Rt Rd Imm

7

Quadro Complessivo a più alto livello

ALUctr RegDst ExtOpALUSrc MemWr

Equal nPC_sel

Instruction Memory

DataPath Control Unit

RegWr

PC Op

Fun

Rs Rt Rd Imm

7 32 32

MemToReg

(25)

CPU

Quadro Complessivo a più alto livello

- 55 -

ALUctr RegDst ALUSrc

ExtOp

MemToReg MemWr

Equal nPC_sel

Instruction Memory

DataPath Control Unit

RegWr

PC Op

Fun

Rs Rt Rd Imm

7 32 32

Adr Data

Memory

WrEn Out

In 32

32 32

ALU

Quadro Complessivo a più alto livello:

note

La Control Unit è un circuito puramente combinatorio

Rs, Rt, Rde Imm16sono passati a datapath con un collegamento fisso Ope Funsono passati alla Control Unit con un collegamento fisso La CU produce i controlli che guidano il datapath

La maggior parte di questi dipende solo da Op , ma:

In alcune Op, ALUctrdipende anche da Fun (in altre, Funnon ha effetto) nPC_seldipende anche daEqual (che torna dal DataPath)

A causa del formato variabile delle istruzioni MIPS, alcuni bit dell’istruzione sono replicati in campi diversi contemporaneamente;

per es:

I bit di Rd sono anche la prima parte di Imm16, I bit di Funsono anche l’ultima parte di Imm16, etc

…ma i controlli mandati dalla CU fanno sempre in modo che i campi senza senso (per es Rd in una istruzione di tipo I) non abbiano alcun effetto (per es siano nella parte ignorata di un Mutex)

- 56 -

(26)

Il Mircroprocessore

L’intera CPU sta tutta su un solo circuito integrato:

il «microprocessore»

(gli Istruction Set di tipo RISC, come il MIPS che abbiamo visto, nascono proprio per permettere questo!)

Comprende:

La Control Unit

Il datapath, che include La ALU

I registri (compreso il PC) Il circuito della gestione del PC etc

La memoria cache (almeno quella L1)

Ma non comprende la RAM, che sta tipicamente su chip separati (collegati da un bus)

- 57 -

Segnali di controllo

Istruzione Register Transfer

ADD R[rd]  R[rs] + R[rt]; PC  PC + 1

ALUsrc = RegB, ALUctr = “add”, RegDst = rd, RegWr, nPC_sel = “+4”

SUB R[rd]  R[rs] – R[rt]; PC  PC + 1

ALUsrc = RegB, ALUctr = “sub”, RegDst = rd, RegWr, nPC_sel = “+4”

ORi R[rt]  R[rs] + zero_ext(Imm16); PC  PC + 1

ALUsrc = Im, Extop = “Z”, ALUctr = “or”, RegDst = rt, RegWr, nPC_sel = “+4”

LOAD R[rt]  MEM[ R[rs] + sign_ext(Imm16)]; PC  PC + 1 ALUsrc = Im, Extop = “Sn”, ALUctr = “add”,

MemtoReg, RegDst = rt, RegWr, nPC_sel = “+4”

STORE MEM[ R[rs] + sign_ext(Imm16)]  R[rs]; PC  PC + 1 ALUsrc = Im, Extop = “Sn”, ALUctr = “add”, MemWr, nPC_sel = “+4”

BEQ if ( R[rs] == R[rt] ) then PC  PC + 1 + sign_ext(Imm16) else PC  PC + 1 nPC_sel = EQUAL, ALUctr = “sub”

(27)

Procedura passo-passo per il progetto di un processore

- 61 -

Definizione dei segnali di controllo

nPC_sel if (OP == BEQ) then EQUAL else 0 ALUsrc if (OP == “000000”) || (OP == BEQ)

then “regB” else “immed”

ALUctr if (OP == “000000”) then funct elseif (OP == ORi) then “or”

elseif (OP == BEQ) then “sub”

else “add”

ExtOp if (OP == ORi) then “zero” else “sign”

MemWr (OP == Store) MemtoReg  (OP == Load)

RegWr: if ((OP == Store) || (OP == BEQ)) then 0 else 1 RegDst: if ((OP == Load) || (OP == ORi)) then 0 else 1

- 62 -

rt rd

(28)

I segnali di controllo

- 63 -

add sub ori lw sw beq jump

RegDst ALUSrc MemtoReg RegWrite MemWrite nPCsel Jump ExtOp ALUctr[2:0]

1 0 0 1 0 0 0 x Add

1 0 0 1 0 0 0 x Sub

0 1 0 1 0 0 0 0 Or

0 1 1 1 0 0 0 1 Add

x 1 x 0 1 0 0 1 Add

x 0 x 0 0 1 0 x Sub

x x x 0 0 0 1 x xxx

op target address

0 6

11 16

21 26

31

op rs rt immediate

R-type I-type J-type

add, sub ori, lw, sw, beq jump

func

op 000000 000000 001101 100011 101011 000100 000010 100000 100010 Don’t Care

Un sottoinsieme delle istruzioni MIPS

Al sottoinsieme delle istruzioni MIPS implementate manca il salto incondizionato

(utile perché: no condizione, ma salta più lontano) JUMP:

j addr

Semantica: PC  PC[31..28] || addr || 00

op addr

25 0 26 31

6 bits 26 bits

Addr in parole, indirizzo in byte

(29)

Specifica delle istruzioni in RTL

Istruzione Effetto su registri e memoria Effetto su PC

addu R[rd]  R[rs] + R[rt]; PC  PC + 4

subu R[rd]  R[rs] – R[rt]; PC  PC + 4

ori R[rt]  R[rs] or zero_ext(imm16); PC  PC + 4

ldw R[rt] 

MEM[R[rs] + sign_ext(imm16)]; PC  PC + 4 stw MEM[R[rs] + sign_ext(imm16)] 

R[rt]; PC  PC + 4

beq if(R[rs]==R[rt]) then PC 

PC+4+sign_ext(imm16)||00 else PC  PC + 4

j PC[0..27]  addr || 00

- 65 -

PC[31..28]

resta immutato

Cammino critico per l’istruzione load

R[rt]  MEM[R[rs] + sign_ext(imm16)];

- 66 -

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt RegDst

Extender

16 32 imm16

ALUSrc ExtOp

Clk

Adr Data Memory

32 WSrc 7

WrEn MemWr

Mux

Out

*

In

nPC_sel 30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

(30)

Clk 32

busB 30

alla CU

Cammino critico per l’istruzione load

R[rt]  MEM[R[rs] + sign_ext(imm16)]

- 67 -

32 ALUctr

Clk busW

RegWr

32 32

5 5 5 busA Rw Ra Rb 32x32 Registers

Rs Rd Rt RegDst

Extender

16 32 imm16

ALUSrc ExtOp

Adr Data Memory

32 WSrc 7

WrEn MemWr

Mux

In Out

*

nPC_sel

ALU

PC = Clk

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

1 1

SUM 0

1 sign 1 0

Cammino critico per l’istruzione load

R[rt]  MEM[R[rs] + sign_ext(imm16)];

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt

RegDst

Extender

16 32 imm16

Clk

Adr Data Memory

32 WSrc 7

WrEn MemWr

Mux

Out

*

In

30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

(31)

- 69 -

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt

RegDst

Extender

16 32 imm16

ALUSrc ExtOp

Clk

Adr Data Memory

32 WSrc 7

WrEn MemWr

Mux

In Out

*

nPC_sel 30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

Cammino critico per l’istruzione load

R[rt]  MEM[R[rs] + sign_ext(imm16)]

- 70 -

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt

RegDst

Extender

16 32 imm16

ALUSrc ExtOp

Clk

Adr Data Memory

32 WSrc 7

WrEn MemWr

Mux

Out

*

In

nPC_sel 30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

Cammino critico per l’istruzione load

R[rt]  MEM[R[rs] + sign_ext(imm16)]

CONTROL UNIT

(32)

- 71 -

32 ALUctr

Clk busW

RegWr

32 32

busA

32 busB

5 5 5

Rs Rd Rt

RegDst

Extender

16 32 imm16

ALUSrc ExtOp

Clk

Adr Data Memory

32 WSrc 7

WrEn MemWr

Mux

In Out

*

nPC_sel 30

ALU

= alla CU

Clk PC

CInSUM 1

30 30 00

30 30

instruction 32

32 Instrucntion

Memory Adr

Out

Cammino critico per l’istruzione load

R[rt]  MEM[R[rs] + sign_ext(imm16)]

start

end

Clk

PC Rs, Rt, Rd, Op, Func

Clk-to-Q

ALUctr

Instruction Memory Access Time

Old Value New Value

RegWr Old Value New Value

Delay through Control Logic

busA

Register File Access Time

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value New Value New Value

Old Value

ExtOp Old Value New Value

ALUSrc Old Value New Value

MemtoReg Old Value New Value

Address Old Value New Value

Delay through Extender & Mux

Register Write Occurs

Data Memory Access Time

Caso pessimo: tempo di esecuzione dell’istruzione Load

(33)

Clk

Clk-to-Q

ALUctr

Old Value New Value

busA

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value

busW Old Value New

Caso pessimo: tempo di esecuzione dell’istruzione Load

- 74 -

1. Il fronte di discesa del clock ordina l’aggiornamento dei registri

2. Il nuovo valore del PC diventa disponibile.

Inizia il fetch dell’istruzione

Clk

Clk-to-Q

ALUctr

Old Value New Value

busA

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value

busW Old Value New

Caso pessimo: tempo di esecuzione dell’istruzione Load

- 75 -

3. La nuova istruzione diventa disponibile.

Inizia la decodifica dell’istruzione

4. La UC genera i segnali di controllo

(34)

Clk

Clk-to-Q

ALUctr

Old Value New Value

busA

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value

busW Old Value New

Caso pessimo: tempo di esecuzione dell’istruzione Load

- 76 -

5. I dati sono stati letti dai registri, si sono propagati attraverso bus, muliplexer e ALU.

Inizia la lettura da mem.

Clk

Clk-to-Q

ALUctr

Old Value New Value

busA

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value

Caso pessimo: tempo di esecuzione dell’istruzione Load

6. Lettura completata.

Poco dopo il dato letto è disponibile agli ingressi del banco di reg. per la scrittura.

(35)

Clk

Clk-to-Q

ALUctr

Old Value New Value

busA

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value

busW Old Value New

Caso pessimo: tempo di esecuzione dell’istruzione Load

- 78 -

7. Il fronte di discesa ordina l’aggiornamento dei registri.

Il valore presente su busW viene scritto nel registro di destinazione.

Clk

Clk-to-Q

ALUctr

Old Value New Value

busA

Old Value New Value

busB

ALU Delay

Old Value New Value

Old Value

busW Old Value New

Caso pessimo: tempo di esecuzione dell’istruzione Load

- 79 -

(36)

Non si usano le implementazioni a ciclo singolo

È uno spreco che operazioni potenzialmente brevi debbano durare tanto quanto quelle lunghe.

Anche per le operazioni lunghe (che accedono a memoria) esiste la possibilità di usare la memoria cache, abbreviando i tempi …

- 82 -

Ricapitolando

5 passi di progetto del processore

Derivare i requisiti per il datapath dall’instruction set Scegliere i componenti del datapath e la metodologia di temporizzazione (clocking)

Progettare il datapath in modo da soddisfare i requisiti

Analizzare il datapath per identificare i controlli che determinano il trasferimento tra registri

Progettare la logica di controllo

Il processore MIPS consente alcune semplificazioni

Tutte le istruzioni hanno la medesima dimensione (32 bit) L’indicazione dei registri sorgenti ha sempre la stessa posizione nell’istruzione

I valori immediati hanno la stessa dimensione e posizione nell’istruzione

Le operazioni sono sempre su registri o valori immediati