Como discutido no capítulo 1, virtualmente todos os computadores modernos tem o mesmo esquema básico, conhecido como arquitetura de von Neumann. Este esquema divide o hardware de um computador em três componentes principais: memória, Unidade Central de Processamento (UCP ou CPU) e dispositivos de entrada e saída. A memória armazena dados e instruçõesde programas. A CPU é encarregada de buscar as isntruções e dados da memória, executar as instruções e então armazenar os valores resultantes de volta na memória. Os dispositivos de entrada (tais como teclado, mouse e microfone) e dispositivos de saída (tais como a tela, altofalantes e impressora) possibilitam a interação com o usuário, permitindo que as pessoas forneçam entradas e exibindo dados, instruções e os resultados das computações.

Este capítulo explora os detalhes da arquitetura de von Neumann, descrevendo o funcionamento interno de um computador. As explicações são dadas de maneira incremental, partindo de um model simples de Parte Operativa de CPU e então acrescentando a memória principal e depois uma Unidade de Controle. Quando combinados com dispositivos de entrada e de saída, estes componentes representam um modelo preciso (apesar de simplificado) de um computor programável moderno. Para facilitar o aprendizado, são utilizados simuladores (desenvolvidos por Grant Braught do Dickinson College) para cada modelo.

Subunidades e Parte Operativa da CPU

Como visto no capítulo1, a CPU age como o cérebro do computador. Ela é responsável por obter dados e instruções a partir da memória, executar as instruções e armazernar os resultados de volta na memória. O conjunto de isntruções que uma dada CPU de um computador pode entender e executar é conhecido como a linguagem de máquina do computador. Os programadores podem controlar o comportamento de um computador definindo instruções para sua CPU - isto pode ser realizado seja escrevendo programas diretamente em linguagem de máquina ou escrevendo programas em uma linguagem de alto nível e então traduzindo para linguagem de máquina. Mesmo programas que exibem um comportamento complexo são especificados para a CPU como sequências de instruções simples de linguagem de máquina, cada uma executando uma tarefa que não é mais complexa do que somar dois números ou copiar dados para uma nova posição na memória. No entanto, A CPU pode executar estas instruções de maneira tão rápida que pode ser obtido um comportamento complexo do computador.

Subunidades da CPU

A CPU é composta de várias subunidades, cada uma com uma função específica na operação do processador como um todo. Estas subunidades são a Unidade Logico-Aritmética (ULA), registradores e Unidade de Controle.

• A Unidade Logico-Aritmética é uma coleção de circuitos que realizam as operações sobre os dados. As operações básicas podem incluir adição, subtração e manipulações de bit (tais como deslocamento ou combinação de bits)
• Registradores saão posições de memória construídas dentro da CPU. Como os registradores são integrados diretamente nos circuitos da CPU, os dados nos registradores podem ser acessados muito mais rapidamente (5 a 10 vezes mais rápido) do que dados na memória principal. No entanto, devido ao número limitado de registradores na CPU (usualmente 16 ou 32 registradores), estas posições de memória são reservadas para dados que a CPU está usando em um dado momento. Para funcionar de maneira efetiva, o computador deve copiar dados constantemente entre os registradores e a memória. Estas transferências ocorrem através de coleção de conexões chamadas barramentos, que conectam  os registradores  com a ULA e com a memória principal.
  
• A Unidade de Controle Unit  pode ser vista como "o cérebro dentro do cérebro", pois ela controla as várias funções da CPU. A Unidade de Controle é formada de circuitos que realizam a busca de dados e instruções a partir da memória principal, bem como controla o fluxo de dados do registradores para a ULA e da ULA para os registradores. 

Figure 14.1: Subunidades da Unidade Central de Processamento (CPU).

Ciclos da Parte Operativa da CPU

Os caminhos que os dados seguem dentro da CPU, viajando através de barramentos a partir dos registradores para a ULA e então de volta para os registradores é conhecido como Parte Operativa da CPU. Todas as tarefas realizadas por um computador, desde formatar um documento até exibir páginas em um navegador Web, são decompostas em sequências de operações imples; o computador executa cada operação individual movimentando dados dos registradores para a ULA, executando computações sobre estes dados na ULA e então armazenam o resultado nos registradores. Uma passagem completa pela Parte Operativa da CPU (dos resgistradores passando pelos barramentos e ULA e voltando aos registradores) é chamado de ciclo da Parte Operativa, ou ainda ciclo da CPU.

Relembrando o que vimos no capítulo 1, onde foi definida a velocidade da CPU como medida pelo número de instruções  que a CPU pode executar em um segundo. Como cada instrução precisa de um ciclo de CPU para executar, a velocidade da CPU corresponde diretamente ao número de ciclos de CPU que ocorrem por segundo. Por exemplo, uma CPU de 800 MHz é capaz de executar 800 milhões de ciclos em um único segundo, enquanto uma CPU de 1,4 GHz é capaz de executar 1,4 bilhoes de ciclos de CPU em um segundo. No entanto, não se pode avaliar CPUs somente comparando a velocidade dos processadores, pois duas linguagens de máquina diferentes podem dividir a mesma tarefa em diferenets conjuntos de isntruções e um conjunto de instruções pode ser mais eficiente que o outro. Isto é, uma CPU pode ser capaz de completar uma dada tarefa em um único ciclo, enquanto outra pode precisar de vários ciclos para completar a mesma tarefa. Para comparar o desempenho de CPUs, deve-se considerar o conjunto de instruções de cada CPU, bem como fatores como o número de registradores e tamanho dos barramentos que transportam os dados entre os componentes.

Simulador de Parte Operativa

Para ajudar a visualizar o comportamento da parte operativa da CPU, vamos usar um simulador. O Simulador de Parte Operativa da CPU modela uma CPU simples contendo quatro registradores. Usando o simulador, você pode seguir o fluxo dos dados a medida que eles trafegam pela parte operativa da CPU, a partir dos registradores para a ULA e de volta para os registradores. Para deixar as coisas simples, não é incluida uma Unidade de Controle explícita neste simulador. Ao invés disto, o usuário deve agir como a Unidade de Controle, selecionando os registradores de entrada, a função da ULA e o registrador de saída clicando nos botões do simulador.

As figuras 14.2 até 14.5 demonstram o uso do simulador para somar dois números - uma tarefa que pode ser realizada em um único ciclo de CPU.

• Este simulador usa caixas de texto para representar registradores, possibilitando ao usuário entrar com dados digitando nas caixas. Os botões, que permitem ao usuário especificar como os dados movem ao longo da parte operativa da CPU e que operações a ULA executa sobre os dados, são imagens que mudam quando o usuário clica nelas. Na figura 14.2, o usuário entrou os números 43 e 296 nos registradores R0 e R1, respectivamente. Depois de entrar estes valores, o usuário clicou no botão do barramento A para selecionar R0 e no botão do barramento B para selecionar R1. Isto fará com que os números armazenados nestes dois registradores sejam transferidos através dos barramentos indicados para a ULA, a qual executará uma operação sobre eles. Como o usuário posicionou o botão de operação da ULA para adição e o botão do barramento C para R2,a ULA fará a soma dos dois n;umero e o resultado será transferido através do barramento C para ser armzenado no registrador R2.
  
• Depois de entrar com os ajustes desejados, o usuário inicia o ciclo de CPU no simulador clicando no botão rotulado Execute. A figura  14.3 mostra o estado da CPU a medida que os valores em R0 e R1 trafagam através dos barramentos A e B para a ULA. As setas que representam os barramentos piscam em vermelho e os números sendo transferidos são mostrados em caixas de texto próximas aos barrament
• A figura 14.4 ilustra o estado da CPU depois que a ULA recebeu os números e executou a operação especificada. Como o usuário colocou o botão de operação da ULA na posição da soma, a ULA soma os dois números, 43 e -296. O resultado -253 é enviado para fora da ULA através do barramento C.
• Finalmente, a figura 14.5 mostra o resultado final do ciclo de CPU. Como o usuário colocou o botão do barramento C para a posição do registrador R2, o valor -253 é enviado através do barramento C e é armazenado no registrador R2.

Figure 14.2: Configuração inicial do simulador.

Figura 14.3: Dados movendo dos registradores para a ULA.

Figura 14.4: Dados trafegando da ULA para os registradores.

Figura 14.5: Resultado final do ciclo de CPU.

CPU e Memória Principal

Apesar da Parte Operativa da CPU descrever como um computador executa computações sobre dados armazenados em registradores, nós ainda não explicamos como os dados entram nos registradores e como os resultados das operações da ULA são acessados fora da CPU. Estas duas tarefas envolvem conexões entre a CPU e a memória princiapl. Como visto no capítulo 1, todos os programas e dados ativos estão armazenados na memória principal de um computador. Nós podemos pensar da memória principal como uma grande coleção de posições de memória, na qual cada posição é acessível através de um endereço. De mesma maneira que os endereços de uma rua (por exemplo, tristão monteiro 590) permitem um carteiro encontrar um destinatário, um endereço de memória (por exemplo, posição de memória 31) permite a CPU encontrar e acessar um pedaço específico da memória principal. Um barramento conecta a memória principal com a CPU, permitindo ao computador copiar dados e instruções em registradores e então copiar os resultados das computações de volta para a memória principal. A figura 14.6 ilustra a interação entre a memória principal de um computador e a CPU; as setas escuras representam o fluxo de dados da parte operativa da CPU, enquanto as setas mais claras representam o barramento que conecta a memória principal aos registradores.

Figura 14.6: Um barramento conecta a memória principal à CPU

Transferindo dados para e a partir da memória principal

Enquanto um programa está sendo executado, a Unidade de Controle processa as instruções do programa e identifica que valores de dados serão necessários para realizar as tarefas especificadas.  Os valores desejados são então buscados a partir da memória principal através do barramento da memória principal, carregados em registradores e utilizados pelas operações da ULA.

Como um exemplo concreto, imgine que você tem um arquivo contendo 1.000 números e precisa computar a soma destes números. O arquivo pode ser carregado na memória principal - por exemplo, nas posições de memória 500 até 1499. Então, a Unidade de Controle pode realizar os seguintes passos para somar estes números e armazenar a soma resultante de volta na memória.

1. Initializar um dos registradores, por exemplo R0, com o valor 0. Este registrador irá armazenar a soma  total dos números
2. Para cada número armazenado nos endereços de memória de 500 até 1499:
   1. Copiar o número da memória principal para outro registrador, por exemplo R1.
   2. Executar um ciclo através da parte operativa da CPU para somar R0 e R1 e armazenar o resultado de volta em R0.
3. Quando todos os valores dos números no arquivo tiverem sido processados, o valor em R0 terá a soma total. Este valor pode então ser copiado de volta para uma posição na memória principal.

Note que cada número deve ser transferido em um registrador antes que ele possa ser acrescentado à soma total. Na prática, transferir dados entre a memória principal e a CPU ocorre em uma velocidade bem menor do que a de um ciclo de CPU. Isto é principalmente devido ao fato de que os sinais eletricos devem viajar por uma grande distância - por exemplo, a partir de um chip de RAM separado para o chip da CPU. No tempo que leva para os dados trafegarem pelo barramento da memória principal e alcançar os registradores, vários ciclos de CPU pode ocorrer. Os processadores modernos compensam este atraso com hardware especial que premite que várias instruções sejam buscadas ao mesmo tempo. Ao buscar várias instruções de antemão, o processador pode começar a lidar com uma próxima instrução e executar computações úteis enquanto uma transferência de dados anterior está ainda em andamento.

Parte Operativa com simulador de memória

Para ajudar a visualizar as relações entre a CPU e a memória principal, o simulador da parte operativa da CPU foi acrescido com uma memória principal. Este simulador estendido inclui uma memória principal que pode armazenar até 32 números, com endereços entre 0 e 31. Um novo barramento, rotulado Barramento da Memória Principal, conecta a memória principal com a CPU; este barramento permite que dados sejam copiados da memória principal para os registradores, bem como permite que os resultados da ULA  possam ser armazenados na memória principal. Como no exemplo anterior, esta versão do simulador não possui uma Unidade de Controle explícita. O usuário deve trabalhar como se fosse a Unidade de Controle, selecionando os ajustes desejados no barramento da memória principal para controlar o fluxo de dados.

As figuras 14.7 até 14.9 demonstram o uso do simulador para somar dois números armazenados na memória.

• Quando a CPU deve somar dois números armazenados na memória, o primeiro passo é copiar um dos números para um registrador. Na figura 14.7, o usuário selecionou o primeiro número a ser somado, naquele momento na posição de memória 0, clicando no botão  R/W próximo àquela posição (R/W se refere ao fato de que o botão seleciona que posição  da memória será lida (Read) ou escrita (Written). O usuário também configurou as setas em torno do barramento da memória principal para que elas conectem a memória principal aos registradores. Note que este barramento pode mover dados entre a memória principal e os registradores ou a partir da ULA para a memória principal, dependendo como o usuário posiciona as chaves do barramento. O usuário pode abrir ou fechar estas chaves clicando nelas, efetivamente conectando ou desconenctando o barramento. Uma vez dentro da CPU, o barramento da memória principal conecta-se ao barramento C, o qual armazena o número no registrador R0 (pois o botão do barramento C está posicionado para R0).
• A figura 14.8 ilustra o próximo passo no nosso exemplo, o qual envolve copiar o segundo número para um registrador. Como o usuário escolheu o botão R/W próximo à posição de memória 1 e posicionou o botão do barramento C para R1, o conteúdo da posição 1 será buscado e armazenado no registrador R1.
• A figura 14.9 mostra o ciclo de CPU durante o qual a ULA soma os conteúdos de R0 e R1. Note que os botões de ajuste do barramento A, do barramento B e da operação da ULA são os mesmo como os das figuras 14.3 through 14.6; isto é por conta dos dois exemplo envolverem a mesma tarefa de somar os números em R0 e R1. Na figura 14.9, no entanto, as chaves do barramento da memória principal estão ajustadas para que o resultado da soma seja enviado para a memória principal, ao invés de que seja enviado para os registradores.

Figure 14.7: Primeiro, 43 é carregado a partir da memória em R0.

Figure 14.8: Segundo, -296 é carregado a partir da memória em R1.

Figure 14.9: Finalmente, os valores são somados e a soma é armazenada de volta na memória.

Duas obervações interessantes podem ser feitas em relação ao comportamento do simulador. Primeiro, o simulador precisa de mais tempo para copiar dados entre a memória e a CPU do que ele precisa para executar um ciclo de CPU. Este atraso simula o efeito do tempos de acesso lentos associados com a memória principal. Em um computador real, cerca de até 10 ciclos de CPU podem ocorrer no tempo que leva para uma transferência de dados entre a CPU e a memória principal. A segunda observação é que, mesmo enquanto os dados estão sendo buscados a partir da memória, as operações ainda estão sendo executadas na parte operativa da CPU. Por exemplo, na figura 14.8, o número em R0 (43) é enviado através dos barramentos A e B para a ULA, produzindo a soma 86. Isto pode parecer lixo, pois o resultado das operações da ULA é ignorado (devido ao barramento C está desconectado). De maneira surpreeendente, isto reflete precisamente o funcionamento interno da CPU. É mais eficiente para a CPU executar computações desnecessárias enquanto dados estão sendo transferidos para ou a partir da memória do que adicionar circuitos extras para reconhecer se o barramento C estava desconectado.

Computador com Programa Armazenado

Agora que discutimos sobre a memória principal, estamos prontos para lidar com o último componente da CPU: uma Unidade de Controle totalmente funcional e automática. Para entende o papel da Unidade de Controle, relembre as tarefas que você realizou enquanto usava os simuladores. Quando você experimentou com Simulador de Parte Operativa, você definiu a computação que um ciclo de CPU deveria executar através da seleção dos registradores e da operação da ULA via botões. No simulador da parte operativa e memória principal, você controlou o fluco de informação entre a parte operativa e memória através de chaves e botões. A principal idéia por trás de um computador com programa armazenado é que estas tarefas pode ser representadas por instruções, armazenada na memória principal junto com os dados e então executadas pela Unidade de Controle.

Linguagens de Máquina

Uma linguagem de máquina é um conjunto de instruções correspondendo às tarefas básicas que uma CPU pode realizar. Em essência, cada instrução de linguagem de máquina especifica a configuração dos componentes de hardware que define uma particular computação em um ciclo da CPU. Assim, nós devemos definir instruções em linguagem de máquina para nosso simulador, enumerando todos os ajustes físicos dos botões e chaves. Por exemplo,

definiria uma configuração na qual os conteúdos de R0 e R1 seriam somados e o resultado armazenado de volta em R2. Esta notação pode ser suficiente para controlar o comportamento de uma máquina muito simples, tal como uma representando nosso simulador; no entanto, CPUs nop mundo real possuem um grande número de componentes físicos e especificar o estado de todas estas partes durante cada ciclo de CPU seria impossível. Além disso, como as isntruções são armazenadas na memória junto com os dados, as instruções devem ser representadas como padrões de bits.

A figura 14.10 descreve uma linguagem de máquina simples que foi projetada para nosso simulador. Como as posições da memória principal em nosso simulador podem caber no máximo 16 bits, nossa linguagem representa cada isntrução como um padrão de 16 bits. Os primeiros bits de cada padrão indicam o tipo de tarefa que a CPU dem realizar, enquanto os bits seguintes indicam os registradores e/ou posições de memória envolvidas na tarefa. Por exemplo, todas as instruções que envolvem soma de conteúdo de dois registradores começam com o padrão de bits 1010000100. Os seis bits finais da isntrução representam o registrador destino em binário (isto é, o registrador onde o resultado será armazenado) e os registradores fonte (isto é, os registradores cujos conteúdos serão somados pela ULA), respectivamente. Por exemplo, suponha que você quer somar os conteúdos de R0 e R1 e então armazenar o resultado em R2 - isto é R2 = R0 + R1. Os padrões de bits para R2 (2 = 10 em binário), R0 (0 = 00 em binário) e R1 (1 = 01 em binário) devem ser acrescentados no final do padrão de bits, produzindo a instrução em linguagem de máquina 1010000100100001. De maneira semelhante, se a intenção é fazer R3 = R0 + R1, então o padrão de bits para R3 (3 = 11 em binário) deve substituir o de R2: 1010000100110001.

As primeiras duas instruções da linguagem de máquina da figura 14.10 correspondem às tarefas que os usuários podem realizar com o simulador de parte operativa da CPU - isto é, selecionar uma operação da ULA e os registradores a serem operados no ciclo de CPU. As três instruções seguintes correspondem às tarefas que os usuários podem realizar com a versão do simulador para parte operativa com memória - isto é, controlar o fluxo de informação entre a memória principal e a parte operativa. A última instrução, parar (HALT), indica para a Unidade de Controle quando uma sequencia de isntruções termina. É claro que em uma CPU real se tem muito mais instruções do que estas. Por exemplo, se uma CPU executa um programa que inclui desvios condicionais (por exemplo, comandos se ... então e repetições), sua linguagem de máquina deve fornecer isntruções de desvio que permitam a CPU pular de uma instrução para outra. No entanto, o conjunto de instruções limitado da figura 14.10 é suficiente para demonstrar o funcionamento de uma CPU básica e sua Unidade de Controle.

Unidade de Controle

Uma vez que uma linguagem uniforme para uma dada CPU é estabelecida, as instruções podem ser armazenadas na memória juntamente com os dados. É então função da Unidade de Controle obter cada instrução em linguagem de máquina a partir da memória, interpretar seu significado, executar o ciclo de CPU correspondente e então passar para a próxima instrução. Como instruções e dados estão armazenados na mesma memória, a Unidade de Controle deve ser capaz de reconhecer onde uma sequência de instruções começa e termina. Em computadores reais, isto é usualmente controlado pelo sistema operacional, o qual mantém uma lista de cada programa em memória e sua localização. Por simplicidade, nosso simulador assume que a primeira instrução se encontra na posição 0 da memória. O final da sequência de instruções é definida explicitamente pelo padrão de bits "parar" (HALT).

Para ordenar a execução de uma sequência de isntruções, a Unidade de Controle mantém  um  Contador de Programa (Program Counter - PC) , que armazena o endereço da próxima instrução a ser executada. Como nós assumimos que todo programa começa no endereço 0, o valor do PC é inicializado com o valor 0 antes de começar a execução do programa. Quando a Unidade de Controle precisa buscar e executar uma instrução, ela acessa o PC e então obtém a instrução armazenada na correspondente posição de memória. Depois que a Unidade de Controle busca a instrução, o PC é automaticamente incrementado, assim ele identifica a próxima instrução na sequência.

Os passos realizados pela Unidade de Controle podem ser definidos com um algoritmo geral, no qual as instruções são repetidamente buscadas e executadas:

Algoritmo de busca e execução implementado pela Unidade de Controle:

1. Inicializa PC = 0.
2. Busca a instrução armazenada na posição de memória indicada pelo conteúdo do PC, e  faz PC = PC + 1.
3. Enquanto a instrução corrente não for a instrução "parar" (HALT):
   1. Decodifica a instrução - isto é, identifica a instrução e determina as configurações do hardware da CPU que devem ser usadas para executar a instrução.
   2. Configura o hardware da CPU para corresponderem ao indicado pela instrução.
   3. Executa um ciclo de parte operativa da CPU.
   4. Quando o ciclo se completa, busca a próxima instrução a partir da posição indicada pelo conteúdo do PC, e faz PC = PC + 1.

Por exemplo, suponha que a memória principal contém o programa e os dados mostrados na figura 14.11

As primeiras cinco posições de memória (endereços de 0 até 4) contém isntruções em linguagem de máquina para somar dois números e armazenar sua soma de volta na memória. Os números podem a serem somados são armazenados na posições de memória 5 e 6. Para executar este programa, a Unidade de Controle  deve seguir os seguintes passos:

1. Primeiro, o contador de programa é inicializado: PC = 0.
2. A instrução na posição de memória 0 (correspondente ao valor atual do PC) é buscada e o PC é incrementado: PC = 0 + 1 = 1.
3. Como esta instrução (1000000100000101) não é uma instrução HALT, ela é decodificada: o hardware da CPU é configurado de modo que o conteúdo da posição de memória 5 seja carregado no registrador  R0 e um ciclo de CPU é executado.
4. A próxima instrução, na posição de memória 1 (correspondente ao valor atual do PC) é buscada e o PC é incrementado: PC = 1 + 1 = 2.
5. Como esta instrução (1000000100100110) não é uma instrução HALT, ela é decodificada: o hardware da CPU é configurado de modo que o conteúdo da posição de memória 6 seja carregado no registrador  R1 e um ciclo de CPU é executado..
6. A próxima instrução, na posição de memória 2 (correspondente ao valor atual do PC) é buscada e o PC é incremenetado: PC = 2 + 1 = 3.
7. Como esta instrução (1010000100100001) não é uma instrução HALT, ela é decodificada: o hardware da CPU é configurado de modo que o conteúdo do registrador R0 é somado ao conteúdo do registrador R1 e o resultado é armazenado no registrador R2 e um ciclo de CPU é executado.
8. A próxima instrução, na posição de memória 3 (correspondente ao valor atual do PC) é buscada e o PC é incrementado: PC = 3 + 1 = 4.
9. Como esta instrução (1000001001000111) não é uma instrução HALT, ela é decodificada: o hardware da CPU é configurado de modo que o conteúdo do registrador R2 seja armazenado na posição de memória 7 e um ciclo de CPU é executado.
10. A próxima instrução, na posição de memória 4 (correspondente ao valor atual do PC) é buscada e o PC é incrementado: PC = 4 + 1 = 5.
11. Como esta instrução (1111111111111111) é uma instrução HALT, a Unidade de Controle reconhece o fim do programa e para a execução.

Simulador do computador com programa armazenado

O  Simulador do computador com programa armazenado modela o comportamento de um computador com programa armazenado completo. Instruções e dados podem ser entrados na memória, assumindo-se que a primeira instrução deve ser sempre colocada na posição 0 da memória. A Unidade de Controle é responsável pela busca e interpretação de instruções em linguagem de máquina, bem como realizar as tarefas especificadas por estas isntruções.

O simulador contém várias caixas de exibição para ajudar os usuários a acompanhar o funcionamento interno da Unidade de Controle. Como descrito na seção anterior, o contador de programa indica o endereço da próxima instrução a executada. Além do PC, a CPU mantém um Registrador de Instrução (Instruction Register - RI) que sempre contém a instrução que está sendo executada no momento pela CPU. O registrador IR é mostrado pelo simulador como uma caixa de texto adicional. Acima destas caixas, o simulador mostra os botões e chaves definidos pela isntrução corrente - isto torna a correspondência entre a instrução em linguagem de máquina e os ajustes nos botões e chaves mais  claro. Os valores dos botões são especificados em binário: 00 representa o botão  posicionado  para cima, 01 representa o botão posicionado para a direita, 10 representa o botão posicionado para baixo e 11 representa o botão posicionado para esquerda. Os valores da chaves também são escritos em binários, com um bit 1 representando a chave fechada e 0  indicando a chave aberta.
 

As figuras de 14.12 até 14.17 demonstram o uso do simulador para executar o exemplo do programa em linguagem de máquina da figura 14.11.

• A figura 14.12 mostra o estado inicial do simulador. As instruções em linguagem de máquinas são carregadas na memória principal, começando do endereço 0. Os dados necessários para executar as instruções também  são armazenados na memória, nos endereços 5 e 6, imediatamente depois da última instrução. Na Unidade de Controle, o contador de programa (PC) é inicializado com 0, assim a instrução 0 será a primeira a ser carregada e executada.
  

Figura 14.12: Estado inicial do simulador, com programa armazenado na memória principal.

Figure 14.13: Simulador depois da primeira instrução ter sido executada (R0 = MM5).

Figure 14.14: Simulador depois da segunda instrução ter sido executada (R1 = MM6).

Figure 14.15: Simulador depois da terceira instrução ter sido executada (R2 = R0 + R1).

Figure 14.16: Simulador depois do quarto comando ter sido executado (MM7 = R2).

Figure 14.17: Simulador depois do quinto comando ter sido executado (HALT).

O simulador é projetado de maneira que o usuário possa entrar valores na memória principal em decimal ou em binário. Por padrão, os valores entrados pelo usuário são assumidos estarem em decimal. No entanto, o usuário pode sempre selecionar 2 a partir da caixa View As a esquerda da posição de memória para ver o conteúdo em binário. Antes de entrar uma instrução em linguagem de máquina em uma célula de memória, o usuário deve primeiro selecionar 2 ta partir da caixa View As pois as instruções em linguagem de máquina são representadas em binário.

A função dos dispositivos de Entrada/Saída

Para completar nossa descrição do computador com programa armazenado, nós devemos pelo menos discutir brevemente a função dos dispositivos de entrada/saída. Os dispositivos de entrada tais como teclados, mouses e digitalizadores permitem o usuário entrar dados e instruções para o computador, que são então armazenados na memória e acessados pela CPU. Da mesma maneira, os dispositivos de saída tais como tela, altofalantes e impressoras permitem ao usuário acessar os resultados das computações que estão armazenados na memória.

Nos computadores projetados para executar um programa de cada vez, tais como os primeiros computadores programáveis da década de 1950 e mesmo os primeiros computadores pessoais da década de 1970, a interação com o usário era direta e sem muitas complicações. O usuário entra instruções de programas e dados diretamente nas posições da memória principal usando dispositivos de entrada tais como teclados ou leitores de fitas. Então apertando um botão, virando uma chave ou entrando um comando específico, o usuário mandava a CPU busca e executar as instruções do programa a partir da memória. O usário pode então observar os resultados da computação exibindo o conteúdo da memória em uma tela ou o enviando para uma impressora. Este processo é modelado por nosso simulador, no qual o usuário entra diretamente com isntruções e dados nas caixas da memória principal e então inicia a execução clicando em uma botão. Por outro lado, a maioria dos computadores modernos permitem que váriosprogramas sejam carregados na memória e sejam executados simultaneamente. Em tais computadores, o sistema operacional deve atuar, recebendo os dados e instruções do usuário, armazenando na memória e indicando suas posições na memória para a CPU.

Perguntas para revisão

1. Indique as três subunidades da CPU e descreva a função de cada uma na execução das computações.
2. O que é a Parte Operativa da CPU? Qual a relação que existe entre a Parte Operativa e a velocidade da CPU?
3. Considere dois sistemas de computação que são idênticos exceto por suas CPUs. O sistema 1 contém um Pentium 4 a 1,8 GHz, enquanto o sistema 2 contém um PowerPC a 1,8 GHz.  Estes dois sistemas sempre irão precisar da mesma quantidade de tempo para realizar um dado programa? Justifique sua resposta.
4. Considere as seguintes tarefas: (1) somar 100 números armazenados na memória principal e (2) somar um número a ele mesmo 100 vezes. Apesar de ambos os programas precisarem de 100 adições, o segundo poderá ser executado muito mais rapidamente do que o primeiro? Por que?
5. As linguagens de máquina são específicas de uma dada máquina, o que significa que cada tipo de computador tem sua própria linguagem de máquina. Explique por que isto acontece.
6. Na Unidade de Controle, qual a função do Contador de Programa (PC)? Ou seja, como o PC é usado na busca e execução das isntruções?