[SYCL][Fusion][NoSTL] Replace YAML I/O for SYCLModuleInfo by metadata-backed approach (intel#12262)

For testing purposes, the `SYCLModuleInfo` data structure (and its
dependents) implemented LLVM's YAML traits for easy (de-)serialization.
However, as the YAML infrastructure requires the participating structs
to support dynamic construction of their instances (e.g. growing a
vector of argument types during parsing), this is detrimental to our
goal of dropping STL classes from the fusion interface.

This PR rewrites the affected lit tests by encoding the information to
be injected as a named metadata in the IR module. Only tests for the
kernel fusion pass actually require the module info; it could be dropped
without replacement from the internalization and CP tests. We also no
longer encode the binary format information as the tests were not
sensitive to it. The named metadata is not intended to persist across
the pipeline, and is currently erased right after parsing. The YAML
export was replaced by a simpler (but still YAML-inspired) textual dump
of the module info.

*This PR is part of a series of changes to remove uses of STL classes in
the kernel fusion interface to prevent ABI issues in the future.*

---------

Signed-off-by: Julian Oppermann <julian.oppermann@codeplay.com>

Author: jopperm

sycl-fusion/common/include/Kernel.h

@@ -111,8 +111,6 @@ struct SYCLKernelBinaryInfo {
 struct SYCLKernelAttribute {
   using AttributeValueList = std::vector<std::string>;
 
-  // Explicit constructor for compatibility with LLVM YAML I/O.
-  SYCLKernelAttribute() : Values{} {};
   SYCLKernelAttribute(std::string Name)
       : AttributeName{std::move(Name)}, Values{} {}
 
@@ -135,18 +133,11 @@ enum ArgUsage : uint8_t {
 
 ///
 /// Encode usage of parameters for the actual kernel function.
-// This is a vector of unsigned char, because std::vector<bool> is a weird
-// construct and unlike all other std::vectors, and LLVM YAML I/O is having a
-// hard time coping with it.
 using ArgUsageMask = std::vector<std::underlying_type_t<ArgUsage>>;
 
 ///
 /// Describe the list of arguments by their kind.
 struct SYCLArgumentDescriptor {
-
-  // Explicit constructor for compatibility with LLVM YAML I/O.
-  SYCLArgumentDescriptor() : Kinds{}, UsageMask{} {}
-
   std::vector<ParameterKind> Kinds;
 
   ArgUsageMask UsageMask;
@@ -277,9 +268,6 @@ struct SYCLKernelInfo {
 
   SYCLKernelBinaryInfo BinaryInfo;
 
-  //// Explicit constructor for compatibility with LLVM YAML I/O.
-  SYCLKernelInfo() : Name{}, Args{}, Attributes{}, NDR{}, BinaryInfo{} {}
-
   SYCLKernelInfo(const std::string &KernelName,
                  const SYCLArgumentDescriptor &ArgDesc, const NDRange &NDR,
                  const SYCLKernelBinaryInfo &BinInfo)

sycl-fusion/common/lib/KernelIO.h

@@ -8,7 +8,6 @@
 
 #include "KernelFusion.h"
 #include "Kernel.h"
-#include "KernelIO.h"
 #include "NDRangesHelper.h"
 #include "Options.h"
 #include "fusion/FusionHelper.h"

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

@@ -8,44 +8,109 @@
 
 #include "SYCLKernelInfo.h"
 
-#include "KernelIO.h"
+#include "metadata/MDParsing.h"
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FormattedStream.h"
 
 using namespace llvm;
 using namespace jit_compiler;
 
-static llvm::cl::opt<std::string>
-    ModuleInfoFilePath("sycl-info-path",
-                       llvm::cl::desc("Path to the SYCL module info YAML file"),
-                       llvm::cl::value_desc("filename"), llvm::cl::init(""));
-
 llvm::AnalysisKey SYCLModuleInfoAnalysis::Key;
 
-void SYCLModuleInfoAnalysis::loadModuleInfoFromFile() {
+// Keep this in sync with the enum definition in
+// `sycl-fusion/common/include/Kernel.h`.
+static constexpr unsigned NumParameterKinds = 6;
+static constexpr std::array<llvm::StringLiteral, NumParameterKinds>
+    ParameterKindStrings = {
+        StringLiteral{"Accessor"},
+        StringLiteral{"StdLayout"},
+        StringLiteral{"Sampler"},
+        StringLiteral{"Pointer"},
+        StringLiteral{"SpecConstantBuffer"},
+        StringLiteral{"Stream"},
+};
+static constexpr llvm::StringLiteral InvalidParameterKindString{"Invalid"};
+
+void SYCLModuleInfoAnalysis::loadModuleInfoFromMetadata(Module &M) {
   DiagnosticPrinterRawOStream Printer{llvm::errs()};
-  ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrError =
-      MemoryBuffer::getFile(ModuleInfoFilePath);
-  if (std::error_code EC = FileOrError.getError()) {
-    Printer << "Could not open file " << ModuleInfoFilePath << " due to error "
-            << EC.message() << "\n";
-    return;
-  }
-  llvm::yaml::Input In{FileOrError->get()->getMemBufferRef()};
   ModuleInfo = std::make_unique<SYCLModuleInfo>();
-  In >> *ModuleInfo;
-  if (In.error()) {
-    Printer << "Error parsing YAML from " << ModuleInfoFilePath << ": "
-            << In.error().message() << "\n";
+  auto *MIMD = M.getNamedMetadata(ModuleInfoMDKey);
+  if (!MIMD) {
+    Printer << "No !" << ModuleInfoMDKey << " metadata found in module\n";
     return;
   }
+
+  for (auto *KIMD : MIMD->operands()) {
+    assert(KIMD->getNumOperands() >= 3 && "Incomplete kernel info entry");
+    const auto *It = KIMD->op_begin(), *End = KIMD->op_end();
+
+    // Operand 0: Kernel name
+    auto Name = cast<MDString>(*It)->getString().str();
+    SYCLKernelInfo KernelInfo{std::move(Name)};
+    ++It;
+
+    // Operand 1: Argument kinds
+    auto *ArgsKindsMD = cast<MDNode>(*It);
+    llvm::transform(
+        ArgsKindsMD->operands(), std::back_inserter(KernelInfo.Args.Kinds),
+        [](const auto &Op) {
+          auto KindStr = cast<MDString>(Op)->getString();
+          auto It = std::find_if(
+              ParameterKindStrings.begin(), ParameterKindStrings.end(),
+              [&KindStr](auto &SL) { return KindStr == SL; });
+          if (It == ParameterKindStrings.end()) {
+            return ParameterKind::Invalid;
+          }
+          auto Idx = std::distance(ParameterKindStrings.begin(), It);
+          return static_cast<ParameterKind>(Idx);
+        });
+    ++It;
+
+    // Operand 2: Argument usage mask
+    auto *ArgsUsageMaskMD = cast<MDNode>(*It);
+    llvm::transform(
+        ArgsUsageMaskMD->operands(),
+        std::back_inserter(KernelInfo.Args.UsageMask), [](const auto &Op) {
+          auto UIntOrErr = metadataToUInt<std::underlying_type_t<ArgUsage>>(Op);
+          if (UIntOrErr.takeError()) {
+            llvm_unreachable("Invalid kernel info metadata");
+          }
+          return *UIntOrErr;
+        });
+    ++It;
+
+    // Operands 3..n: Attributes
+    for (; It != End; ++It) {
+      auto *AIMD = cast<MDNode>(*It);
+      assert(AIMD->getNumOperands() > 1);
+      const auto *AttrIt = AIMD->op_begin(), *AttrEnd = AIMD->op_end();
+
+      // Operand 0: Attribute name
+      auto Name = cast<MDString>(*AttrIt)->getString().str();
+      ++AttrIt;
+
+      // Operands 1..m: String values
+      auto &KernelAttr = KernelInfo.Attributes.emplace_back(std::move(Name));
+      for (; AttrIt != AttrEnd; ++AttrIt) {
+        auto Value = cast<MDString>(*AttrIt)->getString().str();
+        KernelAttr.Values.emplace_back(std::move(Value));
+      }
+    }
+
+    ModuleInfo->addKernel(KernelInfo);
+  }
+
+  // Metadata is no longer needed.
+  MIMD->eraseFromParent();
 }
 
 SYCLModuleInfoAnalysis::Result
-SYCLModuleInfoAnalysis::run(Module &, ModuleAnalysisManager &) {
+SYCLModuleInfoAnalysis::run(Module &M, ModuleAnalysisManager &) {
   if (!ModuleInfo) {
-    loadModuleInfoFromFile();
+    loadModuleInfoFromMetadata(M);
   }
   return {ModuleInfo.get()};
 }
@@ -59,7 +124,43 @@ PreservedAnalyses SYCLModuleInfoPrinter::run(Module &Mod,
     Printer << "Error: No module info available\n";
     return PreservedAnalyses::all();
   }
-  llvm::yaml::Output Out{llvm::outs()};
-  Out << *ModuleInfo;
+
+  formatted_raw_ostream Out{llvm::outs()};
+  constexpr auto Indent = 2, Pad = 26;
+  for (const auto &KernelInfo : ModuleInfo->kernels()) {
+    Out << "KernelName:";
+    Out.PadToColumn(Pad);
+    Out << KernelInfo.Name << '\n';
+
+    Out.indent(Indent) << "Args:\n";
+    Out.indent(Indent * 2) << "Kinds:";
+    Out.PadToColumn(Pad);
+    llvm::interleaveComma(KernelInfo.Args.Kinds, Out, [&Out](auto Kind) {
+      auto KindInt = static_cast<unsigned>(Kind);
+      Out << (KindInt < NumParameterKinds ? ParameterKindStrings[KindInt]
+                                          : InvalidParameterKindString);
+    });
+    Out << '\n';
+
+    Out.indent(Indent * 2) << "Mask:";
+    Out.PadToColumn(Pad);
+    llvm::interleaveComma(KernelInfo.Args.UsageMask, Out, [&Out](auto Mask) {
+      Out << static_cast<unsigned>(Mask);
+    });
+    Out << '\n';
+
+    if (KernelInfo.Attributes.empty()) {
+      continue;
+    }
+
+    Out.indent(Indent) << "Attributes:\n";
+    for (const auto &AttrInfo : KernelInfo.Attributes) {
+      Out.indent(Indent * 2) << AttrInfo.AttributeName << ':';
+      Out.PadToColumn(Pad);
+      llvm::interleaveComma(AttrInfo.Values, Out);
+      Out << '\n';
+    }
+  }
+
   return PreservedAnalyses::all();
 }

sycl-fusion/passes/kernel-info/SYCLKernelInfo.cpp

@@ -22,17 +22,20 @@ class SYCLModuleInfoAnalysis
 public:
   static llvm::AnalysisKey Key;
 
+  constexpr static llvm::StringLiteral ModuleInfoMDKey{"sycl.moduleinfo"};
+
   SYCLModuleInfoAnalysis(
       std::unique_ptr<jit_compiler::SYCLModuleInfo> Info = nullptr)
       : ModuleInfo{std::move(Info)} {}
 
   struct Result {
     jit_compiler::SYCLModuleInfo *ModuleInfo;
   };
-  Result run(llvm::Module &, llvm::ModuleAnalysisManager &);
+  Result run(llvm::Module &M, llvm::ModuleAnalysisManager &);
 
 private:
   void loadModuleInfoFromFile();
+  void loadModuleInfoFromMetadata(llvm::Module &M);
 
   std::unique_ptr<jit_compiler::SYCLModuleInfo> ModuleInfo;
 };

sycl-fusion/passes/kernel-info/SYCLKernelInfo.h

@@ -12,7 +12,7 @@
 namespace llvm {
 template <typename T> inline Expected<T> metadataToUInt(const Metadata *MD) {
   if (auto *C = dyn_cast<ConstantAsMetadata>(MD)) {
-    return C->getValue()->getUniqueInteger().getZExtValue();
+    return static_cast<T>(C->getValue()->getUniqueInteger().getZExtValue());
   }
   {
     std::string Msg{"Invalid metadata format: "};

sycl-fusion/passes/metadata/MDParsing.h

@@ -1,5 +1,5 @@
 ; RUN: opt -load-pass-plugin %shlibdir/SYCLKernelFusion%shlibext \
-; RUN: -passes=sycl-internalization --sycl-info-path %S/abort-kernel-info.yaml -S %s | FileCheck %s
+; RUN: -passes=sycl-internalization -S %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024"
 target triple = "spir64-unknown-unknown"

sycl-fusion/test/internalization/abort-kernel-info.yaml

@@ -1,5 +1,5 @@
 ; RUN: opt -load-pass-plugin %shlibdir/SYCLKernelFusion%shlibext\
-; RUN: -passes=sycl-internalization --sycl-info-path %S/abort-kernel-info.yaml -S %s | FileCheck %s
+; RUN: -passes=sycl-internalization -S %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024"
 target triple = "spir64-unknown-unknown"

sycl-fusion/test/internalization/abort-promote-call.ll

@@ -1,5 +1,5 @@
 ; RUN: opt -load-pass-plugin %shlibdir/SYCLKernelFusion%shlibext \
-; RUN: -passes=sycl-internalization --sycl-info-path %S/../kernel-fusion/kernel-info.yaml -S %s | FileCheck %s
+; RUN: -passes=sycl-internalization -S %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024"
 target triple = "spir64-unknown-unknown"