# CUDA Cloud Installation: CUDA auf Ubuntu 24.04 installieren und Treiberkonflikte beheben

Bei einer CUDA-Cloud-Installation müssen drei Ebenen zusammenpassen: Das NVIDIA-Kernel-Modul verbindet die GPU mit dem Linux-Kernel, User-Mode-Treiber und Bibliotheken stellen Rechenfunktionen bereit, und der Compiler `nvcc` übersetzt CUDA-Code. Erst dieses Zusammenspiel abstrahiert die Cloud-Hardware zuverlässig und verhindert Versionsfehler bei Installation, Neustart und Betrieb.

## Wie der CUDA-Stack in einer Cloud-Instanz funktioniert

[CUDA](https://www.ionos.at/digitalguide/server/konfiguration/nvidia-cuda/) ist nicht nur ein einzelnes Programm. Der sogenannte CUDA-Stack besteht aus mehreren Komponenten, die unterschiedliche Aufgaben übernehmen:

<table>
  <thead>
    <tr>
      <th><strong>Komponente</strong></th>
      <th><strong>Aufgabe</strong></th>
      <th><strong>Prüfbefehl</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Linux-Kernel</td>
      <td>Verwaltet Hardware, Speicher und Prozesse der Instanz</td>
      <td>`uname -r`</td>
    </tr>
    <tr>
      <td>NVIDIA-Kernel-Modul</td>
      <td>Verbindet den Linux-Kernel mit der GPU</td>
      <td>`lsmod </td></tr><tr><td>NVIDIA-User-Mode-Treiber </td><td>Stellt Anwendungen den Zugriff auf die GPU bereit </td><td>`nvidia-smi`</td></tr><tr><td>CUDA Runtime und Bibliotheken </td><td>Enthalten Funktionen für GPU-Berechnungen </td><td>Paketprüfung mit `dpkg`</td></tr><tr><td>CUDA Toolkit </td><td>Enthält Entwicklungswerkzeuge und Bibliotheken </td><td>`nvcc --version`</td></tr><tr><td>`nvcc`</td><td>Übersetzt CUDA-Quellcode für die GPU </td><td>`nvcc --version`</td>
    </tr>
  </tbody>
</table>

## Besonderheit virtualisierter Cloud-GPUs

Bei einer [Cloud](https://www.ionos.at/digitalguide/server/knowhow/was-ist-eine-cloud/)-Instanz befindet sich die physische GPU **im Rechenzentrum des Cloud-Anbieters**. Je nach Angebot wird sie vollständig an Ihre [virtuelle Maschine](https://www.ionos.at/digitalguide/server/knowhow/virtuelle-maschinen/) durchgereicht oder über eine Virtualisierungsschicht bereitgestellt. Für Sie ist vor allem entscheidend, ob die GPU innerhalb der Instanz sichtbar ist:

```bash
lspci | grep -i nvidia
```

Erscheint keine NVIDIA-GPU, lässt sich das Problem nicht durch eine CUDA-Neuinstallation beheben. In diesem Fall wurde wahrscheinlich keine GPU an die Instanz angebunden, der falsche Instanztyp gewählt oder die GPU-Virtualisierung des Anbieters nicht korrekt eingerichtet.

Bei verwalteten vGPU-Angeboten sollten Sie außerdem **keine beliebige Treiberversion** installieren. Der Gasttreiber innerhalb der virtuellen Maschine muss gegebenenfalls zur vGPU-Infrastruktur des Cloud-Anbieters passen. Verwenden Sie dann bevorzugt das GPU-Image oder die Treiberanleitung des jeweiligen Anbieters.

## Welche CUDA-Version passt zu Hopper und Blackwell?

Für neue [Hopper](https://www.ionos.at/digitalguide/server/knowhow/hopper-gpu/)- oder [Blackwell](https://www.ionos.at/digitalguide/server/knowhow/nvidia-blackwell/)-Instanzen ist CUDA Toolkit 13.3 Update eine sinnvolle Standardwahl, sofern verwendete Frameworks und Anwendungen CUDA 13.3 bereits unterstützen.

Hopper-GPUs werden seit CUDA 11.8 nativ unterstützt. Die native Unterstützung für Blackwell beginnt mit CUDA 12.8. Ältere Anwendungen können auf neueren GPUs teilweise über mitgelieferten PTX-Code gestartet werden. Das ist jedoch **nicht mit nativer Unterstützung gleichzusetzen** und kann zusätzliche Startzeit oder Funktionseinschränkungen verursachen.

### Kompatibilitätsmatrix für CUDA, Treiber und GPU-Architektur

<table>
  <thead>
    <tr>
      <th><strong>CUDA Toolkit</strong></th>
      <th><strong>Minimaler Linux-Treiber</strong></th>
      <th><strong>Hopper</strong></th>
      <th><strong>Blackwell</strong></th>
      <th><strong>Einordnung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>CUDA 11.8 GA</td>
      <td>520.61.05</td>
      <td>Nativ unterstützt</td>
      <td>Nur über geeigneten PTX-Code</td>
      <td>Für ältere Hopper-Anwendungen</td>
    </tr>
    <tr>
      <td>CUDA 12.8 GA</td>
      <td>570.26</td>
      <td>Nativ unterstützt</td>
      <td>Nativ unterstützt</td>
      <td>Erste native Blackwell-Unterstützung</td>
    </tr>
    <tr>
      <td>CUDA 12.9 GA</td>
      <td>575.51.03</td>
      <td>Nativ unterstützt</td>
      <td>Nativ unterstützt</td>
      <td>Geeignet für bestehende CUDA-12-Umgebungen</td>
    </tr>
    <tr>
      <td>CUDA 13.0 GA</td>
      <td>580.65.06</td>
      <td>Nativ unterstützt</td>
      <td>Nativ unterstützt</td>
      <td>Erste CUDA-13-Hauptversion</td>
    </tr>
    <tr>
      <td>CUDA 13.1 GA</td>
      <td>590.44.01</td>
      <td>Nativ unterstützt</td>
      <td>Nativ unterstützt</td>
      <td>Neuere CUDA-13-Umgebung</td>
    </tr>
    <tr>
      <td>CUDA 13.2 Update 1</td>
      <td>595.58.03</td>
      <td>Nativ unterstützt</td>
      <td>Nativ unterstützt</td>
      <td>Vorgängerversion von CUDA 13.3</td>
    </tr>
    <tr>
      <td>CUDA 13.3 Update 1</td>
      <td>610.43.02</td>
      <td>Nativ unterstützt</td>
      <td>Nativ unterstützt</td>
      <td>Aktuelle Empfehlung</td>
    </tr>
  </tbody>
</table>

NVIDIA ermöglicht zusätzlich eine sogenannte **Minor Version Compatibility**. Dadurch können Anwendungen aus der CUDA-13-Familie unter bestimmten Voraussetzungen bereits mit einem Treiber ab Version 580 laufen. Für eine neue, möglichst leicht zu wartende Installation sollte jedoch die zur konkreten Toolkit-Version ausgewiesene Treiberversion verwendet werden.

## CUDA Install

### Schritt 1: Cloud-Instanz absichern

Erstellen Sie zunächst einen Snapshot oder ein Image der Instanz. Ein fehlerhaftes [Kernel](https://www.ionos.at/digitalguide/server/knowhow/was-ist-ein-kernel/)-Modul kann dazu führen, dass die GPU nach dem Neustart nicht mehr verfügbar ist. Bei einer reinen [SSH](https://www.ionos.at/digitalguide/server/tools/secure-shell-ssh/)-Instanz bleibt das Betriebssystem normalerweise erreichbar, dennoch vereinfacht ein Snapshot die Wiederherstellung erheblich.

Prüfen Sie außerdem, ob Ihr Cloud-Anbieter bereits ein **GPU-Image mit vorinstalliertem NVIDIA-Treiber** bereitstellt. Funktioniert `nvidia-smi` bereits, sollten Sie den Treiber nicht ohne konkreten Grund ersetzen. Häufig genügt es, lediglich das passende CUDA Toolkit zu ergänzen.

Die Anleitung setzt Folgendes voraus:

- [Ubuntu](https://www.ionos.at/digitalguide/server/knowhow/ubuntu-das-linux-system-fuer-jedermann/) 24.04 LTS oder 26.04 LTS
- angebundene NVIDIA-GPU
- User mit `sudo`-Rechten
- Internetverbindung
- x86\_64-Cloud-Instanz

Hinweis Ubuntu 24.04 wird in diesem Guide als Grundlage verwendet, weil es bereits länger in produktiven Cloud-Umgebungen eingesetzt wird und viele vorhandene GPU-Images, Automatisierungen und Serverkonfigurationen darauf aufbauen. Der CUDA-Install unter Ubuntu 26.04 funktioniert grundsätzlich ähnlich, in Schritt 6 müssen Sie allerdings ein anderes Repository verwenden.

## Schritt 2: Betriebssystem, Kernel und GPU prüfen

Zeigen Sie zunächst die Ubuntu-Version, den laufenden Kernel und die Prozessorarchitektur an:

```bash
hostnamectl
uname -r
uname -m
```

Für die folgende Anleitung sollte `uname -m` diese Ausgabe liefern:

```none
x86_64
```

Prüfen Sie anschließend, ob die NVIDIA-GPU von der virtuellen Maschine erkannt wird:

```bash
lspci | grep -i nvidia
```

Prüfen Sie danach, ob bereits ein Treiber installiert ist:

```bash
nvidia-smi
```

Zeigt `nvidia-smi` die GPU und eine Treiberversion ab 610.43.02, funktioniert der Treiber und Sie können **direkt mit Schritt 8 fortfahren**. Fehlermeldungen oder eine nicht erkannte GPU weisen dagegen auf fehlende Treiberwerkzeuge, ein defektes Kernel-Modul oder eine fehlerhafte GPU-Zuordnung hin.

### Schritt 3: Ubuntu aktualisieren und neu starten

Aktualisieren Sie zunächst das Betriebssystem:

```bash
sudo apt update
sudo apt full-upgrade -y
```

Starten Sie die Instanz anschließend neu:

```bash
sudo reboot
```

Melden Sie sich nach dem Neustart per SSH an und prüfen Sie den aktiven Kernel:

```bash
uname -r
```

### Schritt 4: Passende Kernel-Header installieren

Installieren Sie die Entwicklungswerkzeuge, DKMS und die Header des gegenwärtig laufenden Kernels:

```bash
sudo apt install -y \
    build-essential \
    dkms \
    wget \
    linux-headers-$(uname -r)
```

Der Ausdruck `$(uname -r)` wird automatisch durch die aktuelle Kernel-Version ersetzt.

Prüfen Sie anschließend, ob das Header-Verzeichnis vorhanden ist:

```bash
ls -ld /usr/src/linux-headers-$(uname -r)
```

Wird ein Verzeichnis angezeigt, passen Kernel und Header zusammen. Erscheint dagegen „No such file or directory“, sollte der NVIDIA-Treiber noch nicht installiert werden.

### Schritt 5: Vorhandene CUDA- und Treiberpakete untersuchen

Ermitteln Sie, welche NVIDIA- und CUDA-Pakete bereits installiert sind:

```bash
dpkg -l | grep -E 'nvidia|cuda'
```

Prüfen Sie außerdem die geladenen Kernel-Module:

```bash
lsmod | grep -E 'nvidia|nouveau'
```

Dabei sollten **nicht gleichzeitig** `nvidia` und `nouveau` für dieselbe GPU aktiv sein.

Kontrollieren Sie auch, ob eine frühere Runfile-Installation vorhanden ist:

```bash
ls -ld /usr/local/cuda*
```

Ein Verzeichnis wie `/usr/local/cuda-12.8` zeigt, dass bereits ein CUDA Toolkit installiert sein könnte, aber nicht, ob ein Konflikt besteht. Prüfen Sie deshalb, ob die Installation über APT oder eine `.run`-Datei erfolgte, und **entfernen Sie eine bestehende Runfile-Installation**, bevor Sie CUDA per APT installieren.

### Schritt 6: Offizielles NVIDIA-Repository einrichten

Wechseln Sie zunächst in ein temporäres Verzeichnis:

```bash
cd /tmp
```

Laden Sie das CUDA-Keyring-Paket für Ubuntu 24.04 herunter:

```bash
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
```

Installieren Sie den [Repository](https://www.ionos.at/digitalguide/server/knowhow/repository/)-Schlüssel:

```bash
sudo dpkg -i cuda-keyring_1.1-1_all.deb
```

Aktualisieren Sie anschließend die Paketinformationen:

```bash
sudo apt update
```

Das Keyring-Paket trägt den Signaturschlüssel und die Repository-Konfiguration in das System ein.

### Schritt 7: NVIDIA-Treiber installieren

Für Hopper- und Blackwell-GPUs verwenden Sie die NVIDIA-Kernel-Module, um passende Treiber zu installieren:

```bash
sudo apt install -y nvidia-open
```

Starten Sie die Instanz anschließend neu:

```bash
sudo reboot
```

Prüfen Sie nach dem Neustart den Treiber:

```bash
nvidia-smi
```

Zusätzlich können Sie kontrollieren, ob das Kernel-Modul geladen wurde:

```bash
lsmod | grep nvidia
```

Die genaue Version des geladenen Moduls lässt sich folgendermaßen anzeigen:

```bash
cat /proc/driver/nvidia/version
```

Zeigt `nvidia-smi` eine GPU und mindestens Treiberversion `610.43.02`, ist die Instanz für CUDA 13.3 Update 1 vorbereitet.

Hinweis Verwenden Sie bei einem vom Anbieter verwalteten vGPU-System den vom Anbieter freigegebenen Treiber. Ersetzen Sie diesen nicht allein deshalb, weil im NVIDIA-Repository eine neuere Version verfügbar ist.

### Schritt 8: CUDA Toolkit Install

Nun erfolgt der eigentliche CUDA Install:

```bash
sudo apt install -y cuda-toolkit-13-3
```

Die explizite Versionsnummer verhindert, dass die Installation später automatisch auf eine andere CUDA-Haupt- oder Nebenversion wechselt.

### Schritt 9: `nvcc` dauerhaft in den Suchpfad aufnehmen

Das Toolkit wird üblicherweise unter folgendem Pfad installiert:

```none
/usr/local/cuda-13.3
```

Erstellen Sie eine systemweite PATH-Konfiguration:

```bash
sudo tee /etc/profile.d/cuda.sh >/dev/null <<'EOF'
export PATH=/usr/local/cuda-13.3/bin${PATH:+:${PATH}}
EOF
```

Laden Sie die Einstellung für die aktuelle Sitzung:

```bash
source /etc/profile.d/cuda.sh
```

Prüfen Sie anschließend den CUDA-Compiler:

```bash
nvcc --version
```

Die Ausgabe sollte unter anderem CUDA 13.3 nennen. Bei einer APT-Installation müssen Sie die Umgebungsvariable `LD_LIBRARY_PATH` normalerweise nicht anpassen. Das ist nur bei Runfile-Installationen oder eigenen Installationspfaden nötig.

### Schritt 10: CUDA-Installation praktisch testen

Erstellen Sie ein kleines Testprogramm:

```bash
cat > cuda-check.cu <<'EOF'
#include <cuda_runtime.h>
#include <iostream>
int main() {
    int deviceCount = 0;
    cudaError_t result = cudaGetDeviceCount(&deviceCount);
    if (result != cudaSuccess) {
        std::cerr << "CUDA-Fehler: "
                  << cudaGetErrorString(result)
                  << std::endl;
        return 1;
    }
    std::cout << "Gefundene CUDA-GPUs: "
              << deviceCount
              << std::endl;
    for (int i = 0; i < deviceCount; i++) {
        cudaDeviceProp properties{};
        cudaGetDeviceProperties(&properties, i);
        std::cout << "GPU " << i << ": "
                  << properties.name
                  << std::endl;
    }
    return 0;
}
EOF
```

Übersetzen Sie das Programm mit `nvcc`:

```bash
nvcc cuda-check.cu -o cuda-check
```

Starten Sie den Test:

```bash
./cuda-check
```

Eine erfolgreiche Ausgabe sieht beispielsweise so aus:

```none
Gefundene CUDA-GPUs: 1
GPU 0: NVIDIA H100 80GB HBM3
```

Damit wurden alle wichtigen Ebenen geprüft:

- `nvcc` konnte den Quellcode übersetzen.
- Die CUDA Runtime wurde geladen.
- Der User-Mode-Treiber konnte den Kernel-Treiber ansprechen.
- Die GPU wurde innerhalb der Cloud-Instanz erkannt.

## Typische Probleme bei der CUDA-Installation beheben

Funktionieren `nvidia-smi` oder `nvcc` nach der Installation **nicht**, liegt die Ursache meistens bei den Kernel-Headern, einem konkurrierenden Treiber oder vermischten Installationsmethoden. Prüfen Sie die folgenden Punkte deshalb nacheinander.

### 1. Kernel und Kernel-Header vergleichen

Der NVIDIA-Treiber benötigt Header, die genau zum aktuell laufenden Linux-Kernel passen. Zeigen Sie zunächst die Kernel-Version an:

```bash
uname -r
```

Prüfen Sie anschließend, ob die passenden Header vorhanden sind:

```bash
ls -ld /usr/src/linux-headers-$(uname -r)
```

Fehlen sie, installieren Sie die benötigten Pakete:

```bash
sudo apt update
sudo apt install -y linux-headers-$(uname -r) dkms
```

Wurde kurz zuvor ein neuer Kernel installiert, **starten Sie die Instanz neu**. Andernfalls kann noch der alte Kernel laufen, während bereits die Header der neuen Version installiert sind:

```bash
sudo reboot
```

Besteht das Problem danach weiter, liefern diese Befehle zusätzliche Hinweise:

```bash
dkms status
sudo journalctl -k -b | grep -iE 'nvidia|nouveau|NVRM'
```

### 2. Konflikte mit dem Nouveau-Treiber beheben

Nouveau ist ein freier NVIDIA-Treiber, der in einigen Linux-Systemen automatisch geladen wird. Belegt er die GPU bereits, kann das offizielle NVIDIA-Modul nicht richtig starten.

Prüfen Sie, ob Nouveau aktiv ist:

```bash
lsmod | grep nouveau
```

Erscheint keine Ausgabe, ist Nouveau nicht geladen. Andernfalls können Sie sein automatisches Laden mit einer Sperrdatei verhindern:

```bash
sudo tee /etc/modprobe.d/blacklist-nouveau.conf >/dev/null <<'EOF'
blacklist nouveau
options nouveau modeset=0
EOF
```

Aktualisieren Sie danach das Startabbild des Kernels und starten Sie die Instanz neu:

```bash
sudo update-initramfs -u
sudo reboot
```

Prüfen Sie anschließend erneut:

```bash
lsmod | grep nouveau
```

Der Befehl sollte jetzt keine Ausgabe mehr liefern. Entfernen Sie dafür keine Linux-Kernelpakete: Nouveau muss normalerweise nur deaktiviert und nicht vollständig deinstalliert werden.

### 3. Runfile- und APT-Installationen nicht vermischen

CUDA kann entweder über die Ubuntu-Paketverwaltung oder über eine von NVIDIA heruntergeladene `.run`-Datei installiert werden. Werden beide Methoden vermischt, können unterschiedliche Treiber- und Bibliotheksversionen auf dem System verbleiben.

Prüfen Sie zunächst die installierten Pakete und CUDA-Verzeichnisse:

```bash
dpkg -l | grep -E 'nvidia|cuda'
ls -ld /usr/local/cuda*
```

Wurde CUDA mit einer Runfile installiert, verwenden Sie den dazugehörigen Uninstaller:

```bash
sudo /usr/local/cuda-13.3/bin/cuda-uninstaller
```

Passen Sie `13.3` an die tatsächlich installierte Version an. Einen ebenfalls per Runfile installierten NVIDIA-Treiber entfernen Sie mit:

```bash
sudo /usr/bin/nvidia-uninstall
```

APT-Pakete sollten dagegen auch über APT entfernt werden:

```bash
sudo apt --purge remove cuda-toolkit-13-3
sudo apt autoremove --purge
```

Löschen Sie Verzeichnisse wie `/usr/local/cuda-13.3` **nicht einfach manuell**. Andernfalls können Dateien verschwinden, obwohl die Paketverwaltung sie weiterhin als installiert führt.

Hinweis Installieren und aktualisieren Sie Treiber und CUDA Toolkit dauerhaft mit derselben Methode. Mischen Sie APT und Runfile nicht.

### 4. GPU-Persistenz aktivieren

Bei längeren Pausen ohne GPU-Auftrag kann der Treiber Teile des GPU-Zustands wieder freigeben. Beim nächsten CUDA-Aufruf muss die GPU dann **erneut initialisiert werden**, was kurze Verzögerungen verursachen kann.

Auf dauerhaft betriebenen Cloud-Instanzen lässt sich dafür der NVIDIA Persistence Daemon aktivieren:

```bash
sudo systemctl enable --now nvidia-persistenced.service
```

Prüfen Sie den Dienst:

```bash
systemctl is-active nvidia-persistenced.service
```

Bei erfolgreicher Aktivierung erscheint:

```bash
active
```

Aktivieren Sie anschließend den Persistence Mode:

```bash
sudo nvidia-smi -pm 1
```

Die Einstellung lässt sich so kontrollieren:

```bash
nvidia-smi -q | grep -i "Persistence Mode"
```

Bei kurzlebigen Instanzen sollte diese Konfiguration in einem Startskript oder im verwendeten Server-Image hinterlegt werden. Nach dem Löschen und vollständigen Neuerstellen einer Cloud-Instanz bleibt sie nicht automatisch erhalten.

### Häufige Fehlermeldungen im Überblick

<table>
  <thead>
    <tr>
      <th><strong>Fehlermeldung</strong></th>
      <th><strong>Wahrscheinliche Ursache</strong></th>
      <th><strong>Lösung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`nvidia-smi: command not found`</td>
      <td>NVIDIA-Treiberwerkzeuge fehlen</td>
      <td>Treiberpaket installieren</td>
    </tr>
    <tr>
      <td>`NVIDIA-SMI has failed`</td>
      <td>Kernel-Modul wurde nicht geladen</td>
      <td>Header, DKMS und Kernel-Protokoll prüfen</td>
    </tr>
    <tr>
      <td>`Driver/library version mismatch`</td>
      <td>Alte und neue Treiberbestandteile sind gleichzeitig aktiv</td>
      <td>Instanz neu starten und Paketversionen prüfen</td>
    </tr>
    <tr>
      <td>`nvcc: command not found`</td>
      <td>Toolkit fehlt oder ist nicht im Suchpfad</td>
      <td>Toolkit und `PATH` prüfen</td>
    </tr>
    <tr>
      <td>Keine NVIDIA-GPU in `lspci`</td>
      <td>GPU wurde der Instanz nicht zugewiesen</td>
      <td>Instanztyp und Cloud-Konfiguration prüfen</td>
    </tr>
    <tr>
      <td>`no kernel image is available`</td>
      <td>Anwendung unterstützt die GPU-Architektur nicht</td>
      <td>Anwendung für Hopper oder Blackwell neu kompilieren</td>
    </tr>
  </tbody>
</table>

Erscheint ein `Driver/library version mismatch`, starten Sie die Instanz zunächst neu. Häufig wurde bereits ein neuer Treiber installiert, während noch das alte Kernel-Modul geladen ist. Bleibt der Fehler bestehen, vergleichen Sie die installierten Komponenten:

```bash
cat /proc/driver/nvidia/version
modinfo nvidia | grep '^version'
dpkg -l | grep -E 'nvidia|cuda'
```

Wurden unterschiedliche Installationsmethoden oder Treiberserien verwendet, entfernen Sie die alte Installation und richten Sie den Treiber anschließend einheitlich über APT ein.

## Fazit

Ein stabiler CUDA-Cloud-Install hängt weniger von einem einzelnen Installationsbefehl als von der **Abstimmung der beteiligten Komponenten** ab. Der laufende Linux-Kernel benötigt passende Header, das NVIDIA-Kernel-Modul muss erfolgreich geladen werden und der User-Mode-Treiber muss zur installierten Treiberserie gehören. Die Installation über das offizielle NVIDIA-APT-Repository ist dabei die nachvollziehbarste Lösung. So entsteht ein wartbarer CUDA-Stack für Hopper- und Blackwell-Instanzen.


This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/cuda-installation-ubuntu-2404/](https://www.ionos.at/digitalguide/server/konfiguration/cuda-installation-ubuntu-2404/) for AI/LLM consumption.