त्रुटि CUDA 5

Question

का उपयोग कर समस्या

मैं लगातार स्मृति का उपयोग एक नमूना CUDA कोड तैयार किया है। मैं इसे सफलतापूर्वक cuda 4.2 में चला सकता हूं लेकिन मुझे "अमान्य डिवाइस प्रतीक" मिलता है जब मैं CUDA 5. का उपयोग करके संकलित करता हूं। मैंने यहां नमूना कोड संलग्न किया है।

कोड

#include <iostream> 
#include <stdio.h> 
#include <cuda_runtime.h> 
#include <cuda.h> 

struct CParameter 
{ 
    int A; 
    float B; 
    float C; 
    float D; 
}; 

__constant__ CParameter * CONSTANT_PARAMETER; 
#define PARAMETER "CONSTANT_PARAMETER" 

bool ERROR_CHECK(cudaError_t Status) 
{ 
    if(Status != cudaSuccess) 
    { 
     printf(cudaGetErrorString(Status)); 
     return false; 
    } 
    return true; 
} 

// Kernel that executes on the CUDA device 
__global__ void square_array(float *a, int N) 
{ 
    int idx = blockIdx.x * blockDim.x + threadIdx.x; 
    if (idx<N) 
    { 
     a[idx] = CONSTANT_PARAMETER->A * a[idx]; 
    } 
} 
////Main Function///// 
int main(void) 
{ 
    /////Variable Definition 
    const int N = 10; 
    size_t size = N * sizeof(float); 
    cudaError_t Status = cudaSuccess; 

    CParameter * m_dParameter; 
    CParameter * m_hParameter; 
    float * m_D; 
    float * m_H; 

    //Memory Allocation Host 
    m_hParameter = new CParameter; 
    m_H = new float[N]; 

    //Memory Allocation Device 
    cudaMalloc((void **) &m_D, size); 
    cudaMalloc((void**)&m_dParameter,sizeof(CParameter)); 

    ////Data Initialization 
    for (int i=0; i<N; i++) 
     m_H[i] = (float)i; 

    m_hParameter->A = 5; 
    m_hParameter->B = 3; 
    m_hParameter->C = 98; 
    m_hParameter->D = 100; 

    //Memory Copy from Host To Device 
    Status = cudaMemcpy(m_D, m_H, size, cudaMemcpyHostToDevice); 
    ERROR_CHECK(Status); 

    Status = cudaMemcpy(m_dParameter,m_hParameter,sizeof(CParameter),cudaMemcpyHostToDevice); 
    ERROR_CHECK(Status);   

    Status = cudaMemcpyToSymbol(PARAMETER, &m_dParameter, sizeof(m_dParameter)); 
    ERROR_CHECK(Status); 

    // Do calculation on device: 
    int block_size = 4; 

    int n_blocks = N/block_size + (N%block_size == 0 ? 0:1); 

    square_array <<<n_blocks, block_size>>>(m_D,N); 

    // Retrieve result from device and store it in host array 
    cudaMemcpy(m_H, m_D, sizeof(float)*N, cudaMemcpyDeviceToHost); 

    // Print results 
    for (int i=0; i<N; i++) 
     printf("%d %f\n", i, m_H[i]); 

    // Cleanup 
    free(m_H); 
    free(m_hParameter); 
    cudaFree(m_dParameter); 
    cudaFree(m_D); 
    return 0; 
} 

मैं WINDOWS की कोशिश की है: CUDA 5.0 उत्पादन रिलीज और ग्राफिक्स कार्ड GTX 590.
किसी भी मदद की सराहना की होगी।

Answer 1

"Stringly Typed" होने से बचने के प्रयास में, डिवाइस प्रतीकों को संदर्भित करने के लिए वर्ण तारों का उपयोग CUDA 4.1 में CUDA रनटाइम API फ़ंक्शन में बहिष्कृत किया गया था, और CUDA 5.0 में हटा दिया गया था।

CUDA 5 release notes पढ़ने:

** एक चरित्र स्ट्रिंग के उपयोग के लिए एक उपकरण प्रतीक है, जो कुछ एपीआई कार्यों के साथ संभव था इंगित करने के लिए, अब समर्थित नहीं है। इसके बजाए, प्रतीक सीधे इस्तेमाल किया जाना चाहिए।

यदि आप निम्नलिखित में अपना कोड बदलते हैं, तो इसे काम करना चाहिए।

Status = cudaMemcpyToSymbol(CONSTANT_PARAMETER, &m_dParameter, sizeof(m_dParameter)); 
ERROR_CHECK(Status); 

Answer 2

CUDA 5.0 Release Notes से:

** एक चरित्र स्ट्रिंग के उपयोग के लिए एक उपकरण प्रतीक है, जो कुछ एपीआई कार्यों के साथ संभव हो गया था इंगित करने के लिए, अब समर्थित नहीं है। इसके बजाय, प्रतीक सीधे इस्तेमाल किया जाना चाहिए। "

इन API कार्यों अभी भी मौजूद हैं, लेकिन वे अब केवल एक नंगे पहचानकर्ता के रूप में लक्ष्य प्रतीक तर्क को स्वीकार नहीं या तो एक नंगे पहचानकर्ता या एक स्ट्रिंग शाब्दिक एक अध्यक्ष नामकरण के रूप में। उदाहरण के लिए

__ device__ __ constant__ type ident; 

main() { cudaMemcpyToSymbol("ident", ...); } // no longer valid, returns cudaErrorInvalidSymbol 

main() { cudaMemcpyToSymbol(ident, ...); } // valid 

तो इस से छुटकारा पाने:

#define PARAMETER "CONSTANT_PARAMETER" 

और यह बदलने के लिए:

Status = cudaMemcpyToSymbol(PARAMETER, &m_dParameter, sizeof(m_dParameter)); 

इस के लिए:

Status = cudaMemcpyToSymbol(CONSTANT_PARAMETER, &m_dParameter, sizeof(m_dParameter)); 

और मुझे लगता है काम करेंगे।