RISC vs CISC

Por que CISC existiu

Nas décadas de 1960 e 1970, a memória era extremamente cara. Um megabyte de RAM custava milhares de dólares. Nesse contexto, cada byte do programa era precioso, e os projetistas de processadores tinham uma motivação clara: fazer cada instrução fazer o máximo possível, para que o programa ocupasse menos memória.

Assim nasceu a filosofia CISC (Complex Instruction Set Computer). Processadores CISC oferecem centenas de instruções, muitas delas complexas — uma única instrução pode ler da memória, fazer uma operação aritmética, e gravar o resultado de volta na memória, tudo de uma vez. Os modos de endereçamento são abundantes: direto, indireto, indexado, com deslocamento, auto-incremento, e combinações desses.

O raciocínio era: se o compilador (ou o programador Assembly) consegue expressar uma operação inteira em uma instrução, o programa é menor, ocupa menos memória, e precisa de menos buscas na memória — exatamente o que se queria quando memória era o recurso escasso.

O exemplo mais emblemático de ISA CISC é o x86, da Intel. Lançado em 1978 com o 8086, o x86 acumulou instruções ao longo de quase 50 anos de compatibilidade retroativa. Hoje, o manual de instruções do x86-64 tem milhares de páginas.

Filosofia CISC — "faça muito por instrução"

  • Instruções de tamanho variável (1 a 15 bytes no x86)
  • Muitas instruções (centenas a milhares)
  • Instruções que acessam memória diretamente
    (ex: ADD [mem], reg — soma um valor da memória com um registrador)
  • Muitos modos de endereçamento (~12 no x86)
  • Poucos registradores de propósito geral (8 no x86 original)
  • Microcódigo interno: cada instrução complexa é decomposta
    em micro-operações simples pelo hardware
  • Compiladores mais simples (menos trabalho para gerar código)
  • Hardware mais complexo (decodificador é grande e difícil)

Por que RISC surgiu

No final dos anos 1970, dois grupos de pesquisa — um em Berkeley (liderado por David Patterson) e outro em Stanford (liderado por John Hennessy) — fizeram uma observação importante ao analisar como os programas reais usavam processadores CISC:

A maioria das instruções complexas quase nunca era usada. Os compiladores geravam código que usava um subconjunto pequeno e simples do conjunto de instruções. As instruções "poderosas" do CISC raramente apareciam no código gerado — o compilador preferia sequências de instruções simples que ele entendia e otimizava melhor.

Além disso, o hardware necessário para suportar instruções complexas (o decodificador de microcódigo) ocupava uma fração enorme do chip — área que poderia ser usada para cache, mais registradores, ou pipeline mais profundo.

A conclusão: simplifique as instruções, simplifique o hardware, e use o silício liberado para coisas que realmente melhoram performance. Assim nasceu o RISC (Reduced Instruction Set Computer).

Filosofia RISC — "faça pouco por instrução, mas faça rápido"

  • Instruções de tamanho fixo (4 bytes em MIPS, ARM, RISC-V)
  • Poucas instruções (tipicamente 50-150)
  • Arquitetura load/store: APENAS instruções load e store
    acessam memória; todas as outras operam sobre registradores
  • Poucos modos de endereçamento (2-4)
  • Muitos registradores de propósito geral (32 em MIPS e RISC-V)
  • Sem microcódigo: cada instrução executa diretamente no hardware
  • Pipeline eficiente: formato fixo facilita decodificação
  • Compilador mais complexo (precisa otimizar melhor)
  • Hardware mais simples (mais espaço para cache e registradores)

Tabela comparativa

Característica           CISC (ex: x86)              RISC (ex: ARM, MIPS, RISC-V)
───────────────────────  ──────────────────────────  ────────────────────────────────
Tamanho da instrução     Variável (1-15 bytes)       Fixo (4 bytes)
Número de instruções     Centenas a milhares         50-150
Acesso à memória         Qualquer instrução          Apenas load/store
Modos de endereçamento   Muitos (~12)                Poucos (2-4)
Registradores            Poucos (8-16 gerais)        Muitos (32 gerais)
Decodificação            Complexa (microcódigo)      Simples (hardware direto)
Pipeline                 Difícil de implementar      Natural e eficiente
Código gerado            Menor (menos instruções)    Maior (mais instruções)
Complexidade             No hardware                 No compilador
Consumo de energia       Maior                       Menor
Ciclos por instrução     Variável (1-20+)            ~1 (ideal)

Exemplos reais:
  CISC: Intel x86/x86-64, Motorola 68000, VAX
  RISC: ARM (ARMv7, ARMv8/AArch64), MIPS, RISC-V, SPARC, PowerPC

A mesma operação em x86 e MIPS

Para tornar a diferença concreta, vejamos como a operação a = b + c (onde todas as variáveis estão na memória) é expressa em cada filosofia:

# x86: pode operar diretamente com memória
# a = b + c (a, b, c são endereços de memória)

mov  eax, [b]       # carrega b no registrador eax
add  eax, [c]       # soma c (da memória!) ao eax   ← memória + registrador
mov  [a], eax       # grava resultado em a

# Total: 3 instruções
# Nota: a instrução ADD acessa memória diretamente —
# isso é típico de CISC

# MIPS: somente load/store acessam memória
# a = b + c (a, b, c são endereços de memória)

lw   $t0, b($zero)   # load: carrega b da memória para $t0
lw   $t1, c($zero)   # load: carrega c da memória para $t1
add  $t2, $t0, $t1   # soma: $t2 = $t0 + $t1 (apenas registradores!)
sw   $t2, a($zero)   # store: grava $t2 na memória em a

# Total: 4 instruções
# Nota: a instrução ADD opera SOMENTE com registradores —
# load/store são as únicas que tocam memória

O código RISC tem mais instruções, mas cada instrução é simples, tem tamanho fixo, e executa em um ciclo. O código CISC tem menos instruções, mas a instrução ADD eax, [c] precisa internamente fazer um acesso à memória e uma soma — ela é "macro" por fora mas decompostas em micro-operações por dentro.

O cenário atual: ARM, RISC-V, e o mundo real

A história de RISC vs CISC não terminou com um "vencedor" claro. Em vez disso, cada filosofia dominou mercados diferentes:

ARM — a ISA RISC mais bem-sucedida comercialmente. Projetada pela Acorn Computers em 1985, hoje está em praticamente todos os smartphones, tablets, e dispositivos embarcados do planeta. O segredo do ARM foi a eficiência energética: fazer mais com menos energia. Em 2020, a Apple demonstrou que ARM compete diretamente com x86 em desempenho de desktop/laptop com o chip M1 — que superou processadores Intel em muitos benchmarks enquanto consumia uma fração da energia.

RISC-V — a ISA de código aberto. Criada em 2010 em Berkeley (por uma equipe que incluía David Patterson), o RISC-V é uma ISA livre de royalties que qualquer empresa pode implementar sem pagar licença. Isso é revolucionário: ARM cobra licenciamento, x86 é proprietário da Intel/AMD. RISC-V está crescendo rapidamente em embarcados, IoT, aceleradores de IA, e processadores de uso geral. A China, em particular, está investindo pesadamente em RISC-V para reduzir dependência de tecnologias americanas.

x86-64 — continua dominando servidores e desktops por inércia e compatibilidade. Décadas de software compilado para x86 criam um efeito de rede difícil de romper. Mas o domínio está sendo desafiado: a AWS usa processadores ARM (Graviton) em seus servidores, e o Apple Silicon mostrou que a transição é viável.

Segmento              ISA dominante      Por quê
────────────────────  ─────────────────  ──────────────────────────────
Smartphones           ARM (99%+)         Eficiência energética
Tablets               ARM (99%+)         Eficiência energética
Embarcados / IoT      ARM + RISC-V       Custo baixo, baixo consumo
Laptops               x86 (~80%)         Compatibilidade de software
                      ARM (~20%)         Apple Silicon, Snapdragon X
Desktops              x86 (~90%)         Compatibilidade, gaming
Servidores             x86 (~85%)         Legado, ecossistema
                      ARM (~15%)         AWS Graviton, Ampere
Supercomputadores     ARM + x86          Fugaku (ARM), outros (x86)
Aceleradores IA       ISAs customizadas  Google TPU, NVIDIA GPU (PTX)

A lição de design

RISC vs CISC é, no fundo, uma decisão sobre onde colocar a complexidade:

• CISC: a complexidade está no hardware. O processador faz muito trabalho por instrução, o que simplifica o software (compilador e código gerado). Mas o hardware fica grande, quente, e difícil de otimizar.
• RISC: a complexidade está no software. O processador é simples e rápido, mas o compilador precisa ser mais inteligente para gerar código eficiente com instruções simples. O hardware fica menor, mais frio, e mais fácil de pipeline.

Essa é uma decisão de design universal, não exclusiva de hardware. Em software, a mesma pergunta aparece: você cria uma API com poucos endpoints simples (estilo RISC) que o cliente compõe, ou uma API com endpoints complexos (estilo CISC) que resolvem tudo em uma chamada?

A resposta que a história deu: simplicidade no núcleo, complexidade na borda. Mantenha o componente central simples e rápido; deixe a inteligência para as camadas externas (compilador, software, orquestrador) que são mais fáceis e baratas de atualizar.

No harness.os

RISC vs CISC é uma decisão de design sobre complexidade — fazer poucas coisas bem feitas (RISC) versus muitas coisas num só passo (CISC). No harness.os, preferimos workflows RISC: cada passo faz uma coisa, compostos em pipelines.

Abordagem CISC (tool complexo):
  do_everything(
    project="college-online",
    action="create_lesson",
    module=1,
    lesson=3,
    content="...",
    quiz="...",
    log_decision=true,
    publish=true
  )
  → Uma chamada faz tudo. Difícil de debugar, difícil de recompor.

Abordagem RISC (tools simples, compostos):
  start_session("college-online")      # fetch: carregar contexto
  get_workflow("create-lesson")        # decode: entender o processo
  log_decision("RISC vs CISC", ...)    # execute: registrar decisão
  log_learning("design patterns", ...) # execute: registrar aprendizado
  end_session(summary, next_steps)     # write-back: gravar resultado

  → Cada tool faz UMA coisa. Fáceis de debugar, recompor, substituir.

O harness.os escolheu RISC: tools atômicos, compostos pelo agente.
O agente é o "compilador" que decide a sequência de operações.

A analogia se estende ao design de MCP tools em geral. Um tool log_decision(title, rationale) é RISC — faz uma coisa, recebe parâmetros claros, retorna resultado previsível. Um tool hipotético do_work(task_description) seria CISC — faz coisas demais, difícil de prever o comportamento, difícil de testar. Assim como processadores RISC modernos são mais eficientes, tools RISC são mais confiáveis e componíveis.

Homework

1. Pesquise o processador ARM que está no seu celular (ex: Snapdragon 8 Gen 3, Apple A17 Pro, Dimensity 9300). Qual é a ISA exata (ARMv8? ARMv9?)? Quantos registradores de propósito geral a ISA define? Compare com o x86-64 do seu computador.
2. Escreva a operação d = (a + b) * c em Assembly MIPS (estilo RISC, load/store) e em pseudoassembly x86 (estilo CISC, acesso direto à memória). Quantas instruções cada versão precisa? Qual ocupa mais bytes na memória?
3. O RISC-V é uma ISA aberta e gratuita. Pesquise: quais empresas já produzem processadores RISC-V? Para quais aplicações eles estão sendo usados? Por que empresas chinesas estão particularmente interessadas em RISC-V?
4. No harness.os, analise 3 MCP tools que você usa frequentemente. Classifique cada um como "RISC" (faz uma coisa) ou "CISC" (faz várias coisas). Se algum for CISC, proponha como decompô-lo em tools RISC menores.
5. Releia o princípio "simplicidade no núcleo, complexidade na borda". Identifique outro exemplo (fora de hardware) onde esse princípio é aplicado — pode ser em software, em organização empresarial, ou em qualquer sistema.

Resumo

• CISC surgiu quando memória era cara: instruções complexas para código compacto. Exemplo: x86
• RISC surgiu da observação de Patterson e Hennessy: instruções complexas raramente eram usadas; simplificar o hardware libera silício para cache e pipeline
• RISC é load/store: apenas instruções de carga e armazenamento acessam memória; tudo o mais opera em registradores
• CISC permite acesso direto à memória em qualquer instrução, com muitos modos de endereçamento
• Processadores x86 modernos são CISC por fora, RISC por dentro: traduzem instruções complexas em micro-operações simples
• ARM domina mobile (eficiência energética); RISC-V é a ISA aberta que cresce em embarcados e aceleradores; x86 domina desktop/servidor por compatibilidade
• A lição de design: simplicidade no núcleo, complexidade na borda — válida para hardware, software, e sistemas em geral