Differenza tra funzioni globali e dispositivo

Qualcuno può descrivere le differenze tra __global__e __device__?

Quando dovrei usare __device__e quando usarlo __global__?.

Le funzioni globali sono anche chiamate "kernel". Sono le funzioni che puoi chiamare dal lato host usando semantics ( <<<...>>>) della chiamata del kernel CUDA .

Le funzioni del dispositivo possono essere chiamate solo da altri dispositivi o funzioni globali. __device__le funzioni non possono essere chiamate dal codice host.

Le differenze tra __device__e le __global__funzioni sono:

__device__ le funzioni possono essere chiamate solo dal dispositivo e vengono eseguite solo nel dispositivo.

__global__ le funzioni possono essere chiamate dall'host e vengono eseguite nel dispositivo.

Pertanto, chiamate le __device__funzioni dalle funzioni del kernel e non dovete impostare le impostazioni del kernel. Puoi anche "sovraccaricare" una funzione, ad esempio: puoi dichiarare void foo(void)e __device__ foo (void), quindi una viene eseguita sull'host e può essere chiamata solo da una funzione host. L'altro viene eseguito sul dispositivo e può essere chiamato solo da un dispositivo o da una funzione del kernel.

Puoi anche visitare il seguente link: http://code.google.com/p/stanford-cs193g-sp2010/wiki/TutorialDeviceFunctions , è stato utile per me.

1. __global__- Funziona sulla GPU, chiamata dalla CPU o dalla GPU *. Eseguito con <<<dim3>>>argomenti.
2. __device__- Funziona sulla GPU, chiamata dalla GPU. Può essere utilizzato anche con variabili.
3. __host__ - Funziona sulla CPU, chiamata dalla CPU.

*) le __global__funzioni possono essere chiamate da altre __global__funzioni a partire dalla
capacità di calcolo 3.5.

Lo spiegherò con un esempio:

main()
{
    // Your main function. Executed by CPU
}

__global__ void calledFromCpuForGPU(...)
{
  //This function is called by CPU and suppose to be executed on GPU
}

__device__ void calledFromGPUforGPU(...)
{
  // This function is called by GPU and suppose to be executed on GPU
}

cioè, quando vogliamo che una funzione host (CPU) chiami una funzione dispositivo (GPU), viene utilizzato " globale ". Leggi questo: " https://code.google.com/p/stanford-cs193g-sp2010/wiki/TutorialGlobalFunctions "

E quando vogliamo che una funzione del dispositivo (GPU) (piuttosto che il kernel) chiami un'altra funzione del kernel, usiamo " dispositivo ". Leggi questo " https://code.google.com/p/stanford-cs193g-sp2010/wiki/TutorialDeviceFunctions "

Questo dovrebbe essere sufficiente per capire la differenza.

__global__è per i kernel cuda, funzioni che possono essere richiamate direttamente dall'host. __device__le funzioni possono essere chiamate da __global__e __device__functions ma non dall'host.

Sto registrando alcune speculazioni infondate qui per il momento (le confermerò più tardi quando mi imbatterò in una fonte autorevole) ...

1. __device__le funzioni possono avere un tipo di ritorno diverso da void ma le __global__funzioni devono sempre restituire void.

2. __global__le funzioni possono essere chiamate dall'interno di altri kernel in esecuzione sulla GPU per avviare thread GPU aggiuntivi (come parte del modello di parallelismo dinamico CUDA (noto anche come CNP)) mentre le __device__funzioni vengono eseguite sullo stesso thread del kernel chiamante.

__global__funzione è la definizione di kernel. Ogni volta che viene chiamato dalla CPU, quel kernel viene avviato sulla GPU.

Tuttavia, ogni thread che esegue quel kernel, potrebbe richiedere di eseguire del codice ancora e ancora, ad esempio lo scambio di due numeri interi. Quindi, qui possiamo scrivere una funzione di supporto, proprio come facciamo in un programma C. E per i thread in esecuzione su GPU, una funzione di supporto dovrebbe essere dichiarata come __device__.

Pertanto, una funzione dispositivo viene chiamata dai thread di un kernel: un'istanza per un thread. Mentre, una funzione globale viene chiamata dal thread della CPU.

__global__ è una parola chiave CUDA C (specificatore di dichiarazione) che dice che la funzione,

1. Esegue sul dispositivo (GPU)
2. Chiamate dal codice host (CPU).

funzioni globali (kernel) avviate dal codice host utilizzando <<< no_of_blocks , no_of threads_per_block>>>. Ogni thread esegue il kernel in base al suo ID thread univoco.

Tuttavia, le __device__funzioni non possono essere chiamate dal codice host. Se è necessario, utilizzare entrambe __host__ __device__.

La funzione globale può essere chiamata solo dall'host e non hanno un tipo di ritorno mentre la funzione dispositivo può essere chiamata solo dalla funzione kernel di un'altra funzione dispositivo quindi non richiede l'impostazione del kernel