[NFC][InstructionCost] Use InstructionCost in lib/Transforms/IPO/IROutliner.cpp

[david-arm]

Summary

In places where we call a TTI.getXXCost() function I have changed
the code to use InstructionCost instead of unsigned. This is in
preparation for later on when we will change the TTI interfaces
to return InstructionCost.

See this patch for the introduction of the type: https://reviews.llvm.org/D91174
See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2020-November/146408.html

[david-arm]

• I realised that instead of calling getValue() and asserting the cost is valid I can just change a few functions to return InstructionCost instead. The code simply compares the benefit and cost and decides to outline based upon that.

[AndrewLitteken]

This looks fine to me, just one small nit in getBenefit for consistency with the rest of the patch.

llvm/lib/Transforms/IPO/IROutliner.cpp

246–247

I know this isn't part of the patch, but should probably be fixed to match up with the rest of the changes..

[sdesmalen]

LGTM

llvm/include/llvm/Transforms/IPO/IROutliner.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_IROUTLINER_H
 #define LLVM_TRANSFORMS_IPO_IROUTLINER_H
 
 #include "llvm/Analysis/IRSimilarityIdentifier.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueMap.h"
+#include "llvm/Support/InstructionCost.h"
 #include "llvm/Transforms/Utils/CodeExtractor.h"
 #include <set>
 
 struct OutlinableGroup;
 
 namespace llvm {
 using namespace IRSimilarity;
 
struct OutlinableRegion {
   /// function has been extracted, the start and end of the BasicBlock
   /// containing the called function.
   void reattachCandidate();
 
   /// Get the size of the code removed from the region.
   ///
   /// \param [in] TTI - The TargetTransformInfo for the parent function.
   /// \returns the code size of the region
-  unsigned getBenefit(TargetTransformInfo &TTI);
+  InstructionCost getBenefit(TargetTransformInfo &TTI);
 };
 
 /// This class is a pass that identifies similarity in a Module, extracts
 /// instances of the similarity, and then consolidating the similar regions
 /// in an effort to reduce code size.  It uses the IRSimilarityIdentifier pass
 /// to identify the similar regions of code, and then extracts the similar
 /// sections into a single function.  See the above for an example as to
 /// how code is extracted and consolidated into a single function.
void findAddInputsOutputs(Module &M, OutlinableRegion &Region,
                             DenseSet<unsigned> &NotSame);
 
   /// Find the number of instructions that will be removed by extracting the
   /// OutlinableRegions in \p CurrentGroup.
   ///
   /// \param [in] CurrentGroup - The collection of OutlinableRegions to be
   /// analyzed.
   /// \returns the number of outlined instructions across all regions.
-  unsigned findBenefitFromAllRegions(OutlinableGroup &CurrentGroup);
+  InstructionCost findBenefitFromAllRegions(OutlinableGroup &CurrentGroup);
 
   /// Find the number of instructions that will be added by reloading arguments.
   ///
   /// \param [in] CurrentGroup - The collection of OutlinableRegions to be
   /// analyzed.
   /// \returns the number of added reload instructions across all regions.
-  unsigned findCostOutputReloads(OutlinableGroup &CurrentGroup);
+  InstructionCost findCostOutputReloads(OutlinableGroup &CurrentGroup);
 
   /// Find the cost and the benefit of \p CurrentGroup and save it back to
   /// \p CurrentGroup.
   ///
   /// \param [in] M - The module being analyzed
   /// \param [in,out] CurrentGroup - The overall outlined section
   void findCostBenefit(Module &M, OutlinableGroup &CurrentGroup);
 

llvm/lib/Transforms/IPO/IROutliner.cpp

struct OutlinableGroup {
   bool InputTypesSet = false;
 
   /// The number of input values in \ref ArgumentTypes.  Anything after this
   /// index in ArgumentTypes is an output argument.
   unsigned NumAggregateInputs = 0;
 
   /// The number of instructions that will be outlined by extracting \ref
   /// Regions.
-  unsigned Benefit = 0;
+  InstructionCost Benefit = 0;
   /// The number of added instructions needed for the outlining of the \ref
   /// Regions.
-  unsigned Cost = 0;
+  InstructionCost Cost = 0;
 
   /// The argument that needs to be marked with the swifterr attribute.  If not
   /// needed, there is no value.
   Optional<unsigned> SwiftErrorArgument;
 
   /// For the \ref Regions, we look at every Value.  If it is a constant,
   /// we check whether it is the same in Region.
   ///
constantMatches(Value *V, unsigned GVN,
   // If it was found and is not equal, it is not the same. We do not
   // handle this case yet, and exit early.
   if (Inserted || (GVNToConstantIt->second == CST))
     return true;
 
   return false;
 }
 
-unsigned OutlinableRegion::getBenefit(TargetTransformInfo &TTI) {
-  InstructionCost Benefit(0);
+InstructionCost OutlinableRegion::getBenefit(TargetTransformInfo &TTI) {
+  InstructionCost Benefit = 0;
 
   // Estimate the benefit of outlining a specific sections of the program.  We
   // delegate mostly this task to the TargetTransformInfo so that if the target
   // has specific changes, we can have a more accurate estimate.
 
   // However, getInstructionCost delegates the code size calculation for
   // arithmetic instructions to getArithmeticInstrCost in
   // include/Analysis/TargetTransformImpl.h, where it always estimates that the
case Instruction::URem:
       Benefit += 1;
       break;
     default:
       Benefit += TTI.getInstructionCost(&I, TargetTransformInfo::TCK_CodeSize);
       break;
     }
   }
 
-  return *Benefit.getValue();
+  return Benefit;
 }
 
 /// Find whether \p Region matches the global value numbering to Constant
 /// mapping found so far.
 ///
 /// \param Region - The OutlinableRegion we are checking for constants
 /// \param GVNToConstant - The mapping of global value number to Constants.
 /// \param NotSame - The set of global value numbers that do not have the same
for (IRSimilarityCandidate &IRSC : CandidateVec) {
     OutlinableRegion *OS = new (RegionAllocator.Allocate())
         OutlinableRegion(IRSC, CurrentGroup);
     CurrentGroup.Regions.push_back(OS);
 
     CurrentEndIdx = EndIdx;
   }
 }
 
-unsigned IROutliner::findBenefitFromAllRegions(OutlinableGroup &CurrentGroup) {
-  unsigned RegionBenefit = 0;
+InstructionCost
+IROutliner::findBenefitFromAllRegions(OutlinableGroup &CurrentGroup) {
+  InstructionCost RegionBenefit = 0;
   for (OutlinableRegion *Region : CurrentGroup.Regions) {
     TargetTransformInfo &TTI = getTTI(*Region->StartBB->getParent());
     // We add the number of instructions in the region to the benefit as an
     // estimate as to how much will be removed.
     RegionBenefit += Region->getBenefit(TTI);
     LLVM_DEBUG(dbgs() << "Adding: " << RegionBenefit
                       << " saved instructions to overfall benefit.\n");
   }
 
   return RegionBenefit;
 }
 
-unsigned IROutliner::findCostOutputReloads(OutlinableGroup &CurrentGroup) {
-  unsigned OverallCost = 0;
+InstructionCost
+IROutliner::findCostOutputReloads(OutlinableGroup &CurrentGroup) {
+  InstructionCost OverallCost = 0;
   for (OutlinableRegion *Region : CurrentGroup.Regions) {
     TargetTransformInfo &TTI = getTTI(*Region->StartBB->getParent());
 
     // Each output incurs a load after the call, so we add that to the cost.
     for (unsigned OutputGVN : Region->GVNStores) {
       Optional<Value *> OV = Region->Candidate->fromGVN(OutputGVN);
       assert(OV.hasValue() && "Could not find value for GVN?");
       Value *V = OV.getValue();
-      unsigned LoadCost =
+      InstructionCost LoadCost =
           TTI.getMemoryOpCost(Instruction::Load, V->getType(), Align(1), 0,
                               TargetTransformInfo::TCK_CodeSize);
 
       LLVM_DEBUG(dbgs() << "Adding: " << LoadCost
                         << " instructions to cost for output of type "
                         << *V->getType() << "\n");
       OverallCost += LoadCost;
     }
   }
 
   return OverallCost;
 }
 
 /// Find the extra instructions needed to handle any output values for the
 /// region.
 ///
 /// \param [in] M - The Module to outline from.
 /// \param [in] CurrentGroup - The collection of OutlinableRegions to analyze.
 /// \param [in] TTI - The TargetTransformInfo used to collect information for
 /// new instruction costs.
 /// \returns the additional cost to handle the outputs.
-static unsigned findCostForOutputBlocks(Module &M,
+static InstructionCost findCostForOutputBlocks(Module &M,
                                                OutlinableGroup &CurrentGroup,
                                                TargetTransformInfo &TTI) {
-  unsigned OutputCost = 0;
+  InstructionCost OutputCost = 0;
 
   for (const ArrayRef<unsigned> &OutputUse :
        CurrentGroup.OutputGVNCombinations) {
     IRSimilarityCandidate &Candidate = *CurrentGroup.Regions[0]->Candidate;
     for (unsigned GVN : OutputUse) {
       Optional<Value *> OV = Candidate.fromGVN(GVN);
       assert(OV.hasValue() && "Could not find value for GVN?");
       Value *V = OV.getValue();
-      unsigned StoreCost =
+      InstructionCost StoreCost =
           TTI.getMemoryOpCost(Instruction::Load, V->getType(), Align(1), 0,
                               TargetTransformInfo::TCK_CodeSize);
 
       // An instruction cost is added for each store set that needs to occur for
       // various output combinations inside the function, plus a branch to
       // return to the exit block.
       LLVM_DEBUG(dbgs() << "Adding: " << StoreCost
                         << " instructions to cost for output of type "
                         << *V->getType() << "\n");
       OutputCost += StoreCost;
     }
 
-    unsigned BranchCost =
+    InstructionCost BranchCost =
         TTI.getCFInstrCost(Instruction::Br, TargetTransformInfo::TCK_CodeSize);
     LLVM_DEBUG(dbgs() << "Adding " << BranchCost << " to the current cost for"
                       << " a branch instruction\n");
     OutputCost += BranchCost;
   }
 
   // If there is more than one output scheme, we must have a comparison and
   // branch for each different item in the switch statement.
   if (CurrentGroup.OutputGVNCombinations.size() > 1) {
-    unsigned ComparisonCost = TTI.getCmpSelInstrCost(
+    InstructionCost ComparisonCost = TTI.getCmpSelInstrCost(
         Instruction::ICmp, Type::getInt32Ty(M.getContext()),
         Type::getInt32Ty(M.getContext()), CmpInst::BAD_ICMP_PREDICATE,
         TargetTransformInfo::TCK_CodeSize);
-    unsigned BranchCost =
+    InstructionCost BranchCost =
         TTI.getCFInstrCost(Instruction::Br, TargetTransformInfo::TCK_CodeSize);
 
     unsigned DifferentBlocks = CurrentGroup.OutputGVNCombinations.size();
-    unsigned TotalCost = ComparisonCost * BranchCost * DifferentBlocks;
+    InstructionCost TotalCost = ComparisonCost * BranchCost * DifferentBlocks;
 
     LLVM_DEBUG(dbgs() << "Adding: " << TotalCost
                       << " instructions for each switch case for each different"
                       << " output path in a function\n");
     OutputCost += TotalCost;
   }
 
   return OutputCost;
 }
 
 void IROutliner::findCostBenefit(Module &M, OutlinableGroup &CurrentGroup) {
-  unsigned RegionBenefit = findBenefitFromAllRegions(CurrentGroup);
+  InstructionCost RegionBenefit = findBenefitFromAllRegions(CurrentGroup);
   CurrentGroup.Benefit += RegionBenefit;
   LLVM_DEBUG(dbgs() << "Current Benefit: " << CurrentGroup.Benefit << "\n");
 
-  unsigned OutputReloadCost = findCostOutputReloads(CurrentGroup);
+  InstructionCost OutputReloadCost = findCostOutputReloads(CurrentGroup);
   CurrentGroup.Cost += OutputReloadCost;
   LLVM_DEBUG(dbgs() << "Current Cost: " << CurrentGroup.Cost << "\n");
 
-  unsigned AverageRegionBenefit = RegionBenefit / CurrentGroup.Regions.size();
+  InstructionCost AverageRegionBenefit =
+      RegionBenefit / CurrentGroup.Regions.size();
   unsigned OverallArgumentNum = CurrentGroup.ArgumentTypes.size();
   unsigned NumRegions = CurrentGroup.Regions.size();
   TargetTransformInfo &TTI =
       getTTI(*CurrentGroup.Regions[0]->Candidate->getFunction());
 
   // We add one region to the cost once, to account for the instructions added
   // inside of the newly created function.
   LLVM_DEBUG(dbgs() << "Adding: " << AverageRegionBenefit
if (CurrentGroup.Cost >= CurrentGroup.Benefit && CostModel) {
       ORE.emit([&]() {
         IRSimilarityCandidate *C = CurrentGroup.Regions[0]->Candidate;
         OptimizationRemarkMissed R(DEBUG_TYPE, "WouldNotDecreaseSize",
                                    C->frontInstruction());
         R << "did not outline "
           << ore::NV(std::to_string(CurrentGroup.Regions.size()))
           << " regions due to estimated increase of "
           << ore::NV("InstructionIncrease",
-                     std::to_string(static_cast<int>(CurrentGroup.Cost -
-                                                     CurrentGroup.Benefit)))
+                     CurrentGroup.Cost - CurrentGroup.Benefit)
           << " instructions at locations ";
         interleave(
             CurrentGroup.Regions.begin(), CurrentGroup.Regions.end(),
             [&R](OutlinableRegion *Region) {
               R << ore::NV(
                   "DebugLoc",
                   Region->Candidate->frontInstruction()->getDebugLoc());
             },
for (SimilarityGroup &CandidateVec : SimilarityCandidates) {
 
     OptimizationRemarkEmitter &ORE =
         getORE(*CurrentGroup.Regions[0]->Call->getFunction());
     ORE.emit([&]() {
       IRSimilarityCandidate *C = CurrentGroup.Regions[0]->Candidate;
       OptimizationRemark R(DEBUG_TYPE, "Outlined", C->front()->Inst);
       R << "outlined " << ore::NV(std::to_string(CurrentGroup.Regions.size()))
         << " regions with decrease of "
-        << ore::NV("Benefit", std::to_string(static_cast<int>(
-                                  CurrentGroup.Benefit - CurrentGroup.Cost)))
+        << ore::NV("Benefit", CurrentGroup.Benefit - CurrentGroup.Cost)
         << " instructions at locations ";
       interleave(
           CurrentGroup.Regions.begin(), CurrentGroup.Regions.end(),
           [&R](OutlinableRegion *Region) {
             R << ore::NV("DebugLoc",
                          Region->Candidate->frontInstruction()->getDebugLoc());
           },
           [&R]() { R << " "; });