Rilevamento se un puntatore punta nel dispositivo o nell'host in CUDA

Question

In CUDA esiste un modo per sapere se il puntatore punta in memoria sul dispositivo o sull'host.

Un fatto op esempio di questo potrebbe essere:

int *dev_c, *host_c; 
cudaMalloc((void**)&dev_c, sizeof(int)); 
host_c = (int*) malloc(sizeof(int)); 

posso ovviamente guardare il nome, ma ci sono un modo di guardare ad del dev_c puntatore e host_c e dicendo, punti host_c annuncio l'host e dev_c indica il dispositivo.

Answer 1

Non credo sia possibile. Il puntatore indica alcuni indirizzi in memoria e ora non lo è se si tratta di memoria host o dispositivo. All'avvio del programma, è possibile inserire (quasi) tutti gli indirizzi in memoria del sistema operativo in modo da non provare a indovinare. Dovresti notare i nomi delle variabili.

Answer 2

Non direttamente. Un approccio sarebbe quello di scrivere una classe incapsulante per i puntatori di dispositivo in modo che sia assolutamente chiaro che i puntatori di dispositivo e host sono diversi nel codice. È possibile visualizzare un modello di questa idea nella libreria modello Thrust, che ha un tipo chiamato device_ptr per delineare chiaramente i tipi di puntatori di dispositivo e host.

Answer 3

Avvio (credo) GPU CUDA 4 e Fermi. Nvidia supporta UVA (Unified Virtual Address Space). La funzione cudaPointerGetAttributes sembra fare esattamente quello che stai chiedendo. Nota che credo funzioni solo per i puntatori host assegnati con cudaHostAlloc (e non con c malloc).

Answer 4

Questo è un piccolo esempio che mostra come Unified Virtual Addressing può essere utilizzato per rilevare se un puntatore punta allo spazio di memoria dell'host o del dispositivo. Come ha sottolineato @PrzemyslawZych, funziona solo per i puntatori host assegnati con cudaMallocHost.

#include<stdio.h> 

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

#include<assert.h> 
#include<conio.h> 

#define gpuErrchk(ans) { gpuAssert((ans), __FILE__, __LINE__); } 
inline void gpuAssert(cudaError_t code, char *file, int line, bool abort=true) 
{ 
    if (code != cudaSuccess) 
    { 
     fprintf(stderr,"GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line); 
     getch(); 
     if (abort) { exit(code); getch(); } 
    } 
} 

int main() { 

    int* d_data; 
    int* data; // = (int*)malloc(16*sizeof(int)); 
    cudaMallocHost((void **)&data,16*sizeof(int)); 

    gpuErrchk(cudaMalloc((void**)&d_data,16*sizeof(int))); 

    cudaDeviceProp prop; 
    gpuErrchk(cudaGetDeviceProperties(&prop,0)); 

    printf("Unified Virtual Addressing %i\n",prop.unifiedAddressing); 

    cudaPointerAttributes attributes; 
    gpuErrchk(cudaPointerGetAttributes (&attributes,d_data)); 
    printf("Memory type for d_data %i\n",attributes.memoryType); 
    gpuErrchk(cudaPointerGetAttributes (&attributes,data)); 
    printf("Memory type for data %i\n",attributes.memoryType); 

    getch(); 

    return 0; 
}