Merge pull request #242 from hzongaro/issue17033-commoning-store-sinking-0.54.0

[0.54.0] Track distinct live commoned loads of locals for Store Sinking

Author: vijaysun-omr

compiler/optimizer/DataFlowAnalysis.hpp

@@ -766,6 +766,20 @@ class TR_LiveVariableInformation
    int32_t numNodes()                { return _numNodes; }
 
    TR_BitVector *liveCommonedLoads() { return _liveCommonedLoads; }
+
+   /**
+    * The number of distinct commoned loads that are live for a particular
+    * local variable during a backwards tree walk.
+    * \param localIdx The index of a local variable
+    * \returns The number of distinct commoned loads of the local variable
+    *          that are live, or zero if the number of distinct commoned
+    *          loads is not being tracked.
+    */
+   int32_t numDistinctCommonedLoads(int32_t localIdx)
+      {
+      return (_distinctCommonedLoads == NULL) ? 0 : _distinctCommonedLoads[localIdx];
+      }
+
    void createGenAndKillSetCaches();
    void initializeGenAndKillSetInfo(TR_BitVector **genSetInfo, TR_BitVector **killSetInfo,
                                     TR_BitVector **exceptionGenSetInfo, TR_BitVector **exceptionKillSetInfo);
@@ -815,6 +829,20 @@ class TR_LiveVariableInformation
 
    // this bit vector tracks which commoned loads are currently live
    TR_BitVector   *_liveCommonedLoads;
+
+   /**
+    * A \ref TR::NodeChecklist that is used to keep track of whether a particular
+    * commoned \ref TR::Node for the load of a local variable has already been
+    * encountered during a backwards tree walk.
+    */
+   TR::NodeChecklist   *_seenCommonedNodeForLoadOfLocal;
+
+   /**
+    * An array that is used to keep track of the number of distinct commoned
+    * loads of a local variable that are live at a given point in a backwards
+    * tree walk.
+    */
+   int32_t        *_distinctCommonedLoads;
    };
 
 

compiler/optimizer/LiveVariableInformation.cpp

@@ -54,10 +54,10 @@ class TR_Structure;
 namespace TR { class Optimizer; }
 
 TR_LiveVariableInformation::TR_LiveVariableInformation(TR::Compilation   *c,
-			                               TR::Optimizer *optimizer,
-			                               TR_Structure     *rootStructure,
-			                               bool              splitLongs,
-			                               bool              includeParms,
+                                                       TR::Optimizer *optimizer,
+                                                       TR_Structure     *rootStructure,
+                                                       bool              splitLongs,
+                                                       bool              includeParms,
                                                        bool              ignoreOSRUses)
    : _compilation(c), _trMemory(c->trMemory()), _ignoreOSRUses(ignoreOSRUses)
    {
@@ -77,6 +77,8 @@ TR_LiveVariableInformation::TR_LiveVariableInformation(TR::Compilation   *c,
 
    _haveCachedGenAndKillSets = false;
    _liveCommonedLoads = NULL;
+   _seenCommonedNodeForLoadOfLocal = NULL;
+   _distinctCommonedLoads = NULL;
    }
 
 void TR_LiveVariableInformation::collectLiveVariableInformation()
@@ -413,10 +415,10 @@ void TR_LiveVariableInformation::visitTreeForLocals(TR::Node *node, TR_BitVector
       {
       if (movingForwardThroughTrees)
          traceMsg(comp(), "         Looking forward for uses in node %p has visitCount = %d and comp() visitCount = %d\n",
-		  node, node->getVisitCount(), visitCount);
+                  node, node->getVisitCount(), visitCount);
       else
          traceMsg(comp(), "         Looking backward for uses in node %p has future use count = %d and reference count = %d\n",
-		  node, node->getFutureUseCount(), node->getReferenceCount());
+                  node, node->getFutureUseCount(), node->getReferenceCount());
       }
 
    uint16_t localIndex = INVALID_LIVENESS_INDEX;
@@ -468,6 +470,26 @@ void TR_LiveVariableInformation::visitTreeForLocals(TR::Node *node, TR_BitVector
             if (traceLiveVarInfo())
                traceMsg(comp(), "            not first reference\n");
 
+            if (_liveCommonedLoads != NULL && local != NULL)
+               {
+               if (_seenCommonedNodeForLoadOfLocal == NULL)
+                  {
+                  _seenCommonedNodeForLoadOfLocal = new (trStackMemory()) TR::NodeChecklist(comp());
+                  _distinctCommonedLoads = (int32_t *) comp()->trMemory()->allocateStackMemory(_numLocals * sizeof(int32_t));
+                  memset(_distinctCommonedLoads, 0x0, _numLocals * sizeof(int32_t));
+                  }
+
+               // Has this load of a local variable been encountered before in this backwards
+               // tree walk?  If not, add the node to the checklist and bump the number of distinct
+               // commoned loads of the local variable.
+               //
+               if (!_seenCommonedNodeForLoadOfLocal->contains(node))
+                  {
+                  _seenCommonedNodeForLoadOfLocal->add(node);
+                  _distinctCommonedLoads[localIndex] = _distinctCommonedLoads[localIndex] + 1;
+                  }
+               }
+
             // traversal should either end here (for regular traversal) or track that we're below a commoned node
             if (visitEntireTree)
                belowCommonedNode = true;
@@ -476,12 +498,60 @@ void TR_LiveVariableInformation::visitTreeForLocals(TR::Node *node, TR_BitVector
             }
          else
             {
-            if (traceLiveVarInfo())
-               traceMsg(comp(), "            first reference\n");
+            bool otherReferencesStillLive = false;
 
-            // if this is a load, clear it in liveCommonedLoads if we've been asked to track them
+            // if this is a load, and there are no other live commoned loads of the local,
+            // clear it in liveCommonedLoads if we've been asked to track them
             if (_liveCommonedLoads != NULL && local != NULL)
-               _liveCommonedLoads->reset(localIndex);
+               {
+               if (_seenCommonedNodeForLoadOfLocal != NULL)
+                  {
+                  // If we've encountered a commoned reference to this node, decrease
+                  // the number of distinct commoned references of the local that are
+                  // are still live.  If there are no more live commoned references to
+                  // the local, remove it from _liveCommonedLoads
+                  //
+                  if (_seenCommonedNodeForLoadOfLocal->contains(node))
+                     {
+                     int32_t numDistinctCommonedLoads = _distinctCommonedLoads[localIndex];
+                     _distinctCommonedLoads[localIndex] = numDistinctCommonedLoads - 1;
+
+                     _seenCommonedNodeForLoadOfLocal->remove(node);
+
+                     if (numDistinctCommonedLoads == 1)
+                        {
+                        _liveCommonedLoads->reset(localIndex);
+                        }
+                     else
+                        {
+                        otherReferencesStillLive = true;
+                        }
+                     }
+                  }
+               else
+                  {
+                  _liveCommonedLoads->reset(localIndex);
+                  }
+               }
+
+            if (traceLiveVarInfo())
+               {
+               if (otherReferencesStillLive)
+                  {
+                  traceMsg(comp(), "            First reference to this node, but other commoned references to this local sym are still live\n");
+                  }
+               else
+                  {
+                  if (local != NULL)
+                     {
+                     traceMsg(comp(), "            First reference to this node, and either this is the first of all commoned references to this sym or this it is not a commoned reference\n");
+                     }
+                  else
+                     {
+                     traceMsg(comp(), "            First reference to this node\n");
+                     }
+                  }
+               }
             }
          }
 
@@ -522,6 +592,19 @@ void TR_LiveVariableInformation::visitTreeForLocals(TR::Node *node, TR_BitVector
             if (traceLiveVarInfo())
                traceMsg(comp(), "              Marking %d as live commoned load\n", localIndex);
             _liveCommonedLoads->set(localIndex);
+
+            if (!movingForwardThroughTrees && _seenCommonedNodeForLoadOfLocal != NULL)
+               {
+               // Has this load of a local variable been encountered before in this backwards
+               // tree walk?  If not, add the node to the checklist and bump the number of distinct
+               // commoned loads of the local variable.
+               //
+               if (!_seenCommonedNodeForLoadOfLocal->contains(node))
+                  {
+                  _distinctCommonedLoads[localIndex] = _distinctCommonedLoads[localIndex] + 1;
+                  _seenCommonedNodeForLoadOfLocal->add(node);
+                  }
+               }
             }
          }
       if (_localObjects != NULL && local && local->isLocalObject())

compiler/optimizer/SinkStores.cpp

@@ -715,7 +715,6 @@ void TR_SinkStores::lookForSinkableStores()
 
    // for keeping track of dataflow for each tree
    TR_BitVector *savedLiveCommonedLoads = new (trStackMemory()) TR_BitVector(numLocals, trMemory());
-   TR_BitVector *satisfiedLiveCommonedLoads = new (trStackMemory()) TR_BitVector(numLocals, trMemory());
    TR_BitVector *killedLiveCommonedLoads = new (trStackMemory()) TR_BitVector(numLocals, trMemory());
 
    // treeVisitCount will be incremented for each tree in an EBB
@@ -781,6 +780,7 @@ void TR_SinkStores::lookForSinkableStores()
                foundException = true;
                }
 
+            // remember the currently live commoned loads so that we can figure out later if we can move this store
             (*savedLiveCommonedLoads) = (*_liveVarInfo->liveCommonedLoads());
 
             if (trace())
@@ -789,14 +789,10 @@ void TR_SinkStores::lookForSinkableStores()
                savedLiveCommonedLoads->print(comp());
                traceMsg(comp(), "\n");
                }
+
             // visit the tree below this node and find all the symbols it uses
             TR_BitVector *usedSymbols = new (trStackMemory()) TR_BitVector(numLocals, trMemory());
             TR_BitVector *killedSymbols = new (trStackMemory()) TR_BitVector(numLocals, trMemory());
-            // remove any commoned loads where the first reference to the load has been seen (it is 'satisfied')
-            // satisfiedLiveCommonedLoads was initialized, if required, on the previous node examined
-
-            // remember the currently live commoned loads so that we can figure out later if we can move this store
-            (*savedLiveCommonedLoads) = (*_liveVarInfo->liveCommonedLoads());
 
             treeCommonedLoads->empty();
             if (trace())
@@ -2305,8 +2301,13 @@ TR_SinkStores::genStoreToTempSyms(TR::TreeTop *storeLocation,
                "%s Create new temp store node for commoned loads sym %d and place above store [" POINTER_PRINTF_FORMAT "]\n",OPT_DETAILS, symIdx, storeLocation->getNode())
              && performThisTransformation())
             {
-            // found first ref so reset killed commoned loads for this sym
-            killedLiveCommonedLoads->reset(symIdx);
+            // Found first reference to this commoned load.  If there are no other
+            // live commoned loads of this local, reset killed commoned loads for it
+            if (_liveVarInfo->numDistinctCommonedLoads(symIdx) == 0)
+               {
+               killedLiveCommonedLoads->reset(symIdx);
+               }
+
             TR::SymbolReference *symRef0 = comp()->getSymRefTab()->createTemporary(comp()->getMethodSymbol(), node->getDataType());
             TR::Node *store0 = TR::Node::createStore(symRef0, node);
             TR::TreeTop *store0_tt = TR::TreeTop::create(comp(), store0);