Cache pseudo declarations

Currently, declarations are stored in map from caller to PseudoDcls
struct. Checking if declaration is pseudo then requires iterating
through whole map and checking each element of structs.
We add additional map to get fast lookups.

Author: stefan-il

visa/FlowGraph.cpp

@@ -8,32 +8,19 @@ SPDX-License-Identifier: MIT
 
 
 #include "FlowGraph.h"
-#include "BitSet.h"
 #include "BuildIR.h"
 #include "CFGStructurizer.h"
 #include "DebugInfo.h"
 #include "G4_Kernel.hpp"
 #include "Option.h"
-#include "PhyRegUsage.h"
 #include "visa_wa.h"
 
-#include "BinaryEncodingIGA.h"
-#include "iga/IGALibrary/api/iga.h"
-#include "iga/IGALibrary/api/iga.hpp"
-
 #include <algorithm>
 #include <chrono>
 #include <cstdlib>
-#include <fstream>
-#include <functional>
 #include <iostream>
 #include <iterator>
 #include <random>
-#include <set>
-#include <sstream>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
 
 using namespace vISA;
 
@@ -3678,6 +3665,7 @@ void FlowGraph::addSaveRestorePseudoDeclares(IR_Builder &builder) {
     pseudoVCEDcl = builder.createDeclare(
         "VCE_SAVE", G4_GRF, builder.numEltPerGRF<Type_UD>(),
         static_cast<unsigned short>(numRowsVCE), Type_UD);
+    pseudoDcls.insert(pseudoVCEDcl);
   } else {
     pseudoVCEDcl->getRegVar()->setPhyReg(NULL, 0);
   }
@@ -3710,11 +3698,22 @@ void FlowGraph::addSaveRestorePseudoDeclares(IR_Builder &builder) {
     name = builder.getNameString(64, "SFLAG_%d", i);
     G4_Declare *saveFLAG = builder.createDeclare(
         name, G4_FLAG, (uint16_t)builder.getNumFlagRegisters(), 1, Type_UW);
-    fcallToPseudoDclMap[callSite->asCFInst()] = {VCA, saveA0, saveFLAG};
+    fillPseudoDclMap(callSite->asCFInst(), VCA, saveA0, saveFLAG);
     i++;
   }
 }
 
+void FlowGraph::fillPseudoDclMap(G4_InstCF *cfInst, G4_Declare *VCA,
+                                 G4_Declare *saveA0, G4_Declare *saveFlag) {
+  fcallToPseudoDclMap[cfInst] = {VCA, saveA0, saveFlag};
+  pseudoDcls.insert({VCA, saveA0, saveFlag});
+  pseudoVCADcls.insert(VCA);
+  vISA_ASSERT((3 * fcallToPseudoDclMap.size() + 1) == pseudoDcls.size(),
+              "Found inconsistency between fcallToPseudoDclMap and pseudoDcls");
+  vISA_ASSERT(fcallToPseudoDclMap.size() == pseudoVCADcls.size(),
+              "Found inconsistency between fcallToPseudoDclMap and pseudoVCADcls");
+}
+
 //
 // Since we don't do SIMD augmentation in RA for CM, we have to add an edge
 // between the then and else block of an if branch to ensure that liveness is

visa/FlowGraph.h

@@ -11,9 +11,9 @@ SPDX-License-Identifier: MIT
 
 #include "Assertions.h"
 #include "G4_BB.hpp"
+#include "G4_Declare.h"
 #include "G4_IR.hpp"
 #include "LoopAnalysis.h"
-#include "RelocationInfo.h"
 
 #include <list>
 #include <map>
@@ -257,6 +257,10 @@ class FlowGraph {
   // TODO: remove this in favor of LoopAnalysis.
   Loop naturalLoops;
 
+  // Caches to speed up the lookup of pseudo declares
+  std::unordered_set<const G4_Declare *> pseudoDcls;
+  std::unordered_set<const G4_Declare *> pseudoVCADcls;
+
 public:
   Mem_Manager &mem; // mem mananger for creating BBs & starting IP table
   INST_LIST_NODE_ALLOCATOR &instListAlloc;
@@ -293,7 +297,7 @@ class FlowGraph {
     G4_Declare *Flag;
   };
 
-  std::unordered_map<G4_InstCF *, struct PseudoDcls> fcallToPseudoDclMap;
+  std::unordered_map<G4_InstCF *, PseudoDcls> fcallToPseudoDclMap;
 
   // offset in unit of OW
   unsigned callerSaveAreaOffset = 0;
@@ -376,12 +380,7 @@ class FlowGraph {
     return dcl == pseudoVCEDcl;
   }
   bool isPseudoVCADcl(const G4_Declare *dcl) const {
-    for (const auto &iter : fcallToPseudoDclMap) {
-      if (iter.second.VCA == dcl) {
-        return true;
-      }
-    }
-    return false;
+   return pseudoVCADcls.count(dcl) == 1;
   }
   bool isPseudoA0Dcl(const G4_Declare *dcl) const {
     for (const auto &iter : fcallToPseudoDclMap) {
@@ -403,16 +402,7 @@ class FlowGraph {
     if (!getHasStackCalls() && !getIsStackCallFunc()) {
       return false;
     }
-    if (isPseudoVCEDcl(dcl)) {
-      return true;
-    }
-    for (const auto &iter : fcallToPseudoDclMap) {
-      if (iter.second.A0 == dcl || iter.second.Flag == dcl ||
-          iter.second.VCA == dcl) {
-        return true;
-      }
-    }
-    return false;
+    return pseudoDcls.count(dcl) == 1;
   }
 
   //
@@ -681,6 +671,8 @@ class FlowGraph {
   using BBPrePostIDMap = std::unordered_map<G4_BB *, std::array<uint32_t, 2>>;
   void DFSTraverse(G4_BB *bb, unsigned &preId, unsigned &postId, FuncInfo *fn,
                    BBPrePostIDMap &BBIdMap);
+  void fillPseudoDclMap(G4_InstCF *cfInst, G4_Declare *VCA, G4_Declare *saveA0,
+                        G4_Declare *saveFlag);
 
 }; // FlowGraph
 

visa/GraphColor.cpp

@@ -4945,23 +4945,14 @@ void Augmentation::handleSIMDIntf(G4_Declare *firstDcl, G4_Declare *secondDcl,
     return;
   }
 
-  auto contain = [](const auto &C, auto pred) {
-    return std::find_if(C.cbegin(), C.cend(), pred) != C.cend();
-  };
-
   bool isFirstDcl = true;
+  bool isPseudoVCADcl = kernel.fg.isPseudoVCADcl(firstDcl);
+  if (!isPseudoVCADcl){
+    isPseudoVCADcl = kernel.fg.isPseudoVCADcl(secondDcl);
+    isFirstDcl = false;
+  }
 
-  auto pred = [firstDcl, secondDcl, &isFirstDcl](const auto &el) {
-    if (el.second.VCA == firstDcl)
-      return true;
-    if (el.second.VCA == secondDcl) {
-      isFirstDcl = false;
-      return true;
-    }
-    return false;
-  };
-
-  if (contain(kernel.fg.fcallToPseudoDclMap, pred)) {
+  if (isPseudoVCADcl) {
     // Mark intf for following pattern:
     // V33 =
     // ...