Microprocessadores: A Evolução da Computação com Programa Armazenado

Nos primórdios da computação, pioneiros como Alan Turing e John von Neumann reconheceram que máquina verdadeiramente útil deve fazer mais que meramente executar lista de comandos — deve ser capaz de armazenar, recuperar e modificar dados no mesmo pool de memória. Este insight levou ao conceito de computador com programa armazenado (stored-program computer).

Máquina teórica de Turing dependia de fita de acesso sequencial para manter tanto instruções de programa quanto dados. Circuito de controle lia fita, executava operações, e reescrevia resultados na fita ou movia fita para ler novos dados. Sistemas modernos substituem aquela fita por memória de acesso aleatório (RAM), alcançando mesmo propósito com velocidade e flexibilidade muito maiores.

Analogia útil vem de controle automático de máquina-ferramenta inicial. Sistemas de controle numérico (NC) de malha aberta guiavam torno ou fresa seguindo instruções codificadas como furos em fita de papel. Máquina movia-se cegamente, seguindo fita sem consciência do estado da peça.

Como dispositivo era "cego" ao ambiente, não podia compensar mudanças como expansão de metal ou desgaste de ferramenta. Programador também tinha que antecipar toda sequência possível de instruções, pois fita era somente-leitura e máquina não tinha memória interna para rastrear seu estado.

Atualização para máquina de estados finitos (FSM) deu à ferramenta memória rudimentar: alimentando alguns bits de dados de volta à lógica de endereço, sistema podia lembrar estados simples como "refrigerante ligado" ou "ferramenta em posição". Ainda assim, ficava aquém de verdadeira flexibilidade.

O avanço veio com controle numérico de malha fechada (CNC), onde programa podia escrever novos dados em memória gravável (RAM). Sistema de controle podia então registrar o que fez e adaptar-se a mudanças detectadas por sensores — muito como maquinista anotando notas em rascunho para referência posterior.

Cientistas da computação há muito sonham com máquinas que modificam seu próprio código, espelhando como cérebro humano fortalece sinapses através de experiência. Para tais programas auto-modificáveis serem viáveis, código executável deve residir na mesma memória gravável que armazena dados — noção que permanece na fronteira da pesquisa hoje.

A maioria do software ainda segue sequências fixas de instruções, alterando apenas campo de dados separado. Para verdadeiramente suportar modelo de programa armazenado, precisamos mais que FSM; precisamos memória leitura/escrita, unidade de processamento de dados, e controlador sofisticado.

Memória leitura/escrita é prontamente fornecida por chips RAM estática ou dinâmica — acessíveis e rápidas. Operações lógicas são tratadas por Unidade Lógica Aritmética (ALU), que executa funções aritméticas e booleanas.

Unidade de Controle orquestra movimento de dados entre memória, ALU, e dispositivos externos. Usa buffers tri-state para rotear dados em barramentos e lógica decodificadora para traduzir códigos binários de instrução em ações.

Instruções exemplo: "Some valor no endereço 0010 ao valor no endereço 1101," ou "Calcule paridade do byte no endereço 0111." Mapeamento de códigos binários para operações é arbitrário, como padrão ASCII inicial, embora instruction sets sejam tipicamente manufacturer-specific.

Quando memória leitura/escrita, ALU, e Unidade de Controle são integrados — frequentemente em único chip — formam um processador. Processador com memória externa mínima é microprocessador; acoplado com circuitaria de controle de barramento, torna-se Unidade Central de Processamento (CPU).

Operação da CPU encapsula-se no ciclo fetch/execute. O program counter (contador de programa) mantém endereço da próxima instrução. Unidade de Controle lê aquele endereço no barramento de endereço de memória, recupera instrução da RAM, e armazena em registrador temporário.

Se instrução requer operandos, Unidade de Controle emite acessos de memória adicionais, roteando dados buscados para registradores da ALU. ALU então executa operação solicitada, colocando resultado no acumulador. Finalmente, program counter incrementa, e ciclo repete.

 Microprocessador (CPU)

--------------------------------------
| ** Program counter ** |
| (incrementa valor endereço enviado |
| a chip(s) memória externa para buscar |==========> Address bus
| próxima instrução) | (para RAM memory)
--------------------------------------
| ** Control Unit ** |<=========> Control Bus
| (decodifica instruções lidas de | (para todos dispositivos
| programa em memória, habilita fluxo | compartilhando address e/ou
| de dados para/da ALU, registradores | data busses; arbitra toda
| internos, e dispositivos externos) | comunicação bus)
-------------------------------------- 
| ** Arithmetic Logic Unit (ALU) ** |
| (executa todos cálculos |
| matemáticos e funções |
| Booleanas) |
--------------------------------------
| ** Registers ** |
| (pequenas memórias leitura/escrita |<=========> Data Bus
| para manter códigos instrução, | (da RAM memory e outros
| códigos erro, dados ALU, etc; | dispositivos externos)
| inclui "accumulator") |
--------------------------------------
 

Mesmo operações mais simples requerem muitos micro-passos. Aritmética complexa como exponenciação envolve iterações repetidas de funções básicas. Considere milhares de ciclos que motor gráfico de simulador de voo deve executar para refrescar display a cada frame.

A velocidade pura do ciclo fetch/execute torna isso viável. Alguns designs embutem pequeno programa — chamado microcódigo — em ROM interna. Microcódigo lida com sub-passos de operações complexas, permitindo programador emitir única instrução de alto nível em vez de escrever cada detalhe.

Desta forma, processador contém um processador: programa rodando dentro de programa que simplifica desenvolvimento preservando performance.