CUDA

CUDA
Autores	Ian Buck John Nickolls
Desenvolvedor	Nvidia
Lançamento estável	13.4.1 / 9 setembro 2026}
Escrito em	C
Sistema operacional	Windows, Linux
Plataforma	GPUs suportadas
Tipo	GPGPU
Licença	Proprietária
Website	developer.nvidia.com/cuda-zone

CUDA (Compute Unified Device Architecture) é uma plataforma de computação paralela proprietária e interface de programação de aplicações (API) desenvolvida pela empresa de tecnologia americana Nvidia que permite que software utilize certos tipos de unidades de processamento gráfico (GPUs) para processamento de propósito geral acelerado, ampliando significativamente sua utilidade em computação científica e de alto desempenho. A CUDA foi criada pela Nvidia a partir de 2004 e foi oficialmente lançada em 2007. Quando foi introduzida pela primeira vez, o nome era um acrônimo para Compute Unified Device Architecture, mas a Nvidia posteriormente abandonou o uso comum do acrônimo e raramente o expande atualmente.

CUDA é tanto uma camada de software que gerencia dados, dando acesso direto à GPU e CPU conforme necessário, quanto uma biblioteca de APIs que permitem computação paralela para várias necessidades. Além de drivers e kernels de tempo de execução, a plataforma CUDA inclui compiladores, bibliotecas e ferramentas de desenvolvedor para ajudar programadores a acelerar suas aplicações.

CUDA é escrita na linguagem de programação C, mas é projetada para funcionar com uma ampla gama de outras linguagens de programação, incluindo C++, Fortran, Python e Julia. Essa acessibilidade torna mais fácil para especialistas em programação paralela usar recursos de GPU, em contraste com APIs anteriores como Direct3D e OpenGL, que exigem habilidades avançadas em programação gráfica. GPUs com CUDA também suportam frameworks de programação como OpenMP, OpenACC e OpenCL.

Antecedentes

A unidade de processamento gráfico (GPU), como um processador de computador especializado, atende às demandas de tarefas intensivas de computação de gráficos 3D de alta resolução em tempo real. Em 2012, as GPUs evoluíram para sistemas multi-core altamente paralelos permitindo a manipulação eficiente de grandes blocos de dados. Este design é mais eficaz do que unidades centrais de processamento (CPUs) de propósito geral para algoritmos em situações onde o processamento de grandes blocos de dados é feito em paralelo, como:

• funções hash criptográficas
• aprendizado de máquina
• simulações de dinâmica molecular
• motores de física

As origens da CUDA remontam ao início dos anos 2000, quando Ian Buck, um estudante de doutorado em ciência da computação na Universidade Stanford, começou a experimentar o uso de GPUs para fins além da renderização de gráficos. Buck tornou-se interessado em GPUs durante seus estudos de graduação na Universidade de Princeton, inicialmente através de jogos eletrônicos. Após a formatura, ele estagiou na Nvidia, ganhando maior exposição à arquitetura de GPU. Em Stanford, ele construiu um equipamento de jogos 8K usando 32 placas gráficas GeForce, originalmente para testar os limites do desempenho gráfico em jogos como Quake e Doom. No entanto, seus interesses mudaram para explorar o potencial das GPUs para computação paralela de propósito geral.

Para esse fim, Buck desenvolveu Brook, uma linguagem de programação projetada para permitir computação de propósito geral em GPUs. Seu trabalho atraiu apoio tanto da Nvidia quanto da Agência de Projetos de Pesquisa Avançada de Defesa (DARPA). Em 2004, a Nvidia contratou Buck e o emparelhou com John Nickolls, diretor de arquitetura da empresa para computação em GPU. Juntos, eles começaram a transformar Brook no que se tornaria a CUDA. A CUDA foi oficialmente lançada pela Nvidia em 2007.

Sob a liderança do CEO da Nvidia, Jensen Huang, a CUDA tornou-se central para a estratégia da empresa de posicionar GPUs como hardware versátil para aplicações científicas. Em 2015, o desenvolvimento da CUDA focou cada vez mais na aceleração de aprendizado de máquina e cargas de trabalho de redes neurais artificiais.

Ontologia

A tabela a seguir oferece uma descrição não exata para a ontologia da estrutura CUDA.

Capacidades de programação

A plataforma CUDA é acessível a desenvolvedores de software através de bibliotecas aceleradas por CUDA, diretivas de compilador como OpenACC, e extensões para linguagens de programação padrão da indústria, incluindo C, C++, Fortran e Python. Programadores C/C++ podem usar 'CUDA C/C++', compilado para PTX com nvcc (compilador C/C++ baseado em LLVM da Nvidia) ou pelo próprio clang. Programadores Fortran podem usar 'CUDA Fortran', compilado com o compilador PGI CUDA Fortran da The Portland Group. Programadores Python podem usar a biblioteca cuPyNumeric para acelerar aplicações em GPUs Nvidia.

Além de bibliotecas, diretivas de compilador, CUDA C/C++ e CUDA Fortran, a plataforma CUDA suporta outras interfaces computacionais, incluindo OpenCL do Khronos Group, DirectCompute da Microsoft, OpenGL Compute Shader e C++ AMP. Wrappers de terceiros também estão disponíveis para Python, Perl, Fortran, Java, Ruby, Lua, Common Lisp, Haskell, R, MATLAB, IDL, Julia, e suporte nativo em Mathematica.

Na indústria de jogos de computador, as GPUs são usadas para renderização gráfica e para cálculos de física de jogos (efeitos físicos como detritos, fumaça, fogo, fluidos); exemplos incluem PhysX e Bullet. CUDA também tem sido usada para acelerar aplicações não gráficas em biologia computacional, criptografia e outros campos por uma ordem de magnitude ou mais.

CUDA fornece tanto uma API de baixo nível (API Driver CUDA, não single-source) quanto uma API de nível superior (API Runtime CUDA, single-source). O SDK inicial do CUDA foi tornado público em 15 de fevereiro de 2007, para Microsoft Windows e Linux. O suporte para Mac OS X foi adicionado posteriormente na versão 2.0, que substituiu a versão beta lançada em 14 de fevereiro de 2008. CUDA funciona com todas as GPUs Nvidia da série G8x em diante, incluindo as linhas GeForce, Quadro e Tesla. CUDA é compatível com a maioria dos sistemas operacionais padrão.

CUDA 8.0 vem com as seguintes bibliotecas (para compilação e tempo de execução, em ordem alfabética):

• cuBLAS – biblioteca de sub-rotinas básicas de álgebra linear CUDA
• CUDART – biblioteca de tempo de execução CUDA
• cuFFT – biblioteca de transformada rápida de Fourier CUDA
• cuRAND – biblioteca de geração de números aleatórios CUDA
• cuSOLVER – coleção baseada em CUDA de solucionadores diretos densos e esparsos
• cuSPARSE – biblioteca de matriz esparsa CUDA
• NPP – biblioteca de primitivas de desempenho NVIDIA
• nvGRAPH – biblioteca de análise de grafos NVIDIA
• NVML – biblioteca de gerenciamento NVIDIA
• NVRTC – biblioteca de compilação de tempo de execução NVIDIA para CUDA C++

CUDA 8.0 vem com estes outros componentes de software:

• nView – software de gerenciamento de desktop NVIDIA nView
• NVWMI – kit de ferramentas de gerenciamento empresarial NVIDIA
• GameWorks PhysX – é um mecanismo de física de jogos multiplataforma

CUDA 9.0–9.2 vem com estes outros componentes:

• CUTLASS 1.0 – algoritmos de álgebra linear personalizados,
• NVIDIA Video Decoder foi descontinuado no CUDA 9.2; agora está disponível no NVIDIA Video Codec SDK

CUDA 10 vem com estes outros componentes:

• nvJPEG – processamento JPEG híbrido (CPU e GPU)

CUDA 11.0–11.8 vem com estes outros componentes:

• CUB é uma das novas bibliotecas C++ mais suportadas
• suporte MIG para GPU de múltiplas instâncias
• nvJPEG2000 – codificador e decodificador JPEG 2000

Vantagens

CUDA tem várias vantagens sobre a computação de propósito geral tradicional em GPUs (GPGPU) usando APIs gráficas:

• Leituras dispersas – código pode ler de endereços arbitrários na memória
• Memória virtual unificada (CUDA 4.0 e superior)
• Memória unificada (CUDA 6.0 e superior)
• Memória compartilhada – CUDA expõe uma região de memória compartilhada rápida que pode ser compartilhada entre threads. Isso pode ser usado como um cache gerenciado pelo usuário, permitindo maior largura de banda do que é possível usando buscas de textura.
• Downloads e leituras de volta mais rápidos para e da GPU
• Suporte total para operações inteiras e bit a bit, incluindo buscas de textura inteira

Limitações

• Seja para o computador host ou para o dispositivo GPU, todo o código-fonte CUDA agora é processado de acordo com as regras de sintaxe C++. Este nem sempre foi o caso. Versões anteriores do CUDA eram baseadas em regras de sintaxe C. Como no caso mais geral de compilar código C com um compilador C++, é possível que código-fonte CUDA antigo no estilo C não compile ou não se comporte como originalmente pretendido.
• A interoperabilidade com linguagens de renderização como OpenGL é unidirecional, com OpenGL tendo acesso à memória CUDA registrada, mas o CUDA não tendo acesso à memória OpenGL.
• Copiar entre memória host e dispositivo pode incorrer em uma perda de desempenho devido à largura de banda e latência do barramento do sistema (isso pode ser parcialmente aliviado com transferências de memória assíncronas, tratadas pelo mecanismo DMA da GPU).
• Os threads devem ser executados em grupos de pelo menos 32 para melhor desempenho, com o número total de threads na casa dos milhares. Ramos no código do programa não afetam significativamente o desempenho, desde que cada um dos 32 threads siga o mesmo caminho de execução; o modelo de execução SIMD torna-se uma limitação significativa para qualquer tarefa inerentemente divergente (por exemplo, percorrer uma estrutura de dados de particionamento espacial durante ray tracing).
• Nenhuma emulação ou funcionalidade de fallback está disponível para revisões modernas.
• C++ válido pode às vezes ser sinalizado e impedir a compilação devido à maneira como o compilador aborda a otimização para limitações do dispositivo GPU alvo.^{[carece de fontes]}?
• As informações de tipo de tempo de execução (RTTI) do C++ e o tratamento de exceções no estilo C++ são suportados apenas em código host, não em código de dispositivo.
• Em precisão simples em dispositivos CUDA de primeira geração com capacidade de computação 1.x, números denormais não são suportados e são, em vez disso, zerados, e a precisão das operações de divisão e raiz quadrada é ligeiramente inferior à matemática de precisão simples compatível com IEEE 754. Dispositivos que suportam capacidade de computação 2.0 e superior suportam números denormais, e as operações de divisão e raiz quadrada são compatíveis com IEEE 754 por padrão. No entanto, os usuários podem obter a matemática mais rápida do nível de jogos dos dispositivos de capacidade de computação 1.x, se desejado, definindo flags do compilador para desabilitar divisões precisas e raízes quadradas precisas, e habilitar o zeramento de números denormais.
• Ao contrário do OpenCL, GPUs com CUDA estão disponíveis apenas na Nvidia, pois é proprietário. Tentativas de implementar CUDA em outras GPUs incluem:
  • Projeto Coriander: Converte código-fonte CUDA C++11 para OpenCL 1.2 C. Um fork do CUDA-on-CL destinado a executar TensorFlow.
  • CU2CL: Converte CUDA 3.2 C++ para OpenCL C.
  • GPUOpen HIP: Uma fina camada de abstração sobre CUDA e ROCm destinada a GPUs AMD e Nvidia. Tem uma ferramenta de conversão para importar código-fonte CUDA C++. Suporta CUDA 4.0 mais C++11 e float16.
  • ZLUDA é um substituto direto para CUDA em GPUs AMD e anteriormente GPUs Intel com desempenho próximo ao nativo. O desenvolvedor, Andrzej Janik, foi contratado separadamente pela Intel e AMD para desenvolver o software em 2021 e 2022, respectivamente. No entanto, nenhuma das empresas decidiu lançá-lo oficialmente devido à falta de um caso de uso comercial. O contrato da AMD incluía uma cláusula que permitia a Janik lançar seu código para a AMD independentemente, permitindo-lhe lançar a nova versão que suporta apenas GPUs AMD.
  • ChipStar pode compilar e executar programas CUDA/HIP em plataformas OpenCL 3.0 ou Level Zero avançadas.
  • SCALE é um kit de ferramentas de programação compatível com CUDA para compilação antecipada de código-fonte CUDA em GPUs AMD, visando expandir o suporte para outras GPUs no futuro.

Exemplo

Este código de exemplo em C++ carrega uma textura de uma imagem em uma matriz na GPU:

texture<float, 2, cudaReadModeElementType> tex;

void foo() {
    cudaArray* cu_array;

    // Alocar matriz
    cudaChannelFormatDesc description = cudaCreateChannelDesc<float>();
    cudaMallocArray(&cu_array, &description, width, height);

    // Copiar dados da imagem para a matriz
    cudaMemcpyToArray(cu_array, image, width*height*sizeof(float), cudaMemcpyHostToDevice);

    // Definir parâmetros de textura (padrão)
    tex.addressMode[0] = cudaAddressModeClamp;
    tex.addressMode[1] = cudaAddressModeClamp;
    tex.filterMode = cudaFilterModePoint;
    tex.normalized = false; // não normalizar coordenadas

    // Vincular a matriz à textura
    cudaBindTextureToArray(tex, cu_array);

    // Executar kernel
    dim3 blockDim(16, 16, 1);
    dim3 gridDim((width + blockDim.x - 1)/ blockDim.x, (height + blockDim.y - 1) / blockDim.y, 1);
    kernel<<< gridDim, blockDim, 0 >>>(d_data, height, width);

    // Desvincular a matriz da textura
    cudaUnbindTexture(tex);
}

__global__ void kernel(float* odata, int height, int width) {
    unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
    unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
    if (x < width && y < height) {
        float c = tex2D(tex, x, y);
        odata[y*width+x] = c;
    }
}

Abaixo está um exemplo dado em Python que calcula o produto de duas matrizes na GPU. As ligações não oficiais da linguagem Python podem ser obtidas do PyCUDA.

import numpy
import pycuda.autoinit

from numpy.typing import NDArray, float32
from pycuda.compiler import SourceModule
from pycuda.driver import Function, In, Out

mod: SourceModule = SourceModule(
    """
__global__ void multiply_them(float* dest, float* a, float* b) {
    const int i = threadIdx.x;
    dest[i] = a[i] * b[i];
}
"""
)

multiply_them: Function = mod.get_function("multiply_them")

a: NDArray[float32] = numpy.random.randn(400).astype(numpy.float32)
b: NDArray[float32] = numpy.random.randn(400).astype(numpy.float32)

dest: NDArray[float32] = numpy.zeros_like(a)
multiply_them(Out(dest), In(a), In(b), block=(400, 1, 1))

print(dest - a * b)

Ligações adicionais em Python para simplificar operações de multiplicação de matrizes podem ser encontradas no programa pycublas.

 
import numpy

from pycublas import CUBLASMatrix

A: CUBLASMatrix = CUBLASMatrix(numpy.mat([[1, 2, 3], [4, 5, 6]], numpy.float32))
B: CUBLASMatrix = CUBLASMatrix(numpy.mat([[2, 3], [4, 5], [6, 7]], numpy.float32))
C: CUBLASMatrix = A * B
print(C.np_mat())

enquanto CuPy substitui diretamente o NumPy:

import cupy

from cupy.typing import NDArray, float64

a: NDArray[float64] = cupy.random.randn(400)
b: NDArray[float64] = cupy.random.randn(400)

dest: NDArray[float64] = cupy.zeros_like(a)

print(dest - a * b)

GPUs suportadas

Nota sobre notação: a capacidade de computação X.Y também é escrita SMXY ou sm_xy (por exemplo, 10.3 como SM103 ou sm_103) no software profissional da Nvidia e no código que a Nvidia contribuiu para o LLVM.

Abaixo está uma tabela das capacidades de computação CUDA suportadas com base na versão do SDK CUDA e microarquitetura, listadas por nome de código:

Suporte do SDK CUDA vs. microarquitetura (célula: capacidade de computação)

Versão(s) do SDK CUDA	Tesla	Fermi	Kepler (inicial)	Kepler (tardio)	Maxwell	Pascal	Volta	Turing	Ampere	Ada Lovelace	Hopper	Blackwell
1.0	1.0 – 1.1
1.1	1.0 – 1.1+x
2.0	1.0 – 1.1+x
2.1 – 2.3.1	1.0 – 1.3
3.0 – 3.1	1.0	2.0
3.2	1.0	2.1
4.0 – 4.2	1.0	2.1
5.0 – 5.5	1.0		3.0	3.5
6.0	1.0		3.2	3.5
6.5	1.1			3.7	5.x
7.0 – 7.5		2.0			5.x
8.0		2.0				6.x
9.0 – 9.2			3.0				7.0 – 7.2
10.0 – 10.2			3.0					7.5
11.0				3.5					8.0
11.1 – 11.4				3.5					8.6
11.5 – 11.7.1				3.5					8.7
11.8				3.5						8.9	9.0
12.0 – 12.6					5.0						9.0
12.8								7.5				12.0
12.9								7.5				12.1
13.0								7.5				12.1

Nota: CUDA SDK 10.2 é o último lançamento oficial para macOS, pois o suporte não estará disponível para macOS em versões mais recentes.

Capacidade de computação CUDA por versão com semicondutores GPU associados e modelos de placa GPU (separados por suas várias áreas de aplicação):

* – produtos apenas para OEM

Recursos e especificações por versão

Nota: Uma GPU com uma capacidade de computação maior é capaz de executar código PTX destinado a uma GPU de uma faixa menor de capacidades de computação. No entanto, é possível compilar o código CUDA de uma forma que funcione apenas em uma família específica (mesmo "X") de GPUs; se o código existente for compilado dessa maneira, será necessária a recompilação para que ele funcione em uma GPU mais nova.

Usos da arquitetura CUDA

• Renderização acelerada de gráficos 3D
• Interconversão acelerada de formatos de arquivo de vídeo
• Criptografia, descriptografia e compressão aceleradas
• Bioinformática, por exemplo, sequenciamento de DNA NGS BarraCUDA
• Cálculos distribuídos, como prever a conformação nativa de proteínas
• Simulações de análise médica, por exemplo, realidade virtual baseada em imagens de tomografia computadorizada (TC) e ressonância magnética (RM)
• Simulações físicas, particularmente em dinâmica dos fluidos
• Treinamento de redes neurais em problemas de aprendizado de máquina
• Inferência de Modelos de Linguagem Grande
• Reconhecimento facial
• Projetos de computação voluntária, como SETI@home e outros projetos usando software BOINC
• Dinâmica molecular
• Mineração de criptomoedas
• Software de estrutura a partir do movimento (SfM)

Comparação com concorrentes

CUDA compete com outras pilhas de computação GPU: Intel OneAPI e AMD ROCm.

Enquanto a CUDA da Nvidia é de código fechado, a OneAPI da Intel e a ROCm da AMD são de código aberto.

Ver também

• SYCL – um padrão aberto do Khronos Group para programar uma variedade de plataformas, incluindo GPUs, com C++ moderno single-source, semelhante à API Runtime CUDA de nível superior (single-source)
• Computação paralela
• Vulkan – API de computação e gráficos 3D de baixo nível e alto desempenho

Referências

Leitura adicional

• Buck, Ian; Foley, Tim; Horn, Daniel; Sugerman, Jeremy; Fatahalian, Kayvon; Houston, Mike; Hanrahan, Pat (1 de agosto de 2004). «Brook for GPUs: stream computing on graphics hardware». ACM Transactions on Graphics. 23 (3): 777–786. ISSN 0730-0301. doi:10.1145/1015706.1015800. Cópia arquivada em 14 de junho de 2025 
• Nickolls, John; Buck, Ian; Garland, Michael; Skadron, Kevin (1 de março de 2008). «Scalable Parallel Programming with CUDA: Is CUDA the parallel programming model that application developers have been waiting for?». ACM Queue. 6 (2): 40–53. ISSN 1542-7730. doi:10.1145/1365490.1365500. Cópia arquivada em 20 de fevereiro de 2025 

Ligações externas

• «Página oficial» 
• Livros didáticos CUDA