BenefitInliner phase 2/3 Classes for building the IDT.

compiler/control/OMROptions.cpp

@@ -1132,6 +1132,7 @@ TR::OptionTable OMR::Options::_jitOptions[] = {
    {"traceBasicBlockPeepHole",          "L\ttrace basic blocks peepHole",                  TR::Options::traceOptimization, basicBlockPeepHole, 0, "P"},
    {"traceBBVA",                        "L\ttrace backward bit vector analysis",           SET_OPTION_BIT(TR_TraceBBVA), "P" },
    {"traceBC",                          "L\tdump bytecodes",                               SET_OPTION_BIT(TR_TraceBC), "P" },
+   {"traceBenefitInlinerIDTGen",        "L\ttrace benefit inliner IDT generation",         SET_OPTION_BIT(TR_TraceBIIDTGen), "P" },
    {"traceBlockFrequencyGeneration",    "L\ttrace block frequency generation",             SET_OPTION_BIT(TR_TraceBFGeneration), "P"},
    {"traceBlockShuffling",              "L\ttrace random rearrangement of blocks",         TR::Options::traceOptimization, blockShuffling, 0, "P"},
    {"traceBlockSplitter",               "L\ttrace block splitter",                         TR::Options::traceOptimization, blockSplitter, 0, "P"},

compiler/control/OMROptions.hpp

@@ -96,7 +96,7 @@ enum TR_CompilationOptions
    TR_MimicInterpreterFrameShape = 0x00008000,
 
    TR_TraceBC                    = 0x00010000,
-   // Available                  = 0x00020000,
+   TR_TraceBIIDTGen              = 0x00020000,
    TR_TraceTrees                 = 0x00040000,
    TR_TraceCG                    = 0x00080000,
    TR_TraceAliases               = 0x00100000,

compiler/env/VerboseLog.hpp

@@ -71,6 +71,7 @@ enum TR_VlogTag
    TR_Vlog_PROFILING,
    TR_Vlog_JITServer,
    TR_Vlog_AOTCOMPRESSION,
+   TR_Vlog_BI,       //(benefit inliner)
    TR_Vlog_FSD,
    TR_Vlog_VECTOR_API,
    TR_Vlog_CHECKPOINT_RESTORE,

compiler/optimizer/CMakeLists.txt

@@ -106,4 +106,7 @@ compiler_library(optimizer
 	${CMAKE_CURRENT_LIST_DIR}/abstractinterpreter/AbsValue.cpp
 	${CMAKE_CURRENT_LIST_DIR}/abstractinterpreter/AbsOpStack.cpp
 	${CMAKE_CURRENT_LIST_DIR}/abstractinterpreter/AbsOpArray.cpp
+	${CMAKE_CURRENT_LIST_DIR}/abstractinterpreter/InliningMethodSummary.cpp
+	${CMAKE_CURRENT_LIST_DIR}/abstractinterpreter/IDTNode.cpp
+	${CMAKE_CURRENT_LIST_DIR}/abstractinterpreter/IDT.cpp
 )

compiler/optimizer/abstractinterpreter/IDT.cpp

@@ -0,0 +1,174 @@
+/*******************************************************************************
+ * Copyright IBM Corp. and others 2020
+ *
+ * This program and the accompanying materials are made available under
+ * the terms of the Eclipse Public License 2.0 which accompanies this
+ * distribution and is available at http://eclipse.org/legal/epl-2.0
+ * or the Apache License, Version 2.0 which accompanies this distribution
+ * and is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License, v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception [1] and GNU General Public
+ * License, version 2 with the OpenJDK Assembly Exception [2].
+ *
+ * [1] https://www.gnu.org/software/classpath/license.html
+ * [2] https://openjdk.org/legal/assembly-exception.html
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
+ *******************************************************************************/
+
+#include "optimizer/abstractinterpreter/IDT.hpp"
+#include "infra/String.hpp"
+
+TR::IDT::IDT(TR::Region& region, TR_CallTarget* callTarget, TR::ResolvedMethodSymbol* symbol, uint32_t budget, TR::Compilation* comp):
+      _region(region),
+      _nextIdx(-1),
+      _comp(comp),
+      _root(new (_region) IDTNode(getNextGlobalIDTNodeIndex(), callTarget, symbol, -1, 1, NULL, budget)),
+      _indices(NULL),
+      _totalCost(0)
+   {
+   increaseGlobalIDTNodeIndex();
+   }
+
+void TR::IDT::print()
+   {
+   bool verboseInlining = comp()->getOptions()->getVerboseOption(TR_VerboseInlining);
+   bool traceBIIDTGen = comp()->getOption(TR_TraceBIIDTGen);
+
+   if (!verboseInlining && !traceBIIDTGen)
+      return;
+   const uint32_t candidates = getNumNodes() - 1;
+   // print header line
+   TR::StringBuf line(comp()->trMemory()->currentStackRegion());
+   line.appendf("#IDT: %d candidate methods inlinable into %s with a budget %d",
+               candidates,
+               getRoot()->getName(comp()->trMemory()),
+               getRoot()->getBudget());
+
+   TR_VerboseLog::CriticalSection vlogLock(verboseInlining);
+   if (verboseInlining)
+      {
+      TR_VerboseLog::writeLine(TR_Vlog_BI, "%s", line.text());
+      }
+   if (traceBIIDTGen)
+      traceMsg(comp(), "%s\n", line.text());
+
+   if (candidates <= 0)
+      return;
+
+   // print the IDT nodes in BFS
+   TR::deque<TR::IDTNode*, TR::Region&> idtNodeQueue(comp()->trMemory()->currentStackRegion());
+
+   idtNodeQueue.push_back(getRoot());
+   while (!idtNodeQueue.empty())
+      {
+      TR::IDTNode* currentNode = idtNodeQueue.front();
+      idtNodeQueue.pop_front();
+
+      int32_t index = currentNode->getGlobalIndex();
+
+      // skip root node
+      if (index != -1)
+         {
+         line.clear();
+         line.appendf("#IDT: #%d: #%d inlinable @%d -> bcsz=%d %s target %s, static benefit = %d, benefit = %f, cost = %d, budget = %d, callratio = %f, rootcallratio = %f",
+                     index,
+                     currentNode->getParentGlobalIndex(),
+                     currentNode->getByteCodeIndex(),
+                     currentNode->getByteCodeSize(),
+                     currentNode->getResolvedMethodSymbol()->signature(comp()->trMemory()),
+                     currentNode->getName(comp()->trMemory()),
+                     currentNode->getStaticBenefit(),
+                     currentNode->getBenefit(),
+                     currentNode->getCost(),
+                     currentNode->getBudget(),
+                     currentNode->getCallRatio(),
+                     currentNode->getRootCallRatio()
+                     );
+         if (verboseInlining)
+            TR_VerboseLog::writeLine(TR_Vlog_BI, "%s", line.text());
+
+         if (traceBIIDTGen)
+            traceMsg(comp(), "%s\n", line.text());
+         }
+
+      // process children
+      for (uint32_t i = 0; i < currentNode->getNumChildren(); i ++)
+         idtNodeQueue.push_back(currentNode->getChild(i));
+      }
+   }
+
+void TR::IDT::flattenIDT()
+   {
+   if (_indices != NULL)
+      return;
+
+   // initialize nodes index array
+   uint32_t numNodes = getNumNodes();
+   _indices = new (_region) TR::IDTNode *[numNodes]();
+
+   // add all the descendents of the root node to the indices array
+   TR::deque<TR::IDTNode*, TR::Region&> idtNodeQueue(comp()->trMemory()->currentStackRegion());
+   idtNodeQueue.push_back(getRoot());
+
+   while (!idtNodeQueue.empty())
+      {
+      TR::IDTNode* currentNode = idtNodeQueue.front();
+      idtNodeQueue.pop_front();
+
+      const int32_t index = currentNode->getGlobalIndex();
+      TR_ASSERT_FATAL(_indices[index + 1] == 0, "Callee index not unique!\n");
+
+      _indices[index + 1] = currentNode;
+
+      for (uint32_t i = 0; i < currentNode->getNumChildren(); i ++)
+         {
+         idtNodeQueue.push_back(currentNode->getChild(i));
+         }
+      }
+   }
+
+TR::IDTNode *TR::IDT::getNodeByGlobalIndex(int32_t index)
+   {
+   TR_ASSERT_FATAL(_indices, "Call flattenIDT() first");
+   TR_ASSERT_FATAL(index < getNextGlobalIDTNodeIndex(), "Index out of range!");
+   TR_ASSERT_FATAL(index >= -1, "Index too low!");
+   return _indices[index + 1];
+   }
+
+TR::IDTPriorityQueue::IDTPriorityQueue(TR::IDT* idt, TR::Region& region)  :
+      _entries(region),
+      _idt(idt),
+      _pQueue(IDTNodeCompare(), IDTNodeVector(region))
+   {
+   _pQueue.push(idt->getRoot());
+   }
+
+TR::IDTNode* TR::IDTPriorityQueue::get(uint32_t index)
+   {
+   const size_t entriesSize = _entries.size();
+
+   const uint32_t idtSize = size();
+   TR_ASSERT_FATAL(index < idtSize, "IDTPriorityQueue::get index out of bound!");
+   // already in entries
+   if (entriesSize > index)
+      return _entries.at(index);
+
+   // not in entries yet. Update entries.
+   while (_entries.size() <= index)
+      {
+      TR::IDTNode *newEntry = _pQueue.top();
+      _pQueue.pop();
+
+      _entries.push_back(newEntry);
+      for (uint32_t j = 0; j < newEntry->getNumChildren(); j++)
+         {
+         _pQueue.push(newEntry->getChild(j));
+         }
+      }
+
+   return _entries.at(index);
+   }

compiler/optimizer/abstractinterpreter/IDT.hpp

@@ -0,0 +1,142 @@
+/*******************************************************************************
+ * Copyright IBM Corp. and others 2020
+ *
+ * This program and the accompanying materials are made available under
+ * the terms of the Eclipse Public License 2.0 which accompanies this
+ * distribution and is available at http://eclipse.org/legal/epl-2.0
+ * or the Apache License, Version 2.0 which accompanies this distribution
+ * and is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License, v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception [1] and GNU General Public
+ * License, version 2 with the OpenJDK Assembly Exception [2].
+ *
+ * [1] https://www.gnu.org/software/classpath/license.html
+ * [2] https://openjdk.org/legal/assembly-exception.html
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
+ *******************************************************************************/
+
+#ifndef IDT_INCL
+#define IDT_INCL
+
+#include "compile/Compilation.hpp"
+#include "optimizer/CallInfo.hpp"
+#include "optimizer/abstractinterpreter/IDTNode.hpp"
+#include "env/Region.hpp"
+#include "env/VerboseLog.hpp"
+#include "il/ResolvedMethodSymbol.hpp"
+#include <queue>
+
+namespace TR {
+
+/**
+ * IDT stands for Inlining Dependency Tree
+ * It is a structure that holds all candidate methods to be inlined.
+ *
+ * The parent-child relationship in the IDT corresponds to the caller-callee relationship.
+ */
+class IDT
+   {
+   public:
+   IDT(TR::Region& region, TR_CallTarget*, TR::ResolvedMethodSymbol* symbol, uint32_t budget, TR::Compilation* comp);
+
+   TR::IDTNode* getRoot() { return _root; }
+
+   TR::Region& getRegion() { return _region; }
+
+   void addCost(uint32_t cost) { _totalCost += cost; }
+   uint32_t getTotalCost() { return _totalCost; }
+
+   /**
+    * @brief Get the total number of nodes in this IDT.
+    *
+    * @return the total number of node
+    */
+   uint32_t getNumNodes() { return _nextIdx + 1; }
+
+   /**
+    * @brief Get the next avaible IDTNode index.
+    *
+    * @return the next index
+    */
+   int32_t getNextGlobalIDTNodeIndex() { return _nextIdx; }
+
+   /**
+    * @brief Increase the next available IDTNode index by 1.
+    * This should only be called when successfully adding an IDTNode to the IDT
+    */
+   void increaseGlobalIDTNodeIndex()  { _nextIdx ++; }
+
+   /**
+    * @brief Get the IDTNode using index.
+    * Before using this method for accessing IDTNode, flattenIDT() must be called.
+    *
+    * @return the IDT node
+    */
+   TR::IDTNode *getNodeByGlobalIndex(int32_t index);
+
+   /**
+    * @brief Flatten all the IDTNodes into a list.
+    */
+   void flattenIDT();
+
+   void print();
+
+   private:
+   TR::Compilation* comp() { return _comp; }
+
+   TR::Compilation *_comp;
+   TR::Region&  _region;
+   int32_t _nextIdx;
+   uint32_t _totalCost;
+   TR::IDTNode* _root;
+   TR::IDTNode** _indices;
+   };
+
+/**
+ * A topological sort of the IDT in which the lowest-benefit node is listed first and lowest cost used to
+ * break the tie whenever there is a choice.
+ *
+ * This topological sort is to prepare an ordered list of inlining options for the algorithm described
+ * in following patent:
+ * https://patents.google.com/patent/US10055210B2/en
+ *
+ * This patent describes the topological sort as the following quote:
+ * "constraints on the order of node consideration, where the constraints serve to ensure every node is
+ * considered only after all of the node's ancestors are considered, and nodes are included in order of
+ * increasing cumulative benefit with lowest cumulative cost used to break ties to allow the generation
+ * of all intermediate solutions at a given cost budget to simplify backtracking in subsequent iterations
+ * of the algorithm".
+ */
+class IDTPriorityQueue
+   {
+   public:
+   IDTPriorityQueue(TR::IDT* idt, TR::Region& region);
+   uint32_t size() { return _idt->getNumNodes(); }
+
+   TR::IDTNode* get(uint32_t index);
+
+   private:
+   struct IDTNodeCompare
+      {
+      bool operator()(TR::IDTNode *left, TR::IDTNode *right)
+         {
+         TR_ASSERT_FATAL(left && right, "Comparing against null");
+         if (left->getBenefit() == right->getBenefit()) return left->getCost() > right->getCost();
+         else return left->getBenefit() > right->getBenefit();
+         }
+      };
+
+   typedef TR::vector<IDTNode*, TR::Region&> IDTNodeVector;
+   typedef std::priority_queue<IDTNode*, IDTNodeVector, IDTNodeCompare> IDTNodePriorityQueue;
+
+   TR::IDT* _idt;
+   IDTNodePriorityQueue _pQueue;
+   IDTNodeVector _entries;
+   };
+}
+
+#endif