[FuncSpec] Do not overestimate the specialization bonus for users inside loops.

[labrinea]

Summary

When calculating the specialization bonus for a given function argument, we recursively traverse the chain of (certain) users, accumulating the instruction costs. Then we exponentially increase the bonus to account for loop nests. This is problematic for two reasons: (a) the users might not themselves be inside the loop nest, (b) if they are we are accounting for it multiple times. Instead we should be adjusting the bonus before traversing the user chain.

This reduces the instruction count for CTMark (newPM-O3) when Function Specialization is enabled without actually reducing the amount of specializations performed.

testname	delta % non-LTO	delta % LTO
ClamAV	-0.005	0.039
7zip	0.012	-0.007
tramp3d-v4	-0.013	-0.011
kimwitu++	-0.011	0.146
sqlite3	0.04	-0.445
mafft	0.006	0.011
lencod	-0.02	-0.023
SPASS	-0.006	-1.06
consumer-typeset	0.005	-2.644
Bullet	-0.015	-0.029
geomean	-0.001	-0.406

[ChuanqiXu]

The reason makes sense and the data is overwhelming. LGTM!

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI,
     // Keep minimum possible cost for now so that it doesnt affect
     // specialization.
     if (!I)
       return std::numeric_limits<unsigned>::min();
 
     InstructionCost Cost =
         TTI.getInstructionCost(U, TargetTransformInfo::TCK_SizeAndLatency);
 
+    // Increase the cost if it is inside the loop.
+    unsigned LoopDepth = LI.getLoopDepth(I->getParent());
+    Cost *= std::pow((double)AvgLoopIterationCount, LoopDepth);
+
     // Traverse recursively if there are more uses.
     // TODO: Any other instructions to be added here?
     if (I->mayReadFromMemory() || I->isCast())
       for (auto *User : I->users())
         Cost += getUserBonus(User, TTI, LI);
 
-    // Increase the cost if it is inside the loop.
-    auto LoopDepth = LI.getLoopDepth(I->getParent());
-    Cost *= std::pow((double)AvgLoopIterationCount, LoopDepth);
     return Cost;
   }
 
   /// Compute a bonus for replacing argument \p A with constant \p C.
   InstructionCost getSpecializationBonus(Argument *A, Constant *C) {
     Function *F = A->getParent();
     DominatorTree DT(*F);
     LoopInfo LI(DT);

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

-; RUN: opt -function-specialization -func-specialization-avg-iters-cost=3 -func-specialization-size-threshold=10 -S < %s | FileCheck %s
+; RUN: opt -function-specialization -func-specialization-avg-iters-cost=5 -func-specialization-size-threshold=10 -S < %s | FileCheck %s
 
 ; Check that the loop depth results in a larger specialization bonus.
 ; CHECK: @foo.1(
 ; CHECK: @foo.2(
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 @A = external dso_local constant i32, align 4

 
 if.else:
   %call1 = call i32 @foo(i32 %y, i32* @B, i32* @D)
   br label %return
 
 return:
   %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.else ]
   ret i32 %retval.0
-}
+}