avoid localization of large data for oclbin, use relocation instead

Author: dmitryryintel

IGC/VectorCompiler/include/vc/Support/BackendConfig.h

@@ -51,10 +51,48 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <llvm/Pass.h>
 #include <llvm/PassRegistry.h>
 
+#include <limits>
+
 namespace llvm {
 
 void initializeGenXBackendConfigPass(PassRegistry &PR);
 
+struct GlobalsLocalizationConfig {
+  using LimitT = std::size_t;
+  static constexpr auto NoLimit = std::numeric_limits<LimitT>::max();
+
+private:
+  // Whether every global variable must be localized.
+  bool IsForced = true;
+  // How many GRF memory is allowed to be used for localization.
+  LimitT Limit = NoLimit;
+
+public:
+  GlobalsLocalizationConfig(bool IsForcedIn, LimitT LimitIn)
+      : IsForced{IsForcedIn}, Limit{LimitIn} {
+    if (IsForced)
+      IGC_ASSERT_MESSAGE(
+          Limit == NoLimit,
+          "there can be no localization limit when localization is forced");
+  }
+
+  GlobalsLocalizationConfig() {}
+
+  // Every global variable must be localized.
+  static GlobalsLocalizationConfig CreateForcedLocalization() { return {}; }
+
+  // GlobalsLocalization is allowed to localize globals but it can use only
+  // GlobalsLocalizationLimit bytes of GRF.
+  static GlobalsLocalizationConfig
+  CreateLocalizationWithLimit(LimitT GlobalsLocalizationLimitIn = NoLimit) {
+    return {false, GlobalsLocalizationLimitIn};
+  }
+
+  bool isForced() const { return IsForced; }
+
+  LimitT getLimit() const { return Limit; }
+};
+
 // Plain structure to be filled by users who want to create backend
 // configuration. Some values are default-initialized from cl options.
 struct GenXBackendOptions {
@@ -74,6 +112,10 @@ struct GenXBackendOptions {
   bool EnableDebugInfoDumps;
   std::string DebugInfoDumpsNameOverride;
 
+  // Configuration for GlobalsLocalization pass
+  // (part of CMABI pass by historical reasons).
+  GlobalsLocalizationConfig GlobalsLocalization;
+
   GenXBackendOptions();
 };
 
@@ -132,6 +174,13 @@ class GenXBackendConfig : public ImmutablePass {
   const std::string &dbgInfoDumpsNameOverride() const {
     return Options.DebugInfoDumpsNameOverride;
   }
+
+  bool isGlobalsLocalizationForced() const {
+    return Options.GlobalsLocalization.isForced();
+  }
+  GlobalsLocalizationConfig::LimitT getGlobalsLocalizationLimit() const {
+    return Options.GlobalsLocalization.getLimit();
+  }
 };
 } // namespace llvm
 

IGC/VectorCompiler/lib/GenXCodeGen/GenXWrapper.cpp

@@ -454,6 +454,10 @@ static GenXBackendOptions createBackendOptions(const vc::CompileOptions &Opts) {
   BackendOpts.EnableAsmDumps = Opts.DumpAsm;
   BackendOpts.EnableDebugInfoDumps = Opts.DumpDebugInfo;
   BackendOpts.Dumper = Opts.Dumper.get();
+  BackendOpts.GlobalsLocalization =
+      (Opts.Binary == vc::BinaryKind::OpenCL)
+          ? GlobalsLocalizationConfig::CreateLocalizationWithLimit()
+          : GlobalsLocalizationConfig::CreateForcedLocalization();
   return BackendOpts;
 }
 

IGC/VectorCompiler/lib/GenXOpts/CMTrans/CMABI.cpp

@@ -41,13 +41,18 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #define DEBUG_TYPE "cmabi"
 
+#include "llvmWrapper/Analysis/CallGraph.h"
 #include "llvmWrapper/IR/CallSite.h"
-#include "llvmWrapper/Support/Alignment.h"
 #include "llvmWrapper/IR/DerivedTypes.h"
 #include "llvmWrapper/IR/Instructions.h"
+#include "llvmWrapper/Support/Alignment.h"
+
+#include "Probe/Assertion.h"
 
 #include "vc/GenXOpts/GenXOpts.h"
 #include "vc/GenXOpts/Utils/GenXSTLExtras.h"
+#include "vc/Support/BackendConfig.h"
+
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SCCIterator.h"
@@ -76,9 +81,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 
-#include "llvmWrapper/Analysis/CallGraph.h"
-#include "Probe/Assertion.h"
-
 #include <algorithm>
 #include <iterator>
 #include <numeric>
@@ -89,13 +91,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 using namespace llvm;
 
-using LocalizationLimitT = int32_t;
-static constexpr auto LocalizeAll = std::numeric_limits<LocalizationLimitT>::max();
-static cl::opt<LocalizationLimitT>
-    LocalizationLimit("cm-abi-issues-localization-limit",
-                   cl::desc("maximum size (in bytes) used to localize global variables"),
-                   cl::init(LocalizeAll));
-
 STATISTIC(NumArgumentsTransformed, "Number of pointer arguments transformed");
 
 // FIXME: find a propper place for addrspace enum, agree on addrspace politics
@@ -253,6 +248,7 @@ int DiagnosticInfoOverlappingArgs::KindID = 0;
 class CMABIAnalysis : public ModulePass {
   // This map captures all global variables to be localized.
   std::vector<LocalizationInfo *> LocalizationInfoObjs;
+  GlobalsLocalizationConfig::LimitT GlobalsLocalizationLimit;
 
 public:
   static char ID;
@@ -267,6 +263,7 @@ class CMABIAnalysis : public ModulePass {
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<CallGraphWrapperPass>();
+    AU.addRequired<GenXBackendConfig>();
     AU.setPreservesAll();
   }
 
@@ -359,10 +356,25 @@ char CMABIAnalysis::ID = 0;
 INITIALIZE_PASS_BEGIN(CMABIAnalysis, "cmabi-analysis",
                       "helper analysis pass to get info for CMABI", false, true)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(GenXBackendConfig)
 INITIALIZE_PASS_END(CMABIAnalysis, "cmabi-analysis",
                     "Fix ABI issues for the genx backend", false, true)
 
+static std::size_t
+defineGlobalsLocalizationLimit(const GenXBackendConfig &Config) {
+  if (Config.isGlobalsLocalizationForced())
+    return GlobalsLocalizationConfig::NoLimit;
+
+  // Half of a size of standard GenX register file in bytes.
+  // 128 * 32 / 2
+  constexpr std::size_t HalfGRF = 2048;
+  std::size_t Limit = Config.getGlobalsLocalizationLimit();
+  return std::min(Limit, HalfGRF);
+}
+
 bool CMABIAnalysis::runOnModule(Module &M) {
+  GlobalsLocalizationLimit =
+      defineGlobalsLocalizationLimit(getAnalysis<GenXBackendConfig>());
   runOnCallGraph(getAnalysis<CallGraphWrapperPass>().getCallGraph());
   return false;
 }
@@ -402,7 +414,7 @@ auto selectGlobalsToLocalize(ForwardRange Globals, T Bound,
       Globals, [ExcludePred](GVRef GV) { return !ExcludePred(GV); });
   using GVWithWeightT = std::pair<GVPtr, int>;
 
-  if (Bound == LocalizeAll) {
+  if (Bound == GlobalsLocalizationConfig::NoLimit) {
     std::vector<GVPtr> ToLocalize;
     transform(Unexcluded, std::back_inserter(ToLocalize),
               [](GVRef GV) { return &GV; });
@@ -1950,7 +1962,7 @@ void CMABIAnalysis::analyzeGlobals(CallGraph &CG) {
   };
   const auto &DL = M.getDataLayout();
   std::vector<GlobalVariable *> ToLocalize = selectGlobalsToLocalize(
-      M.globals(), LocalizationLimit.getValue(),
+      M.globals(), GlobalsLocalizationLimit,
       [UsesPrintChecker](const GlobalVariable &GV) {
         // don't localize global constant format string if it's used by print_index intrinsic
         bool UsesPrintIndex = std::any_of(GV.use_begin(), GV.use_end(), UsesPrintChecker);

IGC/VectorCompiler/lib/GenXOpts/CMakeLists.txt

@@ -16,5 +16,6 @@ set(OPT_SOURCES
 add_library(VCTransforms ${OPT_SOURCES})
 target_link_libraries(VCTransforms
   VCHeaders
+  VCSupport
   LLVMGenXIntrinsics
   )

IGC/VectorCompiler/lib/Support/BackendConfig.cpp

@@ -71,6 +71,15 @@ static cl::opt<std::string>
                                "precompiled OpenCL generic builtins"),
                       cl::init(""));
 
+static cl::opt<bool> ForceGlobalsLocalizationOpt(
+    "vc-force-globals-localization",
+    cl::desc("all global variables must be localized"), cl::init(true));
+
+static cl::opt<GlobalsLocalizationConfig::LimitT> GlobalsLocalizationLimitOpt(
+    "vc-globals-localization-limit",
+    cl::desc("maximum size (in bytes) used to localize global variables"),
+    cl::init(GlobalsLocalizationConfig::NoLimit));
+
 //===----------------------------------------------------------------------===//
 //
 // Backend config related stuff.
@@ -82,7 +91,9 @@ GenXBackendOptions::GenXBackendOptions()
     : EnableKernelDebug(GenerateDebugInfoOpt), DumpRegAlloc(DumpRegAllocOpt),
       StackSurfaceMaxSize(StackMemSizeOpt), EnableAsmDumps(EnableAsmDumpsOpt),
       EnableDebugInfoDumps(EnableDebugInfoDumpOpt),
-      DebugInfoDumpsNameOverride(DebugInfoDumpNameOverride) {}
+      DebugInfoDumpsNameOverride(DebugInfoDumpNameOverride),
+      GlobalsLocalization{ForceGlobalsLocalizationOpt.getValue(),
+                          GlobalsLocalizationLimitOpt.getValue()} {}
 
 GenXBackendData::GenXBackendData() {
   if (OCLGenericBiFPath.getNumOccurrences() == 0)