remove sycl devicelib required binary property usage

Signed-off-by: jinge90 <[email protected]>

Author: jinge90

llvm/include/llvm/SYCLLowerIR/ComputeModuleRuntimeInfo.h

@@ -34,8 +34,7 @@ using EntryPointSet = SetVector<Function *>;
 
 PropSetRegTy computeModuleProperties(const Module &M,
                                      const EntryPointSet &EntryPoints,
-                                     const GlobalBinImageProps &GlobProps,
-                                     const StringRef &DeviceLibSPVLoc);
+                                     const GlobalBinImageProps &GlobProps);
 
 std::string computeModuleSymbolTable(const Module &M,
                                      const EntryPointSet &EntryPoints);

llvm/include/llvm/SYCLLowerIR/SYCLRequiredDeviceLibs.h renamed to llvm/include/llvm/SYCLLowerIR/SYCLDeviceLibReqMask.h

@@ -1,4 +1,4 @@
-//===----- SYCLRequiredDeviceLibs.h - get SYCL devicelib required Info ----===//
+//===----- SYCLDeviceLibReqMask.h - get SYCL devicelib required Info -----=-==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -16,8 +16,6 @@
 
 #pragma once
 
-#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/StringRef.h"
 #include <cstdint>
 
 namespace llvm {
@@ -40,27 +38,6 @@ enum class DeviceLibExt : std::uint32_t {
   cl_intel_devicelib_bfloat16,
 };
 
-enum class DeviceLibIsNative : std::uint32_t { Yes, No, Ignore };
-
-struct SYCLDeviceLibSPVMeta {
-  DeviceLibExt SPVExt;
-  const char *SPVFileName;
-  DeviceLibIsNative IsNative;
-};
-
-struct SYCLDeviceLibSPVBinary {
-  typedef uint8_t value_type;
-  value_type *SPVRawBytes;
-  size_t SPVBytesNum;
-  SYCLDeviceLibSPVBinary(value_type *RawB, size_t BNum) {
-    SPVRawBytes = RawB;
-    SPVBytesNum = BNum;
-  }
-  value_type *data() const { return SPVRawBytes; }
-  size_t size() const { return SPVBytesNum; }
-};
-
-void getRequiredSYCLDeviceLibs(const Module &M,
-                               SmallVector<SYCLDeviceLibSPVMeta, 16> &ReqLibs);
+uint32_t getSYCLDeviceLibReqMask(const Module &M);
 
 } // namespace llvm

llvm/include/llvm/Support/PropertySetIO.h

@@ -199,7 +199,7 @@ class PropertySetRegistry {
       "SYCL/specialization constants";
   static constexpr char SYCL_SPEC_CONSTANTS_DEFAULT_VALUES[] =
       "SYCL/specialization constants default values";
-  static constexpr char SYCL_DEVICELIB_REQ_BINS[] = "SYCL/devicelib req bins";
+  static constexpr char SYCL_DEVICELIB_REQ_MASK[] = "SYCL/devicelib req mask";
   static constexpr char SYCL_KERNEL_PARAM_OPT_INFO[] = "SYCL/kernel param opt";
   static constexpr char SYCL_PROGRAM_METADATA[] = "SYCL/program metadata";
   static constexpr char SYCL_MISC_PROP[] = "SYCL/misc properties";

llvm/lib/SYCLLowerIR/CMakeLists.txt

@@ -61,7 +61,7 @@ add_llvm_component_library(LLVMSYCLLowerIR
   SYCLAddOptLevelAttribute.cpp
   SYCLConditionalCallOnDevice.cpp
   SYCLCreateNVVMAnnotations.cpp
-  SYCLRequiredDeviceLibs.cpp
+  SYCLDeviceLibReqMask.cpp
   SYCLDeviceRequirements.cpp
   SYCLKernelParamOptInfo.cpp
   SYCLJointMatrixTransform.cpp

llvm/lib/SYCLLowerIR/ComputeModuleRuntimeInfo.cpp

@@ -17,15 +17,12 @@
 #include "llvm/SYCLLowerIR/DeviceGlobals.h"
 #include "llvm/SYCLLowerIR/HostPipes.h"
 #include "llvm/SYCLLowerIR/ModuleSplitter.h"
+#include "llvm/SYCLLowerIR/SYCLDeviceLibReqMask.h"
 #include "llvm/SYCLLowerIR/SYCLKernelParamOptInfo.h"
-#include "llvm/SYCLLowerIR/SYCLRequiredDeviceLibs.h"
 #include "llvm/SYCLLowerIR/SYCLUtils.h"
 #include "llvm/SYCLLowerIR/SpecConstants.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/MemoryBuffer.h"
 #include <queue>
 #include <unordered_set>
-
 #ifndef NDEBUG
 constexpr int DebugModuleProps = 0;
 #endif
@@ -155,59 +152,14 @@ std::optional<T> getKernelSingleEltMetadata(const Function &Func,
 
 PropSetRegTy computeModuleProperties(const Module &M,
                                      const EntryPointSet &EntryPoints,
-                                     const GlobalBinImageProps &GlobProps,
-                                     const StringRef &DeviceLibSPVLoc) {
+                                     const GlobalBinImageProps &GlobProps) {
 
   PropSetRegTy PropSet;
-  // If sycl-post-link doesn't specify a valid fallback spv path, the param
-  // 'DeviceLibSPVLoc' is set to an empty string.
-  if (!DeviceLibSPVLoc.empty()) {
-    SmallVector<llvm::SYCLDeviceLibSPVMeta, 16> RequiredLibs;
-    llvm::getRequiredSYCLDeviceLibs(M, RequiredLibs);
-    for (auto ExtMeta : RequiredLibs) {
-      std::string SPVPath =
-          DeviceLibSPVLoc.str() + "/" + std::string(ExtMeta.SPVFileName);
-      if (!llvm::sys::fs::exists(SPVPath))
-        continue;
-
-      auto SPVMB = llvm::MemoryBuffer::getFile(SPVPath);
-      if (!SPVMB)
-        continue;
-
-      size_t SPVSize = (*SPVMB)->getBufferSize();
-      // std::aligned_alloc is not available in some pre-ci Windows machine.
-#if defined(_WIN32) || defined(_WIN64)
-      uint8_t *SPVBuffer = reinterpret_cast<uint8_t *>(
-          _aligned_malloc(SPVSize + sizeof(uint32_t) * 2, alignof(uint32_t)));
-#else
-      uint8_t *SPVBuffer = reinterpret_cast<uint8_t *>(std::aligned_alloc(
-          alignof(uint32_t), SPVSize + sizeof(uint32_t) * 2));
-#endif
-
-      if (!SPVBuffer)
-        continue;
-
-      // The data embedded consists of 3 parts, overall layout is following:
-      // |--devicelib ext(4 byte)--|--IsNative Flag(4 byte)--|--spv raw data--|
-      *(reinterpret_cast<uint32_t *>(SPVBuffer)) =
-          static_cast<uint32_t>(ExtMeta.SPVExt);
-
-      *(reinterpret_cast<uint32_t *>(SPVBuffer + sizeof(uint32_t))) =
-          static_cast<uint32_t>(ExtMeta.IsNative);
-      std::memcpy(SPVBuffer + sizeof(uint32_t) * 2, (*SPVMB)->getBufferStart(),
-                  SPVSize);
-      llvm::SYCLDeviceLibSPVBinary SPVBinaryObj(SPVBuffer,
-                                                SPVSize + sizeof(uint32_t) * 2);
-      PropSet.add(PropSetRegTy::SYCL_DEVICELIB_REQ_BINS, ExtMeta.SPVFileName,
-                  SPVBinaryObj);
-#if defined(_WIN32) || defined(_WIN64)
-      _aligned_free(SPVBuffer);
-#else
-      std::free(SPVBuffer);
-#endif
-    }
+  {
+    uint32_t MRMask = getSYCLDeviceLibReqMask(M);
+    std::map<StringRef, uint32_t> RMEntry = {{"DeviceLibReqMask", MRMask}};
+    PropSet.add(PropSetRegTy::SYCL_DEVICELIB_REQ_MASK, RMEntry);
   }
-
   {
     PropSet.add(PropSetRegTy::SYCL_DEVICE_REQUIREMENTS,
                 computeDeviceRequirements(M, EntryPoints).asMap());
@@ -501,7 +453,7 @@ PropSetRegTy computeModuleProperties(const Module &M,
       }
 
       PropSet.add(PropSetRegTy::SYCL_VIRTUAL_FUNCTIONS,
-                  "uses-virtual-functions-set", AllSets);
+                   "uses-virtual-functions-set", AllSets);
     }
   }
 

llvm/lib/SYCLLowerIR/SYCLRequiredDeviceLibs.cpp renamed to llvm/lib/SYCLLowerIR/SYCLDeviceLibReqMask.cpp

@@ -1,4 +1,4 @@
-//==---- SYCLRequiredDeviceLibs.cpp - get SYCL devicelib required Info -----==//
+//==----- SYCLDeviceLibReqMask.cpp - get SYCL devicelib required Info ------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,8 +14,7 @@
 // SYCL runtime later.
 //===----------------------------------------------------------------------===//
 
-#include "llvm/SYCLLowerIR/SYCLRequiredDeviceLibs.h"
-#include "llvm/ADT/SmallSet.h"
+#include "llvm/SYCLLowerIR/SYCLDeviceLibReqMask.h"
 #include "llvm/IR/Module.h"
 #include "llvm/TargetParser/Triple.h"
 
@@ -733,73 +732,46 @@ SYCLDeviceLibFuncMap SDLMap = {
      DeviceLibExt::cl_intel_devicelib_bfloat16},
 };
 
-} // namespace
-
-// One devicelib extension may correspond to multiple spv files, following
-// map stores corresponding index values in SPVMetaList for an extension.
-static std::unordered_map<DeviceLibExt, std::vector<size_t>>
-    DeviceLibSPVExtMap = {{DeviceLibExt::cl_intel_devicelib_assert, {0}},
-                          {DeviceLibExt::cl_intel_devicelib_math, {1}},
-                          {DeviceLibExt::cl_intel_devicelib_math_fp64, {2}},
-                          {DeviceLibExt::cl_intel_devicelib_complex, {3}},
-                          {DeviceLibExt::cl_intel_devicelib_complex_fp64, {4}},
-                          {DeviceLibExt::cl_intel_devicelib_cstring, {5}},
-                          {DeviceLibExt::cl_intel_devicelib_imf, {6}},
-                          {DeviceLibExt::cl_intel_devicelib_imf_fp64, {7}},
-                          {DeviceLibExt::cl_intel_devicelib_imf_bf16, {8}},
-                          {DeviceLibExt::cl_intel_devicelib_bfloat16, {9, 10}}};
+// Each fallback device library corresponds to one bit in "require mask" which
+// is an unsigned int32. getDeviceLibBit checks which fallback device library
+// is required for FuncName and returns the corresponding bit. The corresponding
+// mask for each fallback device library is:
+// cl_intel_devicelib_assert:        0x1
+// cl_intel_devicelib_math:          0x2
+// cl_intel_devicelib_math_fp64:     0x4
+// cl_intel_devicelib_complex:       0x8
+// cl_intel_devicelib_complex_fp64:  0x10
+// cl_intel_devicelib_cstring :      0x20
+// cl_intel_devicelib_imf:           0x40
+// cl_intel_devicelib_imf_fp64:      0x80
+// cl_intel_devicelib_imf_bf16:      0x100
+// cl_intel_devicelib_bfloat16:      0x200
+uint32_t getDeviceLibBits(const std::string &FuncName) {
+  auto DeviceLibFuncIter = SDLMap.find(FuncName);
+  return ((DeviceLibFuncIter == SDLMap.end())
+              ? 0
+              : 0x1 << (static_cast<uint32_t>(DeviceLibFuncIter->second) -
+                        static_cast<uint32_t>(
+                            DeviceLibExt::cl_intel_devicelib_assert)));
+}
 
-static SYCLDeviceLibSPVMeta SPVMetaList[] = {
-    {DeviceLibExt::cl_intel_devicelib_assert, "libsycl-fallback-cassert.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_math, "libsycl-fallback-cmath.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_math_fp64,
-     "libsycl-fallback-cmath-fp64.spv", DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_complex, "libsycl-fallback-complex.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_complex_fp64,
-     "libsycl-fallback-complex-fp64.spv", DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_cstring, "libsycl-fallback-cstring.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_imf, "libsycl-fallback-imf.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_imf_fp64, "libsycl-fallback-imf-fp64.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_imf_bf16, "libsycl-fallback-imf-bf16.spv",
-     DeviceLibIsNative::Ignore},
-    {DeviceLibExt::cl_intel_devicelib_bfloat16, "libsycl-fallback-bfloat16.spv",
-     DeviceLibIsNative::No},
-    {DeviceLibExt::cl_intel_devicelib_bfloat16, "libsycl-native-bfloat16.spv",
-     DeviceLibIsNative::Yes}};
+} // namespace
 
-namespace llvm {
 // For each device image module, we go through all functions which meets
 // 1. The function name has prefix "__devicelib_"
 // 2. The function is declaration which means it doesn't have function body
 // And we don't expect non-spirv functions with "__devicelib_" prefix.
-void getRequiredSYCLDeviceLibs(
-    const Module &M,
-    llvm::SmallVector<SYCLDeviceLibSPVMeta, 16> &ReqDeviceLibs) {
+uint32_t llvm::getSYCLDeviceLibReqMask(const Module &M) {
   // Device libraries will be enabled only for spir-v module.
   if (!Triple(M.getTargetTriple()).isSPIROrSPIRV())
-    return;
-
-  SmallSet<DeviceLibExt, 16> DeviceLibUsed;
+    return 0;
+  uint32_t ReqMask = 0;
   for (const Function &SF : M) {
     if (SF.getName().starts_with(DEVICELIB_FUNC_PREFIX) && SF.isDeclaration()) {
       assert(SF.getCallingConv() == CallingConv::SPIR_FUNC);
-      auto DeviceLibFuncIter = SDLMap.find(SF.getName().str());
-      if (DeviceLibFuncIter == SDLMap.end())
-        continue;
-      if (DeviceLibUsed.contains(DeviceLibFuncIter->second))
-        continue;
-
-      DeviceLibUsed.insert(DeviceLibFuncIter->second);
-      for (size_t idx : DeviceLibSPVExtMap[DeviceLibFuncIter->second]) {
-        ReqDeviceLibs.push_back(SPVMetaList[idx]);
-      }
+      uint32_t DeviceLibBits = getDeviceLibBits(SF.getName().str());
+      ReqMask |= DeviceLibBits;
     }
   }
+  return ReqMask;
 }
-} // namespace llvm

llvm/lib/Support/PropertySetIO.cpp

@@ -195,7 +195,7 @@ void PropertyValue::copy(const PropertyValue &P) {
 }
 
 constexpr char PropertySetRegistry::SYCL_SPECIALIZATION_CONSTANTS[];
-constexpr char PropertySetRegistry::SYCL_DEVICELIB_REQ_BINS[];
+constexpr char PropertySetRegistry::SYCL_DEVICELIB_REQ_MASK[];
 constexpr char PropertySetRegistry::SYCL_SPEC_CONSTANTS_DEFAULT_VALUES[];
 constexpr char PropertySetRegistry::SYCL_KERNEL_PARAM_OPT_INFO[];
 constexpr char PropertySetRegistry::SYCL_PROGRAM_METADATA[];

llvm/test/tools/sycl-post-link/device-requirements/mask.ll

@@ -0,0 +1,20 @@
+; RUN: sycl-post-link -properties -split=auto < %s -o %t.files.table
+; RUN: FileCheck %s -input-file=%t.files_0.prop
+
+; CHECK:[SYCL/devicelib req mask]
+; CHECK: DeviceLibReqMask=1|64
+
+source_filename = "main.cpp"
+target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
+target triple = "spirv64-unknown-unknown"
+
+declare spir_func i32 @__devicelib_imf_umulhi(i32 noundef %0, i32 noundef %1)
+
+; Function Attrs: convergent mustprogress noinline norecurse optnone
+define weak_odr dso_local spir_kernel void @kernel() #0 {
+entry:
+  %0 = call i32 @__devicelib_imf_umulhi(i32 0, i32 0)
+  ret void
+}
+
+attributes #0 = { "sycl-module-id"="main.cpp" }

llvm/tools/sycl-post-link/sycl-post-link.cpp

@@ -104,11 +104,6 @@ cl::opt<std::string> OutputDir{
         "Directory where files listed in the result file table will be output"),
     cl::value_desc("dirname"), cl::cat(PostLinkCat)};
 
-cl::opt<std::string> DeviceLibSPVDir{
-    "device-lib-spv-dir",
-    cl::desc("Directory where sycl fallback spirv device libraries  reside"),
-    cl::value_desc("dirname"), cl::cat(PostLinkCat)};
-
 struct TargetFilenamePair {
   std::string Target;
   std::string Filename;
@@ -312,12 +307,8 @@ std::string saveModuleIR(Module &M, int I, StringRef Suff) {
 std::string saveModuleProperties(module_split::ModuleDesc &MD,
                                  const GlobalBinImageProps &GlobProps, int I,
                                  StringRef Suff, StringRef Target = "") {
-
-  StringRef SPVDir = "";
-  if (DeviceLibSPVDir.getNumOccurrences() > 0)
-    SPVDir = DeviceLibSPVDir;
   auto PropSet =
-      computeModuleProperties(MD.getModule(), MD.entries(), GlobProps, SPVDir);
+      computeModuleProperties(MD.getModule(), MD.entries(), GlobProps);
 
   std::string NewSuff = Suff.str();
   if (!Target.empty()) {

sycl-jit/jit-compiler/lib/rtc/DeviceCompilation.cpp

@@ -425,7 +425,7 @@ Expected<RTCBundleInfo> jit_compiler::performPostLink(
       /*EmitExportedSymbols=*/true, /*EmitImportedSymbols=*/true,
       /*DeviceGlobals=*/false};
   PropertySetRegistry Properties =
-      computeModuleProperties(MDesc.getModule(), MDesc.entries(), PropReq, "");
+      computeModuleProperties(MDesc.getModule(), MDesc.entries(), PropReq);
   // TODO: Manually add `compile_target` property as in
   //       `saveModuleProperties`?
   const auto &PropertySets = Properties.getPropSets();