Upload
internet
View
107
Download
0
Embed Size (px)
Citation preview
11998 Morgan Kaufmann Publishers
ProcessadorFluxo de Dados e Controle
21998 Morgan Kaufmann Publishers
• Estamos prontos para realizarmos uma implementação do MIPS
• Simplificada para conter somente:
– Instruções de referência à memória: lw, sw – Instruções aritméticas e lógicas: add, sub, and, or, slt– Instruções de fluxo de controle: beq, j
• Implementação genérica:
– usar o contador de programa (PC) para fornecer o endereço da instrução
– Ler a instrução da memória
– ler registradores
– Usar a instrução para decidir exatamente o que fazer
• Todas as instruções usam a ALU após a leitura dos registradores
Por que? Referência a memória?Aritmética? Fluxo de
controle?
O processador: Fluxo de Dados & Controle
31998 Morgan Kaufmann Publishers
• Resumo / Vista Simplificada:
Dois tipos de unidades funcionais:– Elementos que operam sobre dados (combinacional)– Elementos que contêm estado (sequencial)
Mais detalhes sobre a Implementação
Registers
Register #
Data
Register #
Datamemory
Address
Data
Register #
PC Instruction ALU
Instructionmemory
Address
41998 Morgan Kaufmann Publishers
• Sem clock vs. com clock
• Clocks são usados em lógica síncrona
– como um elemento que contem estado pode ser atualizado?
Tempo de ciclo
Borda de subida
Borda de descida
Elementos de Estado
51998 Morgan Kaufmann Publishers
preliminares
Número ímpar de inversores em anel
Número par de inversores em anel
61998 Morgan Kaufmann Publishers
• O retentor (latch) set-reset
– A saída depende das entradas atuais e também das entradas passadas
Um elemento de estado sem clock
S
R
Q
S
R
Q
Q
R
S
Q
Q
71998 Morgan Kaufmann Publishers
• A saída é igual ao valor armazenado no elemento(não é necessário pedir permissão para ver o valor)
• A mudança de estado (valor) é baseada no clock
• Latch D: sempre que as entradas mudam, e o clock é acionado
• Flip-flop D: o estado muda somente na borda do clock (edge-triggered)
Latch D e Flip-flop D
81998 Morgan Kaufmann Publishers
• Duas entradas:
– O valor do dado a ser armazenado (D)
– O sinal de clock (C) indicando quando ler & escrever D
• Duas saídas:
– O valor do estado interno (Q) e o seu complemento
Latch D
Q
C
D
_Q
D
C
Q
D
C
Q
Q
91998 Morgan Kaufmann Publishers
flip-flop D
• A saída somente muda na borda do clock
_Q
Q
_Q
Dlatch
D
C
Dlatch
DD
C
C
D
C
Q
D
C
Q
Q
101998 Morgan Kaufmann Publishers
Nossa Implementação
• Uma metodologia usando borda para o disparo ( “trigger”)
• Execução típica:
– Ler conteúdo de certos elementos de estado,
– Enviar valores através de alguma lógica combinacional
– Escrever resultados a um ou mais elementos de estado
Clock cycle
Stateelement
1Combinational logic
Stateelement
2
111998 Morgan Kaufmann Publishers
• Construido usando D flip-flops
Banco de Registradores (Register file)
Mux
Register 0
Register 1
Register n – 1
Register n
Mux
Read data 1
Read data 2
Read registernumber 1
Read registernumber 2
Read registernumber 1 Read
data 1
Readdata 2
Read registernumber 2
Register fileWriteregister
Writedata Write
121998 Morgan Kaufmann Publishers
Banco de Registradores
• Nota: ainda usamos o clock real para determinar quando escrever
n-to-1decoder
Register 0
Register 1
Register n – 1C
C
D
DRegister n
C
C
D
D
Register number
Write
Register data
0
1
n – 1
n
131998 Morgan Kaufmann Publishers
Implementação simples
• Inclui as unidades funcionais que necessitamos para as instruções
PC
Instructionmemory
Instructionaddress
Instruction
a. Instruction memory b. Program counter
Add Sum
c. Adder
ALU control
RegWrite
RegistersWriteregister
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Writedata
ALUresult
ALU
Data
Data
Registernumbers
a. Registers b. ALU
Zero5
5
5 3
16 32Sign
extend
b. Sign-extension unit
MemRead
MemWrite
Datamemory
Writedata
Readdata
a. Data memory unit
Address
141998 Morgan Kaufmann Publishers
multiplexador
• Seleciona uma das entradas para a saída, baseado numa entrada de controle
S
CA
B0
1
mux de 2-entradas A e B e controle S
C
A
B
C
D
0
1
2
3
S
mux de 4 entradasC
A
B
C
D
01
10
10
11
S2 2
151998 Morgan Kaufmann Publishers
ALU
Operando A
Operando B
resultado
Flag de resultado zero
161998 Morgan Kaufmann Publishers
ALU de 32 bits
Seta31
0
Result0a0
Result1a1
0
Result2a2
0
Operation
b31
b0
b1
b2
Result31
Overflow
Bnegate
Zero
ALU0Less
CarryIn
CarryOut
ALU1Less
CarryIn
CarryOut
ALU2Less
CarryIn
CarryOut
ALU31Less
CarryIn
32
32
32
Seleção
result
a
b
ALU
Linhas de controle:
000 = and001 = or010 = add110 = subtract111 = slt
171998 Morgan Kaufmann Publishers
Um dado imediato de 16 bits do MIPS é convertido para 32 bits em aritmética
Copiar o bit mais significativo (o bit de sinal) para outros bits
0010 -> 0000 00101010 -> 1111 1010
"sign extension"
Convertendo um número de n bits em números de mais de n bits
181998 Morgan Kaufmann Publishers
Memória de instruções
endereçode 32 bitspelo PC
instrução de 32 bits
191998 Morgan Kaufmann Publishers
Memória de dados
Para leitura: deve fornecero endereço (Address) e acionar ocontrole de leitura (MemRead=1)
Para escrita deve fornecer o endereço (Address), o dadoa ser escrito no (Writedata) eacionar o controle de escrita (MemWrite=1)
201998 Morgan Kaufmann Publishers
Contador de programa
endereço da próxima de instrução
endereço da instrução corrente
Quando é sequencial é o endereço da instrução corrente adicionado de 4 (memória de instruções constituída de bytes)
211998 Morgan Kaufmann Publishers
Construindo o Fluxo de Dados
• Usar os multiplexadores para juntar os elementos
PC
Instructionmemory
Readaddress
Instruction
16 32
Add ALUresult
Mux
Registers
Writeregister
Writedata
Readdata 1
Readdata 2
Readregister 1Readregister 2
Shiftleft 2
4
Mux
ALU operation3
RegWrite
MemRead
MemWrite
PCSrc
ALUSrc
MemtoReg
ALUresult
ZeroALU
Datamemory
Address
Writedata
Readdata M
ux
Signextend
Add
221998 Morgan Kaufmann Publishers
Controle
• Selecionar as operações para executar (ALU, leitura/escrita, etc.)
• Controlar o fluxo de dados (entradas para o multiplexador)
• A informação vem de 32 bits da instrução
• Exemplo:
add $8, $17, $18 Formato de Instrução:
000000 10001 10010 01000 00000 100000
op rs rt rd shamt funct
• Operação da ALU baseada no tipo de instrução e código da função
231998 Morgan Kaufmann Publishers
• P.ex., o que a ALU faz para essa instrução• Example: lw $1, 100($2)
35 2 1 100
op rs rt 16 bit offset
• Entrada de controle da ALU
000 AND001 OR010 add110 subtract111 set-on-less-than
• Por que o código da subtração é 110 e não 011?
Controle
241998 Morgan Kaufmann Publishers
• Deve descrever o hardware para computar a entrada de controle da ALU de 3-bit
– Dado o tipo de instrução 00 = lw, sw01 = beq, 10 = aritmética
– Código de função para aritmética
• Descreve usando uma tabela verdade (que pode ser convertido em portas):
ALUOp Computado do tipo de instrução
Controle
ALUOp Funct field OperationALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0
0 0 X X X X X X 0100 1 X X X X X X 1101 0 X X 0 0 0 0 0101 0 X X 0 0 1 0 1101 0 X X 0 1 0 0 0001 0 X X 0 1 0 1 0011 0 X X 1 0 1 0 111
251998 Morgan Kaufmann Publishers
Controle
Instruction RegDst ALUSrcMemto-
RegReg
WriteMem Read
Mem Write Branch ALUOp1 ALUp0
R-format 1 0 0 1 0 0 0 1 0lw 0 1 1 1 1 0 0 0 0sw X 1 X 0 0 1 0 0 0beq X 0 X 0 0 0 1 0 1
PC
Instructionmemory
Readaddress
Instruction[31– 0]
Instruction [20– 16]
Instruction [25– 21]
Add
Instruction [5– 0]
MemtoReg
ALUOp
MemWrite
RegWrite
MemRead
BranchRegDst
ALUSrc
Instruction [31– 26]
4
16 32Instruction [15– 0]
0
0Mux
0
1
Control
Add ALUresult
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Signextend
Shiftleft 2
Mux
1
ALUresult
Zero
Datamemory
Writedata
Readdata
Mux
1
Instruction [15– 11]
ALUcontrol
ALUAddress
261998 Morgan Kaufmann Publishers
Controle
• Lógica combinacional simples (tabela verdade)
Operation2
Operation1
Operation0
Operation
ALUOp1
F3
F2
F1
F0
F (5– 0)
ALUOp0
ALUOp
ALU control block
R-format Iw sw beq
Op0
Op1
Op2
Op3
Op4
Op5
Inputs
Outputs
RegDst
ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOpO
271998 Morgan Kaufmann Publishers
• Todas as lógicas são combinacionais
• Esperamos estabilizar tudo, e a operação certa a ser realizada
– ALU não produz resposta certa imediatamente
– Usamos os sinais de escrita sincronizados ao clock para
determinar quando escrever
• O tempo de ciclo é determinado pelo circuito mais moroso
Nossa estrutura de controle simples
Clock cycle
Stateelement
1Combinational logic
Stateelement
2
281998 Morgan Kaufmann Publishers
Implementação em um ciclo
• Calcular o tempo de ciclo assumindo atrasos desprezíveis exceto:
– Memória (2ns), ALU e somadores (2ns), acesso aos registradores (1ns)
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31– 0]
Instruction [20– 16]
Instruction [25– 21]
Add
Instruction [5– 0]
RegWrite
4
16 32Instruction [15– 0]
0Registers
WriteregisterWritedata
Writedata
Readdata 1
Readdata 2
Readregister 1Readregister 2
Signextend
ALUresult
Zero
Datamemory
Address Readdata
Mux
1
0
Mux
1
0
Mux
1
0
Mux
1
Instruction [15– 11]
ALUcontrol
Shiftleft 2
PCSrc
ALU
Add ALUresult
291998 Morgan Kaufmann Publishers
Implementação de MIPS em um único ciclo
Instruction RegDst ALUSrcMemto-
RegReg
WriteMem Read
Mem Write Branch ALUOp1 ALUp0
R-format 1 0 0 1 0 0 0 1 0lw 0 1 1 1 1 0 0 0 0sw X 1 X 0 0 1 0 0 0beq X 0 X 0 0 0 1 0 1
PC
Instructionmemory
Readaddress
Instruction[31– 0]
Instruction [20– 16]
Instruction [25– 21]
Add
Instruction [5– 0]
MemtoReg
ALUOp
MemWrite
RegWrite
MemRead
BranchRegDst
ALUSrc
Instruction [31– 26]
4
16 32Instruction [15– 0]
0
0Mux
0
1
Control
Add ALUresult
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Signextend
Shiftleft 2
Mux
1
ALUresult
Zero
Datamemory
Writedata
Readdata
Mux
1
Instruction [15– 11]
ALUcontrol
ALUAddress
301998 Morgan Kaufmann Publishers
Onde estamos?
• Problemas de ciclo simples:
– E se tivéssemos instruções mais complexas como ponto-flutuante?
– Devastação de área
• Uma Solução:
– usar um tempo de ciclo “menor”
– Ter diferentes instruções levando diferentes números de ciclos
– Um fluxo de dados de “multiplos ciclos”:
PC
Memory
Address
Instructionor data
Data
Instructionregister
Registers
Register #
Data
Register #
Register #
ALU
Memorydata
register
A
B
ALUOut
311998 Morgan Kaufmann Publishers
• Estaremos usando as mesmas unidades funcionais
– ALU é usada para computar o endereço e para incrementar PC
– A memória é usada para instruções e dados
• Nossos sinais de controle não são determinados somente pelas instruções
– P.ex., o que a ALU faria para uma instrução de “subtração” ?
• Usamos uma máquina de estado finito para o controle
Técnica Multiciclo
321998 Morgan Kaufmann Publishers
• Máquinas de estado finito:– Um conjunto de estados e – Função próximo estado (determinado pelo estado atual e entrada)– Função de saída (determinada pelo estado atual e possivelmente entrada)
– Usaremos uma máquina Moore (saída baseada somente no estado atual)
Revisão: máquinas de estado finito
Next-statefunction
Current state
Clock
Outputfunction
Nextstate
Outputs
Inputs
331998 Morgan Kaufmann Publishers
Revisão: máquinas de estado finito
• Exemplo:
B. 21 Um amigo gostaria de construir um olho “eletrônico” para uso em dispositivo de segurança. O dispositivo consiste de 3 luzes alinhados, controladas por saídas Esquerda, Central, e Direita, que, se acionadas, indicam que uma luz estaria acesa. Somente uma luz é acionada por vez, e a luz “move” da esquerda para a direita e, então, da direita para a esquerda, para assustar os ladrões que acreditam que os dispositivos estejam monitorando as suas atividades. Traçar a representação gráfica para a máquina de estado finito usada para especificar o olho eletrônico. Notar que a taxa de movimentação do olho será controlado pela velocidade do clock (que não deveria ser excessivamente grande) e que não existem essencialmente entradas.
341998 Morgan Kaufmann Publishers
• Quebrar as instruções em passos, cada passo leva um ciclo
– Balancear a quantidade de trabalhos a realizar
– Restringir cada ciclo para usar somente uma unidade funcional
• No fim de um ciclo
– Armazenar valores para serem usados nos ciclos posteriores
– introduzir registradores internos adicionais
Técnica multiciclo
Shiftleft 2
PC
Memory
MemData
Writedata
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
1 Mux
0
3
2
Mux
ALUresult
ALUZero
Memorydata
register
Instruction[15– 11]
A
B
ALUOut
0
1
Address
351998 Morgan Kaufmann Publishers
• Busca da instrução (Instruction Fetch)
• Decodificação da instrução e busca do registrador
• Execução, Computação do endereço de memória, ou conclusão de uma instrução de branch
• Acesso à memória ou conclusão de uma instrução R-type
• Passo de Write-back
INSTRUÇÕES LEVEM DE 3 - 5 CICLOS!
Cinco passos de Execução
361998 Morgan Kaufmann Publishers
• Usar o PC para a leitura da instrução e carga da mesma no registrador de instrução (Instruction Register).
• Incrementar o valor do PC por 4 e carregar o resultado no PC.
• Pode ser descrito sucintamente usando RTL "Register-Transfer Language"
IR = Memory[PC];PC = PC + 4;
Podemos obter os valores dos sinais de controle?
Quais as vantagens de atualizar o PC neste passo?
Passo 1: Busca da instrução (Instruction Fetch)
371998 Morgan Kaufmann Publishers
• Leitura dos registradores rs e rt
• Computar o endereço de branch no caso da instrução de branch
• RTL:
A = Reg[IR[25-21]];B = Reg[IR[20-16]];ALUOut = PC + (sign-extend(IR[15-0]) << 2);
• Estamos acionando as linhas de controle baseadas no tipo de instrução
(a instrução está sendo "decodificada" na lógica de controle)
Passo 2: Decod. da Instrução e Busca de Registradores
381998 Morgan Kaufmann Publishers
• ALU está realizando uma das três funções, baseadas no tipo de instrução
• Referência à memória:
ALUOut = A + sign-extend(IR[15-0]);
• R-type:
ALUOut = A op B;
• Branch:
if (A==B) PC = ALUOut;
Passo 3 (dependente da instrução)
391998 Morgan Kaufmann Publishers
• Acesso à memória através de loads e stores
MDR = Memory[ALUOut];or
Memory[ALUOut] = B;
• Fim das instruções R-type
Reg[IR[15-11]] = ALUOut;
A escrita é realizada no fim do ciclo, na borda
Passo 4 (R-type ou acesso à memória)
401998 Morgan Kaufmann Publishers
• Reg[IR[20-16]]= MDR;
E as outras instruções?
Passo Write-back
411998 Morgan Kaufmann Publishers
Resumo:
Step nameAction for R-type
instructionsAction for memory-reference
instructionsAction for branches
Action for jumps
Instruction fetch IR = Memory[PC]PC = PC + 4
Instruction A = Reg [IR[25-21]]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] IIcomputation, branch/ (IR[15-0]) PC = ALUOut (IR[25-0]<<2)jump completion
Memory access or R-type Reg [IR[15-11]] = Load: MDR = Memory[ALUOut]completion ALUOut or
Store: Memory [ALUOut] = B
Memory read completion Load: Reg[IR[20-16]] = MDR
421998 Morgan Kaufmann Publishers
• Quantos ciclos são necessários para o código?
lw $t2, 0($t3)lw $t3, 4($t3)beq $t2, $t3, Label #assume notadd $t5, $t2, $t3sw $t5, 8($t3)
Label: ...
• O que acontece durante o oitavo ciclo de execução?• Em que ciclo a soma de $t2 e $t3 é realizada?
Questões simples
431998 Morgan Kaufmann Publishers
• Os sinais de controle são dependentes de:
– Que instrução está sendo executada
– Que passo está sendo realizada
• Usar as informações acumuladas para especificar uma máquina de estado finito
– Especificar uma máquina de estado finito graficamente, ou
– usar microprogramação
Implementando o Controle
• Quantos bits de estado são necessários?
Especificação da FSM
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst = 0RegWrite
MemtoReg =1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
= 'B
EQ')
(Op
= 'J
')
(Op = 'SW
')
(Op
= 'L
W')
4
01
9862
753
Start
451998 Morgan Kaufmann Publishers
• Implementação:
Máquina de estado finito para controle
PCWrite
PCWriteCond
IorD
MemtoReg
PCSource
ALUOp
ALUSrcB
ALUSrcA
RegWrite
RegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3
S2
S1
S0
State register
IRWrite
MemRead
MemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
461998 Morgan Kaufmann Publishers
Implementação em PLA
Op5
Op4
Op3
Op2
Op1
Op0
S3
S2
S1
S0
IorD
IRWrite
MemReadMemWrite
PCWritePCWriteCond
MemtoRegPCSource1
ALUOp1
ALUSrcB0ALUSrcARegWriteRegDstNS3NS2NS1NS0
ALUSrcB1ALUOp0
PCSource0
471998 Morgan Kaufmann Publishers
• ROM = "Read Only Memory"
– Os valores das palavras de memória são fixas ao longo do tempo
• Uma ROM pode ser usada para implementar uma tabela verdade
– Se o endereço é de m-bits, podemos endereçar 2m entradas na ROM.
– Nossas saídas são os bits de dados onde o endereço aponta.
m é a “altura", e n é a “largura"
Implementação em ROM
m n
0 0 0 0 0 1 10 0 1 1 1 0 00 1 0 1 1 0 00 1 1 1 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 11 1 0 0 1 1 01 1 1 0 1 1 1
481998 Morgan Kaufmann Publishers
• Quantas entradas existem?6 bits para opcode, 4 bits para estado = 10 linhas de
endereço(i.e., 210 = 1024 endereços diferentes)
• Quantas saídas existem?16 saídas de controle do fluxo de dados, 4 bits de estado =
20 saídas
• ROM é 210 x 20 = 20K bits (um tamanho não usual)
Implementação em ROM
491998 Morgan Kaufmann Publishers
• Quebrar a tabela em duas partes
— 4 bits de estado fornecem as 16 saídas, 24 x 16 bits of ROM
— 10 bits fornecem o endereço para os 4 bits de estado seguinte, 210 x 4
bits of ROM
— Total: 4.3K bits de ROM
• PLA é menor
— pode compartilhar termos produtos
— são necessárias somente entradas que produzem saída ativa
— pode levar em conta os irrelevantes
• O tamanho é (#entradas #termos-produto) + (#saídas #termos-produto)
Para esse exemplo = (10x17)+(20x17) = 460 células PLA
• Células PLA são de tamanho aproximado de uma célula de ROM (levemente maior)
ROM vs PLA
501998 Morgan Kaufmann Publishers
• Instruções complexas: o “estado seguinte" é quase sempre o estado atual + 1
Um outro estilo de Implementação
AddrCtl
Outputs
PLA or ROM
State
Address select logic
Op
[5–
0]
Adder
Instruction registeropcode field
1
Control unit
Input
PCWritePCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
IRWrite
MemReadMemWrite
BWrite
511998 Morgan Kaufmann Publishers
DetalhesDispatch ROM 1 Dispatch ROM 2
Op Opcode name Value Op Opcode name Value000000 R-format 0110 100011 lw 0011000010 jmp 1001 101011 sw 0101000100 beq 1000100011 lw 0010101011 sw 0010
State number Address-control action Value of AddrCtl
0 Use incremented state 31 Use dispatch ROM 1 12 Use dispatch ROM 2 23 Use incremented state 34 Replace state number by 0 05 Replace state number by 0 06 Use incremented state 37 Replace state number by 0 08 Replace state number by 0 09 Replace state number by 0 0
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
521998 Morgan Kaufmann Publishers
Microprogramação
• O que são “microinstruções” ?
PCWritePCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWrite
AddrCtl
Outputs
Microcode memory
IRWrite
MemReadMemWrite
RegDst
Control unit
Input
Microprogram counter
Address select logic
Op[
5–
0]
Adder
1
Datapath
Instruction registeropcode field
BWrite
531998 Morgan Kaufmann Publishers
• Uma metodologia de especificação– Apropriado se centenas de opcodes, modos, ciclos, etc.– sinais especificados simbolicamente usando microinstruções
• Duas implementações da mesma arquitetura tem o mesmo microcódigo?
• O que faria um microassembler?
Microprogramação
LabelALU
control SRC1 SRC2Register control Memory
PCWrite control Sequencing
Fetch Add PC 4 Read PC ALU SeqAdd PC Extshft Read Dispatch 1
Mem1 Add A Extend Dispatch 2LW2 Read ALU Seq
Write MDR FetchSW2 Write ALU FetchRformat1 Func code A B Seq
Write ALU FetchBEQ1 Subt A B ALUOut-cond FetchJUMP1 Jump address Fetch
Formato de MicroinstruçãoField 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 andRegDst = 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 thelorD = 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 contentsPCWriteCond 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.
551998 Morgan Kaufmann Publishers
• Sem codificação:
– 1 bit para cada operação do fluxo de dados
– rápido, requer mais memória (lógica)
– Usada para Vax 780 — 400K de memória!
• Muita codificação:
– Enviar as microinstruções através de lógicas para a obtenção dos sinais de controle
– Usa menos memória, lenta
• Contexto histórico do CISC:
– Muita lógica a ser colocada num único chip
– Usar uma ROM (ou mesmo RAM) para manter o microcódigo
– Fácil para adicionar novas instruções
Codificação Maximal vs. Minimal
561998 Morgan Kaufmann Publishers
Microcódigo: compromisso (Trade-offs)
• Vantagens da especificação:
– Fácil de projetar e escrever
– Projetar a arquitetura e o microcódigo simultaneamente
• Vantagens da Implementação (off-chip ROM)
– Fácil de mudar se os valores estão em memória
– Pode emular outras arquiteturas
– Pode fazer uso de registradores internos
• Desvantagens da Implementação, MAIS LENTO que:
– O controle seja implementado no mesmo chip como o processador
– ROM não é mais rápido que RAM
– Quando não existe necessidade para fazer mudanças
571998 Morgan Kaufmann Publishers
Exceções e Interrupções
Exceções e interrupções – são eventos diferentes de branches e jumps que mudam o fluxo normal de execução de instruções.
Exceção – evento inesperado que causa uma mudança no fluxo de controle, que tem origem dentro do processador (por ex. overflow aritmético)
Interrupção –evento inesperado que causa uma mudança inesperada no fluxo de controle, que tem origem fora do processador. (por ex. digitação de um caracter no teclado)
Observação: arquitetura 80x86 (ou IA-32, Intel) usa o termo Interrupção para todos esses eventos.
581998 Morgan Kaufmann Publishers
Exceções e interrupções
TIPO DE EVENTO ORIGEM TERMINOLOGIA
MIPS
Solicitação de dispositivo de E/S
externa interrupção
Chamada do SO pelo programa de usuário
interna exceção
Overflow aritmético interna exceção
Uso de uma instrução indefinida
interna exceção
Mal funcionamento do hardware
ambas exceção ou interrupção
Exemplos:
591998 Morgan Kaufmann Publishers
Como manipular exceções e interrupções
• Ações básicas a serem tomadas pela máquina quando ocorre uma exceção :
1) salvar o endereço da instrução ofendida (instrução atual) num registrador especial EPC (Exception Program Counter).
2) transferir o controle (atualizar o conteúdo de PC) para um endereço específico, que possibilite ao computador executar a rotina de tratamento de exceção.
• ROTINA DE TRATAMENTO DE EXCEÇÃO: depende do tipo de exceção, por exemplo, reportar ao usuário que ocorreu um erro de overflow.
• Ações a serem tomadas após a execução do tratamento de exceção:
- Depende do tipo de exceção: por ex. pode encerrar, ou continuar executanto, o programa que estava executando antes da exceção.
- O EPC é usado para determinar o endereço de reinício da execução.
601998 Morgan Kaufmann Publishers
Como saber a causa da exceção
• Para o computador manipular uma exceção, ele deve conhecer a razão da exceção.
• A razão pode ser obtida de duas formas:
1) usar o registrador de status (cause register) que indica a razão
2) usar interrupção vetorizada, caso em que o endereço de desvio para executar a exceção é determinado pela causa da exceção
611998 Morgan Kaufmann Publishers
Implementação de exceção no MIPS
• Implementação de duas exceções:
1) overflow aritmético
2) instrução indefinida
A causa é determinada pelo valor do registrador CAUSE de 32 bits:
CAUSE = 00 00 00 00 (em hexa), overflow aritmético
CAUSE = 00 00 00 01 (em hexa), instrução indefinida
O endereço da instrução ofendida é guardada em EPC
O endereço de desvio para o início da execução da rotina de tratamento de exceção é dado por C0 00 00 00 (em hexa).
621998 Morgan Kaufmann Publishers
Alterações no fluxo de dados
ALUOut
EPC
EPCWrite
Cause
0
1
CauseWriteIntCause
PCSource
0
1
0
1
2
3
PC
PC+4
ALUOut
JumpAddr
C0 00 00 00
ALU
Sinais de controle adicionais: EPCWrite, CauseWrite, IntCause
Registradores adicionais:EPC, Cause
631998 Morgan Kaufmann Publishers
Alteração na máquina de estado
IntCause=0CauseWrite
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
11
Estado 0
IntCause = 1CauseWrite
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
10
1
overflow
Estado 0
6
Estado 0
7