Modelo Von Neumann - Organização de Computadores

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Modelo de von NeUmann
Arquitetura de Von Neumann
Um computador é organizado internamente com base em três módulos:
Processador (ULA + UC)
Memória Principal (usualmente a memória RAM)
Dispositivos de Entrada e Saída.
A memória do computador não é somente a memória principal, mas pode estar presente de diversas formas:
Registradores na UCP.
Memória Cache
Memórias Secundárias (HD, SSD, Fita magnética, etc)
Arquitetura de Von Neumann
Arquitetura de Von Neumann
A organização de como os computadores funcionam hoje começou a ser elaborada em 1946 pelo John Von Neumann.
Von Neumann e sua equipe trabalhava em um projeto de uma máquina capaz de armazenar programas na memória, junto com os dados.
Até então os computadores eram construidos com um conjunto limitado de instruções e usavam somente “programas fixos”, onde o processo de criação de um novo programa era muito trabalhoso ou até mesmo impossível em alguns casos.
Esse novo computador que usava o conceito de programas armazenados foi projetado pela IAS e influenciou fortemente o projeto dos computadores projetados após ele.
Arquitetura de Von Neumann
ULA (Unidade Lógica e Aritmética)
Características gerais
Executa as operações matemáticas e lógicas especificadas nas instruções recebidas.
Prepara informações para a execução dos desvios ou saltos.
Normalmente executa operações bastante simples.
 (soma de 2 operandos, comparação de 2 operandos, negação ou inversão de um operando, deslocamento à esquerda ou direita, etc). 
Funções ou operações complexas são obtidas pela execução de várias operações simples.
O seu registrador Acumulador serve para receber os operandos necessários e conter o resultado da operação a ser efetuada.
O Acumulador
O tamanho do acumulador define a capacidade em bytes do processador.
O acumulador é ativado por um sinal de controle de carga. 
A cada sinal de carga, o dado que estiver na entrada do registrador será copiado para seu interior.
Em processadores mais modernos, mais de um registrador interno pode desempenhar a função de acumulador.
Registradores mais a ULA formam o caminho de dados do processador.
Representação gráfica da ULA
No barramento de dados (setas grossas) tem-se os operandos como entrada e a ULA fornece o resultado.
A ULA não acumula o valor da última operação.
Normalmente a última operação de um cálculo será mover o resultado obtido para o registrador acumulador e eventualmente deste para alguma posição da memória.
Entre os sinais de controle de entrada, temos os que servem para selecionar que tipo de operação se deseja executar.
A saída de status da ULA irá para o registrador de status, para ser armazenada e consultada em etapa posterior, caso necessário.
Dados de entrada 
Representação gráfica do caminho de dados
Distinção entre ULAs
Uma determinada ULA se distingue de outra, segundo Raul F. Weber, por:
Comprimento em bit dos operandos (tamanho dos registradores de dados e acumulador).
Numero e tipo de operações que podem ser realizadas.
Os códigos de condição (status) gerados.
UC (Unidade de controle)
Características
A Unidade de Controle:
controla o fluxo interno de dados;
define o instante preciso onde ocorrem as transferências entre uma unidade e outra;
gera sinais de controle para os diversos componentes do computador.
Cada sinal da UC dispara o que se chama microoperação.
carregar (armazenar) dados em um registrador.
habilitar ou desabilitar um determinado circuito interno ao processador
ativar uma determinada parte da memória.
selecionar uma operação que seja válida.
A ULA para executar as operações ou cálculos está sempre sob o comando da UC.
Registradores especiais
Alguns registradores possuem funções específicas, fundamentais para o processamento.
 Dependendo da arquitetura, eles podem estar na ULA ou na UC.
Tais registradores, entre outros, são:
Apontador de instruções, contador de instruções, contador do programa, program counter (PC): Contem o endereço de memória da próxima instrução a ser executada.
Registrador de instrução (RI) ou Instruction Register (IR): Contem a instrução que está sendo atualmente executada. A UC irá gerar sinais de controle de acordo com o conteúdo em RI.
Registrador de estado ou registrador de status: fornece o resultado da última operação efetuada. Entre as informações possíveis temos:
overflow: se houve estouro em uma determinada operação
sinal: se o resultado é positivo ou negativo
carry: se a operação gerou vai-um
zero: se o resultado da operação é zero
error: se ocorreu algum erro na operação
Processamento de instruções
Conceituação
Uma instrução é um conjunto de bits devidamente codificados, que indica ao computador que sequência de microoperações devem ser executadas - Raul F. Weber
Na instrução temos a operação a ser executada e informação sobre os operandos necessários para sua execução.
Um programa nada mais é que uma sequencia de instruções pré-estabelecidas.
Os operandos para uma instrução podem estar em um registrador ou em alguma posição da memória.
Conceituação
Tipos de instrução mais comuns:
Instruções de transferência de dados
Operações aritméticas
Operações lógicas
Instruções de teste e desvio
Nas instruções de desvio, deve-se indicar para qual posição do programa se vai desviar. 
As várias formas que se pode informar o endereço de um operando ou o endereço para desvio do programa é denominado modo de endereçamento do computador.
Ciclo de Busca-Decodificação-Execução
O processador está continuamente buscando a próxima instrução a ser executada, decodificando tal instrução e finalmente a executando.
Este processo ou ciclo é denominado ciclo de busca-decodificação-execução (BDE), ou ciclo do processador.
Neste processo, a primeira fase é a de Busca. Nesta fase uma instrução é lida da memória. Para isso deve-se:
Copiar o valor do registrador PC para o Registrador de Endereços da Memória (REM).
Ativar o sinal de leitura da memória.
Copiar o valor colocado no Registrador de Dados da Memória (RDM) para o registrador de instruções (RI).
Atualizar o registrador PC.
Ciclo de Busca-Decodificação-Execução
Decodificação: nesta fase, determina-se que tipo é a instrução recebida. 
Execução: para cada tipo de instrução, pode acontecer nessa fase:
cálculo dos endereços dos operandos
busca dos operando na memória (colocando endereço em REM e lendo o valor em RDM).
carga dos registradores
escrita dos operando na memória
atualização do PC, no caso de desvios.
Após a execução volta-se ao início, já que PC já está com o endereço da próxima instrução.
A velocidade desse ciclo determina, em última análise, a velocidade do processador.
Notar que a sequência se assemelha a um conjunto de operações executadas em um software. 
Portanto, pode-se desenvolver um software que execute as funções de um processador (emulador)
Exemplo de código
Código, do professor Tannenbaun, que simula a interpretação de programas para uma máquina muito simples, que trabalha com instruções de apenas 1 operando.
A máquina tem: 
1 registrador apontador de instruções (PC): guarda o endereço da próxima instrução;
1 registrador de instruções (IR): armazena a instrução corrente; 
1 registrador acumulador (AC): usado nas operações de cálculo;
1 registrador instr_type: contem qual o opcode (tipo de instrução) correspondente à instrução; 
1 registrador de endereço (AR): armazena o endereço do dado, ou -1 se não precisar de dado;
1 registrador de dados (DR): armazena o dado a ser processado no momento;
1 registrador de bit de execução (run_bit): sendo 1 máquina funciona, sendo 0 a máquina para.
A função execute() executa a instrução informada 
Exemplo de código
public class Interp {
 static int PC, AC, IR, AR, DR; //endereço da próxima instrução, acumulador, 				//instrução atual, operando (dado) corrente
 static int instr_type, run_bit;//tipo de instrução (opcode), ativação da máquina
 public static void interpret(int memoria[], int ender_inicial)
{
 PC = ender_inicial;
 While (run_bit) { // busca a proxima instrução,
 IR = memoria[PC]; // armazena-a em IR, e incrementa PC
 PC = PC + 1;
 instr_type = get_instr_type(IR);//determina tipo da instrução.
 AR = find_data(IR,instr_type);//localiza o dado,-1 se não há
 if (AR >= 0) //havendo dado, busca-o e o armazena em DR
 DR = memoria[AR];
 execute(instr_type, DR);
 }
 }
 private static int get_instr_type(int endereco){....}// define o tipo de instrução
 private static int find_data(int instrucao, int tipo) {....} //retorna o dado na 						//memória, ou -1 
 private static void execute (int tipo, int dado) {...} // executa a instrução
}