[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

468

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

do we need to run those unrelated passes?

[SjoerdMeijer]

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

3

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

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

468

Added a test for that in rG29843cbc88f6.

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

3

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/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 += NbFunctionsSpecialized;
     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:
+  // The number of functions specialised, used for collecting statistics and
+  // also in the cost model.
+  unsigned NbFunctionsSpecialized = 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++;
+        NbFunctionsSpecialized++;
       }
 
       // 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 = NbFunctionsSpecialized + 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;
         }
while (FuncSpecializationMaxIters != I++ &&
     // to specialize recursively.
 
     CurrentSpecializations.clear();
     Changed = true;
   }
 
   // Clean up the IR by removing ssa_copy intrinsics.
   cleanup(M);
-
   return Changed;
 }

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

+; REQUIRES: asserts
+
+; RUN: opt -stats -function-specialization -deadargelim -inline -S < %s 2>&1 | FileCheck %s
+
+; CHECK: 2 deadargelim             - Number of unread args removed
+; CHECK: 1 deadargelim             - Number of unused return values removed
+; CHECK: 2 function-specialization - Number of Functions Specialized
+; CHECK: 4 inline                  - Number of functions deleted because all callers found
+; CHECK: 4 inline                  - Number of functions inlined
+; CHECK: 6 inline-cost             - Number of call sites analyzed
+
+define i64 @main(i64 %x, i1 %flag) {
+entry:
+  br i1 %flag, label %plus, label %minus
+
+plus:
+  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus)
+  br label %merge
+
+minus:
+  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus)
+  br label %merge
+
+merge:
+  %tmp2 = phi i64 [ %tmp0, %plus ], [ %tmp1, %minus]
+  ret i64 %tmp2
+}
+
+define internal i64 @compute(i64 %x, i64 (i64)* %binop) {
+entry:
+  %tmp0 = call i64 %binop(i64 %x)
+  ret i64 %tmp0
+}
+
+define internal i64 @plus(i64 %x) {
+entry:
+  %tmp0 = add i64 %x, 1
+  ret i64 %tmp0
+}
+
+define internal i64 @minus(i64 %x) {
+entry:
+  %tmp0 = sub i64 %x, 1
+  ret i64 %tmp0
+}