[OpenMP][libomptarget] Improve plugin device info printing

[kevinsala]

Summary

This patch improves the device info printing in the NextGen plugins. The device info properties are composed of keys and values, each property encapsulated by a PrintInfoTy object. These properties are pushed into a std::deque by each vendor-specific plugins, and later, processed and printed by the PluginInterface. This implementation extensively uses std::string, but it should not be a performance issue, since it's not in any critical path.

For the moment, this patch adds the device info for AMDGPU. It's missing the same changes for the CUDA plugin.

[kevinsala]

Example of a device info printing for a AMDGPU device:

HSA Runtime Version:                 1.1
HSA OpenMP Device Number:            1
Product Name:                        
Device Name:                         gfx906
Vendor Name:                         AMD
Device Type:                         GPU
Max Queues:                          128
Queue Min Size:                      64
Queue Max Size:                      131072
Cache:                               
    L0:                              16384
    L1:                              8388608
Cacheline Size:                      64
Max Clock Freq(MHz):                 1725
Compute Units:                       60
SIMD per CU:                         4
Fast F16 Operation:                  TRUE
Wavefront Size:                      64
Workgroup Max Size:                  1024
Workgroup Max Size per Dimension:    
    x:                               1024
    y:                               1024
    z:                               1024
Max Waves Per CU:                    40
Max Work-item Per CU:                2560
Grid Max Size:                       4294967295
Grid Max Size per Dimension:         
    x:                               4294967295
    y:                               4294967295
    z:                               4294967295
Max fbarriers/Workgrp:               32
Memory Pools:                        
    Pool GLOBAL:                     
        Flags:                       COARSE GRAINED 
        Size:                        34342961152 bytes
        Allocatable:                 TRUE
        Runtime Alloc Granule:       4096 bytes
        Runtime Alloc Alignment:     4096 bytes
        Accessable by all:           FALSE
    Pool GROUP:                      
        Size:                        65536 bytes
        Allocatable:                 FALSE
        Runtime Alloc Granule:       0 bytes
        Runtime Alloc Alignment:     0 bytes
        Accessable by all:           FALSE
ISAs:                                
    Name:                            amdgcn-amd-amdhsa--gfx906:sramecc+:xnack-

Notice it's very similar to the device information printed by the original AMDGPU plugin.

[kevinsala]

Added support for CUDA plugin and improved generic code.

[kevinsala]

Examples of llvm-omp-device-info in AMDGPU and NVIDIA devices:

Device (7):
    CUDA Driver Version:              10020
    CUDA OpenMP Device Number:        3
    Device Name:                      Tesla V100-SXM2-16GB
    Global Memory Size:               16911433728 bytes
    Number of Multiprocessors:        80
    Concurrent Copy and Execution:    Yes
    Total Constant Memory:            65536 bytes
    Max Shared Memory per Block:      49152 bytes
    Registers per Block:              65536
    Warp Size:                        32
    Maximum Threads per Block:        1024
    Maximum Block Dimensions:         
        x:                            1024
        y:                            1024
        z:                            64
    Maximum Grid Dimensions:          
        x:                            2147483647
        y:                            65535
        z:                            65535
    Maximum Memory Pitch:             2147483647 bytes
    Texture Alignment:                512 bytes
    Clock Rate:                       1530000 kHz
    Execution Timeout:                No
    Integrated Device:                No
    Can Map Host Memory:              Yes
    Compute Mode:                     Default
    Concurrent Kernels:               Yes
    ECC Enabled:                      Yes
    Memory Clock Rate:                877000 kHz
    Memory Bus Width:                 4096 bits
    L2 Cache Size:                    6291456 bytes
    Max Threads Per SMP:              2048
    Async Engines:                    4
    Unified Addressing:               Yes
    Managed Memory:                   Yes
    Concurrent Managed Memory:        Yes
    Preemption Supported:             Yes
    Cooperative Launch:               Yes
    Multi-Device Boars:               No
    Compute Capabilities:             sm_70

Device (5):
    HSA Runtime Version:                 1.1
    HSA OpenMP Device Number:            1
    Product Name:                        
    Device Name:                         gfx906
    Vendor Name:                         AMD
    Device Type:                         GPU
    Max Queues:                          128
    Queue Min Size:                      64
    Queue Max Size:                      131072
    Cache:                               
        L0:                              16384
        L1:                              8388608
    Cacheline Size:                      64
    Max Clock Freq:                      1725 MHz
    Compute Units:                       60
    SIMD per CU:                         4
    Fast F16 Operation:                  Yes
    Wavefront Size:                      64
    Workgroup Max Size:                  1024
    Workgroup Max Size per Dimension:    
        x:                               1024
        y:                               1024
        z:                               1024
    Max Waves Per CU:                    40
    Max Work-item Per CU:                2560
    Grid Max Size:                       4294967295
    Grid Max Size per Dimension:         
        x:                               4294967295
        y:                               4294967295
        z:                               4294967295
    Max fbarriers/Workgrp:               32
    Memory Pools:                        
        Pool Global:                     
            Flags:                       Coarse Grained 
            Size:                        34342961152 bytes
            Allocatable:                 Yes
            Runtime Alloc Granule:       4096 bytes
            Runtime Alloc Alignment:     4096 bytes
            Accessable by all:           No
        Pool Group:                      
            Size:                        65536 bytes
            Allocatable:                 No
            Runtime Alloc Granule:       0 bytes
            Runtime Alloc Alignment:     0 bytes
            Accessable by all:           No
    ISAs:                                
        Name:                            amdgcn-amd-amdhsa--gfx906:sramecc+:xnack-

[kevinsala]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

124

Can be const.

[tianshilei1992]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

144

why not just printf?

[jhuber6]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

144

We could even use llvm::outs() if so inclined.

[kevinsala]

Fixing review comments and other improvements.

[kevinsala]

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

144

It looks cleaner with llvm::outs()

[josemonsalve2]

Other than the comment this looks good to me, cleaner than before. Thanks Kevin.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

88

Maybe, add a comment to explain what level means.

/// Level represents the level in the info tree print (i.e. indentation)

Or something like that?

[kevinsala]

Fixed reviewers' comments

[kevinsala]

Fixed format

[tianshilei1992]

LG

openmp/libomptarget/plugins-nextgen/amdgpu/src/rtl.cpp

struct AMDGPUDeviceTy : public GenericDeviceTy, AMDGenericDeviceTy {
   }
 
   /// Synchronize the current thread with the event.
   Error syncEventImpl(void *EventPtr) override {
     return Plugin::error("Synchronize event not implemented");
   }
 
   /// Print information about the device.
-  Error printInfoImpl() override {
-    // TODO: Implement the basic info.
+  Error printInfoImpl(std::deque<PrintInfoTy> &Items) override {
+    char TmpChar[1000];
+    const char *TmpCharPtr;
+    uint16_t Major, Minor;
+    uint32_t TmpUInt, TmpUInt2;
+    uint32_t CacheSize[4];
+    bool TmpBool;
+    uint16_t WorkgroupMaxDim[3];
+    hsa_dim3_t GridMaxDim;
+    hsa_status_t Status, Status2;
+
+    Status = hsa_system_get_info(HSA_SYSTEM_INFO_VERSION_MAJOR, &Major);
+    Status2 = hsa_system_get_info(HSA_SYSTEM_INFO_VERSION_MINOR, &Minor);
+    if (Status == HSA_STATUS_SUCCESS && Status2 == HSA_STATUS_SUCCESS)
+      Items.push_back({"HSA Runtime Version",
+                       std::to_string(Major) + "." + std::to_string(Minor), 1});
+
+    Items.push_back({"HSA OpenMP Device Number", DeviceId, 1});
+
+    Status = hsa_agent_get_info(
+        Agent, (hsa_agent_info_t)HSA_AMD_AGENT_INFO_PRODUCT_NAME, TmpChar);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Product Name", TmpChar, 1});
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_NAME, TmpChar);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Device Name", TmpChar, 1});
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_VENDOR_NAME, TmpChar);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Vendor Name", TmpChar, 1});
+
+    hsa_device_type_t DevType;
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_DEVICE, &DevType);
+    if (Status == HSA_STATUS_SUCCESS) {
+      switch (DevType) {
+      case HSA_DEVICE_TYPE_CPU:
+        TmpCharPtr = "CPU";
+        break;
+      case HSA_DEVICE_TYPE_GPU:
+        TmpCharPtr = "GPU";
+        break;
+      case HSA_DEVICE_TYPE_DSP:
+        TmpCharPtr = "DSP";
+        break;
+      default:
+        TmpCharPtr = "UNKNOWN";
+      }
+      Items.push_back({"Device Type", TmpCharPtr, 1});
+    }
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_QUEUES_MAX, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Max Queues", TmpUInt, 1});
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_QUEUE_MIN_SIZE, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Queue Min Size", TmpUInt, 1});
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_QUEUE_MAX_SIZE, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Queue Max Size", TmpUInt, 1});
+
+    // FIXME: This is deprecated according to HSA documentation. But using
+    // hsa_agent_iterate_caches and hsa_cache_get_info breaks execution during
+    // runtime.
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_CACHE_SIZE, CacheSize);
+    if (Status == HSA_STATUS_SUCCESS) {
+      Items.push_back({"Cache", "", 1});
+
+      for (int I = 0; I < 4; I++)
+        if (CacheSize[I])
+          Items.push_back({"L" + std::to_string(I), CacheSize[I], 2});
+    }
+
+    Status = hsa_agent_get_info(
+        Agent, (hsa_agent_info_t)HSA_AMD_AGENT_INFO_CACHELINE_SIZE, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Cacheline Size", TmpUInt, 1});
+
+    Status = hsa_agent_get_info(
+        Agent, (hsa_agent_info_t)HSA_AMD_AGENT_INFO_MAX_CLOCK_FREQUENCY,
+        &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Max Clock Freq(MHz)", TmpUInt, 1});
+
+    Status = hsa_agent_get_info(
+        Agent, (hsa_agent_info_t)HSA_AMD_AGENT_INFO_COMPUTE_UNIT_COUNT,
+        &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Compute Units", TmpUInt, 1});
+
+    Status = hsa_agent_get_info(
+        Agent, (hsa_agent_info_t)HSA_AMD_AGENT_INFO_NUM_SIMDS_PER_CU, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"SIMD per CU", TmpUInt, 1});
+
+    Status =
+        hsa_agent_get_info(Agent, HSA_AGENT_INFO_FAST_F16_OPERATION, &TmpBool);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Fast F16 Operation", (TmpBool ? "TRUE" : "FALSE"), 1});
+
+    Status =
+        hsa_agent_get_info(Agent, HSA_AGENT_INFO_WAVEFRONT_SIZE, &TmpUInt2);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Wavefront Size", TmpUInt2, 1});
+
+    Status =
+        hsa_agent_get_info(Agent, HSA_AGENT_INFO_WORKGROUP_MAX_SIZE, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Workgroup Max Size", TmpUInt, 1});
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_WORKGROUP_MAX_DIM,
+                                WorkgroupMaxDim);
+    if (Status == HSA_STATUS_SUCCESS) {
+      Items.push_back({"Workgroup Max Size per Dimension", "", 1});
+      Items.push_back({"x", WorkgroupMaxDim[0], 2});
+      Items.push_back({"y", WorkgroupMaxDim[1], 2});
+      Items.push_back({"z", WorkgroupMaxDim[2], 2});
+    }
+
+    Status = hsa_agent_get_info(
+        Agent, (hsa_agent_info_t)HSA_AMD_AGENT_INFO_MAX_WAVES_PER_CU, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS) {
+      Items.push_back({"Max Waves Per CU", TmpUInt, 1});
+      Items.push_back({"Max Work-item Per CU", TmpUInt * TmpUInt2, 1});
+    }
+
+    Status = hsa_agent_get_info(Agent, HSA_AGENT_INFO_GRID_MAX_SIZE, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Grid Max Size", TmpUInt, 1});
+
+    Status =
+        hsa_agent_get_info(Agent, HSA_AGENT_INFO_GRID_MAX_DIM, &GridMaxDim);
+    if (Status == HSA_STATUS_SUCCESS) {
+      Items.push_back({"Grid Max Size per Dimension", "", 1});
+      Items.push_back({"x", GridMaxDim.x, 2});
+      Items.push_back({"y", GridMaxDim.y, 2});
+      Items.push_back({"z", GridMaxDim.z, 2});
+    }
+
+    Status =
+        hsa_agent_get_info(Agent, HSA_AGENT_INFO_FBARRIER_MAX_SIZE, &TmpUInt);
+    if (Status == HSA_STATUS_SUCCESS)
+      Items.push_back({"Max fbarriers/Workgrp", TmpUInt, 1});
+
+    Items.push_back({"Memory Pools", "", 1});
+    auto CbMem = [](hsa_amd_memory_pool_t Region, void *Data) -> hsa_status_t {
+      std::string TmpStr, TmpStr2;
+      size_t Size;
+      bool Alloc, Access;
+      hsa_amd_segment_t Segment;
+      hsa_amd_memory_pool_global_flag_t GlobalFlags;
+      hsa_status_t Status;
+
+      std::deque<PrintInfoTy> *Items =
+          static_cast<std::deque<PrintInfoTy> *>(Data);
+      assert(Items && "Null callback parameter");
+
+      Status = hsa_amd_memory_pool_get_info(
+          Region, HSA_AMD_MEMORY_POOL_INFO_SEGMENT, &Segment);
+      if (Status != HSA_STATUS_SUCCESS)
+        return HSA_STATUS_SUCCESS;
+
+      switch (Segment) {
+      case HSA_AMD_SEGMENT_GLOBAL:
+        TmpStr = "GLOBAL";
+        break;
+      case HSA_AMD_SEGMENT_READONLY:
+        TmpStr = "READONLY";
+        break;
+      case HSA_AMD_SEGMENT_PRIVATE:
+        TmpStr = "PRIVATE";
+        break;
+      case HSA_AMD_SEGMENT_GROUP:
+        TmpStr = "GROUP";
+        break;
+      }
+      Items->push_back({"Pool " + TmpStr, "", 2});
+
+      if (Segment == HSA_AMD_SEGMENT_GLOBAL) {
+        Status = hsa_amd_memory_pool_get_info(
+            Region, HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, &GlobalFlags);
+        if (Status != HSA_STATUS_SUCCESS)
+          return HSA_STATUS_SUCCESS;
+
+        if (HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_KERNARG_INIT & GlobalFlags)
+          TmpStr2 += "KERNARG ";
+        if (HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_FINE_GRAINED & GlobalFlags)
+          TmpStr2 += "FINE GRAINED ";
+        if (HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_COARSE_GRAINED & GlobalFlags)
+          TmpStr2 += "COARSE GRAINED ";
+
+        Items->push_back({"Flags", TmpStr2, 3});
+      }
+
+      Status = hsa_amd_memory_pool_get_info(
+          Region, HSA_AMD_MEMORY_POOL_INFO_SIZE, &Size);
+      if (Status == HSA_STATUS_SUCCESS)
+        Items->push_back({"Size", std::to_string(Size) + " bytes", 3});
+
+      Status = hsa_amd_memory_pool_get_info(
+          Region, HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALLOWED, &Alloc);
+      if (Status == HSA_STATUS_SUCCESS)
+        Items->push_back({"Allocatable", (Alloc ? "TRUE" : "FALSE"), 3});
+
+      Status = hsa_amd_memory_pool_get_info(
+          Region, HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_GRANULE, &Size);
+      if (Status == HSA_STATUS_SUCCESS)
+        Items->push_back(
+            {"Runtime Alloc Granule", std::to_string(Size) + " bytes", 3});
+
+      Status = hsa_amd_memory_pool_get_info(
+          Region, HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALIGNMENT, &Size);
+      if (Status == HSA_STATUS_SUCCESS)
+        Items->push_back(
+            {"Runtime Alloc Alignment", std::to_string(Size) + " bytes", 3});
+
+      Status = hsa_amd_memory_pool_get_info(
+          Region, HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL, &Access);
+      if (Status == HSA_STATUS_SUCCESS)
+        Items->push_back({"Accessable by all", (Access ? "TRUE" : "FALSE"), 3});
+
+      return HSA_STATUS_SUCCESS;
+    };
+    // Iterate over all memory regions for this agent and get their properties.
+    hsa_amd_agent_iterate_memory_pools(Agent, CbMem, &Items);
+
+    Items.push_back({"ISAs", "", 1});
+    auto CBIsas = [](hsa_isa_t Isa, void *Data) -> hsa_status_t {
+      std::deque<PrintInfoTy> *Items =
+          static_cast<std::deque<PrintInfoTy> *>(Data);
+      assert(Items && "Null callback parameter");
+
+      char TmpChar[1000];
+      hsa_status_t Status =
+          hsa_isa_get_info_alt(Isa, HSA_ISA_INFO_NAME, TmpChar);
+      if (Status == HSA_STATUS_SUCCESS)
+        Items->push_back({"Name", TmpChar, 2});
+
+      return HSA_STATUS_SUCCESS;
+    };
+
+    // Iterate over all memory regions for this agent. Get the memory region
+    // type and size.
+    hsa_agent_iterate_isas(Agent, CBIsas, &Items);
+
     return Plugin::success();
   }
 
   /// Getters and setters for stack and heap sizes.
   Error getDeviceStackSize(uint64_t &Value) override {
     Value = 0;
     return Plugin::success();
   }

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

 //===- PluginInterface.h - Target independent plugin device interface -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_COMMON_PLUGININTERFACE_H
 #define OPENMP_LIBOMPTARGET_PLUGINS_NEXTGEN_COMMON_PLUGININTERFACE_H
 
 #include <cstddef>
 #include <cstdint>
+#include <deque>
 #include <list>
 #include <map>
 #include <shared_mutex>
 #include <vector>
 
 #include "Debug.h"
 #include "DeviceEnvironment.h"
 #include "GlobalHandler.h"
struct AsyncInfoWrapperTy {
   Error finalize(Error &Err);
 
 private:
   GenericDeviceTy &Device;
   __tgt_async_info LocalAsyncInfo;
   __tgt_async_info *AsyncInfoPtr;
 };
 
+/// Structure representing a print info item. Each item has a string key, a
+/// string value and the item level (starting at 1). The level specifies the
+/// indentation of the item when printing its key and value.
+struct PrintInfoTy {
+  std::string Key;
+  std::string Value;
+  uint64_t Level;
+
+  PrintInfoTy(const std::string &Key, const std::string &Value, uint64_t Level)
+      : Key(Key), Value(Value), Level(Level) {}
+
+  PrintInfoTy(const std::string &Key, const char *Value, uint64_t Level)
+      : Key(Key), Value(Value), Level(Level) {}
+
+  PrintInfoTy(const std::string &Key, char *Value, uint64_t Level)
+      : Key(Key), Value(Value), Level(Level) {}
+
+  template <typename T>
+  PrintInfoTy(const std::string &Key, T Value, uint64_t Level)
+      : Key(Key), Value(std::to_string(Value)), Level(Level) {}
+
+  PrintInfoTy() {}
+};
+
 /// Class wrapping a __tgt_device_image and its offload entry table on a
 /// specific device. This class is responsible for storing and managing
 /// the offload entries for an image on a device.
 class DeviceImageTy {
 
   /// Class representing the offload entry table. The class stores the
   /// __tgt_target_table and a map to search in the table faster.
   struct OffloadEntryTableTy {
     /// Add new entry to the table.
     void addEntry(const __tgt_offload_entry &Entry) {
       Entries.push_back(Entry);
       TTTablePtr.EntriesBegin = &Entries[0];
       TTTablePtr.EntriesEnd = TTTablePtr.EntriesBegin + Entries.size();
     }
 
     /// Get the raw pointer to the __tgt_target_table.
     operator __tgt_target_table *() {
       if (Entries.empty())
         return nullptr;
       return &TTTablePtr;
     }
 
   private:
     __tgt_target_table TTTablePtr;
     llvm::SmallVector<__tgt_offload_entry> Entries;
   };
 
   /// Image identifier within the corresponding device. Notice that this id is
   /// not unique between different device; they may overlap.
   int32_t ImageId;
 
   /// The pointer to the raw __tgt_device_image.
   const __tgt_device_image *TgtImage;
   const __tgt_device_image *TgtImageBitcode;
 
   /// Table of offload entries.
   OffloadEntryTableTy OffloadEntryTable;
 
 public:
   DeviceImageTy(int32_t Id, const __tgt_device_image *Image)
       : ImageId(Id), TgtImage(Image), TgtImageBitcode(nullptr) {
virtual Error waitEventImpl(void *EventPtr,
                               AsyncInfoWrapperTy &AsyncInfoWrapper) = 0;
 
   /// Synchronize the current thread with the event.
   Error syncEvent(void *EventPtr);
   virtual Error syncEventImpl(void *EventPtr) = 0;
 
   /// Print information about the device.
   Error printInfo();
-  virtual Error printInfoImpl() = 0;
+  virtual Error printInfoImpl(std::deque<PrintInfoTy> &Items) = 0;
 
   /// Getters of the grid values.
   uint32_t getWarpSize() const { return GridValues.GV_Warp_Size; }
   uint32_t getThreadLimit() const { return GridValues.GV_Max_WG_Size; }
   uint32_t getBlockLimit() const { return GridValues.GV_Max_Teams; }
   uint32_t getDefaultNumThreads() const {
     return GridValues.GV_Default_WG_Size;
   }

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

 
 Error GenericDeviceTy::initDeviceInfo(__tgt_device_info *DeviceInfo) {
   assert(DeviceInfo && "Invalid device info");
 
   return initDeviceInfoImpl(DeviceInfo);
 }
 
 Error GenericDeviceTy::printInfo() {
-  // TODO: Print generic information here
-  return printInfoImpl();
+  std::deque<PrintInfoTy> Items;
+
+  // Get the vendor-specific info items describing the properties of the device.
+  if (auto Err = printInfoImpl(Items))
+    return Err;
+
+  // Each level has four spaces.
+  constexpr uint64_t IndentLen = 4;
+
+  // Find the maximum key length (level + key) to compute the individual
+  // indentation of items.
+  uint64_t MaxKeyLen = 0;
+  for (const auto &Info : Items) {
+    if (!Info.Key.empty() &&
+        (Info.Key.size() + Info.Level * IndentLen > MaxKeyLen))
+      MaxKeyLen = Info.Key.size() + Info.Level * IndentLen;
+  }
+
+  // Print all info items.
+  for (const auto &Info : Items) {
+    if (Info.Key.empty()) {
+      fprintf(stdout, "\n");
+    } else {
+      // Compute the indentations for the item.
+      uint64_t KeyIndentLen = Info.Level * IndentLen;
+      uint64_t ValueIndentLen =
+          MaxKeyLen - (Info.Key.size() + Info.Level * IndentLen) + IndentLen;
+
+      fprintf(stdout, "%s%s:%s%s\n", std::string(KeyIndentLen, ' ').data(),
+              Info.Key.data(), std::string(ValueIndentLen, ' ').data(),
+              Info.Value.data());
+    }
+  }
+
+  return Plugin::success();
 }
 
 Error GenericDeviceTy::createEvent(void **EventPtrStorage) {
   return createEventImpl(EventPtrStorage);
 }
 
 Error GenericDeviceTy::destroyEvent(void *EventPtr) {
   return destroyEventImpl(EventPtr);

openmp/libomptarget/plugins-nextgen/cuda/src/rtl.cpp

struct CUDADeviceTy : public GenericDeviceTy {
   /// Synchronize the current thread with the event.
   Error syncEventImpl(void *EventPtr) override {
     CUevent Event = reinterpret_cast<CUevent>(EventPtr);
     CUresult Res = cuEventSynchronize(Event);
     return Plugin::check(Res, "Error in cuEventSynchronize: %s");
   }
 
   /// Print information about the device.
-  Error printInfoImpl() override {
+  Error printInfoImpl(std::deque<PrintInfoTy> &Items) override {
     char TmpChar[1000];
     std::string TmpStr;
     size_t TmpSt;
     int TmpInt, TmpInt2, TmpInt3;
 
     // TODO: All these calls should be checked, but the whole printInfo must be
     // improved, so we will refactor it in the future.
     cuDriverGetVersion(&TmpInt);

openmp/libomptarget/plugins-nextgen/generic-elf-64bit/src/rtl.cpp

struct GenELF64DeviceTy : public GenericDeviceTy {
   }
   Error waitEventImpl(void *EventPtr,
                       AsyncInfoWrapperTy &AsyncInfoWrapper) override {
     return Plugin::success();
   }
   Error syncEventImpl(void *EventPtr) override { return Plugin::success(); }
 
   /// Print information about the device.
-  Error printInfoImpl() override {
+  Error printInfoImpl(std::deque<PrintInfoTy> &Items) override {
     printf("    This is a generic-elf-64bit device\n");
     return Plugin::success();
   }
 
   /// This plugin should not setup the device environment.
   virtual bool shouldSetupDeviceEnvironment() const override { return false; };
 
   /// Getters and setters for stack size and heap size not relevant.