Verwendung von cudamalloc(). Warum der Doppelzeiger?

Ich gehe gerade die Tutorial-Beispiele durch http://code.google.com/p/stanford-cs193g-sp2010/ CUDA zu lernen. Der Code, der demonstriert __global__ Funktionen ist unten angegeben. Es erstellt einfach zwei Arrays, eines auf der CPU und eines auf der GPU, füllt das GPU-Array mit der Nummer 7 und kopiert die GPU-Array-Daten in das CPU-Array.

#include <stdlib.h>
#include <stdio.h>

__global__ void kernel(int *array)
{
  int index = blockIdx.x * blockDim.x + threadIdx.x;

  array[index] = 7;
}

int main(void)
{
  int num_elements = 256;

  int num_bytes = num_elements * sizeof(int);

  // pointers to host & device arrays
  int *device_array = 0;
  int *host_array = 0;

  // malloc a host array
  host_array = (int*)malloc(num_bytes);

  // cudaMalloc a device array
  cudaMalloc((void**)&device_array, num_bytes);

  int block_size = 128;
  int grid_size = num_elements / block_size;

  kernel<<<grid_size,block_size>>>(device_array);

  // download and inspect the result on the host:
  cudaMemcpy(host_array, device_array, num_bytes, cudaMemcpyDeviceToHost);

  // print out the result element by element
  for(int i=0; i < num_elements; ++i)
  {
    printf("%d ", host_array[i]);
  }

  // deallocate memory
  free(host_array);
  cudaFree(device_array);
} 

Meine Frage ist, warum sie das formuliert haben cudaMalloc((void**)&device_array, num_bytes); Anweisung mit einem Doppelzeiger? Eben hier Die Definition von cudamalloc() besagt, dass das erste Argument ein Doppelzeiger ist.

Warum nicht einfach einen Zeiger auf den Anfang des zugewiesenen Speichers auf der GPU zurückgeben, genau wie die malloc funktioniert auf der CPU?

Alle CUDA-API-Funktionen geben einen Fehlercode zurück (oder cudaSuccess, wenn kein Fehler aufgetreten ist). Alle anderen Parameter werden per Referenz übergeben. In Plain C können Sie jedoch keine Referenzen haben, deshalb müssen Sie eine Adresse der Variablen übergeben, in der die Rückgabeinformationen gespeichert werden sollen. Da Sie einen Zeiger zurückgeben, müssen Sie einen Doppelzeiger übergeben.

Eine weitere bekannte Funktion, die aus demselben Grund auf Adressen angewendet wird, ist die scanf Funktion. Wie oft hast du vergessen, das zu schreiben & vor der Variable, in der Sie den Wert speichern möchten? 😉

int i;
scanf("%d",&i);

Das ist einfach ein schreckliches, schreckliches API-Design. Das Problem beim Übergeben von Doppelzeigern für eine Zuordnungsfunktion, die abstrakte (void *) Speicher ist, dass Sie eine temporäre Variable vom Typ erstellen müssen void * um das Ergebnis zu halten, weisen Sie es dann dem echten Zeiger des richtigen Typs zu, den Sie verwenden möchten. Gießen, wie in (void**)&device_array, ist ungültiges C und führt zu undefiniertem Verhalten. Sie sollten einfach eine Wrapper-Funktion schreiben, die sich normal verhält malloc und gibt einen Zeiger zurück, wie in:

void *fixed_cudaMalloc(size_t len)
{
    void *p;
    if (cudaMalloc(&p, len) == success_code) return p;
    return 0;
}

In C/C++ können Sie einen Speicherblock zur Laufzeit dynamisch zuweisen, indem Sie die aufrufen malloc Funktion.

int * h_array;
h_array = malloc(sizeof(int));

Das malloc Die Funktion gibt die Adresse des zugewiesenen Speicherblocks zurück, die in einer Variablen oder einer Art Zeiger gespeichert werden kann.
Die Speicherzuweisung in CUDA ist in zweierlei Hinsicht etwas anders:

1. Das cudamalloc statt eines Zeigers auf den Speicherblock eine ganze Zahl als Fehlercode zurückgeben.

2. Neben der zuzuweisenden Bytegröße cudamalloc erfordert außerdem einen doppelten void-Zeiger als ersten Parameter.

   int * d_array
cudamalloc((void **) &d_array, sizeof(int))

Der Grund für den ersten Unterschied ist, dass alle CUDA-API-Funktionen der Konvention folgen, einen ganzzahligen Fehlercode zurückzugeben. Um die Dinge konsistent zu machen, cudamalloc Die API gibt auch eine ganze Zahl zurück.

Die Anforderungen für einen Doppelzeiger als erstes Funktionsargument können in zwei Schritten verstanden werden.

Erstens, da wir bereits entschieden haben, dass cudamalloc einen ganzzahligen Wert zurückgeben soll, können wir es nicht mehr verwenden, um die Adresse des zugewiesenen Speichers zurückzugeben. In C besteht die einzige andere Kommunikationsmöglichkeit für eine Funktion darin, den Zeiger oder die Adresse an die Funktion zu übergeben. Die Funktion kann Änderungen an dem Wert vornehmen, der an der Adresse gespeichert ist, oder an der Adresse, auf die der Zeiger zeigt. Die Änderungen an diesen Werten können später außerhalb des Funktionsbereichs abgerufen werden, indem dieselbe Speicheradresse verwendet wird.

wie der Doppelzeiger funktioniert

Das folgende Diagramm veranschaulicht, wie es mit dem Doppelzeiger funktioniert.

int cudamalloc((void **) &d_array, int type_size) {
  *d_array = malloc(type_size);
  return return_code;
}

Wozu brauchen wir den Doppelzeiger? Warum das funktioniert

Ich lebe normalerweise in der Python-Welt, also hatte ich auch Mühe zu verstehen, warum dies nicht funktionieren wird.

int cudamalloc((void *) d_array, int type_size) {
  d_array = malloc(type_size);
  ...
  return error_status;
}

Warum funktioniert es also nicht? Denn in C, wann cudamalloc aufgerufen wird, wird eine lokale Variable namens d_array erstellt und ihr der Wert des ersten Funktionsarguments zugewiesen. Es gibt keine Möglichkeit, den Wert in dieser lokalen Variablen außerhalb des Gültigkeitsbereichs der Funktion abzurufen. Deshalb brauchen wir hier einen Zeiger auf einen Zeiger.

int cudamalloc((void *) d_array, int type_size) {
  *d_array = malloc(type_size);
  ...
  return return_code;
}

Wir wandeln es in einen Doppelzeiger um, weil es ein Zeiger auf den Zeiger ist. Es muss auf einen Zeiger des GPU-Speichers zeigen. Was cudaMalloc() macht, ist, dass es einen Speicherzeiger (mit Platz) auf der GPU zuweist, auf den dann das erste Argument zeigt, das wir geben.

Das Problem: Sie müssen zwei Werte zurückgeben: Returncode UND Zeiger auf Speicher (falls Returncode Erfolg anzeigt). Sie müssen also einen davon zu einem Zeiger machen, um den Typ zurückzugeben. Und als Rückgabetyp haben Sie die Wahl zwischen Rückgabezeiger auf int (für Fehlercode) oder Rückgabezeiger auf Zeiger (für Speicheradresse). Da ist eine Lösung so gut wie die andere (und eine davon ergibt den Zeiger auf den Zeiger (ich ziehe es vor, diesen Begriff anstelle von zu verwenden Doppelzeigerda dies eher wie ein Zeiger auf eine doppelte Gleitkommazahl klingt)).

In malloc haben Sie die nette Eigenschaft, dass Sie Nullzeiger haben können, um einen Fehler anzuzeigen, sodass Sie im Grunde nur einen Rückgabewert benötigen. Ich bin mir nicht sicher, ob dies mit einem Zeiger auf den Gerätespeicher möglich ist, da dies möglicherweise der Fall ist kein oder ein falscher Nullwert (zur Erinnerung: Das ist CUDA und NICHT Ansi C). Es könnte sein, dass der Null-Zeiger auf dem Hostsystem völlig anders ist als die für das Gerät verwendete Null, und daher funktioniert die Rückgabe des Null-Zeigers zur Anzeige von Fehlern nicht, und Sie müssen die API so gestalten (das würde auch bedeuten dass Sie auf beiden Geräten KEINE gemeinsame NULL haben).