Was passiert eigentlich, wenn Sie cudaMalloc im Gerät anrufen?

Question

Das hier funktioniert tatsächlich, so frage ich mich, ist Cuda dynamisch Speicher auf dem Gerät im Thread zuweisen? Wenn ja, was ist die Verwendung von , da dies im Vergleich viel viel viel schneller ist? Ich frage, was wirklich hinter der Szene passiert, wenn Sie den cudaMalloc im Kernel verwenden, da es so viel schneller scheint als nur Gerät malloc auf Heap.

#include <iostream> 
#include <numeric> 
#include <stdlib.h> 

__global__ void testMem(int* time){ 
    int* a; 
    cudaMalloc(&a,sizeof(int)); 
    a[0] = 4; 
    time = a[0]; 
} 

__global__ void testMem2(int* time){ 

} 
int main(){ 
    int* h_time = (int*)malloc(sizeof(int)); 
    h_time[0] =0; 
    int* d_time; 
    cudaMalloc(&d_time,sizeof(int)); 
    clock_t start1 = clock(); 
    cudaMemcpy(d_time,h_time,sizeof(int),cudaMemcpyHostToDevice); 

    testMem<<<1,1>>>(d_time); 
    cudaMemcpy(h_time,d_time,sizeof(int),cudaMemcpyDeviceToHost); 
    cudaDeviceSynchronize(); 
    clock_t end1 = clock(); 

    int result = end1- start1; 
    //float result = (float)*h_time; 
    //result =result/ CLOCKS_PER_SEC; 
    std::cout<<result<<std::endl; 
    std::cout<<*h_time<<std::endl; 
    //std::cout<<(1<<10); 
    cudaFree(d_time); 
    free(h_time); 

} 

Answer 1

Starten von compute function 3.5, können Sie einen Teil der Cuda Runtime API in Kernen verwenden. Diese Verfahren sind als __host__ __device__ in der Dokumentation erklärt, wie here:

__host__ ​ __device__ ​cudaError_t cudaMalloc (void** devPtr, size_t size)

Weisen-Speicher auf dem Gerät.

Dabei erinnern an das Gerät-Laufzeitbibliothek zu verknüpfen: cudadevrt.lib.

Es gibt eine andere Möglichkeit, dynamisch Speicher auf dem Gerät zuzuweisen: die Verwendung von malloc, die anders implementiert ist (dokumentiert here). Es verwendet einen kleinen Speicher-Heap und benötigt nicht die gleiche Rechenleistung.