Kategorie: GPU

CUDA Speicher-Verwaltung

Über Pointers kann von einem Speicher (CPU), auf den anderen (GPU) zugewiesen werden.

  • Device-Pointer zeigen auf Speicher im GPU
    – Kann im host-code gebraucht, aber nicht dereferenziert werden
  • Host-Pointer zeigen auf den Speicher der CPU. Kann vom GPU Code gebraucht, aber nicht dereferenziert werden.

    Funktionen
    cudaMalloc( Wert, Grösse);
    cudaFree();
    cudaMemcpy();

Bsp. aus der Einführung

int main( void ) {
int a, b, c;                  // host: a, b, c
int*dev_a, *dev_b, *dev_c;    // device copies of a, b, c
intsize =sizeof(int);         

// allocate device copies of a, b, c
cudaMalloc( (void**)&dev_a, size );
cudaMalloc( (void**)&dev_b, size );
cudaMalloc( (void**)&dev_c, size );

a = 2;
b = 7;

// copy inputs to device
cudaMemcpy(dev_a, &a, size,cudaMemcpyHostToDevice);
cudaMemcpy(dev_b, &b, size,cudaMemcpyHostToDevice);

// launch add() kernel on GPU, passing parameters
add<<< 1, 1 >>>(dev_a,dev_b,dev_c);

// copy device result back to host copy of c
cudaMemcpy( &c,dev_c, size,cudaMemcpyDeviceToHost);

cudaFree(dev_a);
cudaFree(dev_b);
cudaFree(dev_c);
return 0;
}

 

CUDA Introduction: Sprache

Cuda ist von Nvidia eine Sprache wie auch Architektur zur GPU-Verarbeitung. Die Sprache wird im Buch CUDA_by_Example. ausführlich beschrieben. Einen ersten Üblick gibt folgender Vortrag, der vom Autor desselben Buches ebd. über Cuda_Introduction gegeben wurde.

Kompiler
nvcc

Trennung: Ablage in GPU – CPU
Der nvcc-Kompiler trennt den Code in CPU-Speicher und GPU-Speicher.
– Device-Funktionen werden im kernel()  bearbeitet und im GPU-Speicher abgelegt.
– Normale Funktionen werden im der CPU (host) im main()  bearbeitet und ihre Variablen liegen im Speicher der CPU. Kompiliert wird mit  gcc.

int main( void) {
    kernel <<< 1, 1 >>> ();
    printf("hallo \n");
    return 0;
}


Von CPU auf GPU
__global__ :             cuda Schlüssewort für Funktionen die auf GPU laufen,
.                                    Diese Funktionen müssen  von CPU – im main() – aufgerufen
.                                    werden
<funktion> <<< :     Befehl zum Ausführen der Funktion auf der GPU
>>> <parameter> :   Mitgabe der Argumente für die GPU-Funktion.

Bsp.

__global__ void kernel( void ) { 
} 

__global__ void add (int *a, int *b, int *c)
{
 *c = *a + *b;
}

Dies funktioniert nur, wenn man im main() die Funktion auf die GPU verschiebt.

int main( void) {
    int a, b, c;
    int *dev_a, *dev_b, *dev_c;

    // Funktion auf GPU   // Argumente mitgeben
    add <<< 1, 1 >>> (dev_a, dev_b, dev_c);
    printf("hallo \n");
    return 0;
}

CPU (host) ruft GPU (device) auf. Ist notwendig, um eine Funktion auf der GPU aufzurufen.

GPU Introduction

GPU ist ein Grafikprozessor. Also ein Prozessor, mit spezifischem Profil. Hersteller sind Intel, AMD und Nvidia.

CPU <-> GPU
Wird von einem Host gesprochen, meint man damit die CPU (inkl. Memory). Ein C-Programm läuft auf dem Host.

Cuda <-> Metal
Cuda ist das Framework und die Sprache von Nvidio. Will man eine GPU für ein iOS konfigurieren, so braucht man metal als Framework und swift als Sprache.