[TTI] Devirtualize getInstructionLatency

[samparker]

Summary

No backend implemented this and it's simple to do the implementation within TargetTransformInfo.

[spatel]

llvm/lib/Analysis/TargetTransformInfo.cpp

1164

I realize this is just copied over, but why 40?
Added with D38104.

[spatel]

Also, I see that D37170 is where the latency/throughput enhancements were made, so adding more potential reviewers. Is there an llvm-dev thread that describes what we want the cost model to end up looking like?

[RKSimon]

Is it a good idea to have getInstructionThroughput/getInstructionLatency/getUserCost being implemented through different mechanisms?

[samparker]

Thanks both.

Is it a good idea to have getInstructionThroughput/getInstructionLatency/getUserCost being implemented through different mechanisms?

I don't think so. I like the idea of using the getInstructionCost interface which then calls into the respective functions, which then calls into the concrete implementation. This means the getUserCost would disappear though, and various cost methods would take the explicit TargetCostKind argument. I think AMDGPU is the only backend with a significant getUserCost implementation.

Is there an llvm-dev thread that describes what we want the cost model to end up looking like?

I will try to get an RFC patch for what I described above and then post to the list.

[samparker]

See D79483 for first steps, abandoning this for now.

llvm/include/llvm/Analysis/TargetTransformInfo.h

   virtual unsigned getStoreVectorFactor(unsigned VF, unsigned StoreSize,
                                         unsigned ChainSizeInBytes,
                                         VectorType *VecTy) const = 0;
   virtual bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
                                      ReductionFlags) const = 0;
   virtual bool shouldExpandReduction(const IntrinsicInst *II) const = 0;
   virtual unsigned getGISelRematGlobalCost() const = 0;
   virtual bool hasActiveVectorLength() const = 0;
-  virtual int getInstructionLatency(const Instruction *I) = 0;
 };
 
 template <typename T>
 class TargetTransformInfo::Model final : public TargetTransformInfo::Concept {
   T Impl;
 
 public:
   Model(T Impl) : Impl(std::move(Impl)) {}

 
   unsigned getGISelRematGlobalCost() const override {
     return Impl.getGISelRematGlobalCost();
   }
 
   bool hasActiveVectorLength() const override {
     return Impl.hasActiveVectorLength();
   }
-
-  int getInstructionLatency(const Instruction *I) override {
-    return Impl.getInstructionLatency(I);
-  }
 };
 
 template <typename T>
 TargetTransformInfo::TargetTransformInfo(T Impl)
     : TTIImpl(new Model<T>(Impl)) {}
 
 /// Analysis pass providing the \c TargetTransformInfo.
 ///

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

     case Instruction::ZExt:
       if (I && TargetTTI->getExtCost(I, Operands.back()) == TTI::TCC_Free)
         return TTI::TCC_Free;
       break;
     }
     // By default, just classify everything as 'basic'.
     return TTI::TCC_Basic;
   }
-
-  int getInstructionLatency(const Instruction *I) {
-    SmallVector<const Value *, 4> Operands(I->value_op_begin(),
-                                           I->value_op_end());
-    if (getUserCost(I, Operands) == TTI::TCC_Free)
-      return 0;
-
-    if (isa<LoadInst>(I))
-      return 4;
-
-    Type *DstTy = I->getType();
-
-    // Usually an intrinsic is a simple instruction.
-    // A real function call is much slower.
-    if (auto *CI = dyn_cast<CallInst>(I)) {
-      const Function *F = CI->getCalledFunction();
-      if (!F || static_cast<T *>(this)->isLoweredToCall(F))
-        return 40;
-      // Some intrinsics return a value and a flag, we use the value type
-      // to decide its latency.
-      if (StructType *StructTy = dyn_cast<StructType>(DstTy))
-        DstTy = StructTy->getElementType(0);
-      // Fall through to simple instructions.
-    }
-
-    if (VectorType *VectorTy = dyn_cast<VectorType>(DstTy))
-      DstTy = VectorTy->getElementType();
-    if (DstTy->isFloatingPointTy())
-      return 3;
-
-    return 1;
-  }
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/CodeGen/BasicTTIImpl.h

public:
 
   bool preferPredicateOverEpilogue(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
                                    AssumptionCache &AC, TargetLibraryInfo *TLI,
                                    DominatorTree *DT,
                                    const LoopAccessInfo *LAI) {
     return BaseT::preferPredicateOverEpilogue(L, LI, SE, AC, TLI, DT, LAI);
   }
 
-  int getInstructionLatency(const Instruction *I) {
-    if (isa<LoadInst>(I))
-      return getST()->getSchedModel().DefaultLoadLatency;
-
-    return BaseT::getInstructionLatency(I);
-  }
-
   virtual Optional<unsigned>
   getCacheSize(TargetTransformInfo::CacheLevel Level) const {
     return Optional<unsigned>(
       getST()->getCacheSize(static_cast<unsigned>(Level)));
   }
 
   virtual Optional<unsigned>
   getCacheAssociativity(TargetTransformInfo::CacheLevel Level) const {

llvm/lib/Analysis/TargetTransformInfo.cpp

 bool TargetTransformInfo::shouldExpandReduction(const IntrinsicInst *II) const {
   return TTIImpl->shouldExpandReduction(II);
 }
 
 unsigned TargetTransformInfo::getGISelRematGlobalCost() const {
   return TTIImpl->getGISelRematGlobalCost();
 }
 
-int TargetTransformInfo::getInstructionLatency(const Instruction *I) const {
-  return TTIImpl->getInstructionLatency(I);
-}
-
 static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft,
                                      unsigned Level) {
   // We don't need a shuffle if we just want to have element 0 in position 0 of
   // the vector.
   if (!SI && Level == 0 && IsLeft)
     return true;
   else if (!SI)
     return false;

     MaskStart *= 2;
   }
 
   Opcode = RD->Opcode;
   Ty = VecTy;
   return RD->Kind;
 }
 
+int TargetTransformInfo::getInstructionLatency(const Instruction *I) const {
+  SmallVector<const Value *, 4> Operands(I->value_op_begin(),
+                                         I->value_op_end());
+  if (getUserCost(I, Operands) == TargetTransformInfo::TCC_Free)
+    return 0;
+
+  if (isa<LoadInst>(I))
+    return 4;
+
+  Type *DstTy = I->getType();
+
+  // Usually an intrinsic is a simple instruction.
+  // A real function call is much slower.
+  if (auto *CI = dyn_cast<CallInst>(I)) {
+    const Function *F = CI->getCalledFunction();
+    if (!F || TTIImpl->isLoweredToCall(F))
+      return 40;
+    // Some intrinsics return a value and a flag, we use the value type
+    // to decide its latency.
+    if (StructType *StructTy = dyn_cast<StructType>(DstTy))
+      DstTy = StructTy->getElementType(0);
+    // Fall through to simple instructions.
+  }
+
+  if (VectorType *VectorTy = dyn_cast<VectorType>(DstTy))
+    DstTy = VectorTy->getElementType();
+  if (DstTy->isFloatingPointTy())
+    return 3;
+
+  return 1;
+}
+
 int TargetTransformInfo::getInstructionThroughput(const Instruction *I) const {
   switch (I->getOpcode()) {
   case Instruction::GetElementPtr:
     return getUserCost(I);
 
   case Instruction::Ret:
   case Instruction::PHI:
   case Instruction::Br: {