[llvm] [Offload] Port llvm-offload-device-info to new offload API (PR #155626)
Kevin Sala Penades via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 29 17:40:18 PDT 2025
================
@@ -1,32 +1,273 @@
-//===- llvm-offload-device-info.cpp - Device info as seen by LLVM/Offload -===//
+//===- llvm-offload-device-info.cpp - Print liboffload properties ---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
-// This is a command line utility that, by using LLVM/Offload, and the device
-// plugins, list devices information as seen by the runtime.
+// This is a command line utility that, by using the new liboffload API, prints
+// all devices and properties
//
//===----------------------------------------------------------------------===//
-#include "omptarget.h"
-#include <cstdio>
+#include <OffloadAPI.h>
+#include <iostream>
+#include <vector>
-int main(int argc, char **argv) {
- __tgt_bin_desc EmptyDesc = {0, nullptr, nullptr, nullptr};
- __tgt_register_lib(&EmptyDesc);
- __tgt_init_all_rtls();
+#define OFFLOAD_ERR(X) \
+ if (auto Err = X) { \
+ return Err; \
+ }
+
+enum class PrintKind {
+ NORMAL,
+ FP_FLAGS,
+};
+
+template <typename T, PrintKind PK = PrintKind::NORMAL>
+void doWrite(std::ostream &S, T &&Val) {
+ S << Val;
+}
+
+template <>
+void doWrite<ol_platform_backend_t>(std::ostream &S,
+ ol_platform_backend_t &&Val) {
+ switch (Val) {
+ case OL_PLATFORM_BACKEND_UNKNOWN:
+ S << "UNKNOWN";
+ break;
+ case OL_PLATFORM_BACKEND_CUDA:
+ S << "CUDA";
+ break;
+ case OL_PLATFORM_BACKEND_AMDGPU:
+ S << "AMDGPU";
+ break;
+ case OL_PLATFORM_BACKEND_HOST:
+ S << "HOST";
+ break;
+ default:
+ S << "<< INVALID >>";
+ break;
+ }
+}
+template <>
+void doWrite<ol_device_type_t>(std::ostream &S, ol_device_type_t &&Val) {
+ switch (Val) {
+ case OL_DEVICE_TYPE_GPU:
+ S << "GPU";
+ break;
+ case OL_DEVICE_TYPE_CPU:
+ S << "CPU";
+ break;
+ case OL_DEVICE_TYPE_HOST:
+ S << "HOST";
+ break;
+ default:
+ S << "<< INVALID >>";
+ break;
+ }
+}
+template <>
+void doWrite<ol_dimensions_t>(std::ostream &S, ol_dimensions_t &&Val) {
+ S << "{x: " << Val.x << ", y: " << Val.y << ", z: " << Val.z << "}";
+}
+template <>
+void doWrite<ol_device_fp_capability_flags_t, PrintKind::FP_FLAGS>(
+ std::ostream &S, ol_device_fp_capability_flags_t &&Val) {
+ S << Val << " {";
+
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT) {
+ S << " CORRECTLY_ROUNDED_DIVIDE_SQRT";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST) {
+ S << " ROUND_TO_NEAREST";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO) {
+ S << " ROUND_TO_ZERO";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF) {
+ S << " ROUND_TO_INF";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_INF_NAN) {
+ S << " INF_NAN";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_DENORM) {
+ S << " DENORM";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_FMA) {
+ S << " FMA";
+ }
+ if (Val & OL_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT) {
+ S << " SOFT_FLOAT";
+ }
+
+ S << " }";
+}
- printf("Found %d devices:\n", omp_get_num_devices());
- for (int Dev = 0; Dev < omp_get_num_devices(); Dev++) {
- printf(" Device %d:\n", Dev);
- if (!__tgt_print_device_info(Dev))
- printf(" print_device_info not implemented\n");
- printf("\n");
+template <typename T>
+ol_result_t printPlatformValue(std::ostream &S, ol_platform_handle_t Plat,
+ ol_platform_info_t Info, const char *Desc) {
+ S << Desc << ": ";
+
+ if constexpr (std::is_pointer_v<T>) {
+ std::vector<uint8_t> Val;
+ size_t Size;
+ OFFLOAD_ERR(olGetPlatformInfoSize(Plat, Info, &Size));
+ Val.resize(Size);
+ OFFLOAD_ERR(olGetPlatformInfo(Plat, Info, sizeof(Val), Val.data()));
+ doWrite(S, reinterpret_cast<T>(Val.data()));
+ } else {
+ T Val;
+ OFFLOAD_ERR(olGetPlatformInfo(Plat, Info, sizeof(Val), &Val));
+ doWrite(S, std::move(Val));
+ }
+ S << "\n";
+ return OL_SUCCESS;
+}
+
+template <typename T, PrintKind PK = PrintKind::NORMAL>
+ol_result_t printDeviceValue(std::ostream &S, ol_device_handle_t Dev,
+ ol_device_info_t Info, const char *Desc,
+ const char *Units = "") {
+ S << Desc << ": ";
+
+ if constexpr (std::is_pointer_v<T>) {
+ std::vector<uint8_t> Val;
+ size_t Size;
+ OFFLOAD_ERR(olGetDeviceInfoSize(Dev, Info, &Size));
+ Val.resize(Size);
+ OFFLOAD_ERR(olGetDeviceInfo(Dev, Info, sizeof(Val), Val.data()));
+ doWrite<T, PK>(S, reinterpret_cast<T>(Val.data()));
+ } else {
+ T Val;
+ OFFLOAD_ERR(olGetDeviceInfo(Dev, Info, sizeof(Val), &Val));
+ doWrite<T, PK>(S, std::move(Val));
+ }
+ S << Units << "\n";
+ return OL_SUCCESS;
+}
+
+ol_result_t printDevice(std::ostream &S, ol_device_handle_t D) {
+ ol_platform_handle_t Platform;
+ OFFLOAD_ERR(
+ olGetDeviceInfo(D, OL_DEVICE_INFO_PLATFORM, sizeof(Platform), &Platform));
+
+ std::vector<char> Name;
+ size_t NameSize;
+ OFFLOAD_ERR(olGetDeviceInfoSize(D, OL_DEVICE_INFO_PRODUCT_NAME, &NameSize))
+ Name.resize(NameSize);
+ OFFLOAD_ERR(
+ olGetDeviceInfo(D, OL_DEVICE_INFO_PRODUCT_NAME, NameSize, Name.data()));
+ S << "[" << Name.data() << "]\n";
+
+ OFFLOAD_ERR(printPlatformValue<const char *>(
+ S, Platform, OL_PLATFORM_INFO_NAME, "Platform Name"));
+ OFFLOAD_ERR(printPlatformValue<const char *>(
+ S, Platform, OL_PLATFORM_INFO_VENDOR_NAME, "Platform Vendor Name"));
+ OFFLOAD_ERR(printPlatformValue<const char *>(
+ S, Platform, OL_PLATFORM_INFO_VERSION, "Platform Version"));
+ OFFLOAD_ERR(printPlatformValue<ol_platform_backend_t>(
+ S, Platform, OL_PLATFORM_INFO_BACKEND, "Platform Backend"));
+
+ OFFLOAD_ERR(
+ printDeviceValue<const char *>(S, D, OL_DEVICE_INFO_NAME, "Name"));
+ OFFLOAD_ERR(
+ printDeviceValue<ol_device_type_t>(S, D, OL_DEVICE_INFO_TYPE, "Type"));
+ OFFLOAD_ERR(printDeviceValue<const char *>(
+ S, D, OL_DEVICE_INFO_DRIVER_VERSION, "Driver Version"));
+ OFFLOAD_ERR(printDeviceValue<uint32_t>(
+ S, D, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, "Max Work Group Size"));
+ OFFLOAD_ERR(printDeviceValue<ol_dimensions_t>(
+ S, D, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION,
+ "Max Work Group Size Per Dimension"));
+ OFFLOAD_ERR(printDeviceValue<uint32_t>(S, D, OL_DEVICE_INFO_MAX_WORK_SIZE,
+ "Max Work Size"));
+ OFFLOAD_ERR(printDeviceValue<ol_dimensions_t>(
+ S, D, OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION,
+ "Max Work Size Per Dimension"));
+ OFFLOAD_ERR(
+ printDeviceValue<uint32_t>(S, D, OL_DEVICE_INFO_VENDOR_ID, "Vendor ID"));
+ OFFLOAD_ERR(printDeviceValue<uint32_t>(S, D, OL_DEVICE_INFO_NUM_COMPUTE_UNITS,
+ "Num Compute Units"));
+ OFFLOAD_ERR(printDeviceValue<uint32_t>(
+ S, D, OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, "Max Clock Frequency", "MHz"));
+ OFFLOAD_ERR(printDeviceValue<uint32_t>(S, D, OL_DEVICE_INFO_MEMORY_CLOCK_RATE,
+ "Memory Clock Rate", "MHz"));
+ OFFLOAD_ERR(printDeviceValue<uint32_t>(S, D, OL_DEVICE_INFO_ADDRESS_BITS,
+ "Address Bits"));
+ OFFLOAD_ERR(printDeviceValue<uint64_t>(
+ S, D, OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, "Max Mem Allocation Size", "B"));
----------------
kevinsala wrote:
Can you add a space between the value and the units in all these fields?
https://github.com/llvm/llvm-project/pull/155626
More information about the llvm-commits
mailing list