capítulo 1 organização de computadoresvargas/disciplinas/arquitetura_i/cap-1-2... ·...

1

Capítulo 1

Organização de Computadores

1.1. Organização de um Computador

As partes componentes de um computador podem ser divididas de acordo com osblocos mostrados na fig. 1. A parte operativa (datapath) é responsável pela execução defunções lógicas e aritméticas tais como soma, subtração, deslocamentos, funções E e OU bit-a-bit. A parte de controle comanda a parte operativa, a memória e os dispositivos de entrada esaída informando as ações que eles devem tomar e quando estas ações devem ser tomadaspara executar a seqüência de instruções especificada por um programa. A memória armazenaprogramas e dados necessários para a operação do computador. Os dispositivos de entradacapturam informação do meio externo e os dispositivos de saída fornecem informação para omeio externo.

Nos computadores modernos a memória pode ser dividida em Dynamic RandomAccess Memory (DRAM) e Memória Cache. A DRAM possui um baixo custo por bitarmazenado, mas possui um tempo de acesso relativamente elevado. A memória cache énormalmente construída com memórias SRAM (Static Random Access Memories) quepossuem um custo maior por bit armazenado, mas que são bem mais rápidas. Emconseqüência, memórias caches são usualmente de pequena capacidade de armazenamento eservem como um "amortecedor" entre a memória principal (DRAM) e o processador.

Todos os componentes de um computador podem ser descritos de forma hierárquicaem vários níveis de abstração. Esta estratificação é importante para permitir que o projetistatrabalhando em um nível ignore detalhes de descrição de camadas inferiores. Assim, umprojetista de computadores trabalhando a nível de sistemas só precisa saber o tamanho damemória (espaço de endereçamento), a sua forma de organização e o seu tempo de acesso.

2

Ele não precisa saber qual a tecnologia de semicondutores ou quantos transistores (tamanhofísico) foram utilizados para fabricar aquela memória.

Interface

Parte

ControleEntrada

M em ória

Parte

Operativa

Processador

��

��

��

��

��

��

��

��

��

��

��

��

Saída

Sistema Operacional

Fig. 1.1. Principais Blocos de um Computador.

Fig. 1.2. Fotografia de uma estação de trabalho (workstation). A tela do tubo de raios catódicos (CRT) é odispositivo de saída usual, enquanto que o teclado e o "mouse" são os dispositivos de entrada principais.

Fig. 1.3. Fotografia do interior de um "mouse".

3

Fig. 1.4. Tela de um tubo de raios catódicos (Cathode Ray Tube - CRT). Um feixe de elétrons é aceleradoatravés do vácuo contra uma tela revestida com fósforo. O feixe de elétrons é guiado em direção à tela através deuma bobina colocada na parte traseira do CRT. Este tipo de sistema, que é o mesmo usado em televisão ecomputadores, pinta através de uma série de pontos (pixels) uma linha de cada vez na tela. A tela é reanimada(refresh) de 30 à 60 vezes por segundo.

Fig. 1.5. Cada coordenada no "buffer de quadro" na esquerda, determina o nível de cinza da coordenadacorrespondente para a tela do CRT, na direita. O pixel(X0, Y0) contem o padrão de bit 0011, o qual é um nívelde cinza mais claro que o determinado pelo padrão de bit 1101 no pixel(X1, Y1).

A fig. 1.6 mostra as tecnologias mais utilizadas ao longo dos tempos, com umaestimativa da performance relativa por custo unitário para cada uma destas tecnologias.

Desde 1975, a tecnologia de circuitos integrados (CIs) define o que e com que rapidezos computadores são capazes de fazer. Assim, profissionais na área de computação devem sefamiliarizar com os conceitos básicos envolvendo circuitos integrados.

Um transistor é simplesmente uma chave on/off controlada por eletricidade. Um CI,pode conter algumas centenas ou até mesmo alguns milhões de transistores.

A taxa de aumento da integração tem sido irremarcavelmente estável ao longo dosúltimos anos. A fig. 1.7 mostra o aumento da capacidade de memórias DRAM entre 1976 e1992. A indústria de semicondutores tem quadruplicado a capacidade destes CIs a cada trêsanos. Esta incrível taxa de evolução na relação custo/performance e na capacidade dasmemórias tem governado o projeto de hardware e software de computadores e por isto,tornado obrigatório o conhecimento das tecnologias de CIs.

A fabricação de um chip começa com silício (Si), uma substância encontrada na areia.O Si é chamado de semicondutor porque ele não conduz muito bem a eletricidade. Atravésde processos químicos, é possível se adicionar materiais ao Si, permitindo a suatransformação em:

i) excelente condutor de eletricidade (similar ao cobre e ao alumínio), ouii) excelente isolante (como plástico ou vidro), ouiii) áreas que conduzem ou isolam, de acordo com algumas condiçõesespeciais (como transistores, diodos, etc...).

O processo de manufatura de CIs começa com um lingote (de 5 à 8 polegadas dediâmetro e 12 de comprimento) de cristal de silício, o qual é cortado em fatias (wafers) decerca de 0,1 polegada de espessura. Os wafers passam então por uma série de etapas, duranteas quais cria-se no Si vários elementos como transistores, diodos, capacitores, resistores, etc...Dado que um wafer custa aproximadamente o mesmo preço não importando o que está

4

construído em cima, poucos CIs implicam em altos custos porque grandes pastilhas de CIs sãomais propícias a conter defeitos e assim ter de ser rejeitadas, o que reduz o rendimento doprocesso (process yield). Assim, projetistas de CIs tem que conhecer bem a tecnologia queestá sendo utilizada para ter certeza de que o aumento no custo para produzir CIs maiores sejustifica por uma melhoria na performance destes CIs.

(a)

(b)

(c)

Fig. 1.6. (a) Performance relativa por custo unitário para as tecnologias mais usadas em computadores ao longodos tempos. (b) Gerações de computadores são normalmente determinadas pela mudança de tecnologiadominante. Tipicamente, cada geração oferece a oportunidade para desenvolver uma nova classe decomputadores e de criar novas empresas. Muitos pesquisadores acreditam que o processamento paralelo paraaplicações de alta performance (high-end computers) e computadores portáteis para aplicações menos críticas(low-end computers) serão a base para uma quinta geração de computadores. (c) Características decomputadores comerciais desde 1950, em dólares da época, e em dólares corrigidos pela inflação para 1991.

O custo de um CI pode ser expresso em três simples equações:

custo da pastilha = custo do wafer . [i]

pastilhas por wafer x rendimento

pastilhas por wafer = área do wafer . [ii]

área da pastilha

rendimento = 1 . [iii]

(1 + defeitos por área x área da pastilha)2

2

5

A primeira equação é obtida diretamente. A segunda é uma aproximação, dado queela não subtrai a área próxima à borda do wafer que não pode acomodar pastilhasretangulares. A equação [iii] é baseada em anos de observações empíricas dos rendimentos deprocessos em fábricas de CIs, onde o expoente indica o número de etapas críticas no processode manufatura.

Fig. 1.7. Aumento da capacidade de chips DRAM. O eixo y é medido em Kbits (onde K = 1024 bits ou 210).A indústria de semicondutores tem quadruplicado a capacidade das memórias a cada três anos, ou 60% a cadaano, por mais de 15 anos.

Fig. 1.8. Vista geral da placa do processador de uma estação de trabalho. Esta placa utiliza o MIPS R4000, oqual está localizado no lado direito, ao centro da placa. O R4000 contem memórias cache de alta velocidadeimplemententadas dentro da sua própria pastilha. A memória principal está contida nas placas menores,instaladas perpendicularmente à placa-mãe, no canto esquero superior. Os chips de memória DRAM estãomontados nestas placas perpendiculares (chamadas SIMMs: Single In-line Memory Module) e em seguidaligados aos conectores. Os connectores na parte inferior da placa são para dispositivos de I/O externos, taiscomo rede (Ethernet), teclado, e vídeo.

6

Fig. 1.9. Fotografia do microprocessador MIPS R3000 encapsulado.

Fig. 1.10. Fotografia de três versões diferentes do microprocessador R4000, mostrado na forma de pastilha, àesquerda no alto. Para reduzir o custo do chip, um encapsulamento menor é usado em aplicações que nãonecessitam alta qualidade, enquanto que um maior encapsulamento é utilizado para aplicações que necessitamalta performance: servidores e estações de trabalho. O encapsulamento grande possui pouco mais de 400 pinos,enquanto que o menor, cerca de 150 pinos. Os pinos permite um caminho de acesso mais largo entre oprocessador e a memória principal, e assim, permitindo transferências de dados mais rápidas e endereçamento dememórias maiores.

1.2. Clocks e Lógica Seqüencial

Clocks são necessários para decidir quando um elemento que armazena o estado atualde um sistema deve ser atualizado. O sinal de clock possui um período (medido emsegundos) fixo; a freqüência do clock (medida em Hertz) é o inverso do seu período. A fig.1.11. mostra um sinal de clock identificando o seu período, sua borda de subida e sua borda dedecida. Nós assumimos que todos os sinais de clocks utilizados nos sistemas que estudarmosserão acionados pelas bordas. Isto é, todas as mudanças de estado terão início quando o sinal

7

de clock mudar e valor baixo para valor alto (borda de subida) ou de valor alto para valorbaixo (borda de descida).

Período do Clock

Borda de Subida Borda de Descid

Fig. 1.11. Sinal de clock.

Um sistema baseado em clock é denominado sistema síncrono. Os valores que serãoescritos nos elementos de estado (também chamados elementos de memória) do sistema temque estar válidos quando ocorrer a borda do clock que ativa a escrita. Um sinal é consideradoválido quando ele está estável (seu valor não está mudando) e o valor não vai mudar maisenquanto as entradas da lógica que gera o sinal não mudarem. A fig. 1.12. mostra a relaçãoentre os elementos de estado, a lógica combinacional e o sinal de clock em um sistemasíncrono. O período do clock tem que ser suficientemente longo para garantir que as saídas dalógica combinacional (entradas do elemento de estado 2) tenham tempo para estabilizar desdea última mudança ocorrida no elemento de estado 1. Note que neste tipo de circuito, não hálaços de realimentação dos elementos de memorização das saídas primárias para as entradasdo circuito. Assim, o estado seguinte da lógica combinacional depende somente dos valoresdas suas entradas. Este tipo de circuito é denominado circuito combinacional síncrono.

Clock

entradas saídas

Lógica

CombinacionalElemento de

Estado 1Elemento de

Estado 2

Fig. 1.12. Circuito Combinacional Síncrono.

entradas saídas

Lógica

Combinacional

Elemento de

Estado 1Elemento de

Estado 2

Fig. 1.13. Circuito Seqüencial Síncrono.

Os mesmos elementos de estado podem ser utilizados como entrada e saída do circuitode lógica combinacional. Assim, o estado seguinte da lógica combinacional depende dosvalores das suas entradas e de 1 ou mais das suas saídas. Uma organização deste tipo échamada de circuito seqüencial síncrono. (Veja fig. 1.13).

1.3. Instruções: a Linguagem da Máquina

Para comandar o hardware de um computador, devemos falar a sua língua. As palavrasde uma linguagem de máquina são chamadas instruções e o seu vocabulário é chamado deconjunto de instruções.

8

A representação simbólica de instruções de um computador é chamada de linguagemassembler e a representação numérica destas instruções, no formato que será executado pelamáquina, é chamado de linguagem de máquina. A tradução da linguagem assembler para alinguagem de máquina é realizada por um programa chamado Assembler. Ver fig. 1.14, ondeum programa escrito em C é primeiramente traduzido pelo compilador para um programa emlinguagem assembler. Em seguida, o Assembler traduz o programa em linguagem assemblerpara a linguagem de máquina. O programa que coloca o programa em linguagem de máquinadentro da memória para ser executado é chamado de carregador (loader).

O compilador é um programa que realiza a interface HW/SW do computador (fig. 1.15).Ele:

i) mapeia variáveis definidas pelo programador em linguagem de alto níveldiretamente para os registradores do microprocessador.

ii) aloca espaços de memória para estruturas de dados simples e complexas (variáveis,arrays, matrizes,...).

iii) define endereços iniciais de arrays e matrizes.iv) cria desvios e rótulos no programa compilado em linguagem de máquina antes de

armazená-lo na memória principal.

Fig. 1.14. Hierarquia de tradução. Um programa em linguagem de alto nível é primeiramente compilado paraum programa em linguagem assembler e em seguida traduzido para um programa em linguagem de máquina. Ocarregador tem como função colocar o código de máquina dentro dos respectivos endereços da memória docomputador para ser executado.

O compilador associa variáveis de um programa aos registradores de ummicroprocessador.

Exemplo 1: Considere o seguinte trecho de programa em linguagem C e o respectivocódigo assembler para o MC68000:

b = 10; MOVE.W #10, D0;c = 20; MOVE.W #20, D1;c = b + c; ADD D0, D1;

9

O compilador associou a variável b ao registrador D0 e a variável c ao registrador D1.Além de associar variáveis à registradores, o compilador também aloca espaço na memóriaprincipal para armazenar estruturas de dados como arrays e matrizes. Assim, o compiladordefine o endereço inicial de estruturas complexas para as instruções de transferência de dados.

Fig. 1.15. Programa C compilado para linguagem assembler e em seguida compilado para linguagem demáquina. Embora a tradução da linguagem de alto-nível para a linguagem de máquina seja apresentada em 2passos, alguns compiladores eliminam a etapa intermediária e produzem a linguagem de máquina diretamente.

Exemplo 2: no segmento do código C abaixo, f, g, h, i, j são variáveis.

if (i == j) goto L1;f = g + h;

L1: f = f - i;

Assumindo que as 5 variáveis estão associadas aos 5 registradores de $16 à $20, qual éo código assembler para o MIPS?

beq $19, $20, L1 # if (i == j) goto L1 (salta para L1 se i = j)add $16, $17, $18 # f = g + h (não executado se i = j)

L1: sub $16, $16, $19 # f = f - i (sempre executado)Exit:

Exemplo 3: compiladores freqüentemente criam desvios e rótulos quando eles nãoaparecem em linguagens de programação. Usando as mesmas variáveis e registradores doexemplo anterior, o código C:

if (i == j) f = f - i; else f = g + h;

10

é compilado para a linguagem assembler do processador MIPS da seguinte forma:

bne $19, $20, Else # salta para Else se i � jsub $16, $16, $19 # f = f - i (não executado se i � j)j Exit # salta para Exit

Else: add $16, $17, $18 # f = g + h (não executado se i = j)Exit:

Linguagens assembler são muito similares, quem sabe programar em assembler de umprocessador pode rapidamente aprender a programar no assembler de outros processadores.Para quem só conhece linguagens de alto nível, tais como C e Pascal, é importante entenderalgumas distinções fundamentais entre estas linguagens e as linguagens assembler. Saberresponder adequadamente as seguintes perguntas é importante:

Como existe um número limitado de registradores em um processador, o número de“variáveis” que podem ser definidas em um programa em assembler também é limitado.Existe também um número limitado de "nomes" que estas variáveis podem receber.Normalmente os nomes das variáveis em assembler são os próprios nomes dos registradores.Por exemplo, o microprocessador MC68000 fabricado pela Motorola possui oito registros dedados que são chamados D0, D1, ..., D7. Portanto dados em programas assembler doMC68000 somente podem ser armazenados em uma destas variáveis (D0 a D7).

Historicamente, nos primeiros microprocessadores implementados, a limitação era onúmero de registradores que podiam ser implementados dentro do chip. No entanto, mesmodepois do desenvolvimento de tecnologias de alta integração em silício, o número deregistradores implementados dentro de um microprocessador permaneceu reduzido. Umgrande número de registradores implica nos sinais de clock terem que ser transmitidos porlongas distâncias para ir de um registro a outro, resultando em um aumento do período declock e assim tornando o microprocessador mais lento.

Linguagens de programação apresentam variáveis simples contendo estruturas dedados simples como nos exemplos 1, 2 e 3, mas também podem apresentar estruturas dedados complexas, tais como arrays e matrizes. Estas estruturas de dados complexas podemconter muito mais dados do que o número de registradores no microprocessador. Como omicroprocessador armazena e acessa tais estruturas complexas?

Uma vez que o microprocessador pode acessar somente uma pequena parte dos dadosnos registradores, estruturas de dados como arrays e matrizes são armazenados na memóriaprincipal. Operações aritméticas ocorrem somente entre registradores no microprocessadorMIPS. Assim o MIPS inclui, além de instruções aritméticas, instruções de transferência dedados. Para acessar uma palavra na memória, a instrução de transferência de dados devefornecer o seu endereço. A instrução de transferência de dados é chamada load (lw para oMIPS). O formato da instrução de load é o nome da operação seguido pelo registrador a sercarregado, o endereço de início do array e finalmente o registrador que contém o index doelemento do array a ser carregado. Assim, o endereço da memória contendo o elemento doarray é formado pela soma da parte constante da instrução com o registrador.

Exemplo 4: assuma que A é um array de 100 elementos cujo espaço de memória jáfoi alocado pelo compilador, e que o compilador associa as variáveis g, h, e i aos registradores

11

$17, $18 e $19. Assuma também que o compilador associou o endereço Astart como oendereço inicial para o array na memória. Traduza a linha de programa em C:

g = h + A[i];para o código assembler do MIPS.

lw $8, Astart ($19) # registrador temporário $8 recebe A[i]add $17, $18, $8 #g = h + A[i], onde $17 = g, $18 = h, $8 = A[i]

A instrução load, lw, soma o endereço de início do array Astart ao index i armazenadono registrador $19 para formar o endereço do elemento A[i]. O processador então lê amemória com o endereço A[i] (Astart ($19)) e coloca-o no registrador $8. A instrução addsoma o conteúdo do registrador $18 (variável h) ao elemento do array na posição $19(armazenado em $8).

A instrução complementar de load é store. Ela transfere dados de um registrador paraa memória. O formato de store é similar ao do load: o nome da operação, seguido doregistrador cujo conteúdo deve ser armazenado, o endereço de início do array, e finalmente oregistrador que contem o index para a posição do elemento no array a ser armazenado.

Exemplo 5: assuma que a variável L está associada ao registrador $18. Assumatambém que o registrador $19 contem o valor de index. Qual é o código assembler para oMIPS do seguinte comando em C:

A[i] = L + A[i];

Código assembler:lw $8, Astart ($19) # registrador temporário $8 recebe A[i]add $8, $18, $8 # registrador temporário $8 recebe L + A[i], onde L = $18sw $8, Astart ($19) # armazenar L + A[i] de volta em Astart ($19)

Note que foram necessárias 3 operações para somar 2 elementos, visto que operaçõesaritméticas só são realizadas entre registradores no MIPS. Assim, se um dos operandos estána memória principal, ele deve ser trazido para um dos registradores do microprocessadorantes de ser somado.

O número máximo de variáveis em um programa assembler é igual ao número deregistradores no processador. Como a maioria dos programas escritos em linguagem de altonível possuem mais variáveis do que o número de registradores disponíveis nosmicroprocessadores, o compilador precisa gerenciar o transbordamento de variáveis para amemória. Um compilador bem construído procura manter as variáveis utilizadas maisfreqüentemente nos registradores e coloca as variáveis restantes na memória. A otimização deum compilador consiste em minimizar o número de vezes em que uma variável armazenadana memória é acessada, porque o acesso à memória é muito mais lento do que o acesso a umregistrador. Ao mover uma variável para a memória para abrir espaço no conjunto deregistradores para uma nova variável o compilador deve tentar mover a variável que tem amenor probabilidade de ser utilizada no futuro próximo.

12

1.4. Organização da Memória

Desde os primórdios da computação, projetistas e programadores sempre desejaramgrandes quantidades de memória extremamente rápida. Existem várias técnicas quepermitem atingir este objetivo. Algumas destas técnicas serão apresentadas neste polígrafo, afim de ajudar projetistas e programadores a atingir este objetivo de memória rápida eilimitada.

Definições:

i) Localidade Temporal: se um item é referenciado, ele tende a ser referenciadonovamente em um futuro próximo.

ii) Localidade Espacial: se um item é referenciado, itens cujos endereços são vizinhosa este tendem a ser referenciados também em um futuro próximo.

Localidade temporal aparece em programas a partir de estruturas simples e naturais,por exemplo, muitos programas contém loops, de forma que instruções e dados tendem a seracessados repetidamente, mostrando altos níveis de localidade temporal. Uma vez queinstruções são acessadas seqüencialmente, programas mostram um alto grau de localidadeespacial, por exemplo, acessos a elementos de um array.

iii) Palavra: é a unidade mais comum de trabalho de um microprocessador. Diferentesmicroprocessadores podem ter palavras de diferentes tamanhos (1, 2 e 4 bytes são tamanhostípicos).

Nós podemos tirar vantagem do princípio de localidade para implementar umamemória de computador baseada em hierarquia. Uma hierarquia de memória consiste demúltiplos níveis de memória com diferentes velocidades e tamanhos. As memórias maisrápidas são mais caras por bit do que as memórias mais lentas e portanto elas sãonormalmente menores. A memória principal é normalmente implementada a partir deDRAMs (Dynamic Random Access Memories), enquanto que memórias em níveis inferiores,mais próximos do processador (memórias CACHE), são implementadas em SRAMs (StaticRandom Access Memories).

Memórias DRAM são mais baratas por bit que as SRAM, embora as memóriasdinâmicas sejam sensivelmente mais lentas. A diferença de preço se justifica porque DRAMsutilizam um menor número de transistores por bit e assim, estas memórias possuem maiorcapacidade de armazenar informação para a mesma área em silício. A diferença emvelocidade se justifica porque as células das SRAMs armazenam informação através dochaveamento de portas inversoras que estão ligadas entre si (cross-coupled), criando uma açãode realimentação extremamente rápida, menos susceptível ao ruído e com maior capacidadede drive de corrente das linhas de bit-line, e assim, sendo mais rápidas para se ler e escreverque as pequenas células das memórias DRAM.

Devido às diferenças de custo e de tempo de acesso, é vantagoso construir memóriascomo em hierarquia de níveis, com a memória mais rápida mais próxima do processador e amais lenta colocada mais distante do processador (fig. 1.16). Atualmente existem trêstecnologias principais para se construir hierarquias de memórias: SRAM, DRAM e disco

13

magnético. O tempo de acesso e o preço por bit variam largamente entre estas tecnologias, talcomo a fig. 1.17 mostra para valores típicos de 1993.

Fig. 1.16. Estrutura básica de uma hierarquia de memória. Através da implementação de um sistema de memóriahierárquico, o usuário tem a ilusão de que a memória é tão grande quanto a memória presente no nível maisbaixo, ao mesmo tempo que ela pode ser acessada na mesma velocidade que a memória no nível mais alto dahierarquia.

Fig. 1.17. Tempo de acesso e preço por bit para as três principais tecnologias usadas na concepção de sistemashierárquicos de memórias.

Fig. 1.18. Hierarquia de memória com dois níveis: inferior (mais lento, porém com maior capacidade dearmazenamento de informações) e superior (mais rápido, porém com pouca capacidade).

1.5. Quatro Princípios para Projeto de Processadores

i) Simplicidade favorece regularidade:Deve-se procurar projetar conjuntos de instruções em que as instruções possuam

mesmo tamanho. Os segmentos do programa em C abaixo possuem 10 variáveis(a,b,c,d,e,f,g,h,i,j):

14

Segmento 1: Código assembler para o MIPS:a = b + c; add a, b, cd = a - e; sub d, a, e

Segmento 2: Código assembler para o MIPS:f = (g + h) - (i + j); add t0, g, h # variável temporária t0 contem g + h

add t1, i, j # variável temporária t1 contem i + jsub f, t0, t1 # f armazena t0 - t1

Note que o compilador teve que criar 2 novas variáveis (temporárias), t0 e t1, e 2linhas adicionais de código para traduzir o segmento 2 do programa em C para a linguagemassembler a fim de poder manter a simplicidade e a regularidade do seu conjunto de instruçõesatravés do formato: [instrução] [registro de destino/origem] [op.1] [op.2]. Ou seja, se amaioria das instruções do computador apresentarem o mesmo formato e se cada linha conterapenas 1 instrução, o hardware que implementa tais funções é bem mais simples.

ii) Menor é mais rápido:Um número elevado de registradores resulta em acesso mais lento a estes

registradores. Portanto, dentro dos limites de cada tecnologia, um número reduzido deregistradores resulta em uma arquitetura mais rápida.

iii) Bom projeto implica em compromissos:Em todo projeto de engenharia existem objetivos conflitantes, o bom projetista de

computadores é aquele que consegue obter o melhor compromisso entre estes objetivos. Porexemplo, a inclusão de hardware dedicado para a execução de instruções em ponto flutuanteacelera o processamento, porém aumenta a área em silício necessária para implementá-la etorna o projeto das partes de Controle e Operativa relativamente mais complexo. Outrosexemplos:

1. um conjunto maior de instruções em um processador permite que ele trate maisrapidamente instruções específicas de deferentes aplicações, porém este conjunto não pode sermuito grande pois a implementação do hardware/software necessários ficariam muitocomplexos, comprometendo demasiadamente a velocidade de execução do processador.2. multiplexação do número de pinos de I/O de um processador: por exemplo, umprocessador que multiplexa 32 de seus pinos entre dados (32 bits) e endereços (32 bits); ouentão um processador que trabalha com barramento interno de dados de 64 bits e combarramento externo de 32 bits. Note que quanto maior o número de pinos, mais caro é oencapsulamento do chip, porém maior é o paralelismo obtido, resultando em umprocessamento mais rápido.

iv) Fazer o caso comum rápido:Nada adianta fazer com que uma instrução complicada, que raramente é executada,

seja rápida. O importante é que o caso comum que é executado freqüentemente seja executadocom rapidez.

15

1.6. Notas Históricas (Evolução das Arquiteturas)

Ao longo da história dos computadores, podem ser identificadas algumascaracterísticas que tipificam algumas eras. Os microprocessadores podem ser classificados deacordo com a quantidade de registradores e a função destes registradores:

i) Arquiteturas de Acumulador: a característica dos primeiros microprocessadores era aexistência de um registrador chamado de acumulador. Este registrador acumulava osresultados de todas as operações aritméticas realizadas no microprocessador. Nestas máquinasas operações aritméticas eram sempre realizadas entre o valor do acumulador e um valorarmazenado em memória.

ii) Registradores Dedicados: (HL do 8086) no lugar de um único registrador com a funçãoespecífica de acumulador, estas máquinas possuem vários registradores com funçõesespecíficas. (Ex: o par de registradores HL do 8086 é utilizado como um índice para endereçara memória).

iii) Registros de Uso Geral: a evolução dos registradores de uso dedicado resultou nasarquiteturas com registradores de uso geral. Nestes microprocessadores todos osregistradores são idênticos e podem ser usados sem restrição. As arquiteturas de registradoresde uso geral se sub-dividem em:

a) Registro-Memória: é permitida a realização de operações aritméticas em que umdos operandos está na memória e o outro em um registrador.

b) Carrega-Armazena: todas as operações são feitas exclusivamente com operandosque estão em registradores. Não é possível combinar um acesso à memória com umaoperação aritmética na mesma operação. Apesar desta arquitetura requerer um número maiorde instruções para realização de uma mesma tarefa, o ganho em velocidade devido àsimplicidade da arquitetura compensa o número maior de instruções executadas.

16

Capítulo 2

Análise de Desempenho

2.1. Definição de Desempenho

Avião Capacidade(# de passageiros)

Alcance(kilometros)

VelocidadeCruzeiro)

(km/h)

Capacidade deTransporte

(pass. x km/h)Boeing 737-100 101 1.008 957 96.637

Boeing 747 470 6.640 976 458.720BAC/Sud Concorde 132 6.400 2.160 285.120Douglas DC-8-50 146 13.952 870 127.078

Tabela 2.1. Capacidade, alcance e velocidade para aviões.

A tabela 2.1 apresenta a capacidade medida em número de passageiros, o alcancemedido em quilômetros, a velocidade cruzeiro medida em km/h e a capacidade de transportemedida em passageiros x km/h. A partir dos dados da tabela 2.1 pergunta-se qual o avião commelhor desempenho? Ao depararmo-nos com esta pergunta a primeira dúvida que surge écomo se define desempenho. Três possibilidades podem ser consideradas para definir o aviãocom maior desempenho:

• A maior velocidade cruzeiro é do Concorde;• O avião com maior alcance é o DC-8;• O avião com maior capacidade é o 747;

Se optarmos por definir desempenho em termos de velocidade, ainda restam duaspossibilidades:

17

1. O avião mais rápido é aquele que possui a maior velocidade cruzeiro, levandoum único passageiro de um ponto a outro (Concorde).

2. O avião mais rápido é aquele que consegue transportar um grande número depassageiros de um ponto a outro no menor intervalo de tempo (Boeing 747).

De maneira similar, para o usuário de um computador, o computador mais rápido éaquele que termina seu programa primeiro. Para o gerente de um centro de processamento dedados com vários computadores, é aquele que completa mais programas num curto espaço detempo.

Tempo de resposta tempo decorrido entre o início e o término de uma tarefa,incluindo acessos a disco, acessos à memória, atividades de entrada/saída, execução de outrosprogramas no caso de multiprogramação, onde vários programas são executadosconcorrentemente, etc... Também chamado tempo de execução.

Capacidade de processamento Quantidade total de trabalho realizado em umdeterminado intervalo de tempo (throughput).

Ao estudar desempenho, vamos nos concentrar no tempo de resposta ou tempo deexecução de um computador. O tempo de execução e o desempenho são inversamenteproporcionais:

Desempenho (x) = ________1__________ (1)

Tempo de Execução (x)

Comparando uma máquina x que possui maior desempenho do que uma máquina y,obtemos que o tempo de execução de y é maior do que o tempo de execução de x:

Desempenho (x) > Desempenho (y) (2)

________1__________ > ________1__________ (3)Tempo de Execução (x) Tempo de Execução (y)

Tempo de Execução (y) > Tempo de Execução (x) (4)

Para obter uma medida comparativa de desempenho, nós dizemos que “x é n vezesmais rápida do que y”, significando que:

Desempenho (x) = n (5)Desempenho (y)

Se x é n vezes mais rápida do que y, então o tempo de execução de y é n vezes maislongo do que o tempo de x.

Desempenho (x) = Tempo de Execução (y) = n (6)Desempenho (y) Tempo de Execução (x)

18

2.2. Relacionando Medidas (tempo de CPU, ciclos de clock, frequência)

Tempo de CPU de um Programa = # ciclos de clock X período de clock (7)

Tempo de CPU de um Programa = # ciclos de clock (8) Freqüência do clock

O projetista pode aumentar o desempenho reduzindo o período de clock ou o númerode períodos de clock necessário para executar o programa.

O número médio de clock por instrução é normalmente abreviado por CPI (clocks perinstruction).

# de ciclos de clock = # de instruções no programa X CPI (9)

Tempo de CPU = # de instruções X CPI X período de clock (10)

Tempo de CPU = # de instruções x CPI (11) Freqüência de clock

Projetistas podem obter o número de ciclos de CPU de um programa através daseguinte equação:

# Ciclos de CPU = Σ ni=1

(CPIi.Ci) (12)

onde Ci é o número de instruções tipo i no programa, CPIi é o número médio de períodos declock por instrução do tipo i e n é o número total de classes de instrução.

2.3. Medidas de Desempenho

Várias métricas foram criadas para substituir o tempo como medida de desempenho deum computador. Métricas simples que são válidas em um contexto limitado são comumenteusadas de forma errada.

2.3.1. MIPS

MIPS (Million Instructions per Second) é a medida da freqüência de execução de umadada instrução em uma máquina específica. Também é chamada de MIPS nativa.

MIPS = # de instruções = # de instruções (13)

Tempo de CPU X 106# ciclos CPU X período clock X 10

6

MIPS = # de instruções X Freqüência do clock = Freqüência do clock (14)

# de instruções X CPI X 106 CPI X 106

Portanto:MIPS = Freqüência do clock (15)

CPI X 106

19

MIPS mede a freqüência de execução de instruções, portanto MIPS especifica odesempenho inversamente ao tempo de CPU. Máquinas mais rápidas possuem um MIPS maiselevado.

O uso de MIPS como medida para comparar máquinas diferentes apresenta trêsproblemas:

• MIPS especifica a freqüência de execução de instruções. Ele depende do conjunto deinstruções da máquina. Não pode-se comparar máquinas com diferentes conjuntos de instruções poiso número de instruções executadas será certamente diferente.

• MIPS varia entre programas do mesmo computador uma vez que ele depende do tipo dasinstruções executadas. Portanto, a mesma máquina pode apresentar várias medidas de MIPS.

• MIPS pode variar inversamente com o desempenho. Exemplo: considere uma máquina comhardware dedicado para operações em ponto flutuante. Programas de ponto flutuante rodando nohardware opcional ao invés do hardware simples levam menos tempo de CPU, mas tem uma medidade MIPS inferior.

Isto ocorre porque programas em ponto flutuante quando executados via software (istoé, rodando em HW simples) executam instruções simples depois de compilados (portanto CPIbaixo, resultando em uma medida de MIPS elevada). Por outro lado, leva-se mais ciclos declock por instrução em ponto flutuante em HW dedicado do que para uma instrução eminteiros em HW simples (portanto CPI elevado) resultando em uma medida de MIPS baixa.

2.3.2. MFLOPS

MFLOPS (Million Floating-Point Operations per Second) mede o desempenho deoperações em ponto flutuante.

MFLOPS = # Operações de Ponto Flutuante (19)

Tempo de CPU x 106

Uma operação de ponto flutuante é uma adição, subtração, multiplicação ou divisãoaplicada a um número representado em ponto flutuante.

20

O uso de MFLOPS como medida para comparar máquinas diferentes apresenta trêsproblemas:

• MFLOPS depende do programa. Programas diferentes requerem a execução de diferentesnúmeros de operações de ponto flutuante.

• MFLOPS não pode ser aplicado para programas que não usam ponto flutuante.

• MFLOPS não é uma boa medida pois o conjunto de operações de ponto flutuante disponívelem cada máquina é diferente. Ex: o Cray-2 não tem instrução de divisão, enquanto que o Motorola68882 tem divisão, raiz quadrada, seno e cosseno. Assim, são necessárias ao Cray-2 váriasoperações de soma/subtração em inteiros para realizar uma única operação de ponto flutuante,enquanto que o Motorola 68882 necessita apenas uma única instrução.

2.3.3. Speedup

Um dos conceitos mais utilizados na avaliação de desempenho de um sistemacomputacional é o conceito de Speedup que pode ser traduzido simplesmente por “aumento develocidade”. O speedup é simplesmente definido como o quociente entre o desempenho deum sistema computacional depois e antes de uma melhoria:

Desempenho depois da melhoria

Speedup = _______________________________________

Desempenho antes da melhoria

Lembrando que o desempenho de um sistema computacional para uma determinadaaplicação é igual ao inverso do tempo necessário para executar a aplicação no sistema, ospeedup também pode ser medido como o quociente entre os tempos de execução antes edepois da melhoria:

Tempo de Execução antes da melhoria

Speedup = __________________________________________

Tempo de Execução depois da melhoria

Uma das relações mais conhecidas quando se trata da avaliação de performance decomputadores, especialmente na área de máquinas paralelas, é a Lei de Amdahl. A lei deAmdahl contempla o fato de que uma melhoria realizada em um sistema computacionalnormalmente afeta apenas uma parte das operações computacionais realizadas por aquelesistema. A Lei de Amdahl pode ser sumariada na seguinte relação:

TEX/DEP = TEX/AFE + TEX/NAF

QMEL

Onde TEX/DEP é o tempo de execução depois da melhoria ser aplicada ao sistema, TEX/AFE

é o tempo de execução afetado pela melhoria, QMEL é a quantidade de melhoria obtida na partedo sistema afetada pela melhoria (por exemplo, QMEL = 3 indica que a porção do sistemaafetada pela melhoria ficou três vezes mais rápida) e TEX/NAF é o tempo de execução nãoafetado pela melhoria.

21

Capítulo 3

Parte Operativa

3.1 Introdução

3.1.1. Notação em Complemento de 2

A notação em complemento de 2 é a forma mais comumente utilizada para representarnúmeros com sinal em computadores. Nesta notação, se o bit mais significativo (o bit mais àesquerda quando o número é escrito) é igual a 0, o número é considerado positivo e o seuvalor decimal pode ser lido diretamente pela maneira convencional de conversão de valoresbinários para valores decimais. No entanto, se o bit mais significativo é igual a um, o númeroé negativo e a sua magnitude pode ser encontrada invertendo-se bit-a-bit a representaçãobinária, somando-se 1 ao valor invertido e fazendo-se a conversão normal de binário paradecimal. Esta operação é ilustrada na fig. 3.1.

0010 = +2

1101 : inverte

+ 1 : soma 1

1110 = -2

0001 : inverte

+ 1 : soma 1

0010 = +2

0010 = +2

+ 1110 = -2

0000 = 0

(a) Inversão de sinais (b) Soma de números complementares.

Fig. 3.1. Operações em Complemento de 2.

22

3.1.2. Overflow

Overflow ocorre quando o número de bits do resultado é maior do que a capacidade derepresentação da arquitetura. A fig. 3.2 mostra situações de ocorrência de overflow emaritmética em complemento de dois em uma arquitetura de 8 bits. Overflow pode ocorrertanto em operações de adição quanto de subtração. Uma situação de overflow pode serdetectada analisando-se os sinais dos operandos, o tipo de operação e o sinal do resultado. Atabela 3.1 apresenta as situações em que ocorre overflow.

01111111 = + 127

+ 00000010 = + 2

10000001 = - 127

10000001 = - 127

- 00000010 = + 2

|||

10000001 = - 127

+ 11111110 = - 2

101111111 = + 127

(a) Adição (b) Subtração

Fig. 3.2. Ocorrência de overfow em operações aritméticas.

Operação Sinal do Operando A Sinal do Operando B Sinal do Resultado

A+B + + -

A+B - - +

A-B + - -

A-B - + +

A+B + - não

A+B - + não

A-B + + não

A-B - - não

Tabela 3.1. Condições para ocorrência de overflow.

A detecção de overflow (transbordamento) e a decisão de o que fazer no caso deocorrência de overflow é feita pelo projetista do processador. Pode-se gerar uma exceçãoforçando-se assim o software a tomar uma ação no caso de ocorrência de overflow, ou pode-seapenas setar um flag indicando que ocorreu overflow. Neste último caso é responsabilidade doprogramador verificar este flag e tomar alguma providência no caso de ocorrência deoverflow.

3.2. Unidade Lógica e Aritmética para Computadores (ULA)

A Unidade Lógica e Aritmética é o componente principal da parte operativa dequalquer microprocessador. Ela realiza operações aritméticas como adição e subtração e

23

operações lógicas como "E" e "OU". A seguir, demonstramos como uma ULA pode serconstruída a partir das 4 funções lógicas elementares mostradas na fig. 3.3.

1. Porta E : (c = a . b)

a b c = a . b0 0 00 1 01 0 01 1 1

2. Porta OU : (c = a + b)

a b c = a + b0 0 00 1 11 0 11 1 1

3. Inversor : (c = a)

a c

a c = ^a0 11 0

4. Multiplexador: (Se d = 0 então c ←←←← asenão c ←←←← b)

d c

0 a

1 b

Fig. 3.3. Funções Lógicas Elementares.

Uma Unidade Lógica de um bit pode ser construída utilizando-se uma porta E, umaporta OU e um multiplexador como ilustrado na fig. 3.4.

A próxima função a incluir é a soma. Para construir um somador de 1 bit, devemosconsiderar como a soma é realizada. Conforme indicado na fig. 3.5, cada somador de 1 bit temtrês entradas: os 2 operandos e o vem-um (carry-in) que é oriundo do transbordamento do bitimediatamente anterior, e produz duas saídas: 1 bit soma e 1 bit de vai-um (carry-out) que seráusado no somador do bit posterior.

24

A “tabela verdade” do somador de 1 bit é apresentada na fig. 3.6. Observe que a saída"Vai-Um" será igual a 1 se e somente se pelo menos duas das entradas forem 1simultaneamente. A saída soma será igual a um se e somente se um número ímpar de entradasfor igual a 1.

Fig. 3.4. Unidade Lógica de 1 bit para as operações "E"e "OU".

��

��

A B Carry-in

Carry-out

Soma

��

��

��

Somador Completo (Full Adder)

��

A B

Carry-out

Soma

��

��

Somador Parcial (Half Adder)

��

Fig. 3.5. Somador de 1 bit.

Entradas Saídasa b Vem-um Vai-um Soma Comentários0 0 0 0 0 0+0+0=00two0 0 1 0 1 0+0+1=01two0 1 0 0 1 0+1+0=01two0 1 1 1 0 0+1+1=10two1 0 0 0 1 1+0+0=01two1 0 1 1 0 1+0+1=10two1 1 0 1 0 1+1+0=10two1 1 1 1 1 1+1+1=11two

Fig. 3.6. Tabela verdade do somador de 1 bit.

25

Juntando a unidade lógica de 1 bit e o somador de 1 bit, podemos construir umaUnidade Lógica e Aritmética (ULA) de 1 bit conforme ilustrado na fig. 3.7. Observe queagora estamos utilizando um multiplexador com três entradas, portanto precisaremos de doisbits para especificar a operação a ser realizada na ULA.

A ULA mostrada na fig. 3.7 possui uma séria limitação: ela não subtrai. Lembrando queem notação de complemento de 2, pode-se obter o complemento de um número invertendo-setodos os bits e somando-se 1, podemos incluir a operação de subtração conforme ilustra a fig.3.8, utilizando um segundo multiplexador e um inversor. Agora para realizar a operação desubtração devemos especificar a inversão do operando b e colocar 1 na entrada vem-um dosomador.

Fig. 3.7. Unidade Lógica e Aritmética de 1 bit.

Finalmente, 32 destas ULAs de 1 bit podem ser conectadas para formar uma ULA de 32bits, conforme ilustrado na fig. 3.9.

Soma

Fig. 3.8. ULA de 1 bit que soma, subtrai e realiza as operações lógicas "E" e "OU".

26

a0

b0

a1

b1

a2

b2

a31

b31

ALU0

ALU1

ALU2

ALU31

::

:

:

Resultado 0

Resultado 1

Resultado 2

Resultado 31

Vem-Um

Vem-Um

Vem-Um

Vem-Um

Vem-Um

Vai-Um

Vai-Um

Vai-Um

Vai-Um

OperaçãoInverte

Fig. 3.9. ULA de 32 bits.

O símbolo mais comumente utilizado para representar uma ULA na representação emdiagrama de blocos de o sistema é mostrado na fig. 3.10.

Carry-out

ZeroResultadoOverflow

a

ALU

Operação

3

b

Linhas de Controle da ULA

OperaçãoInverte

00

01

10

10

0

0

0

1 subtrai

soma

OU

E

Função

Fig. 3.10. Símbolo para ULA (a linha "Operação" inclui as linhas "Inverte" e "Operação" da fig. 3.8).

3.3. Operação de Soma (Carry Lookahead)

O crescimento linear do delay com o tamanho da palavra de entrada (conforme vistoanteriormente) pode ser melhorado através do cálculo dos carries de cada estágio em paralelo.O carry do estágio Ci pode ser expresso como:

27

Ci = Gi + Pi.Ci-1 [1]

onde Gi = Ai.Bi (generate signal) [2]Pi = Ai + Bi (propagate signal). [3]

Expandindo [1], temos:

Ci = Gi + PiCi-1 + PiPi-1Gi-2 + ... + Pi ... P1C0

A soma Si é gerada por:Si = Ci-1 ⊕ Ai ⊕ Bi = Ci-1 ⊕ Pi

A quantidade de portas lógicas necessárias para implementar este somador podeclaramente explodir exponencialmente. Como conseqüência, o número de estágios dolookahead é normalmente limitado a quatro. Para um somador de quatro estágios (quatro bits),os termos apropriados são os seguintes:

C1 = G1 + P1.C0

C2 = G2 + P2G1 + P2P1C0

C3 = G3 + P3G2 + P3P2G1 + P3P2P1C0

C4 = G4 + P4G3 + P4P3G2 + P4P3P2G1 + P4P3P2P1C0

Duas possíveis implementações para este somador carry lookahead podem ser vistasna fig. 3.11.

(a)

28

��

�� C1

��

��

P1

C0

G1 �� C2

G2

P2

P3

��

��

C3

��

��

��

��

��

G3

��

��

A1

B1

P1

��

�� G1

��

��

A2

B2

P2

�� G2

��

A3

B3

P3

��

G3

��

A1

B1 S1

�� S2

��

��

S3

C0

A2

B2

C1

A3B3C2

(b)

Fig. 3.11. Somador Carry Lookahead de 4 bits.

3.4. Operação de Multiplicação

Nesta seção vamos estudar dois algoritmos de multiplicação. Começaremos com umalgoritmo simples para compreender o fluxo de dados. Em seguida apresentaremos oAlgoritmo de Booth, que é um dos algoritmos mais utilizados na prática. A escolha dosprojetistas pelo Algoritmo de Booth se justifica pelo fato dele poder multiplicar númerospositivos e negativos, independentemente dos seus sinais.

Os dois operandos a serem multiplicados são chamados de multiplicando emultiplicador e o resultado é chamado de produto:

Multiplicando: BMultiplicador: x A .Produto: C

29

Para implementar um algoritmo de multiplicação em hardware necessitamos doisregistradores: o registrador do Multiplicando e o do Produto. Se considerarmos umamultiplicação de números com n bits, o registrador do Produto deverá ter 2n bits. Oregistrador do Produto é dividido em duas partes: produto(alto) e produto(baixo). A partesuperior do registrador do Produto, produto(alto), com n bits, é inicializada com 0s, enquantoque o multiplicando é colocado no registrador do Multiplicando e o multiplicador é colocadona parte inferior do registrador do Produto: produto(baixo). A operação deste primeiroalgoritmo de multiplicação pode ser descrita conforme visto na fig. 3.12.

MULTIPLICAÇÃO 1:

1. produto (alto) ← ∅2. produto (baixo) ← multiplicador

3. for i ← ∅ to 31

4. do if multiplicador (∅ ) = 1

5. then produto (alto) ← produto (alto) + multiplicando

6. produto ← produto >> 1

Fig. 3.12. Algoritmo Multiplicação 1.

Exemplo: 510 x 210 = 001012 x 000102, onde: multiplicador: 00101 (510)multiplicando: 00010 (210)

Iteração Operação Multipli

cando

Produto

alto baixo

Multiplicador(0)

0 Inicialização 00010 00000 00101 1

1 Prod ← Prod + Mult 00010 00010 00101

Prod ← Prod >> 1 00010 00001 00010 0

2 Sem operação 00010 00001 00010

Prod ← Prod >> 1 00010 00000 10001 1

3 Prod ← Prod + Mult 00010 00010 10001

Prod ← Prod >> 1 00010 00001 01000 0

4 Sem operação 00010 00001 01000

Prod ← Prod >> 1 00010 00000 10100 0

5 Sem operação 00010 00000 10100

Prod ← Prod >> 1 00010 00000 01010 0

↓ 1010

O hardware necessário para implementar este algoritmo é mostrado na fig. 3.13.Este algoritmo estudado faz a multiplicação de números inteiros positivos. Para operar

números inteiros negativos, poderíamos transformá-los em positivos, realizar a multiplicaçãoe negar o resultado se os operandos fossem de sinais opostos.

Um algoritmo mais elegante para multiplicar números com sinal é o Algoritmo deBooth. Para entender este algoritmo, observamos que existem várias maneiras para calcular oproduto de dois números. Ao encontrar uma seqüência de 1s no multiplicador, ao invés de

30

realizar uma soma para cada um dos 1s da seqüência, o Algoritmo de Booth faz umasubtração ao encontrar o primeiro 1 e uma soma após o último.

PRODUTO

MULTIPLICANDO

32

32 32

ALU DE 32 BITS

SOMA

64 BITS

CONTROLEPRODUTO

DESLOCA À DIREITA

BIT

Multiplicador(φ)φ

Fig. 3.13. Hardware para Multiplicação 1.

000010

x 001110

000000

+ 000010 (soma)

+ 000010 (soma)

+ 000010 (soma)

000000

000000 _

00000011100

000010 = 210

x 001110 = 1410

000000

- 000010 (subtração)

000000

000000

+ 000010 (soma)

000000 .

00000011100 = 2810

(a) (b)

Fig. 3.14. Multiplicação de +2 por +14 representados em 6 bits: (a) Método tradicional; (b) Método de Booth.

Observe no exemplo apresentado na fig. 3.14 que enquanto o método tradicionalnecessitou de 3 operações aritméticas para efetuar a multiplicação, o método de Boothcompletou a multiplicação com apenas 2 duas. Podem-se construir exemplos em que ométodo de Booth necessita mais operações aritméticas. No entanto, como números negativosrepresentados em complemento de dois tendem a possuir uma longa seqüência de uns em suarepresentação, a multiplicação destes números pelo método de Booth é em geral mais rápida.Na representação do algoritmo de multiplicação de Booth da fig. 3.15, produto(alto)representa a metade alta do registrador de produto, produto(baixo) representa a metade baixado registrador de produto, produto(0) representa o bit menos significativo do registrador deproduto e bit_à_direita representa um bit armazenado em hardware e que memoriza qual era ovalor do bit à direita do bit do multiplicador que está sendo processado. O símbolo >>aritmético

indica um deslocamento aritmético à direita. Quando um deslocamento aritmético é realizado,0s são introduzidos à esquerda se o bit mais significativo do número original era 0, e 1s sãointroduzidos à esquerda se o bit era 1. Em outras palavras, o deslocamento preserva o sinal dooperando.

31

BOOTH:

1. produto (alto) ← ∅

2. produto (baixo) ← multiplicador

3. bit_à_direita ← ∅

4. for i ← ∅ to 31

5. do if bit_à_direita = ∅ and produto (∅ ) = 1

6. then produto (alto) ← produto (alto) - multiplicando

7. else if bit_à_direita = 1 and produto (∅ ) = ∅

8. then produto (alto) ← produto (alto) + multiplicando

9. bit_à_direita ← produto (∅ )

10. produto ← produto >>aritmético 1

Fig. 3.15. Algoritmo de Booth.

Lembrando que a operação de soma pode levar bastante tempo para ser realizada porcausa do tempo necessário para propagar o “vai-um” até o bit mais significativo, e lembrandotambém que a subtração é feita pelo mesmo circuito do somador, o Algoritmo de Boothoferece a vantagem de redução do número de operações na ULA quando o multiplicadorpossui uma seqüência longa de 1s.

Verifique no hardware para o algoritmo de Booth apresentado na fig. 3.16 a presençade um bit extra de armazenamento. Este bit é necessário para “lembrar” o bit à direita do bitque está sendo processado.

MULTIPLICANDO

32 32

32

PRODUTO

DESLOCAMENTO

SOMA/SUBTRAI

Bit à Direita

Produto(0)CONTROLE

Fig. 3.16. Hardware para Algoritmo de Multiplicação de Booth.

No exemplo a seguir, o Algoritmo de Booth é usado para multiplicar númerosnegativos expressos em notação complemento de 2.

Exemplo 1: -310 x 210 = 0010 x 1101, onde:multiplicador: 1101 (-310)multiplicando: 0010 (210)Obs.: -210 = 1110.

32

Iteração Operação Multiplicando

Produtoalto baixo

Bit à direita/Produto(0)

0 Inicialização 0010 0000 1101 0 / 1

1 Prod(alto) ← Prod(alto) - Mult 0010 1110 1101

Prod ← Prod >>aritmético 1 0010 1111 0110 1 / 0

2 Prod(alto) ← Prod(alto) + Mult 0010 0001 0110


3 Prod(alto) ← Prod(alto) - Mult 0010 1110 1011


4 Sem operação 0010 1111 0101


↓ −6

Exemplo 2: -210 x -210 = 1110 x 1110, onde:multiplicador: 1110 (-210)multiplicando: 1110 (-210)

Iteração Operação Multiplicando

Produtoalto baixo

Bit à direita/Produto(0)

0 Inicialização 1110 0000 1110 0 / 0

1 Sem operação 1110 0000 1110


2 Prod ← Prod - Mult 1110 0010 0111


3 Sem operação 1110 0001 0011


4 Sem operação 1110 0000 1001


↓ 4

3.5. Operação de Divisão

Dividendo = A | B = Divisor C = Quociente .

R = Resto

A divisão pode ser computada com o mesmo hardware da multiplicação:

32

ALU DE 32 BITS

CONTROLEDesloca

Soma/Subtrai

DIVISOR

RESTO

33

E o algoritmo para a divisão pode ser visto na fig. 3.17.

DIVISÃO:

1. resto (alto) ← ∅

2. resto (baixo) ← dividendo

3. resto ← resto << 1

4. For i ← ∅ to 31

5. do resto (alto) ← resto (alto) - divisor

6. if resto(alto) < ∅

7. then resto (alto) ← resto (alto) + divisor

8. resto ← resto << 1

9. else resto ← resto <<aritmético 1

10. resto(alto) ← resto(alto) >> 1

Fig. 3.17. Algoritmo de Divisão.

Exemplo 1: 710 ÷ 210 = 0111 ÷ 0010, onde: dividendo: 0111 (710)divisor: 0010 (210)Obs: -2 = 11102

Iteração Operação Divisor Restoalto baixo

0 Inicialização 0010 0000 0111

Resto ← Resto << 1 0010 0000 1110

1 Resto(alto) ← Resto(alto) - Divisor 0010 1110 1110

Resto < 0 : Resto(alto) ← Resto(alto) + Divisor 0010 0000 1110

Resto ← Resto << 1 0010 0001 1100

2 Resto ← Resto - Divisor 0010 1111 1100

Resto(alto) < 0 : Resto(alto) ← Resto(alto) + Divisor 0010 0001 1100

Resto ← Resto << 1 0010 0011 1000


Resto > 0 : Resto ← Resto <<aritmético 1 0010 0011 0001



- Resto (alto) ← Resto (alto) >> 1 0010 0001 0011

Resto / Quoc.

Exemplo 2: 810 ÷ 310 = 01000 ÷ 00011, onde:dividendo: 01000 (810)divisor: 00011 (310)Obs: -3 = 111012

34

Iteração Operação Divisor Restoalto baixo

0 Inicialização 00011 00000 01000

Resto ← Resto << 1 00011 00000 10000


Resto < 0 : Resto + Divisor 00011 00000 10000

Resto ← Resto << 1 00011 00001 00000



Resto ← Resto << 1 00011 00010 00000



Resto ← Resto << 1 00011 00100 00000





Resto ← Resto << 1 00011 00100 00010

- Resto (alto) ← Resto (alto) >> 1 00011 00010 00010

Resto / Quoc.

Até o momento números negativos foram ignorados na divisão. A maneira maissimples é lembrar dos sinais do divisor e do dividendo e então negar o quociente se os sinaissão diferentes. Note que a seguinte equação deve ser verificada:

Dividendo = Quociente x Divisor + Resto

Assim, veja o exemplo: +7 ÷ +2: quociente = +3 e resto = +1 -7 ÷ +2: quociente = -3 e resto = -1 +7 ÷ -2: quociente = -3 e resto = +1 -7 ÷ -2: quociente = +3 e resto = -1

Desta forma, não basta apenas inverter o sinal do quociente quando os sinais dodividendo e do divisor forem diferentes, também é preciso notar que o sinal do resto sempre éo mesmo do dividendo.

3.6. Notação em Ponto Flutuante

Permite a representação de números reais e de números com magnitudes muitodiferentes em uma forma padrão. A representação utilizada é a notação científica em que oponto decimal é colocado à direita do primeiro algarismo significativo e a magnitude donúmero é armazenada no expoente.

39

Capítulo 4

Arquiteturas em Pipeline

4.1. Organização de uma Máquina Pipeline

A maioria das arquiteturas e processadores projetadas depois de 1990 possuem umaorganização chamada pipeline. A tradução literal de “pipeline” seria “linha de dutos”, umatradução mais aproximada do significado que este termo assume em arquiteturas decomputadores seria “linha de montagem”. Organizar a execução de uma tarefa em pipelinesignifica dividir a execução desta tarefa em estágios sucessivos, exatamente como ocorre naprodução de um produto em uma linha de montagem.

Em um microprocessador, a execução de uma instrução é tipicamente dividida emcinco estágios: busca da instrução, decodificação da instrução, execução da instrução,acesso à memória e escrita de resultados. Esta divisão da execução em múltiplos estágiosaumenta o desempenho do processador pois é possível ter uma instrução diferente executandoem cada estágio ao mesmo tempo.

A passagem de uma instrução através dos diferentes estágios do pipeline é similar àprodução de um carro em uma linha de montagem. Existem algumas regras muito importantesque devem ser seguidas quando se projeta uma arquitetura em pipeline:

1. Todos os estágios devem ter a mesma duração de tempo.2. Deve-se procurar manter o pipeline cheio a maior parte do tempo.3. O intervalo mínimo entre o término de execução de duas instruções

consecutivas é igual ao tempo de execução do estágio que leva mais tempo.4. Dadas duas arquiteturas implementadas com a mesma tecnologia, a

arquitetura que é construída usando pipeline não reduz o tempo de execução de instruções,mas aumenta a freqüência de execução de instruções (throughput).

40

A execução que ocorre em cada um dos estágios é descrita a seguir:

1) Busca de Instrução: O contador de programa é usado para buscar a próximainstrução. As instruções são usualmente armazenadas em uma memória cache que é lidadurante o estágio de busca.

2) Decodificação de Instruções e Busca de Operandos: O código da instrução ébuscado, os campos são analisados e os sinais de controle são gerados. Os campos dasinstruções referentes aos registradores são usados para ler os operandos no banco deregistradores.

3) Execução de Instruções: A operação especificada pelo código de operação éexecutada. Para uma instrução de acesso à memória, o endereço efetivo da memória écalculado.

4) Acesso à Memória: Dados são carregados da memória ou escritos na memória.Uma cache de dados é tipicamente utilizada.

5) Escrita de Resultados: O resultado da operação é escrito de volta no banco deregistradores.

IF ID EX ME WB

→→→→ →→→→ →→→→ →→→→ →→→→

Busca Decodifica Executa Acessa Escreve nosInstrução Instrução Instrução Memória Registradores

Fig. 4.1. Estrutura de uma máquina pipeline.

Cada um dos retângulos mostrados na fig. 4.1 representa um banco de “flip-flops” quesão elementos de memória utilizados para armazenar os resultados no final de cada estágio dopipeline. Os pipelines utilizados em microprocessadores são síncronos, portanto um sinal derelógio não mostrado na fig. 4.1 habilita o elemento de memória a “passar” seus resultadospara o estágio seguinte. Como existe um único relógio para comandar o pipeline, o tempogasto em todos os estágios do pipeline é idêntico e não pode ser menor o que o tempo gastono estágio mais lento. Este tempo gasto em cada estágio é o período do clock utilizado paracomandar o pipeline e ele determina a velocidade de execução das instruções.

A latência de um pipeline é o tempo necessário para uma instrução atravessar todo opipeline. Portanto para calcular o tempo de latência de uma máquina com pipeline bastamultiplicar o período do clock pelo número de estágios no pipeline. A latência é importanteapenas para se determinar quanto tempo a execução da primeira instrução leva para sercompletada.

Estágio do pipeline onde a instrução se encontraCiclo de Clock 0 1 2 3 4 5 6 7

Instrução 1 IF ID EX ME WBInstrução 2 IF ID EX ME WBInstrução 3 IF ID EX ME WBInstrução 4 IF ID EX ME WB

Fig. 4.2. Execução de uma seqüência de instruções num pipeline.

41

4.2. Geração de Bolhas no Pipeline

Uma "bolha" em um pipeline consiste em uma seqüência de um ou mais períodos declock em que um estágio do pipeline está vazio. Se um estágio do pipeline estiver vazio nociclo de clock n, consequentemente o estágio seguinte estará vazio no ciclo de clock n+1.

Desta forma bolhas formadas na entrada de um pipeline propagam-se através dopipeline até desaparecerem no último estágio. Situações que geram bolhas em pipelinesincluem:

1) a execução de instruções de desvio,2) o atendimento de interrupções,3) o tratamento de exceções,4) o retardo na execução de instruções devido a dependências existentes

com instruções que a precedem.

No caso de atendimento de exceções e interrupções não existem muitas técnicasefetivas para minorar o problema da formação de bolhas no pipeline pois estas ocorrências sãobastante imprevisíveis.

No caso de execução de desvios condicionais a formação de bolhas pode ser reduzidaatravés da utilização de predição de ocorrência e desvio.

No caso de dependências, a formação de bolhas pode ser minorada através doreordenamento de instruções. Vamos examinar estas técnicas nas próximas seções.

4.3 Previsão de Desvios

O problema introduzido por desvios condicionais em arquiteturas organizadas empipeline é que quando o desvio é decodificado na unidade de decodificação de instruções éimpossível decidir se o desvio será executado ou não. Isto é, não pode-se determinar a prioriqual a próxima instrução a ser executada. Existem duas possibilidades:

a) a condição que determina o desvio é falsa e o desvio não é executado, neste caso apróxima instrução a ser executada é a instrução seguinte à instrução de desvio no programa;

b) condição é verdadeira e o endereço da próxima instrução a ser executada édeterminada pela instrução de desvio.

Como determinar qual a próxima instrução a ser buscada quando uma instrução dedesvio condicional é decodificada?

A forma mais simples e menos eficaz de tratar um desvio condicional consiste emsimplesmente paralizar a busca de instruções quando uma instrução de desvio condicional édecodificada. Com esta forma de tratamento de desvio garantimos que todo desviocondicional gerará uma bolha no pipeline pois a busca de instrução ficará paralizada até quese possa decidir se o desvio será executado ou não. Esta técnica só deve ser utilizada quandoo custo de buscar e depois ter que descartar a instrução errada é muito alto.

Uma outra forma é tentar prever o que vai acontecer com o desvio. Neste caso aprevisão pode ser estática ou dinâmica. A previsão estática é aquela em que dada umainstrução de desvio em um programa nós vamos sempre fazer a mesma previsão para aquelainstrução. Observe que podemos fazer previsões diferentes para diferentes instruções de

42

desvio no mesmo programa. Na previsão dinâmica podemos mudar a previsão para umamesma instrução de branch à medida que o programa é executado.

4.3.1 Previsão Estática

A forma mais simples de previsão estática é aquela em que a mesma previsão é feitapara um dado desvio condicional. Esta técnica de previsão é simples de implementar e podetomar duas formas:

• Os desvios condicionais nunca ocorrem: Assumindo que os desvios condicionaisnunca ocorrem, simplesmente se continua o processamento normal de instruçõesincrementando o PC e buscando a instrução seguinte. Se for determinado mais tarde que oprograma deve desviar as instruções buscadas terão que ser descartadas e os efeitos dequaisquer operações realizadas por elas devem ser anulados.

• Os desvios condicionais sempre ocorrem: Assumindo que os desvioscondicionais sempre ocorrem é necessário calcular o endereço de desvio muito rapidamente jána Unidade de Decodificação de Instrução para dar tempo de buscar a nova instrução noendereço especificado pela instrução de desvio.

Algumas observações feitas por projetistas de computadores após analisar diversosprogramas indicam que um grande número de desvios ocorre no final de laços de programa.Se um laço de programa for executado n vezes, o desvio que se encontra no final do laço iráocorrer n vezes e não ocorrer uma vez no final do laço. Alguns programadores tambémobservaram que desvios condicionais originados por comandos IF em linguagens de ao níveltendem a não ocorrer. Portanto, existe evidências de que seria desejável possuir-se acapacidade de fazer previsão estática diferenciada para diferentes instruções de desvio em ummesmo programa (ex: beq sempre ocorre, bne nunca ocorre, etc...).

Uma solução para esta situação consiste em adicionar um bit no código de instruçõesde desvio condicional para informar o hardware se aquele desvio será provavelmenteexecutado ou provavelmente não executado. Este bit deverá ser especificado pelo compilador.Como a determinação de que a previsão será de execução ou não do desvio é feita em tempode compilação, este método de previsão também é estático.

4.3.2 Previsão Dinâmica

Na previsão dinâmica de desvios condicionais uma mesma instrução de desvio podereceber uma previsão de ser ou não executada em diferentes momentos do programa. Umasolução comum é criar uma tabela de desvios em hardware. Esta tabela pode ser gerenciadana forma de uma cache (Content Addressable Memory - CAM). A cada vez que umainstrução de desvio é executada ela é adicionada à tabela e um bit é setado ou resetado paraindicar se o desvio foi executado ou não. Na tabela também é registrado o endereço para qualo desvio foi realizado. Desta forma na próxima vez que a mesma instrução de desvio fordecodificada, esta tabela é consultada e a previsão feita é de que a mesma coisa (execução ounão execução do desvio) vai ocorrer de novo. Se a previsão for de execução do desvio oendereço no qual a nova instrução deve ser buscada já se encontra nesta tabela.

43

4.4 Processamento de Exceções

A ocorrência de exceções em um computador é imprevisível e portanto numa máquinaem pipeline uma exceção normalmente resulta na formação de bolhas. Uma complicaçãoadicional é que como existem várias instruções em diferentes estágios de execução ao mesmotempo, é difícil decidir qual foi a instrução que causou a geração da exceção. Uma soluçãopara minorar este problema é categorizar as exceções de acordo com o estágio do pipeline emque elas ocorrem. Por exemplo uma instrução ilegal só pode ocorrer na unidade dedecodificação de instruções (ID) e uma divisão por zero ou uma exceção devida a overflow sópode ocorrer na unidade de execução (EX).

Algumas máquinas com arquitetura em pipeline são ditas ter exceções imprecisas.Nestas máquinas não é possível determinar qual a instrução que causou a exceção.

Uma outra complicação nas arquiteturas em pipeline é o aparecimento de múltiplasexceções no mesmo ciclo de clock. Por exemplo uma instrução que causa erro aritméticopode ser seguida de uma instrução ilegal. Neste caso a unidade de execução (EX) gerará umaexceção por erro aritmético e a unidade de decodificação (ID) gerará uma exceção porinstrução ilegal, ambas no mesmo ciclo de clock. A solução para este problema consiste emcriar uma tabela de prioridade para o processamento de exceções.

4.5 Bolhas Causadas por Dependências

Uma outra causa de formação de bolhas em arquiteturas com pipeline são asdependências existentes entre instruções num programa. Para ilustrar estre problema, vamosconsiderar o exemplo de pseudo programa assembler apresentado a seguir. Este pseudocódigo foi escrito com uma simbologia muito similar à simbologia utilizada pela Motorolapara os processadores da família MC68000. O trecho de programa abaixo permuta os valoresarmazenados nas posições $800 e $1000 da memória.

inst.: A MOVE $800, D0; copia o valor do endereço $800 no registrador D0 B MOVE $1000, D1; copia o valor do endereço $1000 no registrador D1 C MOVE D1, $800; copia o valor do registrador D1 no endereço $800 D MOVE D0, $1000; copia o valor do registrador D0 no endereço $1000

WB A B C DME A B C DEX A B C DID A B C C C DIF A B C D D D

Período clock 1 2 3 4 5 6 7 8 9 10

Fig. 4.3. Formação de bolha devido à dependência entre instruções.

Observe na fig. 4.3 que no período de clock 6 quando a instrução C deveria executarno estágio de escrita na memória (ME) para escrever o valor de D1 no endereço $800, o valorlido do endereço $1000 ainda não está disponível em D1 pois ele só será escrito quando ainstrução B tiver executado no estágio de escrita nos registradores (WB), o que ocorre

44

também no período de clock 6. Portanto a execução da instrução C necessita ser atrasada pordois ciclos de relógio, gerando uma bolha no pipeline.

Uma forma simples de resolver este problema consiste em reordenar as instruções noprograma, conforme ilustrado a seguir.

inst.: B MOVE $1000, D1; copia o valor do endereço $1000 no registrador D1 A MOVE $800, D0; copia o valor do endereço $800 no registrador D0 C MOVE D1, $800; copia o valor do registrador D1 no endereço $800 D MOVE D0, $1000; copia o valor do registrador D0 no endereço $1000

WB B A C DME B A C DEX B A C DID B A C C DIF B A C D D

Período clock 1 2 3 4 5 6 7 8 9 10

Fig. 4.4. Minimização de bolhas por reordenamento de instruções.

A fig. 4.4 ilustra que um simples reordenamento de instruções é suficiente neste casopara minimizar a bolha gerada pela dependência. Observe que o tempo total para a execuçãoda seqüência de instruções foi reduzido de 1 ciclo de clock.

Existem situações em que um simples reordenamento de instruções não é suficientepara minimizar (ou eliminar) bolhas causadas por dependências. Considere o programa abaixoque realiza a inversão de uma tabela de palavras localizada entre os endereços $1000 e $9000da memória.

A MOVEA #$1000, A0; inicializa A0B MOVEA #$9000, A1; inicializa A1C LOOP MOVE (A0), D0; copia em D0 dado apontado por AOD MOVE (A1), D1; copia em D1 dado apontado por A1E MOVE D0, (A1); copia valor em D0 no end. indicado em A1F MOVE D1, (A0); copia valor em D1 no end. indicado em A0G ADDQ #2, A0; incrementa o valor de A0H SUBQ #2, A1; decrementa o valor de A1I CMPA A0, A1; compara os endereços em A0 e A1J BGT LOOP; enquanto A1 é maior que A0, continuaK MOVE #$500, A0; inicia outro procedimentoL MOVE #$17000, A1; inicia outro procedimento

WB - - C D - - G H - -ME - - C D E F G H - -EX A B C D E F G H I JID A B C D E E F G H I I I J K CIF A B C D E F F G H I J J J K L C DClk 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Fig. 4.5. Execução do programa com loop.

45

Conforme ilustrado na fig. 4.5, o laço do programa que efetivamente transfere osdados para fazer a inversão da tabela de palavras necessita de 12 ciclos de clock para executar.Para inverter uma tabela com n palavras é necessário executar este laço n/2 vezes. Portanto onúmero de ciclos de clock necessário para realizar a inversão da tabela é 6n (supondo quecada instrução é executada em apenas 1 ciclo de clock).

A fig. 4.5 indica a formação de 3 bolhas dentro da execução do loop:1) a primeira bolha aparece no ciclo de clock 7 quando a instrução E tem que esperar

até o fim do WB da instrução C. Em outras palavras, ela tem que aguardar até que o novovalor do registrador D0 produzido pela instrução C seja escrito no estágio de escrita emregistradores WB, o que só vai ocorrer no ciclo de clock 6. Esta bolha tem o tamanho de 1ciclo de clock.

2) a segunda bolha, com tamanho de 2 ciclos de clock, aparece no ciclo de clock 12quando a instrução I tem que esperar até o fim do WB da instrução H.

3) a terceira bolha aparece no final do loop devido ao uso de uma previsão de que odesvio não será executado, o que faz com que o processador busque as instruções K e L quenão serão executadas. Quando é determinado que estas instruções não serão executadas, elassão eliminadas do pipe, gerando uma bolha de dois ciclos de clock.

O programa foi reescrito para que fosse eliminada a dependência entre as instruções deatualização dos endereços em A0 e A1 e a instrução de comparação. Para que isto ocorresse aatualização dos valores dos registradores foi feita no início do laço e a inicialização de A0 eA1 foi alterada apropriadamente. O novo programa é apresentado a seguir.

A MOVEA #$0FFE, A0; inicializa A0B MOVEA #$9002, A1; inicializa A1C LOOP ADDQ #2, A0; incrementa o valor de A0D SUBQ #2, A1; decrementa o valor de A1E MOVE (A0), D0; copia em D0 dado apontado por AOF MOVE (A1), D1; copia em D1 dado apontado por A1G MOVE D0, (A1); copia valor em D0 no end. indicado em A1H MOVE D1, (A0); copia valor em D1 no end. indicado em A0I CMPA A0, A1; compara os endereços em A0 e A1J BGT LOOP; enquanto A1 é maior que A0, continuaK MOVE #$500, A0; inicia outro procedimentoL MOVE #$17000, A1; inicia outro procedimento

Para eliminar a bolha no final do loop, as instruções foram reordenadas dentro do laçoe a previsão estática do desvio foi alterada para uma previsão de que o desvio sempre ocorre.Assim obtemos a execução mostrada na fig. 4.6.

WB - - C D E F - - - - CME - - C D E F G H - - C DEX A B C D E F G H I J C DID A B C D E E F G G H I J C D E EIF A B C D E F F G H H I J C D E F FClk 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Fig. 4.6. Eliminação de bolhas dentro do loop.

46

Conforme mostrado na fig. 4.6, a modificação da previsão estática de desvio paradesvio executado e a eliminação de bolha por reordenação de instruções dentro do laçocausaram uma redução de 30 no número de ciclos de clock necessários para executar o laço.Com um laço de 8 ciclos de clock, uma tabela com n palavras pode ser invertida em 4n ciclosde clock. Observe que a instrução C não faz nada e foi inserida apenas como uma reserva deespaço de tempo para que o laço pudesse começar ordenadamente. A inserção da instrução Cé necessária por causa da dependência existente entre a instrução B e a instrução D.

4.6. Máquinas Superpipeline, Superescalar

O período de clock de uma máquina pipeline é determinado pelo estágio que levamaior tempo para ser executado. Uma técnica utilizada para acelerar uma máquina pipeline ésubdividir os estágios mais lentos em subestágios de menor duração. Uma máquina com umnúmero de estágios maior do que cinco é chamada de superpipeline. A fig. 4.7 ilustra umaorganização superpipeline obtida pela divisão do estágio de busca de instruções (IF) em doissubestágios e do estágio de acesso à memória em três subestágios.

IF IF ID EX ME ME ME WBIF IF ID EX ME ME ME WB

Fig. 4.7. Arquitetura Superpipeline.

Uma outra técnica para acelerar o processamento em máquinas pipeline é a utilizaçãode múltiplas unidades funcionais que podem operar concorrentemente. Numa arquiteturadeste tipo múltiplas instruções podem ser executadas no mesmo ciclo de clock. É necessáriorealizar análise de dependências para determinar se as instruções começadas ao mesmo temponão possuem interdependências.

IF ID EX ME WBIF ID EX ME WB

Fig. 4.8. Arquitetura Superescalar.

A fig. 4.8. ilustra uma arquitetura superescalar com dois pipelines que podem operarem paralelo. Uma preocupação que surge com a implementação de máquinas superescalar é apossibilidade de término de execução fora de ordem. Isto ocorreria quando suas instruções sãoiniciadas ao mesmo tempo em dois pipelines e uma bolha surge em um deles causando queuma instrução leve mais tempo do que a outra. Uma solução adotada para este problemaconsiste em criar um buffer de reordenação que armazena o resultado das instruções até queos resultados possam ser escritos na ordem correta.

A maioria dos processadores RISC são arquiteturas superescalar e superpipelined. Istoé eles possuem mais de cinco estágios no pipeline devido à subdivisão de alguns estágios eeles possuem múltiplas unidades funcionais em cada estágio. Uma configuração típica é o usode quatro unidades funcionais em cada estágio.

capítulo 1 organização de computadoresvargas/disciplinas/arquitetura_i/cap-1-2... ·...

Documents