/external/eigen/Eigen/src/Core/ |
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
|
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...] |
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 }; };
|
/external/llvm/include/llvm/Target/ |
CostTable.h | 1 //===-- CostTable.h - Instruction Cost Table handling -----------*- C++ -*-===// 11 /// \brief Cost tables and simple lookup functions 23 /// Cost Table Entry 27 unsigned Cost; 30 /// Find in cost table, TypeTy must be comparable to CompareTy by == 43 /// Type Conversion Cost Table 48 unsigned Cost; 51 /// Find in type conversion cost table, TypeTy must be comparable to CompareTy
|
/external/eigen/blas/ |
level1_cplx_impl.h | 21 enum { Cost = 3 * NumTraits<Scalar>::AddCost, PacketAccess = 0 };
|
/external/eigen/test/eigen2/ |
eigen2_cwiseop.cpp | 19 enum { Cost = NumTraits<Scalar>::AddCost };
|
/external/llvm/include/llvm/Analysis/ |
InlineCost.h | 1 //===- InlineCost.h - Cost analysis for inliner -----------------*- C++ -*-===// 41 /// \brief Represents the cost of inlining a function. 44 /// "never" be inlined. Otherwise, the cost represents a unitless amount; 49 /// directly tested to determine if inlining should occur given the cost and 50 /// threshold for this cost metric. 57 /// \brief The estimated cost of inlining this callsite. 58 const int Cost; 60 /// \brief The adjusted threshold against which this cost was computed. 64 InlineCost(int Cost, int Threshold) : Cost(Cost), Threshold(Threshold) { [all...] |
/external/llvm/lib/Transforms/Scalar/ |
SpeculativeExecution.cpp | 71 "spec-exec-max-speculation-cost", cl::init(7), cl::Hidden, 73 "the cost of the instructions to speculatively execute " 209 const unsigned Cost = ComputeSpeculationCost(&I, *TTI); 210 if (Cost != UINT_MAX && isSafeToSpeculativelyExecute(&I) && 212 TotalSpeculationCost += Cost;
|
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 81 /// \brief Add the user to the use list and update the cost. 82 void addUser(Instruction *Inst, unsigned Idx, unsigned Cost) { 83 CumulativeCost += Cost; 279 unsigned Cost; 280 // Ask the target about the cost of materializing the constant for the given 283 Cost = TTI->getIntImmCost(IntrInst->getIntrinsicID(), Idx [all...] |
/external/eigen/test/ |
cwiseop.cpp | 30 enum { Cost = NumTraits<Scalar>::AddCost };
|
/external/llvm/lib/CodeGen/ |
RegisterClassInfo.cpp | 103 unsigned Cost = TRI->getCostPerUse(PhysReg); 104 MinCost = std::min(MinCost, Cost); 110 if (Cost != LastCost) 113 LastCost = Cost; 122 unsigned Cost = TRI->getCostPerUse(PhysReg); 123 if (Cost != LastCost) 126 LastCost = Cost;
|
RegAllocFast.cpp | 443 // calcSpillCost - Return the cost of spilling clearing out PhysReg and 469 // This is a disabled register, add up cost of aliases. 471 unsigned Cost = 0; 478 ++Cost; 485 Cost += I->Dirty ? spillDirty : spillClean; 490 return Cost; 533 unsigned Cost = calcSpillCost(Hint); 534 if (Cost < spillDirty) { 535 if (Cost) 559 unsigned Cost = calcSpillCost(*I) [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/llvm/lib/Target/ARM/ |
ARMTargetTransformInfo.cpp | 66 return LT.first * Entry->Cost; 76 // to cast up/down their types automatically at no extra cost. 157 return Entry->Cost; 187 return Entry->Cost; 218 return Entry->Cost; 237 return Entry->Cost; 288 return Entry->Cost; 340 // Reverse shuffle cost one instruction if we are shuffling within a 356 return LT.first * Entry->Cost; 362 // Alt shuffle cost table for ARM. Cost is the number of instruction [all...] |
/external/llvm/lib/Target/PowerPC/ |
PPCTargetTransformInfo.cpp | 26 // PPC cost model. 192 // often outweigh the cost of a division to compute the trip count. 314 // Estimated cost of a load-hit-store delay. This was obtained 340 int Cost = BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace); 345 return Cost; 357 // one permute (the last load in a series has extra cost, but we're 365 return Cost + LT.first; // Add the cost of the permutations. 369 // load sequence, so that might be used instead, but regardless, the net cost 372 return Cost; [all...] |
/external/llvm/utils/PerfectShuffle/ |
PerfectShuffle.cpp | 89 unsigned Cost; // Number of instrs used to generate this value. 92 ShuffleVal() : Cost(1000000) {} 108 unsigned Cost; 111 unsigned cost = 1) 112 : Name(name), ShuffleMask(shufflemask), OpNum(opnum),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/webrtc/webrtc/modules/rtp_rtcp/source/ |
vp8_partition_aggregator.cc | 32 // If |this_size_| > INT_MAX, Cost() and CreateChildren() won't work properly. 51 int PartitionTreeNode::Cost(size_t penalty) { 52 int cost = 0; local 55 cost = std::max(max_parent_size_, this_size_int()) - 58 cost = std::max(max_parent_size_, this_size_int()) - min_parent_size_; 60 return cost + NumPackets() * penalty; 125 if (left->Cost(penalty) <= right->Cost(penalty)) { 133 if (second->Cost(penalty) <= first->Cost(penalty)) 249 size_t cost = 0; local [all...] |
/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 33 #define CM_NAME "cost-model" 50 /// Returns the expected cost of the instruction. 51 /// Returns -1 if the cost is unknown [all...] |
TargetTransformInfo.cpp | 51 int Cost = TTIImpl->getOperationCost(Opcode, Ty, OpTy); 52 assert(Cost >= 0 && "TTI should not produce negative costs!"); 53 return Cost; 57 int Cost = TTIImpl->getCallCost(FTy, NumArgs); 58 assert(Cost >= 0 && "TTI should not produce negative costs!"); 59 return Cost; 64 int Cost = TTIImpl->getCallCost(F, Arguments); 65 assert(Cost >= 0 && "TTI should not produce negative costs!"); 66 return Cost; 71 int Cost = TTIImpl->getIntrinsicCost(IID, RetTy, Arguments) [all...] |
/external/llvm/lib/Target/AArch64/ |
AArch64TargetTransformInfo.cpp | 23 /// \brief Calculate the cost of materializing a 64-bit value. This helper 25 /// is valid to return a cost of ZERO. 39 /// \brief Calculate the cost of materializing the given constant. 52 // Split the constant into 64-bit chunks and calculate the cost for each 54 int Cost = 0; 58 Cost += getIntImmCost(Val); 61 return std::max(1, Cost); 69 // There is no cost model for constants with a bit size of 0. Return TCC_Free 122 int Cost = AArch64TTIImpl::getIntImmCost(Imm, Ty); 123 return (Cost <= NumConstants * TTI::TCC_Basic [all...] |
/external/llvm/include/llvm/CodeGen/ |
BasicTTIImpl.h | 49 unsigned Cost = 0; 53 Cost += static_cast<T *>(this) 56 Cost += static_cast<T *>(this) 60 return Cost; 63 /// Estimate the cost overhead of SK_Alternate shuffle. 66 unsigned Cost = 0; 67 // Shuffle cost is equal to the cost of extracting element from its argument 68 // plus the cost of inserting them onto the result vector. 75 Cost += static_cast<T *>(this [all...] |
/external/llvm/lib/Target/X86/ |
X86TargetTransformInfo.cpp | 31 // X86 cost model. 73 // check and memory check cost. 105 int Cost = 2 * getArithmeticInstrCost(Instruction::AShr, Ty, Op1Info, 108 Cost += getArithmeticInstrCost(Instruction::LShr, Ty, Op1Info, Op2Info, 111 Cost += getArithmeticInstrCost(Instruction::Add, Ty, Op1Info, Op2Info, 115 return Cost; 131 return LT.first * Entry->Cost; 145 return LT.first * Entry->Cost; 173 return LT.first * Entry->Cost; 208 return LT.first * Entry->Cost; [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;
|