सीयूडीए

Question

का उपयोग करते हुए स्थानीय मेमोरी में सरणी पर वैरिएबल आकार को परिभाषित करता है क्या डिवाइस में किसी सूची, सरणी, कुछ सूची बनाने के लिए कुछ हद तक संभव है, कॉल में पैरामीटर मधुमक्खियों की सूची/सरणी के आकार के साथ फ़ंक्शन ... या वैश्विक वेरिएबल जो कॉल समय पर शुरू हुआ है?

मैं काम करने के लिए इन सूची में से एक की तरह कुछ करना चाहते हैं:

unsigned int size1; 

__device__ void function(int size2) { 

    int list1[size1]; 
    int list2[size2]; 
} 

यह इस काम की तरह कुछ बनाने के लिए कुछ स्मार्ट करने के लिए संभव है?

Answer 1

1 जिस तरह से साझा स्मृति के गतिशील राशि आवंटित करने के लिए नहीं है देखना चाहेंगे -

__device__ void function(int * a, int * b, int k) // k elements in first list 
{ 
    extern __shared__ int list1 []; 
    extern __shared__ int list2 []; // list2 points to the same point as list1 does 

    list1 [threadIdx.x] = a[blockIdx.x * blockDim.x + threadIdx.x]; 
    list2 [k + threadIdx.x] = b[blockIdx.x * blockDim.x + threadIdx.x]; 
    // . . . 
} 

आप को ध्यान में रखना चाहिए:: स्मृति एक के लिए आवंटित

__global__ void kernel (int * arr) 
{ 
    extern __shared__ int buf []; // size is not stated 
    // copy data to shared mem: 
    buf[threadIdx.x] = arr[blockIdx.x * blockDim.x + threadIdx.x]; 
    // . . . 
} 
// . . . 
// launch kernel, set size of shared mem in bytes (k elements in buf): 
kernel<<<grid, threads, k * sizeof(int)>>> (arr); 

कई सरणियों के लिए एक हैक है: तीसरे लांच कर्नेल पैरामीटर का उपयोग करने ब्लॉक करेंगे

Answer 2

यदि आप जानते हैं कि आप किस आकार के आकार की अपेक्षा कर सकते हैं, तो C++ टेम्पलेट्स का उपयोग करने पर विचार करें। बूस्ट प्रीप्रोसेसर के साथ आप आसानी से कई उदाहरण/प्रविष्टि बिंदु उत्पन्न कर सकते हैं।

अन्य चीज जो आप कर सकते हैं वह गतिशील रूप से साझा स्मृति आवंटित करता है और मैन्युअल रूप से पॉइंटर्स असाइन करता है। जाहिर है इस लिए यदि आप साझा स्मृति

मैं एक लिंक प्रदान कर सकते हैं से अधिक निजी स्मृति थ्रेड की आवश्यकता होती है काम नहीं कर सकता यदि आप उदाहरण

Answer 3

बेशक यह संभव है!

परियोजना के स्रोत-कोड में एक नज़र डालें: http://code.google.com/p/cuda-grayscale/

इस समारोह मुख्य रूप से कहा जाता है() और प्रदर्शन करती gpu_image पर ग्रेस्केल रूपांतरण पर आधारित चौड़ाई और ऊंचाई है: cuda_grayscale (gpu_image, चौड़ाई , ऊंचाई, ग्रिड, ब्लॉक);

आप एक छोटे से खुदाई, तो आप kernel_gpu.cu में कार्यान्वयन मिल जाएगा:

__global__ void grayscale(float4* imagem, int width, int height) 
{ 
    const int i = blockIdx.x * (blockDim.x * blockDim.y) + blockDim.x * threadIdx.y + threadIdx.x; 

    if (i < width * height) 
    { 
     float v = 0.3 * imagem[i].x + 0.6 * imagem[i].y + 0.1 * imagem[i].z; 
     imagem[i] = make_float4(v, v, v, 0); 
    } 
}