[sycl-ls] Enhance sycl-ls Architecture output

sycl/tools/sycl-ls/sycl-ls.cpp

@@ -19,12 +19,14 @@
 #include <sycl/sycl.hpp>
 
 #include <algorithm>
+#include <cctype>
 #include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <map>
 #include <sstream>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #ifdef __linux__
@@ -47,6 +49,45 @@
 using namespace sycl;
 using namespace std::literals;
 
+namespace {
+
+namespace syclex = sycl::ext::oneapi::experimental;
+
+struct ArchitectureNameEntry {
+  syclex::architecture Arch;
+  std::string_view Name;
+};
+
+bool isNumericIntelGpuAlias(std::string_view Name) {
+  constexpr std::string_view Prefix = "intel_gpu_";
+  return Name.size() > Prefix.size() &&
+         Name.compare(0, Prefix.size(), Prefix) == 0 &&
+         std::isdigit(static_cast<unsigned char>(Name[Prefix.size()]));
+}
+
+std::string getArchitectureName(syclex::architecture Arch) {
+  static constexpr ArchitectureNameEntry ArchitectureNames[] = {
+#define __SYCL_ARCHITECTURE(ARCH, VAL) {syclex::architecture::ARCH, #ARCH},
+#define __SYCL_ARCHITECTURE_ALIAS(ARCH, VAL) {syclex::architecture::VAL, #ARCH},
+#include <sycl/ext/oneapi/experimental/device_architecture.def>
+#undef __SYCL_ARCHITECTURE
+#undef __SYCL_ARCHITECTURE_ALIAS
+  };
+
+  std::string Result;
+  for (const auto &Entry : ArchitectureNames) {
+    if (Entry.Arch != Arch || isNumericIntelGpuAlias(Entry.Name))
+      continue;
+    if (!Result.empty())
+      Result += " / ";
+    Result += Entry.Name;
+  }
+
+  return Result.empty() ? "unknown" : Result;
+}
+
+} // namespace
+
 // Controls verbose output vs. concise.
 bool verbose;
 
@@ -83,19 +124,9 @@ std::string getDeviceTypeName(const device &Device) {
   }
 }
 
-const char *getArchName(const device &Device) {
-  namespace syclex = sycl::ext::oneapi::experimental;
-  auto arch = Device.get_info<syclex::info::device::architecture>();
-  switch (arch) {
-#define __SYCL_ARCHITECTURE(ARCH, VAL)                                         \
-  case syclex::architecture::ARCH:                                             \
-    return #ARCH;
-#define __SYCL_ARCHITECTURE_ALIAS(ARCH, VAL)
-#include <sycl/ext/oneapi/experimental/device_architecture.def>
-#undef __SYCL_ARCHITECTURE
-#undef __SYCL_ARCHITECTURE_ALIAS
-  }
-  return "unknown";
+std::string getArchName(const device &Device) {
+  auto Arch = Device.get_info<syclex::info::device::architecture>();
+  return getArchitectureName(Arch);
 }
 
 template <typename RangeTy, typename ElemTy>

sycl/unittests/Extensions/CMakeLists.txt

@@ -23,6 +23,7 @@ add_sycl_unittest(ExtensionsTests OBJECT
   LaunchQueries.cpp
   EventMode.cpp
   DeviceInfo.cpp
+  SyclLsArchitectureName.cpp
   RootGroup.cpp
   USMPrefetch.cpp
   RegisterHostMemory.cpp

sycl/unittests/Extensions/SyclLsArchitectureName.cpp

@@ -0,0 +1,93 @@
+//==---------------- SyclLsArchitectureName.cpp ---------------------------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <gtest/gtest.h>
+
+#include <sycl/ext/oneapi/experimental/device_architecture.hpp>
+
+#include <string>
+#include <vector>
+
+// sycl-ls.cpp uses aspect::image; suppress the deprecation warning.
+#define SYCL_DISABLE_IMAGE_ASPECT_WARNING
+#define main sycl_ls_main
+#include "../../tools/sycl-ls/sycl-ls.cpp"
+#undef main
+
+namespace syclex = sycl::ext::oneapi::experimental;
+
+struct ArchitectureNameCase {
+  syclex::architecture Arch;
+  std::string Expected;
+};
+
+std::vector<ArchitectureNameCase> getArchitectureNameCases() {
+  return {
+      {syclex::architecture::intel_gpu_apl, "intel_gpu_apl / intel_gpu_bxt"},
+      {syclex::architecture::intel_gpu_bxt, "intel_gpu_apl / intel_gpu_bxt"},
+      {syclex::architecture::intel_gpu_icllp,
+       "intel_gpu_icllp / intel_gpu_icl"},
+      {syclex::architecture::intel_gpu_icl, "intel_gpu_icllp / intel_gpu_icl"},
+      {syclex::architecture::intel_gpu_ehl, "intel_gpu_ehl / intel_gpu_jsl"},
+      {syclex::architecture::intel_gpu_jsl, "intel_gpu_ehl / intel_gpu_jsl"},
+      {syclex::architecture::intel_gpu_tgllp,
+       "intel_gpu_tgllp / intel_gpu_tgl"},
+      {syclex::architecture::intel_gpu_tgl, "intel_gpu_tgllp / intel_gpu_tgl"},
+      {syclex::architecture::intel_gpu_adl_s,
+       "intel_gpu_adl_s / intel_gpu_rpl_s"},
+      {syclex::architecture::intel_gpu_rpl_s,
+       "intel_gpu_adl_s / intel_gpu_rpl_s"},
+      {syclex::architecture::intel_gpu_acm_g10,
+       "intel_gpu_acm_g10 / intel_gpu_dg2_g10"},
+      {syclex::architecture::intel_gpu_dg2_g10,
+       "intel_gpu_acm_g10 / intel_gpu_dg2_g10"},
+      {syclex::architecture::intel_gpu_acm_g11,
+       "intel_gpu_acm_g11 / intel_gpu_dg2_g11"},
+      {syclex::architecture::intel_gpu_dg2_g11,
+       "intel_gpu_acm_g11 / intel_gpu_dg2_g11"},
+      {syclex::architecture::intel_gpu_acm_g12,
+       "intel_gpu_acm_g12 / intel_gpu_dg2_g12"},
+      {syclex::architecture::intel_gpu_dg2_g12,
+       "intel_gpu_acm_g12 / intel_gpu_dg2_g12"},
+      {syclex::architecture::intel_gpu_mtl_u,
+       "intel_gpu_mtl_u / intel_gpu_mtl_s / intel_gpu_arl_u / "
+       "intel_gpu_arl_s"},
+      {syclex::architecture::intel_gpu_mtl_s,
+       "intel_gpu_mtl_u / intel_gpu_mtl_s / intel_gpu_arl_u / "
+       "intel_gpu_arl_s"},
+      {syclex::architecture::intel_gpu_arl_u,
+       "intel_gpu_mtl_u / intel_gpu_mtl_s / intel_gpu_arl_u / "
+       "intel_gpu_arl_s"},
+      {syclex::architecture::intel_gpu_arl_s,
+       "intel_gpu_mtl_u / intel_gpu_mtl_s / intel_gpu_arl_u / "
+       "intel_gpu_arl_s"},
+      {syclex::architecture::intel_gpu_nvl_s,
+       "intel_gpu_nvl_s / intel_gpu_nvl_hx / intel_gpu_nvl_ul"},
+      {syclex::architecture::intel_gpu_nvl_hx,
+       "intel_gpu_nvl_s / intel_gpu_nvl_hx / intel_gpu_nvl_ul"},
+      {syclex::architecture::intel_gpu_nvl_ul,
+       "intel_gpu_nvl_s / intel_gpu_nvl_hx / intel_gpu_nvl_ul"},
+      {syclex::architecture::intel_gpu_nvl_u,
+       "intel_gpu_nvl_u / intel_gpu_nvl_h"},
+      {syclex::architecture::intel_gpu_nvl_h,
+       "intel_gpu_nvl_u / intel_gpu_nvl_h"},
+  };
+}
+
+TEST(SyclLsArchitectureNameTest, PrintsAllAliases) {
+  for (const auto &Case : getArchitectureNameCases())
+    EXPECT_EQ(getArchitectureName(Case.Arch), Case.Expected);
+}
+
+TEST(SyclLsArchitectureNameTest, HidesNumericAliasesFromOutput) {
+  EXPECT_EQ(getArchitectureName(syclex::architecture::intel_gpu_mtl_u),
+            "intel_gpu_mtl_u / intel_gpu_mtl_s / intel_gpu_arl_u / "
+            "intel_gpu_arl_s");
+  EXPECT_EQ(getArchitectureName(syclex::architecture::intel_gpu_bmg_g21),
+            "intel_gpu_bmg_g21");
+}