[llvm] [VPlan] First step towards VPlan cost modeling (LegacyCM in CostCtx) (PR #92555)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Thu May 23 14:30:14 PDT 2024
================
@@ -7396,6 +7397,118 @@ LoopVectorizationPlanner::plan(ElementCount UserVF, unsigned UserIC) {
return VF;
}
+InstructionCost VPCostContext::getLegacyCost(Instruction *UI, ElementCount VF) {
+ return CM.getInstructionCost(UI, VF).first;
+}
+
+bool VPCostContext::skipForCostComputation(Instruction *UI) const {
+ return CM.VecValuesToIgnore.contains(UI) || SkipCostComputation.contains(UI);
+}
+
+InstructionCost LoopVectorizationPlanner::computeCost(VPlan &Plan,
+ ElementCount VF) const {
+ InstructionCost Cost = 0;
+ LLVMContext &Ctx = OrigLoop->getHeader()->getContext();
+ VPCostContext CostCtx(CM.TTI, Legal->getWidestInductionType(), Ctx, CM);
+
+ // Cost modeling for inductions is inaccurate in the legacy cost model
+ // compared to the recipes that are generated. To match here initially during
+ // VPlan cost model bring up directly use the induction costs from the legacy
+ // cost model and skip induction recipes. Note that we do this as
+ // pre-processing; the VPlan may not have any recipes associated with the
+ // original induction increment instruction.
+ // TODO: Switch to more accurate costing based on VPlan.
+ for (const auto &[IV, _] : Legal->getInductionVars()) {
+ Instruction *IVInc = cast<Instruction>(
+ IV->getIncomingValueForBlock(OrigLoop->getLoopLatch()));
+ InstructionCost InductionCost = CM.getInstructionCost(IVInc, VF).first;
+ LLVM_DEBUG({
+ dbgs() << "Cost of " << InductionCost << " for VF " << VF
+ << ":\n induction increment " << *IVInc << "\n";
+ IVInc->dump();
+ });
+ Cost += InductionCost;
+ CostCtx.SkipCostComputation.insert(IVInc);
+ }
+
+ // The legacy cost model has special logic to compute the cost of in-loop
+ // reductions, which may be smaller than the sum of all instructions involved
+ // in the reduction. Pre-compute the cost for now.
+ // TODO: Switch to costing based on VPlan once the logic has been ported.
+ for (const auto &[RedPhi, RdxDesc] : Legal->getReductionVars()) {
+ if (!CM.isInLoopReduction(RedPhi))
+ continue;
+
+ SmallVector<Instruction *, 4> ReductionOperations =
+ RdxDesc.getReductionOpChain(RedPhi, OrigLoop);
+ // Also include the operands of instructions in the chain, as the cost-model
+ // may mark extends as free.
+ for (unsigned I = 0, E = ReductionOperations.size(); I != E; ++I) {
+ for (Value *Op : ReductionOperations[I]->operands()) {
+ if (auto *I = dyn_cast<Instruction>(Op))
+ ReductionOperations.push_back(I);
+ }
+ }
+ for (Instruction *I : ReductionOperations) {
+ auto ReductionCost = CM.getReductionPatternCost(
+ I, VF, ToVectorTy(I->getType(), VF), TTI::TCK_RecipThroughput);
+ if (!ReductionCost)
+ continue;
+
+ if (!CostCtx.SkipCostComputation.insert(I).second)
+ continue;
----------------
fhahn wrote:
We need to first check if we have a reduction pattern cost before inserting into the set, as otherwise we may insert instructions without a reduction pattern cost.
https://github.com/llvm/llvm-project/pull/92555
More information about the llvm-commits
mailing list