| /external/llvm/include/llvm/Analysis/ |
| InlineCost.h | 1 //===- InlineCost.h - Cost analysis for inliner -----------------*- C++ -*-===//
40 /// \brief Represents the cost of inlining a function.
43 /// "never" be inlined. Otherwise, the cost represents a unitless amount;
48 /// directly tested to determine if inlining should occur given the cost and
49 /// threshold for this cost metric.
56 /// \brief The estimated cost of inlining this callsite.
57 const int Cost;
59 /// \brief The adjusted threshold against which this cost was computed.
63 InlineCost(int Cost, int Threshold) : Cost(Cost), Threshold(Threshold) {
[all...] |
| /external/llvm/utils/PerfectShuffle/ |
| PerfectShuffle.cpp | 88 unsigned Cost; // Number of instrs used to generate this value.
92 ShuffleVal() : Cost(1000000) {}
108 unsigned Cost;
111 unsigned cost = 1)
112 : ShuffleMask(shufflemask), OpNum(opnum), Name(name), Cost(cost) {
125 unsigned getCost() const { return Cost; }
153 assert(0 && "bad zero cost operation");
164 if (ShufTab[ShufTab[ThisOp].Arg0].Cost == 0) {
178 if (ShufTab[ShufTab[ThisOp].Arg1].Cost == 0)
[all...] |
| /external/llvm/utils/TableGen/ |
| DAGISelEmitter.cpp | 43 unsigned Cost = 0;
46 Cost++;
49 Cost += 10;
52 Cost += getResultPatternCost(P->getChild(i), CGP);
53 return Cost;
62 unsigned Cost = 0;
65 Cost += Op->getValueAsInt("CodeSize");
68 Cost += getResultPatternSize(P->getChild(i), CGP);
69 return Cost;
74 // In particular, we want to match maximal patterns first and lowest cost withi
[all...] |
| /external/eigen/Eigen/src/Core/ |
| Functors.h | 37 Cost = NumTraits<Scalar>::AddCost,
65 Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate!
94 Cost = NumTraits<LhsScalar>::MulCost,
117 Cost = NumTraits<Scalar>::AddCost,
140 Cost = NumTraits<Scalar>::AddCost,
165 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 };
177 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
197 Cost = NumTraits<Scalar>::AddCost,
217 Cost = 2 * NumTraits<Scalar>::MulCost,
233 Cost = NumTraits<bool>::AddCost
[all...] |
| Random.h | 25 { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; };
|
| Visitor.h | 81 && (SizeAtCompileTime == 1 || internal::functor_traits<Visitor>::Cost != Dynamic)
82 && SizeAtCompileTime * CoeffReadCost + (SizeAtCompileTime-1) * internal::functor_traits<Visitor>::Cost
133 Cost = NumTraits<Scalar>::AddCost
161 Cost = NumTraits<Scalar>::AddCost
|
| Redux.h | 53 Cost = ( Derived::SizeAtCompileTime == Dynamic
55 || (Derived::SizeAtCompileTime!=1 && functor_traits<Func>::Cost == Dynamic)
58 + (Derived::SizeAtCompileTime-1) * functor_traits<Func>::Cost,
64 Unrolling = Cost != Dynamic && Cost <= UnrollingLimit
|
| VectorwiseOp.h | 56 typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
58 typedef typename MemberOp::template Cost<InputScalar,TraversalSize> CostOpType;
104 #define EIGEN_MEMBER_FUNCTOR(MEMBER,COST) \
109 template<typename Scalar, int Size> struct Cost \
110 { enum { value = COST }; }; \
122 EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost );
138 template<typename _Scalar, int Size> struct Cost
139 { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; };
|
| CwiseUnaryOp.h | 50 CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits<UnaryOp>::Cost
|
| CwiseUnaryView.h | 41 CoeffReadCost = traits<_MatrixTypeNested>::CoeffReadCost + functor_traits<ViewOp>::Cost,
|
| /external/llvm/include/llvm/Target/ |
| CostTable.h | 1 //===-- CostTable.h - Instruction Cost Table handling -----------*- C++ -*-===//
11 /// \brief Cost tables and simple lookup functions
20 /// Cost Table Entry
25 unsigned Cost;
28 /// Find in cost table, TypeTy must be comparable by ==
40 /// Type Conversion Cost Table
46 unsigned Cost;
49 /// Find in type conversion cost table, TypeTy must be comparable by ==
|
| /external/llvm/lib/CodeGen/ |
| RegisterClassInfo.cpp | 101 unsigned Cost = TRI->getCostPerUse(PhysReg);
102 MinCost = std::min(MinCost, Cost);
108 if (Cost != LastCost)
111 LastCost = Cost;
120 unsigned Cost = TRI->getCostPerUse(PhysReg);
121 if (Cost != LastCost)
124 LastCost = Cost;
|
| BasicTargetTransformInfo.cpp | 194 unsigned Cost = 0;
198 Cost += TopTTI->getVectorInstrCost(Instruction::InsertElement, Ty, i);
200 Cost += TopTTI->getVectorInstrCost(Instruction::ExtractElement, Ty, i);
203 return Cost;
229 // Assume that floating point arithmetic operations cost twice as much as
237 // TODO: Once we have extract/insert subvector cost we need to use them.
252 unsigned Cost = TopTTI->getArithmeticInstrCost(Opcode, Ty->getScalarType());
253 // return the cost of multiple scalar invocation plus the cost of inserting
255 return getScalarizationOverhead(Ty, true, true) + Num * Cost;
[all...] |
| RegAllocGreedy.cpp | 156 /// Cost of evicting interference.
482 unsigned Cost = TRI->getCostPerUse(PhysReg);
484 // Most registers have 0 additional cost.
485 if (!Cost)
488 DEBUG(dbgs() << PrintReg(PhysReg, TRI) << " is available at cost " << Cost
490 unsigned CheapReg = tryEvict(VirtReg, Order, NewVRegs, Cost);
555 /// @param MaxCost Only look for cheaper candidates and update with new cost
577 EvictionCost Cost;
609 Cost.BrokenHints += 10
[all...] |
| MachineLICM.cpp | 206 /// check if hoisting an instruction of the given cost matrix can cause high
208 bool CanCauseHighRegPressure(DenseMap<unsigned, int> &Cost, bool Cheap);
244 /// index, return the ID and cost of its representative register class by
777 /// index, return the ID and cost of its representative register class.
[all...] |
| RegAllocFast.cpp | 435 // calcSpillCost - Return the cost of spilling clearing out PhysReg and
461 // This is a disabled register, add up cost of aliases.
463 unsigned Cost = 0;
470 ++Cost;
477 Cost += I->Dirty ? spillDirty : spillClean;
482 return Cost;
525 unsigned Cost = calcSpillCost(Hint);
526 if (Cost < spillDirty) {
527 if (Cost)
551 unsigned Cost = calcSpillCost(*I)
[all...] |
| /external/llvm/lib/Target/X86/ |
| X86TargetTransformInfo.cpp | 122 // X86 cost model.
217 return LT.first * AVX2CostTable[Idx].Cost;
245 return LT.first * SSE2UniformConstCostTable[Idx].Cost;
255 // to ISel. The cost model must return worst case assumptions because it is
293 return LT.first * SSE2CostTable[Idx].Cost;
308 // split factor of two in the cost table. Therefore, the cost here is 18
318 return LT.first * AVX1CostTable[Idx].Cost;
331 return LT.first * CustomLowered[Idx].Cost;
346 // We only estimate the cost of reverse shuffles
[all...] |
| /frameworks/av/media/libstagefright/codecs/on2/h264dec/omxdl/reference/vc/m4p10/src/ |
| omxVCM4P10_MotionEstimationMB.c | 453 * Intra 4x4 Mode decision by calculating cost for all possible modes and
471 * [in] pBestCost - Cost for the Best Intra 4x4 mode
489 OMX_S32 Cost, BestCost;
531 Cost = BestCost = ARM_VCM4P10_MAX_COST;
533 /* Go through each mode for minim cost */
553 &Cost,
557 if (Cost < BestCost)
559 BestCost = Cost;
761 * [in] nLamda - For calculating the cost
762 * [out] pBestCost - Minimum cost for encoding current block
[all...] |
| /external/llvm/lib/Target/PowerPC/ |
| PPCTargetTransformInfo.cpp | 121 // PPC cost model.
204 // Estimated cost of a load-hit-store delay. This was obtained
230 unsigned Cost = LT.first * 1;
236 Cost *= (SrcBytes/Alignment);
238 return Cost;
|
| /external/llvm/lib/Analysis/IPA/ |
| InlineCost.cpp | 1 //===- InlineCost.cpp - Cost analysis for inliner -------------------------===//
10 // This file implements inline cost analysis.
14 #define DEBUG_TYPE "inline-cost"
55 int Cost;
75 // can cause dramatic shifts in the cost of inlining a function.
82 // The mapping of caller Alloca values to their accumulated cost savings. If
84 // cost must be added.
139 : TD(TD), TTI(TTI), F(Callee), Threshold(Threshold), Cost(0),
152 int getCost() { return Cost; }
154 // Keep a bunch of stats about the cost savings found so we can print the
[all...] |
| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.cpp | 478 DiffEntry() : Cost(0) {}
480 unsigned Cost;
510 Cur[I].Cost = I * LeftCost;
518 Next[0].Cost += RightCost;
525 Next[Index].Cost += MatchCost;
528 } else if (Next[Index-1].Cost <= Cur[Index].Cost) {
530 Next[Index].Cost += LeftCost;
534 Next[Index].Cost += RightCost;
|
| /external/llvm/lib/Analysis/ |
| CostModel.cpp | 1 //===- CostModel.cpp ------ Cost Model Analysis ---------------------------===//
10 // This file defines the cost model analysis. It provides a very basic cost
12 // to approximate the cost of any IR instruction when lowered to machine
13 // instructions. The cost results are unit-less and the cost number represents
15 // branches are predicted, etc. The cost numbers can be added in order to
20 #define CM_NAME "cost-model"
43 /// Returns the expected cost of the instruction.
44 /// Returns -1 if the cost is unknown
[all...] |
| /external/llvm/lib/Target/ARM/ |
| ARMTargetTransformInfo.cpp | 198 return LT.first * NEONFltDblTbl[Idx].Cost;
208 // to cast up/down their types automatically at no extra cost.
290 return NEONVectorConversionTbl[Idx].Cost;
322 return NEONFloatConversionTbl[Idx].Cost;
355 return NEONIntegerConversionTbl[Idx].Cost;
377 return ARMIntegerConversionTbl[Idx].Cost;
420 return NEONVectorSelectTbl[Idx].Cost;
452 // Reverse shuffle cost one instruction if we are shuffling within a double
472 return LT.first * NEONShuffleTbl[Idx].Cost;
485 // These costs are somewhat random. Choose a cost of 20 to indicate tha
[all...] |
| /external/llvm/lib/Transforms/Vectorize/ |
| LoopVectorize.cpp | 635 /// TargetTransformInfo to query the different backends for the cost of
647 unsigned Width; // Vector width with best cost
648 unsigned Cost; // Cost of the loop with that width
650 /// \return The most profitable vectorization factor and the cost of that VF.
665 /// VF and LoopCost are the selected vectorization factor and the cost of the
685 /// Returns the expected execution cost. The unit of the cost does
686 /// not matter because we use the 'cost' units to compare different
687 /// vector widths. The cost that is returned is *not* normalized b
[all...] |
| SLPVectorizer.cpp | 243 /// \returns the vectorization cost of the subtree that starts at \p VL.
267 /// \returns the cost of the vectorizable entry.
291 /// \returns the scalarization cost for this type. Scalarization in this
295 /// \returns the scalarization cost for this list of values. Assuming that
297 /// roots. This method calculates the cost of extracting the values.
838 // Calculate the cost of this instruction.
867 // Calculate the cost of this instruction.
884 // Cost of wide load - cost of scalar loads.
891 // We know that we can merge the stores. Calculate the cost
[all...] |
