• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Arquiteturas de Computadores - slides
 

Arquiteturas de Computadores - slides

on

  • 5,641 views

Slides da matéria Arquiteturas de Computadores

Slides da matéria Arquiteturas de Computadores

Statistics

Views

Total Views
5,641
Views on SlideShare
5,641
Embed Views
0

Actions

Likes
0
Downloads
119
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Arquiteturas de Computadores - slides Arquiteturas de Computadores - slides Presentation Transcript

    • Arquiteturas deComputadore s informalUma abordagem 1
    • O que é um computador? Computadores são ferramentas Servem para resolver problemas 2
    •  Qualquer sistema computacional possui 3características em geral  Processamento  Memória (armazenamento)  Comunicação Um celular, por exemplo, é um sistemacomputacional que possui como principalcaracterística a comunicação 3
    • Curiosidades No Brasil, segundo o censo de 2010, há 190milhões de habitantes Segundo o Portal Teleco, site de informaçõessobre telecomunicações, dados de julho de 2011mostram que há 220 milhões de celulares no país Pois é, há mais celulares do que pessoas noBrasil. O mercado para profissionais de computaçãoé imenso! 4
    •  Uma ferramenta deve possuir objetividade(realizar sem restrições a tarefa para a qual ela foicriada) Além disso, há 3 aspectos importantes quedefinem sua qualidade:  Desempenho (tempo de processamento)  Custo-benefício  Facilidade de uso 5
    •  Você pode optar por uma memória de 2 GB aR$ 500,00 ou por uma de 4 GB a R$ 600,00. Qual éa melhor opção? 2 GB 4 GB 6
    •  A resposta é: depende  Se a sua aplicação não necessitar de mais de 2 GB de memória, você estará gastando R$ 100,00 a mais que o necessário Isto faz parte da questão do custo-benefício No caso de carros e TVs, produtos novos emelhores são lançados a preços mais caros que osanteriores Já produtos da indústria computacional tempreços iguais ou menores que os anteriores, eainda assim são geralmente melhores (mais ágeis) 7
    • Ok, mas chega de filosofar... Vamos à matéria deArquiteturas de Computadores! 8
    • Como funciona um computador? Algoritmos implementados por um programa escrito em uma sequências linguagem de de instruções programaçãoProgramadores se comunicam com computadoresatravés de uma linguagem de programação 9
    •  Para haver comunicação, é necessário que hajauma linguagem em comum... ...ou um tradutor 10
    •  Linguagens em geral...Mais Mais complexa chinês português, simples inglês etc (computador (usuário entende) entende) É necessária uma espécie de tradução daslinguagens comuns para a linguagem binária, que éo que o computador “entende” de fato Veremos a seguir que, na verdade, tradução éapenas parte do processo 11
    •  A nível de software, Ling. de Prog. T N5 Rtemos: Alto Nível A Compilação D U Ç Lê o código e, usando Montagem N4 Ã as informações nele O contidas, manipula a memória. Montador Sistema N3 Operacional Interpretação Parcial Macroprogramação N2 Interpretação 12
    •  A nível de hardware, Interpretaçãotemos: Microprogramação N1 Aqui, há um número muito maior de instruções do que havia no início. Com isso, mais circuitos devem ser Só agora são executadas criados, aumentando o custo. as instruções Portanto, linguagem simples é necessária. Circuitos Digitais N0 13
    • Tradução X Interpretação O esquema das etapas de execução de um programa apresentado anteriormente não é uma generalização Isto porque existem linguagens compiladas (utilizam tradução) e outras, interpretadas A tradução é feita uma vez apenas. Já a interpretação é realizada cada vez que o programa é executado 14
    •  Tradução: ________ ________ Execução ________ ✔ _________ ________ ✔ _________ ________ ✔ _________ ________ ✔ _________ ________ ✔ _________ ________ ✔ _________ ________ ✔ ________ . L2 . ________ . L1 Interpretação: _________ ✔ _________ ✔ _________ ✔ _________ ✔ _________ . _________ . Tempo de execução . L2 L1 15
    •  Mas afinal, para que tantas etapas na execução de um programa? O esquema abaixo mostra um dos problemas que ocorreriam caso as instruções das linguagens em alto nível fossem executadas sem todas essas etapasm C Pascal Cobol C++ ..... n Pentium 4 I7 Xeon AMD ..... 16
    •  Note que, para cada linguagem diferente, seria necessária uma maneira diferente de fazer suas instruções serem executadas. Isso para cada processador Para cada nova linguagem ou novo processador, já haveria uma nova necessidade para que o programa fosse executado No total, teríamos m*nnecessidades diferentes! 17
    •  Todas aquelas etapas servem então para que, utilizando o conceito de divisão e conquista, os processadores não precisem “se preocupar” com linguagens, e vice-versa As instruções complexas são reduzidas a instruções em uma linguagem simples, entendida por todos os processadoresm C Pascal Cobol C++ .....n Pentium 4 I7 Xeon AMD ..... 18
    •  Agora, são apenas m+n maneiras diferentes de execução de programas Intuitivamente, temos um custo maior por ter tantas etapas... mas não é bem assim. Dos níveis N5 até N3, o custo muitas vezes nem chega ao usuário, pois o software é compilado antes de chegar até ele É importante ressaltar que uma instrução em L2 não pode nunca ser diretamente executada no nível N0. Depois de N2, não ocorre mais tradução, apenas interpretação 19
    •  Na interpretação, as instruções são apenas convertidas nas ordens em que serão executadas, o que acontece de N1 para N0 no esquema apresentado anteriormente Relembrando: Macroprogramação L2 Interpretação Microprogramação L1 Execução Circuitos digitais Instruções A seguir, uma melhor representação das etapas de um programa até que ele esteja em L2 20
    • _____________ L5 _____________ _____________ _____________ Compilação _______ _______ _______ ....... + _______ _______ + _______ _______ + _______ _______ + ....... L4 Montagem 010010101101 001010101010 L3 -> L2 + L1O programa em L3 tem 101011100110também os endereços de ...memória envolvidos noprocesso 101101010101 L2 010100101101 ... 21
    • Curiosidades Em Delphi, é possível manipular o programa nonível de montagem. Com isso, pode-se ter umanoção maior de quanto tempo levará sua execução Atualmente, no caso de dispositivos móveis, porexemplo, programa-se em alto nível e depois acessa-se o programa em nível de montagem, para quesejam reprogramadas apenas as partes “ruins” 22
    •  Com o conceito de linguagens (L1, L2, L3 etc) apresentado, temos também o conceito de máquinas virtuais. Por exemplo: Macroprogramação Máquina L2 virtual L3 Microprogramação Máquina virtual L2 L1 Máquina física Circuitos digitais Instruções 23
    •  Generalizando para o topo, temos: Linguagem de programação de alto nível L5 Compilação . . . . . . . Máquina . virtual à vista . do usuário . 24
    • Abstração Considere o seguinte esquema: C Pascal Java Compilador B Compilador C Compilador D Compilador A Windows Linux Política de compatibilidade da Intel: todas as instruções Processador Processador 1 2 entendidas por um Pentium 4 são entendidas também pelo I7 (mais avançado) 25
    •  Vimos anteriormente que os compiladores A, B, C e D não são necessariamente diferentes, assim como os processadores Porém, com processadores que não sejam da Intel, é possível que sejam necessários diferentes compiladores para cada situação A linguagem Java, teoricamente, não possui restrições de plataforma Veremos a seguir que ela utiliza uma espécie de disfarce... 26
    • Através da abstração, a JVM (Java Virtual Machine) “esconde” as complexidades que envolvem as plataformas ______________ Java ______________ ______________ _________________ _________________ _________________ _________________ Java ByteCode JVM Máquina Virtual Java 27
    • Hardware X Software Considere o esquema abaixo: N5 COMPLEXIDADE N4 N3 N2 N1 N0 28
    •  Mas, complexidade de...? Funcionalidade Cabe ao arquiteto do sistema saber onde cada função deve ser implementada Adição e multiplicação são sempre feitas em hardware, pois o desempenho é muito melhor. Mas então, por que não implementar tudo em hardware? Custo é a resposta. Operações mais sofisticadas, se implementadas todas em hardware, aumentariam demais o custo (circuitos demais) 29
    •  Não são poucos os circuitos necessários para implementar operações de soma e multiplicação em hardware. Agora imagine implementar um programa complexo inteiro usando apenas esses circuitos digitais! Por outro lado, imagine também o gasto de tempo desnecessário que haveria se, para cada vez que precisássemos somar ou multiplicar, fosse neces- sário traduzir as instruções em software para hardware! 30
    •  Outra desvantagem de hardware é: se ocorrer algum problema físico com as peças, como reparar? Softwares são mais baratos e, caso haja algum erro, é muito mais fácil localizar e consertá-lo. Porém, como já foi citado, o desempenho é menor. 31
    • Computadores: Visão geral Placa mãe endereços C A CMemória dados C A RAM Processador / H C leitura / escrita CPU E H E Hard Disk (HD) Central Processing UnitDisquete / Blu-ray Rede Wi-Fi Graphics Processing USB Unit GPU . 32 Fonte
    •  Vamos começar falando superficialmente sobre o processador Sua função é executar programas armazenados na memória principal, buscando instruções, identificando e executando as mesmas uma após a outra  Unidade de controle (UC): É responsável pela busca das instruções na memória principal e pelas suas identificações  Unidade Lógica Aritmética (ULA): É responsável pela realização de operações como adição, AND booleano, entre outras, necessárias para a execução das instruções  Registradores: Juntos, formam uma pequena memória de alta velocidade, que armazena resultados temporários e certas informações de controle. Cada registrador possui uma determinada função. Os dois mais importantes são o contador de programa, PC (responsável por apontar a próxima instrução a ser executada), e o registrador de instruções, IR (responsável por armazenar a instrução que será executada) 33
    •  O processador executa as instruções através de uma pequena sequência de passos conhecida como o ciclo busca-decodifica-executa Este ciclo é o centro da operação de todos os computadores Veremos mais tarde por que o ciclo é tão determinante na execução das instruções de um programa 34
    •  A memória é a parte do computador onde programas e dados são armazenadosSem ela, os processadores não poderiam escrever informações, então não existiria nenhuma maneira de um computador armazenar um programa e dificilmente poderia executar algum Em um computador, geralmente existe memória primária e memória secundária 35
    •  Memórias primárias:  memórias que o processador pode endereçar diretamente  elas geralmente fornecem uma ponte para as memórias secundárias, mas sua função principal é conter a informação necessária para o processador num determinado momento – por exemplo, dados dos programas em execução  Exemplo: a memória principal, sobre a qual falaremos mais detalhadamente ao analisar o Modelo de Von Neumann 36
    • Memórias secundárias:  não podem ser endereçadas diretamente; a informação precisa ser carregada em memória primária antes de poder ser tratada pelo processador  não são fundamentais para a parte operacional do computador. Computadores feitos exclusivamente para efetuar cálculos matemáticos complexos, por exemplo, não precisam tanto desse tipo de memória  são geralmente não-voláteis, permitindo guardar os dados permanentemente  Exemplos: HD, CDs e DVDs 37
    •  RAM x CACHE Memória RAM: É a memória principal da máquina, onde todos os processos necessários para a inicialização e execução de programas armazenados em uma memória secundária são carregados Memória Cache: É uma memória com maior veloci- dade de acesso para o pro- cessador que a RAM. É localizada embutida no processador justamente para aumentar a velocidade de acesso. Entretanto, seus dados são temporários 38
    •  Pode-se dizer que o “mundo” do computador se resume a (esquema do Modelo de Von Neumann): Busca Memória Processador Sequência de bits 0 ou 1 . . BUSCA próxima instrução L2 . IDENTIFICA (decodifica e entende) . EXECUTA cada instrução L1 . 39
    • Curiosidades 1 byte equivale a 8 bits 1 kilobyte (KB) equivale a 1.000 bytes, 1 megabyte(MB) equivale a 1.000.000 bytes, 1 gigabyte (GB)equivale a 1.000.000.000 bytes, e assim por diante... ...ou não? 40
    • Curiosidades A memória é contada em potência de 2. Quandodizemos “1 GB de memória RAM”, estamos usando asigla incorreta para gibibytes (GiB) Portanto, 1 GB coloquialmente representa 1 GiB,que equivale a 2³: bytes (1.073.741.824 bytes);quase 7,4% mais do que 1.000.000.000 bytes Mas você provavelmentejá sabia disso 41
    •  A seguir, será descrita mais detalhadamente a arquitetura interna de um processador Mas antes, vamos resolver uma espécie de enigma, apresentado em uma aula de Arquiteturas de Computadores, pelo professor Vinod processador memória endereços . . . dados . . . controle (r/w) . . . 42
    •  Dado o esquema do slide anterior, deseja-se que os dados lidos da memória passem por todos os nove pontos do processador, utilizando o mínimo possível de fios Os fios são todos retos, ou seja, a solução para o problema será o mínimo de linhas retas que passem por todos os pontos . . . Uma configuração óbvia seria: . . . . . . 43
    •  Com essa solução, temos 5 retas Será que 5 é realmente o número mínimo de retas? Pense mais um pouco e clique para ver a resposta... . . .  Começando de uma forma diferente  Seguindo por mais 2 pontos... . . . Podemos usar apenas mais 2 retas!  Por que não fazer isso...  ...para depois fazer isso? . . .  E finalmente isso. 4 retas! 44
    • Curiosidades Por que esta última solução não é tão óbviaquanto a primeira, se não havia nenhuma restriçãode que as retas não podiam ultrapassar a caixa? Não estamos acostumados a pensar além do quetemos de concreto. Em países como os EUA, porexemplo, os alunos são estimulados desde oprimário a “pensar fora da caixa” Não é à toa que a maioria das descobertas einvenções vem de países desenvolvidos Então, lembre-se: “Think outside the box” 45
    • Processadores e MicroprogramaçãoVamos agora analisar mais a fundo o Modelo de Von Neumann Vamos definir conceitos como registradores, barramentos, Unidade Lógica Aritmética (ULA), entre outros Em seguida, construiremos nosso processador utilizando todas as componentes apresentadas 46
    •  Registradores  Locais onde são armazenadas informações  A diferença dos registradores para as células da memória principal é que os primeiros estão localizados dentro do processador. Isso faz com que informações contidas nos registradores sejam buscadas bem mais rapidamente para processamento  Representação*: Registrador*ATENÇÃO: tanto esta como as outras representações feitas aqui não fazemparte de nenhum tipo de convenção – são meras ilustrações! 47
    •  Barramentos  Conjuntos de fios por onde passam bits de dados ou de controle  Em outras palavras, artifícios utilizados para transmitir sinais de um dispositivo para outro  Representação: ou n Onde n é o número de fios do barramento, lembrando que por cada fio passa um bit por vez 48
    •  Multiplexadores (MUX)  Circuitos que recebem entradas, selecionam uma delas através de sinais de controle e as liberam como saída Representação: MUX 49
    •  Unidade Lógica Aritmética (ULA)  Dispositivo que recebe dois dados de entrada A e B, opera-os sobre uma função pré-determinada e libera um dado de saída  Recebe bits de controle que especificam a operação a ser realizada  A ULA poderá fazer 4 operações em nossa abordagem, portanto são necessários 2 bits de controle (00, 01, 10 e 11 = 4 possibilidades)  Por ora, a única operação relevante é a soma (00)  Representação: A B ULA 50
    •  Deslocador  Dispositivo que recebe um número binário e multiplica ou divide por 2, se desejado for, através do deslocamento à direita ou à esquerda  Deslocar à direita significa “apagar” o bit mais à direita e adicionar um 0 à esquerda, e o procedimento é exatamente o oposto no deslocamento à esquerda  Exemplo: 0010 (=2)  Deslocando à direita (divisão): 0001 (=1)  Deslocando à esquerda (multiplicação): 0100 (=4)  Representação: DES 51
    •  Vamos falar mais detalhadamente sobre registradores Sabemos que registradores contém dados que tanto podem ser lidos quanto sobrescritos Por isso, cada registrador precisa receber um bit que controla sua entrada, que chamaremos de HE, e outro que controla sua saída, HS Registradores possuem na sua estrutura interna um circuito flip-flop para cada bit que armazena, cada um deles conectado a um fio tanto do barramento de entrada como do barramento de saída 52
    •  Abaixo, esquematizada a estrutura interna de um registrador de 8 bits: E N T R HE (habilita A D entrada) A S AHS (habilita Ísaída) D A Tri-state buffer 53
    •  Tri-state buffers são circuitos que evitam conflitos entre as saídas para o barramento, fazendo um tipo de “desconexão virtual” entre registradores e barramentos Esses conflitos seriam possíveis porque várias saídas de registradores estarão conectadas a um mesmo barramento Nossa arquitetura terá 16 registradores para armazenar dados, dentre os quais alguns tem funções especiais: PC (Program Counter), IR (Instruction Register) e AC (Accumulator) 54
    •  O Program Counter contém o endereço da próxima instrução a ser buscada na memória principal O Instruction Register armazena a instrução buscada na memória. Ou seja, IR = MP[pc], sendo IR o conteúdo do registrador e pc um endereço da memória principal MP Accumulator é um registrador que armazena valores intermediários, que não seriam úteis ao final da operação Haverá em nossa arquitetura, além dos 16, outros registradores espalhados no processador: dois latches, A e B, o Memory Adress Register (MAR) e o Memory Buffer Register (MBR) 55
    •  Os latches servem para “segurar” dados no barramento e evitar que sejam sobrescritos Precisamos sempre lembrar que os fios do barramento apenas conduzem eletricidade, que já é instável por si mesma Latches serão importantes então para captar dados do barramento que estão prontos para serem processados, isto é, estão estáveis É como tirar uma foto: é necessário esperar até que todos estejam parados 56
    • O MAR é ligado ao barramento de endereços, que controla exclusivamente o fluxo de endereços que o processador envia para serem consultados na memória O MBR é ligado ao barramento de dados do sistema, e guarda os dados buscados na memória que serão processados na CPU ou os dados resultantes de algum processamento e que serão escritos na memória, ou até mesmo processados novamente 57
    •  Podemos agora começar a “montar” o nosso processador Já foi dito que, para começar, vamos pensar apenas em somar dados. Para isso, precisamos simplesmente ler dois deles e somá-los Dois registradores e uma ULA são necessários  Escolheremos então, PC IR dentre nossos 16 AC R1 registradores, um R2 registrador R1 e outro R2 . ULA . para ler e somar seus . . dados 58
    •  Intuitivamente, ligamos tudo através de barramentos  Vamos guardar o resultado da soma no registrador R3 PC IR AC Barramento B R1 R2 Barramento A R3 . . ULA .Barramento C 59
    •  Ainda não é o caso, mas se quiséssemos multiplicar ou dividir um número por 2, precisaríamos adicionar um deslocador Posicionando os 2 dispositivos separadamente, teríamos a vantagem de fazer operações simultâneas. Colocando ambos juntos, podemos usá-los consecutivamente, isto é, multiplicar ou dividir direto o resultado de uma soma, sem precisar armazená-lo antes 60
    •  Mesmo que ainda não seja necessário, vamos adiantar um deslocador para a nossa máquina, colocando o mesmo logo após a ULA: PC IR AC Barramento B R1 R2 Barramento A R3 . . ULA . DES Barramento C 61
    •  Agora, precisamos pensar fisicamente Imagine se nossa soma fosse R1 ← R1 + R2, isto é, o registrador R1 receberia o resultado da soma de seu valor atual com o valor de R2 Enquanto a ULA processa os primeiros bits de cada dado, o barramento de saída está sendo modificado e, portanto, os novos valores já estão sendo salvos em R1, o que poderia causar um erro na soma Uma das soluções para esse impasse é adicionar latches antes da ULA, que guardarão os valores originais de R1 e R2 enquanto são processados62
    • PC IR AC Barramento B R1 R2 Barramento A R3 LA LB . . . ULA DESBarramento C 63
    •  Ok, mas temos que pensar também na interação processador-memória É preciso adicionar, então, MAR e MBR. O MAR controla apenas informações (endereços) que vão do processador para a memória, mas o MBR controla o fluxo de dados de toda a interação, incluindo os dados de saída do deslocador, dados de entrada para a ULA e dados que serão lidos ou escritos na memória MAR MBR 64
    •  Em nossa arquitetura, o MAR poderá ser carregado a partir do latch B É interessante possibilitar o processamento de dados direto do MBR para a ULA, poupando assim o tempo de selecionar o registrador (entre 16 deles!) desejado para armazenar o resultado da operação, e depois selecionar o mesmo novamente para buscar os bits e processá-los 65
    •  Porém, repare que o MBR estará conectado à ULA, junto com o latch A. Há um conflito visível nessa configuração Latch A MBR ULA Lembre-se de que a ULA é apenas um circuito combinatório. Os bits de controle que recebe são apenas para especificar a operação a ser feita, o que significa que está sempre recebendo dados 66
    • PC IR AC Barramento B R1 R2 Barramento A R3 LA LB . Barramento C . .MAR Sem pânico! ULAMBR DES A solução é simples! 67
    •  Basta adicionar um multiplexador, que chamaremos de AMUX(multiplexador A): PC IR AC Barramento B R1 R2 Barramento A R3 Barramento C LA LB . . . AMUXMAR ULAMBR DES 68
    •  O multiplexador controlará qual dos dados deve ser enviado para a ULA Mas e se a instrução a ser executada fosse R1 ← R1 + R2 + R3 + R4 ? Intuitivamente, a solução seria uma ULA com 4 entradas, com a vantagem de resolver essa soma sem precisar guardar nenhum resultado intermediário A B C D ULA 69
    •  Sendo assim, uma ULA com 4 entradas é mais vantajosa para os casos de soma com 4 parcelas.  O problema é que isto não será econômico se essa soma não ocorrer com frequência E pensando bem, de fato ela não é tão comum quanto uma soma com apenas 2 operandos, para a qual basta uma ULA com 2 entradas Unindo o útil ao agradável, por que não pensar em uma solução alternativa para realizar esta soma, ainda sem precisar salvar valores intermediários? 70
    •  Eis a solução: A B C D ULA 1 ULA 2 E F ULA 3 A B C D ULA 4 71
    • Curiosidades Fabricar 3 ULA’s com 2 entradas é ainda maiseconômico do que projetar uma única ULA com 4 Além disso, outra vantagem em reduzir o tamanhodas ULA’s pode ser explicada fazendo uma analogiacom a forma como são fabricados os própriosprocessadores 72
    • Curiosidades Processadores são obtidos através de fatiasredondas de silício, que podem ser divididas empartes pequenas ou nem tanto: 73
    • Curiosidades Podemos pensar em cada um desses pedaçoscomo uma componente do processador As fatias, porém, sempre tem impurezas Imagine, por exemplo, a fatia abaixo, onde asmanchas vermelhas são suas impurezas 74
    • Curiosidades Cada parte atingida por uma impureza estáinutilizada Pensando nas partes como componentes, aquelasque foram atingidas não irão funcionar Na partição em componentes menores, repareque bem mais delas saíram ilesas O que restou: 75
    •  Recapitulando, temos então um processadorque realiza a soma que queríamos Fora do Dentro do Processador Processador (memória) PC IR AC Barramento B R1 Barramento A R2 R3 Barramento C . LA LB . . AMUX MAR ULA MBR DES 76
    •  É importante ressaltar que as linhas que ilustram os barramentos estão sendo mostradas apenas nos caminhos que queríamos para a soma Na verdade, todos os registradores estão conectados aos barramentos A, B e C, e uma estrutura de controle é que determina de onde são lidos os dados e onde eles são gravados Falando em controle, já vimos que não são só os registradores que precisam de bits de controle para que o processador possa funcionar A seguir, vamos quantificar os bits de controle de todas as componentes e descrever para que eles servem em cada uma delas 77
    •  Temos 16 registradores para leitura e escrita A intenção é ler sempre 2 dados (um vai para o barramento A e o outro para o barramento B), realizar uma operação na ULA e/ou no deslocador e, quando necessário, armazenar o resultado em outro registrador Isso faz com que precisemos de 16 bits de controle para cada uma dessas operações. Entenderemos o motivo logo a seguir 78
    •  A posição do registrador-alvo seria dada pela posição do bit 1 em meio aos 16 bits de controle Por exemplo, na operação de leitura cujo controle é: 0000000000001000 seria lido o dado do 0000000000001000 quarto registrador 0 PC 0 IR 0 AC 1 R1 0 R2 0 R3 . . . 0 R13 79
    •  Mas não é por mágica que a informação do registrador é lida quando ele recebe o bit 1 Na estrutura interna dos registradores, vimos que eles recebem um bit HE para habilitar sua entrada e outro, HS, para habilitar sua saída No exemplo anterior, a operação a ser feita era de leitura. Então, é a saída do registrador que precisa ser habilitada, para que a informação seja jogada em um dos dois barramentos (A ou B) Bits de controle especificam qual dos dois barramentos será o destino dos dados, mas isso por ora não tem importância 80
    •  Caso a operação fosse de escrita no registrador, o bit que iria para cada registrador corresponderia ao HE, e aquele que recebesse 1 seria sobrescrito Mas, e se quisermos simplesmente gravar o resultado no MBR, e não gravar em nenhum registrador? Para isso, precisamos de um 17º bit de controle (EnC, Enable C), ao barramento C, que impeça escrita em qualquer um dos 16 registradores caso isso não seja desejado 81
    •  Os outros registradores (latches A e B, MAR e MBR) recebem, separadamente, também 2 bits de controle (HE e HS), exceto pelo MBR que recebe 4 Os outros 2 bits do MBR são comandos de leitura e escrita na memória (chamaremos RD, leitura, e WR, escrita) Nossa ULA recebe 2 bits de controle para as 4 operações que pode executar a partir de dados de entrada A e B: 00 para A + B, 01 para a operação lógica A AND B, 10 para simplesmente retornar A, e 11 para retornar o inverso de A 82
    •  O deslocador também precisa receber 2 bits de controle (00 para não deslocar, 01 para deslocar à esquerda, 10 para deslocar à direita e 11 nada faz) Finalmente, o multiplexador recebe apenas um bit para controlar qual dos dois dados que ele recebe deve seguir (0 para seguir o valor de latch A e 1 para seguir o valor que veio de MBR) Na ordem, temos então 16 + 16 + 17 + 2 + 2 +2 + 4 + 2 + 2 + 1 = 64 À primeira vista, precisamos apenas de um registrador especial para controle, de 64 bits, com um bit para cada sinal Mas serão todos esses 64 bits realmente necessários? 83
    •  A verdade é que muito desses bits podem ser dispensados Fazendo uma análise mais cuidadosa dos controles de cada componente, veremos por que muitos desses sinais são desnecessários Mas, antes disso, vamos introduzir uma nova componente que será necessária para nos livrarmos de alguns bits 84
    •  Decodificador  Dispositivo que, para a nossa abordagem, receberá um número binário de 4 bits e, com ele, liberará 16 bits onde o bit na posição i será 1 e os outros, 0  OBS: i é o valor na base 10 do binário original. Note que i está entre 0 e 15  Exemplo: se o decodificador recebe o binário 0011 (=3), a saída será 00000000000010003 2 1 0  Representação: DEC 85
    •  Afinal, qual a grande utilidade do decodificador? Pense: se com apenas 4 bits, podemos representar até o número 15, então é possível especificar em 4 bits qual o registrador a ser selecionado Adicionando decodificadores para A, B e C, passamos a conta de 16 + 16 + 17 bits para 4 + 4 + 5, já que o bit EnC permanece Pois é, já economizamos 36 bits de controle 86
    •  Os latches A e B são registradores que não precisam de controle na saída. Precisam apenas controlar os dados que entram, que vão sobrescrever as informações que eles guardavam até então A saída dos latches pode ficar sempre liberada, já que a função deles é simplesmente salvar valores e não deixar que outras informações de um barramento passem por cima deles HE HS 87
    •  Para a nossa abordagem, o MAR também precisa de controle apenas na entrada, para controlar os endereços que nele entram e que serão então enviados para a memória automaticamente O mesmo serve para o MBR. Apenas um bit de controle é necessário, que é enviado para a saída do MBR, controlando se a informação nele contida irá ou não para a memória As operações de leitura e escrita na memória continuam sendo comandadas pelos bits RD e WR descritos anteriormente 88
    •  Ótimo, precisávamos de um registrador de 64 bits para controle, e agora conseguimos reduzir este tamanho para 24 Superficialmente, o que nós temos até então é: Memória Processador principal endereços MAR Controle (24 bits) dados MBR controle (leit/esc) N1 N2 N0 89
    •  Podemos imaginar N0 como um pobre estagiário, que trabalha e executa ordens O controle, N1, seria o chefe, quem dá as ordens, através da busca das instruções e dos recursos presentes na memória principal Aos poucos, iremos desvendar o que está por trás da nuvem no slide anterior 90
    • A E nosso proces- 16 4 4 Controle B sador ficou assim: 16 4 bits C 17 0 1 1 Barramento B 2 Barramento A 1 3 16 4 registradores 1 . Barramento C LA LB . 1 . AMUX 1 . . 2 . MAR . . ULA . 1 MBR . 23 2 DES 2 91 RD/WR
    •  Vamos dessa vez utilizar como exemplo a instrução R1 ← R1 + R2, para ilustrar como ficam os bits de controle durante o processo A B C EnC AMUX ULA RD WR MAR MBR DES LA LB 92
    •  Chamaremos o momento inicial de t₀ Os registradores R1 e R2 ficam nas posições 3 e 4, respectivamente, lembrando que o primeiro registrador, PC, fica na posição 0. O valor em R1 será jogado no barramento A, e o valor de R2 no barramento B; logo, A = 0011 e B = 0100 O resultado será armazenado em R1, então o controle do barramento C deve também ser 0011 93
    •  Obviamente, no início do processo ainda não podemos gravar nada no destino, então EnC tem de estar “desativado” Neste momento, não há problemas em especificar qual dos 2 dados (vindos do MBR ou do latch A) o AMUX irá direcionar para a ULA. Sabemos que serão dados vindos de latch A, então o bit de controle para AMUX será 0 Já vimos que a combinação do controle para que a ULA opere uma soma é 00 94
    •  Nada está sendo lido ou escrito na memória (RD = 0 e WR = 0) MAR não receberá nenhum endereço de memória MBR também não está realizando nenhuma atividade em t₀ Também já vimos que a combinação que faz com que o deslocador retorne a própria entrada é 00 As entradas dos latches A e B devem estar desabilitadas, pois as informações ainda não foram transferidas para os barramentos A e B 95
    •  Temos então, no momento t₀: A B C EnC AMUX ULA RD WR MAR MBR DES LA LBt₀ 0011 0100 0011 0 0 00 0 0 0 000 00 0 0 96
    •  Após um tempo para busca dos dados, tь, os únicos controles que se modificam são aqueles dos latches Isso porque, agora que os dados já foram jogados aos barramentos, os latches precisam recebê-los, quando estáveis, para que sejam transferidos à ULA Vamos considerar t₁ = t₀ + tь 97
    •  Temos então, no momento t₁ : A B C EnC AMUX ULA RD WR MAR MBR DES LA LBt₀ 0011 0100 0011 0 0 00 0 0 0 000 00 0 0t₁ 0011 0100 0011 0 0 00 0 0 0 000 00 1 1 98
    •  Após um tempo de execução, tє, os latches precisam voltar a ser 0, para que nada presente nos barramentos A e B sobrescreva os dados armazenados nos latches, já que não sabemos se eles virão a ser ainda necessários para a ULA futuramente Além disso, se queremos gravar o resultado de volta em R1, EnC precisa agora passar a ser 1 O resto permanece inalterado Agora consideremos t₂ = t₀ + tь + tє 99
    •  Temos então, no momento t₂ : A B C EnC AMUX ULA RD WR MAR MBR DES LA LBt₀ 0011 0100 0011 0 0 00 0 0 0 000 00 0 0t₁ 0011 0100 0011 0 0 00 0 0 0 000 00 1 1t₂ 0011 0100 0011 1 0 00 0 0 0 000 00 0 0 100
    •  Mas então, é necessário ler toda a sequência de bits de controle 3 vezes para uma simples operação de soma? Vimos pela tabela que pouca coisa se altera durante o tempo que decorre desde a leitura dos dados nos registradores até o armazenamento do resultado em um deles Então, deve haver uma maneira mais inteligente e menos custosa de executar instruções. Afinal, tempo é sempre precioso 101
    •  Relógio (clock)  Este é outro dispositivo importante, que emite uma sequência de pulsos periódicos que controlam alguns circuitos da máquina  Se os pulsos são periódicos, quer dizer que possuem uma determinada frequência  O período de cada pulsação define o ciclo da máquina  A máquina realiza um conjunto de atividades durante um ciclo  Representação: Ciclo Marcador de 102 frequência
    •  Agora, podemos conservar todos os bits que se mantiveram inalterados na tabela, deixando por conta do relógio as alterações necessárias Por exemplo, sabemos que o bit EnC está diretamente relacionado ao bit HE dos registradores Os pulsos enviados pelo clock definem então o momento exato em que a entrada do registrador deve ser habilitada, caso se deseje armazenar o resultado de algum cálculo em um registrador Isto pode ser feito através de um circuito bastante simples: CK HE EnC 103
    •  Com isso, já temos tudo de que precisamos para começar a ver o que está por dentro da nuvem que havia em N1 Em outras palavras, vamos agora entender como funciona toda a máquina de controle do processador e como ela executa o microprograma Microprogramas são sequências de instruções (em binário, evidentemente) que controlam o funcionamento de cada componente em N0 Cada instrução de um microprograma é executada em um ciclo 104
    •  O processamento de uma microinstrução se resume a:  Busca da instrução  Identificação da instrução  “Execução”, entre aspas porque engloba na verdade:  Busca dos operandos  Operação  Armazenamento do resultado Temos então 5 atividades que são realizadas pelo processador durante um ciclo 105
    •  Dentre as 5 atividades listadas, o tempo necessário para a segunda (identificação de uma instrução) será quase nulo na nossa abordagem Isto porque teremos na nossa arquitetura de controle (N1) um registrador especial chamado MIR (MicroInstruction Register), para onde cada microinstrução será carregada O MIR já “entende” o significado dos bits de uma instrução de acordo com a posição de cada um MIR 106
    •  Visto isso, o relógio que utilizaremos poderá ser dividido em 4 subciclos: Atraso Atraso Atraso 1 ciclo 1 subciclo O relógio terá 4 saídas, das quais 3 possuem atrasos. Isso faz com que sejam gerados pulsos em momentos diferentes para cada saída Cada uma dessas saídas consiste em um subciclo, como vemos na representação acima 107
    •  Teremos também em N1 uma memória, chamada memória de controle, onde são armazenadas e de onde serão lidas as microinstruções Nossa memória de controle poderá armazenar, no máximo, 256 instruções, cada uma com 32 bits Se é no MIR onde cada instrução será carregada, concluímos que a largura do MIR será de 32 bits Memória de Controle Carrega instrução MIR 108
    •  Toda memória precisa estar ligada a um MAR e um MBR, e com a memória de controle não é diferente Portanto, vamos adicionar um registrador MAR, que chamaremos de MPC (MicroProgram Counter), cuja função é encontrar a próxima instrução do microprograma a ir para o MIR Recebe endereço da próxima instrução MPC Envia endereço da próxima instrução Memória de Controle MIR 109
    •  O MBR da memória de controle já está em N1...  ...é o próprio MIR! Mas precisamos voltar a falar do MPC. De onde ele recebe a próxima microinstrução? Podemos supor que as instruções são executadas sequencialmente. Neste caso, basta incrementar o endereço atual, e teremos o endereço da próxima Precisamos então de uma componente simples, mas que ainda não tínhamos visto 110
    •  Incrementador  Circuito relativamente simples de poucas portas lógicas que, como o nome já diz, recebe um número binário como entrada e retorna o seu sucessor  O número binário de entrada, no incrementador que usaremos no nosso exemplo, será composto por 8 bits  Representação: INC 111
    •  Temos até agora: INC MPC Memória de Controle MIR Visivelmente, temos um problema MPC precisa ser controlado para não ficar o tempo todo selecio- nando endereços na memória! 112
    •  Vamos inserir agora o relógio, que será uma componente fundamental para todo o processador, tanto em N0 quanto em N1 Por enquanto, não falaremos da atuação do relógio em N0, e já podemos ligá-lo a duas das componentes de N1 que temos até agora: I 1 N MPC C 2 Atraso Memória de Controle 3 Atraso Atraso 4 MIR 113
    •  Fazendo isso, permitimos que uma instrução seja carregada da memória para o MIR apenas no início do ciclo (subciclo 1), que é quando a instrução começará a ser processada Além disso, permitimos que a próxima instrução seja selecionada na memória pelo MPC apenas ao final de um ciclo (subciclo 4), para que seja recebida pelo MIR no início do ciclo seguinte Note que o MIR estará desabilitado e não irá mudar durante os subciclos 2, 3 e 4. O mesmo vale para o MPC durante os subciclos 1, 2 e 3 114
    •  Nosso nível N1 está quase concluído, mas precisamos estudar o interior do MIR antes de continuar Você certamente achou estranho quando dissemos que o MIR entende a função de cada bit de uma instrução apenas pela posição. Observe: MIR A U D M M E M R W U L E B A n C B A D R X A S R R C 115
    •  No MIR, os bits da instrução que ele recebe se encaixam em cada uma das partes da figura Cada divisão do MIR serve para especificar o destino em N0 de cada bit. Por exemplo: o bit mais à esquerda será o controle de AMUX; do bloco DES saem os dois bits de controle para o deslocador; e assim por diante Não são mais necessários bits de controle para os latches. Já que eles possuem um momento certo para serem ativados e este é o mesmo em todos os ciclos, podemos deixar os latches por conta do relógio Para continuar a montagem do interpretador de microinstruções, precisamos primeiramente do que está por trás de 116
    •  Alguns slides atrás, fizemos uma suposição de que as instruções do microprograma seriam processadas sequencialmente. Porém, nem sempre isso acontece É comum que ocorram desvios de endereços durante o processamento, e por isso precisamos reservar bits em uma instrução que especifiquem o endereço da próxima, para quando for necessário que esse desvio ocorra Já podemos substituir por ADDR, conjunto de bits que representam cada endereço da memória de controle Se nossa memória de controle armazena até 256 instruções (= 2⁸), ADDR deve ser composto por 8 bits para poder representar todos os endereços 117
    • I 1 N MPC C 2 Atraso Memória de Controle 3 Atraso A 4 . . . . D D Atraso R Ops, o problema do conflito de novo Ainda se lembra da solução? 118
    • MMUX I 1 N MPC C 2 Atraso Memória de Controle 3 Atraso A 4 . . . . D D Atraso R Basta adicionar um multiplexador Chamaremos este de MMUX 119
    •  É bastante comum que esses desvios de endereços sejam condicionais Por exemplo, voltar ao primeiro endereço da memória de controle se uma condição X for satisfeita. Senão, selecionar o endereço seguinte Isto nos leva a revelar o que há por trás de no nosso MIR: um par de bits, o qual chamaremos de COND, que determina se ocorrerá desvio ou se o endereço da próxima instrução será simplesmente o endereço atual + 1 Se você entendeu isso, então você pode concluir que COND será o controle de MMUX. Ou pelo menos parte dele, como veremos mais adiante 120
    •  Lógica de microssequenciamento  Diferente de todos os circuitos que apresentamos até aqui, este foi projetado para uma única situação, bem específica  Ele recebe da ULA informações sobre o resultado de uma operação: um sinal N que diz se foi negativo e um sinal Z que diz se foi igual a 0  Recebe também o par de bits COND do MIR  Enfim, sabendo se o resultado da operação foi positivo, nulo ou negativo e sabendo a condição de desvio da microinstrução atual, podemos indicar se o endereço da próxima microinstrução será simplesmente o atual + 1 ou algum outro 121
    •  Lógica de microssequenciamento  Talvez seja uma explicação confusa. Podemos clareá- la com um exemplo prático: x = 5; if (x > 0) return x;  Por que o trecho de programa acima é válido?  Temos todas as informações necessárias para decidir se x será ou não retornado: sabemos qual a condição para retornar x, e sabemos se x satisfaz a condição (se x é 5, então x é maior que 0)  A saída será o bit de controle para o nosso MMUX  Representação: LMS 122
    •  Temos enfim: MUX I 1 N MPC C 2 Atraso Memória de Controle 3 Atraso A C A U Atraso 4 M U X O N D L A . . . . . D D R LMSN1N0 ULA Z N 123
    •  Agora, convencionando os significados dos bits COND:  00 = não desviar; a próxima instrução estará no endereço seguinte na sequência de instruções  01 = desviar para o endereço em ADDR se N = 1, isto é, se o resultado da operação realizada pela ULA for negativo  10 = desviar para o endereço em ADDR se Z = 1, isto é, se o resultado for 0  11 = desviar independente do resultado da ULA O sinal de controle de MMUX é resultado de R.N + L.Z + L.R (L é o bit à esquerda, e R é o bit à direita no par COND) Relembrando: ‘+’ é o operador lógico OR e ‘ . ’ é AND 124
    •  Nosso processador completo, incluindo N0 e N1, fica assim: Figura retirada e adaptada do livro Organização Estruturada de 125 Computadores, de Andrew S. Tanenbaum (p. 140)
    •  Para concluir, falta apenas falar sobre as ligações do relógio com as componentes de N0, que ainda não havíamos visto Para isto, vamos supor um microprograma qualquer que interpreta a soma de x + y, que foi executada com x recebendo o valor 3 e y recebendo o valor 5 Para simplificar o exemplo, escolheremos o ciclo em que a soma será efetuada. Isto significa que as constantes 3 e 5 já foram buscadas na memória e armazenadas nos registradores (suponhamos R1 e R2), e está pré-determinado que o resultado será armazenado em R3 Assim, a microinstrução deste ciclo será r3 := r1 + r2 (o símbolo “:=“ denota atribuição) 126
    •  Para conseguir passar esta microinstrução para sua forma real (binária), vamos relembrar as divisões do MIR: Depois, vamos analisar quais os bits de controle necessários para cada um desses campos e, dessa forma, teremos nossa instrução em bits A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R 127
    •  Sabemos que ambos os operandos virão dos latches, já que não buscamos nada do MBR. Para que AMUX direcione à ULA a informação contida no latch A, o controle deve ser 0 Não há desvios nesta instrução, então COND = 00 A operação é de soma. Esta operação é realizada pela ULA quando o controle é igual a 00 A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R 0 00 00 128
    •  Nada será feito além da soma, então o controle do deslocador precisa ser 00 para que sua saída seja igual à entrada Nada sairá de MBR para a memória ou vice-versa O campo MAR também será 0 já que não enviará nenhum endereço para a memória principal A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R 0 00 00 00 0 0 129
    •  Nada será lido da memória neste ciclo (RD = 0)... ...nem escrito (WR = 0) O bit EnC deve ser 1 porque neste ciclo haverá armazenamento de um valor (o resultado da soma está sendo atribuído a R3 na microinstrução). Evidentemente, o relógio irá ditar o momento certo do armazenamento A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R 0 00 00 00 0 0 0 0 1 130
    • PC 0 Lembra-se dos nossos registradores? IR 1 AC 2 Começando da posição 0, R1, que . R1 3 . R2 4 contém o primeiro operando, está na . R3 5 . posição 3. Logo, A = 0011 (3 na base 2) . R2, que contém o segundo operando, . . está na posição 4. Logo, B = 0100 Enfim, R3, destino do resultado, está na posição 5. Logo, C = 0101 A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R 0 00 00 00 0 0 0 0 1 0101 0100 0011 131
    •  Agora só nos resta o campo ADDR. Nossa microinstrução contém uma simples soma, sem desvio de endereços. Então, podemos atribuir qualquer valor para ADDR, já que ele será ignorado. Sendo assim, vamos optar por todos os bits sendo 0 Enfim, nossa microinstrução na forma binária é: 00000000000101010100001100000000 A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R 0 00 00 00 0 0 0 0 1 0101 0100 0011 00000000 132
    •  Agora, podemos começar a processar a instrução No subciclo 1, o relógio ativa apenas o MIR, porque estamos ainda na etapa da busca da instrução Vimos que a instrução é automaticamente identificada no MIR e não leva praticamente tempo algum. Consideramos então que a identificação também ocorre no subciclo 1 Memória de Controle0 00 00 00 0 0 0 0 1 0101 0100 0011 00000000 . . . . . MIR 133
    •  No subciclo 2, os bits dos campos A e B do MIR serão enviados aos decodificadores, para habilitar as saídas dos registradores R1 e R2 Com isso, os valores 3 e 5 são jogados aos barramentos A e B, respectivamente Neste subciclo, o relógio ativa os latches, para que possam receber esses valores Retomaremos a figura do livro Organização Estruturada de Computadores para mostrar o caminho dos dados durante este subciclo 134
    • 3 5 135
    •  O subciclo 3 é o intervalo em que ULA e deslocador irão operar sobre os dados recebidos Aqui seria também o momento certo para que o MAR fosse carregado, se fosse necessário. Mas a microinstrução deste ciclo não envolve essa necessidade, e por isso tivemos o bit 0 na parte do MIR destinada ao MAR 5+3 00 (soma) 8 --- 00 (saída = entrada) 136 8
    •  E finalmente, é no subciclo 4 em que ocorre o armazenamento do resultado em um dos nossos 16 registradores, quando a instrução assim determina Nossa microinstrução r3 := r1 + r2 atribui o resultado da soma a R3, o que significa que temos, sim, que armazenar dados em um dos 16 durante este ciclo O valor 8, neste instante, está no barramento C Já vimos que EnC é 1 durante todo o ciclo, pois é um dos sinais de controle fornecidos pelo MIR. Cabe ao relógio habilitar a entrada de R3 no momento certo, que é o subciclo 4 para qualquer microinstrução Agora que 8 está em R3, podemos começar um novo ciclo com uma nova microinstrução, caso ela exista 137
    •  Podemos dividir o nosso MIR em 2 conceitos: A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R OPCODE Operandos (determina a operação da microinstrução) ADDR é formado por 8 bits, e A, B e C por mais 4 cada. Ou seja, 20 bits compõem os operandos Os outros 12 do MIR compõem então o código da operação. Isto quer dizer que temos 2¹² (= 4096) possíveis instruções diferentes 138
    •  Porém, queremos economizar novamente. Será que é possível? Com uma análise mais cuidadosa, veremos que podemos reduzir de 4096 para 2048 possibilidades  Para iniciar nossa “eco- nomia”, precisamos ter em mente que alguns pares de bits do MIR não admitem todas as 4 combinações (00, 01, 10 e 11) 139
    •  Mais especificamente, o par de bits RD e WR não admite a combinação 11, já que é impossível que aconteçam simultaneamente operações de leitura e escrita na memória Vamos raciocinar: tínhamos 2¹² possibilidades 0 ou 1 2 2 2 2 2 2 2 2 2 2 2 2 = 2x2x2x2x2x2x2x2x2x2x2x2 = 2¹² Quantas possibilidades teríamos se o par RD/WR apenas admitisse a combinação 11, isto é, se RD fosse sempre 1 e WR fosse sempre 1? 2 2 2 2 2 2 2 2 2 1 1 2 = 2x2x2x2x2x2x2x2x2x1x1x2 = 2¹⁰ 140
    •  Daí, temos que o nosso total de possibilidades agora é 2¹² - 2;:, isto é, 4096 - 1024 = 3072 Podemos usar um raciocínio análogo para o deslocador, que nunca receberá a combinação 11 Teremos 3072 - 1024 = 2048 microinstruções Assim, já reduzimos as possibilidades de instruções pela metade. Poderíamos levar em conta outras restrições, mas chega de ser pão duro e vamos voltar ao que interessa 141
    • Pilhas Você já deve saber que uma pilha é uma estrutura de dados que consiste em um amontoado de valo- res (empilhados, daí o nome) Pilhas serão importantes na execução de programas. Veremos a seguir como elas são utilizadas 142
    •  Toda pilha possui duas operações básicas: PUSH, que consiste em adicionar um valor na pilha; e POP, que retira da pilha o valor presente no topo Para a nossa arquitetura, pilhas serão blocos contíguos presentes na memó- ria principal que conterão dados a serem processados, com um ponteiro SP (Stack Pointer) que indicará o endereço onde está o topo da pilha À medida que descemos pela memória, os endereços aumentam. Ou seja, sempre que adicionarmos um valor na pilha (PUSH), o ponteiro SP apontará para o endereço atual – 1, um endereço acima O contrário acontece para a operação POP 143
    •  A pilha do exemplo a seguir começa no endereço 1000 da memória, e seu topo está em 996 . . . . . . 996 9 997 4 7 SP 998 999 2 1000 5 . . . . . 144
    •  Fazendo PUSH 3, o valor 3 será acrescentado na pilha, e o topo será o endereço 996 – 1 = 995 . . . . . . 995 3 996 9 997 4 7 SP 998 999 2 1000 5 . . . . . 145
    •  Por outro lado, se tivéssemos feito POP, sairia o valor 9 que está no topo da pilha e o novo topo estaria em 996 + 1 = 997 . . . . . . 996 9 997 4 7 SP 998 999 2 1000 5 . . . . . 146
    •  Algumas linguagens de programação são organizadas em blocos (escopos) Em Java, por exemplo, o escopo de uma classe são todos os procedimentos existentes naquela classe, e no escopo de cada procedimento existem todas as operações realizadas por ele, inclusive eventuais chamadas a outros procedimentos 147
    •  Para essas linguagens, é interessante utilizar pilhas durante a execução de um programa para liberar o espaço ocupado pelas variáveis locais de um procedimento, quando ele é finalizado Variáveis locais são variáveis utilizadas e conhecidas exclusivamente nos procedimentos onde foram inicializadas, e no nível de macroprogramação são geralmente carregadas nas pilhas Já as variáveis globais são variáveis conhecidas em todo o programa e a princípio estão presentes em endereços da memória que não fazem parte da pilha de um procedimento em particular 148
    •  Além das operações PUSH e POP, outra operação útil para pilhas é mover arbitrariamente o ponteiro SP, sem inserir dados inicialmente Isto é útil para quando a execução entrar em um procedimento que utilizará variáveis locais, de maneira que SP será decrementado (topo subirá) para reservar espaço para essas variáveis Em Pascal, isso fica fácil de ser visto, já que as variáveis locais são inicializadas antes da palavra begin, que indica o começo do procedimento O exemplo a seguir mostra o começo do método de ordenação BubbleSort, em Pascal 149
    • procedure BubbleSort(var A: ArrayType); var i, j: integer; begin . . . Repare que as variáveis i e j são inicializadas. Em seguida, a palavra begin indica o começo das operações do procedimento – é neste ponto onde SP é decrementado em 2 A pilha agora ocupa mais 2 espaços: os espaços de i e j, que eventualmente receberão valores durante a execução do procedimento E se o topo da pilha atingir endereços que já estão sendo usados pelo programa? 150
    •  Familiar? Agora vamos supor uma função, também em Pascal, que recebe duas entradas e retorna como resultado o produto entre elas Perceba como fica sua pilha de execução 151
    • function produto(a, b: integer): integer; var p, j: integer; begin if (a = 0) or (b = 0) then produto := 0 else begin p := 0; for j := 1 to a do p := p + b; produto := p; end end; j   Ao final desta linha, precisamosvariáveis Quando a função termina, os espaços das de 2 p locais são liberados. Em outras palavras, SP é um espaços para as variáveis a e b, maisSP end. ret.  Já aopara o endereço de retorno, de incrementado em 2, voltando a ser o endereço de espaço final desta linha, a execução estava precisamos de retorno. Este endereço dirá onde mais 2que a as variáveis locais p e j b modo paraafunção saberáepara onde a quando chamou função produto, ela continuará a 152 partir daquele ponto terminar retornar quando
    •  Com apenas estas descrições, fica a impressão de que a função foi inútil, já que a pilha guardou apenas seus valores de entrada e manipulou as variáveis locais Mas é óbvio que isto não é verdade. De que maneira então foram usadas as variáveis a e b para chegar até o resultado final, e onde ele foi parar? Todos os resultados de operações intermediárias foram sendo armazenados no nosso registrador AC (Accumulator). O mesmo vale para o resultado final da função, que pode ser apenas um valor intermediário para o resto do programa 153
    •  O endereço de retorno está relacionado a outro registrador, o Program Counter Quando a função produto termina, o endereço de retorno é desempilhado e salvo em PC Caso você não se lembre, AC e PC são dois dos nossos 16 registradores conectados aos barramentos A, B e C em N0 Isso nos dá bagagem suficiente para falar sobre o nível de macroprogramação 154
    • Macroprogramação Vimos que existem milhares de possibilidades de microinstruções diferentes Surge a necessidade de haver instruções em um nível mais alto, para consequentemente reduzir o conjunto de instruções de forma significativa Veremos no slide seguinte uma tabela, mais uma vez do livro Organização Estruturada de Computadores, com todas as macroinstruções da nossa máquina e suas descrições Repare como diminuímos de mais de 2 mil para menos de 25 instruções 155
    • 156
    •  Antes de entender melhor a tabela, é importante ressaltar que seus bits não devem nunca ser confundidos com os bits das microinstruções! Até porque microinstruções são formadas por 32 bits, enquanto as macro possuem 16 apenas Dito isto, perceba que da 1ª até a 15ª instrução, nunca se repete uma combinação para os 4 primeiros bits. Isto quer dizer que é possível identificar instruções que não comecem por 1111 apenas pelos 4 primeiros bits Porém, quando a instrução começa por 1111, é necessário analisar os bits seguintes 157
    •  Diferentemente das microinstruções, que tinham um número fixo para OPCODE e outro para os operandos, a parte de OPCODE varia nas macro A instrução LODD, por exemplo, possui 4 bits de operação, 0000, enquanto todos os outros representam seu operando. Já as instruções que começam por 1111 precisam de mais bits OPCODE para que possam ser diferenciadas entre si 158
    •  Para ilustrar como é feita a identificação das macroinstruções, precisamos primeiro tornar aqueles nossos 16 registradores um pouco mais complexos Além de PC, IR e AC, precisamos de mais registradores com funções especiais para que seja possível implementar um microprograma que interprete nossas macroinstruções corretamente Mais uma vez, trabalharemos em cima de uma figura do livro Organizações Estruturadas de Computadores, que mostra os registradores adequadamente nomeados 159
    •  O registrador SP armazena o endereço do topo da pilha TIR armazena uma cópia temporária da macroinstrução que está sendo executada, ou seja, uma cópia de IR. É usado para decodificar o OPCODE Os 3 registradores que seguem contém as constantes 0, +1 e -1 AMASK contém a chamada máscara de endereços e é usado para separar bits OPCODE dos bits de endereço, através da operação AND do seu conteúdo com a macroinstrução da qual se quer separar os bits SMASK é útil nas instruções INSP e DESP, que contém 8 bits de operandos, pois a operação AND de seu conteúdo com a macroinstrução isolará esses 8 bits Os demais registradores permanecem sem 160 funções específicas
    •  É preciso convencionar os nomes de algumas operações feitas em microinstruções Para as operações da ULA, utilizaremos a + b para soma, band(a, b) para AND, a para retornar a própria entrada e inv(a) para retornar o inverso do primeiro operando Para operações do deslocador: lshift(a) desloca a entrada 1 bit para a esquerda, e rshift(a) faz o oposto Desvios condicionais serão representados por if b then goto addr, que significa: se o bit b for 1, vá para o endereço addr No nosso microprograma, b será N ou Z, os dois bits da ULA que indicam se o resultado foi menor que 0 ou igual a 0, respectivamente 161
    •  Veja a seguir quais valores cada conjunto de bits assume no MIR para os seguintes exemplos de microinstruções, em uma nova tabela do livro: Dito tudo isso, podemos ver um microprograma que interpreta macroinstruções 162
    • 163
    •  O microprograma começa com um loop principal, que só termina quando acabar o macroprograma, isto é, quando não mais houver macroinstruções a serem interpretadas Na linha 0, o MAR recebe o conteúdo de PC, que é o endereço da macroinstrução a ser interpretada. Também nesta linha, RD é ativado, para que a macroinstrução desejada comece a ser lida na memória a partir do endereço do MAR Na linha 1, o microprograma aproveita para incrementar o conteúdo de PC, já que isso alguma hora teria que acontecer. Se isto não fosse feito, a linha 1 seria desperdiçada, porque a macroinstrução ainda não chegou até o MBR. Pelo mesmo motivo, RD continua ativado, pois ainda estamos lendo a macroinstrução na memória 164
    •  Na linha 2, a macroinstrução em MBR é salva em IR. Aqui ainda há tempo para testar o primeiro bit da instrução, da esquerda para a direita: se este não for 0, já sabemos que a macroinstrução não é nenhuma das 8 primeiras da nossa tabela, então podemos ir para a linha 28 e testar o segundo bit 165
    •  Tanto na linha 28 quanto na linha 3, repare que o teste do desvio condicional é exatamente o mesmo: tir := lshift(ir + ir); Não é uma percepção trivial à primeira vista, mas o que acontece nesse teste é o deslocamento de dois bits à esquerda do conteúdo de IR Recordando, deslocar um bit à esquerda em um número binário é o mesmo que multiplicar o seu valor por 2. Fazer ir + ir é equivalente a fazer 2 * ir, ou seja, deslocar um bit à esquerda de ir. Fazer lshift(2 * ir) então é o mesmo que deslocar 2 bits Porém, lembre-se de que os testes são feitos sempre em função dos bits N e Z liberados pela ULA 166
    •  Vamos voltar a focar nas primeiras linhas do microprograma. Na linha 3 (tir := lshift(ir + ir); if n then goto 19;), a interpretação irá para a linha 19 caso o bit N da saída da ULA seja 1 Isto quer dizer que o teste é feito em cima da instrução vinda de IR deslocada um bit à esquerda, pois o segundo deslocamento à esquerda (feito por lshift) é feito somente no deslocador, e não mais na ULA Caso N tenha sido 0, passamos à linha 4 (tir := lshift(tir); if n then goto 11;). Aqui, o registrador TIR receberá seu próprio conteúdo deslocado em um bit à esquerda 167
    •  Só que este deslocamento é novamente feito por lshift, e opera em cima do próprio conteúdo de TIR. Isso significa que a ULA receberá tir como um dos operandos e retornará ele mesmo – lembrando que tir já é o conteúdo de IR deslocado 2 bits à esquerda, por causa do que aconteceu na linha 3 Então, se na linha 3 testamos o segundo bit da instrução, na linha 4 testa-se o terceiro, e só depois desse teste o conteúdo de tir é novamente deslocado (lshift(tir)) Na linha 5 (alu := tir; if n then goto 9;), alu é uma pseudovariável que representa que o conteúdo de TIR apenas passará pela ULA para que seja testado seu primeiro bit (4º da instrução original) 168
    •  Na linha 5, se o bit testado for 1, significa que o OPCODE da instrução é 0001, e STOD é a única macroinstrução cujo início é 0001. Por isso desviamos para a linha 9, linha onde STOD é executada em microinstruções Se o bit testado for 0, o OPCODE é 0000, então basta prosseguir para a linha seguinte, que é onde LODD é executada Esse processo teste-desvio-execução é a base do microprograma que interpreta macroinstruções Acompanhe a seguir um trecho, bastante simples, de um programa qualquer 169
    • se (i ≤ j) faça // ‘i’ e ‘j’ são variáveis quaisquer m = a[i*2] // ‘a’ é um vetor e ‘m’ uma variável // qualquer fim se Vamos expressar este algoritmo em nível de macroprogramação, e depois em microinstruções, para enfim nos despedirmos da nossa máquina-exemplo 170
    •  Serão realizadas 4 operações nesse algoritmo: Macroprograma  i ≤ j? i*2 LODD j  buscar valor em a[i * 2] SUBD i  m := a[i * 2] JNEG saida Testar se i ≤ j é o mesmo que testar se i - j ≤ 0 Atenção: ‘i’ e ‘j’ são variáveis globais Com a instrução LODD passando j (entenda asvariáveis passadas no macroprograma como oendereço onde essas variáveis estão, e não seusrespectivos valores), armazenamos noregistrador AC o valor contido no endereço saida (continuaçãopassado do programa) . Precisamos agora subtrair do valor de i. Com a . .instrução SUBD, o resultado já será armazenado .em AC Hora de implementar o desvio condicional:caso o conteúdo de AC seja negativo (j > i),desviamos para o final do ‘se’ do algoritmo. Paraisso, criaremos um label “saida” 171
    •  Agora, carregamos o endereço do primeiro Macroprogramaelemento do vetor a no registrador AC. Se LODD jfizéssemos LODD a, teríamos o valor de a[0] no SUBD iacumulador, e não é o que queremos JNEG saida Quisemos o endereço de a[0] porque assim LOCO apodemos encontrar a[i * 2]. Já que i * 2 = i + i, ADDD ifazemos 0 + i... ADDD i ...+ i, e temos em AC o endereço correto do PSHI(i * 2)-ésimo elemento do vetor a POP Aqui vem o problema: queremos fazer STOD mac := m[ac], mas não temos uma instrução que o saida (continuaçãofaça. Temos como fazer, porém, m[sp] := m[ac], do programa)isto é, colocar na pilha de execução o valor . .contido no endereço presente em AC . . ...e depois armazenar este valor em AC . .(ac := m[sp]) Finalmente, armazenar o valor de AC noendereço da memória onde está a variável m 172
    •  Com o macroprograma e com o que vimos até aqui sobre microinstruções, fica fácil entender como é o nosso algoritmo em microprograma Antes, precisamos apenas esclarecer como funciona a subtração O oposto de um número x é -x, e a codificação do oposto de um número binário é o seu inverso + 1 Formalizando: x - y = x + (-y) = x + (y + 1) Lembre-se também: usaremos &v quando quisermos o endereço de uma variável v 173
    • mar := &i; rd; //MAR recebe o endereço da variável i rd; //esperando o valor de i chegar até MBR b := mbr; //B é um dos resgistradores sem função definida mar := &j; rd; ac := b + 1; rd; //armazenando i + 1 em AC. Falta somar com j a := inv(mbr); //valor de j chegou ao MBR. A recebe o inverso ac := ac + a; if n goto faça; //se i + j + 1 < 0, não saia do algoritmo alu := ac; if z goto faça; //se essa soma for igual a 0, também não saia goto saida;faça b := lshift(b); //multiplicando por 2 o conteúdo de B ac := &a; //AC recebe o endereço de a[0] ac := ac + b; //AC recebe o endereço de a[i*2] mar := ac; rd; //lendo na memória o valor que está em a[i*2] rd; mar := &m; wr; //escreve na variável m o que acabou de ser lido wr;saida ... //aqui está o que vem após o ‘fim se’ no programa 174
    •  Há apenas uma última observação. Analise estas últimas linhas do microprograma anterior: mar := ac; rd; rd; mar := &m; wr; wr; Implicitamente, o que temos é: mar := ac; rd; rd; ac := mbr; mar := &m; wr; mbr := ac; wr; O acumulador recebe o que foi lido da memória (valor em a[i*2]). Em seguida, indicamos que estamos visando o endereço da variável m para escrita, fazemos o MBR receber o valor em AC e escrevemos esse valor no endereço onde está m 175
    • Princípios da Microprogramação Horizontal X Vertical Passaremos agora a discutir sobre dois conceitos relacionados à microprogramação Na micrprogramação horizontal, a preocupação é exclusivamente com as portas lógicas Nada de sinais codificados para economia de bits: cada conjunto de sinais que sai do MIR controla de forma direta sua respectiva componente 176
    •  Isto significa que as microinstruções em uma arquitetura assim teriam largura equivalente ao total de sinais de controle recebidos pelas componentes ...mas é claro que esta explicação não deixou nada muito claro 177
    •  Usaremos um exemplo da máquina que projetamos anteriormente. Lembra-se do nosso MIR? A A C U D M M E M O R W D U N L E B A n C B A D R D X D A S R R C R Os campos A, B e C possuíam 4 bits cada, que passavam por decodificadores onde eram “transformados” em 16 Se tivéssemos usado, exclusivamente, microprogramação horizontal na arquitetura, cada um desses campos teria 16 bits. Isto aumentaria drasticamente a largura do MIR 178
    •  Os campos ULA e DES também ficariam maiores. Os pares 00, 01, 10 e 11 também são codificações, as quais geram um conjunto de 4 bits que identifica qual a operação a ser realizada pela ULA ou pelo deslocador No caso do deslocador, pode ser gerado um conjunto de 3 bits, já que o deslocador possui apenas 3 funções e o par 11 nunca ocorre Assim, concluímos que o campo ULA passaria a ter 4 bits e o campo DES, 3 bits 179
    •  É fácil perceber que seguir à risca o conceito de microprogramação horizontal não teria sido a opção mais inteligente para a nossa máquina, já que sempre optamos por tentar baratear o custo da mesma Mas se quiséssemos ser ainda mais econômicos na largura das microinstruções (e do MIR, consequentemente) da arquitetura que projetamos, poderíamos aplicar o conceito de microprogramação vertical 180
    •  A microprogramação vertical carrega uma ideia rigorosamente oposta à horizontal: encurtar ao máximo a largura das microinstruções, criando o máximo possível de codificações nos sinais Diminuir o número de bits das microinstruções é sempre uma ideia interessante. Vamos mostrar como ficaria nossa máquina se seguíssemos este princípio exclusivamente Nosso MIR, que antes tinha 32 bits de largura, pode passar a ter apenas 12, como veremos a seguir 181
    •  Com apenas 4 bits para OPCODE e 8 para operandos (4 para cada), é possível escrever um microprograma equivalente ao que vimos anteriormente 4 bits 4 bits 4 bits OPERANDO 1 OPERANDO 2 OPCODE ADDR (endereço) É claro que as restrições aumentam com esses cortes Agora, só temos 2 operandos. Como saber onde o resultado será gravado? A solução é guardar o resultado sempre no mesmo registrador de um dos operandos 182
    •  Antes, podíamos fazer R3 <- R1 + R2. Agora, se queremos de fato guardar em R3 o resultado da soma dos valores de R1 e R2, precisamos fazer R1 <- R1 + R2; e depois R3 <- R1 Por este exemplo já foi possível perceber que o microprograma ficaria mais extenso do que aquele que fizemos anteriormente, mas isso é assunto para mais tarde A seguir, será apresentada como ficaria nossa máquina em microprogramação vertical. Repare na presença de 3 novos elementos: OP, AND e NZ 183
    • 184
    •  Recordando: os dados de entrada são sempre carregados dos registradores no subciclo 2, e o resultado é salvo em um deles no subciclo 4 Já que agora temos 2 operandos apenas e um deles será ao mesmo tempo um dado de entrada e o destino do resultado, o bloco AND se faz necessário para ativar cada barramento na etapa correta Pelo esquema apresentado alguns slides atrás, vimos que os 2 operandos da microinstrução pode também ser usado como um endereço. Isto significa que não podemos ter endereço e operandos em uma mesma microinstrução 185
    •  Para começo de conversa, já podemos com isso adiantar que não é possível testar se o resultado de uma operação da ULA é maior, igual ou menor que 0, em apenas uma microinstrução Precisamos portanto armazenar os bits N e Z liberados pela ULA, para que eles possam ser avaliados no ciclo seguinte. É aí que entra NZ, que nada mais é do que um registrador que armazena estes dois bits Resta falar sobre OP, a mais importante das 3 inéditas componentes em nossa nova máquina 186
    •  Para cada combinação de OPCODE (16 possíveis, já que são 4 bits), são gerados 13 bits que controlam a lógica de microssequenciamento – bloco usado na avaliação dos bits N e Z –, a ULA, o deslocador, o registrador NZ, o AMUX, os registradores MBR e MAR, e os sinais RD e WR; 2 bits para os 3 primeiros e um bit para os outros O problema é que quem está projetando a máquina precisa construir todo um circuito que gere os bits de controle corretos para cada OPCODE 187
    •  Exemplificando: suponha que as combinações OPCODE para as instruções que iniciam as operações de leitura e escrita (portanto, envolvem a ativação do MAR) sejam 1000 e 1001 Tudo o que sabemos é:  A combinação de OPCODE 1000 gera o bit 1 para MAR  A combinação de OPCODE 1001 gera o bit 1 para MAR  As demais combinações geram o bit 0 para MAR Temos então uma tabela que contém os bits de entrada e também os bits de saída 188
    • A B C D S0 0 0 0 00 0 0 1 00 0 1 0 0  A, B, C e D seguem a0 0 1 1 00 1 0 0 0 ordem do bit mais0 1 0 1 0 significativo para o menos0 1 1 0 0 significativo, e S é a saída0 1 1 1 0  A partir daí, basta utilizar1 0 0 0 1 os conhecimentos da1 0 0 1 1 disciplina de Circuitos1 0 1 0 01 0 1 1 0 Digitais para montar um1 1 0 0 0 circuito apropriado1 1 0 1 01 1 1 0 01 1 1 1 0 189
    •  Da tabela, obtemos (A.B.C.D) + (A.B.C.D), que pode ser simplificado em A.B.C Com isso, já temos projetado o circuito que, recebendo os bits de OPCODE, gera o bit de controle apropriado para MAR. Os circuitos que vão gerar os outros 12 bits de controle são construídos utilizando o mesmo raciocínio deste exemplo Enfim, o bloco OP nada mais é do que o conjunto de todos estes circuitos. Como chegar em cada um deles não é relevante para os nossos estudos 190
    •  Para efeitos de comparação, vamos supor que fosse ser executado em nossa máquina original um microprograma de 80 instruções, lembrando que na máquina original uma microinstrução tinha 32 bits de largura, enquanto na que acabamos de projetar, uma microinstrução possui 12 bits Muito provavelmente, mais de 80 instruções 80 instruções 191
    •  Como já foi dito, as restrições causadas pela fixação da largura de OPCODE em 4 fazem com que uma função desempenhada por uma microinstrução em nossa primeira máquina necessite de mais de uma microinstrução na nova arquitetura (operar na ULA e depois avaliar o resultado, por exemplo) Assim, podemos saber qual das duas máquinas será mais econômica através de um cálculo bastante simples O microprograma que ocupar menos “volume” na memória de controle determinará a resposta 192
    •  Por “volume”, entende-se a largura de cada microinstrução multiplicada pelo total de microinstruções Na máquina original, ocupou-se um volume de 80 x 32 = 2560 bits. Se fizermos: 80 x 32 > n x 12 teremos n < 213, isto é, a máquina que acabamos de projetar será mais econômica caso o microprograma equivalente àquele de 80 instruções tenha menos de 213 E a tendência é que realmente tenha bem menos que 213 microinstruções 193
    •  Então, toda máquina deve ser projetada seguindo à risca o princípio da microprogramação vertical? Certamente não. Lembre-se de que cada microinstrução é, independente de sua largura, executada no tempo de um ciclo, que é fixo Quanto mais microinstruções necessárias para executar uma determinada função, mais lenta é a execução. Conclusão: a nossa primeira máquina é mais cara e mais rápida, enquanto a última é mais lenta, porém mais barata 194
    • Nanoprogramação Falando em economia, existe ainda outra forma de ocupar menos memória no armazenamento dos microprogramas, que deve ser discutida Vimos que programas são sequências de instruções. É possível dividi-los em sequências e instruções Vamos a seguir entender melhor esta jogada 195
    • h Memória de Controle w Consideremos um microprograma que ocupa completamente esta memória de controle, isto é, possui h instruções de largura w Podemos dividi-lo em duas partes: 196
    • 1 cada instrução A 3 individualmente, B sequência na qual todas distintas 2 C ocorre cada entre si . 0 instrução, (n instruções no . 1 identificada total)h . apenas 2 por um número 5 . w . . À esquerda, temos uma memória que armazena números binários que identificam cada instruçãoAs instruções completas são armazenadas na memória à direita, com a vantagem de cada uma aparecer apenas uma vez 197
    •  Novamente, a melhor maneira de clarear tudo é ilustrando com um pequeno exemplo Imagine o seguinte microprograma: A B A A  A equivale a 01100101100101101001 A C  B equivale a 10110110001000011011 D D  C equivale a 11101000110100110000 B  D equivale a 00010110100101110010 D C A A C D B 198
    •  Neste exemplo, w = 20 e h = 16, isto é, um total de 16 microinstruções onde a largura de cada uma é de 20 bits, totalizando 320 bits Vamos agora dividir o microprograma. A parte à esquerda é o microprograma de fato, e à direita temos o nanoprograma, que guarda cada microinstrução diferente Cada linha do microprograma passa a conter apenas o endereço da nanomemória no qual está a instrução que deveria estar naquele local do microprograma 199
    • memória de controleA 00B 01 endereçosA 00 00 nanomemóriaAA 00 00 10 01100101100101101001C 11 01 10110110001000011011DD h = 16 11 10 11101000110100110000B 01 11 00010110100101110010D 11C 10 w = 20A 00A 00C 10D 11B 01 200
    •  Vimos que cada linha da memória de controle passou a ter 2 bits apenas. Isto porque o microprograma tem, no total, 4 instruções diferentes, fazendo necessários log₂4 = 2 bits para representá-las. A quantidade de linhas é a mesma do microprograma original: 16 Portanto, a memória de controle passou a ter 16 x 2 = 32 bits ocupados Já a nanomemória possui o total de instruções multiplicado pela largura das mesmas, o que totaliza 80 bits (4 x 20) Dos 320 bits originais, o microprograma passou a ocupar apenas 32 + 80 = 112 bits! 201
    •  De uma forma geral, temos:  o microprograma original ocupa h.w bits  a memória de controle após a divisão passa de h.w para h.log₂n bits ocupados, onde n é o total de instruções diferentes do microprograma  a nanomemória introduzida tem n.w bits ocupados Em outras palavras, a nanoprogramação será econômica sempre que a seguinte inequação for satisfeita: h.w > h.log₂n + n.w 202
    •  Observe que n aparece nos dois produtos à direita, sendo determinante na economia dos bits Isso faz sentido porque, se houver muitas instruções diferentes em relação ao número de linhas no microprograma original, recorrer à nanoprogramação não será eficiente. A nanomemória terá um tamanho próximo ao tamanho que tinha a memória de controle antes da divisão Tudo o que teríamos então seria uma memória parecida com a anterior, e mais uma outra contendo apenas referências para a nova memória 203
    • Pipeline Até agora, nos prendemos muito em economizar espaço na memória e baratear o custo de uma máquina Mas, e quando quisermos uma máquina mais veloz, isto é, com melhor desempenho? 204
    •  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 Esquecendo um pouco a memória, vamos focar agora em como reduzir o tempo gasto na execu- ção das microinstruções A seguir, veremos o uso do pipeline 205
    •  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 Podemos representar desta forma, onde cada quadrado representa um subciclo: I B E AR BO 206
    •  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 Esquematizando, teríamos: I1 B BO E AR I2 B BO E AR3 B ... tempo Como otimizar este processo? 207
    • Curiosidades Henry Ford (1863 – 1947) nasceu nos EUA, fundou a Ford – fábrica de auto- móveis – e defendia for- temente o consumismo Mas nada disso nos interessa 208
    • Curiosidades Ford utilizava a chamada “linha de montagem”, que consistia em especializar seus empregados em funções definidas O mesmo empregado passava todo o temporealizando uma única tarefa, mais específica possívele repetidas vezes, de forma a diminuir a chance deerros e fazer com que levasse menos tempo paraconcluir a tarefa 209
    •  Aplicaremos o “fordismo” aos nossos estudos: em vez de uma via de dados onde todas as atividades são realizadas, teremos uma via de dados especializada para cada operação O ganho no desempenho é bastante significativo I1 B BO E AR I2 B BO E AR3 B ... I tempo 210
    •  Dessa forma, assim que a busca de uma instrução for concluída, pode ser iniciada a busca da próxima, já que a via especializada nesta tarefa estará livre. E o mesmo serve para identificação, busca de operandos etc Podemos chamar cada um dos quadrados de um estágio do pipeline Antes, o tempo total era dado pelo tempo de uma instrução multiplicado pelo total de instruções: t = n.tinst 211
    •  No pipeline, o tempo de uma instrução é dado pelo número de estágios multiplicado pelo tempo de um estágio: tinst = ne.te 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: tpipe = tinst + (n – 1).te = (ne + n – 1).te Com isso, podemos conhecer o speedup, ou seja, o quanto mais rápido é a execução por pipeline em relação ao modelo de Von Neumann 212
    •  O cálculo se dá dividindo o tempo total t do modelo de Von Neumann pelo tempo gasto no pipeline, o que nos dá: O número de estágios vai ser sempre muito inferior ao número de instruções, portanto podemos ignorar os valores ne e -1 no denominador. No numerador, isso não é possível por ser uma multiplicação, e não uma soma Passamos a ter então: 213
    •  Com o resultado, inferimos que a execução de um programa é, idealmente, ne vezes mais rápida no pipeline É fácil visualizar isso:  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 214
    •  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 Mas, como sempre, existem problemas E é deles que vamos falar a partir de agora 215
    •  Dependência de dados  Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos  Isto caracteriza desperdício de tempo a = b + c d = a + h B I E GR BO B I E GR BO Agora, aparece o problema. Neste ciclo, buscamos No operandos a e h instrução é dos sendoOub a é e Vamos a máquina identifica a instrução “a para+ c” o os primeiro ciclo, a dasucessão buscada. que Aqui, acompanhar a instrução 2, ciclos = seja, ao seu final,valor dos operandos resultado ainda entender o que acontece E estetem a instrução resultadoo ainstrução 1. já busca da máquina apenas b e c. Neste mesmo sem nemé buscada queo que significa, pois ainda ciclo, já sequer saber isto só “d = a + feito não foi gravado, já a instruçãoterá sidoh” ao não foi identificada final do ciclo seguinte 216
    •  Dependência de dados  Quando há dependência de dados entre instruções, algumas componentes precisam se manter ociosas durante alguns ciclos  Isto caracteriza desperdício de tempo a = b + c d = a + h B I E GR BO B I - BO E - GR Portanto, faz-se necessário esperar até que o valor de a esteja corretamente gravado em algum registrador 217
    •  Note que, sem esse problema, levaríamos 5 ciclos para executar as 2 instruções. Com o impasse, levamos 2 ciclos a mais Se a dependência de dados ocorresse seguidamente em 500 instruções, levaríamos 2 ciclos a mais para cada dependência De pouco mais de 500 ciclos, a sequência passaria a levar cerca de 1500 ciclos para ser executada Há ainda outro problema, muito mais comum do que a dependência de dados 218
    •  Dependência de controle  Vimos que o endereço da instrução a ser buscada na memória se encontra no registrador PC  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  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 219
    • Controle Convém uma pequena MUX revisão. Lembra-se deste I esquema? N C MPC É sobre como são feitos os Memória de Controle desvios de instruções A C U A M U X O N D L A . . . . . D D R LMS N1 N0 ULA Z N 220
    •  Na verdade, não é necessário relembrar o que acontece em cada parte no desenho 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 Dito isso, conclui-se então que só sabemos se ocorrerá desvio no terceiro estágio B I E GR BO 221
    •  Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: se a = 0 então goto 8 Suponha que a instrução acima esteja no endereço 1 da memória principal B I E GR BO B I E GR BO Porém, chegamos agora ao ciclo onde a primeira Neste ciclo, executada. buscando a como saída o o instrução é estaremos A ULA dará nossa Agora, identificamos nossa instrução e buscamos instrução. a. Vamos supor queavaliado na lógica de próprio operando a, que seu endereço, então a 0. operando Se PC contém será este seja igual o conteúdo de PC é 1 buscamos a próxima instrução, microssequenciamento e, como é igual a 0, a Neste mesmo ciclo, execução dono endereço pc + 1.ser desviada para a por default, programa teria de Está sendo instrução então, a instrução no endereço 2 buscada, no endereço 8 222
    •  Isso significa que teremos problemas no pipeline se tivermos uma instrução parecida com: se a = 0 então goto 8 Suponha que a instrução acima esteja no endereço 1 da memória principal B I E GR BO B - I - BO E GR E agora? Constatamos anteriormente que a Mais umano endereço 2 já foi buscada, e a ciclos instrução vez, é necessário esperar alguns até que tenhamos a confirmação dee buscou os máquina a essa altura já identificou que haverá desvio, para só depois buscar a próxima interessa operandos dessa instrução que não nos instrução 223
    •  Nós, como projetistas da máquina, precisamos sempre buscar formas de passar por todos os obstáculos existentes em uma implementação A saída geralmente é pensar em otimizações que diminuam o prejuízo causado por possíveis problemas de uma implementação 224
    •  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 Vimos que a sequência a = b + c d = a + h causaria um desperdício de 2 ciclos na máquina Entretanto, o compilador pode “procurar” outras instruções que nada tenham a ver com estas e executá-las neste espaço 225
    •  Por exemplo, se houver no programa outras duas instruções de soma, a ordem de execução pode ser: a = b + c x = y + z m = n + p d = a + h Desta forma, não haverá perda de tempo O processador acaba de gravar o resultado em alguma = b + c B I E GR BO registrador I x = y + z B BO E GR Inicia-se a busca dos I operandos. Quando o m = n + p B BO E GR registrador onde está a for I consultado, lá já estará o d = a + h B BO E GR valor correto de a 226
    •  Outra otimização possível é conhecida como Data Forwarding 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 Registradores ULA 227
    •  Na sequência: a = b + c d = a + h sabemos que a segunda instrução também pode ser escrita como “d = b + c + h” Desta forma, não precisamos esperar até que o registrador da variável a seja atualizado para buscar os operandos da segunda instrução 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 228
    • Agora, podemos reaproveitar este Antes, precisávamos do valor valor logo após o término da gravado em um registrador execução da operação na ULA B I E GR BO B - - I E GR BOEsta seria uma opção bastante útilpara um caso do tipo: a = b + c d = a + e f = d + g h = f + i j = h + k x = j + h 229
    •  Processadores como o da Intel possuem uma série de outras otimizações na implementação do pipeline 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 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) 230
    •  Acompanhe: i <- 1; i=1 A condição é analisada e para i = 1 até 10 faça não ocorre desvio: para ...desviamos de volta entramos no loop no instrução 1; a primeira instrução loop instrução 2; instrução 3; i <- i + 1; Neste momento, Hora de analisar i = 2, fim do loop então para iniciar menor novamente se i é a segunda iteração... ou igual a 10 231
    •  Há ainda uma última forma de otimização que melhora o desempenho da nossa máquina, conhecida como superpipelining Vimos que a implementação do pipeline agiliza, idealmente, ne vezes a execução das instruções em relação à nossa máquina antiga Ora, por que então usar apenas 4 estágios? 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 B1 B2 B3 B4 . . . . . . 232
    •  Esta configuração caracteriza exatamente um superpipeline Ok, 20 estágios já está melhor que 4. Mas por que não usar, talvez, 1000 estágios? 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 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 233
    •  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 Até agora, economizamos alguns ciclos aqui, outros lá, já executamos várias instruções ao mesmo tempo e por aí vai 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 Estas operações levam aproximadamente 100 ciclos para serem realizadas! 234
    • Memória Principal x Cache Uma das soluções possíveis para diminuir a perda de tempo envolvida em operações de leitura e escrita na memória principal são as memórias cache Este é um tipo de memória rápida, isto é, acessos a ela levam muito menos tempo, porém com a desvantagem de serem surrealmente caras Recordando, de forma simplificada, o modelo de Von Neumann: Memória Processador 235
    •  Temos as seguintes opções:  A que usávamos antes, memória principal, lenta, mas com um tamanho maior sem um custo alto demais Memória Processador Principal  Uma memória cache, caríssima e, portanto, de tamanho bem limitado, mas muito mais rápida Cache Processador 236
    •  Podemos sonhar que somos infinitamente ricos e simplesmente aumentar a cache até o tamanho que queremos Ou podemos voltar à realidade... 237
    •  Agora, vem a pergunta “manjada”: será que é possível ter o benefício da rapidez da memória cache sem ter que aumentá-la a ponto de deixar a máquina cara demais, e ao mesmo tempo ter o tamanho de uma memória principal razoável? Podemos começar com uma constatação básica: utilizando uma memória convencional, gastaremos 100 ciclos (tempo de leitura na memória, como já vimos) pelo menos uma vez por instrução, pois precisamos buscar cada uma delas na memória Então, já seria um bom começo não precisar buscar uma mesma instrução duas vezes 238
    •  Podemos arrumar nossa máquina da seguinte forma: Memória Cache Processador Principal dados dados Já que a cache tem um tamanho bastante limitado, podemos usá-la pelo menos para armazenar instruções que já tenham sido buscadas. Assim, quando o processador precisar de alguma instrução pela segunda vez, ela será carregada da cache, o que levará muito menos tempo do que carregá-la da memória principal novamente 239
    •  Vamos agora supor uma instrução que é executada k vezes ao longo de um programa Na arquitetura em que só havia processador e memória principal, o tempo médio para buscar essa instrução seria, naturalmente, o tempo gasto em uma operação de busca na memória Já na arquitetura proposta no slide anterior, sabemos que a instrução só será buscada na memória principal na primeira vez. Nas outras (k - 1) vezes, ela será carregada da cache. Logo, o tempo médio para buscar essa instrução será: 240
    •  Para k muito grande, temos k >> tmem, e k ≈ k - 1. Daí: Ou seja, o tempo médio de busca dessa instrução será o tempo de buscá-la na cache, que era o que queríamos antes E nem precisamos gastar uma senhora grana com uma cache do tamanho da memória principal; bastou usar uma menor com alguma inteligência 241
    •  Existe um tipo especial de cache, chamado cache associativa, que recebe da memória principal um conjunto de instruções, em vez de apenas uma por vez. Estes conjuntos são os blocos Blocos de instruções são divisões feitas tanto na memória principal quanto na cache, de tamanho fixo e pré-determinado Por exemplo, podemos dividir a memória principal em blocos de tamanho 4 (cada um contém 4 palavras): bloco 1 bloco 2 bloco 3 bloco 4 bloco 5 . . 242 .
    •  Sempre que o processador pedir uma instrução, a cache armazenará todo o bloco de onde essa instrução faz parte: Vamos dar um zoom em parte da memória do slide anterior. Suponha que o processador precisa da palavra no endereço 6: 0 1 As palavras nos endereços 2 4, 5 e 7 também são 3 carregadas para a cache 4 5 6 7 Cache 8 9 10 243 11
    •  Se as palavras nos endereços 4, 5, 6 e 7 forem todas instruções e estas forem executadas sequencialmente, apenas uma consulta na memória principal será necessária, em vez de 4 Considerando que, em aplicações reais, o tamanho dos blocos tende a ser muito maior que 4, pode-se dizer que conseguimos uma grande vantagem Analisaremos mais a fundo a cache associativa para entender melhor suas vantagens 244
    •  Cache associativa para blocos de tamanho 4: validade nº do bloco (0 ou 1) bloco (Pn é a n-ésima palavra do bloco) 1 3 P0 P1 P2 P3 1 5 P0 P1 P2 P3 0 2 P0 P1 P2 P3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
    •  Validade é o bit que diz se aquele bloco está sendo usado ou é lixo. 1 significa que o bloco está sendo usado, enquanto 0 quer dizer que aquela linha pode ser sobrescrita Número do bloco é o número (evidentemente binário) que representa onde aquele bloco estava na memória principal. Se o bloco armazena as palavras vindas dos endereços 0, 1, 2 e 3 da memória, então seu número é 0; se armazena as palavras dos endereços 4, 5, 6 e 7, então seu número é 1; etc Quando o processador pede alguma palavra da memória, todas as linhas de validade 1 são verificadas, e a palavra é buscada na memória principal apenas se não existir na cache Mas como essa checagem é feita? 246
    •  Antes, precisamos entender uma certa “mágica” Seja a memória dividida em blocos de tamanho n Cortando os log₂n bits menos significativos do endereço de uma palavra, obtemos exatamente o bloco onde ela está Por exemplo, vimos que, dividindo em blocos de tamanho 4, a instrução no endereço 7 está no bloco 1 7 na base 2, em 8 bits, é igual a: 00000111 log₂4 = 2; então, tirando os 2 bits menos significativos, obtemos o valor 1, que é o 247 número do bloco da instrução 7
    •  Na verdade, não é algo tão difícil de aceitar se pensarmos em uma generalização Vamos pensar na base 10: considere uma memória dividida em blocos de tamanho 100 Os endereços 0 até 99 estão no bloco 0, do 100 até 199, estão no bloco 1, e por aí vai Para obter o bloco da palavra no endereço 374, precisamos tirar os log₁₀100 bits menos significativos (mudamos para a base 10, então a base do logaritmo passa a ser 10) log₁₀100 = 2, então tiramos os 2 374 3 algarismos menos significativos. A palavra está no bloco 3 248
    •  Voltando ao que interessa, vamos supor que o valor 00001001 chegue ao MAR no processador. Isto significa que o processador está pedindo a palavra que está no endereço 9 Os 2 bits menos significativos são ignorados, e o valor 000010 é comparado, na cache, a todos os números de bloco pertencentes a linhas de validade 1 Mas como uma consulta na cache pode ser tão rápida, se ainda precisamos fazer uma busca sequencial para saber se o bloco 2 já está de fato armazenado na cache? 249
    •  Na verdade, a busca não é sequencial Em cada uma das linhas da cache, existem portas lógicas que comparam simultaneamente o número do bloco nela presente ao valor recebido os valores são diferentes 000010 os valores são iguais 1 3 P0 P1 P2 P3 1 5 P0 P1 P2 P3 1 2 P0 P1 P2 P3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
    •  O bloco então está na cache. Mas como encontrar a palavra certa (a do endereço 9) em meio às 4 palavras do bloco, que contém as palavras dos endereços 8, 9, 10 e 11? Recordando: a palavra pedida é a do endereço 00001001, e para obter o bloco ignoramos os 2 bits mais à esquerda, 01 E estes dois bits são exatamente os bits que informam qual a palavra certa a ser buscada no bloco! Então, a palavra do endereço 9 é a P₁ do bloco 2Dessa forma, carregamos a palavra direto da cache, sem consulta à memória principal 251