9dd5ee0117 · tduncan/Nvidia-Optimization-Stack-VLLM

@@ -46,6 +46,17 @@ SystemEnv = namedtuple(

46 "nvidia_driver_version",

47 "nvidia_gpu_models",

48 "cudnn_version",

49 + "xpu_available",

50 + "xpu_runtime_version",

51 + "intel_graphics_compiler_version",

52 + "intel_gpu_models",

53 + "oneapi_compiler_version",

54 + "level_zero_loader_version",

55 + "level_zero_driver_version",

56 + "oneccl_version",

57 + "libigdgmm_version",

58 + "vllm_xpu_kernels_version",

59 + "sycl_version",

60 "pip_version", # 'pip' or 'pip3'

61 "pip_packages",

62 "conda_packages",

@@ -277,6 +288,134 @@ def get_rocm_version(run_lambda):

288 )

289

290

291 +def get_xpu_available():

292 + if TORCH_AVAILABLE and hasattr(torch, "xpu") and torch.xpu.is_available():

293 + return True

294 + return False

295 +

296 +

297 +def get_xpu_runtime_version():

298 + if TORCH_AVAILABLE and hasattr(torch.version, "xpu"):

299 + return torch.version.xpu

300 + return None

301 +

302 +

303 +def get_pkg_version(run_lambda, pkg):

304 + assert get_platform() == "linux"

305 +

306 + if pkg == "vllm_xpu_kernels":

307 + rc, out, _ = run_lambda("pip show vllm-xpu-kernels")

308 + if rc == 0:

309 + match = re.search(r"Version: (.*)", out)

310 + return match.group(1).strip() if match else None

311 + return None

312 +

313 + pkg_map = {

314 + "igc": ["intel-igc-core", "libigc2", "libigc1"],

315 + "level_zero_loader": ["level-zero", "libze1"],

316 + "level_zero_driver": ["libze-intel-gpu1", "intel-level-zero-gpu"],

317 + "oneccl": ["intel-oneapi-ccl", "oneccl"],

318 + "libigdgmm": ["libigdgmm12", "libigdgmm"],

319 + }

320 +

321 + pkg_candidates = pkg_map.get(pkg, [])

322 + if not pkg_candidates:

323 + return None

324 +

325 + mgr_name = None

326 + for mgr in ["dpkg", "dnf", "yum", "zypper"]:

327 + rc, _, _ = run_lambda(f"which {mgr}")

328 + if rc == 0:

329 + mgr_name = mgr

330 + break

331 +

332 + if not mgr_name:

333 + return None

334 +

335 + ret = ""

336 + index = -1

337 +

338 + for pkg_name in pkg_candidates:

339 + if not pkg_name:

340 + continue

341 +

342 + cmd = ""

343 + if mgr_name in ["dnf", "yum"]:

344 + index = 1

345 + cmd = f"{mgr_name} list | grep -w {pkg_name}"

346 + elif mgr_name == "zypper":

347 + index = 2

348 + cmd = f"{mgr_name} info {pkg_name} | grep Version"

349 + elif mgr_name == "dpkg":

350 + index = 2

351 + cmd = f"{mgr_name} -l | grep -w {pkg_name}"

352 +

353 + if cmd:

354 + out = run_and_read_all(run_lambda, cmd)

355 + if out:

356 + ret = out.splitlines()[0]

357 + break

358 +

359 + if not ret or index == -1:

360 + return None

361 +

362 + lst = re.sub(" +", " ", ret).strip().split(" ")

363 + if len(lst) > index:

364 + return lst[index]

365 +

366 + return None

367 +

368 +

369 +def get_intel_graphics_compiler_version(run_lambda):

370 + """Return Intel Graphics Compiler (IGC) version."""

371 + return get_pkg_version(run_lambda, "igc")

372 +

373 +

374 +def get_level_zero_loader_version(run_lambda):

375 + """Return Level Zero loader runtime version."""

376 + return get_pkg_version(run_lambda, "level_zero_loader")

377 +

378 +

379 +def get_level_zero_driver_version(run_lambda):

380 + """Return Level Zero driver version."""

381 + return get_pkg_version(run_lambda, "level_zero_driver")

382 +

383 +

384 +def get_oneapi_ccl_version(run_lambda):

385 + """Return oneAPI Collective Communications Library (oneCCL) version."""

386 + return get_pkg_version(run_lambda, "oneccl")

387 +

388 +

389 +def get_libigdgmm_version(run_lambda):

390 + return get_pkg_version(run_lambda, "libigdgmm")

391 +

392 +

393 +def get_vllm_xpu_kernels_version(run_lambda):

394 + return get_pkg_version(run_lambda, "vllm_xpu_kernels")

395 +

396 +

397 +def get_intel_gpu_models():

398 + if TORCH_AVAILABLE and hasattr(torch, "xpu") and torch.xpu.is_available():

399 + device_count = torch.xpu.device_count()

400 + return "\n".join(

401 + "GPU {}: {}".format(i, torch.xpu.get_device_name(i))

402 + for i in range(device_count)

403 + )

404 + return None

405 +

406 +

407 +def get_oneapi_compiler_version(run_lambda):

408 + """Return Intel oneAPI DPC++/C++ Compiler version via icpx."""

409 + return run_and_parse_first_match(

410 + run_lambda, "icpx --version", r"oneAPI DPC\+\+/C\+\+ Compiler (\S+)"

411 + )

412 +

413 +

414 +def get_sycl_version(run_lambda):

415 + """Return SYCL/DPC++ compiler build version."""

416 + return run_and_parse_first_match(run_lambda, "icpx --version", r"\((\d[\d.]+)\)")

417 +

418 +

419 def get_vllm_version():

420 from vllm import __version__, __version_tuple__

421

@@ -298,11 +437,12 @@ def get_vllm_version():

437

438

439 def summarize_vllm_build_flags():

301 - # This could be a static method if the flags are constant, or dynamic if you need to check environment variables, etc.

302 - return "CUDA Archs: {}; ROCm: {}".format(

440 + flags = "CUDA Archs: {}; ROCm: {}; XPU: {}".format(

441 os.environ.get("TORCH_CUDA_ARCH_LIST", "Not Set"),

442 "Enabled" if os.environ.get("ROCM_HOME") else "Disabled",

443 + "Enabled" if get_xpu_available() else "Disabled",

444 )

445 + return flags

446

447

448 def get_gpu_topo(run_lambda):

@@ -574,6 +714,13 @@ def get_env_vars():

714 "OMP_",

715 "MKL_",

716 "NVIDIA",

717 + "ZE_",

718 + "ONEAPI_",

719 + "SYCL_",

720 + "NEOReadDebugKeys",

721 + "IGC_",

722 + "CCL_",

723 + "I_MPI_",

724 )

725 for k, v in os.environ.items():

726 if any(term in k.lower() for term in secret_terms):

@@ -637,6 +784,17 @@ def get_env_info():

784 nvidia_gpu_models=get_gpu_info(run_lambda),

785 nvidia_driver_version=get_nvidia_driver_version(run_lambda),

786 cudnn_version=get_cudnn_version(run_lambda),

787 + xpu_available=str(get_xpu_available()),

788 + xpu_runtime_version=get_xpu_runtime_version(),

789 + intel_graphics_compiler_version=get_intel_graphics_compiler_version(run_lambda),

790 + intel_gpu_models=get_intel_gpu_models(),

791 + oneapi_compiler_version=get_oneapi_compiler_version(run_lambda),

792 + level_zero_loader_version=get_level_zero_loader_version(run_lambda),

793 + level_zero_driver_version=get_level_zero_driver_version(run_lambda),

794 + oneccl_version=get_oneapi_ccl_version(run_lambda),

795 + libigdgmm_version=get_libigdgmm_version(run_lambda),

796 + vllm_xpu_kernels_version=get_vllm_xpu_kernels_version(run_lambda),

797 + sycl_version=get_sycl_version(run_lambda),

798 hip_compiled_version=hip_compiled_version,

799 hip_runtime_version=hip_runtime_version,

800 miopen_runtime_version=miopen_runtime_version,

@@ -676,26 +834,15 @@ PyTorch version : {torch_version}

834 Is debug build : {is_debug_build}

835 CUDA used to build PyTorch : {cuda_compiled_version}

836 ROCM used to build PyTorch : {hip_compiled_version}

837 +XPU used to build PyTorch : {xpu_runtime_version}

838

839 ==============================

840 Python Environment

841 ==============================

842 Python version : {python_version}

843 Python platform : {python_platform}

685 -

686 -==============================

687 - CUDA / GPU Info

688 -==============================

689 -Is CUDA available : {is_cuda_available}

690 -CUDA runtime version : {cuda_runtime_version}

691 -CUDA_MODULE_LOADING set to : {cuda_module_loading}

692 -GPU models and configuration : {nvidia_gpu_models}

693 -Nvidia driver version : {nvidia_driver_version}

694 -cuDNN version : {cudnn_version}

695 -HIP runtime version : {hip_runtime_version}

696 -MIOpen runtime version : {miopen_runtime_version}

697 -Is XNNPACK available : {is_xnnpack_available}

698 -

844 +

845 +{gpu_info}

846 ==============================

847 CPU Info

848 ==============================

@@ -790,6 +937,35 @@ def pretty_str(envinfo):

937 if envinfo.cuda_compiled_version is None:

938 mutable_dict["cuda_compiled_version"] = "None"

939

940 + # If the machine doesn't have XPU, report XPU fields as 'No XPU'

941 + dynamic_xpu_fields = [

942 + "intel_graphics_compiler_version",

943 + "intel_gpu_models",

944 + "level_zero_loader_version",

945 + "level_zero_driver_version",

946 + "oneccl_version",

947 + "libigdgmm_version",

948 + "vllm_xpu_kernels_version",

949 + ]

950 + all_xpu_fields = dynamic_xpu_fields + [

951 + "oneapi_compiler_version",

952 + "sycl_version",

953 + ]

954 + all_dynamic_xpu_fields_missing = all(

955 + mutable_dict[field] is None for field in dynamic_xpu_fields

956 + )

957 + xpu_available = mutable_dict.get("xpu_available") == "True"

958 + if not xpu_available and all_dynamic_xpu_fields_missing:

959 + for field in all_xpu_fields:

960 + mutable_dict[field] = "No XPU"

961 + if envinfo.xpu_runtime_version is None or envinfo.xpu_runtime_version == "N/A":

962 + mutable_dict["xpu_runtime_version"] = "N/A"

963 +

964 + # If intel_gpu_models is multiline, start on the next line

965 + mutable_dict["intel_gpu_models"] = maybe_start_on_next_line(

966 + mutable_dict.get("intel_gpu_models")

967 + )

968 +

969 # Replace True with Yes, False with No

970 mutable_dict = replace_bools(mutable_dict)

971

@@ -811,6 +987,62 @@ def pretty_str(envinfo):

987 mutable_dict["conda_packages"], "[conda] "

988 )

989 mutable_dict["cpu_info"] = envinfo.cpu_info

990 +

991 + CUDA_FMT = """

992 +==============================

993 + CUDA / GPU Info

994 +==============================

995 +Is CUDA available : {is_cuda_available}

996 +CUDA runtime version : {cuda_runtime_version}

997 +CUDA_MODULE_LOADING set to : {cuda_module_loading}

998 +GPU models and configuration : {nvidia_gpu_models}

999 +Nvidia driver version : {nvidia_driver_version}

1000 +cuDNN version : {cudnn_version}

1001 +HIP runtime version : {hip_runtime_version}

1002 +MIOpen runtime version : {miopen_runtime_version}

1003 +Is XNNPACK available : {is_xnnpack_available}

1004 +""".strip()

1005 +

1006 + XPU_FMT = """

1007 +==============================

1008 + Intel XPU / GPU Info

1009 +==============================

1010 +Is XPU available : {xpu_available}

1011 +XPU runtime version : {xpu_runtime_version}

1012 +Intel GPU models : {intel_gpu_models}

1013 +

1014 +--Compile time--

1015 +oneAPI compiler version : {oneapi_compiler_version}

1016 +SYCL compiler build : {sycl_version}

1017 +oneCCL version : {oneccl_version}

1018 +

1019 +--Runtime--

1020 +Intel Graphics Compiler (IGC): {intel_graphics_compiler_version}

1021 +Intel GMM (libigdgmm) : {libigdgmm_version}

1022 +Level Zero loader version : {level_zero_loader_version}

1023 +Level Zero driver version : {level_zero_driver_version}

1024 +vLLM XPU kernels version : {vllm_xpu_kernels_version}

1025 +""".strip()

1026 +

1027 + invalid_vers = {"N/A", "Could not collect", "None"}

1028 + sections = []

1029 +

1030 + if (

1031 + mutable_dict.get("is_cuda_available") in ("True", "Yes")

1032 + or mutable_dict.get("cuda_compiled_version") not in invalid_vers

1033 + ):

1034 + sections.append(CUDA_FMT)

1035 +

1036 + if (

1037 + mutable_dict.get("xpu_available") in ("True", "Yes")

1038 + or mutable_dict.get("xpu_runtime_version") not in invalid_vers

1039 + ):

1040 + sections.append(XPU_FMT)

1041 +

1042 + mutable_dict["gpu_info"] = (

1043 + ("\n\n".join(sections) + "\n").format(**mutable_dict) if sections else ""

1044 + )

1045 +

1046 return env_info_fmt.format(**mutable_dict)

1047

1048

[XPU]Enhance environment collection for Intel XPU and optimize layout (#35698)