[Driver] Enable --offload-arch for SYCL AOT compilation with the new

srividya-sundaram · srividya-sundaram · commit afd6a5cb61fe · 2024-09-08T22:11:23.000-07:00
offload driver.
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
@@ -1022,7 +1022,7 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
 
       for (const auto &TripleAndArchs : DerivedArchs)
         OpenMPTriples.insert(TripleAndArchs.first());
-    }
+    } // end of offload-arch
 
     for (StringRef Val : OpenMPTriples) {
       llvm::Triple TT(ToolChain::getOpenMPTriple(Val));
@@ -1109,6 +1109,7 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
   };
 
   Arg *SYCLTargets = getArgRequiringSYCLRuntime(options::OPT_fsycl_targets_EQ);
+  Arg *SYCLOffloadArch = getArgRequiringSYCLRuntime(options::OPT_offload_arch_EQ);
 
   // Check if -fsycl-host-compiler is used in conjunction with -fsycl.
   Arg *SYCLHostCompiler =
@@ -1182,12 +1183,14 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
   llvm::StringMap<llvm::DenseSet<StringRef>> DerivedArchs;
   llvm::StringMap<StringRef> FoundNormalizedTriples;
   llvm::SmallVector<llvm::Triple, 4> UniqueSYCLTriplesVec;
+//llvm::StringSet<> SYCLTriples;
+  std::multiset<StringRef> SYCLTriples;  
   if (HasSYCLTargetsOption) {
     // At this point, we know we have a valid combination
     // of -fsycl*target options passed
     Arg *SYCLTargetsValues = SYCLTargets;
     if (SYCLTargetsValues) {
-      llvm::StringSet<> SYCLTriples;
+
       if (SYCLTargetsValues->getNumValues()) {
 
         // Multiple targets are currently not supported when using
@@ -1275,10 +1278,12 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
           SYCLTriples.insert(DeviceTriple.normalize());
           if (!Arch.empty())
             DerivedArchs[DeviceTriple.getTriple()].insert(Arch);
-        }
+        } // end of SYCLTargetsValues for loop
+
         if (!SYCLTriples.empty()) {
           for (const auto &SYCLTriple : SYCLTriples) {
-            llvm::Triple Triple(SYCLTriple.getKey());
+            //llvm::Triple TT(MakeSYCLDeviceTriple(Val));
+            llvm::Triple Triple(MakeSYCLDeviceTriple(SYCLTriple));
             UniqueSYCLTriplesVec.push_back(Triple);
           }
         }
@@ -1287,7 +1292,93 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
         Diag(clang::diag::warn_drv_empty_joined_argument)
             << SYCLTargetsValues->getAsString(C.getInputArgs());
     }
-  } else {
+  } else if(SYCLOffloadArch) {
+      const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
+      auto AMDTriple = getHIPOffloadTargetTriple(*this, C.getInputArgs());
+      auto NVPTXTriple = getNVIDIAOffloadTargetTriple(*this, C.getInputArgs(),
+                                                      HostTC->getTriple());
+
+      // Attempt to deduce the offloading triple from the set of architectures.
+      // We can only correctly deduce NVPTX / AMDGPU triples currently. We need
+      // to temporarily create these toolchains so that we can access tools for
+      // inferring architectures.
+      llvm::DenseSet<StringRef> Archs;
+      if (NVPTXTriple) {
+        auto TempTC = std::make_unique<toolchains::CudaToolChain>(
+            *this, *NVPTXTriple, *HostTC, C.getInputArgs(), Action::OFK_None);
+        for (StringRef Arch : getOffloadArchs(
+                 C, C.getArgs(), Action::OFK_SYCL, &*TempTC, true))
+          Archs.insert(Arch);
+      }
+      if (AMDTriple) {
+        auto TempTC = std::make_unique<toolchains::AMDGPUOpenMPToolChain>(
+            *this, *AMDTriple, *HostTC, C.getInputArgs());
+        for (StringRef Arch : getOffloadArchs(
+                 C, C.getArgs(), Action::OFK_SYCL, &*TempTC, true))
+          Archs.insert(Arch);
+      }
+      if (!AMDTriple && !NVPTXTriple) {
+        for (StringRef Arch :
+             getOffloadArchs(C, C.getArgs(), Action::OFK_SYCL, nullptr, true))
+          Archs.insert(Arch);
+      }    
+      for (StringRef Arch : Archs) {
+        if (NVPTXTriple && IsNVIDIAOffloadArch(StringToOffloadArch(
+                               getProcessorFromTargetID(*NVPTXTriple, Arch)))) {
+          DerivedArchs[NVPTXTriple->getTriple()].insert(Arch);
+        } else if (AMDTriple &&
+                   IsAMDOffloadArch(StringToOffloadArch(
+                       getProcessorFromTargetID(*AMDTriple, Arch)))) {
+          DerivedArchs[AMDTriple->getTriple()].insert(Arch);
+        }
+        else if (IsIntelCPUOffloadArch(StringToOffloadArchIntel(Arch))) {
+                    DerivedArchs["spir64_x86_64"].insert(Arch);
+        } else if(IsIntelGPUOffloadArch(StringToOffloadArchIntel(Arch))) {
+                    DerivedArchs["spir64_gen"].insert(Arch);
+        }
+        else {
+          Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch) << Arch;
+          return;
+        }
+      }
+      // If the set is empty then we failed to find a native architecture.
+      if (Archs.empty()) {
+        Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch)
+            << "native";
+        return;
+      }
+
+      for (const auto &TripleAndArchs : DerivedArchs)
+        SYCLTriples.insert(TripleAndArchs.first()); // ["triple -> arch"]
+
+
+for (StringRef Val : SYCLTriples) {
+      llvm::Triple TT(MakeSYCLDeviceTriple(Val));
+      std::string NormalizedName = TT.normalize();
+
+      // Make sure we don't have a duplicate triple.
+      auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
+      if (Duplicate != FoundNormalizedTriples.end()) {
+        Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
+            << Val << Duplicate->second;
+        continue;
+      }
+
+      // Store the current triple so that we can check for duplicates in the
+      // following iterations.
+      FoundNormalizedTriples[NormalizedName] = Val;
+}
+
+        if (!SYCLTriples.empty()) {
+          for (const auto &SYCLTriple : SYCLTriples) {
+            llvm::Triple Triple(MakeSYCLDeviceTriple(SYCLTriple));
+            UniqueSYCLTriplesVec.push_back(Triple);
+          }
+        }
+        addSYCLDefaultTriple(C, UniqueSYCLTriplesVec);
+       
+} // end of --offload-arch
+  else {
     // If -fsycl is supplied without -fsycl-targets we will assume SPIR-V.
     // For -fsycl-device-only, we also setup the implied triple as needed.
     if (HasValidSYCLRuntime) {
diff --git a/clang/lib/Driver/ToolChains/SYCL.cpp b/clang/lib/Driver/ToolChains/SYCL.cpp
@@ -27,6 +27,31 @@ using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
+struct StringToOffloadArchIntelMap {
+  const char *ArchName;
+  OffloadArchIntel IntelArch;
+};
+
+static const StringToOffloadArchIntelMap StringToArchNamesMap[] = {
+    {"broadwell", OffloadArchIntel::BROADWELL},
+    {"coffeelake", OffloadArchIntel::COFFEELAKE},
+    {"icelake-client", OffloadArchIntel::ICELAKECLIENT},
+    {"bdw", OffloadArchIntel::BDW},
+    {"cfl", OffloadArchIntel::CFL},
+    {"icl", OffloadArchIntel::ICL}};
+
+OffloadArchIntel
+clang::driver::StringToOffloadArchIntel(llvm::StringRef ArchNameAsString) {
+  auto result = std::find_if(
+      std::begin(StringToArchNamesMap), std::end(StringToArchNamesMap),
+      [ArchNameAsString](const StringToOffloadArchIntelMap &map) {
+        return ArchNameAsString == map.ArchName;
+      });
+  if (result == std::end(StringToArchNamesMap))
+    return OffloadArchIntel::UNKNOWN;
+  return result->IntelArch;
+}
+
 SYCLInstallationDetector::SYCLInstallationDetector(const Driver &D)
     : D(D), InstallationCandidates() {
   InstallationCandidates.emplace_back(D.Dir + "/..");
diff --git a/clang/lib/Driver/ToolChains/SYCL.h b/clang/lib/Driver/ToolChains/SYCL.h
@@ -16,6 +16,82 @@
 namespace clang {
 namespace driver {
 
+// List of supported Intel values for CPUs
+// and GPUs.
+enum class OffloadArchIntel {
+  // CPUs
+  UNKNOWN,
+  SKYLAKEAVX512,
+  COREAVX2,
+  COREI7AVX,
+  COREI7,
+  WESTMERE,
+  SANDYBRIDGE,
+  IVYBRIDGE,
+  BROADWELL,
+  COFFEELAKE,
+  ALDERLAKE,
+  SKYLAKE,
+  SKX,
+  CASCADELAKE,
+  ICELAKECLIENT,
+  ICELAKESERVER,
+  SAPPHIRERAPIDS,
+  GRANITERAPIDS,
+  // GPUs
+  BDW,
+  SKL,
+  KBL,
+  CFL,
+  APL,
+  BXT,
+  GLK,
+  WHL,
+  AML,
+  CML,
+  ICLLP,
+  ICL,
+  EHL,
+  JSL,
+  TGLLP,
+  TGL,
+  RKL,
+  ADL_S,
+  RPL_S,
+  ADL_P,
+  ADL_N,
+  DG1,
+  ACM_G10,
+  DG2_G10,
+  ACM_G11,
+  DG2_GLL,
+  ACM_G12,
+  DG2_G12,
+  PVC,
+  PVC_VG,
+  MTL_U,
+  MTL_S,
+  ARL_U,
+  ARL_S,
+  MTL_H,
+  ARL_H,
+  BMG_G21,
+  LNL_M
+};
+
+// Check if the given Arch value is a valid Intel CPU.
+static inline bool IsIntelCPUOffloadArch(OffloadArchIntel Arch) {
+  return Arch >= OffloadArchIntel::SKYLAKEAVX512 &&
+         Arch < OffloadArchIntel::BDW;
+}
+
+// Check if the given Arch value is a valid Intel GPU.
+static inline bool IsIntelGPUOffloadArch(OffloadArchIntel Arch) {
+  return Arch >= OffloadArchIntel::BDW && Arch <= OffloadArchIntel::LNL_M;
+}
+
+OffloadArchIntel StringToOffloadArchIntel(llvm::StringRef ArchNameAsString);
+
 class SYCLInstallationDetector {
 public:
   SYCLInstallationDetector(const Driver &D);
diff --git a/clang/test/Driver/sycl-offload-arch-intelgpu.cpp b/clang/test/Driver/sycl-offload-arch-intelgpu.cpp
@@ -0,0 +1,10 @@
+/// Tests the behaviors of using -fsycl --offload-new-driver 
+//  --offload-arch=<intel-gpu-values>.
+
+// RUN: %clangxx -### --offload-new-driver -fsycl --offload-arch=bdw %s 2>&1 | \
+// RUN:   FileCheck %s --check-prefixes=DEVICE,MACRO -DDEV_STR=bdw -DMAC_STR=BDW
+// MACRO: clang{{.*}} "-triple" "spir64_gen-unknown-unknown"
+// MACRO: "-D__SYCL_TARGET_INTEL_GPU_[[MAC_STR]]__"
+// MACRO: clang{{.*}} "-fsycl-is-host"
+// MACRO: "-D__SYCL_TARGET_INTEL_GPU_[[MAC_STR]]__"
+// DEVICE: ocloc{{.*}} "-device" "[[DEV_STR]]"
