Pipeline <ul><li>Até agora, nos prendemos muito em economizar espaço na memória e baratear o custo de uma máquina </li></u...
<ul><li>Até aqui, sempre assumimos que o tempo de um ciclo era fixo e pré-definido. E por causa disso, o número de microin...
<ul><li>Até aqui, seguindo o modelo de Von Neumann, vimos que as etapas de execução de uma instrução seguem uma ordem:  bu...
<ul><li>Vimos também que, por este modelo, uma nova microinstrução só pode ser executada após o término da anterior, mesmo...
Curiosidades <ul><li>Henry Ford (1863 – 1947) </li></ul><ul><li>nasceu nos EUA, fundou </li></ul><ul><li>a Ford – fábrica ...
Curiosidades <ul><li>Ford utilizava a chamada “linha  </li></ul><ul><li>de montagem”, que consistia em </li></ul><ul><li>e...
<ul><li>Aplicaremos o “fordismo” aos nossos estudos: as componentes deverão estar exercendo suas funções sempre que possív...
<ul><li>Aplicaremos o “fordismo” aos nossos estudos: as componentes deverão estar exercendo suas funções sempre que possív...
<ul><li>Dessa forma, assim que a busca de uma instrução for concluída, pode ser iniciada a busca da próxima, já que as com...
<ul><li>No pipeline, o tempo de uma instrução é dado pelo número de estágios multiplicado pelo tempo de um estágio: </li><...
<ul><li>O cálculo se dá dividindo o tempo total  t  do modelo de Von Neumann pelo tempo gasto no pipeline, o que nos dá: <...
<ul><li>Com o resultado, inferimos que a execução de um programa é, idealmente, n e  vezes mais rápida no pipeline </li></...
<ul><li>Lembre-se de que, em uma aplicação real, o esquema anterior teria centenas de microinstruções. Isto é, a área entr...
<ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes pr...
<ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes pr...
<ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes pr...
<ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes pr...
<ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes pr...
<ul><li>Note que, sem esse problema, levaríamos 5 ciclos para executar as 2 instruções. Com o impasse, levamos 2 ciclos a ...
<ul><li>Dependência de controle </li></ul><ul><ul><li>Sabemos que o endereço da instrução a ser buscada na memória se enco...
MUX AMU X C O N D N1 N0 LMS N Z Controle Controle <ul><li>Convém uma pequena </li></ul><ul><li>revisão. Lembra-se deste </...
<ul><li>Na verdade, não é necessário relembrar o que acontece em cada parte no desenho </li></ul><ul><li>Tudo o que precis...
<ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha...
<ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha...
<ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha...
<ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha...
<ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha...
<ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha...
<ul><li>Nós, como projetistas da máquina, precisamos sempre buscar formas de passar por todos os obstáculos existentes em ...
<ul><li>A primeira otimização, que qualquer bom compilador deve ser capaz de fazer, é uma arrumação na sequência de instru...
<ul><li>Por exemplo, se houver no programa outras duas instruções de soma, a ordem de execução pode ser: </li></ul><ul><li...
<ul><li>Outra otimização possível é conhecida como  Data Forwarding </li></ul><ul><li>Consiste em buscar os operandos sem ...
<ul><li>Na sequência: </li></ul><ul><li>a = b + c </li></ul><ul><li>d = a + h </li></ul><ul><li>sabemos que a segunda inst...
B Antes, precisávamos do valor gravado em um registrador - - B E GR I BO E GR I BO
B Agora, podemos reaproveitar este valor logo após o término da execução da operação na ULA Esta seria uma opção bastante ...
<ul><li>Processadores como o da Intel possuem uma série de outras otimizações na implementação do pipeline </li></ul><ul><...
<ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li>...
<ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li>...
<ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li>...
<ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li>...
<ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li>...
<ul><li>Há ainda uma última forma de otimização que melhora o desempenho da nossa máquina, conhecida como  superpipelining...
<ul><li>Esta configuração caracteriza exatamente um superpipeline </li></ul><ul><li>Ok, 20 estágios já está melhor que 4. ...
<ul><li>Muito bem, falamos bastante sobre como amenizar os revés do pipeline, mas não podemos esquecer que estes não são o...
Próximos SlideShares
Carregando em…5
×

Pipeline

1.427 visualizações

Publicada em

0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
1.427
No SlideShare
0
A partir de incorporações
0
Número de incorporações
5
Ações
Compartilhamentos
0
Downloads
39
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Pipeline

  1. 1. Pipeline <ul><li>Até agora, nos prendemos muito em economizar espaço na memória e baratear o custo de uma máquina </li></ul><ul><li>Mas, e quando quisermos uma máquina mais veloz, isto é, com melhor desempenho ? </li></ul>
  2. 2. <ul><li>Até aqui, sempre assumimos que o tempo de um ciclo era fixo e pré-definido. E por causa disso, o número de microinstruções a serem executadas definia o tempo gasto na execução do programa </li></ul><ul><li>Esquecendo um pouco a memória, </li></ul><ul><li>vamos focar agora em como </li></ul><ul><li>reduzir o tempo gasto na execu- </li></ul><ul><li>ção das microinstruções </li></ul><ul><li>A seguir, veremos o uso do </li></ul><ul><li>pipeline </li></ul>
  3. 3. <ul><li>Até aqui, seguindo o modelo de Von Neumann, vimos que as etapas de execução de uma instrução seguem uma ordem: busca da instrução , identificação , busca dos operandos , execução da operação e armazenamento do resultado </li></ul><ul><li>Podemos representar desta forma, onde cada quadrado representa um subciclo: </li></ul>B I BO E AR
  4. 4. <ul><li>Vimos também que, por este modelo, uma nova microinstrução só pode ser executada após o término da anterior, mesmo que não haja interdependência entre elas </li></ul><ul><li>Esquematizando, teríamos: </li></ul><ul><li>Como otimizar este processo? </li></ul>1 2 tempo 3 B I BO E AR B I BO E AR B ...
  5. 5. Curiosidades <ul><li>Henry Ford (1863 – 1947) </li></ul><ul><li>nasceu nos EUA, fundou </li></ul><ul><li>a Ford – fábrica de auto- </li></ul><ul><li>móveis – e defendia for- </li></ul><ul><li>temente o consumismo </li></ul><ul><li>Mas nada disso nos </li></ul><ul><li>interessa </li></ul>
  6. 6. Curiosidades <ul><li>Ford utilizava a chamada “linha </li></ul><ul><li>de montagem”, que consistia em </li></ul><ul><li>especializar seus empregados em </li></ul><ul><li>funções definidas </li></ul><ul><li>O mesmo empregado passava todo o tempo realizando uma única tarefa, mais específica possível e repetidas vezes, de forma que a prática o levasse a diminuir a chance de erros e o fizesse gastar menos tempo para concluir a tarefa </li></ul>
  7. 7. <ul><li>Aplicaremos o “fordismo” aos nossos estudos: as componentes deverão estar exercendo suas funções sempre que possível, em vez de ter que esperar o que chamávamos de um ciclo para voltar a trabalhar </li></ul><ul><li>O ganho no desempenho é bastante significativo </li></ul>1 2 tempo 3 B I BO E AR B I BO E AR B ... B I BO E AR
  8. 8. <ul><li>Aplicaremos o “fordismo” aos nossos estudos: as componentes deverão estar exercendo suas funções sempre que possível, em vez de ter que esperar o que chamávamos de um ciclo para voltar a trabalhar </li></ul><ul><li>O ganho no desempenho é bastante significativo </li></ul>1 2 tempo 3 B I BO E AR B I BO E AR B I BO E AR
  9. 9. <ul><li>Dessa forma, assim que a busca de uma instrução for concluída, pode ser iniciada a busca da próxima, já que as componentes especializadas nesta tarefa (no caso, PC, IR e MAR) já estarão livres. E o mesmo serve para identificação, busca de operandos etc </li></ul><ul><li>Podemos chamar cada um dos quadrados de um estágio do pipeline </li></ul><ul><li>Antes, o tempo total era dado pelo tempo de uma instrução multiplicado pelo total de instruções: </li></ul><ul><li>t = n.t inst </li></ul>
  10. 10. <ul><li>No pipeline, o tempo de uma instrução é dado pelo número de estágios multiplicado pelo tempo de um estágio: </li></ul><ul><li>t inst = n e .t e </li></ul><ul><li>E, se analisarmos o esquema de execução das instruções no pipeline feito há pouco, teremos o tempo total de execução no pipeline: </li></ul><ul><li>t pipe = t inst + (n – 1).t e </li></ul><ul><li>= (n e + n – 1).t e </li></ul><ul><li>Com isso, podemos conhecer o speedup , ou seja, o quanto mais rápido é a execução por pipeline em relação à arquitetura anterior </li></ul>
  11. 11. <ul><li>O cálculo se dá dividindo o tempo total t do modelo de Von Neumann pelo tempo gasto no pipeline, o que nos dá: </li></ul><ul><li>O número de estágios vai ser sempre muito inferior ao número de instruções, portanto podemos ignorar os valores n e e -1 no denominador. No numerador, isso não é possível por ser uma multiplicação, e não uma soma </li></ul><ul><li>Passamos a ter então: </li></ul>
  12. 12. <ul><li>Com o resultado, inferimos que a execução de um programa é, idealmente, n e vezes mais rápida no pipeline </li></ul><ul><li>É fácil visualizar isso: </li></ul><ul><li>Note que na área entre os pontilhados, 4 tarefas estão sendo executadas ao mesmo tempo, enquanto apenas uma estaria sendo no modelo antigo. Isto porque são 4 estágios </li></ul>
  13. 13. <ul><li>Lembre-se de que, em uma aplicação real, o esquema anterior teria centenas de microinstruções. Isto é, a área entre as linhas pontilhadas sempre vai ser a imensa maioria </li></ul><ul><li>Mas, como sempre, existem problemas </li></ul><ul><li>E é deles que vamos falar a partir de agora </li></ul>
  14. 14. <ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos </li></ul></ul><ul><ul><li>Isto caracteriza desperdício de tempo </li></ul></ul>a = b + c d = a + h Vamos acompanhar a sucessão dos ciclos para entender o que acontece I BO B E GR I BO B E GR I BO
  15. 15. <ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos </li></ul></ul><ul><ul><li>Isto caracteriza desperdício de tempo </li></ul></ul>a = b + c d = a + h B No primeiro ciclo, a instrução é buscada. Ou seja, ao seu final, a máquina apenas tem a instrução sem nem sequer saber o que significa, pois ainda não foi identificada I BO B E GR I BO B E GR I BO
  16. 16. <ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos </li></ul></ul><ul><ul><li>Isto caracteriza desperdício de tempo </li></ul></ul>a = b + c d = a + h I BO B Aqui, a máquina identifica a instrução “a = b + c” e já busca o valor dos operandos b e c . Neste mesmo ciclo, já é buscada a instrução “d = a + h” I BO B E GR I BO B E GR I BO
  17. 17. <ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos </li></ul></ul><ul><ul><li>Isto caracteriza desperdício de tempo </li></ul></ul>a = b + c d = a + h I BO E I BO Agora, aparece o problema. Neste ciclo, buscamos os operandos a e h da instrução 2, sendo que a é o resultado da instrução 1. E este resultado ainda não foi gravado, já que isto só terá sido feito ao final do ciclo seguinte B E GR I BO B E GR I BO
  18. 18. <ul><li>Dependência de dados </li></ul><ul><ul><li>Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos </li></ul></ul><ul><ul><li>Isto caracteriza desperdício de tempo </li></ul></ul>a = b + c d = a + h Portanto, faz-se necessário esperar até que o valor de a esteja corretamente gravado em algum registrador B - - B E GR I BO E GR I BO
  19. 19. <ul><li>Note que, sem esse problema, levaríamos 5 ciclos para executar as 2 instruções. Com o impasse, levamos 2 ciclos a mais </li></ul><ul><li>Se a dependência de dados ocorresse seguidamente em 500 instruções, levaríamos 2 ciclos a mais para cada dependência </li></ul><ul><li>De pouco mais de 500 ciclos, a sequência passaria a levar cerca de 1500 ciclos para ser executada </li></ul><ul><li>Há ainda outro problema, muito mais comum do que a dependência de dados </li></ul>
  20. 20. <ul><li>Dependência de controle </li></ul><ul><ul><li>Sabemos que o endereço da instrução a ser buscada na memória se encontra no registrador PC </li></ul></ul><ul><ul><li>Sabemos também que, se não há desvios, a próxima instrução a ser buscada está no endereço dado por pc (conteúdo de PC) + 1 </li></ul></ul><ul><ul><li>No pipeline, busca-se uma instrução em um estágio, e já no próximo busca-se a instrução seguinte, no endereço pc + 1 </li></ul></ul>
  21. 21. MUX AMU X C O N D N1 N0 LMS N Z Controle Controle <ul><li>Convém uma pequena </li></ul><ul><li>revisão. Lembra-se deste </li></ul><ul><li>esquema? </li></ul><ul><li>É sobre como são feitos os </li></ul><ul><li>desvios de instruções </li></ul>U L A . . . . . A D D R Memória de Controle MPC INC ULA
  22. 22. <ul><li>Na verdade, não é necessário relembrar o que acontece em cada parte no desenho </li></ul><ul><li>Tudo o que precisamos ter em mente é que os desvios condicionais são realizados após alguma operação na ULA, a qual libera os sinais N e Z que contêm informações sobre a saída da ULA. Esta saída é, então, avaliada de acordo com a condição do desvio </li></ul><ul><li>Dito isso, conclui-se então que só no terceiro estágio saberemos se ocorrerá desvio </li></ul>B E GR I BO
  23. 23. <ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha que a instrução acima esteja no endereço 1 da memória principal </li></ul>se a = 0 então goto 8 I BO B E GR I BO B E GR I BO
  24. 24. <ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha que a instrução acima esteja no endereço 1 da memória principal </li></ul>se a = 0 então goto 8 B I BO Neste ciclo, estaremos buscando a nossa instrução. PC contém seu endereço, então o conteúdo de PC é 1 B E GR I BO B E GR I BO
  25. 25. <ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha que a instrução acima esteja no endereço 1 da memória principal </li></ul>se a = 0 então goto 8 I BO B I BO Agora, identificamos nossa instrução e buscamos o operando a . Vamos supor que este seja igual a 0. Neste mesmo ciclo, buscamos a próxima instrução, por default , no endereço pc + 1. Está sendo buscada, então, a instrução no endereço 2 B E GR I BO B E GR I BO
  26. 26. <ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha que a instrução acima esteja no endereço 1 da memória principal </li></ul>se a = 0 então goto 8 I E I BO Porém, chegamos agora ao ciclo onde a primeira instrução é executada. A ULA dará como saída o próprio operando a , que será avaliado na lógica de microssequenciamento e, como é igual a 0, a execução do programa teria de ser desviada para a instrução no endereço 8 ( goto 8) B E GR I BO B E GR I BO
  27. 27. <ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha que a instrução acima esteja no endereço 1 da memória principal </li></ul>se a = 0 então goto 8 E agora? Constatamos anteriormente que a instrução no endereço 2 já foi buscada, e a máquina a essa altura já identificou e buscou os operandos dessa instrução que não nos interessa - - B E GR I BO B E GR I BO
  28. 28. <ul><li>Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: </li></ul><ul><li>Suponha que a instrução acima esteja no endereço 1 da memória principal </li></ul>se a = 0 então goto 8 Mais uma vez, é necessário esperar alguns ciclos até que tenhamos a confirmação de que haverá desvio, para só depois buscar a próxima instrução - - B E GR I BO B E GR I BO
  29. 29. <ul><li>Nós, como projetistas da máquina, precisamos sempre buscar formas de passar por todos os obstáculos existentes em uma implementação </li></ul><ul><li>A saída geralmente é pensar em otimizações que diminuam o prejuízo causado por possíveis problemas de uma implementação </li></ul>
  30. 30. <ul><li>A primeira otimização, que qualquer bom compilador deve ser capaz de fazer, é uma arrumação na sequência de instruções a fim de diminuir ao máximo o número de ocorrências de dependência de dados em um programa </li></ul><ul><li>Vimos que a sequência </li></ul><ul><li>a = b + c </li></ul><ul><li>d = a + h </li></ul><ul><li>causaria um desperdício de 2 ciclos na máquina </li></ul><ul><li>Entretanto, o compilador pode “procurar” outras instruções que nada tenham a ver com estas e executá-las neste espaço </li></ul>
  31. 31. <ul><li>Por exemplo, se houver no programa outras duas instruções de soma, a ordem de execução pode ser: </li></ul><ul><li>a = b + c </li></ul><ul><li>x = y + z </li></ul><ul><li>m = n + p </li></ul><ul><li>d = a + h </li></ul><ul><li>Desta forma, não haverá perda de tempo </li></ul>a = b + c x = y + z m = n + p d = a + h O processador acaba de gravar o resultado em algum registrador Inicia-se a busca dos operandos. Quando o registrador onde está a for consultado, lá já estará o valor correto de a B E GR I BO B E GR I BO B E GR I BO B E GR I BO
  32. 32. <ul><li>Outra otimização possível é conhecida como Data Forwarding </li></ul><ul><li>Consiste em buscar os operandos sem esperar que o resultado da instrução anterior seja gravado em um registrador, mesmo que um desses operandos seja esse resultado </li></ul>Registradores ULA
  33. 33. <ul><li>Na sequência: </li></ul><ul><li>a = b + c </li></ul><ul><li>d = a + h </li></ul><ul><li>sabemos que a segunda instrução também pode ser escrita como “d = b + c + h” </li></ul><ul><li>Desta forma, não precisamos esperar até que o registrador da variável a seja atualizado para buscar os operandos da segunda instrução </li></ul><ul><li>Em outras palavras, não é necessário esperar chegarmos ao final do estágio onde o resultado é gravado (GR) para conhecermos um dos operandos da segunda instrução </li></ul>
  34. 34. B Antes, precisávamos do valor gravado em um registrador - - B E GR I BO E GR I BO
  35. 35. B Agora, podemos reaproveitar este valor logo após o término da execução da operação na ULA Esta seria uma opção bastante útil para um caso do tipo: a = b + c d = a + e f = d + g h = f + i j = h + k x = j + h - - B E GR I BO E GR I BO
  36. 36. <ul><li>Processadores como o da Intel possuem uma série de outras otimizações na implementação do pipeline </li></ul><ul><li>Prejuízos causados por dependência de controle são diminuídos com maneiras de “prever” se a instrução atual causará desvio na execução da sequência de instruções, com probabilidades altas de acerto </li></ul><ul><li>Outra otimização possível é armazenar certas informações quando houver desvios na instrução, para serem usadas quando esta instrução aparecer novamente. Por exemplo, em um loop onde são feitas 10 iterações, ocorrem 9 desvios para a mesma instrução (a primeira) </li></ul>
  37. 37. <ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li></ul><ul><li>instrução 2; </li></ul><ul><li>instrução 3; </li></ul><ul><li>i <- i + 1; </li></ul><ul><li>fim do loop </li></ul>i = 1
  38. 38. <ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li></ul><ul><li>instrução 2; </li></ul><ul><li>instrução 3; </li></ul><ul><li>i <- i + 1; </li></ul><ul><li>fim do loop </li></ul>A condição é analisada e não ocorre desvio: entramos no loop
  39. 39. <ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li></ul><ul><li>instrução 2; </li></ul><ul><li>instrução 3; </li></ul><ul><li>i <- i + 1; </li></ul><ul><li>fim do loop </li></ul>Hora de analisar novamente se i é menor ou igual a 10
  40. 40. <ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li></ul><ul><li>instrução 2; </li></ul><ul><li>instrução 3; </li></ul><ul><li>i <- i + 1; </li></ul><ul><li>fim do loop </li></ul>Neste momento, i = 2, então para iniciar a segunda iteração...
  41. 41. <ul><li>Acompanhe: </li></ul><ul><li>i <- 1; </li></ul><ul><li>para i = 1 até 10 faça </li></ul><ul><li>instrução 1; </li></ul><ul><li>instrução 2; </li></ul><ul><li>instrução 3; </li></ul><ul><li>i <- i + 1; </li></ul><ul><li>fim do loop </li></ul>...desviamos de volta para a primeira instrução no loop
  42. 42. <ul><li>Há ainda uma última forma de otimização que melhora o desempenho da nossa máquina, conhecida como superpipelining </li></ul><ul><li>Vimos que a implementação do pipeline agiliza, idealmente, n e vezes a execução das instruções em relação à nossa máquina antiga </li></ul><ul><li>Ora, por que então usar apenas 4 estágios? </li></ul><ul><li>Um dos processadores da Intel possui pipeline de 20 estágios. Apenas para dar uma ideia, os primeiros 4 estágios são usados para operações de busca de instruções </li></ul>B1 B2 B3 B4 . . . . . .
  43. 43. <ul><li>Esta configuração caracteriza exatamente um superpipeline </li></ul><ul><li>Ok, 20 estágios já está melhor que 4. Mas por que não usar, talvez, 1000 estágios? </li></ul><ul><li>Para executar várias operações do mesmo tipo ao mesmo tempo, precisaríamos aumentar o número de componentes. No caso de 4 operações de busca, por exemplo, o processador precisa ter 4 PCs para armazenar o endereço dessas instruções, 4 IRs para armazenar as instruções propriamente ditas, etc </li></ul><ul><li>Aumentar o número de componentes encarece a máquina, o que tornaria um desastre elevar demais o número de estágios do pipeline </li></ul>
  44. 44. <ul><li>Muito bem, falamos bastante sobre como amenizar os revés do pipeline, mas não podemos esquecer que estes não são os únicos que afetam o desempenho da máquina </li></ul><ul><li>Até agora, economizamos alguns ciclos aqui, outros lá, já executamos várias instruções ao mesmo tempo e por aí vai </li></ul><ul><li>Mas não nos aprofundamos ainda em um outro problema que aumenta consideravelmente o tempo gasto pela máquina na execução de problemas: leitura e escrita na memória principal </li></ul><ul><li>Estas operações levam aproximadamente 100 ciclos para serem realizadas! </li></ul>

×