[NFCI][CodeGen, AArch64] Fix inconsistent TargetCostKind types.

[dfukalov]

Summary

The pass uses different cost kinds to estimate "old" and "interleaved" costs:
default cost kind for all targets override getInterleavedMemoryOpCost() is
TCK_SizeAndLatency. Although at the moment estimated TCK_Latency costs are
equal to TCK_SizeAndLatency, (so the change is NFC) it may change in future.

[fhahn]

Looks reasonable in general, thanks!

default cost kind for all targets override getInterleavedMemoryOpCost() is TCK_SizeAndLatency

Interesting, it looks like the top-level define in TTI defaults to TTI::TCK_RecipThroughput, so should this trump the default in the target-specific defines?

https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Analysis/TargetTransformInfo.h#L1155

[RKSimon]

Do you think we should stop using default cost kinds entirely?

[samparker]

Do you think we should stop using default cost kinds entirely?

I think this would be for the best, and I thought I already changed most of the calls to be explicit.

[RKSimon]

In D110100#3014729, @samparker wrote:

Do you think we should stop using default cost kinds entirely?

I think this would be for the best, and I thought I already changed most of the calls to be explicit.

@dfukalov Is this something you'd be willing to do in this patch? At least for getInstructionCost + getInterleavedMemoryOpCost (TTI + Impl)?

[dfukalov]

In D110100#3014761, @RKSimon wrote:

In D110100#3014729, @samparker wrote:

Do you think we should stop using default cost kinds entirely?

I think this would be for the best, and I thought I already changed most of the calls to be explicit.

@dfukalov Is this something you'd be willing to do in this patch? At least for getInstructionCost + getInterleavedMemoryOpCost (TTI + Impl)?

I guess suggested changes should be in different patch, I just checked who uses pure latency cost kind our days and found this inconsistency.
Perhaps the fix may be "less invasive" with using TCK_Latency in both places, but they seems equal at the moment and I'm not sure the author meant exactly pure latency here...

[RKSimon]

LGTM with one (optional) minor

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

1133–1134

Would it make sense to add a common CostKind variable here and update all the getCost calls to use that? We already do something similar in SLP.

TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency;

[dfukalov]

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

1133–1134

Good point, thanks!

llvm/lib/CodeGen/InterleavedLoadCombinePass.cpp

bool InterleavedLoadCombineImpl::combine(std::list<VectorInfo> &InterleavedLoad,
   if (!InsertionPoint)
     return false;
 
   std::set<LoadInst *> LIs;
   std::set<Instruction *> Is;
   std::set<Instruction *> SVIs;
 
   InstructionCost InterleavedCost;
   InstructionCost InstructionCost = 0;
+  const TTI::TargetCostKind CostKind = TTI::TCK_SizeAndLatency;
 
   // Get the interleave factor
   unsigned Factor = InterleavedLoad.size();
 
   // Merge all input sets used in analysis
   for (auto &VI : InterleavedLoad) {
     // Generate a set of all load instructions to be combined
     LIs.insert(VI.LIs.begin(), VI.LIs.end());
bool InterleavedLoadCombineImpl::combine(std::list<VectorInfo> &InterleavedLoad,
   if (LIs.size() < 2)
     return false;
 
   // Test if all participating instruction will be dead after the
   // transformation. If intermediate results are used, no performance gain can
   // be expected. Also sum the cost of the Instructions beeing left dead.
   for (auto &I : Is) {
     // Compute the old cost
-    InstructionCost +=
-        TTI.getInstructionCost(I, TargetTransformInfo::TCK_Latency);
+    InstructionCost += TTI.getInstructionCost(I, CostKind);
 
     // The final SVIs are allowed not to be dead, all uses will be replaced
     if (SVIs.find(I) != SVIs.end())
       continue;
 
     // If there are users outside the set to be eliminated, we abort the
     // transformation. No gain can be expected.
     for (auto *U : I->users()) {
unsigned ElementsPerSVI =
           ->getNumElements();
   FixedVectorType *ILTy = FixedVectorType::get(ETy, Factor * ElementsPerSVI);
 
   SmallVector<unsigned, 4> Indices;
   for (unsigned i = 0; i < Factor; i++)
     Indices.push_back(i);
   InterleavedCost = TTI.getInterleavedMemoryOpCost(
       Instruction::Load, ILTy, Factor, Indices, InsertionPoint->getAlign(),
-      InsertionPoint->getPointerAddressSpace());
+      InsertionPoint->getPointerAddressSpace(), CostKind);
 
   if (InterleavedCost >= InstructionCost) {
     return false;
   }
 
   // Create a pointer cast for the wide load.
   auto CI = Builder.CreatePointerCast(InsertionPoint->getOperand(0),
                                       ILTy->getPointerTo(),