[FuncSpec] Statistics

[SjoerdMeijer]

Summary

Adds some bookkeeping for collecting the number of specialised functions, and a test.

[SjoerdMeijer]

This is sort of a placeholder for follow up comments of D93838 while I am looking into a few things.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

67

I did change something here; partly addressed this, but need to remind myself what that was. Will look into this.

[SjoerdMeijer]

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

466

Looks like this is not covered by a test. Would be good to have one.

Will look into that.

[SjoerdMeijer]

The wrong location didn't sit right, so I have precommitted that in rG9907746f5db7 before I continue with the rest and this is a little rebase on top of that.

[fhahn]

Thanks for the update! Could you update the description/title, as they seem a bit out-of-sync after the recent changes.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

124

might be good to also have a test to check the stats work as expected?

146

Would be good to add a comment. Should the type be unsigned?

[ChuanqiXu]

It looks like this patch is tried to refactor the counter? What's the difference after applying this patch? Or is it a NFC patch?

[SjoerdMeijer]

Thanks for your comments. I quickly put this patch together to collect post-commit comments. I will pick this is up today.

[ChuanqiXu]

In D104102#2818671, @SjoerdMeijer wrote:

Thanks for your comments. I quickly put this patch together to collect post-commit comments. I will pick this is up today.

Oh, so it is a WIP patch which containing changes in different aspects? I am not sure if it is better to separate them. I guess it would be better to review and revert (if needed).

[SjoerdMeijer]

This is now only about statistics: commented/renamed the counter, and added a test case.

[ChuanqiXu]

LGTM.

[fhahn]

llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll

3 ↗

(On Diff #352055)

do we need to run those unrelated passes?

[SjoerdMeijer]

llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll

3 ↗

(On Diff #352055)

Not necessarily, but it kind of nicely illustrates the possibilities with those "clean up" passes, the things function specialisation enables.

Let me know what you prefer as I am of course happy to remove them.

[fhahn]

llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll

3 ↗

(On Diff #352055)

Not necessarily, but it kind of nicely illustrates the possibilities with those "clean up" passes, the things function specialisation enables.

Let me know what you prefer as I am of course happy to remove them.

Usually we try to avoid having tests depend on different passes, to reduce churn when making changes to unrelated passes. While it is nice other stats improve, it’s independent of checking the function specialisation stats.

[SjoerdMeijer]

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

466

Added a test for that in rG29843cbc88f6.

llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll

3 ↗

(On Diff #352055)

Ok, sure, understood. This is indeed almost an end-to-end test for function specialisation, and it would be good to have that, but it does not necessarily fit here. Will modify this test.

llvm/lib/Transforms/IPO/CMakeLists.txt

add_llvm_component_library(LLVMipo
   ConstantMerge.cpp
   CrossDSOCFI.cpp
   DeadArgumentElimination.cpp
   ElimAvailExtern.cpp
   ExtractGV.cpp
   ForceFunctionAttrs.cpp
   FunctionAttrs.cpp
   FunctionImport.cpp
+  FunctionSpecialization.cpp
   GlobalDCE.cpp
   GlobalOpt.cpp
   GlobalSplit.cpp
   HotColdSplitting.cpp
   IPO.cpp
   IROutliner.cpp
   InferFunctionAttrs.cpp
   InlineSimple.cpp

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

static cl::opt<unsigned> MaxConstantsThreshold(
     cl::init(3));
 
 static cl::opt<unsigned>
     AvgLoopIterationCount("func-specialization-avg-iters-cost", cl::Hidden,
                           cl::desc("Average loop iteration count cost"),
                           cl::init(10));
 
 // Helper to check if \p LV is either overdefined or a constant int.
 static bool isOverdefined(const ValueLatticeElement &LV) {
   return !LV.isUnknownOrUndef() && !LV.isConstant();
 }
 
 class FunctionSpecializer {
 
   /// The IPSCCP Solver.
   SCCPSolver &Solver;
 
for (auto *SpecializedFunc : CurrentSpecializations) {
       // them argument-tracked and executable.
 
       // Replace the function arguments for the specialized functions.
       for (Argument &Arg : SpecializedFunc->args())
         if (!Arg.use_empty() && tryToReplaceWithConstant(&Arg))
           LLVM_DEBUG(dbgs() << "FnSpecialization: Replaced constant argument: "
                             << Arg.getName() << "\n");
     }
+
+    NumFuncSpecialized += FunctionsSpecialized;
     return Changed;
   }
 
   bool tryToReplaceWithConstant(Value *V) {
     if (!V->getType()->isSingleValueType() || isa<CallBase>(V) ||
         V->user_empty())
       return false;
 
     const ValueLatticeElement &IV = Solver.getLatticeValueFor(V);
     if (isOverdefined(IV))
       return false;
     auto *Const = IV.isConstant() ? Solver.getConstant(IV)
                                   : UndefValue::get(V->getType());
     V->replaceAllUsesWith(Const);
 
     // TODO: Update the solver here if we want to specialize specialized
     // functions.
     return true;
   }
 
 private:
+  int FunctionsSpecialized = 0;
+
   /// This function decides whether to specialize function \p F based on the
   /// known constant values its arguments can take on. Specialization is
   /// performed on the first interesting argument. Specializations based on
   /// additional arguments will be evaluated on following iterations of the
   /// main IPSCCP solve loop. \returns true if the function is specialized and
   /// false otherwise.
   bool specializeFunction(Function *F,
                           SmallVectorImpl<Function *> &Specializations) {
for (Argument &A : F->args()) {
 
         // Initialize the lattice state of the arguments of the function clone,
         // marking the argument on which we specialized the function constant
         // with the given value.
         Solver.markArgInFuncSpecialization(F, ClonedArg, C);
 
         // Mark all the specialized functions
         Specializations.push_back(Clone);
-        NumFuncSpecialized++;
+        FunctionsSpecialized++;
       }
 
       // TODO: if we want to support specialize specialized functions, and if
       // the function has been completely specialized, the original function is
       // no longer needed, so we would need to mark it unreachable here.
 
       // FIXME: Only one argument per function.
       return true;
InstructionCost getSpecializationCost(Function *F) {
 
     // If the code metrics reveal that we shouldn't duplicate the function, we
     // shouldn't specialize it. Set the specialization cost to the maximum.
     if (Metrics.notDuplicatable)
       return std::numeric_limits<unsigned>::max();
 
     // Otherwise, set the specialization cost to be the cost of all the
     // instructions in the function and penalty for specializing more functions.
-    unsigned Penalty = (NumFuncSpecialized + 1);
+    unsigned Penalty = FunctionsSpecialized + 1;
     return Metrics.NumInsts * InlineConstants::InstrCost * Penalty;
   }
 
   InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI,
                                LoopInfo &LI) {
     auto *I = dyn_cast_or_null<Instruction>(U);
     // If not an instruction we do not know how to evaluate.
     // Keep minimum possible cost for now so that it doesnt affect
bool getPossibleConstants(Argument *A,
     // Iterate over all the call sites of the argument's parent function.
     for (User *U : F->users()) {
       if (!isa<CallInst>(U) && !isa<InvokeInst>(U))
         continue;
       auto &CS = *cast<CallBase>(U);
 
       // If the parent of the call site will never be executed, we don't need
       // to worry about the passed value.
       if (!Solver.isBlockExecutable(CS.getParent()))
         continue;
 
       auto *V = CS.getArgOperand(A->getArgNo());
       // TrackValueOfGlobalVariable only tracks scalar global variables.
       if (auto *GV = dyn_cast<GlobalVariable>(V)) {
         if (!GV->getValueType()->isSingleValueType()) {
           return false;
         }
for (auto *U : F->users()) {
       if (!isa<CallInst>(U) && !isa<InvokeInst>(U))
         continue;
       auto &CS = *cast<CallBase>(U);
       if (!CS.getCalledFunction() || CS.getCalledFunction() != F)
         continue;
       CallSitesToRewrite.push_back(&CS);
     }
     for (auto *CS : CallSitesToRewrite) {
-
       if ((CS->getFunction() == Clone && CS->getArgOperand(ArgNo) == &Arg) ||
           CS->getArgOperand(ArgNo) == C) {
         CS->setCalledFunction(Clone);
         Solver.markOverdefined(CS);
       }
     }
   }
 };
while (FuncSpecializationMaxIters != I++ &&
     // to specialize recursively.
 
     CurrentSpecializations.clear();
     Changed = true;
   }
 
   // Clean up the IR by removing ssa_copy intrinsics.
   cleanup(M);
-
   return Changed;
 }

llvm/lib/Transforms/Scalar/CMakeLists.txt

 add_llvm_component_library(LLVMScalarOpts
   ADCE.cpp
   AlignmentFromAssumptions.cpp
   AnnotationRemarks.cpp
   BDCE.cpp
   CallSiteSplitting.cpp
   ConstantHoisting.cpp
   ConstraintElimination.cpp
   CorrelatedValuePropagation.cpp
   DCE.cpp
   DeadStoreElimination.cpp
   DivRemPairs.cpp
   EarlyCSE.cpp
   FlattenCFGPass.cpp
   Float2Int.cpp
-  FunctionSpecialization.cpp
   GuardWidening.cpp
   GVN.cpp
   GVNHoist.cpp
   GVNSink.cpp
   IVUsersPrinter.cpp
   InductiveRangeCheckElimination.cpp
   IndVarSimplify.cpp
   InferAddressSpaces.cpp