CUDA

Descrição

CUDA (Compute Unified Device Architecture) é uma plataforma de computação paralela e modelo de programação desenvolvidos pela NVIDIA para processamento em GPUs (Graphics Processing Units). Permite aceleração significativa de aplicações científicas, aprendizado de máquina e processamento de imagens.

Versões Disponíveis

  • cuda/12.4

  • cuda/12.9 (default)

Nota

As versões CUDA são compatíveis com drivers específicos. Verifique a documentação das aplicações que você pretende usar para escolher a versão adequada.

Configuração de Ambiente

Ao carregar o módulo CUDA, várias variáveis de ambiente são definidas:

module load cuda/12.9

# Diretórios importantes
echo $CUDA_HOME      # Diretório de instalação
echo $CUDA_PATH      # Mesmo que CUDA_HOME
echo $CUDA_ROOT      # Raiz do CUDA

# PATH e LD_LIBRARY_PATH são automaticamente configurados
echo $PATH
echo $LD_LIBRARY_PATH

Os jobs que utilizam GPU devem ser submetidos à partição especial gpu:

#SBATCH --partition=gpu
#SBATCH --gres=gpu:N    # N = número de GPUs desejado (1-4)

Compilando Código CUDA

O compilador nvcc é usado para compilar código CUDA.

compile_cuda.sh
#!/bin/bash
#SBATCH -J compile_cuda
#SBATCH -p gpu
#SBATCH --gres=gpu:1
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=20G

export INPUT="vetor_add.cu"
export OUTPUT="vetor_add"

module load cuda/12.9

job-nanny nvcc -o vetor_add vetor_add.cu

Exemplo de Código CUDA

vetor_add.cu
#include <stdio.h>
#include <cuda_runtime.h>

// Kernel CUDA
__global__ void add_vectors(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        c[i] = a[i] + b[i];
    }
}

int main() {
    int n = 1000000;
    size_t size = n * sizeof(float);

    // Alocar memória no host
    float *h_a = (float*)malloc(size);
    float *h_b = (float*)malloc(size);
    float *h_c = (float*)malloc(size);

    // Inicializar dados
    for (int i = 0; i < n; i++) {
        h_a[i] = i * 1.0f;
        h_b[i] = i * 2.0f;
    }

    // Alocar memória no device
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, size);
    cudaMalloc(&d_b, size);
    cudaMalloc(&d_c, size);

    // Copiar dados para device
    cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);

    // Configurar e lançar kernel
    int threads = 256;
    int blocks = (n + threads - 1) / threads;

    add_vectors<<<blocks, threads>>>(d_a, d_b, d_c, n);
    cudaDeviceSynchronize();

    // Copiar resultado de volta
    cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);

    // Verificar resultado
    printf("c[0] = %f\n", h_c[0]);
    printf("c[%d] = %f\n", n-1, h_c[n-1]);

    // Liberar memória
    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);
    free(h_a);
    free(h_b);
    free(h_c);

    return 0;
}

Submissão de Jobs CUDA

submit_cuda.sh
#!/bin/bash
#SBATCH -J cuda_job
#SBATCH -p gpu
#SBATCH --gres=gpu:1
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:30:00
#SBATCH --mem=40G

export INPUT="vetor_add"
export OUTPUT="cuda_output.txt"

module load cuda/12.9

job-nanny ./vetor_add > cuda_output.txt

Multi-GPU

submit_cuda_multi.sh
#!/bin/bash
#SBATCH -J cuda_multi
#SBATCH -p gpu
#SBATCH --gres=gpu:4
#SBATCH -N 1
#SBATCH -n 4
#SBATCH -t 02:00:00
#SBATCH --mem=32G

export INPUT="programa_multi_gpu"
export OUTPUT="multi_gpu_output/"

module load cuda/12.9

# O programa deve gerenciar múltiplas GPUs
job-nanny ./programa_multi_gpu

Informações sobre GPUs

Durante a execução, você pode obter informações sobre as GPUs:

# No script de submissão
nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv

# Verificar GPUs disponíveis para o job
echo "CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"

# Teste simples
deviceQuery

Compilando com Múltiplas Arquiteturas

# Compilar para várias arquiteturas
nvcc -arch=sm_80 -code=sm_80,sm_86,sm_89 programa.cu -o programa

# Ou usar a arquitetura atual
nvcc -arch=native programa.cu -o programa

Usando CUDA com Python (CuPy)

submit_cupy.sh
#!/bin/bash
#SBATCH -J cupy
#SBATCH -p gpu
#SBATCH --gres=gpu:1
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 01:00:00
#SBATCH --mem=8G

export INPUT="cupy_script.py"
export OUTPUT="cupy_output/"

module load cuda/12.9
module load miniconda/24.4.0-libmamba

source activate cupy_env  # Ambiente com cupy instalado

job-nanny python cupy_script.py

Exemplo com CuPy

cupy_script.py
import cupy as cp
import numpy as np
import time

# Criar arrays na GPU
size = 10000
a = cp.random.randn(size, size, dtype=cp.float32)
b = cp.random.randn(size, size, dtype=cp.float32)

# Operação na GPU
start = time.time()
c = cp.matmul(a, b)
cp.cuda.Stream.null.synchronize()
gpu_time = time.time() - start

print(f"Multiplicação de matrizes {size}x{size} na GPU: {gpu_time:.3f}s")

# Comparação com CPU
a_cpu = cp.asnumpy(a)
b_cpu = cp.asnumpy(b)

start = time.time()
c_cpu = np.matmul(a_cpu, b_cpu)
cpu_time = time.time() - start

print(f"Multiplicação na CPU: {cpu_time:.3f}s")
print(f"Speedup: {cpu_time/gpu_time:.2f}x")

Depuração e Perfilamento

# Usar cuda-gdb para depuração
cuda-gdb ./programa

# Perfilamento com nvprof (versões antigas)
nvprof ./programa

# Perfilamento com Nsight Systems (versões novas)
nsys profile ./programa

# Perfilamento com Nsight Compute
ncu ./programa

Referências

Ver também