Capítulo 4

Prévia do material em texto

O Processor 
Sumário 
͍ Introdução 
͍ Caminho da Dados 
͍ Pipeline 
͍ Hazards de Dados e de Controle 
͍ Exceções 
Desempenho 
Contagem de Instruções 
Tempo de Ciclo de Clock 
CPI (no. ciclo 
clock/instrução) 
CPI 
Contagem 
de Instrução Tempo 
de CPU 
(significa o tempo 
que a CPU 
consome 
computando) 
Taxa de 
Clock 
x 
= ____________________ 
Compilador 
Arquitetura do 
Conjunto de 
Instruções 
Processador 
Instrução x ciclo/instrucao 
------- 
 ciclos/segundo (1 Hz = 1 ciclo/s) 
Objetivo 
͍ Entender os princípios e as técnicas utilizadas na 
implementação de um processador 
- caminho de dados 
- unidade de controle 
Implementação MIPS Básica 
͍ Subconjunto do conjunto de instruções MIPS básico 
- instruções de transferência de dados: lw e sw. 
- instruções lógicas e aritméticas: add, sub, and, or e slt. 
- instruções de desvio: beq e j. 
Como o conjunto de instruções determina 
muitos aspectos da implementação? 
Como as diferentes estratégias de 
implementação afetam a velocidade de clock 
e o CPI? 
Torne o caso mais comum mais rápido 
Implementação de 
Instruções 
͍ Etapas comuns para diversas classes de instruções 
1. Buscar a instrução na memória 
2. Ler um ou mais registradores (de acordo com o 
formato da instrução 
͍ As próximas ações dependem da classe da 
instrução 
Execuções Semelhantes 
͍ A simplicidade e a regularidade do conjunto de instruções 
simplifica a implementação 
- mesmo instruções de classes diferente são executadas com 
quase as mesmas ações 
- Exemplo: todas as instruções usam a ALU (exceto jump) 
͍ As execuções necessárias para completar as instruções podem 
ser diferentes: acessar memória ou registrador, incrementar PC em 
4 ou atribuir endereço de desvio, etc. 
͍ OBS.: Contador de programa é um registrador de uma CPU que indica qual é a posição atual na sequência 
de execução de um processo. Ele armazena o endereço da instrução sendo executada ou o endereço da 
próxima instrução. O contador de programa é automaticamente incrementado para cada ciclo de instrução de 
forma que as instruções são normalmente executadas sequencialmente sendo que o contador de programa 
deve ser colocado a zero no inicio da execução do mesmo. 
CPU 
͍ Um CPU é composta basicamente pelos três 
seguintes componentes : 
͍ Unidade lógica e aritmética (ULA ou ALU): executa 
operações lógicas e aritméticas; 
͍ Unidade de controle: decodifica instruções, busca 
operandos, controla o ponto de execução e desvios; 
͍ Registradores: armazenar dados para o 
processamento. 
ULA 
͍ A unidade lógica e aritmética pode realizar diversas 
operações, entre elas: 
͍ Adição Subtração 
͍ Operações lógicas (E, OU, XOR, INVERSÃO) 
͍ Deslocamento (à esquerda e à direita) 
͍ Comparação 
͍ As unidades aritméticas e lógicas mais modernas realizam 
também as operações de multiplicação e divisão. 
͍ As operações são realizadas pela leitura de dois registradores 
fontes do banco de registradores, e com a escrita do resultado 
no registrador de destino. 
Visão abstrata da implementação do subconjunto MIPS com principais 
unidades funcionais e conexões entre elas 
Decodif. instrução 
rs 
rt 
5 bits 
Convenções de 
Lógica Digital 
͍ Tipos de elementos lógicos 
- elemento combinacional (elemento operacional, ex. ALU, porta 
AND) 
- elemento de estado (elemento de memória, ex. registrador ou 
memória) 
͍ Tipos de Sinais 
- sinal de controle (seleção de multiplexador ou operação de uma 
unidade funcional) 
- sinal de dados (informações sobre as quais operam uma unidade 
funcional) 
Metodologia de Clocking 
͍ O método usado para determinar quando os dados 
são válidos e estáveis (em relação ao clock) 
͍ Metodologia de sincronização acionada por 
transição 
- as mudanças de estado ocorrem em uma transição do clock 
- sinal ativo: alto (verdadeiro, 1) 
- sinal inativo: sinal baixo (falso, 0) 
Construindo um 
Caminho de Dados 
͍ Examinar quais os componentes necessários para 
executar cada classe de instrução do MIPS 
- elementos (memória, registrador, somador, ALU) 
- extensão dos barramentos (de dados e controle) 
Buscar uma Instrução 
Buscar uma Instrução 
͍ O processador executa uma instrução em uma série de etapas: 
 – 1. Busca a próxima instrução que está localizada na memória de 
instrução para o registrador ; 
– 2. Atualiza o apontador de instruções (PC) para que ele aponte para 
a próxima instrução a ser executada. 
– 3. Determina o tipo de instrução; 
– 4. Se a instrução faz uso de dados (operandos), determina onde 
estão localizados; 
– 5. Busca os operandos, se houver, para os registradores do 
processador; 
– 6. Executa a instrução; 
– 7. Armazena os resultados nos locais apropriados; 
– 8. Volta ao passo 1 para executar a próxima instrução. 
Instrução do Tipo R 
op rs rt rd shamt func 
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits 
operação 
básica 
(opcode) 
primeiro 
operando 
fonte 
segundo 
operando 
fonte 
registrador 
de destino 
quantidade de 
deslocamento (shift 
amount) 
variante da 
operação 
básica 
͍ Ex: add $t2, $t1, $t0 
͍ add, sub, and, or, slt 
͍ Elementos: banco de registradores e uma ALU 
͍ Sinal de controle de escrita no banco de registradores (ativo para 
que a escrita ocorra na transição do clock) 
32 
Identificação dos registradores = no do registrador 
O registrador Zero se ativa (1) se os registradores comparados forem iguais 
Zero é usado para lógica de controle de desvio 
add 
Load e Store 
͍ Ex: lw $t2, offset_value($t0) ; offset de 16 bits é somado 
com registrador base 
͍ Elementos: banco de registradores, ALU, unidade 
de memória e unidade de extensão do sinal 
op rs rt 
6 bits 5 bits 5 bits 16 bits 
operação 
básica 
(opcode) 
registrado
r base 
registrado
r destino 
constante ou endereço 
As unidades necessárias para implementar loads e stores, além do banco de 
Registradores e da ALU, são a unidade de memória de dados e a unidade de 
extensão de sinal. 
1111 1111 1111 1111 (-1 em complemento de 2, representado em 16 bits), a extensão de 
 sinal transforma este vetor em 1111 1111 1111 1111 1111 1111 1111 1111 (-1 em 
complemento de 2, representado em 32 bits). 
Instrução beq 
͍ beq possui 3 operandos, 2 registradores comparadores e 1 offset 
de 16 bits para calcular o endereço de destino do desvio relativo 
ao endereço da instrução desvio. 
͍ Ex: beq $t2, $t1, offset 
͍ offset é deslocado à esquerda em 2 bits e somado a PC+4 
operação de deslocamento de 2 bits para a esquerda (uma vez que o endereço de salto 
especificado é o endereço de uma palavra de 32 bits, que ocupa 4 células de memória). 
͍ Ações necessárias: calcular o endereço de desvio e comparar os 
registradores 
op rs rt 
6 bits 5 bits 5 bits 16 bits 
operação 
básica 
(opcode) 
registrado
r base 
registrado
r destino 
constante ou endereço 
O caminho de dados para um desvio usando a ALU a fim de avaliar a condição de desvio 
e um somador separado para calcular o destino do desvio como a soma do PC 
incrementado. 
Criando um caminho de 
dados 
͍ O caminho de dados mais simples pode tentar 
executar todas as instruções em um único ciclo de 
clock. 
͍ Operações do tipo R e de acesso a memória são 
parecidas, diferenciando-se em: 
- Em R usa-se a ALU com as entradas vindo de 2 registradores, 
já as de memória também usam a ALU para cálculo do 
endereço. 
- O valor armazenado em um registrador de destino vem da ALU 
(para instrução tipo R) ou da memória (para um load). 
 
0 = instrução aritmética 
1= instruçãoload/store 
0 = instrução 
aritmética 
1= instrução 
load/store 
Visão Geral de Pipelining 
Definição 
͍ Pipelining é uma técnica de implementação em que 
várias instruções são sobrepostas na execução 
- semelhante a uma linha de montagem 
Analogia 
͍ Processo de lavar roupas 
1. colocar a trouxa de roupa suja na lavadora; 
2. colocar a trouxa de roupa molhada na secadora; 
3. passar a roupa; 
4. arrumar as roupas no guarda-roupa. 
Lavagem de roupa com pipelining 
Visão geral do Pipeline 
Performance: 
• 8 horas/3,5 horas = 2,3 
 
Pipeline e 2,3 vezes mais rápido!!! 
 
E agora se o total de roupas for dividido em 20 cargas, 
sendo que estagio continua com o periodo de 30 minutos, 
quanto mais rápido será o uso do pipeline? 
R.: Sem pipeline gastaríamos 20 x 2 horas/carga = 40 horas 
R.: Com pipeline gastaríamos: 
 1a. Carga = 2 horas 
19 cargas restantes a cada meia hora: 19 * 0,5 = 9,5 horas 
-> Total = 11,5 horas 
 Performance = 40/11,5 ≈ 3,5 
Desempenho 
͍ O uso de pipeline não diminui o tempo de execução 
de uma instrução, mas aumenta a vazão do sistema 
- uso dos recursos em paralelo aumenta o número de 
tarefas executadas em um determinado período de tempo 
͍ Se todos os estágios demoram o mesmo tempo e 
há recursos suficientes, então o ganho de 
velocidade é aproximadamente igual ao número de 
estágios do pipeline 
- a lavanderia com pipeline é potencialmente 4 vezes mais 
rápida do que a sem pipeline 
Conceitos Básicos 
͍ Estágio: cada etapa da execução de uma tarefa 
- deve haver recursos separados para cada estágio do 
pipeline 
͍ Pipeline cheio: é quando todos os estágios estão 
operando simultaneamente 
Pipeline no MIPS 
͍ O MIPS usa pipeline para execução das instruções. 
1. Buscar instrução na memória 
2. Decodificar a instrução e ler registradores 
3. Executar uma operação lógica ou aritmética ou calcular 
um endereço. 
4. Acessar um operando na memória de dados 
5. Escrever o resultado em um registrador 
1. IF (instruction Fetch): buscar a instrução na memória 
2. ID (instruction decode): decodificar a instrução e ler 
registradores 
3. EX: executar uma operação lógica ou aritmética 
4. MEM: acessar uma posição de memória 
5. WB (write back): escrever o resultado em um registrador 
Exemplo 
͍ Compare o tempo médio de entre as instruções de: 
- uma implementação em ciclo único (todas as instruções 
demoram um ciclo de clock; o ciclo precisa ser esticado 
para acomodar a instrução mais lenta) 
- implementação com pipeline (5 estágios) 
͍ Tempo de operação das unidades funcionais: 
- 200ps (ciclo de clock) para acesso à memória 
- 200ps para operação com ALU 
- 100ps para leitura e escrita em registrador 
Tempo total para cada instrução 
ciclo de clock = 800ps 
tempo entre o fim da primeira e da quarta 
instrução é de 2400ps 
Registrador $1 recebe (base do array A) A[25] 
rs rt 
Um ciclo de clock para cada estágio do pipeline: 200ps 
• tempo entre o fim da primeira e da quarta 
instrução é de 600ps 
• na média, uma instrução é completada a 
cada ciclo de clock de 200ps 
Hazards de Pipeline 
͍ Hazards são situações em pipelining em que a 
próxima instrução não pode ser executada no ciclo 
de clock seguinte 
͍ Tipos: 
- Hazards estruturais 
- Hazards de dados 
- Hazards de controle 
Hazard Estrutural 
͍ É quando o hardware não suporta a combinação de 
instruções que queremos executar no mesmo ciclo 
de clock 
Hazard de Dados 
͍ É uma ocorrência em que uma instrução planejada 
não pode ser executada no ciclo de clock correto 
porque os dados necessários para executar a 
instrução ainda não estão disponíveis 
- quando o pipeline precisa ser interrompido porque uma 
etapa precisa esperar até que outra seja concluída. 
add $s0, $t0, $t1 
sub $t2, $s0, $t3 
Possíveis Soluções 
͍ Compiladores podem ajudar! 
͍ Forwarding (ou bypassing) 
- recurso de hardware que permite disponibilizar o item 
que falta antes do estágio previsto (não é preciso 
esperar que a instrução termine) 
Exemplo 
add $s0, $t0, $t1 
sub $t2, $s0, $t3 
Quais estágios do 
pipeline estariam 
conectados pelo 
forwarding? 
- o caminho de forwarding só é válido se o estágio de 
destino estiver mais adiante no tempo do que o estágio 
de origem 
lw $s0, 20($t1) 
sub $t2, $s0, $t3 
pipeline stall (bolha): atrasar um estágio 
Exercício 
͍ Considere o seguinte segmento de código em 
C 
a = b + c 
d = b + e 
… 
e 
d 
c 
b 
a endereço base ($t0) 
- Qual o código MIPS ? 
Exercício 
- Encontre hazards de dados e 
reordene as instruções para evitar 
pipeline stalls. 
- Teste esses códigos no simulador. 
Exercício 
lw $t1, 4($t0) 
lw $t2, 8($t0) 
add $t3, $t1,$t2 
sw $t3, 0($t0) 
lw $t4, 16($t0) 
a = b + c 
d = b + e 
add $t3,$t1,$t4 
sw $t3, 12($t0) 
. 
. 
Exercício 
lw $t1, 4($t0) 
lw $t2, 8($t0) 
add $t3, $t1,$t2 
sw $t3, 0($t0) 
lw $t4, 16($t0) 
a = b + c 
d = b + e 
add $t3,$t1,$t4 
sw $t3, 12($t0) 
. 
. 
conflito!! 
Exercício 
lw $t1, 4($t0) 
lw $t2, 8($t0) 
add $t3, $t1,$t2 
sw $t3, 0($t0) 
lw $t4, 16($t0) 
a = b + c 
d = b + e 
add $t3,$t1,$t4 
sw $t3, 12($t0) 
. 
. 
conflito!! 
Exercício 
lw $t1, 4($t0) 
lw $t2, 8($t0) 
add $t3, $t1,$t2 
sw $t3, 0($t0) 
lw $t4, 16($t0) 
Existe conflito?? 
No Mars ...sem pipeline 
No Mars ...sem pipeline 
Observações do syscall..... 
 li $v0, 1 # system call code for print_int 
Hazard de Controle 
͍ Também denominado hazard de desvio 
͍ É quando a instrução seguinte não pode ser 
executada no devido ciclo de clock do pipeline 
porque a instrução buscada não é aquela 
apropriada 
- Surge da necessidade de tomar uma decisão com base 
no resultado de uma instrução 
- o pipeline possivelmente não saberá qual deve ser a 
próxima instrução. 
pipeline stall? 
Previsão de Desvio 
͍ Previsão de que o desvio não será tomado 
͍ Previsão de que alguns desvios serão tomados 
- ex. laços (desvios para endereços anteriores são tomados) 
͍ Previsores de hardware dinâmicos (precisão > 90%) 
- histórico recente para prever o futuro 
͍ Delayed branch (desvio adiado), usado no MIPS 
Exceções 
͍ Exceção: evento não programado que interrompe o 
fluxo de execução do programa, ocorre dentro do 
próprio programa, como divisão por zero. 
͍ Interrupção: uma exceção que vem de fora do 
processador (ex. de dispositivos de E/S) e a CPU 
trata. 
Desafios 
͍ O Controle é o aspecto mais desafiador do projeto 
de um processador 
- implementar exceções e interrupções 
͍ Detectar condições excepcionais e tomar as ações 
apropriadas 
- aspecto crítico de temporização (influencia no tempo do ciclo 
de clock) 
- identificar as exceções em tempo de projeto 
Tratamento de Exceções 
(MIPS) 
͍ Tipos de exceção 
- Instrução indefinida 
- Overflow Aritmético 
͍ Ações tomadas: 
- Salvar o endereço da instrução que causou a exceção no 
PC de Exceção (EPC — Exception Program Counter) 
- Transferir o controle (fluxo de execução) para o sistema 
operacional em algum endereço especificado 
Rotinas de Tratamento 
͍ Fornecer algum serviço ao programa do usuário 
͍ Tomar alguma ação predefinida em resposta a um 
overflow 
͍ Terminar a execução do programa e informar um 
erro 
Após realizar as ações necessárias, o sistema 
operacional pode terminar ou continuar (EPC) a 
execução do programa