LPU vs GPU: o que a negação da Nvidia significa para devs

Quando li no Olhardigital.com.br que a Nvidia desmentiu o rumor de lançar uma LPU dedicada à China ainda em 2026, minha primeira reação não foi geopolítica — foi técnica. Quem trabalha com inferência de LLM sabe que a discussão GPU vs LPU virou o novo “Rust vs Go”: cada lado com argumentos válidos, benchmarks seletivos, e pouca gente explicando o que de fato muda no seu pipeline. Vou destrinchar o que está por trás desse movimento, o que significa para quem programa IA no dia a dia e por que o silêncio da Nvidia sobre a China importa mais do que parece.

O contexto real por trás do desmentido da Nvidia

A reportagem original do The Information, desmentida pela Nvidia, dizia que a empresa enviaria pequenos lotes de uma nova LPU (Language Processing Unit) à China até o final de 2026, baseada em tecnologia licenciada da Groq. Segundo a Nvidia, nenhum produto desse tipo existe no roadmap atual e não há vendas de LPUs em andamento no país.

Isso não significa que a tecnologia é fictícia — significa que o timing e o canal estavam errados. A Nvidia está, na prática, fazendo três coisas ao mesmo tempo:

• Cumprindo as restrições de exportação dos EUA (o sistema Vera Rubin já está bloqueado para a China);
• Mantendo o mercado chinês aquecido via produtos legais (como o H20, quando permitido);
• Avaliando internamente se vale a pena canibalizar sua própria linha de GPUs com uma LPU dedicada.

Jensen Huang já admitiu em maio que a Nvidia “em grande parte cedeu” o mercado chinês de chips de IA à Huawei. Isso é histórico: a empresa que ditou a corrida de hardware de IA está, pela primeira vez em uma década, aceitando perder uma fatia inteira de mercado.

LPU vs GPU: o que muda de verdade no seu código

Muita gente ainda confunde LPU com GPU mais fraca. Não é. A arquitetura é fundamentalmente diferente:

O ponto-chave para devs: LPUs exigem que o modelo seja compilado para o hardware antes da inferência. Não dá pra carregar um safetensors genérico e esperar que “rode”. O compilador Groq (ou o equivalente) faz um grafo estático do modelo e mapeia pesos em SRAM. Isso elimina overhead de runtime, mas limita flexibilidade.

GPUs convencionais são generalistas. LPUs são Purpose-Built Inference Machines. A diferença prática? Uma LPU bem configurada entrega latência p99 de poucos milissegundos em LLMs de 70B+ parâmetros — coisa que GPUs só conseguem com quantização agressiva e TensorRT-LLM bem afinado.

Na Prática: simulando o impacto de latência no seu pipeline

Mesmo que você não tenha uma LPU em mãos, dá pra simular o impacto de latência determinística no seu backend. Aqui vai um teste que rodei semana passada comparando diferentes estratégias de inferência com a API da OpenAI:

import asyncio
import time
import statistics
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def medir_latencia(prompt: str, runs: int = 50):
    latencias = []
    tokens_por_segundo = []

    for _ in range(runs):
        start = time.perf_counter()
        stream = await client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            stream=True,
            temperature=0.2
        )

        first_token_time = None
        total_tokens = 0
        async for chunk in stream:
            if chunk.choices[0].delta.content and first_token_time is None:
                first_token_time = time.perf_counter() - start
                latencias.append(first_token_time)
            if chunk.choices[0].delta.content:
                total_tokens += 1

        elapsed = time.perf_counter() - start
        if elapsed > 0:
            tokens_por_segundo.append(total_tokens / elapsed)

    return {
        "ttft_p50_ms": statistics.median(latencias) * 1000,
        "ttft_p99_ms": sorted(latencias)[int(len(latencias) * 0.99)] * 1000,
        "tps_medio": statistics.mean(tokens_por_segundo)
    }

async def main():
    prompts = [
        "Explique quantização int4 em LLMs",
        "Qual a diferença entre LoRA e QLoRA?",
        "Como funciona speculative decoding?"
    ]

    for p in prompts:
        resultado = await medir_latencia(p, runs=30)
        print(f"Prompt: {p[:40]}...")
        print(f"  TTFT p50: {resultado['ttft_p50_ms']:.1f}ms")
        print(f"  TTFT p99: {resultado['ttft_p99_ms']:.1f}ms")
        print(f"  TPS: {resultado['tps_medio']:.1f}\n")

asyncio.run(main())

Esse script mede três coisas que importam em produção:

1. TTFT (Time To First Token): latência até o primeiro caractere chegar. É isso que define se o usuário vê o chatbot como “responsivo”. LPUs brilham aqui.
2. p99: o pior caso dos piores. Em UX de chat, p99 define percepção de qualidade.
3. TPS (Tokens Per Second): throughput bruto, mais importante para batch jobs.

Quando rodamos isso contra uma API servida por GPU tradicional, o p99 oscila bastante dependendo do tráfego do vizinho de tenant. Em LPUs, a oscilação é mínima justamente porque o hardware tem latência determinística. Se você está construindo um chatbot para cliente enterprise, isso importa mais que o benchmark sintético que aparece no Twitter.

O tabuleiro geopolítico que pouca gente comenta

A Nvidia não quer canibalizar suas próprias GPUs. Uma LPU dedicada competindo com a linha Hopper/Blackwell internamente seria um problema comercial sério. Por isso a estratégia é clara: LPUs para mercados restritos (como a China), GPUs para o resto do mundo. É um movimento defensivo, não ofensivo.

Para devs, a consequência imediata é fragmentação de stack. Se você roda inferência na China, em 2026, suas opções são:

• Huawei Ascend: ecossistema CANN, divergente do CUDA. Código não portável sem refatoração.
• Nvidia H20 (quando liberado): CUDA nativo, mas com limitações de compute e interconnect.
• Groq-like via parceria: latência excelente, mas modelo de licenciamento ainda nebuloso.

Se você mantém um produto SaaS com presença global, prepare-se para manter duas bases de código de inferência. Já vejo isso acontecer com clientes que operam em regiões com restrições — e é uma dor que ninguém fala abertamente.

Erros comuns que devs cometem ao avaliar hardware de IA

Três armadilhas que vejo recorrentemente em revisões de arquitetura:

1. Confundir FLOPS com utilidade real

Um H100 SXM tem ~990 TFLOPS em FP16. Mas isso é peak. Em produção, com batching realista e overhead de scheduler, você usa 30-50% disso. LPUs não publicitam FLOPS porque o número seria ridículo comparado — elas vendem latência garantida, não throughput bruto.

2. Ignorar o custo total de memória

LPUs baseadas em SRAM têm capacidade limitada (centenas de GB no melhor caso). Modelos grandes precisam ser sharded ou quantizados agressivamente. Se seu pipeline depende de KV cache gigante para contexto longo, LPU pura não resolve — você acaba com um cluster de LPUs e a conta explode.

3. Subestimar o lock-in do compilador

Groq, Tenstorrent, Cerebras — todos têm compiladores proprietários. Migrar de um para outro não é “trocar backend”. É reescrever parte do grafo de inferência. CUDA venceu não por performance absoluta, mas por portabilidade de código. LPUs vão repetir o mesmo erro histórico a menos que abram o stack.

O que isso significa para quem está construindo produto agora

Se você está desenvolvendo um produto de IA em 2026, minha recomendação pragmática:

• Para inference de baixa latência em produção: avalie LPUs ou aceleradores dedicados (Groq, SambaNova, Cerebras). Faça POC real, não confie em benchmark de marketing.
• Para treinamento e fine-tuning: continue em GPUs CUDA. O ecossistema (PyTorch + FSDP + DeepSpeed) ainda não tem equivalente maduro fora do CUDA.
• Para presença multi-região: abstraia a inferência atrás de uma interface. Use vLLM ou TensorRT-LLM como camada intermediária — isso suaviza a transição quando o hardware mudar.
• Para contexto longo: otimize antes de trocar hardware. Speculative decoding, prompt caching e KV cache compression dão ganho de 3-10x sem trocar nada.

Perguntas frequentes (FAQ)

1. O que é exatamente uma LPU e por que ela é diferente de uma GPU?

LPU (Language Processing Unit) é um chip otimizado especificamente para inferência de modelos de linguagem. A diferença central está na memória: LPUs usam SRAM de baixa latência em vez de HBM, o que permite tempos de resposta determinísticos. GPUs são generalistas e ótimas para treinamento; LPUs são especializadas e ótimas para inferência de produção com SLA rígido.

2. A Nvidia realmente perdeu o mercado chinês para a Huawei?

Parcialmente. A declaração de Jensen Huang em maio de 2025 foi clara: a Nvidia “em grande parte cedeu” o mercado chinês de chips de IA. Restrições dos EUA impedem a venda de modelos topo de linha (Vera Rubin, Blackwell), enquanto a Huawei Ascend ocupa o espaço com produtos locais. Mas a Nvidia ainda vende produtos antigos e licenciados quando permitido.

3. Vale a pena migrar de GPU para LPU em um projeto pequeno?

Depende do SLA. Se seu produto precisa de p99 sub-100ms em inferência de LLM, LPU faz sentido. Se você roda batch jobs noturnos ou tem tolerância a latência variável, GPU tradicional com vLLM ou TensorRT-LLM entrega 90% do benefício com metade da complexidade operacional.

4. Por que a Nvidia negou o lançamento da LPU na China se o produto é viável?

Provavelmente por duas razões: evitar fricção regulatória extra com o Departamento de Comércio dos EUA, e não canibalizar a própria linha de GPUs no único mercado onde ainda atua plenamente. Negar publicamente não significa que o produto não exista internamente.

5. Como devs brasileiros podem se preparar para a fragmentação de hardware de IA?

Três ações concretas: (1) Aprenda CUDA — ainda é o padrão de fato; (2) Estude vLLM e TensorRT-LLM para abstrair o backend; (3) Faça ao menos um POC com um acelerador não-Nvidia (Groq oferece acesso gratuito limitado) para entender as diferenças arquiteturais na prática.

No fim das contas, a notícia da Nvidia negando a LPU chinesa é menos sobre o produto específico e mais sobre o novo normal: hardware de IA deixou de ser commoditie e virou tabuleiro geopolítico. Quem programa precisa parar de tratar GPU como sinônimo de inferência e começar a pensar em latência como feature de produto. É aí que o jogo muda de verdade.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.