FACULDADE INDEPENDENTE DO NORDESTE – FAINOR

ENGENHARIA DE COMPUTAÇÃO – MATUTINO

ARQUITETURA E ORGANIZAÇÃO DE COMPUTADORES I

PIPELINE

VITÓRIA DA CONQUISTA

JUNHO DE 2013

Carlos Sérgio Pereira Sobrinho

Eliezer Marques da Silva Neto

Humberto Leone Rodrigues Azevedo

Igor Santos Guimarães

Robson Lima de Souza

Rodrigo Borges de Oliveira

Rodrigo da Silva Ribeiro

PIPELINE

Trabalho desenvolvido durante a disciplina

de Arquitetura e Organização de

Computadores I, como parte da avaliação

referente à III unidade do 3º semestre.

Professora: Críjina Chagas

VITÓRIA DA CONQUISTA

JUNHO DE 2013

SUMÁRIO

Introdução_______________________________________________02

Conflitos de Pipeline_______________________________________04

Conflito Estrutural____________________________________04

Conflito de Dados____________________________________05

Conflito de Controle___________________________________06

Caminho de Dados de Pipeline_______________________________07

Referências______________________________________________13

INTRODUÇÃO

O pipeline é uma técnica utilizada para aperfeiçoar a velocidade de

processamento das instruções. Essa técnica consiste em executar as

instruções de forma seqüencial, ou seja, ao término do primeiro estágio de uma

instrução o primeiro estágio da próxima instrução é inicializado. Essa técnica

não melhora o tempo dos estágios das instruções, mas melhora o processo

como um todo, visto que se fosse necessário esperar o término de uma

instrução para iniciar outra, o tempo seria muito maior.

Vamos analisar abaixo algumas características do pipeline:

Melhora o desempenho de um trabalho por completo (não diminui

o tempo de cada instrução, mas melhora o trabalho por completo,

visto que são realizadas várias instruções).

A Speedup (aceleração) ideal deve ser igual ao número de

estágios, isso só não acontece quando o tempo dos estágios está

desbalanceado, desta forma a taxa de pipeline é limitada pelo

estágio mais lento.

O ganho começa a existir a partir da segunda instrução.

Um exemplo prático de pipeline é representado logo abaixo.

Em um refeitório temos quatro opções de prato, os quais cada pessoa,

demora 10 segundos para servir cada um desses. Ou seja, a cada 10

segundos a pessoa consegue colocar o feijão, depois de mais 10 segundos o

arroz e assim sucessivamente, até completar o tempo total de 40 segundos.

Então, uma única pessoa ao se servir, demora o tempo total de 40 segundos.

Executando assim os quatro estágios, que são: pegar o feijão, arroz, carne e

macarrão. Supondo agora que tenha mais 2 pessoas na fila, esperando para se

servir, irei demonstrar aqui a utilização de um sistema não-pipeline e um

pipeline.

Em um sistema não-pipeline, uma pessoa demora 40 segundos para se

servir, sendo assim, para que outra pessoa comece a fazer o mesmo, a

anterior precisará completar esse ciclo. Então, após 40 segundos a segunda

pessoa inicia a preparação da sua refeição, levando assim a mesma

quantidade de tempo, e o mesmo acontece com a terceira pessoa. Se cada

pessoa demora 40 segundos para se servir e existem exatamente três clientes,

podemos afirmar que a quantidade de tempo gasto, é igual a quantidade de

clientes , vezes o tempo total – 3x40 = 120 segundos. Em 120 segundos, três

pessoas puderam se servir. É como se tudo funcionasse de modo serial.

Terminar todo um processo, para depois executar outro.

Se estivéssemos utilizando a técnica de pipeline, seria bem diferente,

podendo ser até três vezes mais rápida. Para sabermos a diferença entre o

tempo de um estágio para o outro no pipeline, basta apenas dividir o tempo

total entre as instruções não-pipeline pela quantidade de estágios. Neste caso,

dividir 40 por 4, que será igual a 10 segundos para que o próximo estágio do

pipeline seja executado. Vamos ao exemplo:

Como dito no segundo parágrafo, uma pessoa demora 40 segundos

para servir seu prato por completo, após passar pelos quatro estágios (feijão,

arroz, carne e macarrão). Então, como podemos ver na tabela logo abaixo, a

cada 10 segundos um novo estágio é iniciado. Assim que um termina o

primeiro estágio indo para o segundo, o segundo cliente, já vai iniciando o

primeiro e assim sucessivamente. O tempo total para servir a mesma

quantidade de pessoas utilizando-se do pipeline é igual a 60 segundos. Tendo

então uma diferença de tempo entre pipeline e a não-pipeline, calculada da

seguinte forma: Tempo total do não-pipeline subtraído de tempo total do

pipeline, assim ficando, 120 – 60 = 60 seg. Essa é a diferença entre os dois

métodos.

Tempo gasto para se servir (Utilizando Pipeline)10 seg. 20 seg. 30 seg. 40 seg. 50 seg. 60 seg.

Cliente 1 Feijão Arroz Carne MacarrãoCliente 2 ######## Feijão Arroz Carne MacarrãoCliente 3 ######## ######## Feijão Arroz Carne Macarrão

É notável que a técnica do pipeline melhora, em muito, a execução de

instruções e consequentemente melhora o desempenho do processador.

Atualmente todos os processadores usam essa técnica. Vamos ver agora os

estágios por onde uma instrução passa na arquitetura MIPS.

Qualquer instrução MIPS pode ser executada em cinco estágios:

1. Busca da instrução na memória (BI/IF);2. Decodificação da instrução e leitura do banco de registradores (DI/ID);3. Execução de uma operação ou cálculo de um endereço (EX);4. Acesso à memória de dados (MEM);5. Escrita do resultado em um registrador (ER/WB).

No decorrer da execução de uma instrução pode ocorrer alguns conflitos

que serão mencionados a seguir.

CONFLITOS DE PIPELINE

Conflito Estrutural

Os conflitos estruturais acontecem quando duas instruções estão em

estágios (etapas) diferentes, mas estão utilizando o mesmo hardware, por

exemplo, a memória. Isso acontece quando uma instrução está sendo buscada

ao mesmo tempo em que um dado está sendo escrito.

A imagem abaixo mostra um conflito estrutural quando a instrução 4 e a 7 tentam acessar a memória no mesmo ciclo de clock.

Na arquitetura MIPS a memória é dividida em duas, sendo que uma é utilizada para a busca de instrução e a outra para a escrita ou busca de dados, resolvendo assim conflitos desse tipo.

Outro conflito poderia ocorrer se o banco de registradores lesse ou escrevesse o dado em um ciclo de clock, dessa forma haveria um aumento na execução de cada instrução. Felizmente no projeto MIPS a leitura e a escrita no banco de registradores são realizadas no mesmo ciclo de clock evitando um conflito estrutural.

Conflito de Dados

Ocorre quando uma instrução depende do resultado da anterior para fazer os devidos cálculos:

Ex:

Add $s0,$t0,$t1 Sub $t2,$s0,$t3

Gerando Bolhas, pois a execução do sub só iniciará após o término do add.

Uma das soluções seria o Adiantamento (forwarding ou bypass):

Quando a ULA calcula o resultado da operação ela já pode ser disponibilizada para a execução da próxima instrução que vem logo a seguir.

Porém existem casos onde é inevitável o surgimento de bolhas. O Bypass de um Lw seguida de uma instrução que usa o valor que acaba de ser buscado na memória é um exemplo em que gera bolhas inevitavelmente.

Em casos de instruções seguidas umas das outras o compilador pode reordenar essas instruções não ocasionando conflitos:

Conflito: Solução:

Conflito de controle

Esse conflito é originado na interação entre PC e PIPELINE, ou seja,

quando é necessário se tomar uma decisão para o valor de PC baseado nos

resultados de uma instrução, a qual ainda não foi concluída. Ele é comum em

instruções de desvio, exemplo: beq, bne.

As técnicas mais utilizadas para resolver esse problema é a previsão ou

predição dos desvios, elas são divididas em três:

Previsão estática que também é dividido em duas:

Simples: Consiste em assumir que os desvios condicionais

sempre irão falhar, se esse acontecer há um ganho de tempo

muito grande mais se não acontecer é necessário atrasar o

PIPELINE e consequentemente irá criar bolhas.

Sofisticada: Assumir que parte dos desvios ocorre e outros não.

Exemplo: Dizer que desvios para endereços anteriores são feitos.

Previsão dinâmica:

Essa previsão é realizada em função de comportamentos

anteriores de cada desvio, ela cria estatísticas dos desvios feitos

e dos não feitos, essa previsão tem um nível de acerto de 90%,

se essas previsões forem erradas, o controle do PIPELINE que as

instruções após os desvios errados não tenham sido realizadas e

deve reiniciar o PIPELINE a partir do endereço de desvio

apropriado.

Retardar decisões:

Essa instrução consiste em encaixar uma instrução útil para ser

usada logo após a instrução de desvio, mantendo o PIPELINE

preenchido, evitando bolhas.

CAMINHO DE DADOS COM PIPELINE

Qualquer instrução MIPS pode ser executada em cinco estágios:

6. Busca da instrução na memória (BI/IF);7. Decodificação da instrução e leitura do banco de registradores (DI/ID);8. Execução de uma operação ou cálculo de um endereço (EX);9. Acesso à memória de dados (MEM);10.Escrita do resultado em um registrador (ER/WB).

Representação gráfica do Pipeline das possíveis instruções no MIPS

Os gráficos acima são ilustrações, respectivamente, das instruções sw, lw (tipo I) e todas as instruções do tipo R. Para as demais instruções de saltos condicionais e incondicionais (tipo I e J), serão necessários outros itens no caminho de dados que não estão representados nos gráficos acima. Levando em conta apenas os itens representados, os saltos condicionais e incondicionais precisariam dos itens BI, DI, e EX para suas execuções.

A figura abaixo mostra os 5 estágios de uma instrução em MIPS. No primeiro estágio acontece a busca da instrução (BI); no segundo estágio há a decodificação da instrução e a leitura dos registradores (DI); no terceiro estágio há a execução dessa instrução (EX); no quarto estágio há a leitura ou escrita na memória de dados e no quinto estágio acontece a escrita nos registradores.

É necessário um registrador em cada uma das fronteiras dos estágios de pipeline para guardar o valor da instrução no momento da transação de um estágio para outro. A figura abaixo mostra o caminho de dados com os registradores implementados.

Vamos tomar como exemplo uma instrução lw para construir o gráfico usando o pipeline.

Primeiramente a instrução é lida na Memória de Instruções, guardada no registrador BI/DI para logo após ser decodificada e o PC é incrementado com o endereço da próxima instrução.

A instrução é então decodificada e lida no banco de registradores, os dados são então colocados no registrador DI/EX que logo após serão executados.

A terceira etapa irá calcular o endereço da Memória de Dados onde está o dado que será escrito no Banco de Registradores. Após o cálculo do endereço o resultado irá para o registrador EX/MEM.

O endereço da Memória de Dados é lido no registrador EX/MEM e então o dado poderá ser acessado na Memória de Dados. O dado é gravado no registrador MEM/ER.

O dado buscado na Memória de Dados é gravado no Banco de Registradores.

O número do registrador onde o dado deverá ser escrito vem do próprio registrador MEM/ER juntamente com o dado que será escrito no banco de registradores. O número do registrador de escrita é passado desde o estágio DI

até o registrador MEM/ER. O caminho de dados abaixo mostra as linhas por onde o número de registrador é passado.

A última figura mostra o caminho de dados completo de uma instrução lw.

REFERÊNCIAS:

Univasf, acessado em 09/06/2013, em <http://www.univasf.edu.br/~leonardo.campos/Arquivos/Disciplinas/Org_Arq_I_2007_2/Aula_10.pdf>

Unicamp, acessado em 09/06/2013, em <http://www.dca.fee.unicamp.br/~tokarnia/ea960/ano2012/aulas/Pipeline.pdf>