Почему вычислительная норма L2 с cuBLAS приводит к ошибке?

Question

Edit 2: включают более полную программу

Edit 1: включает полную программу

Я пытаюсь вычислить норму L2 вектора с использованием cuBLAS. Мой код выглядит следующим образом

void GPU_Print_Matrix(real_t *A, int nrows, int ncols) { 
    real_t *hostA = (real_t*)malloc(nrows*ncols * sizeof(real_t)); 
    CUDA_SAFE_CALL(cudaMemcpy(hostA, A, nrows*ncols * sizeof(real_t), cudaMemcpyDeviceToHost)); 

    cout << "GPU Matrix of Size: " << nrows << "x" << ncols << endl; 
    for (int i = 0; i < nrows; ++i) { 
    for (int j = 0; j < ncols; ++j) { 
     cout << fixed << setprecision(PRINT_PRECISION) << hostA[j*nrows + i] << " "; 
    } 
    cout << endl; 
    } 

    free(hostA); 
    cout << endl; 
} 

void GPU_Random_Vector(thrust::device_vector <real_t> &vec) { 
    thrust::counting_iterator<unsigned int> index_sequence_begin(rand()); 
    thrust::transform(index_sequence_begin, index_sequence_begin + vec.size(), vec.begin(), RANDOM(-initRange, initRange)); 
} 

int main(int argc, char *argv[]) { 
    srand(clock()); 
    cout << "# Running NMT" << endl; 

    //ParseOpts(argc, argv); 

    cublasHandle_t handle; 
    CUBLAS_SAFE_CALL(cublasCreate(&handle)); 
    thrust::device_vector <real_t> x(10); 
    GPU_Random_Vector(x); 
    GPU_Print_Matrix(thrust::raw_pointer_cast(&x[0]), 10, 1); 
    real_t nrm = 0; 
    CUBLAS_SAFE_CALL(cublasXnrm2(handle, 10, thrust::raw_pointer_cast(&x[0]), 1, &nrm)); 
    cout << "nrm2 = " << nrm << endl; 
} 

Здесь CUBLAS_SAFE_CALL определяется следующим

#define CUBLAS_SAFE_CALL(call)              \ 
{                     \ 
    const cublasStatus_t stat = call;            \ 
    if (stat != CUBLAS_STATUS_SUCCESS) {            \ 
    cout << "cuBlas Error: " << __FILE__ << ":" << __LINE__ << endl;    \ 
    cout << " Code: " << stat << endl;           \ 
    exit(1);                  \ 
    }                    \ 
} 

GPU_Random_Vector и GPU_Print_Matrix были подтверждены на работу раньше. Кроме того, перед вызовом инициализируется cublasHandle[singleGPU]. Когда я запустил программу, у меня был следующий выход:

// GPU_Print_Matrix 
GPU Matrix of Size: 10x1 
0.0652332678 
0.0747700930 
0.0274266358 
-0.0885794610 
-0.0192640368 
-0.0942506194 
0.0283640027 
-0.0411146656 
-0.0460337885 
-0.0970785618 

cuBlas Error: nmt.cu:2252 
    Code: 14 

Что происходит? И есть ли какая-либо ссылка, как я могу интерпретировать номер ошибки cuBLAS? Благодаря тонну.

Answer 1

Ошибка CUBLAS 14 равна CUBLAS_STATUS_INTERNAL_ERROR и обычно означает, что внутреннее устройство для размещения копии в конце вызова нормы L2 завершилось с ошибкой. Но почему это произошло, невозможно сказать без какого-либо контекста о том, что еще делает ваш код.

Если код размещен собран и конкретизирован в полную демо случае (с тривиальным случайным числом высева ошибки правильной), как это:

#include <iostream> 
#include <iomanip> 
#include <cstdlib> 
#include <cublas_v2.h> 
#include <thrust/transform.h> 
#include <thrust/device_vector.h> 
#include <thrust/device_ptr.h> 
#include <thrust/iterator/counting_iterator.h> 
#include <thrust/random.h> 

typedef float real_t; 

#define CUBLAS_SAFE_CALL(call)              \ 
{                     \ 
    const cublasStatus_t stat = call;            \ 
    if (stat != CUBLAS_STATUS_SUCCESS) {            \ 
    std::cout << "cuBlas Error: " << __FILE__ << ":" << __LINE__ << std::endl;  \ 
    std::cout << " Code: " << stat << std::endl;         \ 
    exit(1);                  \ 
    }                    \ 
} 

#define PRINT_PRECISION (6) 

struct RANDOM 
{ 
    real_t a, b; 

    __host__ __device__ 
    RANDOM(real_t _a=0, real_t _b=1) : a(_a), b(_b) {}; 

    __host__ __device__ 
     real_t operator()(const unsigned int n) const 
     { 
      thrust::default_random_engine rng; 
      thrust::uniform_real_distribution<float> dist(a, b); 
      rng.discard(n); 

      return dist(rng); 
     } 
}; 

void GPU_Print_Matrix(real_t *A, int nrows, int ncols) { 
    real_t *hostA = (real_t*)malloc(nrows*ncols * sizeof(real_t)); 
    cudaMemcpy(hostA, A, nrows*ncols * sizeof(real_t), cudaMemcpyDeviceToHost); 

    std::cout << "GPU Matrix of Size: " << nrows << "x" << ncols << std::endl; 
    for (int i = 0; i < nrows; ++i) { 
    for (int j = 0; j < ncols; ++j) { 
     std::cout << std::fixed << std::setprecision(PRINT_PRECISION) << hostA[j*nrows + i] << " "; 
    } 
    std::cout << std::endl; 
    } 

    free(hostA); 
    std::cout << std::endl; 
} 

void GPU_Random_Vector(thrust::device_vector <real_t> &vec) { 
    const real_t initRange = 10; 
    thrust::counting_iterator<unsigned int> index_sequence_begin(std::rand()); 
    thrust::transform(index_sequence_begin, index_sequence_begin + vec.size(), vec.begin(), RANDOM(-initRange, initRange)); 
} 

int main(int argc, char *argv[]) { 
    std::srand(std::time(0)); 
    std::cout << "# Running NMT" << std::endl; 

    cublasHandle_t handle; 
    CUBLAS_SAFE_CALL(cublasCreate(&handle)); 
    thrust::device_vector <real_t> x(10); 
    GPU_Random_Vector(x); 
    GPU_Print_Matrix(thrust::raw_pointer_cast(&x[0]), 10, 1); 
    real_t nrm = 0; 
    CUBLAS_SAFE_CALL(cublasSnrm2(handle, 10, thrust::raw_pointer_cast(&x[0]), 1, &nrm)); 
    std::cout << "nrm2 = " << nrm << std::endl; 
} 

и компиляцией и запуск, как это (CUDA 6.5, если что вопросы):

>nvcc -arch=sm_21 -run runkkari.cu -lcublas 
runkkari.cu 
    Creating library a.lib and object a.exp 
# Running NMT 
GPU Matrix of Size: 10x1 
-5.712992 
8.181723 
-0.086308 
-6.177320 
-5.442665 
-2.889552 
-1.555665 
6.506872 
-6.800190 
8.024273 

nrm2 = 18.196394 

Работает должным образом. Вы должны скомпилировать и запустить это, чтобы подтвердить это самостоятельно. Поэтому из этого можно сделать вывод, что у вас есть еще одна проблема, которую вы не смогли описать. Но, возможно, это помогает сузить список возможностей.