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

Chegamos ao último artigo da série Por Dentro do Computador. Ao longo dos treze artigos anteriores, construímos uma compreensão completa de como um computador funciona por dentro: das portas lógicas à sua simplificação, 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:

O projeto de Berkeley não virou produto diretamente, mas foi a base de um: a SPARC, lançada pela Sun Microsystems em 1986–87, é descendente direta do RISC-II. É uma confusão comum atribuir a SPARC a Berkeley — a ideia veio de lá, o processador veio da Sun.

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"]

A figura abaixo organiza as quatro categorias no quadrante que dá sentido aos nomes: as linhas contam os fluxos de instruções, e as colunas, os fluxos de dados. Em cada casa, um fluxo único é uma linha só, que se ramifica até as unidades de processamento; vários fluxos são linhas separadas. A casa MISD aparece esmaecida pelo motivo da tabela: é rara e não tem exemplo consensual.

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. Na figura abaixo, cada CPU está no seu próprio chip, com o seu cache, e todas chegam à memória e à E/S pelo mesmo barramento. Os valores de x nos caches ilustram o problema de coerência discutido logo adiante.

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.

É o caso da figura acima: no cache da CPU 1, x já foi alterado para 7 e está no estado M; a cópia da CPU 2 ainda diz 5, e o MESI a marca I, inválida. A memória principal também guarda o valor antigo: por enquanto, a alteração existe só no cache da CPU 1.

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).

¹ O limite do SMP é contado em soquetes, isto é, em processadores físicos disputando a mesma memória — e aí ele é de fato baixo, porque o barramento compartilhado satura. Contando núcleos, o número muda de escala: um servidor atual de dois soquetes passa de 190 núcleos. É o mesmo SMP, com o paralelismo empacotado dentro de cada chip.

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.

A figura abaixo mostra esse arranjo no mesmo vocabulário visual da figura do SMP, e a diferença salta à vista: lá havia uma fronteira de chip em volta de cada CPU; aqui há uma só, em volta dos quatro núcleos e do L3 que eles dividem.

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

SMT: os núcleos que o gerenciador de tarefas mostra a mais

#

Abra o gerenciador de tarefas de um computador moderno e é provável que ele diga algo como “8 núcleos, 16 processadores lógicos”. A diferença é a multithreading simultânea (SMT) — que a Intel comercializa como Hyper-Threading.

A ideia parte de uma observação sobre desperdício: um núcleo passa boa parte do tempo esperando — por uma falta de cache, por um desvio mal previsto —, e durante essa espera o pipeline fica parado. Com SMT, o núcleo duplica os registradores que guardam o estado de uma thread (CI, registradores de propósito geral, flags) mas mantém uma única cópia do resto — UAL, caches, preditor de desvio. Dois fluxos de instrução passam a compartilhar o mesmo hardware de execução, e quando um espera, o outro avança.

O ganho é real mas modesto: tipicamente entre 15% e 30% em cargas que se beneficiam, e nenhum em cargas que já saturam o núcleo. Um núcleo com SMT não equivale a dois núcleos — equivale a um núcleo que desperdiça menos. É por isso que o sistema operacional, ao distribuir tarefas, prefere ocupar primeiro núcleos físicos distintos e só depois os processadores lógicos de um mesmo núcleo.

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

#

O limite de multiplicar núcleos: a Lei de Amdahl

#

Se a solução para o muro térmico foi multiplicar o hardware, fica a pergunta que este artigo levantou lá atrás e ainda não respondeu: até onde isso vai? Dobrar o número de núcleos dobra o desempenho?

A resposta foi dada em 1967 por Gene Amdahl, e é a fórmula mais importante sobre paralelismo. A ideia é que quase todo programa tem uma parte que não se paraleliza — ler a entrada, inicializar estruturas, combinar os resultados parciais, qualquer trecho em que um passo depende do anterior. Chamando de \(s\) a fração do tempo gasta nessa parte serial, o ganho máximo com \(N\) núcleos é dado pela Lei de Amdahl:

A parte paralela, \(1 - s\), é dividida por \(N\); a parte serial, \(s\), não é dividida por nada. E aí está o problema. Para um programa com apenas 10% de código serial (\(s = 0{,}1\)):

Com 8 núcleos, o programa não fica 8 vezes mais rápido: fica 4,7. E nenhuma quantidade de núcleos o leva além de 10×, porque quando \(N\) cresce sem limite o termo \((1-s)/N\) some e sobra \(S = 1/s\). Os 10% seriais, que pareciam pouco, viram o teto.

Conclusão

#

Chegamos ao fim da série. Partimos de portas lógicas e de uma célula de memória — os arranjos mínimos de cálculo e 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!