Inteligência Artificial e Infraestrutura

Arquitetura de Computação para IA e GPUs: CUDA, Tensor Cores, VRAM e Paralelismo em Servidores

Guia técnico avançado de arquitetura de hardware para Inteligência Artificial: as diferenças fundamentais entre CPU e GPU SIMT, o funcionamento interno dos Tensor Cores na aceleração de operações GEMM, a hierarquia de memória SRAM versus HBM3e, barramentos PCIe 5.0 e NVLink, formatos de precisão numérica (FP32, BF16, FP8 e INT4) e estratégias de paralelismo distribuído (DDP, Pipeline e Tensor Parallelism).

Nos últimos anos, a evolução da Inteligência Artificial deixou de ser uma discussão puramente algorítmica para se consolidar como uma disciplina rigorosa de engenharia de sistemas e arquitetura de computadores. O treinamento e a inferência de modelos fundacionais modernos — como os Grandes Modelos de Linguagem (LLMs), modelos de difusão visual e arquiteturas multimodais — demandam trilhões de operações de ponto flutuante por segundo. Para qualquer engenheiro de software, arquiteto de dados ou líder de tecnologia, compreender o que acontece na camada física de silício não é mais opcional: é o divisor de águas entre infraestruturas viáveis e servidores inviabilizados por gargalos de latência e consumo descontrolado de energia.

Neste guia aprofundado, exploramos os fundamentos da computação de alto desempenho voltada à IA: da transição entre os modelos de Von Neumann e o paralelismo massivo SIMT, passando pelo funcionamento dos Tensor Cores, a física da memória HBM versus SRAM, e as estratégias de paralelismo distribuído que sustentam os maiores clusters do mundo em 2026.

---

1. Do Paradigma de Von Neumann ao Paralelismo Massivo (SIMT)

A computação tradicional de uso geral é historicamente ancorada na arquitetura de Von Neumann. Nesse modelo, a Unidade Central de Processamento (CPU) busca instruções sequenciais da memória, decodifica essas instruções e as executa em uma cadeia otimizada para minimizar a latência de ponta a ponta. Para que um único thread de execução seja concluído no menor tempo possível, as CPUs modernas dedicam a maior parte de sua área de silício a estruturas auxiliares complexas:

  • Preditores de Desvio (Branch Predictors): Circuitos neurais internos que tentam adivinhar o resultado de condicionais (`if/else`) antes que elas sejam calculadas;
  • Execução Fora de Ordem (Out-of-Order Execution Engines): Mecanismos que reorganizam as instruções para manter as Unidades Lógico-Aritméticas (ALUs) ocupadas;
  • Hierarquias Profundas de Memória Cache (L1, L2 e L3): Bancos de SRAM ultrarrápidos que tentam esconder o custo de latência de acesso à memória RAM principal.

Essa arquitetura é ideal para tarefas sequenciais heterogêneas — como sistemas operacionais, servidores web e bancos de dados transacionais. No entanto, as redes neurais artificiais possuem uma natureza matemática completamente diferente: elas operam através de álgebra linear densa, especificamente a multiplicação de matrizes por vetores ($y = Wx + b$) e a multiplicação de matrizes por matrizes (GEMM — General Matrix Multiply).

Nesse contexto, o que importa não é quão rápido uma única instrução individual é executada, mas quantas milhões de operações aritméticas idênticas podem ser processadas simultaneamente no mesmo ciclo de clock. É aqui que entra a arquitetura SIMT (Single Instruction, Multiple Threads), popularizada pela NVIDIA com o modelo de programação CUDA.

       ARQUITETURA CPU (Latência)                ARQUITETURA GPU (Throughput)
┌───────────────────────────────────────┐    ┌───────────────────────────────────┐
│  Controle   │   ALU   │     ALU       │    │ Ctr │ Ctr │ Ctr │ Ctr │ Ctr │ Ctr │
├───────────────────────────────────────┤    ├───────────────────────────────────┤
│          Cache L1 / L2                │    │ ███ │ ███ │ ███ │ ███ │ ███ │ ███ │
├───────────────────────────────────────┤    │ ███ │ ███ │ ███ │ ███ │ ███ │ ███ │
│                                       │    │ Milhares de ALUs Compactas (CUDA) │
│               Cache L3                │    │ ███ │ ███ │ ███ │ ███ │ ███ │ ███ │
│                                       │    ├───────────────────────────────────┤
├───────────────────────────────────────┤    │          Shared Memory / L1       │
│              Memória DRAM             │    ├───────────────────────────────────┤
│          (Canal Duplo / DDR5)         │    │       Memória HBM3e / VRAM        │
└───────────────────────────────────────┘    └───────────────────────────────────┘

Em uma GPU moderna, o espaço de silício é massivamente dedicado a ALUs compactas organizadas em blocos chamados Streaming Multiprocessors (SMs). Em vez de prever desvios para um thread, a GPU agrupa 32 threads em uma unidade lógica chamada Warp. Todas as threads de um Warp executam exatamente a mesma instrução matemática ao mesmo tempo, mas sobre posições de memória distintas. Se o acesso à memória de um Warp atrasar, o agendador de hardware da GPU troca instantaneamente o contexto para outro Warp pronto em zero ciclos, mascarando a latência pela pura abundância de paralelismo.

---

2. A Anatomia dos Tensor Cores e a Matemática do GEMM

Até a geração Pascal (2016), as GPUs utilizavam núcleos CUDA convencionais escalares para realizar cálculos de IA. Cada núcleo processava uma operação aritmética por ciclo de clock (por exemplo, multiplicar dois números de ponto flutuante e somar o resultado a um acumulador — uma instrução MAD/FMA escalar). Para multiplicar duas matrizes densas de dimensão $N \times N$, a complexidade de tempo exigia $O(N^3)$ operações individuais.

A introdução dos Tensor Cores a partir da arquitetura Volta e seu refinamento nas gerações Ampere, Hopper e Blackwell revolucionaram esse fluxo. Um Tensor Core não opera sobre números individuais; ele é uma unidade matricial de hardware projetada para calcular diretamente a operação:

$D = A \cdot B + C$

Onde $A$, $B$, $C$ e $D$ são pequenas submatrizes (tipicamente de dimensões $4 \times 4$, $8 \times 8$ ou $16 \times 16$). Em vez de emitir dezenas de instruções individuais para carregar registradores, calcular produtos escalares e acumular somas parciais, o compilador CUDA emite uma única instrução de nível de montador (WMMA — Warp Matrix Multiply and Accumulate ou MMA assíncrono).

# Exemplo conceitual da operação realizada internamente em hardware por um Tensor Core
# Multiplicação e Acumulação Matricial 4x4 em 1 ciclo de clock
import torch

def tensor_core_fma_concept(A: torch.Tensor, B: torch.Tensor, C: torch.Tensor) -> torch.Tensor:
    # A: matriz de entrada [4, 4] em meia precisão (FP16/BF16)
    # B: matriz de pesos [4, 4] em meia precisão (FP16/BF16)
    # C: matriz acumuladora [4, 4] em precisão total (FP32)
    assert A.shape == (4, 4) and B.shape == (4, 4) and C.shape == (4, 4)
    
    # Realiza a multiplicação em hardware e acumula sem perda de precisão intermediária
    D = torch.matmul(A, B) + C
    return D

Essa abordagem traz três vantagens cruciais:

1. Redução Drástica do Tráfego de Instruções: Uma única instrução comanda centenas de multiplicações simultâneas em paralelo físico no silício.

2. Reaproveitamento de Registradores: Os elementos das matrizes $A$ e $B$ são mantidos nos registradores internos do SM e multiplicados cruzadamente sem necessidade de trafegar de volta pela memória cache.

3. Precisão Mista (Mixed Precision): As entradas podem ser representadas em formatos menores (como BF16 ou FP8), economizando banda de transmissão, enquanto a acumulação intermediária é realizada em FP32 para manter a estabilidade numérica dos gradientes e evitar divergências de treinamento.

---

3. Hierarquia de Memória: A Batalha entre SRAM e HBM3e

Na engenharia de aceleradores de Inteligência Artificial, existe um princípio amplamente aceito: FLOPs de computação são baratos; movimentar dados é extremamente caro.

A energia necessária para transportar um valor de 32 bits da memória DRAM externa através dos barramentos da placa de circuito até os registradores do processador consome até 100 vezes mais energia do que a própria operação aritmética de multiplicá-lo. Além disso, a velocidade com que as ALUs conseguem processar dados há muito tempo superou a taxa de transferência dos barramentos de memória — fenômeno conhecido na ciência da computação como a Memory Wall (Muralha da Memória).

Para solucionar esse estrangulamento, a arquitetura de uma GPU corporativa moderna adota uma hierarquia estrita de armazenamento:

| Nível de Memória | Tecnologia | Capacidade Típica | Largura de Banda Típica | Latência |

| :--- | :--- | :--- | :--- | :--- |

| Registradores do SM | Flip-Flops no Die | ~256 KB por SM | > 20.000 GB/s (agregada) | 1 ciclo |

| Shared Memory / Cache L1 | SRAM interna | ~128 KB a 228 KB / SM | > 12.000 GB/s (agregada) | ~20 a 30 ciclos |

| Cache L2 Unificado | SRAM no Die | 50 MB a 96 MB | ~4.000 a 7.000 GB/s | ~100 a 150 ciclos |

| VRAM Externa Principal | HBM3e (High Bandwidth) | 80 GB a 192 GB | 3.350 a 8.000 GB/s | ~400 ciclos |

| Memória RAM da CPU | DDR5 / LPDDR5 | 512 GB a 2 TB | 300 a 600 GB/s | > 800 ciclos |

| Armazenamento Secundário | NVMe PCIe Gen5 SSD | Vários Terabytes | 14 GB/s por drive | Milhares de ciclos |

A tecnologia HBM3e (High Bandwidth Memory) difere radicalmente das memórias convencionais GDDR6 utilizadas em placas gráficas de consumo. Em vez de soldar chips de memória ao redor da GPU conectados por trilhas longas na placa-mãe, múltiplos dies de memória DRAM são empilhados verticalmente em 3D e conectados por milhares de microvias microscópicas de silício (TSVs — Through-Silicon Vias).

Esse bloco empilhado fica montado sobre um substrato intermediário de silício de altíssima densidade (Silicon Interposer) colado diretamente ao lado do die da GPU. Essa proximidade física microscópica permite barramentos de dados com mais de 4.096 bits de largura, entregando taxas de transferência que superam 3 Terabytes por segundo por acelerador.

---

4. Precisão Numérica: Do FP32 ao FP8 e Quantização em Silício

Durante décadas, o padrão ouro do cálculo científico foi o ponto flutuante de precisão simples (FP32), padronizado pelo IEEE 754. O FP32 divide seus 32 bits em:

  • 1 bit de sinal ($s$);
  • 8 bits de expoente ($e$), determinando o alcance dinâmico (de $\approx 10^{-38}$ a $10^{38}$);
  • 23 bits de mantissa/fração ($m$), garantindo cerca de 7 dígitos decimais de precisão.

Porém, os pesquisadores de Deep Learning descobriram uma propriedade fascinante das redes neurais: elas são inerentemente tolerantes a ruído numérico. Os pesos de uma rede neural funcionam como filtros estatísticos; perder a precisão do sexto dígito decimal não impede que o modelo identifique um objeto ou gere a próxima palavra correta em um texto.

Essa constatação permitiu a introdução de novos formatos numéricos:

FP32:  [s][  expoente (8 bits)  ][         mantissa / fração (23 bits)         ] (32 bits)
TF32:  [s][  expoente (8 bits)  ][   mantissa (10 bits)   ] (19 bits internos em Tensor Cores)
BF16:  [s][  expoente (8 bits)  ][ mantissa (7) ] (16 bits - padrão ouro para treinamento)
FP16:  [s][ expoente (5) ][    mantissa (10 bits)   ] (16 bits - risco de underflow em gradientes)
FP8:   [s][ expoente (4/5) ][ mantissa (3/2) ] (8 bits - inferência e treinamento de ponta)

1. Bfloat16 (Brain Floating Point): Desenvolvido pelo Google Brain, o BF16 sacrifica a mantissa (apenas 7 bits, o mesmo que 2 dígitos decimais de precisão), mas preserva rigorosamente os 8 bits de expoente do FP32. Isso significa que ele cobre o exato mesmo alcance dinâmico de grandezas, eliminando o risco de underflow (quando um gradiente se torna tão pequeno que vira zero) e de overflow (quando um valor explode para infinito), sem exigir escalonamento dinâmico de perda (loss scaling).

2. FP8 (8-bit Floating Point): Introduzido nativamente nas arquiteturas mais recentes, o FP8 adota duas especificações complementares (E4M3 e E5M2). O formato E4M3 (4 bits de expoente e 3 de mantissa) oferece maior precisão numérica e é ideal para as ativações e pesos no passe direto (forward pass). O formato E5M2 (5 bits de expoente e 2 de mantissa) espelha a dinâmica do FP16 e é utilizado para representar gradientes no passe reverso (backward pass).

3. Economia em Cascata: Ao migrar um modelo de 70 bilhões de parâmetros de FP16 (que consome 140 GB de VRAM apenas para armazenar os pesos brutos) para FP8 quantizado, o consumo de memória despenca para 70 GB, permitindo que a inferência seja executada inteiramente dentro de uma única GPU H100 ou em nós menores, dobrando o rendimento (tokens por segundo) e reduzindo pela metade o custo operacional de nuvem.

---

5. Barramentos e Topologias de Rede: PCIe 5.0 vs NVLink e InfiniBand

Quando um modelo de Inteligência Artificial ultrapassa o tamanho da memória de uma única GPU, os aceleradores precisam trabalhar em conjunto como uma máquina distribuída massiva. Nesse momento, o barramento de comunicação entre as placas passa a ser o fator limitante do sistema.

O barramento tradicional da indústria é o PCIe (Peripheral Component Interconnect Express). Na especificação PCIe 5.0 x16, a largura de banda máxima teórica é de 64 GB/s em cada direção (128 GB/s agregado). Embora seja veloz para transferências de dados comuns, em um cluster de IA esse canal é insuficiente:

  • Se quatro GPUs precisarem sincronizar 40 Gigabytes de gradientes a cada fração de segundo durante o passo de otimização, o barramento PCIe satura, deixando as ALUs de silício ociosas esperando o término da transmissão dos dados (GPU Starvation).
  • O tráfego PCIe tradicionalmente precisa passar pelos controladores da CPU e pela memória RAM central do servidor, introduzindo saltos adicionais e aumento de latência.

Para contornar essa barreira, foram criadas as tecnologias de comunicação direta:

        COMUNICAÇÃO CONVENCIONAL PCIe                 COMUNICAÇÃO DIRETA NVLink MESH
┌─────────────────────────────────────────┐     ┌─────────────────────────────────────────┐
│              CPU do Sistema             │     │              CPU do Sistema             │
│        (Controlador de Memória)         │     │         (Apenas Orquestração)           │
└───────────────┬─────────────────────────┘     └─────────────────────────────────────────┘
                │ Barramento PCIe                                       │
     ┌──────────┴──────────┐                                            │
     │                     │                    ┌───────┐  NVLink  ┌───────┐  NVLink  ┌───────┐
┌────┴────┐           ┌────┴────┐               │ GPU 0 │◄════════►│ GPU 1 │◄════════►│ GPU 2 │
│  GPU 0  │           │  GPU 1  │               └───┬───┘          └───┬───┘          └───┬───┘
└─────────┘           └─────────┘                   │      NVLink MESH │                  │
(Tráfego passa pela CPU e gera gargalo)             └══════════════════╩══════════════════┘
                                                (Transmissão Direta com até 900 GB/s - 1.8 TB/s)

1. NVLink e NVSwitch: O NVLink conecta as GPUs diretamente através de links ponto a ponto de alta velocidade, contornando a CPU. Na geração atual, a malha NVSwitch conecta até 8 GPUs em um mesmo nó com uma largura de banda agregada bidirecional de 900 GB/s por placa (ou até 1.8 TB/s na arquitetura Blackwell). Cada GPU consegue ler e escrever diretamente na VRAM de qualquer outra GPU do nó com acesso direto à memória remota (GPUDirect RDMA).

2. InfiniBand e RoCE (RDMA over Converged Ethernet): Para a comunicação entre servidores diferentes dentro do datacenter (Scale-Out), conexões Ethernet comuns de 10 Gbps ou 100 Gbps são inadequadas devido ao overhead do protocolo TCP/IP e à perda de pacotes. Os supercomputadores de IA utilizam redes InfiniBand Quantum-2 operando a 400 Gbps ou 800 Gbps por porta com suporte nativo a RDMA, permitindo que a VRAM de um servidor transfira tensores diretamente para a VRAM de outro servidor do outro lado do datacenter sem envolver a CPU ou copiar dados para o sistema operacional.

---

6. Estratégias de Paralelismo Distribuído: DDP, Pipeline e Tensor Parallelism

Como os maiores modelos de linguagem contemporâneos variam de 70 bilhões a mais de 1 trilhão de parâmetros (como as arquiteturas Mixture-of-Experts), é impossível alocar os pesos, ativações, gradientes e estados do otimizador em um único dispositivo. A comunidade de computação de alta performance desenvolveu três estratégias ortogonais de paralelismo que podem ser combinadas:

1. Paralelismo de Dados Distribuído (DDP — Distributed Data Parallel)

No DDP, o modelo completo é replicado identicamente em cada GPU do cluster. O conjunto total de dados de treinamento (dataset) é dividido em fatias menores (batches locais), e cada placa processa um lote independente calculando suas próprias perdas e gradientes. No final do passe reverso, uma operação coletiva de rede chamada All-Reduce calcula a média dos gradientes de todas as placas e atualiza os pesos sincronizadamente.

  • Limitação: O modelo inteiro precisa caber na memória de uma única GPU.

2. Paralelismo de Tensores (TP — Tensor Parallelism / Megatron-LM)

Quando uma única camada de atenção ou projeção linear não cabe na VRAM, as matrizes de pesos são divididas matematicamente entre múltiplas GPUs no mesmo nó. Em uma multiplicação de matrizes $Y = XW$, a matriz $W$ pode ser fatiada por colunas ($W = [W_1 | W_2]$), permitindo que duas GPUs calculem suas frações do resultado em paralelo e combinem os vetores resultantes via comunicação rápida NVLink.

  • Requisito: Exige latência ultrabaixa e barramento massivo, sendo restrito a GPUs conectadas por NVLink dentro do mesmo chassi físico.

3. Paralelismo de Pipeline (PP — Pipeline Parallelism)

Nesta abordagem, as camadas consecutivas da rede neural são particionadas horizontalmente entre diferentes servidores. Por exemplo, em um modelo de 80 camadas:

  • As camadas 1 a 20 ficam no Servidor A;
  • As camadas 21 a 40 ficam no Servidor B;
  • As camadas 41 a 60 ficam no Servidor C;
  • As camadas 61 a 80 ficam no Servidor D.

Para evitar que os servidores fiquem ociosos esperando que o anterior termine seu cálculo (o chamado pipeline bubble), as entradas são divididas em micro-batches processados continuamente de forma escalonada, como uma linha de montagem industrial.

---

Conclusão e Perspectivas para a Engenharia de IA

A computação para Inteligência Artificial atingiu um patamar de maturidade onde o software e o silício são co-projetados em simbiose total. Os algoritmos modernos — como o FlashAttention, que reorganiza a computação da atenção matricial para caber nos blocos de SRAM rápida e minimizar acessos à HBM3e — mostram que os maiores ganhos de desempenho hoje não vêm de simplesmente adicionar mais transistores, mas de desenhar código que respeite a física da memória e a hierarquia de barramentos do hardware.

Para os engenheiros e arquitetos de sistemas, dominar esses princípios é a garantia de projetar pipelines de dados, servidores de inferência e sistemas autônomos que operem com máxima eficiência energética, mínima latência e custo computacional sustentável.

---

Fonte de Referência Educativa: Conteúdo técnico estruturado a partir da Formação Kaisen AI University (Apostilas Oficiais de Fundamentos de IA, Engenharia de Modelos e Agentes Autônomos).*