CUDA Academy · Aula

Condições de corrida na GPU

Por que escritas simultâneas corrompem os dados.

Aula 1 de 413 etapas

Condições de corrida na GPU é uma aula grátis de CUDA Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de CUDA Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de CUDA Academy inclui 4 aulas no total.

Muitas Mãos, Um Contador

Na GPU, milhares de linhas de execução podem acessar a mesma memória ao mesmo tempo. Quando várias escrevem juntas em um único local, ocorre uma condição de corrida. 🏁

O Que uma Corrida Realmente É

Uma condição de corrida ocorre quando o resultado final depende da ordem imprevisível em que as linhas de execução são executadas. O mesmo código, uma resposta diferente a cada inicialização.

Leitura-Modificação-Escrita

Incrementar um contador são, na verdade, três etapas: ler o valor, adicionar um e escrevê-lo de volta. É nessa sequência de leitura-modificação-escrita que os problemas aparecem.

counter = counter + 1;

Como as Etapas se Intercalam

Duas linhas de execução leem 5, calculam 6 e escrevem 6. Você esperava 7, mas obteve 6. Um incremento desapareceu silenciosamente.

A Atualização Perdida

Esse incremento desaparecido é chamado de atualização perdida. Com milhares de linhas de execução em disputa, dezenas ou centenas de atualizações podem desaparecer de uma vez.

Um Núcleo que Parece Correto

Este núcleo parece correto, mas todas as linhas de execução competem pelo mesmo endereço. A contagem final estará errada e variará entre as execuções.

__global__ void count(int* total) {
    *total = *total + 1;
}

Por Que É Não Determinístico

O hardware nunca promete uma ordem para as linhas de execução. Portanto, um núcleo com condição de corrida é não determinístico: pode até passar com entradas pequenas e falhar com entradas grandes.

Somente Leituras São Seguras

Muitas linhas de execução lendo o mesmo valor não causam problema algum. O problema começa apenas quando pelo menos uma linha escreve enquanto outras leem ou escrevem.

Escritas em Locais Distintos Também São Seguras

Se cada linha de execução escrever em sua própria posição exclusiva, como out[i], não haverá conflito. Uma corrida exige que as linhas de execução apontem para o mesmo local.

out[i] = a[i] + b[i];

Uma Prévia da Solução

A solução é fazer com que a leitura-modificação-escrita aconteça como uma única etapa indivisível. Isso é uma operação atômica, que será apresentada na próxima lição. ⚛️

Identificando Corridas na Revisão

Ao revisar um núcleo, pergunte: duas linhas de execução escrevem no mesmo endereço sem proteção? Se sim, quase certamente há uma corrida de dados.

Verificação Rápida

Vamos confirmar se a ideia de corrida ficou clara.

Recapitulação: Corridas na GPU

Você aprendeu que a leitura-modificação-escrita sem proteção em dados compartilhados causa condições de corrida e atualizações perdidas. As operações atômicas, apresentadas a seguir, tornam essas etapas indivisíveis. ✅

Grátis para começar

Aprenda C++ com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Condições de corrida na GPU” é grátis?

Sim — o texto completo de “Condições de corrida na GPU” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de CUDA Academy, atualize para CoddyKit PRO. O curso de CUDA Academy inclui 4 aulas no total.

O que vou aprender em “Condições de corrida na GPU”?

Por que escritas simultâneas corrompem os dados. Você pratica CUDA Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar CUDA Academy?

Nenhuma experiência prévia é necessária. CUDA Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Condições de corrida na GPU”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de CUDA Academy?

Sim. Cada aula de CUDA Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Condições de corrida na GPU
  2. atomicAdd e funções relacionadas
  3. Construa um histograma
  4. Operações atômicas personalizadas com atomicCAS
← Voltar para CUDA Academy