[SYCL][Fusion] Add HIP support (#11003)

The patch add support for HIP via the libamd_comgr:

- Add build path in sycl-fusion
- Add finalization routine inside hip adapter's build program

---------

Signed-off-by: Victor Lomuller <[email protected]>
Co-authored-by: Lukas Sommer <[email protected]>

Author: Victor Lomuller

clang/lib/Driver/Driver.cpp

@@ -5559,8 +5559,9 @@ class OffloadingActionBuilder final {
             DA.add(*DeviceWrappingAction, *TC, BoundArch, Action::OFK_SYCL);
             continue;
           }
-          if (IsNVPTX && Args.hasArg(options::OPT_fsycl_embed_ir)) {
-            // When compiling for Nvidia/CUDA devices and the user requested the
+          if ((IsNVPTX || IsAMDGCN) &&
+              Args.hasArg(options::OPT_fsycl_embed_ir)) {
+            // When compiling for Nvidia/AMD devices and the user requested the
             // IR to be embedded in the application (via option), run the output
             // of sycl-post-link (filetable referencing LLVM Bitcode + symbols)
             // through the offload wrapper and link the resulting object to the

clang/test/Driver/sycl-embed-ir.cpp

@@ -0,0 +1,19 @@
+/// Tests for -fsycl-embed-ir
+
+// UNSUPPORTED: system-windows
+
+// RUN: %clangxx -fsycl -fsycl-targets=nvidia_gpu_sm_80 -fsycl-embed-ir -ccc-print-phases %s 2>&1 | \
+// RUN: FileCheck -check-prefix=CHECK-NV %s
+
+// CHECK-NV: [[IR:[0-9]+]]: compiler, {4}, ir, (device-sycl, sm_80)
+// CHECK-NV: [[POSTLINK:[0-9]+]]: sycl-post-link, {{{.*}}}, ir, (device-sycl, sm_80)
+// CHECK-NV: [[WRAP:[0-9]+]]: clang-offload-wrapper, {[[POSTLINK]]}, object, (device-sycl, sm_80)
+// CHECK-NV: offload, "host-sycl (x86_64-unknown-linux-gnu)" {{{.*}}}, "device-sycl (nvptx64-nvidia-cuda:sm_80)" {[[WRAP]]}, "device-sycl (nvptx64-nvidia-cuda:sm_80)" {{{.*}}}, image
+
+// RUN: %clangxx -fsycl -fsycl-targets=amd_gpu_gfx1010 -fsycl-embed-ir -ccc-print-phases %s 2>&1 | \
+// RUN: FileCheck -check-prefix=CHECK-AMD %s
+
+// CHECK-AMD: [[IR:[0-9]+]]: compiler, {4}, ir, (device-sycl, gfx1010)
+// CHECK-AMD: [[POSTLINK:[0-9]+]]: sycl-post-link, {{{.*}}}, ir, (device-sycl, gfx1010)
+// CHECK-AMD: [[WRAP:[0-9]+]]: clang-offload-wrapper, {[[POSTLINK]]}, object, (device-sycl, gfx1010)
+// CHECK-AMD: offload, "host-sycl (x86_64-unknown-linux-gnu)" {{{.*}}}, "device-sycl (amdgcn-amd-amdhsa:gfx1010)" {[[WRAP]]}, "device-sycl (amdgcn-amd-amdhsa:gfx1010)" {{{.*}}}, image

sycl-fusion/common/include/Kernel.h

@@ -20,6 +20,30 @@ namespace jit_compiler {
 
 using BinaryAddress = const uint8_t *;
 
+/// Possible barrier flags
+enum class BarrierFlags : uint32_t {
+  None = 0,   // Do not insert barrier
+  Local = 1,  // Ensure correct ordering of memory operations to local memory
+  Global = 2, // Ensure correct ordering of memory operations to global memory
+  LocalAndGlobal = Local | Global
+};
+
+constexpr BarrierFlags getNoBarrierFlag() { return BarrierFlags::None; }
+constexpr BarrierFlags getLocalAndGlobalBarrierFlag() {
+  return BarrierFlags::LocalAndGlobal;
+}
+constexpr bool isNoBarrierFlag(BarrierFlags Flag) {
+  return Flag == BarrierFlags::None;
+}
+constexpr bool hasLocalBarrierFlag(BarrierFlags Flag) {
+  return static_cast<uint32_t>(Flag) &
+         static_cast<uint32_t>(BarrierFlags::Local);
+}
+constexpr bool hasGlobalBarrierFlag(BarrierFlags Flag) {
+  return static_cast<uint32_t>(Flag) &
+         static_cast<uint32_t>(BarrierFlags::Global);
+}
+
 ///
 /// Enumerate possible kinds of parameters.
 /// 1:1 correspondence with the definition in kernel_desc.hpp in the DPC++ SYCL
@@ -35,7 +59,7 @@ enum class ParameterKind : uint32_t {
 };
 
 /// Different binary formats supported as input to the JIT compiler.
-enum class BinaryFormat : uint32_t { INVALID, LLVM, SPIRV, PTX };
+enum class BinaryFormat : uint32_t { INVALID, LLVM, SPIRV, PTX, AMDGCN };
 
 /// Information about a device intermediate representation module (e.g., SPIR-V,
 /// LLVM IR) from DPC++.

sycl-fusion/common/lib/KernelIO.h

@@ -48,6 +48,7 @@ template <> struct ScalarEnumerationTraits<jit_compiler::BinaryFormat> {
     IO.enumCase(BF, "LLVM", jit_compiler::BinaryFormat::LLVM);
     IO.enumCase(BF, "SPIRV", jit_compiler::BinaryFormat::SPIRV);
     IO.enumCase(BF, "PTX", jit_compiler::BinaryFormat::PTX);
+    IO.enumCase(BF, "AMDGCN", jit_compiler::BinaryFormat::AMDGCN);
     IO.enumCase(BF, "INVALID", jit_compiler::BinaryFormat::INVALID);
   }
 };

sycl-fusion/jit-compiler/CMakeLists.txt

@@ -9,6 +9,9 @@ add_llvm_library(sycl-fusion
    lib/fusion/ModuleHelper.cpp
    lib/helper/ConfigHelper.cpp
 
+   DEPENDS
+   intrinsics_gen
+
    LINK_COMPONENTS
    BitReader
    Core
@@ -50,6 +53,10 @@ if("NVPTX" IN_LIST LLVM_TARGETS_TO_BUILD)
   target_compile_definitions(sycl-fusion PRIVATE FUSION_JIT_SUPPORT_PTX)
 endif()
 
+if("AMDGPU" IN_LIST LLVM_TARGETS_TO_BUILD)
+  target_compile_definitions(sycl-fusion PRIVATE FUSION_JIT_SUPPORT_AMDGCN)
+endif()
+
 if (BUILD_SHARED_LIBS)
   if(NOT MSVC AND NOT APPLE)
     # Manage symbol visibility through the linker to make sure no LLVM symbols

sycl-fusion/jit-compiler/include/JITContext.h

@@ -19,6 +19,7 @@
 
 #include "Hashing.h"
 #include "Kernel.h"
+#include "Options.h"
 #include "Parameter.h"
 
 namespace llvm {
@@ -28,7 +29,7 @@ class LLVMContext;
 namespace jit_compiler {
 
 using CacheKeyT =
-    std::tuple<std::vector<std::string>, ParamIdentList, int,
+    std::tuple<std::vector<std::string>, ParamIdentList, BarrierFlags,
                std::vector<ParameterInternalization>, std::vector<JITConstant>,
                // This field of the cache is optional because, if all of the
                // ranges are equal, we will perform no remapping, so that fused

sycl-fusion/jit-compiler/include/KernelFusion.h

@@ -60,7 +60,8 @@ class KernelFusion {
               const std::vector<SYCLKernelInfo> &KernelInformation,
               const std::vector<std::string> &KernelsToFuse,
               const std::string &FusedKernelName,
-              jit_compiler::ParamIdentList &Identities, int BarriersFlags,
+              jit_compiler::ParamIdentList &Identities,
+              BarrierFlags BarriersFlags,
               const std::vector<jit_compiler::ParameterInternalization>
                   &Internalization,
               const std::vector<jit_compiler::JITConstant> &JITConstants);

sycl-fusion/jit-compiler/lib/KernelFusion.cpp

@@ -58,6 +58,13 @@ static bool isTargetFormatSupported(BinaryFormat TargetFormat) {
 #else  // FUSION_JIT_SUPPORT_PTX
     return false;
 #endif // FUSION_JIT_SUPPORT_PTX
+  }
+  case BinaryFormat::AMDGCN: {
+#ifdef FUSION_JIT_SUPPORT_AMDGCN
+    return true;
+#else  // FUSION_JIT_SUPPORT_AMDGCN
+    return false;
+#endif // FUSION_JIT_SUPPORT_AMDGCN
   }
   default:
     return false;
@@ -69,7 +76,7 @@ FusionResult KernelFusion::fuseKernels(
     const std::vector<SYCLKernelInfo> &KernelInformation,
     const std::vector<std::string> &KernelsToFuse,
     const std::string &FusedKernelName, ParamIdentList &Identities,
-    int BarriersFlags,
+    BarrierFlags BarriersFlags,
     const std::vector<jit_compiler::ParameterInternalization> &Internalization,
     const std::vector<jit_compiler::JITConstant> &Constants) {
   // Initialize the configuration helper to make the options for this invocation

sycl-fusion/jit-compiler/lib/fusion/FusionPipeline.cpp

@@ -40,7 +40,7 @@ static unsigned getFlatAddressSpace(Module &Mod) {
   // Ideally, we could get this information from the TargetTransformInfo, but
   // the SPIR-V backend does not yet seem to have an implementation for that.
   llvm::Triple Tri(Mod.getTargetTriple());
-  if (Tri.isNVPTX()) {
+  if (Tri.isNVPTX() || Tri.isAMDGCN()) {
     return 0;
   }
   if (Tri.isSPIRV() || Tri.isSPIR()) {
@@ -53,7 +53,7 @@ static unsigned getFlatAddressSpace(Module &Mod) {
 
 std::unique_ptr<SYCLModuleInfo>
 FusionPipeline::runFusionPasses(Module &Mod, SYCLModuleInfo &InputInfo,
-                                int BarriersFlags) {
+                                BarrierFlags BarriersFlags) {
   // Perform the actual kernel fusion, i.e., generate a kernel function for the
   // fused kernel from the kernel functions of the input kernels. This is done
   // by the SYCLKernelFusion LLVM pass, which is run here through a custom LLVM

sycl-fusion/jit-compiler/lib/fusion/FusionPipeline.h

@@ -25,7 +25,7 @@ class FusionPipeline {
   /// contain an entry for the fused kernel.
   static std::unique_ptr<SYCLModuleInfo>
   runFusionPasses(llvm::Module &Mod, SYCLModuleInfo &InputInfo,
-                  int BarriersFlags);
+                  BarrierFlags BarriersFlags);
 };
 } // namespace fusion
 } // namespace jit_compiler