| /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 | 45 unsigned Cost = 0;
48 Cost++;
51 Cost += 10;
54 Cost += getResultPatternCost(P->getChild(i), CGP);
55 return Cost;
64 unsigned Cost = 0;
67 Cost += Op->getValueAsInt("CodeSize");
70 Cost += getResultPatternSize(P->getChild(i), CGP);
71 return Cost;
76 // 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,
166 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 };
178 enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
198 Cost = NumTraits<Scalar>::AddCost,
223 Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost), // rough estimate!
241 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;
105 #define EIGEN_MEMBER_FUNCTOR(MEMBER,COST) \
110 template<typename Scalar, int Size> struct Cost \
111 { enum { value = COST }; }; \
123 EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost );
139 template<typename _Scalar, int Size> struct Cost
140 { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; };
|
| CwiseUnaryOp.h | 50 CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits<UnaryOp>::Cost
|
| /external/llvm/lib/CodeGen/ |
| RegisterClassInfo.cpp | 102 unsigned Cost = TRI->getCostPerUse(PhysReg);
103 MinCost = std::min(MinCost, Cost);
109 if (Cost != LastCost)
112 LastCost = Cost;
121 unsigned Cost = TRI->getCostPerUse(PhysReg);
122 if (Cost != LastCost)
125 LastCost = Cost;
|
| BasicTargetTransformInfo.cpp | 42 /// Estimate the cost overhead of SK_Alternate shuffle.
265 unsigned Cost = 0;
269 Cost += TopTTI->getVectorInstrCost(Instruction::InsertElement, Ty, i);
271 Cost += TopTTI->getVectorInstrCost(Instruction::ExtractElement, Ty, i);
274 return Cost;
300 // Assume that floating point arithmetic operations cost twice as much as
308 // TODO: Once we have extract/insert subvector cost we need to use them.
323 unsigned Cost = TopTTI->getArithmeticInstrCost(Opcode, Ty->getScalarType());
324 // return the cost of multiple scalar invocation plus the cost of insertin
[all...] |
| MachineLICM.cpp | 207 /// check if hoisting an instruction of the given cost matrix can cause high
209 bool CanCauseHighRegPressure(DenseMap<unsigned, int> &Cost, bool Cheap);
245 /// index, return the ID and cost of its representative register class by
781 /// index, return the ID and cost of its representative register class.
[all...] |
| RegAllocFast.cpp | 436 // calcSpillCost - Return the cost of spilling clearing out PhysReg and
462 // This is a disabled register, add up cost of aliases.
464 unsigned Cost = 0;
471 ++Cost;
478 Cost += I->Dirty ? spillDirty : spillClean;
483 return Cost;
526 unsigned Cost = calcSpillCost(Hint);
527 if (Cost < spillDirty) {
528 if (Cost)
552 unsigned Cost = calcSpillCost(*I)
[all...] |
| RegAllocGreedy.cpp | 91 CSRFirstTimeCost("regalloc-csr-first-time-cost",
92 cl::desc("Cost for first time use of callee-saved register."),
216 /// Cost of evicting interference.
292 /// Callee-save register cost, calculated once per machine function.
353 /// Calculate cost of region splitting.
595 unsigned Cost = TRI->getCostPerUse(PhysReg);
597 // Most registers have 0 additional cost.
598 if (!Cost)
601 DEBUG(dbgs() << PrintReg(PhysReg, TRI) << " is available at cost " << Cost
[all...] |
| /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 to CompareTy by ==
40 /// Find in cost table, TypeTy must be comparable to CompareTy by ==
47 /// Type Conversion Cost Table
53 unsigned Cost;
56 /// Find in type conversion cost table, TypeTy must be comparable to CompareTy
70 /// Find in type conversion cost table, TypeTy must be comparable to CompareT
[all...] |
| /external/llvm/lib/Target/X86/ |
| X86TargetTransformInfo.cpp | 131 // X86 cost model.
202 return LT.first * AVX2UniformConstCostTable[Idx].Cost;
251 return LT.first * AVX2CostTable[Idx].Cost;
287 return LT.first * SSE2UniformConstCostTable[Idx].Cost;
311 // to ISel. The cost model must return worst case assumptions because it is
349 return LT.first * SSE2CostTable[Idx].Cost;
365 // split factor of two in the cost table. Therefore, the cost here is 18
382 return LT.first * AVX1CostTable[Idx].Cost;
394 return LT.first * CustomLowered[Idx].Cost;
[all...] |
| /external/chromium_org/third_party/webrtc/modules/rtp_rtcp/source/ |
| vp8_partition_aggregator.cc | 51 int PartitionTreeNode::Cost(int penalty) {
53 int cost = 0; local
56 cost = std::max(max_parent_size_, this_size_) -
59 cost = std::max(max_parent_size_, this_size_) - min_parent_size_;
61 return cost + NumPackets() * penalty;
130 if (left->Cost(penalty) <= right->Cost(penalty)) {
138 if (second->Cost(penalty) <= first->Cost(penalty)) {
140 // Compare cost estimate for "second" with actual cost for "first"
248 int cost = 0; local
[all...] |
| vp8_partition_aggregator.h | 37 // Calculate the cost for the node. If the node is a solution node, the cost
38 // will be the actual cost associated with that solution. If not, the cost
39 // will be the cost accumulated so far along the current branch (which is a
41 int Cost(int penalty);
100 // Find the aggregation of VP8 partitions that produces the smallest cost.
116 // be larger than max_payload_size. Each fragment comes at an overhead cost
118 // [min_size, max_size], an extra cost is inflicted.
|
| /frameworks/av/media/libstagefright/codecs/on2/h264dec/omxdl/reference/vc/m4p10/src/ |
| omxVCM4P10_MotionEstimationMB.c | 468 * Intra 4x4 Mode decision by calculating cost for all possible modes and
486 * [in] pBestCost - Cost for the Best Intra 4x4 mode
504 OMX_S32 Cost, BestCost;
546 Cost = BestCost = ARM_VCM4P10_MAX_COST;
548 /* Go through each mode for minim cost */
568 &Cost,
572 if (Cost < BestCost)
574 BestCost = Cost;
776 * [in] nLamda - For calculating the cost
777 * [out] pBestCost - Minimum cost for encoding current block
[all...] |
| /external/llvm/lib/Target/AArch64/ |
| AArch64TargetTransformInfo.cpp | 141 /// \brief Calculate the cost of materializing a 64-bit value. This helper
143 /// is valid to return a cost of ZERO.
157 /// \brief Calculate the cost of materializing the given constant.
170 // Split the constant into 64-bit chunks and calculate the cost for each
172 unsigned Cost = 0;
176 Cost += getIntImmCost(Val);
179 return std::max(1U, Cost);
187 // There is no cost model for constants with a bit size of 0. Return TCC_Free
240 unsigned Cost = AArch64TTI::getIntImmCost(Imm, Ty);
241 return (Cost <= NumConstants * TCC_Basic
[all...] |
| /external/llvm/lib/Target/PowerPC/ |
| PPCTargetTransformInfo.cpp | 127 // PPC cost model.
362 // Estimated cost of a load-hit-store delay. This was obtained
389 unsigned Cost =
395 return Cost;
408 Cost += LT.first*(SrcBytes/Alignment-1);
415 Cost += getVectorInstrCost(Instruction::ExtractElement, Src, i);
418 return Cost;
|
| /external/llvm/lib/Analysis/IPA/ |
| InlineCost.cpp | 1 //===- InlineCost.cpp - Cost analysis for inliner -------------------------===//
10 // This file implements inline cost analysis.
36 #define DEBUG_TYPE "inline-cost"
56 int Cost;
78 // can cause dramatic shifts in the cost of inlining a function.
85 // The mapping of caller Alloca values to their accumulated cost savings. If
87 // cost must be added.
145 : DL(DL), TTI(TTI), F(Callee), Threshold(Threshold), Cost(0),
159 int getCost() { return Cost; }
161 // Keep a bunch of stats about the cost savings found so we can print the
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| ConstantHoisting.cpp | 15 // cost. If the constant can be folded into the instruction (the cost is
16 // TCC_Free) or the cost is just a simple operation (TCC_BASIC), then we don't
20 // If the cost is more than TCC_BASIC, then the integer constant can't be folded
80 /// \brief Add the user to the use list and update the cost.
81 void addUser(Instruction *Inst, unsigned Idx, unsigned Cost) {
82 CumulativeCost += Cost;
275 unsigned Cost;
276 // Ask the target about the cost of materializing the constant for the given
279 Cost = TTI->getIntImmCost(IntrInst->getIntrinsicID(), Idx
[all...] |
| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.cpp | 476 DiffEntry() : Cost(0) {}
478 unsigned Cost;
508 Cur[I].Cost = I * LeftCost;
516 Next[0].Cost += RightCost;
523 Next[Index].Cost += MatchCost;
526 } else if (Next[Index-1].Cost <= Cur[Index].Cost) {
528 Next[Index].Cost += LeftCost;
532 Next[Index].Cost += RightCost;
|
| /external/llvm/lib/Target/ARM/ |
| ARMTargetTransformInfo.cpp | 201 return LT.first * NEONFltDblTbl[Idx].Cost;
211 // to cast up/down their types automatically at no extra cost.
293 return NEONVectorConversionTbl[Idx].Cost;
324 return NEONFloatConversionTbl[Idx].Cost;
356 return NEONIntegerConversionTbl[Idx].Cost;
376 return ARMIntegerConversionTbl[Idx].Cost;
419 return NEONVectorSelectTbl[Idx].Cost;
452 // Reverse shuffle cost one instruction if we are shuffling within a
470 return LT.first * NEONShuffleTbl[Idx].Cost;
474 // Alt shuffle cost table for ARM. Cost is the number of instruction
[all...] |
