Arquiteturas Avançadas: RISC, Flynn e o Paralelismo Moderno

Chegamos ao último artigo da série Por Dentro do Computador. Ao longo dos onze artigos anteriores, construímos uma compreensão completa de como um computador funciona por dentro: da hierarquia de memória à cache, dos componentes da CPU ao ciclo de instrução, do pipeline aos barramentos, da representação de dados à execução de programas, e da entrada e saída que conecta tudo ao mundo externo.

Este artigo fecha o ciclo com as grandes questões arquiteturais: por que os princípios RISC venceram no projeto interno de muitos processadores modernos, por que o CISC continua relevante na interface de arquiteturas como x86, como classificar arquiteturas paralelas com a taxonomia de Flynn, e quais são os caminhos modernos para multiplicar o desempenho além dos limites de um único núcleo.

RISC: a filosofia da simplicidade

#

Na década de 1970, os computadores eram dominados por arquiteturas CISC (Complex Instruction Set Computer) — processadores com centenas de instruções complexas, cada uma podendo realizar múltiplas operações em uma única chamada. A ideia era que instruções poderosas tornariam os programas mais curtos e os compiladores mais simples.

Três projetos independentes questionaram essa premissa:

A conclusão comum era empírica: análise de compiladores reais mostrou que apenas uma fração das instruções CISC era efetivamente utilizada. A maior parte do tempo de execução envolvia operações simples (movimentação de dados, aritmética inteira básica, desvios). Instruções complexas raramente valiam o custo de implementação em hardware. Seria mais eficiente ter poucas instruções simples, executadas em um ciclo, do que muitas instruções complexas, executadas em vários ciclos.

Nascia o RISC — Reduced Instruction Set Computer.

As sete características do RISC

#

1. Conjunto reduzido de instruções — poucas dezenas a ~100 instruções; cada uma simples e regular.
2. Formato fixo — todas as instruções têm o mesmo tamanho (32 bits no MIPS, 32 bits no ARM clássico). Isso simplifica enormemente o estágio de decodificação do pipeline.
3. Arquitetura Load/Store — apenas LOAD e STORE acessam a memória principal; todas as demais instruções operam exclusivamente sobre registradores.
4. Grande banco de registradores — 32 ou mais registradores de propósito geral (vs. 8–16 no x86).
5. Baixo CPI nas instruções simples — a maioria das instruções é projetada para execução rápida, idealmente com CPI (ciclos por instrução) próximo de 1, favorecendo alto throughput no pipeline.
6. Pipeline altamente eficiente — o formato fixo permite decodificação paralela e estágios uniformes.
7. Compiladores mais complexos — a responsabilidade de otimizar código migra do hardware para o compilador; o hardware fica mais simples.

RISC × CISC: a comparação completa

#

Arquiteturas RISC reais

#

• ARM (Advanced RISC Machines): domina smartphones e sistemas embarcados, e também ganhou muito espaço em notebooks, desktops e cloud. A linha Apple Silicon é um exemplo marcante do uso de ARM em computadores pessoais.
• MIPS: amplamente usado em roteadores, consoles (PlayStation 1/2) e como base para o ensino de arquitetura de computadores.
• SPARC: usado em servidores Sun/Oracle. Implementa register windows — técnica que acelera chamadas de função sem salvar registradores na memória.
• RISC-V: arquitetura RISC aberta e livre de royalties. Cresceu fortemente em pesquisa, ensino, sistemas embarcados e vem avançando de forma acelerada também em aplicações comerciais.
• Intel x86 / AMD64: CISC clássico que domina desktops e servidores. Instruções de tamanho variável (1 a 15 bytes). Internamente usa µops RISC.

Métricas de desempenho

#

Comparar processadores exige cuidado — a métrica errada pode levar a conclusões enganosas.

MIPS — Millions of Instructions Per Second

#

onde \(f_{\text{clock}}\) é a frequência em Hz e \(CPI\) (Cycles Per Instruction) é o número médio de ciclos por instrução.

MFLOPS e SPECmark

#

• MFLOPS (Millions of Floating Point Operations Per Second): usado para cálculo científico, simulações, álgebra linear, deep learning. Conta operações de ponto flutuante, não instruções.

• SPECmark (Standard Performance Evaluation Corporation): benchmark padronizado e independente que executa um conjunto representativo de programas reais e compara com um sistema de referência. Supera as limitações do MIPS ao usar cargas de trabalho reais.

A taxonomia de Flynn

#

Durante décadas, a indústria entregou mais desempenho de duas formas: aumentando a frequência do relógio (megahertz para gigahertz) e otimizando o pipeline de um único núcleo. No entanto, essas abordagens bateram em um muro físico: o limite térmico. Como não é mais viável acelerar o clock de um único chip sem que ele derreta, a solução foi multiplicar o hardware.

Para entender e classificar as diversas formas de paralelismo, costuma-se usar a taxonomia de Flynn, proposta em 1966 por Michael Flynn. Ela continua sendo uma referência útil para classificar grande parte das arquiteturas paralelas, com base em dois eixos: o fluxo de instruções e o fluxo de dados.

%%{init: {'flowchart': {'useMaxWidth': false}}}%%
graph TD
    Flynn["Taxonomia de Flynn
(Classificação de Arquiteturas Paralelas)"]

    Flynn --> SISD["SISD
Single Instruction, Single Data
─────────────────
1 instrução, 1 dado por ciclo
Von Neumann clássico
Ex.: PC de 1 núcleo"]
    Flynn --> SIMD["SIMD
Single Instruction, Multiple Data
─────────────────
1 instrução → N dados simultâneos
Processamento vetorial / GPU
Ex.: Intel SSE/AVX, CUDA"]
    Flynn --> MISD["MISD
Multiple Instruction, Single Data
─────────────────
N instruções → 1 dado
Categoria rara e controversa
Ex.: poucos casos práticos convincentes"]
    Flynn --> MIMD["MIMD
Multiple Instruction, Multiple Data
─────────────────
N instruções + N dados
Paralelismo real e geral
Ex.: SMP, clusters, multicore"]

SMP: múltiplos processadores, uma memória

#

O SMP (Symmetric Multi-Processing) conecta vários processadores idênticos à mesma memória principal e ao mesmo sistema de E/S, gerenciados por um único sistema operacional:

+----+   +----+   +----+   +----+
|CPU1|   |CPU2|   |CPU3|   |CPU4|   <- Processadores idênticos
+-+--+   +-+--+   +-+--+   +-+--+
  |        |        |        |
  +--------+--------+--------+
               |
         Barramento compartilhado
               |
      +--------+-----------+
      |                    |
   +--+--+              +--+--+
   | RAM |              | E/S |
   +-----+              +-----+

Vantagens: múltiplas CPUs trabalhando em paralelo; falha de uma CPU não paralisa o sistema; crescimento incremental (adicionar CPUs conforme a demanda).

Problema crítico — Coerência de cache: cada CPU tem seus próprios caches (L1, L2). Se CPU1 modifica o valor de uma variável no seu cache, CPU2 pode estar lendo um valor desatualizado do seu cache. Protocolos de coerência como o MESI (Modified, Exclusive, Shared, Invalid) resolvem isso em hardware.

Clusters: memória distribuída, escala ilimitada

#

Um cluster é um grupo de computadores independentes (nós) conectados por uma rede de alta velocidade (Ethernet, InfiniBand), trabalhando de forma coordenada como um único sistema. Cada nó tem sua própria memória; a comunicação entre nós é feita por passagem de mensagens (MPI — Message Passing Interface).

NUMA: o meio-termo

#

O NUMA (Non-Uniform Memory Access) é uma arquitetura intermediária entre SMP e clusters:

• A memória é fisicamente distribuída entre os nós — cada processador tem RAM local.
• Logicamente, todo o espaço de endereçamento é unificado — qualquer CPU pode endereçar qualquer posição de memória.
• Acesso à RAM local: rápido.
• Acesso à RAM remota (de outro nó): mais lento — atravessa a interconexão entre nós.

Usado em servidores modernos de alto desempenho, o CC-NUMA combina memória fisicamente distribuída com um espaço de endereçamento logicamente unificado, preservando a coerência de cache por hardware.

Computação vetorial: SIMD em ação

#

A computação vetorial aplica a mesma operação repetidamente sobre grandes conjuntos de dados — arrays científicos, simulações, álgebra linear, redes neurais.

Dois caminhos de implementação:

A evolução histórica:

• Cray-1 (1976): primeiro supercomputador vetorial comercial de sucesso; 160 MFLOPS — impressionante para a época.
• Intel SSE / AVX: extensões SIMD do x86. AVX-512 processa 16 floats de 32 bits (ou 8 doubles de 64 bits) em uma única instrução.
• NVIDIA GPU: dezenas de milhares de núcleos CUDA operando em SIMD massivo — arquitetura SIMT (Single Instruction Multiple Threads).

Tendências modernas: multicore e many-core

#

Multicore

#

Vários núcleos de processamento completos integrados em um mesmo processador. Cada núcleo costuma ter caches L1 e L2 privados, enquanto níveis mais altos de cache podem ser compartilhados, dependendo da microarquitetura.

CPU 0          CPU 1          CPU 2          CPU 3
+------------+ +------------+ +------------+ +------------+
| L1-I  L1-D | | L1-I  L1-D | | L1-I  L1-D | | L1-I  L1-D |  (privado)
|    L2      | |    L2      | |    L2      | |    L2      |  (privado)
+-----+------+ +-----+------+ +-----+------+ +-----+------+
      |              |              |              |
      +--------------+--------------+--------------+
                              |
                     +--------+--------+
                     |    L3 (LLC)     |  (compartilhado)
                     +--------+--------+
                              |
                       Memória Principal

Exemplos: processadores Intel Core e AMD Ryzen em desktops e notebooks, além da linha Apple Silicon em Macs. Classificação: MIMD.

Many-core

#

Arquiteturas many-core reúnem dezenas, centenas ou milhares de unidades de execução simples no mesmo chip, otimizadas para paralelismo massivo.

Exemplos típicos são as GPUs modernas da NVIDIA e AMD. Em vez de focar em poucas unidades muito complexas, essas arquiteturas priorizam alta vazão para cargas massivamente paralelas. Classificação aproximada: SIMD / SIMT.

Onde cada arquitetura se encaixa

#

Conclusão

#

Chegamos ao fim da série. Partimos de uma célula de memória — um arranjo mínimo de armazenamento — e chegamos a processadores com múltiplos níveis de cache, pipelines, DMA, barramentos hierárquicos e arquiteturas paralelas em vários níveis. Cada artigo revelou uma camada diferente da mesma máquina que responde a um comando seu em frações de segundo.

O computador que você usa é uma obra de engenharia com sessenta anos de refinamento contínuo. Agora você sabe o que há por dentro.

Fique atento para as próximas séries de artigos do site. Até a próxima!