Wie kann man feststellen, ob Nvidia-GPU-Kerne 32/64 Bit-Prozessoren sind?

Question

Gibt es einen Linux/Windows-Befehl, der den Typ des Prozessors in einer Nvidia-GPU anzeigt? Ich spreche nicht über das Betriebssystem noch über den CPU-Typ. Ich frage nach den Prozessoren (Kernen) in der GPU selbst. Am Ende des Tages sind sie Prozessoren. Wie erkennt man, ob sie 32/64-Bit-Register und 32/64-Bit-ALUs haben? Eine weitere Frage, die damit zusammenhängt, sind 64-Bit-Anweisungen, wie das Hinzufügen von zwei (unsigned long int) -Zahlen, emuliert mit 32-Bit-Anweisungen, durch den Compiler oder was auch immer Zwischenprodukt, oder sie werden nativ ausgeführt von der Hardware?

Diese Frage ist nicht ganz ähnlich zu this, ich brauche eine Möglichkeit zu sagen, welche Art von Maschine ist die GPU selbst. Die Antwort auf diese Frage zeigt auch nicht, wie 64-Bit-Anweisungen speziell ausgeführt werden.

Answer 1

Ich habe zwei einfache Kernel codiert. Jeder fügt zwei Vektoren vom Typ int (32-Bit)/long int (64-Bit) hinzu. Es stellt sich heraus auf meiner GPU (Tesla K80), die ziemlich neu und gut ist, die Kerne sind nur 32-Bit.

Die Zeit verdoppelt sich ungefähr, wenn die Vektorgröße zunimmt.

Die Kerne sind wie folgt:

__global__ void add_32(int * c, int * a, int * b) 
{ 
    int gid = blockIdx.x * blockDim.x + threadIdx.x; 
    c[gid] = a[gid] + b[gid]; 
} 

typedef long int int64; 

__global__ void add_64(int64 * c, int64 * a, int64 * b) 
{ 
    int gid = blockIdx.x * blockDim.x + threadIdx.x; 
    c[gid] = a[gid] + b[gid]; 
} 

Wenn Vektorgröße 1 Mega-Element, add_32 dauert etwa 102,911 microsec, während add_64 nimmt 192,669 microsec. (Ausführungszeiten wurden unter Verwendung des Nvidia-Profilers beim Ausführen der Binärdatei im Veröffentlichungsmodus gemeldet).

Es scheint, dass 64-Bit-Befehle nur über 32-Bit-Befehle emuliert werden!

Dies könnte eine Brute-Force-Lösung sein, um herauszufinden, welche Art von Maschinen die GPU-Kerne sind, aber definitiv keine elegante.

Update:

Dank @ Paul A. Clayton Kommentar, so scheint es, dass die Lösung über keinen fairen Vergleich ist die Datengröße in dem Fall 64-Bit verdoppelt. Daher sollten wir nicht beide Kernel mit der gleichen Anzahl von Elementen starten. Das korrekte Prinzip wäre, die 64-Bit-Version mit der halben Anzahl von Elementen zu starten.

Um noch sicherer zu sein, betrachten wir die elementweise Vektormultiplikation anstelle der Addition. Wenn die GPU 64-Bit-Befehle über 32-Bit-Befehle emuliert, benötigt sie mindestens 3 32-Bit-Multiplikationsbefehle, um 2 64-Bit-Zahlen zu multiplizieren, beispielsweise unter Verwendung des Karatsuba-Algorithmus. Dies impliziert, dass wenn wir den 64-Bit-Vektor-Multiplikationskern mit N/2 Elementen starten würden, würde es länger dauern als der 32-Bit-Kern mit N Elementen, wenn 64-Bit-Multiplikationen gerade emuliert würden.

Hier sind die Kerne:

__global__ void mul_32(int * c, int * a, int * b) 
{ 
    int gid = blockIdx.x * blockDim.x + threadIdx.x; 
    c[gid] = a[gid] * b[gid]; 
} 

typedef long int int64; 

__global__ void mul_64(int64 * c, int64 * a, int64 * b) 
{ 
    int gid = blockIdx.x * blockDim.x + threadIdx.x; 
    c[gid] = a[gid] * b[gid]; 
} 

Und hier sind die Details Experiment: Zeiten hier gemeldet sind von nvidia-Profiler auf Release-Modus binary: 1- Kernel mul_32 mit Vektorgröße N = 256 Mega-Elemente , dauert 25.608 Millisekunden. 2- Kernel mul_64 mit Vektorgröße N = 128 Mega-Elemente, dauert 24.153 Millisekunden.

Ich bin mir bewusst, dass beide Kernel falsche Ergebnisse produzieren, aber ich denke, das hat nichts mit der Art und Weise zu tun, wie die Berechnung durchgeführt wird.