second stage of implementation

Signed-off-by: Arvind Sudarsanam <[email protected]>

Author: asudarsa

clang/include/clang/Basic/Attr.td

@@ -1309,12 +1309,12 @@ def SYCLType: InheritableAttr {
                             "specialization_id", "kernel_handler", "buffer_location",
                             "no_alias", "accessor_property_list", "group",
                             "private_memory", "aspect", "annotated_ptr", "annotated_arg",
-                            "compile_options", "stream", "sampler"],
+                            "stream", "sampler"],
                            ["accessor", "local_accessor", "spec_constant",
                             "specialization_id", "kernel_handler", "buffer_location",
                             "no_alias", "accessor_property_list", "group",
                             "private_memory", "aspect", "annotated_ptr", "annotated_arg",
-                            "compile_options", "stream", "sampler"]>];
+                            "stream", "sampler"]>];
   // Only used internally by SYCL implementation
   let Documentation = [InternalOnly];
 }
@@ -1328,15 +1328,6 @@ def SYCLDeviceHas : InheritableAttr {
   let SupportsNonconformingLambdaSyntax = 1;
 }
 
-def SYCLDeviceCompileOptions : InheritableAttr {
-  let Spellings = [CXX11<"sycl", "device_compile_options">];
-  let Subjects = SubjectList<[Function], ErrorDiag>;
-  let Args = [VariadicExprArgument<"DeviceCompileOptions">];
-  let LangOpts = [SYCLIsDevice, SilentlyIgnoreSYCLIsHost];
-  // Only used internally by SYCL implementation
-  let Documentation = [InternalOnly];
-}
-
 def SYCLUsesAspects : InheritableAttr {
   let Spellings = [CXX11<"__sycl_detail__", "__uses_aspects__">];
   let Subjects = SubjectList<[CXXRecord, Function], ErrorDiag>;

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -587,7 +587,7 @@ void CodeGenFunction::EmitKernelMetadata(const FunctionDecl *FD,
     // TODO Module identifier is not reliable for this purpose since two modules
     // can have the same ID, needs improvement
     Fn->addFnAttr("sycl-module-id", Fn->getParent()->getModuleIdentifier());
-    int SYCLDeviceCompileOptLevel;
+    int SYCLDeviceCompileOptLevel = 2;
     switch (CGM.getCodeGenOpts().OptimizationLevel) {
     default:
       llvm_unreachable("Invalid optimization level!");

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

@@ -208,10 +208,6 @@ attributeToExecModeMetadata(Module &M, const Attribute &Attr) {
                                             MDNode::get(Ctx, MD));
   }
 
-  if (AttrKindStr == "sycl-device-compile-options") {
-    auto Opt = Attr.getValueAsString();
-    llvm::errs() << "ARV: Opt is -O" << Opt << "\n";
-  }
   return None;
 }
 

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

@@ -43,6 +43,9 @@ constexpr char ESIMD_MARKER_MD[] = "sycl_explicit_simd";
 
 constexpr char ATTR_SYCL_MODULE_ID[] = "sycl-module-id";
 
+// Similar copy in sycl-post-link.cpp
+constexpr char ATTR_OPT_LEVEL[] = "sycl-device-compile-optlevel";
+
 bool hasIndirectFunctionsOrCalls(const Module &M) {
   for (const auto &F : M.functions()) {
     // There are functions marked with [[intel::device_indirectly_callable]]
@@ -299,6 +302,44 @@ groupEntryPointsByAttribute(ModuleDesc &MD, StringRef AttrName,
   return EntryPointGroups;
 }
 
+template <class EntryPoinGroupFunc>
+EntryPointGroupVec
+groupEntryPointsByOptLevel(ModuleDesc &MD, StringRef AttrName,
+                            bool EmitOnlyKernelsAsEntryPoints,
+                            EntryPoinGroupFunc F) {
+  EntryPointGroupVec EntryPointGroups{};
+  std::map<StringRef, EntryPointSet> EntryPointMap;
+  Module &M = MD.getModule();
+
+  // Only process module entry points:
+  for (auto &F : M.functions()) {
+    if (!isEntryPoint(F, EmitOnlyKernelsAsEntryPoints) ||
+        !MD.isEntryPointCandidate(F)) {
+      continue;
+    }
+    if (F.hasFnAttribute(AttrName)) {
+      SmallString<16> stringConstName;
+      StringRef OptLevelStr = F.getFnAttribute(AttrName).getValueAsString();
+      EntryPointMap[OptLevelStr].insert(&F);
+    } else {
+      EntryPointMap["2"].insert(&F);
+    }
+  }
+  if (!EntryPointMap.empty()) {
+    EntryPointGroups.reserve(EntryPointMap.size());
+    for (auto &EPG : EntryPointMap) {
+      EntryPointGroups.emplace_back(EntryPointGroup{
+          EPG.first, std::move(EPG.second), MD.getEntryPointGroup().Props});
+      F(EntryPointGroups.back());
+    }
+  } else {
+    // No entry points met, record this.
+    EntryPointGroups.push_back({GLOBAL_SCOPE_NAME, {}});
+    F(EntryPointGroups.back());
+  }
+  return EntryPointGroups;
+}
+
 // Represents a call graph between functions in a module. Nodes are functions,
 // edges are "calls" relation.
 class CallGraph {
@@ -761,5 +802,28 @@ getLargeGRFSplitter(ModuleDesc &&MD, bool EmitOnlyKernelsAsEntryPoints) {
     return std::make_unique<ModuleCopier>(std::move(MD), std::move(Groups));
 }
 
+std::unique_ptr<ModuleSplitterBase>
+getOptLevelSplitter(ModuleDesc &&MD, bool EmitOnlyKernelsAsEntryPoints) {
+  EntryPointGroupVec Groups = groupEntryPointsByOptLevel(
+      MD, ATTR_OPT_LEVEL, EmitOnlyKernelsAsEntryPoints,
+      [](EntryPointGroup &G) {
+        if (G.GroupId == "3")
+          G.Props.OptLevel = 3;
+        else if (G.GroupId == "2")
+          G.Props.OptLevel = 2;
+        else if (G.GroupId == "1")
+          G.Props.OptLevel = 1;
+        else if (G.GroupId == "0")
+          G.Props.OptLevel = 0;
+      });
+  assert(!Groups.empty() && "At least one group is expected");
+  assert(Groups.size() <= 2 && "At most 2 groups are expected");
+
+  if (Groups.size() > 1)
+    return std::make_unique<ModuleSplitter>(std::move(MD), std::move(Groups));
+  else
+    return std::make_unique<ModuleCopier>(std::move(MD), std::move(Groups));
+}
+
 } // namespace module_split
 } // namespace llvm

llvm/tools/sycl-post-link/ModuleSplitter.h

@@ -60,12 +60,16 @@ struct EntryPointGroup {
     // Scope represented by EPs in a group
     EntryPointsGroupScope Scope = Scope_Global;
 
+    // opt level
+    unsigned OptLevel = 2;
+
     Properties merge(const Properties &Other) const {
       Properties Res;
       Res.HasESIMD = HasESIMD == Other.HasESIMD
                          ? HasESIMD
                          : SyclEsimdSplitStatus::SYCL_AND_ESIMD;
       Res.UsesLargeGRF = UsesLargeGRF || Other.UsesLargeGRF;
+      // Opt Level remains at '2'
       // Scope remains global
       return Res;
     }
@@ -93,6 +97,9 @@ struct EntryPointGroup {
   // Tells if some entry points use large GRF mode.
   bool isLargeGRF() const { return Props.UsesLargeGRF; }
 
+  // Get opt level.
+  uint32_t getOptLevel() const { return Props.OptLevel; }
+
   void saveNames(std::vector<std::string> &Dest) const;
   void rebuildFromNames(const std::vector<std::string> &Names, const Module &M);
   void rebuild(const Module &M);
@@ -147,6 +154,7 @@ class ModuleDesc {
   bool isESIMD() const { return EntryPoints.isEsimd(); }
   bool isSYCL() const { return EntryPoints.isSycl(); }
   bool isLargeGRF() const { return EntryPoints.isLargeGRF(); }
+  uint32_t getOptLevel() const { return EntryPoints.getOptLevel(); }
 
   const EntryPointSet &entries() const { return EntryPoints.Functions; }
   const EntryPointGroup &getEntryPointGroup() const { return EntryPoints; }
@@ -253,6 +261,9 @@ getSplitterByMode(ModuleDesc &&MD, IRSplitMode Mode,
 std::unique_ptr<ModuleSplitterBase>
 getLargeGRFSplitter(ModuleDesc &&MD, bool EmitOnlyKernelsAsEntryPoints);
 
+std::unique_ptr<ModuleSplitterBase>
+getOptLevelSplitter(ModuleDesc &&MD, bool EmitOnlyKernelsAsEntryPoints);
+
 #ifndef NDEBUG
 void dumpEntryPoints(const EntryPointSet &C, const char *msg = "", int Tab = 0);
 void dumpEntryPoints(const Module &M, bool OnlyKernelsAreEntryPoints = false,