[llvm] r293155 - [TargetTransformInfo] Refactor and improve getScalarizationOverhead()
Craig Topper via llvm-commits
llvm-commits at lists.llvm.org
Wed Jan 25 23:36:25 PST 2017
I believe this is throwing several warnings for missing override keyword
*llvm/include/llvm/Analysis/TargetTransformInfo.h:945:12: **error:
**'getScalarizationOverhead'
overrides a member function but is not marked 'override'
[-Werror,-Winconsistent-missing-override]*
unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
~Craig
On Wed, Jan 25, 2017 at 11:03 PM, Jonas Paulsson via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
> Author: jonpa
> Date: Thu Jan 26 01:03:25 2017
> New Revision: 293155
>
> URL: http://llvm.org/viewvc/llvm-project?rev=293155&view=rev
> Log:
> [TargetTransformInfo] Refactor and improve getScalarizationOverhead()
>
> Refactoring to remove duplications of this method.
>
> New method getOperandsScalarizationOverhead() that looks at the present
> unique
> operands and add extract costs for them. Old behaviour was to just add
> extract
> costs for one operand of the type always, which still happens in
> getArithmeticInstrCost() if no operands are provided by the caller.
>
> This is a good start of improving on this, but there are more places
> that can be improved by using getOperandsScalarizationOverhead().
>
> Review: Hal Finkel
> https://reviews.llvm.org/D29017
>
> Modified:
> llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h
> llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h
> llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h
> llvm/trunk/lib/Analysis/TargetTransformInfo.cpp
> llvm/trunk/lib/Target/AArch64/AArch64TargetTransformInfo.h
> llvm/trunk/lib/Target/ARM/ARMTargetTransformInfo.h
> llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp
> llvm/trunk/lib/Target/X86/X86TargetTransformInfo.h
> llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
>
> Modified: llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/
> TargetTransformInfo.h?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h (original)
> +++ llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h Thu Jan 26
> 01:03:25 2017
> @@ -411,6 +411,11 @@ public:
> /// containing this constant value for the target.
> bool shouldBuildLookupTablesForConstant(Constant *C) const;
>
> + unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract)
> const;
> +
> + unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
> + unsigned VF) const;
> +
> /// \brief Don't restrict interleaved unrolling to small loops.
> bool enableAggressiveInterleaving(bool LoopHasReductions) const;
>
> @@ -743,6 +748,10 @@ public:
> virtual unsigned getJumpBufSize() = 0;
> virtual bool shouldBuildLookupTables() = 0;
> virtual bool shouldBuildLookupTablesForConstant(Constant *C) = 0;
> + virtual unsigned
> + getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) = 0;
> + virtual unsigned getOperandsScalarizationOverhead(ArrayRef<const Value
> *> Args,
> + unsigned VF) = 0;
> virtual bool enableAggressiveInterleaving(bool LoopHasReductions) = 0;
> virtual bool enableInterleavedAccessVectorization() = 0;
> virtual bool isFPVectorizationPotentiallyUnsafe() = 0;
> @@ -933,6 +942,14 @@ public:
> bool shouldBuildLookupTablesForConstant(Constant *C) override {
> return Impl.shouldBuildLookupTablesForConstant(C);
> }
> + unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
> + return Impl.getScalarizationOverhead(Ty, Insert, Extract);
> + }
> + unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
> + unsigned VF) {
> + return Impl.getOperandsScalarizationOverhead(Args, VF);
> + }
> +
> bool enableAggressiveInterleaving(bool LoopHasReductions) override {
> return Impl.enableAggressiveInterleaving(LoopHasReductions);
> }
>
> Modified: llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/
> TargetTransformInfoImpl.h?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h (original)
> +++ llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h Thu Jan 26
> 01:03:25 2017
> @@ -251,6 +251,13 @@ public:
> bool shouldBuildLookupTables() { return true; }
> bool shouldBuildLookupTablesForConstant(Constant *C) { return true; }
>
> + unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
> + return 0;
> + }
> +
> + unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
> + unsigned VF) { return 0; }
> +
> bool enableAggressiveInterleaving(bool LoopHasReductions) { return
> false; }
>
> bool enableInterleavedAccessVectorization() { return false; }
>
> Modified: llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/
> llvm/CodeGen/BasicTTIImpl.h?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h (original)
> +++ llvm/trunk/include/llvm/CodeGen/BasicTTIImpl.h Thu Jan 26 01:03:25
> 2017
> @@ -42,24 +42,6 @@ private:
> typedef TargetTransformInfoImplCRTPBase<T> BaseT;
> typedef TargetTransformInfo TTI;
>
> - /// Estimate the overhead of scalarizing an instruction. Insert and
> Extract
> - /// are set if the result needs to be inserted and/or extracted from
> vectors.
> - unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
> - assert(Ty->isVectorTy() && "Can only scalarize vectors");
> - unsigned Cost = 0;
> -
> - for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
> - if (Insert)
> - Cost += static_cast<T *>(this)
> - ->getVectorInstrCost(Instruction::InsertElement, Ty,
> i);
> - if (Extract)
> - Cost += static_cast<T *>(this)
> - ->getVectorInstrCost(Instruction::ExtractElement,
> Ty, i);
> - }
> -
> - return Cost;
> - }
> -
> /// Estimate a cost of shuffle as a sequence of extract and insert
> /// operations.
> unsigned getPermuteShuffleOverhead(Type *Ty) {
> @@ -301,6 +283,37 @@ public:
>
> unsigned getRegisterBitWidth(bool Vector) { return 32; }
>
> + /// Estimate the overhead of scalarizing an instruction. Insert and
> Extract
> + /// are set if the result needs to be inserted and/or extracted from
> vectors.
> + unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
> + assert(Ty->isVectorTy() && "Can only scalarize vectors");
> + unsigned Cost = 0;
> +
> + for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
> + if (Insert)
> + Cost += static_cast<T *>(this)
> + ->getVectorInstrCost(Instruction::InsertElement, Ty,
> i);
> + if (Extract)
> + Cost += static_cast<T *>(this)
> + ->getVectorInstrCost(Instruction::ExtractElement,
> Ty, i);
> + }
> +
> + return Cost;
> + }
> +
> + /// Estimate the overhead of scalarizing an instructions unique
> operands.
> + unsigned getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
> + unsigned VF) {
> + unsigned Cost = 0;
> + SmallPtrSet<const Value*, 4> UniqueOperands;
> + for (const Value *A : Args) {
> + if (UniqueOperands.insert(A).second)
> + Cost += getScalarizationOverhead(VectorType::get(A->getType(),
> VF),
> + false, true);
> + }
> + return Cost;
> + }
> +
> unsigned getMaxInterleaveFactor(unsigned VF) { return 1; }
>
> unsigned getArithmeticInstrCost(
> @@ -341,10 +354,17 @@ public:
> unsigned Num = Ty->getVectorNumElements();
> unsigned Cost = static_cast<T *>(this)
> ->getArithmeticInstrCost(Opcode,
> Ty->getScalarType());
> - // return the cost of multiple scalar invocation plus the cost of
> - // inserting
> - // and extracting the values.
> - return getScalarizationOverhead(Ty, true, true) + Num * Cost;
> + // Return the cost of multiple scalar invocation plus the cost of
> + // inserting and extracting the values.
> + unsigned TotCost = getScalarizationOverhead(Ty, true, false) + Num
> * Cost;
> + if (!Args.empty())
> + TotCost += getOperandsScalarizationOverhead(Args, Num);
> + else
> + // When no information on arguments is provided, we add the cost
> + // associated with one argument as a heuristic.
> + TotCost += getScalarizationOverhead(Ty, false, true);
> +
> + return TotCost;
> }
>
> // We don't know anything about this scalar instruction.
>
> Modified: llvm/trunk/lib/Analysis/TargetTransformInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/
> Analysis/TargetTransformInfo.cpp?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Analysis/TargetTransformInfo.cpp (original)
> +++ llvm/trunk/lib/Analysis/TargetTransformInfo.cpp Thu Jan 26 01:03:25
> 2017
> @@ -182,6 +182,17 @@ bool TargetTransformInfo::shouldBuildLoo
> return TTIImpl->shouldBuildLookupTablesForConstant(C);
> }
>
> +unsigned TargetTransformInfo::
> +getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) const {
> + return TTIImpl->getScalarizationOverhead(Ty, Insert, Extract);
> +}
> +
> +unsigned TargetTransformInfo::
> +getOperandsScalarizationOverhead(ArrayRef<const Value *> Args,
> + unsigned VF) const {
> + return TTIImpl->getOperandsScalarizationOverhead(Args, VF);
> +}
> +
> bool TargetTransformInfo::enableAggressiveInterleaving(bool
> LoopHasReductions) const {
> return TTIImpl->enableAggressiveInterleaving(LoopHasReductions);
> }
>
> Modified: llvm/trunk/lib/Target/AArch64/AArch64TargetTransformInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/AArch64/
> AArch64TargetTransformInfo.h?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Target/AArch64/AArch64TargetTransformInfo.h (original)
> +++ llvm/trunk/lib/Target/AArch64/AArch64TargetTransformInfo.h Thu Jan 26
> 01:03:25 2017
> @@ -34,10 +34,6 @@ class AArch64TTIImpl : public BasicTTIIm
> const AArch64Subtarget *ST;
> const AArch64TargetLowering *TLI;
>
> - /// Estimate the overhead of scalarizing an instruction. Insert and
> Extract
> - /// are set if the result needs to be inserted and/or extracted from
> vectors.
> - unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract);
> -
> const AArch64Subtarget *getST() const { return ST; }
> const AArch64TargetLowering *getTLI() const { return TLI; }
>
>
> Modified: llvm/trunk/lib/Target/ARM/ARMTargetTransformInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/
> ARM/ARMTargetTransformInfo.h?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Target/ARM/ARMTargetTransformInfo.h (original)
> +++ llvm/trunk/lib/Target/ARM/ARMTargetTransformInfo.h Thu Jan 26
> 01:03:25 2017
> @@ -33,10 +33,6 @@ class ARMTTIImpl : public BasicTTIImplBa
> const ARMSubtarget *ST;
> const ARMTargetLowering *TLI;
>
> - /// Estimate the overhead of scalarizing an instruction. Insert and
> Extract
> - /// are set if the result needs to be inserted and/or extracted from
> vectors.
> - unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract);
> -
> const ARMSubtarget *getST() const { return ST; }
> const ARMTargetLowering *getTLI() const { return TLI; }
>
>
> Modified: llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/
> X86/X86TargetTransformInfo.cpp?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp (original)
> +++ llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp Thu Jan 26
> 01:03:25 2017
> @@ -1577,20 +1577,6 @@ int X86TTIImpl::getVectorInstrCost(unsig
> return BaseT::getVectorInstrCost(Opcode, Val, Index) +
> RegisterFileMoveCost;
> }
>
> -int X86TTIImpl::getScalarizationOverhead(Type *Ty, bool Insert, bool
> Extract) {
> - assert (Ty->isVectorTy() && "Can only scalarize vectors");
> - int Cost = 0;
> -
> - for (int i = 0, e = Ty->getVectorNumElements(); i < e; ++i) {
> - if (Insert)
> - Cost += getVectorInstrCost(Instruction::InsertElement, Ty, i);
> - if (Extract)
> - Cost += getVectorInstrCost(Instruction::ExtractElement, Ty, i);
> - }
> -
> - return Cost;
> -}
> -
> int X86TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src, unsigned
> Alignment,
> unsigned AddressSpace) {
> // Handle non-power-of-two vectors such as <3 x float>
>
> Modified: llvm/trunk/lib/Target/X86/X86TargetTransformInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/
> X86/X86TargetTransformInfo.h?rev=293155&r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Target/X86/X86TargetTransformInfo.h (original)
> +++ llvm/trunk/lib/Target/X86/X86TargetTransformInfo.h Thu Jan 26
> 01:03:25 2017
> @@ -33,8 +33,6 @@ class X86TTIImpl : public BasicTTIImplBa
> const X86Subtarget *ST;
> const X86TargetLowering *TLI;
>
> - int getScalarizationOverhead(Type *Ty, bool Insert, bool Extract);
> -
> const X86Subtarget *getST() const { return ST; }
> const X86TargetLowering *getTLI() const { return TLI; }
>
>
> Modified: llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/
> Transforms/Vectorize/LoopVectorize.cpp?rev=293155&
> r1=293154&r2=293155&view=diff
> ============================================================
> ==================
> --- llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp (original)
> +++ llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp Thu Jan 26
> 01:03:25 2017
> @@ -3598,37 +3598,18 @@ static Value *addFastMathFlag(Value *V)
> return V;
> }
>
> -/// \brief Estimate the overhead of scalarizing a value based on its type.
> -/// Insert and Extract are set if the result needs to be inserted and/or
> -/// extracted from vectors.
> -static unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool
> Extract,
> - const TargetTransformInfo &TTI) {
> - if (Ty->isVoidTy())
> - return 0;
> -
> - assert(Ty->isVectorTy() && "Can only scalarize vectors");
> - unsigned Cost = 0;
> -
> - for (unsigned I = 0, E = Ty->getVectorNumElements(); I < E; ++I) {
> - if (Extract)
> - Cost += TTI.getVectorInstrCost(Instruction::ExtractElement, Ty, I);
> - if (Insert)
> - Cost += TTI.getVectorInstrCost(Instruction::InsertElement, Ty, I);
> - }
> -
> - return Cost;
> -}
> -
> /// \brief Estimate the overhead of scalarizing an Instruction based on
> the
> /// types of its operands and return value.
> static unsigned getScalarizationOverhead(SmallVectorImpl<Type *> &OpTys,
> Type *RetTy,
> const TargetTransformInfo &TTI) {
> - unsigned ScalarizationCost =
> - getScalarizationOverhead(RetTy, true, false, TTI);
> + unsigned ScalarizationCost = 0;
> +
> + if (!RetTy->isVoidTy())
> + ScalarizationCost += TTI.getScalarizationOverhead(RetTy, true,
> false);
>
> for (Type *Ty : OpTys)
> - ScalarizationCost += getScalarizationOverhead(Ty, false, true, TTI);
> + ScalarizationCost += TTI.getScalarizationOverhead(Ty, false, true);
>
> return ScalarizationCost;
> }
> @@ -3640,14 +3621,15 @@ static unsigned getScalarizationOverhead
> if (VF == 1)
> return 0;
>
> + unsigned Cost = 0;
> Type *RetTy = ToVectorTy(I->getType(), VF);
> + if (!RetTy->isVoidTy())
> + Cost += TTI.getScalarizationOverhead(RetTy, true, false);
>
> - SmallVector<Type *, 4> OpTys;
> - unsigned OperandsNum = I->getNumOperands();
> - for (unsigned OpInd = 0; OpInd < OperandsNum; ++OpInd)
> - OpTys.push_back(ToVectorTy(I->getOperand(OpInd)->getType(), VF));
> + SmallVector<const Value *, 4> Operands(I->operand_values());
> + Cost += TTI.getOperandsScalarizationOverhead(Operands, VF);
>
> - return getScalarizationOverhead(OpTys, RetTy, TTI);
> + return Cost;
> }
>
> // Estimate cost of a call instruction CI if it were vectorized with
> factor VF.
> @@ -6713,8 +6695,8 @@ int LoopVectorizationCostModel::computeP
> // Compute the scalarization overhead of needed insertelement
> instructions
> // and phi nodes.
> if (Legal->isScalarWithPredication(I) && !I->getType()->isVoidTy()) {
> - ScalarCost += getScalarizationOverhead(ToVectorTy(I->getType(),
> VF), true,
> - false, TTI);
> + ScalarCost += TTI.getScalarizationOverhead(ToVectorTy(I->getType(),
> VF),
> + true, false);
> ScalarCost += VF * TTI.getCFInstrCost(Instruction::PHI);
> }
>
> @@ -6729,8 +6711,8 @@ int LoopVectorizationCostModel::computeP
> if (canBeScalarized(J))
> Worklist.push_back(J);
> else if (needsExtract(J))
> - ScalarCost += getScalarizationOverhead(ToVectorTy(J->getType(),
> VF),
> - false, true, TTI);
> + ScalarCost += TTI.getScalarizationOverhead(
> + ToVectorTy(J->getType(),VF), false, true);
> }
>
> // Scale the total scalar cost by block probability.
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20170125/1ca76275/attachment.html>
More information about the llvm-commits
mailing list