Update GRF selection heuristic

Author: jfuentes

visa/G4_Kernel.cpp

@@ -620,11 +620,11 @@ void G4_Kernel::calculateSimdSize() {
 // Updates kernel's related structures to large GRF
 //
 bool G4_Kernel::updateKernelToLargerGRF() {
-  if (numRegTotal == grfMode.getVRTMaxGRF())
+  if (numRegTotal == grfMode.getMaxGRF())
     return false;
 
   // Scale number of GRFs, Acc, SWSB tokens.
-  setKernelParameters(grfMode.getVRTLargerGRF());
+  setKernelParameters(grfMode.moveToLargerGRF());
   fg.builder->rebuildPhyRegPool(getNumRegTotal());
   return true;
 }
@@ -633,11 +633,11 @@ bool G4_Kernel::updateKernelToLargerGRF() {
 // Updates kernel's related structures to smaller GRF
 //
 bool G4_Kernel::updateKernelToSmallerGRF() {
-  if (numRegTotal == grfMode.getVRTMinGRF())
+  if (numRegTotal == grfMode.getMinGRF())
     return false;
 
   // Scale number of GRFs, Acc, SWSB tokens.
-  setKernelParameters(grfMode.getVRTSmallerGRF());
+  setKernelParameters(grfMode.moveToSmallerGRF());
   fg.builder->rebuildPhyRegPool(getNumRegTotal());
   return true;
 }
@@ -653,7 +653,7 @@ void G4_Kernel::updateKernelByRegPressure(unsigned regPressure) {
     largestInputReg = std::max(largestInputReg, maxRegPayloadDispatch);
   }
 
-  unsigned newGRF = grfMode.findModeByRegPressure(regPressure, largestInputReg);
+  unsigned newGRF = grfMode.setModeByRegPressure(regPressure, largestInputReg);
 
   if (newGRF == numRegTotal)
     return;
@@ -2099,25 +2099,27 @@ GRFMode::GRFMode(const TARGET_PLATFORM platform, Options *op) : options(op) {
   currentMode = defaultMode;
 }
 
-unsigned GRFMode::findModeByRegPressure(unsigned maxRP, unsigned largestInputReg) {
-  unsigned size = configs.size();
-  unsigned i = 0, newGRF = 0;
+unsigned GRFMode::setModeByRegPressure(unsigned maxRP, unsigned largestInputReg) {
+  unsigned size = configs.size(), i = 0;
   // find appropiate GRF based on reg pressure
   for (; i < size; i++) {
     if (configs[i].VRTEnable && maxRP <= configs[i].numGRF &&
         // Check that we've at least 8 GRFs over and above
         // those blocked for kernel input. This helps cases
         // where an 8 GRF variable shows up in entry BB.
         (largestInputReg + 8) <= configs[i].numGRF) {
-      newGRF = configs[i].numGRF;
+      currentMode = i;
       break;
     }
   }
+  return configs[currentMode].numGRF;
+}
 
-  // if not found, pressure is too high
-  // set largest grf mode
-  if (i == size)
-    newGRF = getVRTMaxGRF();
+// Check if next larger GRF has the same number of threads per EU
+bool GRFMode::hasLargerGRFSameThreads() const {
+  unsigned largerGrfIdx = currentMode + 1;
+  if (largerGrfIdx == configs.size() || !configs[largerGrfIdx].VRTEnable)
+    return false;
 
-  return newGRF;
+  return configs[currentMode].numThreads == configs[largerGrfIdx].numThreads;
 }

visa/G4_Kernel.hpp

@@ -148,7 +148,8 @@ class GRFMode {
     return iter != configs.end();
   }
 
-  unsigned findModeByRegPressure(unsigned maxRP, unsigned largestInputReg);
+  unsigned setModeByRegPressure(unsigned maxRP, unsigned largestInputReg);
+  bool hasLargerGRFSameThreads() const;
 
   unsigned getNumGRF() const { return configs[currentMode].numGRF; }
   unsigned getDefaultGRF() const { return configs[defaultMode].numGRF; }
@@ -170,19 +171,20 @@ class GRFMode {
   unsigned getNumAcc() const { return configs[currentMode].numAcc; }
 
   // ----- helper functions for autoGRFSelection (VRT) ----- //
-  unsigned getVRTMinGRF() const {
+  unsigned getMinGRF() const {
     auto found = std::find_if(configs.begin(), configs.end(),
                               [](const Config &c) { return c.VRTEnable; });
     return found->numGRF;
   }
 
-  unsigned getVRTMaxGRF() const {
+  unsigned getMaxGRF() const {
     auto found = std::find_if(configs.rbegin(), configs.rend(),
                               [](const Config &c) { return c.VRTEnable; });
     return found->numGRF;
   }
 
-  unsigned getVRTLargerGRF() const {
+  // Get the next larger GRF available
+  unsigned getLargerGRF() const {
     // find the first larger mode that's available for VRT
     for (auto i = currentMode + 1; i < configs.size(); ++i) {
       if (configs[i].VRTEnable)
@@ -191,14 +193,37 @@ class GRFMode {
     return configs[currentMode].numGRF;
   }
 
-  unsigned getVRTSmallerGRF() const {
+  // Get the next smaller GRF available
+  unsigned getSmallerGRF() const {
     for (auto i = static_cast<int>(currentMode) - 1; i >= 0 ; --i) {
       if (configs[i].VRTEnable)
         return configs[i].numGRF;
     }
     return configs[currentMode].numGRF;
   }
 
+  // Move GRF mode to the larger GRF available and return the number
+  unsigned moveToLargerGRF() {
+    for (auto i = currentMode + 1; i < configs.size(); ++i) {
+      if (configs[i].VRTEnable) {
+        currentMode = i;
+        break;
+      }
+    }
+    return configs[currentMode].numGRF;
+  }
+
+  // Move GRF mode to the smaller GRF available and return the number
+  unsigned moveToSmallerGRF() {
+    for (auto i = currentMode - 1; i >= 0; --i) {
+      if (configs[i].VRTEnable) {
+        currentMode = i;
+        break;
+      }
+    }
+    return configs[currentMode].numGRF;
+  }
+
 private:
   // Parameters associated to a GRF mode
   struct Config {

visa/LocalScheduler/G4_Sched.cpp

@@ -715,19 +715,24 @@ bool preRA_Scheduler::runWithGRFSelection(unsigned &KernelPressure) {
     unsigned BBRP = rp.getPressure(bb);
 
     unsigned UpperBoundGRF = 0;
-    if (GRFdecreased && KernelPressure < kernel.grfMode.getVRTMaxGRF())
-      UpperBoundGRF = kernel.grfMode.getVRTLargerGRF();
+    if (GRFdecreased && KernelPressure < kernel.grfMode.getMaxGRF())
+      UpperBoundGRF = kernel.grfMode.getLargerGRF();
     Changed |= S.scheduleBlockForLatency(BBRP, Changed, UpperBoundGRF);
   }
 
   if (Changed) {
     rp.recompute();
     KernelPressure = rp.getMaxRP();
   }
-  // In RA extra registers might be needed to satisfy
-  // some restrictions, e.g. alignment, SIMD size, etc.
-  // So extra registers are provided.
-  unsigned ExtraRegs = (unsigned)(kernel.getNumRegTotal() * EXTRA_REGISTERS_FOR_RA / 100.0f);
+
+  unsigned ExtraRegs = 0;
+  if (kernel.grfMode.hasLargerGRFSameThreads()) {
+    // In RA extra registers might be needed to satisfy some restrictions,
+    // e.g. alignment, SIMD size, etc. So in order to avoid spill in GRF
+    // modes smaller than default, extra registers are added to reg pressure.
+    ExtraRegs =
+        (unsigned)(kernel.getNumRegTotal() * EXTRA_REGISTERS_FOR_RA / 100.0f);
+  }
   kernel.updateKernelByRegPressure(KernelPressure + ExtraRegs);
 
   return Changed;