Use a shared bit vector for dominance computation

Author: mikedn

src/jit/ssabuilder.cpp

@@ -145,6 +145,7 @@ void Compiler::fgResetForSsa()
 SsaBuilder::SsaBuilder(Compiler* pCompiler)
     : m_pCompiler(pCompiler)
     , m_allocator(pCompiler, CMK_SSA)
+    , m_visitedTraits(0, pCompiler) // at this point we do not know the size, SetupBBRoot can add a block
 #ifdef SSA_FEATURE_DOMARR
     , m_pDomPreOrder(nullptr)
     , m_pDomPostOrder(nullptr)
@@ -170,17 +171,17 @@ int SsaBuilder::TopologicalSort(BasicBlock** postOrder, int count)
 {
     Compiler* comp = m_pCompiler;
 
-    BitVecTraits traits(comp->fgBBNumMax + 1, comp);
-    BitVec       visited(BitVecOps::MakeEmpty(&traits));
-
     // Display basic blocks.
     DBEXEC(VERBOSE, comp->fgDispBasicBlocks());
     DBEXEC(VERBOSE, comp->fgDispHandlerTab());
 
+    // TopologicalSort is called first so m_visited should already be empty
+    assert(BitVecOps::IsEmpty(&m_visitedTraits, m_visited));
+
     // Compute order.
     int         postIndex = 0;
     BasicBlock* block     = comp->fgFirstBB;
-    BitVecOps::AddElemD(&traits, visited, block->bbNum);
+    BitVecOps::AddElemD(&m_visitedTraits, m_visited, block->bbNum);
 
     ArrayStack<BasicBlock*>      blocks(comp);
     ArrayStack<AllSuccessorIter> iterators(comp);
@@ -225,12 +226,12 @@ int SsaBuilder::TopologicalSort(BasicBlock** postOrder, int count)
             ++iter;
 
             // push the children
-            if (!BitVecOps::IsMember(&traits, visited, succ->bbNum))
+            if (!BitVecOps::IsMember(&m_visitedTraits, m_visited, succ->bbNum))
             {
                 blocks.Push(succ);
                 iterators.Push(succ->GetAllSuccs(comp).begin());
                 ends.Push(succ->GetAllSuccs(comp).end());
-                BitVecOps::AddElemD(&traits, visited, succ->bbNum);
+                BitVecOps::AddElemD(&m_visitedTraits, m_visited, succ->bbNum);
             }
         }
         else
@@ -274,10 +275,9 @@ void SsaBuilder::ComputeImmediateDom(BasicBlock** postOrder, int count)
     }
 
     // Add entry point to processed as its IDom is NULL.
-    BitVecTraits traits(m_pCompiler->fgBBNumMax + 1, m_pCompiler);
-    BitVec       processed(BitVecOps::MakeEmpty(&traits));
 
-    BitVecOps::AddElemD(&traits, processed, m_pCompiler->fgFirstBB->bbNum);
+    BitVecOps::ClearD(&m_visitedTraits, m_visited);
+    BitVecOps::AddElemD(&m_visitedTraits, m_visited, m_pCompiler->fgFirstBB->bbNum);
     assert(postOrder[count - 1] == m_pCompiler->fgFirstBB);
 
     bool changed = true;
@@ -296,7 +296,7 @@ void SsaBuilder::ComputeImmediateDom(BasicBlock** postOrder, int count)
             BasicBlock* predBlock = nullptr;
             for (flowList* pred = m_pCompiler->BlockPredsWithEH(block); pred; pred = pred->flNext)
             {
-                if (BitVecOps::IsMember(&traits, processed, pred->flBlock->bbNum))
+                if (BitVecOps::IsMember(&m_visitedTraits, m_visited, pred->flBlock->bbNum))
                 {
                     predBlock = pred->flBlock;
                     break;
@@ -340,7 +340,7 @@ void SsaBuilder::ComputeImmediateDom(BasicBlock** postOrder, int count)
             }
 
             // Mark the current block as processed.
-            BitVecOps::AddElemD(&traits, processed, block->bbNum);
+            BitVecOps::AddElemD(&m_visitedTraits, m_visited, block->bbNum);
 
             DBG_SSA_JITDUMP("Marking block BB%02u as processed.\n", block->bbNum);
         }
@@ -598,8 +598,6 @@ BlkToBlkVectorMap* SsaBuilder::ComputeIteratedDominanceFrontier(BasicBlock** pos
 
     // Now do the closure operation to make the dominance frontier into an IDF.
     BlkToBlkVectorMap* mapIDF = new (&m_allocator) BlkToBlkVectorMap(&m_allocator);
-    // We need to keep track of the blocks added to an IDF to avoid duplicates.
-    hashBv* added = hashBv::Create(m_pCompiler);
 
     for (BlkToBlkVectorMap::KeyIterator ki = mapDF.Begin(); !ki.Equal(mapDF.End()); ki++)
     {
@@ -608,10 +606,11 @@ BlkToBlkVectorMap* SsaBuilder::ComputeIteratedDominanceFrontier(BasicBlock** pos
         BlkVector&  bDF  = ki.GetValue();
         BlkVector&  bIDF = *mapIDF->Emplace(b, &m_allocator);
         bIDF.reserve(bDF.size());
+        BitVecOps::ClearD(&m_visitedTraits, m_visited);
 
         for (BasicBlock* f : bDF)
         {
-            added->setBit(f->bbNum);
+            BitVecOps::AddElemD(&m_visitedTraits, m_visited, f->bbNum);
             bIDF.push_back(f);
         }
 
@@ -629,16 +628,14 @@ BlkToBlkVectorMap* SsaBuilder::ComputeIteratedDominanceFrontier(BasicBlock** pos
             {
                 for (BasicBlock* ff : *fDF)
                 {
-                    if (!added->testBit(ff->bbNum))
+                    if (!BitVecOps::IsMember(&m_visitedTraits, m_visited, ff->bbNum))
                     {
-                        added->setBit(ff->bbNum);
+                        BitVecOps::AddElemD(&m_visitedTraits, m_visited, ff->bbNum);
                         bIDF.push_back(ff);
                     }
                 }
             }
         }
-
-        added->ZeroAll();
     }
 
 #ifdef DEBUG
@@ -1857,6 +1854,9 @@ void SsaBuilder::Build()
         postOrder = (BasicBlock**)alloca(blockCount * sizeof(BasicBlock*));
     }
 
+    m_visitedTraits = BitVecTraits(m_pCompiler->fgBBNumMax + 1, m_pCompiler);
+    m_visited       = BitVecOps::MakeEmpty(&m_visitedTraits);
+
     // Topologically sort the graph.
     int count = TopologicalSort(postOrder, blockCount);
     JITDUMP("[SsaBuilder] Topologically sorted the graph.\n");

src/jit/ssabuilder.h

@@ -176,6 +176,11 @@ class SsaBuilder
     Compiler*     m_pCompiler;
     CompAllocator m_allocator;
 
+    // Bit vector used by TopologicalSort, ComputeImmediateDom and ComputeIteratedDominanceFrontier
+    // to track already visited/added blocks.
+    BitVecTraits m_visitedTraits;
+    BitVec       m_visited;
+
 #ifdef SSA_FEATURE_DOMARR
     // To answer queries of type a DOM b.
     // Do not move these outside of this class, use accessors/interface methods.