Introducao Pipeline

Universidade Federal de Ouro Preto
Departamento de Computação e Sistemas - DECSI
Organização e Arquitetura de Computadores II (CEA 509)

Introdução e Pipeline
Vicente Amorim
vicente.amorim.ufop@gmail.com
www.decom.ufop.br/vicente
Sumário
* Introdução
* Caminho de Dados
* Organização em multiciclos
* Pipelining
* Caminho de dados e controle com pipeline
* Detecção e Tratamento dos Conflitos

Introdução
Introdução
* Anteriormente
- Em OACI:
★ Como calcular o desempenho de um computador: número de
instruções, tempo de cada ciclo de clock, número de ciclos de
clock gastos por cada instrução (CPI).
★ Número de instruções de um programa é determinado pelo

compilador e pela arquitetura do conjunto de instruções.
★ Entretanto, modo como foi implementado o hardware (CPU)

define o tempo de cada ciclo de clock e CPI.
Introdução
* Anteriormente
- Em OACI:
★ Formatos de instruções conhecidos até agora:
Introdução
* Anteriormente
- Exercício 1: Converter as seguintes instruções para binário.
. Traduzindo:
✓op de lw = 35; reg. $t1 = 9; reg. $t0 = 8; offset = 300 x 4 = 1200;
✓op de add = 0; funct = 32; reg. $t0 = 8; reg. $s2 = 18;
✓op de sw = 43;
Introdução
* Anteriormente
- Exercício 1: Converter as seguintes instruções para binário.
. Equivalente em binário:
. Diferença entre as instruções lw e sw é 1 bit (em destaque).
. Similaridade entre as instruções facilitam o projeto de hardware.
Introdução
* Agora
- Em OACII:
★ Construção do caminho de dados;
★ Construção da unidade de controle;
★ Explicação das técnicas e princípios utilizados na construção
de uma CPU;
★ Paralelismo em nível de software e hardware;
★ Linguagens de descrição de hardware;
★ Sistemas de armazenamento e E/S.
Introdução
* Agora
- Inicialmente, máquina com implementação básica do MIPS:
★ Instruções de acesso a memória: lw e sw.
★ Instruções aritméticas/lógicas: add, sub, and, or e slt.
★ Instruções de branch e jump: beq e j.
★ Implementação do restante das instruções é similar.

★ Examinar a implementação de cada instrução permite
entender o funcionamento interno da máquina.
Introdução
* Visão Geral
- Independente da instrução a ser executada, dois primeiros passos
são comuns:
★ Envio do valor do contador de programa (PC)* para a memória
que contém o código e fazer o carregamento da instrução.
★ Leitura dos registradores:
• Ler um ou dois registradores à partir dos campos descritos na
instrução.
• lw precisa ter somente um registrador lido enquanto add, sub, etc
precisam ter dois.
* PC (program counter): registrador que contém o endereço de memória da instrução a ser executada.
Introdução
* Visão Geral
- Após dois primeiros passos, ações são específicas para cada tipo
de instrução.
- Simplicidade e regularidade favorecem implementação:

★ Ações a serem tomadas se diferem pela classe de cada
instrução: acesso a memória, aritméticas e lógicas, e desvio.
- Após execução da instrução, PC é incrementado em 4* e

próxima instrução entra na máquina para ser executada.
* 4 bytes (1 word / 32 bits): Tamanho de cada instrução na máquina MIPS.
Introdução
* Visão Geral
- Resumo da interconexão entre os principais elementos da
máquina MIPS (unidade de controle não descrita):
Introdução
* Visão Geral
- Resumo da interconexão entre os principais elementos da
máquina MIPS:
Introdução
* Visão Geral
- Implementação MIPS é composta por dois tipos de elementos
lógicos:
★ Combinacionais: Saídas dependem exclusivamente das entradas
providas - ULA, multiplexers, etc.
★ De estado: Internamente possuem algum mecanismo de

armazenamento de estado (valores) - banco de registradores,
memória de instruções, etc.
★ Ambos obedecem ao ciclo de clock.
Introdução
* Visão Geral
- Exemplos elementos combinacionais e de estado:
Introdução
* Visão Geral
- Regime de clock / temporização:
★ Define quando os sinais dos componentes podem ser lidos e
quando devem ser escritos.
★ Importante definir quando um elemento pode ser escrito / lido:
• A leitura e escrita simultâneas de um sinal podem causar
inconsistências indesejáveis.
★ Escritas são feitas ao final do ciclo de clock enquanto que
leituras no início.
Introdução
* Visão Geral
★ Como saber quando um valor deve ser escrito em um dado
elemento? (registradores, por exemplo)
• Cada registrador possui um “sinal de carga” particular que é
ativado com lógica direta.
• Registradores são “disparados” pela borda ascendente do

relógio.
• Quando CK=up, se cargaR1=1, então

R1<-entradas.
Introdução
* Visão Geral
★ Metodologia de baseada nos sinais de borda do clock, permite
que em um mesmo ciclo de clock:
• Execução de leitura do dado armazenado em um registrador;
• Envio do valor através de alguma lógica combinacional

previamente criada em hardware; e
• Escrita do valor de volta no próprio registrador.
Caminho de Dados
Caminho de Dados
* Criação do Caminho de Dados
- Como construir uma máquina capaz de executar instruções
MIPS?
- Dados das instruções devem passar por cada componente de

hardware relacionado até sua execução completa.
- Além de entrada e saída de dados, cada componente necessita

também de sinais de controle que dirão o que o mesmo “deve”
fazer.
Caminho de Dados
- Instruções são executadas em diversos passos diferentes:
1) Busca de instrução;
2) Decodificação da instrução:
3) Execução da operação: Instruções do tipo r
4) Acesso à memória: Instruções load / store
5) Escrita de registrador (instrução load)
Caminho de Dados
- Qualquer instrução é executada em um único ciclo de relógio.
- O período do relógio será longo o suficiente para acomodar

qualquer instrução:
* Na verdade, o período de relógio será em função da instrução mais
demorada.
Caminho de Dados
* Elementos Básicos
- Elementos necessários para a Busca da Instrução:
* Memória onde estão armazenadas as instruções;
* O contador de programa (PC) para saber a instrução a ser
executada;
* Um somador para calcular o endereço da próxima instrução.
Caminho de Dados
- Elementos necessários para a Busca da Instrução:
* Contador de programa (PC)
contém o endereço da instrução
em execução.
* Endereço da próxima instrução é

obtido pela soma de 4 posições ao
contador de programa.
* A instrução lida é usada por outras

partes do bloco operativo.
Caminho de Dados
- Simulação
Caminho de Dados
- Elementos necessários para instruções do tipo R:
* Banco de registradores para armazenar os operandos e o
resultado das operações.
* Uma Unidade Lógica e Aritmética (ULA) que será utilizada para
realizar as operações.
Caminho de Dados
* A instrução (fornecida pelo hardware de busca da instrução)
contém o endereço de três registradores.
* Dois destes registradores são lidos e passados para a ULA

realizar a operação.
* O resultado é armazenado em um terceiro registrador.
* O controle da ULA determina qual operação será realizada (à

partir do campo funct da instrução).
Caminho de Dados
Caminho de Dados
- Simulação
Caminho de Dados
- Elementos necessários para instruções lw e sw:
* Memória de dados;
* Módulo de extensão de sinal;
* Banco de registradores (já mostrado);
* Uma ULA (já mostrada).
Caminho de Dados
- Combinando os elementos para a escrita em memória (sw):
* Endereço de escrita é obtido pela soma de um registrador
base (registrador 1) com um deslocamento de 16bits estendido
para 32bits.
* O registrador 2 é escrito na memória.
4
Caminho de Dados
- Combinando os elementos para a leitura da memória (lw):
* Semelhante ao processo de escrita.
* Diferença básica é a existência de um caminho para escrever o
valor lido no banco de registradores.
4
Caminho de Dados
- Elementos necessários p/ se executar um beq (branch on equal):
* Comparar dois registradores utilizando o bloco ULA (através
da subtração);
* Se ocorrer desvio, o endereço do desvio será: PC

+4+deslocamento;
* O deslocamento deve ser estendido para 32 bits (pois possui

inicialmente 16 bits).
Caminho de Dados
- Elementos necessários p/ se executar
um beq (branch on equal):
Caminho de Dados
- Nesta versão do bloco operativo qualquer instrução executa em
um ciclo de clock.
- Período do relógio deverá ser suficientemente longo para
acomodar a instrução mais demorada.
- Durante a execução de qualquer instrução, cada unidade
funcional poderá ser utilizada uma única vez.
- Resultado: Necessário uma memória de instruções e outra
memória de dados.
- Quando combinando os módulos, muitas unidades funcionais
poderão ser compartilhadas.
Caminho de Dados
* Elementos Básicos: Combinando os módulos
• sw: Campo rt (bits 20-16) designa registrador cujo conteúdo será escrito na
memória de dados.
• lw: Campo rt (bits 20-16) designa registrador no qual será carregado o valor
lido da memória de dados.
Caminho de Dados
* Elementos Básicos: Combinando os módulos
4
• Instruções do tipo R: Endereço do registrador a ser escrito está no campo rd

(bits 15-11).
Caminho de Dados
- Acrescentando os recursos para a busca de instrução e cálculo do
próximo endereço.
Caminho de Dados
- Acrescentando os recursos para a busca de instrução e cálculo do
próximo endereço.
Caminho de Dados
- Ao final de cada ciclo do relógio o PC é carregado com um
novo valor;
- Mudança no valor do PC se propaga através de uma grande

lógica combinacional.
• Memória de instruções -> banco de registradores -> ULA ->
memória de dados -> banco de registradores.
- Período do ciclo do relógio deve ser maior que o atraso

máximo de propagação através da lógica combinacional.
Caminho de Dados
* Esquema Simples de Implementação
- Caminho de dados anterior pode ser utilizado para criação da
máquina mínima MIPS.
- Implementação cobre as instruções: lw, sw, beq, add, sub, AND, OR e

slt.
- Posteriormente serão incluídas as alterações para suporte as

instruções do tipo j.
- Os componentes listados anteriormente ainda não tornam a

máquina funcional o bastante para executar sozinha tais instruções
Caminho de Dados
- Componente controle da ALU
★ Sinal de controle com 4 bits.
★ Possíveis valores:
★ Dependendo da instrução a ser processada, a ALU deverá

executar uma das 6 operações acima.
Caminho de Dados
★ É possível gerar os 4 bits de controle da ALU à partir de uma
unidade de controle que possui como entradas:
• Campo “function” da instrução; e
• 2 bits adicionais de controle (ALUOp).
★ ALUOp indica o tipo de operação a ser realizada.
★ A saída da unidade de controle da ALU (não ALUOp)

é um sinal de 4 bits que diretamente controla a ALU.
Caminho de Dados
★ Abaixo uma descrição de como é dado o controle do sinal
ALUOp e da própria ALU:
Caminho de Dados
- A unidade de controle principal
★ Tipos de instruções suportadas até agora:
Caminho de Dados
★ Caminho de dados atual com todos os multiplexadores e
sinais:
Caminho de Dados
Caminho de Dados
★ Exceto o PCSrc, a unidade de controle principal é a responsável
por controlar todos os sinais.
★ O valor da saída “zero” da ALU é utilizado para auxiliar na

seleção do valor de PCSrc.
★ Unidade de controle principal pode ser representada como um

único componente capaz de controlar todos os sinais da máquina.
★ O valor de cada sinal de controle depende exclusivamente do

valor contido no campo “opcode” (bits 26 a 31).
Caminho de Dados
Caminho de Dados
★ Uso dos sinais de controle por cada uma das instruções:
Caminho de Dados
- Execução de instruções do tipo-R (Ex.: add $t1, $t2, $t3)
1. Instrução é carregada e valor de PC é incrementado;
2. Dois registradores ($t2 e $t3) são lidos; unidade de controle

principal configura os valores dos sinais a serem utilizados;
3. ALU faz a operação nos dados lidos dos registradores usando os

bits de função (bits 5:0 - campo funct.);
4. Resultado do cálculo executado pela ALU é escrito no

registrador $t1 (bits 15:11)
Caminho de Dados
Caminho de Dados
- Execução de instruções de acesso a memória (Ex.: lw $t1,off($t2))
2. O valor do registrador é lido do banco de registradores ($t2);
3. ALU computa a soma do valor lido do registrador $t2 com o
valor do offset (off) extendido de 16 para 32 bits;
4. O resultado da soma executada na ALU é utilizado como
endereço de entrada para memória de dados;
5. Dado lido da memória é escrito no registrador ($t1, dado pelos

bits 20:16 da instrução).
Caminho de Dados
Caminho de Dados
- Execução de instruções de desvio condicional (Ex.: beq $t1,$t2,off)
2. Dois registradores ($t1e $t2) são lidos do banco de
registradores;
3. ALU faz uma subtração dos valores contidos em $t1e $t2. O
valor de PC + 4 é adicionado aos 16 bits menos significativos
(estendidos) da instrução (off), posteriormente shiftados de dois
bits; o resultado é o endereço-alvo do branch.
4. O sinal “zero" da ALU é utilizado para se decidir qual será o
novo valor a ser armazenado dentro do PC.
Caminho de Dados
Caminho de Dados
- Finalizando implementação da unidade de controle principal
★ Unidade de controle pode ser mapeada através de suas E/Ss.
Caminho de Dados
- Implementando Jumps
★ Implementação das instruções de desvio incondicional (jump)
se assemelham com as de desvio incondicional (branch).
★ Cálculo do novo valor de PC é feito de forma incondicional.
★ Formato das instruções tipo j:
Caminho de Dados
- Implementando Jumps
★ 32 bits do endereço final (PC) são compostos por:
• 4 bits mais significativos do PC+4 (31:28);
• 26 bits do campo de endereço da instrução jump (25-0); e
• 2 bits (00).
★ Para suporte a jumps máquina precisa receber um
multiplexador adicional como forma de selecionar o valor correto
de PC.
★ Consequentemente, um novo sinal de controle também deverá
ser utilizado (jump).
Caminho de Dados
Caminho de Dados
Caminho de Dados
* Características principais:
-> Cada instrução executa em um ciclo de clock.
-> Período do relógio é determinado pela instrução mais lenta.
* Problema: Recursos de hardware não podem ser reaproveitados:

-> Duas memórias: Instrução e Dados.
-> ULA (unidade lógica e aritmética).
-> Dois somadores.
* Conclusão: Desperdício de hardware.
Caminho de Dados
- Conclusões
★ Máquina proposta até aqui executa qualquer das instruções em
apenas um ciclo de clock.
★ Por que tal tipo de implementação não é atualmente utilizada?

• Ineficiente;
• Ciclo de clock precisa ser grande o suficiente para acomodar
a instrução mais demorada (lw);
• Todas as instruções passam a ter o tempo de execução igual
ao pior caso.
• Solução: Organização em multiciclos para permitir o pipeline.
Exercícios
* Exercícios
1) Descreva o papel do registrador PC e como o mesmo
funciona.
2) No que diferem os elementos “Combinacionais" dos “De

estado”? Explique ainda como os mesmos se relacionam com o
período de clock do hardware.
3) Apresente os cinco passos - e suas ações - necessários para a

execução de uma instrução assembly MIPS.
4) Qual o papel da unidade de controle em uma máquina MIPS?
Exercícios
* Exercícios
5) Execute a instrução add $t0, $t1, $t2 na máquina
apresentada à seguir. Deixe claro os valores de cada elemento
na mesma.
Exercícios
* Exercícios
6) Descreva a razão pela qual três das entradas do componente
“banco de registradores” podem ser especificadas utilizando-se
somente 5 bits.
Organização em Multiciclos
* Introdução
- Instruções são divididas em etapas.
- Cada etapa executa em um único ciclo de clock.
- Período do relógio é determinado pela etapa mais lenta.
- Cada instrução executa em um número apropriado de ciclos do

relógio (proporcional ao número de etapas).
* Introdução
- Recursos de hardware podem agora ser reaproveitados:
★ Redução no custo do bloco operativo. :-D
★ Aumento na complexidade do bloco de controle. :-(
- Agora temos:
★ Única memória para instrução e dados.
★ Apenas uma ULA (sem necessidade de somadores extras).
* Introdução
- Agora temos:
★ Inserção de registradores (internos) para reter as saídas das
unidades funcionais (exigência do regime multiciclo):
✦ Dados a serem utilizados na mesma instrução em ciclos de relógio

posterior;
✦ Dados a serem utilizados em instruções posteriores ->

Armazenados em elementos de memória invisíveis ao programador.
* Introdução
- Novos registradores (não visíveis ao programador):
★ Registrador de instrução (IR);
★ Registrador de Dados da Memória (MDR);
★ Registradores A e B para armazenar os dados lidos do banco de

registradores;
★ Registrador ULASaída.
(IR)
(MDR)
* Warning: Todos os registradores acima (exceto IR) armazenam dados somente

entre as bordas de relógio adjacentes e portanto, não necessitam de sinal de escrita,
somente sinal de clock.
* Registradores são barreiras temporais:
* Introdução
- Com a utilização dos novos registradores tem-se então uma
separação mais clara do que é feito em cada ciclo.
- Fases de execução de uma instrução podem ser claramente

observadas.
* Registradores são barreiras temporais:
* Características do Bloco Operativo Multiciclos
- Acréscimo de recursos para suportar jump e branch on equal:
★ Três possíveis fontes para o valor de PC:
1 - O resultado de PC+4, disponível na saída da ULA: Este valor

sempre será armazenado no PC;
2 - O conteúdo do ULASaída: Este registrador armazena o

endereço-alvo do desvio condicional, após este ter sido calculado
pela ULA (beq);
- Acréscimo de recursos para suportar jump e branch on equal:
★ Três possíveis fontes para o valor de PC:
3 - Os 26bits menos significativos do IR, deslocados à esquerda e

concatenados com os 4 bits mais significativos do PC
incrementado (jump).
* Ciclos (resumo)
- Busca da Instrução
- Decodificação da instrução
★ Leitura dos registradores - mesmo que não sejam utilizados.
★ Cálculo do endereço do branch - mesmo que a instrução não
seja de branch.
- Execução da operação:
★ Cálculo do endereço efetivo do operando - Instruções load/store
★ Determinar se branch deve ser executado - Instrução branch.
* Ciclos (resumo)
- Acesso à memória - Instruções load / store
★ Escrita / leitura na/da memória;
★ Escrita de registrador - Instruções do tipo R.
- Escrita de registrador - Instrução load.
* Ciclos (resumo)
- Execução de Instruções
1. Busca da instrução (e incremento do PC).
★ RI = Mem[PC];
PC = PC + 4.
★ Duas operações acima ocorrem em paralelo.
* Ciclos (resumo)
2. Decodificação (Geração dos Sinais de Controle) e Leitura de Rs e
Rt.
★ A = Reg[RI[25-21]];
B = Reg[RI[20-16]];
ULASaída = PC + (extensão de sinal (RI[15-0]) << 2)
★ Operações acima ocorrem em paralelo.
* Ciclos (resumo)
* Ciclos (resumo)
3. Execução da Instrução:
★ Referência à memória:
• ULASaída = A + extensão de sinal(RI[15-0]);
★ Tipo R
• ULASaída = A op B.
* Ciclos (resumo)
3. Execução da Instrução:
★ Desvio Condicional
• Se (A == B) então PC = ULASaída;
• Usar a ULA para fazer A-B, porém sem escrever em ULASaída).
★ Desvio Incondicional
• PC = PC[31-28] || (RI[25-0] << 2);
* Ciclos (resumo)
* Ciclos (resumo)
* Ciclos (resumo)
* Ciclos (resumo)
* Ciclos (resumo)
4. Final da Execução de sw e Tipo R:

★ lw:
• RDM = Mem[ULASaída].
★ sw
• Mem[ULASaída] = B.
★ Tipo R
• Reg[RI[15-11]] = ULASaída.
* lw
* Ciclos (resumo)
5. Final da execução de lw
★ lw:
• Reg[RI[20-16]] = RDM.
* Comparativo do número de passos
Pipelining
Pipelining
* Introdução
- Pipeline é a implementação de uma técnica na qual múltiplas
instruções são sobrepostas na execução.
- Atualmente é amplamente adotada pelo mercado.
- Objetiva principalmente a entrega/finalização da execução de um

maior número de instruções no mesmo período de tempo.
- Extensão dos conceitos de uma lavanderia.
Pipelining
* Introdução
- Uma lavanderia sem pipeline:
★ Tempo total: 8h
★ Tempo entre início de duas mudas de roupa: 2h
Pipelining
* Introdução
- Uma lavanderia com pipeline:
★ Tempo total: 3.5h

★ Tempo entre início de duas mudas de roupa: 0.5h
Pipelining
* Introdução
- Modelo com pipeline toma muito menos tempo e faz um melhor
uso dos recursos disponíveis.
- Uma vez que a primeira carga de lavagem é terminada e

colocada na secadora, uma segunda carga já pode ser colocada no
primeiro estágio.
- Pensamento se repete aos estágios seguintes.
Pipelining
* Introdução
- Paradoxo do pipeline:
★ O ganho do pipeline não está na redução do tempo de
execução de cada um dos estágios.
★ Ganho do pipeline está na utilização em paralelo de todos os

estágios da máquina.
★ Pipeline aumenta a vazão do sistema como um todo: Primeira

carga leva o mesmo tempo nas duas versões.
Pipelining
* Introdução
- “Se todos os estágios levam a mesma quantidade de tempo, a
melhoria do sistema devido ao pipeline é igual ao número de estágios
do sistema.”
★ Quanto maior o tempo executando em pipeline, maior o
ganho.
★ Exemplo 1: 5 Tarefas
• Sem pipeline: 20 slots de tempo.
• Com pipeline: 8 slots de tempo.
• Ganho: 20/8 = 2,5
Pipelining
* Introdução
★ Exemplo 2: 10 Tarefas
• Sem pipeline: 40 slots de tempo.
• Com pipeline: 13 slots de tempo.
• Ganho: 40/13 = 3,077
- Se o número de tarefas é muito grande, então todos os estágios

ficarão cheios por muito tempo - fazendo com que o ganho se
aproxime de 4.
Pipelining
* Introdução
- Mesmos princípios da lavanderia se aplicam aos processadores:
- Instruções em MIPS normalmente levam 5 estágios para serem
executadas:
1. Busca da instrução.
2. Decodificação e leitura dos registradores.
3. Execução da operação ou cálculo do endereço.
4. Acesso ao operando na memória de dados.
5. Escrita do resultado em um registrador.
Pipelining
* Introdução
- Exemplo 3: Comparar o tempo de execução da versão
monociclo do MIPS com o tempo da versão pipeline. Considerar:
★ Execução sequencial de três instruções lw; e
★ Tabela de tempos nas unidades funcionais (abaixo).
Pipelining
* Introdução
24/14 = 1.7
Pipelining
* Introdução
- Se os estágios de um pipeline forem balanceados, então:
- Condições ideais, portanto, dificilmente atingidas!
- Costuma-se dizer que o ganho máximo teórico de um pipeline é

igual ao número de estágios do mesmo.
Pipelining
* Introdução
- Motivos pelos quais o ganho teórico não é atingido:
★ Os estágios de um pipeline não são perfeitamente
balanceados;
★ Existe um overhead referente ao preenchimento do pipeline.
- Em função do segundo motivo, o tempo entre instruções é mais

importante do que o tempo total.
Pipelining
* Introdução
- Exemplo 4: Ainda em relação à tabela do exemplo 3, considere
que agora existam 1003 instruções lw seguidas.
Qual será o tempo total em cada caso (monociclo e pipeline) e

qual será o ganho obtido pelo uso do pipeline?
Pipelining
* Introdução
Pipelining
* Introdução
- Exemplo 4:
★ Sem pipeline: 24ns + 1000 * 8ns = 8024ns.

★ Com pipeline: 10ns + 1002 * 2ns = 2014ns.
★ Ganho = 8024ns / 2014ns = 3,98
★ O pipeline aumenta o desempenho por meio do aumento na
vazão das instruções - e não através do aumento de velocidade
no processamento de cada instrução.
Pipelining
* Conceitos Básicos
- Facilidade de implementação do pipeline em MIPS (vs. x86):
★ Todas as instruções possuem o mesmo tamanho (32 bits):
Facilidade no carregamento e decodificação das instruções.
★ Poucos formatos de instruções: Permite carregar os

registradores enquanto instrução ainda está sendo decodificada.
★ Operandos de memória aparecem somente nas instruções

load/store: Estágio já existente pode ser utilizado para o calc. end.
★ Operandos estão alinhados na memória: Com somente um

acesso os dados são lidos e carregados.
Pipelining
* Hazards
- Durante o pipeline, determinadas situações impedem que a
próxima instrução comece a executar já no próximo ciclo de clock.
- Tais eventos são comumente conhecidos como hazards:

★ Hazards estruturais;
★ Hazards de dados; e
★ Hazards de controle.
Pipelining
* Hazards
- Hazards estruturais
★ Hardware não pode suportar a combinação de instruções a
serem executadas em um mesmo ciclo de clock.
★ Na analogia da lavanderia: Como se a lavagem e secagem das

roupas fôsse um único estágio.
★ Sem dois blocos de memória, o pipeline em MIPS também
seria impossível.
• Por que?
Pipelining
* Hazards
- Hazards de dados
★ Ocorre quando o pipeline necessita parar para aguardar que
um estágio anterior seja completado.
★ Aparecem à partir da dependência de uma instrução atual por

uma anterior ainda não finalizada.
★ Ex.: Qual o problema do trecho de código abaixo?

add $s0, $t0, $t1
sub $t2, $s0, $t3
Pipelining
* Hazards
- Hazards de dados
★ Se não houver uma intervenção, um hazard de dados pode
chegar a interromper o pipeline.
★ A instrução add não escreverá seu resultado no registrador

até que a mesma tenha sido finalizada.
★ Em determinadas situações, compiladores podem ajudar na

resolução de hazards de dados.
★ Entretanto, nem sempre compiladores são tão espertos.
Pipelining
* Hazards
- Hazards de dados
★ Como resolver?
• Com ajuda do compilador (já citado).
• Utilização de hardware adicional:
✓ Adiantamento (forwarding): Resultado disponibilizado pela ALU
pode ser adiantado como entrada para a próxima instrução.
• Para analisar o que realmente acontece utilizaremos o seguinte
esquema gráfico: add $s0, $t0, $t1
Esc
a
rit
tur
a
L ei
Pipelining
* Hazards
- Hazards de dados
★ Como resolver?
• Alteração do hardware
Pipelining
* Hazards
- Hazards de dados
★ Como resolver?
• Importante: Técnica do adiantamento em hardware só válida se
estágio destino está temporalmente após estágio fonte.
• Ex. 1: Saída do bloco de memória de uma instrução não pode

ser ligada à entrada do bloco de execução de uma instrução
subsequente:
• Ex. 2: O que acontece no seguinte cenário?
lw $s0, 20($t1)
sub $t2,$s0,$t3
Pipelining
* Hazards
- Hazards de dados
★ Como resolver?
• Pior solução (temporariamente):
pipeline
stall
Pipelining
* Hazards
- Hazards de dados
★ Exercício: Considerando o trecho de código MIPS a seguir:
a) Solucione os possíveis hazards existentes.
b) Em número de ciclos, qual foi o ganho se compararmos o
código original com o melhorado?
lw $t1, 0($t0)
lw $t2, 4($t0)
add $t3, $t1, $t2
sw $t3, 12($t0)
lw $t4, 8($t0)
add $t5, $t1, $t4
sw $t5, 16($t0)
Pipelining
* Hazards
- Hazards de dados
★ Resposta:
lw $t1, 0($t0) IF-ID-EX-ME-WB
————— STALL ————— ———— STALL ————
————— STALL ————— ———— STALL ————
add $t3, $t1, $t2 IF-ID-EX-ME-WB
————— STALL ————— ———— STALL ————
sw $t3, 12($t0) IF-ID-EX-ME-WB
————— STALL ————— ———— STALL ————
————— STALL ————— ———— STALL ————
————— STALL ————— ———— STALL ————
• Total sem otimização do código:

17 ciclos
Pipelining
* Hazards
- Hazards de dados
★ Resposta:

————— STALL ————— ———— STALL ————
————— STALL ————— ———— STALL ————
• Total com otimização do código:

13 ciclos
Pipelining
* Hazards
- Hazards de controle
★ Ocorrem devido a capacidade do código de tomar diferentes
caminhos de execução conforme as entradas.
★ Diretamente associados as instruções de desvio condicional
(beq, bne, etc).
★ Dependendo do resultado de uma comparação, trechos A
“ou” B do código podem ser executados.
★ Caso ainda mais problemático: Por se desconhecer qual a
próxima instrução a ser executada, nem o primeiro estágio (IF)
poderia ser “adiantado”.
Pipelining
* Hazards
★ Considerando a existência de hardware especial que
possibilitasse a tomada de decisão já no segundo estágio do
pipeline:
Pipelining
* Hazards
★ Caso hardware especial não esteja disponível para cálculo no
segundo estágio:
• Stall ainda mais longo pode ser necessário.
• Stall pode se tornar inviável dependendo do programa
executado.
★ Segunda solução:
• Predição: “Chuta-se” o caminho a ser tomado.
• branches serão tomados todas as vezes! (ou não)
Pipelining
* Hazards
★ Considerando que os branches nunca serão tomados, o que
acontece caso contrário?
Pipelining
* Hazards
★ Segunda solução (melhorada):
• Manter um histórico recente do comportamento associado aos
últimos branches: Tomados ou não tomados!?
• Quando há acerto: pipeline continua normalmente.
• Quando há erro: instruções à partir do branch devem ser tornadas

sem efeito e instruções corretas devem ser carregadas.
• Manutenção de histórico de tomada dos branches pode levar a

até 90% de acerto.
Pipelining
* Hazards
★ Terceira solução: Decisão/branch atrasada(o)
• Baseia-se na espera em se tomar a decisão de qual a próxima
instrução a ser executada.
• Ao contrário, coloca-se outra “instrução útil” no lugar que não
dependa da decisão tomada pelo branch ainda não avaliado.
• Atualmente é a solução considerada na implementação da
arquitetura MIPS.
• MIPS “re-arranja” as instruções de forma que tal
comportamento se torna invisível ao programador.
Pipelining
* Hazards
★ Terceira solução: Decisão/branch atrasada(o)
Pipelining
* Hazards
- Exercício:
★ Para cada uma das seguintes sequências de código abaixo,
avalie se:
• Código necessitará de stalls, executará sem stalls se
adiantamento for implementado ou se executará sem stalls.
a) lw $t0,0($t0) b) add $t1,$t0,$t0 c) addi $t1,$t0,1
add $t1,$t0,$t0 addi $t2,$t0,5 addi $t2,$t0,2
addi $t4,$t1,5 addi $t3,$t0,2
addi $t3,$t0,4
addi $t5,$t0,5
Pipelining
* Hazards
- Solução:
IF-ID-EX-ME-WB
a) lw $t0,0($t0) ————STALL—————
add $t1,$t0,$t0 IF-ID-EX-ME-WB
b) add $t1,$t0,$t0 IF-ID-EX-ME-WB

addi $t2,$t0,5 IF-ID-EX-ME-WB
Pipelining
* Hazards
- Solução:
c) addi $t1,$t0,1 IF-ID-EX-ME-WB

Caminho de Dados com Pipeline
* Introdução
- Número de estágios para execução de uma instrução significa
também o número de estágios de um pipeline.
★ Se a mais longa das instruções leva n estágios, então esse será
também o número de estágios do pipeline.
- Caminho de dados precisa ser separado em n estágios.

- MIPS considera um pipeline com 5 estágios:
1. IF: Instruction fetch; 4. MEM: Data memory access;
2. ID: Instruction decode; 5. WB: Write back.
3. EX: Execution / address decode;
Caminho de Dados e Controle com Pipeline
* Introdução
- Fluxo de informações da esquerda para direita, exceto:
★ WB: Escrita dos valores de volta ao registrador destino; e
★ Escrita ou carregamento do novo valor de PC.
- Uma maneira de se compreender o uso do pipeline pelas

instruções é representar a utilização de cada um dos componentes.
- Assim, temporalmente fica fácil compreender quais componentes

estão trabalhando e quais estão ocupados.
Caminho de Dados e Controle com Pipeline
* Introdução
- Em um pipeline cheio de n estágios, até n instruções diferentes
podem executar ao mesmo tempo.
- Entretanto, como persistir os dados de uma instrução em um
dado estágio para o próximo?
★ Registradores especiais fazem a persistência dos dados de um
estágio a outro.
★ Registradores são escritos ao final de um ciclo e lidos no
início do próximo.
* Introdução
- Todas as instruções alteram o valor de PC:
★ Incremento direto; ou
★ Tomada de branch condicional/incondicional.
- PC também pode ser enxergado como sendo um outro
registrador parte do pipeline.
★ Alimenta o primeiro estágio de IF (instruction fetch).
★ Seu conteúdo deve ser salvo na ocorrência de alguma
excessão.
* Introdução
- Execução da maior instrução lw:
★ Ocupa todos os 5 estágios do pipeline.
★ Execução a seguir demonstra utilização da máquina por tal
instrução.
* Introdução
- Estágios do pipeline: 1- Instruction Fetch (IF) - busca da instrução
* Introdução
- Estágios do pipeline: 2- Instruction decode (ID) - Decodificação
* Introdução
- Estágios do pipeline: 3 - Execution (EX) - Execução ou calc. do end.
* Introdução
- Estágios do pipeline: 4 - Mem. access (MEM) - Acesso a memória
* Introdução
- Estágios do pipeline: 5 - Write back (WB) - Escrita de volta no reg.
* Introdução
- Execução da instrução sw:
★ Não ocupa todos os 5 estágios do pipeline.
★ Execução a seguir demonstra utilização da máquina por tal
instrução.
* Introdução
- Estágios do pipeline: 3 - Execution (EX) - Execução ou calc. do end.
* Introdução
- Estágios do pipeline: 4 - Mem. access (MEM) - Acesso a memória
* Introdução
- Estágios do pipeline: 5 - Write back (WB) - Escrita de volta no reg.
* Introdução
- Problema na execução da instrução lw:
★ O último passo da execução da instrução lw é o WB.
★ Nele o valor lido da memória é escrito de volta em um
registrador (dentro do banco).
★ Problema: O número do registrador a ser escrito foi perdido
no segundo passo do pipeline.
★ Geração de um hazard estrutural.
★ Solução: Levar junto no pipeline a informação de qual

registrador deve ser utilizado para WB.
* Introdução
- Problema na execução da instrução lw:
* Representando graficamente os Pipelines
- Duas possíveis representações para:
★ Diagrama de múltiplos clocks:
* Representando graficamente os Pipelines
- Duas possíveis representações para:
★ Diagrama de clock simples: (correspondente ao 5o ciclo).
Unidade de Controle com Pipeline
* Introdução
- No passo anterior vimos a implementação do caminho de dados
com pipeline.
- Neste mesmo cenário é necessário considerar também como se

comportariam os sinais de controle.
- Primeiro passo: Nomear e reconsiderar as linhas de controle já

existentes na máquina.
- Segundo passo: Adaptar os sinais de controle para funcionamento

em modo pipeline.
* Introdução
- Significado e papel de cada sinal de controle já foi descrito
anteriormente.
- Valores de entradas e saídas do componente ALUOp também já
especificado anteriormente. Entretanto, agora separados em três
grupos:
* Considerações
- PC não possui sinal de controle (em todo ciclo ele será escrito).
- Registradores do pipeline não possuem sinal de controle (em

todos os ciclos eles serão escritos).
- Cada sinal de controle é associado somente a um componente

ativo a cada estágio do pipeline.
- Unidade de controle ainda é responsável pelos sinais em cada um

dos estágios do pipeline.
* Considerações
- Sinais de controle agora divididos em cinco diferentes grupos:
★ Instruction fetch (IF);
★ Instruction decode / register file read (ID);
★ Execution / address calculation (EX);
★ Memory access (MEM);
★ Write back (WB).
* Considerações
Detecção e Tratamento dos Conflitos
* Introdução
- Cenários exemplificados anteriormente dificilmente acontecem
em programas reais.
- Considerando o trecho de código abaixo:

sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
sw $12, 100($2)
- Últimas 4 instruções são dependentes da primeira: Registrador

$2.
* Introdução
- Considerando ainda que o registrador $2 possui o valor “10”
antes da operação de subtração e “20” após a mesma.
- Intento do desenvolvedor é fazer com que o valor “20” seja

utilizado nas instruções subsequentes.
- Questionamentos:
★ Como tal trecho de código seria considerado no pipeline?
★ Algum problema? Se sim, qual(is)?
* Introdução
* Adiantamento
- Em execução normal, valor de $2 poderia ser utilizado somente
após o 5o ciclo de clock.
- Em uma implementação simplista máquina deveria aguardar:

Instruções subsequentes seriam postergadas até que a primeira
fosse finalizada.
- Análise:
★ Resultado desejado está pronto após a execução do estágio
EX da primeira instrução.
* Adiantamento
- Possível solução:
★ Dados são efetivamente utilizados pelas instruções AND e OR
em seus estágios EX - ciclo de clock 4 e 5.
★ Execução do segmento de código pode prosseguir
normalmente se dados necessários forem “adiantados”.
★ Resultado calculado na primeira instrução pode ser entregue

às outras instruções antes mesmo de ser escrito no registrador.
* Adiantamento
- Como adiantamento de dados funciona?
★ Considerando somente os casos de adiantamento para uma
operação no estágio EX.
★ Algumas instruções não escrevem em registradores. Política de
adiantamento poderia causar mais problemas.
• Problema: Como controlar quando da ocorrência de instruções
que não escrevem em registradores?
• Solução: Examinar o sinal de controle RegWrite para saber se o

mesmo estará ativo durante os estágios de EX e MEM.
* Adiantamento
★ Dependência dos dados agora advém dos registradores de
pipeline.
★ No projeto da máquina, a adição de multiplexadores na

entrada da ALU permite que o pipeline funcione corretamente
mesmo na presença de dependências.
* Introdução
* Introdução
* Adiantamento
★ Controle de adiantamento dos dados é feito no estágio EX
pois os multiplexadores da ALU - que escolhem de onde vem os
operandos - se encontram nesse estágio.
★ Números dos registradores operandos precisam ser passados
do estágio ID para estágio EX via registrador de pipeline.
• Objetivo: Detectar para qual estágio os dados devem ser
adiantados.
* Adiantamento
★ Problema: Como detectar os hazards e acionar os sinais de
controle (ForwardA e ForwardB)?
★ Solução: Seguintes condições para ocorrência de um hazard

em EX:
* Adiantamento
★ Solução: Seguintes condições para ocorrência de um hazard
em MEM:
* Introdução
* Adiantamento
★ Valores de controle dos multiplexadores para adiantamento de
dados:
* Hazards de dados e Stalls
- Adiantamentos nem sempre funcionam:
★ Instrução que lê um registrador logo após uma instrução lw
que escreve no mesmo registrador.
- Instrução tenta utilizar um valor na ULA que ainda não foi

efetivamente lido da memória.
- Como solucionar?
★ Algum componente precisa demandar a parada do pipeline
quando situação acima é detectada.
- Como detectar?
★ Necessária uma unidade de detecção de hazards.
★ Verificar por instruções lw diante da seguinte condição:
★ Primeira linha verifica se a instrução é um lw; e

★ Próximas linhas verificam se o registrador de destino do lw
(no estágio EX) é o mesmo que pelo menos um dos fontes da
instrução atual.
- Como detectar?
★ Se a condição anterior é verdadeira, pipeline pára por um ciclo.
• Se não existe adiantamento, stall deve ser de dois ciclos.
★ Como os stalls/nops são efetivamente implementados?

• Instrução é identificada no estágio ID.
• Se hazard for detectado então um stall é inserido

alterando-se os campos de controle dos estágios seguintes
(EX, MEM, WB).
- Como detectar? Em nível de hardware…
★ Unidade de adiantamento continua existindo e sua tarefa é
recuperar os valores a serem “adiantados”.
★ Nova unidade é acrescentada de forma a detectar a

ocorrência de hazard: Unidade de detecção de hazard.
★ Unidade de detecção de hazard controla os valores escritos

no PC e registradores IF/ID além dos multiplexadores que
escolhem entre os valores reais de controle e/ou tudo zero.
* Hazards de controle
- Até o momento somente foram analisados problemas
relacionados as operações aritméticas e de transf. de dados.
- Entretanto, existem problemas (hazards) também envolvendo os
branches.
- Problema ocorre normalmente por não se saber de antemão se o

branch será ou não tomado.
- Consequentemente, não há como se saber qual a próxima

instrução a ser carregada no pipeline.
- Hazards de controle são normalmente mais fáceis de serem
compreendidos.
- Possíveis soluções para hazards de controle não são tão efetivas
quanto as soluções para hazards de dados.
- Duas possíveis soluções e uma otimização:
1) Assumir que os branches nunca serão tomados;
• Reduzir os atrasos dos branches.
2) Predição dinâmica de branches.
- Assumir que branches nunca serão tomados:
★ Possível solução é sempre considerar que os branches nunca
serão tomados;
★ Continua-se executando as instruções seguidamente e as
enfileirando no pipeline.
★ Se porventura o branch for tomado, as instruções antes
buscadas na memória são descartadas.
★ Se realmente o branch não for tomado, instruções já foram

adiantadas e pipeline não é parado.
- Assumir que branches nunca serão tomados:
★ Reduzir os atrasos dos branches
• Mover o cálculo do endereço alvo do branch do estágio
EX para o estágio ID: alteração do hardware; e
• Mover a execução do branch também para o estágio ID:

alteração do hardware.
- Predição dinâmica de branches
★ Tenta-se “adivinhar” o comportamento do branch se baseando
em vários fatores.
• Analisar o endereço da instrução e verificar se da última
vez que a mesma foi executada o branch foi tomado ou não.
• Buffer de predição de branch: Porção de memória que

indexa o endereço do branch e sinaliza, através de 1bit, se
recentemente o mesmo foi ou não tomado.
• Visa utilizar informações do histórico para fazer uma

predição correta da execução do branch.

Introducao Pipeline

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Introducao Pipeline

Enviado por

Direitos autorais:

Formatos disponíveis

Universidade Federal de Ouro Preto

Departamento de Computação e Sistemas - DECSI

Organização e Arquitetura de Computadores II (CEA 509)

* Caminho de dados e controle com pipeline

* Detecção e Tratamento dos Conflitos

★ Número de instruções de um programa é determinado pelo

★ Entretanto, modo como foi implementado o hardware (CPU)

. Diferença entre as instruções lw e sw é 1 bit (em destaque).

. Similaridade entre as instruções facilitam o projeto de hardware.

★ Instruções de branch e jump: beq e j.

★ Implementação do restante das instruções é similar.

- Simplicidade e regularidade favorecem implementação:

- Após execução da instrução, PC é incrementado em 4* e

* 4 bytes (1 word / 32 bits): Tamanho de cada instrução na máquina MIPS.

★ De estado: Internamente possuem algum mecanismo de

• Registradores são “disparados” pela borda ascendente do

• Quando CK=up, se cargaR1=1, então

• Envio do valor através de alguma lógica combinacional

- Dados das instruções devem passar por cada componente de

- Além de entrada e saída de dados, cada componente necessita

3) Execução da operação: Instruções do tipo r

4) Acesso à memória: Instruções load / store

5) Escrita de registrador (instrução load)

- Qualquer instrução é executada em um único ciclo de relógio.

- O período do relógio será longo o suficiente para acomodar

* Endereço da próxima instrução é

* A instrução lida é usada por outras

* Dois destes registradores são lidos e passados para a ULA

* O resultado é armazenado em um terceiro registrador.

* O controle da ULA determina qual operação será realizada (à

* Se ocorrer desvio, o endereço do desvio será: PC

* O deslocamento deve ser estendido para 32 bits (pois possui

• Instruções do tipo R: Endereço do registrador a ser escrito está no campo rd

- Mudança no valor do PC se propaga através de uma grande

- Período do ciclo do relógio deve ser maior que o atraso

- Implementação cobre as instruções: lw, sw, beq, add, sub, AND, OR e

- Posteriormente serão incluídas as alterações para suporte as

- Os componentes listados anteriormente ainda não tornam a

★ Dependendo da instrução a ser processada, a ALU deverá

★ A saída da unidade de controle da ALU (não ALUOp)

★ O valor da saída “zero” da ALU é utilizado para auxiliar na

★ Unidade de controle principal pode ser representada como um

★ O valor de cada sinal de controle depende exclusivamente do

2. Dois registradores ($t2 e $t3) são lidos; unidade de controle

3. ALU faz a operação nos dados lidos dos registradores usando os

4. Resultado do cálculo executado pela ALU é escrito no

5. Dado lido da memória é escrito no registrador ($t1, dado pelos

★ Cálculo do novo valor de PC é feito de forma incondicional.

★ Formato das instruções tipo j:

* Problema: Recursos de hardware não podem ser reaproveitados:

* Conclusão: Desperdício de hardware.

★ Por que tal tipo de implementação não é atualmente utilizada?

2) No que diferem os elementos “Combinacionais" dos “De

3) Apresente os cinco passos - e suas ações - necessários para a

4) Qual o papel da unidade de controle em uma máquina MIPS?

- Cada etapa executa em um único ciclo de clock.

- Período do relógio é determinado pela etapa mais lenta.

- Cada instrução executa em um número apropriado de ciclos do

✦ Dados a serem utilizados na mesma instrução em ciclos de relógio

✦ Dados a serem utilizados em instruções posteriores ->

★ Registrador de instrução (IR);

★ Registrador de Dados da Memória (MDR);

★ Registradores A e B para armazenar os dados lidos do banco de

* Warning: Todos os registradores acima (exceto IR) armazenam dados somente