Use TR_BitVector instead of CS2::ABitVector in TR_InterferenceGraph

nbhuiyan · nbhuiyan · commit 6d806b9844db · 2020-11-19T15:13:27.000-07:00
Some of the largest symbols in the compiler obj files originates
from TR_InterferenceGraph resulting from its use of
CS2::ABitVector, while providing no real benefits in terms
of capabilities or performance. Use of CS2::ABitVector has been
replaced with TR_BitVector in TR_InterferenceGraph, which results
in significant reduction in the size of the Compiler component's
obj files, whether it is part of a standalone OMR build or part of
a downstream project.

Signed-off-by: Nazim Bhuiyan &lt;nubhuiyan@ibm.com&gt;
diff --git a/compiler/infra/InterferenceGraph.cpp b/compiler/infra/InterferenceGraph.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corp. and others
+ * Copyright (c) 2000, 2020 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -225,50 +225,48 @@ void TR_InterferenceGraph::virtualRemoveNodeFromIG(TR_IGNode *igNode)
 // Partition the nodes identified by the 'workingSet' bit vector into sets
 // based on their degree.
 //
-void TR_InterferenceGraph::partitionNodesIntoDegreeSets(CS2::ABitVector<TR::Allocator> &workingSet,
-                                                        CS2::ABitVector<TR::Allocator> &colourableDegreeSet,
-                                                        CS2::ABitVector<TR::Allocator> &notColourableDegreeSet)
+void TR_InterferenceGraph::partitionNodesIntoDegreeSets(TR_BitVector *workingSet,
+                                                        TR_BitVector *colourableDegreeSet,
+                                                        TR_BitVector *notColourableDegreeSet)
    {
    int32_t               i;
-   CS2::ABitVector<TR::Allocator>::Cursor bvc(workingSet);
+   TR_BitVectorIterator bvi(*workingSet);
 
    TR_ASSERT(getNumColours() > 0,
           "can't partition without knowing the number of available colours\n");
 
    // Empty the existing degree sets.
    //
-   colourableDegreeSet.Clear();
-   colourableDegreeSet.GrowTo(getNumColours());
-   notColourableDegreeSet.Clear();
-   notColourableDegreeSet.GrowTo(getNumColours());
+   colourableDegreeSet->empty();
+   notColourableDegreeSet->empty();
 
    // Partition the specified nodes into sets based on their working degree.
    //
-   for(bvc.SetToFirstOne(); bvc.Valid(); bvc.SetToNextOne())
-     {
-     i = bvc;
-
-     if (getNodeTable(i)->getWorkingDegree() < getNumColours())
-       {
-       colourableDegreeSet[i] = 1;
-       }
-     else
-       {
-       notColourableDegreeSet[i] = 1;
-       }
-     }
+   while (bvi.hasMoreElements())
+      {
+      i = bvi.getNextElement();
+
+      if (getNodeTable(i)->getWorkingDegree() < getNumColours())
+         {
+         colourableDegreeSet->set(i);
+         }
+      else
+         {
+         notColourableDegreeSet->set(i);
+         }
+      }
 
 #ifdef DEBUG
    if (debug("traceIG"))
      {
      diagnostic("\nPartitioned Nodes\n");
      diagnostic("-----------------\n");
 
-     diagnostic("\n[%4d] degree < %-10d : ", colourableDegreeSet.PopulationCount(), getNumColours());
-     (*comp()) << colourableDegreeSet;
+     diagnostic("\n[%4d] degree < %-10d : ", colourableDegreeSet->elementCount(), getNumColours());
+     colourableDegreeSet->print(comp());
 
-     diagnostic("\n[%4d] degree < MAX_DEGREE : ", notColourableDegreeSet.PopulationCount());
-     (*comp()) << notColourableDegreeSet;
+     diagnostic("\n[%4d] degree < MAX_DEGREE : ", notColourableDegreeSet->elementCount());
+     notColourableDegreeSet->print(comp());
      diagnostic("\n\n");
      }
 #endif
@@ -344,13 +342,11 @@ bool TR_InterferenceGraph::simplify()
 
    if (getNumNodes()==0) return true;
 
-   CS2::ABitVector<TR::Allocator> workingSet(comp()->allocator());
-   workingSet.SetAll(getNumNodes());
+   TR_BitVector *workingSet = new (trStackMemory()) TR_BitVector(getNumNodes(), trMemory(), stackAlloc);
+   workingSet->setAll(getNumNodes());
 
-   CS2::ABitVector<TR::Allocator> colourableDegreeSet(comp()->allocator());
-   CS2::ABitVector<TR::Allocator> notColourableDegreeSet(comp()->allocator());
-   colourableDegreeSet.GrowTo(getNumNodes());
-   notColourableDegreeSet.GrowTo(getNumNodes());
+   TR_BitVector * colourableDegreeSet = new (trStackMemory()) TR_BitVector(getNumNodes(), trMemory(), stackAlloc);
+   TR_BitVector * notColourableDegreeSet = new (trStackMemory()) TR_BitVector(getNumNodes(), trMemory(), stackAlloc);
 
    for (i=0; i<getNumNodes(); i++)
       {
@@ -360,20 +356,20 @@ bool TR_InterferenceGraph::simplify()
       igNode->setColour(UNCOLOURED);
       }
 
-   while (!workingSet.IsZero())
+   while (!workingSet->isEmpty())
       {
       partitionNodesIntoDegreeSets(workingSet,colourableDegreeSet,notColourableDegreeSet);
 
       // Push nodes from the colourable set onto the stack and adjust the degrees of
       // their neighbours until there are no nodes remaining in the colourable set.
       //
-      if (!colourableDegreeSet.IsZero())
+      if (!colourableDegreeSet->isEmpty())
          {
-         CS2::ABitVector<TR::Allocator>::Cursor colourableCursor(colourableDegreeSet);
+         TR_BitVectorIterator bvi(*colourableDegreeSet);
 
-         for(colourableCursor.SetToFirstOne(); colourableCursor.Valid(); colourableCursor.SetToNextOne())
+         while (bvi.hasMoreElements())
             {
-            igNode = getNodeTable(colourableCursor);
+            igNode = getNodeTable(bvi.getNextElement());
 
             if (debug("traceIG"))
                {
@@ -382,7 +378,7 @@ bool TR_InterferenceGraph::simplify()
                }
 
             virtualRemoveNodeFromIG(igNode);
-            workingSet[igNode->getIndex()] = 0;
+            workingSet->reset(igNode->getIndex());
             getNodeStack()->push(igNode);
             }
 
@@ -394,21 +390,22 @@ bool TR_InterferenceGraph::simplify()
       // There are no nodes left in the colourable set.  Choose a spill candidate among nodes in
       // the non-colourable degree set.
       //
-      TR_ASSERT(!notColourableDegreeSet.IsZero(),
+      TR_ASSERT(!notColourableDegreeSet->isEmpty(),
              "not colourable set must contain at least one member\n");
 
-      CS2::ABitVector<TR::Allocator>::Cursor notColourableCursor(notColourableDegreeSet);
-      if (!notColourableDegreeSet.IsZero())
+      //CS2::ABitVector<TR::Allocator>::Cursor notColourableCursor(notColourableDegreeSet);
+      TR_BitVectorIterator bvi;
+      if (!notColourableDegreeSet->isEmpty())
          {
          // Choose the node from this degree set with the largest degree
          // and optimistically push it onto the stack.
          //
          int32_t degree = -1;
 
          bestSpillNode = NULL;
-         for(notColourableCursor.SetToFirstOne(); notColourableCursor.Valid(); notColourableCursor.SetToNextOne())
+         while (bvi.hasMoreElements())
             {
-            igNode = getNodeTable(notColourableCursor);
+            igNode = getNodeTable(bvi.getNextElement());
             if (igNode->getDegree() > degree)
                {
                degree = igNode->getDegree();
@@ -419,7 +416,7 @@ bool TR_InterferenceGraph::simplify()
          TR_ASSERT(bestSpillNode, "Could not find a spill candidate.\n");
 
          virtualRemoveNodeFromIG(bestSpillNode);
-         workingSet[bestSpillNode->getIndex()] = 0;
+         workingSet->reset(bestSpillNode->getIndex());
          getNodeStack()->push(bestSpillNode);
          }
       }
@@ -435,18 +432,16 @@ bool TR_InterferenceGraph::select()
    TR_IGNode            *igNode;
    TR_BitVectorIterator  bvi;
 
-   CS2::ABitVector<TR::Allocator> availableColours(comp()->allocator());
-   CS2::ABitVector<TR::Allocator> assignedColours(comp()->allocator());
-   availableColours.GrowTo(getNumColours());
-   assignedColours.GrowTo(getNumColours());
+   TR_BitVector *availableColours = new (trStackMemory()) TR_BitVector(getNumColours(), trMemory(), stackAlloc);
+   TR_BitVector *assignedColours = new (trStackMemory()) TR_BitVector(getNumColours(), trMemory(), stackAlloc);
 
    setNumberOfColoursUsedToColour(0);
 
    while (!getNodeStack()->isEmpty())
       {
       igNode = getNodeStack()->pop();
 
-      availableColours.SetAll(getNumColours());
+      availableColours->setAll(getNumColours());
 
       ListIterator<TR_IGNode> iterator(&igNode->getAdjList());
       TR_IGNode *adjCursor = iterator.getFirst();
@@ -455,7 +450,7 @@ bool TR_InterferenceGraph::select()
          {
          if (adjCursor->getColour() != UNCOLOURED)
             {
-            availableColours[adjCursor->getColour()] = 0;
+            availableColours->reset(adjCursor->getColour());
             }
 
          adjCursor = iterator.getNext();
@@ -464,16 +459,21 @@ bool TR_InterferenceGraph::select()
       if (debug("traceIG"))
          {
          diagnostic("SELECT:  For IG node #%d (%p), available colours = ", igNode->getIndex(), igNode);
-         (*comp()) << availableColours;
+         availableColours->print(_compilation);
          diagnostic("\n");
          }
 
-      if (!availableColours.IsZero())
+      bvi.setBitVector(*availableColours);
+
+      if (bvi.hasMoreElements())
          {
-         IGNodeColour colour = (IGNodeColour)availableColours.FirstOne();
+         IGNodeColour colour = (IGNodeColour)bvi.getNextElement();
          igNode->setColour(colour);
 
-         assignedColours[colour] = 1;
+         if (!assignedColours->isSet(colour))
+            {
+            assignedColours->set(colour);
+            }
 
          if (debug("traceIG"))
             {
@@ -493,7 +493,7 @@ bool TR_InterferenceGraph::select()
          }
       }
 
-  setNumberOfColoursUsedToColour(assignedColours.PopulationCount());
+   setNumberOfColoursUsedToColour(assignedColours->elementCount());
    return true;
    }
 
diff --git a/compiler/infra/InterferenceGraph.hpp b/compiler/infra/InterferenceGraph.hpp
@@ -76,9 +76,9 @@ class TR_InterferenceGraph : public TR_IGBase
    TR_StackMemory            trStackMemory()               { return _trMemory; }
    TR_HeapMemory             trHeapMemory()                { return _trMemory; }
 
-   void partitionNodesIntoDegreeSets(CS2::ABitVector<TR::Allocator> &workingSet,
-                                     CS2::ABitVector<TR::Allocator> &colourableDegreeSet,
-                                     CS2::ABitVector<TR::Allocator> &notColourableDegreeSet);
+   void partitionNodesIntoDegreeSets(TR_BitVector *workingSet,
+                                     TR_BitVector *colourableDegreeSet,
+                                     TR_BitVector *notColourableDegreeSet);
 
    TR::Compilation *_compilation;
    TR_Memory *_trMemory;
