Qual è il modo canonico per verificare la presenza di errori utilizzando l'API di runtime CUDA?


Answers

La risposta di talonmie sopra è un ottimo modo per abortire un'applicazione in stile assert .

Occasionalmente potremmo voler segnalare e recuperare da una condizione di errore in un contesto C ++ come parte di un'applicazione più grande.

Ecco un modo ragionevolmente teso per farlo gettando un'eccezione C ++ derivata da std::runtime_error usando thrust::system_error :

#include <thrust/system_error.h>
#include <thrust/system/cuda/error.h>
#include <sstream>

void throw_on_cuda_error(cudaError_t code, const char *file, int line)
{
  if(code != cudaSuccess)
  {
    std::stringstream ss;
    ss << file << "(" << line << ")";
    std::string file_and_line;
    ss >> file_and_line;
    throw thrust::system_error(code, thrust::cuda_category(), file_and_line);
  }
}

Questo includerà il nome file, il numero di riga e una descrizione della lingua inglese di cudaError_t nel membro .what() dell'eccezione generata:

#include <iostream>

int main()
{
  try
  {
    // do something crazy
    throw_on_cuda_error(cudaSetDevice(-1), __FILE__, __LINE__);
  }
  catch(thrust::system_error &e)
  {
    std::cerr << "CUDA error after cudaSetDevice: " << e.what() << std::endl;

    // oops, recover
    cudaSetDevice(0);
  }

  return 0;
}

Il risultato:

$ nvcc exception.cu -run
CUDA error after cudaSetDevice: exception.cu(23): invalid device ordinal

Un client di some_function può distinguere gli errori CUDA da altri tipi di errori se lo si desidera:

try
{
  // call some_function which may throw something
  some_function();
}
catch(thrust::system_error &e)
{
  std::cerr << "CUDA error during some_function: " << e.what() << std::endl;
}
catch(std::bad_alloc &e)
{
  std::cerr << "Bad memory allocation during some_function: " << e.what() << std::endl;
}
catch(std::runtime_error &e)
{
  std::cerr << "Runtime error during some_function: " << e.what() << std::endl;
}
catch(...)
{
  std::cerr << "Some other kind of error during some_function" << std::endl;

  // no idea what to do, so just rethrow the exception
  throw;
}

Poiché thrust::system_error è uno std::runtime_error , possiamo alternativamente gestirlo nello stesso modo di un'ampia classe di errori se non richiediamo la precisione dell'esempio precedente:

try
{
  // call some_function which may throw something
  some_function();
}
catch(std::runtime_error &e)
{
  std::cerr << "Runtime error during some_function: " << e.what() << std::endl;
}
Question

Guardando attraverso le risposte e i commenti sulle domande CUDA, e nel tag wiki CUDA , vedo che spesso viene suggerito che lo stato di ritorno di ogni chiamata API dovrebbe essere controllato per gli errori. La documentazione dell'API contiene funzioni come cudaGetLastError , cudaPeekAtLastError e cudaGetErrorString , ma qual è il modo migliore per raggruppare questi elementi in modo affidabile per rilevare e segnalare errori senza richiedere molto codice aggiuntivo?




La soluzione discussa here funzionato bene per me. Questa soluzione utilizza funzioni integrate di cuda ed è molto semplice da implementare.

Il codice rilevante è copiato di seguito:

#include <stdio.h>
#include <stdlib.h>

__global__ void foo(int *ptr)
{
  *ptr = 7;
}

int main(void)
{
  foo<<<1,1>>>(0);

  // make the host block until the device is finished with foo
  cudaDeviceSynchronize();

  // check for error
  cudaError_t error = cudaGetLastError();
  if(error != cudaSuccess)
  {
    // print the CUDA error message and exit
    printf("CUDA error: %s\n", cudaGetErrorString(error));
    exit(-1);
  }

  return 0;
}



Links