CUDA erklärt: Wie GPUs die KI-Entwicklung beschleunigen

Von Grafikberechnungen zum KI-Training: wie Nvidias Plattform funktioniert, ein lauffähiges Beispiel und eine Einordnung der Alternativen
Aktualisiert:
Abstract
- #CUDA
- #Parallelverarbeitung
- #GPUs
- #KI-Entwicklung
- #Nvidia
- #GPU-Computing
- #Deep Learning
- #Technologien
Warum fast jedes große KI-Modell auf Nvidia-Hardware trainiert wird und was Entwicklungsteams über CUDA wissen sollten, auch ohne es selbst zu programmieren
Wer heute ein großes Sprachmodell trainiert, tut das mit großer Wahrscheinlichkeit auf Grafikprozessoren von Nvidia. Das liegt nicht nur an der Hardware. Mindestens ebenso wichtig ist eine Software-Schicht, die Nvidia seit 2007 pflegt: CUDA. Sie erlaubt es, Grafikkarten für ganz normale Rechenaufgaben einzusetzen, und ist über die Jahre so tief in die KI-Werkzeuge eingewachsen, dass Konkurrenten bis heute damit kämpfen.
Die meisten Entwicklerinnen und Entwickler schreiben nie eine Zeile CUDA-Code. Sie nutzen es trotzdem, sobald PyTorch oder TensorFlow eine Rechnung auf die GPU schiebt. Wer versteht, was dabei passiert, kann Hardware besser auswählen, Engpässe erkennen und die Abhängigkeit von einem einzelnen Hersteller realistisch einschätzen.
Was CUDA ist und woher es kommt
CUDA steht für Compute Unified Device Architecture. Gemeint ist eine Plattform aus Programmiermodell, Compiler, Treibern und Bibliotheken, mit der sich Nvidia-GPUs für allgemeine Berechnungen programmieren lassen. Fachleute sprechen von GPGPU, General-Purpose Computing on Graphics Processing Units.
Nvidia stellte CUDA Ende 2006 vor, die erste öffentliche Version erschien 2007. Wesentlich daran beteiligt waren Ian Buck, der zuvor an der Stanford University mit der Sprache Brook an GPU-Programmierung geforscht hatte, und der GPU-Architekt John Nickolls. Vorher ließen sich Grafikkarten nur über Umwege für Berechnungen nutzen: Wissenschaftler tarnten ihre Daten als Texturen und ihre Rechnungen als Grafikeffekte. CUDA machte daraus eine Erweiterung von C und C++, die Programmierer ohne Grafikkenntnisse lernen konnten.
Heute umfasst CUDA weit mehr als die Sprache. Dazu gehören Bibliotheken für lineare Algebra (cuBLAS), für neuronale Netze (cuDNN), für die Kommunikation zwischen vielen GPUs (NCCL) und für die Ausführung trainierter Modelle (TensorRT). Gerade diese Bibliotheken machen den Vorsprung von Nvidia aus.
Warum GPUs so viel schneller rechnen können
Ein Prozessor (CPU) und ein Grafikprozessor (GPU) sind für unterschiedliche Aufgaben gebaut. Eine CPU hat relativ wenige, sehr leistungsfähige Kerne. Sie ist darauf ausgelegt, verzweigten Programmcode mit vielen Entscheidungen schnell abzuarbeiten, etwa ein Betriebssystem, einen Webserver oder eine Tabellenkalkulation.
Eine GPU verfolgt das gegenteilige Prinzip. Sie hat Tausende einfache Recheneinheiten, die dieselbe Operation gleichzeitig auf vielen Daten ausführen. Ursprünglich diente das der Grafik: Bei einem Bild in Full-HD müssen rund zwei Millionen Bildpunkte berechnet werden, viele Male pro Sekunde, und jeder Bildpunkt folgt denselben Formeln.
Ein Vergleich aus dem Büroalltag: Eine CPU gleicht einer kleinen Gruppe erfahrener Sachbearbeiter, die jeweils komplizierte Einzelfälle lösen. Eine GPU gleicht einem großen Saal voller Aushilfen, die alle dieselbe einfache Aufgabe erledigen, etwa Formulare auf Vollständigkeit prüfen. Bei 10.000 gleichartigen Formularen gewinnt der Saal, bei einem komplizierten Einzelfall die Sachbearbeiter.
Die Herstellerangaben zu Kernzahlen illustrieren den Unterschied, sind aber nicht direkt vergleichbar. Eine Desktop-CPU der Oberklasse hat 16 bis 24 Kerne. Eine Spiele-Grafikkarte wie die GeForce RTX 5090 hat laut Nvidia über 20.000 „CUDA-Kerne“. Ein CUDA-Kern ist aber eine viel einfachere Recheneinheit als ein CPU-Kern. Aussagekräftiger für KI sind die Rechenleistung in Gleitkommaoperationen pro Sekunde (FLOPS), die Größe des Grafikspeichers und dessen Bandbreite.
Das Programmiermodell: Kernel, Threads und Blöcke
CUDA-Programme bestehen aus zwei Teilen. Der Host-Code läuft auf der CPU und steuert den Ablauf. Der Device-Code läuft auf der GPU. Die Funktionen, die auf der GPU ausgeführt werden, heißen Kernel.
Ein Kernel wird nicht einmal, sondern tausend- oder millionenfach gleichzeitig gestartet. Jede dieser Instanzen heißt Thread und bearbeitet typischerweise ein einzelnes Datenelement. Threads werden in Blöcke gruppiert, Blöcke in ein Grid. Diese Hierarchie entspricht der Hardware: Ein Block läuft auf einem Streaming Multiprocessor, einer Gruppe von Recheneinheiten mit gemeinsamem schnellem Speicher. Threads innerhalb eines Blocks können über diesen Speicher Daten austauschen und sich synchronisieren.
Der typische Ablauf sieht so aus:
- Daten liegen im Hauptspeicher und werden in den Grafikspeicher kopiert, entweder ausdrücklich oder automatisch über Unified Memory, einen gemeinsamen Adressraum für CPU und GPU.
- Die CPU startet den Kernel mit einer bestimmten Zahl von Blöcken und Threads.
- Die GPU arbeitet alle Threads parallel ab.
- Die Ergebnisse gehen zurück in den Hauptspeicher.
Der Datentransport ist oft der Flaschenhals. Wer für jede kleine Rechnung Daten über den PCI-Express-Bus hin- und herschiebt, verliert den Geschwindigkeitsvorteil schnell wieder. Leistungsfähiger CUDA-Code hält die Daten deshalb so lange wie möglich auf der GPU.
Ein lauffähiges Beispiel: zwei Vektoren addieren
Das klassische Einstiegsbeispiel addiert zwei Zahlenreihen Element für Element. Auf der CPU wäre das eine Schleife, auf der GPU übernimmt jeder Thread ein Element:
// vektoren.cu
#include <cstdio>
#include <cuda_runtime.h>
// Kernel: läuft auf der GPU, jeder Thread addiert ein Element
__global__ void addVectors(const float *a, const float *b, float *c, int n) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < n) {
c[i] = a[i] + b[i];
}
}
int main() {
const int n = 1 << 20; // gut eine Million Elemente
float *a, *b, *c;
// Unified Memory: von CPU und GPU aus erreichbar
cudaMallocManaged(&a, n * sizeof(float));
cudaMallocManaged(&b, n * sizeof(float));
cudaMallocManaged(&c, n * sizeof(float));
for (int i = 0; i < n; ++i) {
a[i] = 1.0f;
b[i] = 2.0f;
}
const int threadsPerBlock = 256;
const int blocks = (n + threadsPerBlock - 1) / threadsPerBlock;
addVectors<<<blocks, threadsPerBlock>>>(a, b, c, n);
// Auf die GPU warten und Fehler abfragen
cudaError_t err = cudaGetLastError();
if (err == cudaSuccess) {
err = cudaDeviceSynchronize();
}
if (err != cudaSuccess) {
std::printf("CUDA-Fehler: %s\n", cudaGetErrorString(err));
return 1;
}
std::printf("c[0] = %.1f\n", c[0]); // erwartet: 3.0
cudaFree(a);
cudaFree(b);
cudaFree(c);
return 0;
}
Übersetzt wird das Programm mit dem Compiler nvcc aus dem CUDA Toolkit:
nvcc vektoren.cu -o vektoren
./vektoren
Die wichtigsten Stellen: __global__ markiert die Funktion als Kernel. Aus Blocknummer, Blockgröße und Threadnummer berechnet jeder Thread seinen eigenen Index i. Die Abfrage if (i < n) verhindert, dass überzählige Threads im letzten Block über das Ende der Daten hinaus schreiben. Die Syntax mit den dreifachen spitzen Klammern <<<blocks, threadsPerBlock>>> legt fest, wie viele Blöcke mit wie vielen Threads starten.
Für eine Vektoraddition lohnt sich die GPU in der Praxis kaum, weil das Kopieren der Daten länger dauert als die Rechnung. Spürbar wird der Vorteil bei rechenintensiven Operationen wie Matrixmultiplikationen, und genau aus solchen bestehen neuronale Netze.
Warum KI ohne GPUs kaum denkbar ist
Training und Ausführung neuronaler Netze bestehen zum größten Teil aus Matrixmultiplikationen: riesige Tabellen von Zahlen, die miteinander verrechnet werden. Das ist genau die Art gleichförmiger, massenhaft paralleler Arbeit, für die GPUs gebaut sind.
Ein Wendepunkt war 2012. Das neuronale Netz AlexNet gewann einen bekannten Bilderkennungswettbewerb mit deutlichem Abstand und wurde auf zwei Nvidia-Grafikkarten mit CUDA trainiert. Seitdem setzt praktisch die gesamte Deep-Learning-Forschung auf GPUs. Nvidia baute die Hardware gezielt dafür aus: Seit der Volta-Generation (2017) enthalten Rechenzentrums-GPUs spezielle Tensor Cores für Matrixrechnungen in geringer Genauigkeit. Es folgten Ampere (A100), Hopper (H100), Blackwell (B200) und Rubin (2026). Große Sprachmodelle werden heute auf Tausenden solcher GPUs gleichzeitig trainiert.
Im Alltag eines Entwicklungsteams taucht CUDA meist nur indirekt auf. PyTorch etwa erkennt eine Nvidia-GPU und nutzt sie mit einer Zeile:
import torch
device = "cuda" if torch.cuda.is_available() else "cpu"
a = torch.ones(1_000_000, device=device)
b = torch.full((1_000_000,), 2.0, device=device)
c = a + b # läuft auf der GPU, falls vorhanden
print(c[:3], c.device)
Dahinter ruft PyTorch optimierte CUDA-Kernel und Bibliotheken wie cuBLAS und cuDNN auf. Wer KI-Anwendungen entwickelt, muss deshalb selten eigene Kernel schreiben, sollte aber Treiberversionen, CUDA-Version und Framework-Version aufeinander abstimmen. Genau an dieser Stelle scheitern viele Installationen. Wie der Weg vom ersten Modell zur Produktionsanwendung aussieht, beschreibt unser Beitrag KI-Entwicklung für Einsteiger, Details zum Betrieb unser Infothek-Beitrag zum Deployment von PyTorch-Modellen.
Eine andere Abstraktionsebene wählt JAX: Es kompiliert NumPy-ähnlichen Python-Code über einen eigenen Compiler für GPU und TPU, ohne dass Entwickler mit CUDA in Berührung kommen. Was das in der Praxis bedeutet, erklärt unser Beitrag Von NumPy zu JAX.
Alternativen zu CUDA und die Frage der Abhängigkeit
CUDA läuft ausschließlich auf Nvidia-Hardware. Das ist der Kern der Kritik und der Grund, warum Wettbewerber eigene Plattformen anbieten:
| Plattform | Anbieter | Hardware | Einordnung |
|---|---|---|---|
| CUDA | Nvidia | nur Nvidia-GPUs | größtes Ökosystem, beste Unterstützung in KI-Frameworks |
| ROCm / HIP | AMD | AMD-GPUs | HIP ähnelt CUDA stark, Unterstützung in PyTorch wächst |
| oneAPI / SYCL | Intel, Khronos | verschiedene Hersteller | offener Standard auf Basis von C++, kleinere Verbreitung |
| OpenCL | Khronos | viele GPUs und Prozessoren | herstellerneutral, für KI kaum noch relevant |
| Metal | Apple | Apple-Chips | für Macs mit Apple-Prozessoren, von PyTorch unterstützt |
| Triton | OpenAI (Open Source) | Nvidia, AMD | Python-ähnliche Sprache für eigene Kernel, in PyTorch integriert |
Für Unternehmen ist die Frage weniger technisch als strategisch. Nvidia-GPUs sind teuer und waren zeitweise knapp. Wer ausschließlich über Frameworks wie PyTorch arbeitet, kann leichter auf andere Hardware ausweichen als ein Team mit viel eigenem CUDA-Code. Gleichzeitig ist die Unterstützung durch Bibliotheken, Werkzeuge und Dokumentation bei Nvidia nach wie vor am breitesten. Ein Wechsel kostet daher fast immer Testaufwand.
Was das für Ihr Team bedeutet
Für die meisten Entwicklungsteams ist CUDA eine Infrastrukturfrage, keine Programmiersprache, die man lernen muss. Wichtiger als eigene Kernel sind drei Entscheidungen. Erstens: Brauchen Sie überhaupt eigene GPUs? Für das Nutzen fertiger Sprachmodelle über eine API nicht. Für Training, Feinabstimmung oder den Betrieb eigener Modelle in der Regel schon. Zweitens: eigene Hardware oder GPUs in der Cloud? Cloud-Instanzen sind flexibel und ohne Vorabinvestition verfügbar, bei dauerhafter Auslastung kann eigene Hardware günstiger sein. Unser Seminar zu Cloud-Technologien und -Strategien hilft bei dieser Abwägung. Drittens: Wie stark binden Sie sich an Nvidia? Wer auf Framework-Ebene bleibt, behält Spielraum.
Eigene CUDA-Programmierung lohnt sich dort, wo Standardbibliotheken nicht ausreichen: in Simulationen, Bild- und Signalverarbeitung, Finanzmathematik oder bei sehr spezifischen KI-Operationen. Dann ist sie ein Spezialistenthema mit steiler Lernkurve, denn wirklich schneller Code erfordert Verständnis für Speicherhierarchie und Hardware. Überschätzt wird dagegen die Bedeutung der reinen Kernzahl auf dem Datenblatt. Für KI zählen vor allem Speichergröße, Speicherbandbreite und die Unterstützung durch die verwendeten Frameworks.
Bei Auswahl, Aufbau und Schulung rund um Machine Learning und KI-Infrastruktur unterstützen wir auf unserer Themenseite Maschinelles Lernen und Künstliche Intelligenz.
Häufige Fragen zu CUDA
Lässt sich CUDA ohne Nvidia-GPU nutzen?
Nicht direkt. CUDA ist an Nvidia-Hardware gebunden. Für AMD-GPUs gibt es mit HIP eine sehr ähnliche Schnittstelle, und Werkzeuge wie HIPIFY übersetzen CUDA-Code teilweise automatisch. Ohne GPU können Sie CUDA-Code zwar übersetzen, aber nicht ausführen. Zum Lernen eignen sich Cloud-Instanzen oder kostenlose Notebook-Dienste mit GPU.
Welche Sprachen unterstützt CUDA?
Im Kern C und C++. Für Python gibt es mehrere Wege: Nvidias eigene Python-Anbindung, Bibliotheken wie CuPy mit NumPy-ähnlicher Schnittstelle, Numba zum Übersetzen von Python-Funktionen in Kernel und Triton für eigene Kernel in Python-ähnlicher Syntax. Daneben existieren Anbindungen für Fortran, Julia und weitere Sprachen.
Ist CUDA-Programmierung schwer zu lernen?
Ein erstes Programm wie das obige ist mit C- oder C++-Kenntnissen schnell geschrieben. Schwierig wird es bei der Optimierung: gemeinsamer Speicher, Speicherzugriffsmuster, Synchronisation und das Zusammenspiel mehrerer GPUs erfordern Erfahrung. Werkzeuge wie Nsight Systems und Nsight Compute helfen, Engpässe zu finden.
Welche CUDA-Version ist die richtige?
Das hängt von GPU, Treiber und Framework ab. Neuere Toolkit-Versionen setzen einen ausreichend aktuellen Treiber voraus und unterstützen ältere GPU-Generationen irgendwann nicht mehr. Bei PyTorch ist die CUDA-Laufzeit in den offiziellen Paketen bereits enthalten, sodass meist nur ein passender Treiber installiert sein muss.
Kategorien
Schlagworte