"""GPU-, CUDA- und CTranslate2-Diagnose. Die GTX 1070 Ti ist eine Pascal-Karte (Compute Capability 6.1). Sie besitzt keine FP16-Tensor-Cores. Deshalb wird FP16/BF16 hier grundsaetzlich nicht als GPU-Rechenmodus vorausgesetzt; bevorzugt wird ``int8_float32``. """ from __future__ import annotations import ctypes.util import glob import os import re import subprocess from dataclasses import dataclass, field from pathlib import Path from ..utils.logging import get_logger logger = get_logger("system.gpu") # Pascal und aelter: kein FP16-Tensor-Betrieb auf Consumer-Karten. PASCAL_CONSUMER_MAX_CC = 6.2 PREFERRED_COMPUTE_TYPE = "int8_float32" FORBIDDEN_GPU_COMPUTE_TYPES = ("float16", "bfloat16", "int8_bfloat16", "int8_float16") @dataclass class GpuInfo: """Angaben aus ``nvidia-smi``.""" name: str driver_version: str | None = None cuda_driver_version: str | None = None memory_total_mb: int | None = None compute_capability: str | None = None @dataclass class RuntimeInfo: """Laufzeitinformationen zu CTranslate2, CUDA und SQLite.""" ctranslate2_version: str | None = None cuda_device_count: int = 0 supported_compute_types: dict[str, list[str]] = field(default_factory=dict) cuda_libraries: list[str] = field(default_factory=list) cudnn_libraries: list[str] = field(default_factory=list) python_version: str = "" platform: str = "" sqlite_version: str = "" fts5_available: bool = False trigram_available: bool = False @property def cuda_runtime_usable(self) -> bool: return self.cuda_device_count > 0 and bool(self.supported_compute_types.get("cuda")) @property def cuda_compute_types(self) -> list[str]: return sorted(self.supported_compute_types.get("cuda", [])) @property def cpu_compute_types(self) -> list[str]: return sorted(self.supported_compute_types.get("cpu", [])) @dataclass class ResolvedExecution: """Tatsaechlich verwendeter Ausfuehrungsmodus.""" device: str compute_type: str requested_device: str requested_compute_type: str notes: list[str] = field(default_factory=list) @property def used_fallback(self) -> bool: return self.device != self.requested_device or self.compute_type != self.requested_compute_type def _run_nvidia_smi(args: list[str]) -> str | None: try: completed = subprocess.run( ["nvidia-smi", *args], capture_output=True, text=True, timeout=15, check=False, ) except (OSError, subprocess.SubprocessError) as exc: logger.debug("nvidia-smi nicht ausfuehrbar: %s", exc) return None if completed.returncode != 0: return None return completed.stdout def detect_gpu() -> GpuInfo | None: """Ermittelt GPU-Modell, Treiber und Compute Capability.""" output = _run_nvidia_smi( [ "--query-gpu=name,driver_version,memory.total,compute_cap", "--format=csv,noheader", ] ) gpu: GpuInfo | None = None if output: first_line = output.strip().splitlines()[0] if output.strip() else "" parts = [part.strip() for part in first_line.split(",")] if len(parts) >= 4: memory_mb = None match = re.search(r"(\d+)", parts[2]) if match: memory_mb = int(match.group(1)) gpu = GpuInfo( name=parts[0], driver_version=parts[1] or None, memory_total_mb=memory_mb, compute_capability=parts[3] or None, ) if gpu is None: return None header = _run_nvidia_smi([]) or "" match = re.search(r"CUDA Version:\s*([0-9.]+)", header) if match: gpu.cuda_driver_version = match.group(1) return gpu _PRELOADED_LIBRARIES: list[str] = [] def ensure_cuda_libraries() -> list[str]: """Laedt CUDA-/cuDNN-Bibliotheken aus den pip-``nvidia``-Paketen. CTranslate2 linkt dynamisch gegen ``libcublas.so.12`` und ``libcudnn.so.9``. Die PyPI-Wheels legen diese Bibliotheken unter ``site-packages/nvidia`` ab, wo der dynamische Linker sie nicht von allein findet. Ein Preload mit ``RTLD_GLOBAL`` macht sie verfuegbar, ohne systemweite Aenderungen an ``/etc/ld.so.conf`` oder installierte CUDA-Versionen. Muss vor dem ersten CUDA-Aufruf von CTranslate2 erfolgen. """ global _PRELOADED_LIBRARIES if _PRELOADED_LIBRARIES or os.name != "posix": return _PRELOADED_LIBRARIES cuda_libs, cudnn_libs = detect_cuda_libraries() if not cuda_libs and not cudnn_libs: return _PRELOADED_LIBRARIES order = ("libcudart", "libcublasLt", "libcublas", "libcudnn") def sort_key(path: str) -> int: name = Path(path).name for index, prefix in enumerate(order): if name.startswith(prefix): return index return len(order) import ctypes loaded: list[str] = [] for path in sorted(cuda_libs + cudnn_libs, key=sort_key): # cuDNN-Teilbibliotheken werden von libcudnn.so.9 selbst nachgeladen. name = Path(path).name if name.startswith("libcudnn") and not name.startswith("libcudnn.so"): continue try: ctypes.CDLL(path, mode=ctypes.RTLD_GLOBAL) loaded.append(path) except OSError as exc: logger.debug("Bibliothek konnte nicht vorgeladen werden (%s): %s", path, exc) if loaded: directories = sorted({str(Path(path).parent) for path in loaded}) existing = os.environ.get("LD_LIBRARY_PATH", "") os.environ["LD_LIBRARY_PATH"] = os.pathsep.join( directories + ([existing] if existing else []) ) logger.debug("CUDA-Bibliotheken vorgeladen: %s", ", ".join(Path(p).name for p in loaded)) _PRELOADED_LIBRARIES = loaded return loaded def _find_libraries(patterns: list[str], directories: list[str]) -> list[str]: found: list[str] = [] for pattern in patterns: for directory in directories: try: found.extend(glob.glob(os.path.join(directory, pattern))) except OSError: continue return sorted(set(found)) def detect_cuda_libraries() -> tuple[list[str], list[str]]: """Sucht CUDA- und cuDNN-Bibliotheken im System und in der venv.""" directories = [ "/usr/lib", "/usr/lib64", "/usr/local/cuda/lib64", "/usr/local/lib", "/opt/cuda/lib64", str(Path.cwd() / ".venv" / "lib"), ] # nvidia-Wheels (falls installiert) liegen unter site-packages/nvidia//lib import site import sys site_roots: list[Path] = [] for base in (os.environ.get("VIRTUAL_ENV"), os.environ.get("CONDA_PREFIX")): if base: site_roots.append(Path(base)) site_roots.extend(Path(p) for p in site.getsitepackages()) site_roots.append(Path(sys.prefix)) for base in site_roots: directories.extend([str(base / "lib"), str(base / "lib64")]) nvidia_root = base / "lib" / f"python{sys.version_info.major}.{sys.version_info.minor}" / "site-packages" / "nvidia" directories.extend(str(path) for path in nvidia_root.glob("*/lib")) directories.extend(str(path) for path in (base / "Lib" / "site-packages" / "nvidia").glob("*/bin")) cuda_patterns = ["libcudart.so*", "libcublas.so*", "libcublasLt.so*"] cudnn_patterns = ["libcudnn*.so*"] cuda_libs = _find_libraries(cuda_patterns, directories) cudnn_libs = _find_libraries(cudnn_patterns, directories) # Zusaetzlich ueber den dynamischen Linker suchen. for name in ("cudart", "cublas", "cudnn"): located = ctypes.util.find_library(name) if located and located not in cuda_libs and name != "cudnn": cuda_libs.append(located) if located and name == "cudnn" and located not in cudnn_libs: cudnn_libs.append(located) return sorted(set(cuda_libs)), sorted(set(cudnn_libs)) def probe_ctranslate2() -> tuple[str | None, int, dict[str, list[str]], str | None]: """Fragt CTranslate2 nach Geraeten und unterstuetzten Compute Types.""" try: import ctranslate2 except ImportError as exc: return None, 0, {}, f"CTranslate2 nicht installiert: {exc}" version = getattr(ctranslate2, "__version__", None) error: str | None = None try: device_count = int(ctranslate2.get_cuda_device_count()) except Exception as exc: # pragma: no cover - hardwareabhaengig device_count = 0 error = f"CUDA-Geraete konnten nicht abgefragt werden: {exc}" supported: dict[str, list[str]] = {} for device in ("cpu", "cuda"): try: supported[device] = sorted(ctranslate2.get_supported_compute_types(device)) except Exception as exc: logger.debug("Compute Types fuer %s nicht verfuegbar: %s", device, exc) supported[device] = [] return version, device_count, supported, error def collect_runtime_info(*, check_fts: bool = True) -> RuntimeInfo: """Sammelt alle Laufzeitinformationen fuer den Systembericht.""" import platform import sqlite3 import sys version, device_count, supported, error = probe_ctranslate2() cuda_libs, cudnn_libs = detect_cuda_libraries() info = RuntimeInfo( ctranslate2_version=version, cuda_device_count=device_count, supported_compute_types=supported, cuda_libraries=cuda_libs, cudnn_libraries=cudnn_libs, python_version=sys.version.split()[0], platform=f"{platform.system()} {platform.release()}", sqlite_version=sqlite3.sqlite_version, ) if error: logger.debug(error) if check_fts: from ..database.connection import check_fts5, connect conn = connect(":memory:") try: info.fts5_available, info.trigram_available = check_fts5(conn) finally: conn.close() return info def _cc_tuple(compute_capability: str | None) -> tuple[int, int] | None: if not compute_capability: return None match = re.match(r"^\s*(\d+)\.(\d+)", compute_capability) if not match: return None return int(match.group(1)), int(match.group(2)) def is_pascal_or_older(gpu: GpuInfo | None) -> bool: """True fuer Pascal und aeltere Architekturen (Compute Capability <= 6.x).""" if gpu is None: return False cc = _cc_tuple(gpu.compute_capability) if cc is None: return False return cc[0] <= 6 def resolve_execution( requested_device: str, requested_compute_type: str, gpu: GpuInfo | None, runtime: RuntimeInfo, ) -> ResolvedExecution: """Waehlt einen tatsaechlich unterstuetzten Ausfuehrungsmodus. Regeln: * Nie einen Compute Type verwenden, den CTranslate2 fuer das Geraet nicht meldet. * Auf Pascal kein FP16/BF16. * Wenn CUDA nicht nutzbar ist, automatisch CPU mit einer verstaendlichen Notiz. """ device = (requested_device or "auto").strip().lower() requested_compute = (requested_compute_type or "auto").strip().lower() notes: list[str] = [] if device in {"auto", ""}: device = "cuda" if runtime.cuda_runtime_usable else "cpu" notes.append(f"device=auto auf '{device}' aufgeloest.") if device == "cuda" and not runtime.cuda_runtime_usable: notes.append( "CUDA ist nicht nutzbar (keine CUDA-Geraete oder keine CUDA-Compute-Types) - " "es wird die CPU verwendet." ) device = "cpu" if device == "cuda" and gpu is None: notes.append("nvidia-smi lieferte keine GPU-Informationen; CUDA wird trotzdem versucht.") cc = _cc_tuple(gpu.compute_capability) if gpu else None if device == "cuda" and cc is not None and cc[0] <= 6: if requested_compute in FORBIDDEN_GPU_COMPUTE_TYPES: notes.append( f"'{requested_compute}' ist auf Pascal (CC {gpu.compute_capability}) nicht sinnvoll - " f"stattdessen {PREFERRED_COMPUTE_TYPE}." ) requested_compute = PREFERRED_COMPUTE_TYPE if device == "cpu": supported = runtime.cpu_compute_types or ["int8", "float32"] preference = [requested_compute, "int8", "int8_float32", "float32"] notes.append("CPU-Fallback aktiv: Transkription laeuft ohne GPU und ist deutlich langsamer.") else: supported = runtime.cuda_compute_types or [] if gpu is not None and gpu.compute_capability: supported = [item for item in supported] # Pascal: FP16/BF16 nie automatisch waehlen. if cc is not None and cc[0] <= 6: supported = [item for item in supported if item not in FORBIDDEN_GPU_COMPUTE_TYPES] preference = [requested_compute, PREFERRED_COMPUTE_TYPE, "float32", "int8"] chosen = "" for candidate in preference: if candidate in {"", "auto"}: continue if candidate in supported: chosen = candidate break if not chosen: # Letzter Ausweg: erster gemeldeter Typ. chosen = supported[0] if supported else "float32" notes.append( f"Kein bevorzugter Compute Type verfuegbar; verwende '{chosen}'." ) elif chosen != requested_compute and requested_compute not in {"", "auto"}: notes.append( f"'{requested_compute}' ist nicht verfuegbar - verwende '{chosen}'." ) if device == "cuda" and chosen in FORBIDDEN_GPU_COMPUTE_TYPES and cc is not None and cc[0] <= 6: chosen = PREFERRED_COMPUTE_TYPE notes.append("FP16/BF16 auf Pascal verhindert, int8_float32 erzwungen.") return ResolvedExecution( device=device, compute_type=chosen, requested_device=requested_device, requested_compute_type=requested_compute_type, notes=notes, )