15 #ifdef LLVM_HAVE_TF_API
26 #ifdef LLVM_HAVE_TF_API
41 cl::desc(
"Path to saved model evaluating native size from IR."));
43 #define DEBUG_TYPE "inline-size-estimator"
45 unsigned getMaxInstructionID() {
46 #define LAST_OTHER_INST(NR) return NR;
47 #include "llvm/IR/Instruction.def"
50 class IRToNativeSizeLearning {
52 enum class NamedFeatureIndex : size_t {
65 static const size_t NumNamedFeatures =
66 static_cast<size_t>(NamedFeatureIndex::NumNamedFeatures);
67 struct FunctionFeatures {
68 static const size_t FeatureCount;
70 std::array<int32_t, NumNamedFeatures> NamedFeatures = {0};
71 std::vector<int32_t> InstructionHistogram;
72 std::vector<int32_t> InstructionPairHistogram;
74 void fillTensor(int32_t *Ptr)
const;
75 int32_t &operator[](NamedFeatureIndex Pos) {
76 return NamedFeatures[
static_cast<size_t>(Pos)];
79 IRToNativeSizeLearning() =
default;
81 static FunctionFeatures getFunctionFeatures(
Function &
F,
93 static const std::array<std::pair<size_t, size_t>, 137>
94 ImportantInstructionSuccessions{
95 {{1, 1}, {1, 4}, {1, 5}, {1, 7}, {1, 8}, {1, 9}, {1, 11},
96 {1, 12}, {1, 13}, {1, 14}, {1, 18}, {1, 20}, {1, 22}, {1, 24},
97 {1, 25}, {1, 26}, {1, 27}, {1, 28}, {1, 29}, {1, 30}, {1, 31},
98 {1, 32}, {1, 33}, {1, 34}, {1, 39}, {1, 40}, {1, 42}, {1, 45},
99 {2, 1}, {2, 2}, {2, 13}, {2, 28}, {2, 29}, {2, 32}, {2, 33},
100 {2, 34}, {2, 38}, {2, 48}, {2, 49}, {2, 53}, {2, 55}, {2, 56},
101 {13, 2}, {13, 13}, {13, 26}, {13, 33}, {13, 34}, {13, 56}, {15, 27},
102 {28, 2}, {28, 48}, {28, 53}, {29, 2}, {29, 33}, {29, 56}, {31, 31},
103 {31, 33}, {31, 34}, {31, 49}, {32, 1}, {32, 2}, {32, 13}, {32, 15},
104 {32, 28}, {32, 29}, {32, 32}, {32, 33}, {32, 34}, {32, 39}, {32, 40},
105 {32, 48}, {32, 49}, {32, 53}, {32, 56}, {33, 1}, {33, 2}, {33, 32},
106 {33, 33}, {33, 34}, {33, 49}, {33, 53}, {33, 56}, {34, 1}, {34, 2},
107 {34, 32}, {34, 33}, {34, 34}, {34, 49}, {34, 53}, {34, 56}, {38, 34},
108 {39, 57}, {40, 34}, {47, 15}, {47, 49}, {48, 2}, {48, 34}, {48, 56},
109 {49, 1}, {49, 2}, {49, 28}, {49, 32}, {49, 33}, {49, 34}, {49, 39},
110 {49, 49}, {49, 56}, {53, 1}, {53, 2}, {53, 28}, {53, 34}, {53, 53},
111 {53, 57}, {55, 1}, {55, 28}, {55, 34}, {55, 53}, {55, 55}, {55, 56},
112 {56, 1}, {56, 2}, {56, 7}, {56, 13}, {56, 32}, {56, 33}, {56, 34},
113 {56, 49}, {56, 53}, {56, 56}, {56, 64}, {57, 34}, {57, 56}, {57, 57},
114 {64, 1}, {64, 64}, {65, 1}, {65, 65}}};
123 const size_t IRToNativeSizeLearning::FunctionFeatures::FeatureCount =
124 ImportantInstructionSuccessions.size() + getMaxInstructionID() + 1 +
125 IRToNativeSizeLearning::NumNamedFeatures;
129 for (
const auto &
BB :
F)
130 for (
const auto &
I :
BB)
132 &
I, TargetTransformInfo::TargetCostKind::TCK_CodeSize).
getValue());
138 return getSize(
F,
TTI);
141 unsigned getMaxDominatorTreeDepth(
const Function &
F,
144 for (
const auto &
BB :
F)
151 IRToNativeSizeLearning::FunctionFeatures
152 IRToNativeSizeLearning::getFunctionFeatures(
Function &
F,
155 "expected function features are sorted");
159 size_t InstrCount = getMaxInstructionID() + 1;
162 FF.InstructionPairHistogram.resize(ImportantInstructionSuccessions.size());
165 int LastID = StartID;
166 auto getPairIndex = [](
size_t a,
size_t b) {
167 auto I =
llvm::find(ImportantInstructionSuccessions, std::make_pair(
a,
b));
168 if (
I == ImportantInstructionSuccessions.end())
170 return static_cast<int>(
171 std::distance(ImportantInstructionSuccessions.begin(),
I));
175 for (
const auto &
BB :
F) {
176 for (
const auto &
I :
BB.instructionsWithoutDebug()) {
177 auto ID =
I.getOpcode();
179 ++FF.InstructionHistogram[
ID];
180 int PairIndex = getPairIndex(LastID,
ID);
182 ++FF.InstructionPairHistogram[PairIndex];
184 if (isa<CallBase>(
I))
185 ++FF[NamedFeatureIndex::Calls];
189 FF[NamedFeatureIndex::InitialSize] = getSize(
F,
FAM);
190 FF[NamedFeatureIndex::IsLocal] =
F.hasLocalLinkage();
191 FF[NamedFeatureIndex::IsLinkOnceODR] =
F.hasLinkOnceODRLinkage();
192 FF[NamedFeatureIndex::IsLinkOnce] =
F.hasLinkOnceLinkage();
193 FF[NamedFeatureIndex::Blocks] =
194 std::distance(
F.getBasicBlockList().begin(),
F.getBasicBlockList().end());
198 FF[NamedFeatureIndex::MaxLoopDepth] =
199 std::max(FF[NamedFeatureIndex::MaxLoopDepth],
200 static_cast<int32_t
>(L->getLoopDepth()));
201 FF[NamedFeatureIndex::MaxDomTreeLevel] = getMaxDominatorTreeDepth(
F, DomTree);
205 void IRToNativeSizeLearning::FunctionFeatures::fillTensor(int32_t *Ptr)
const {
206 std::copy(NamedFeatures.begin(), NamedFeatures.end(), Ptr);
207 Ptr += NamedFeatures.size();
208 std::copy(InstructionHistogram.begin(), InstructionHistogram.end(), Ptr);
209 Ptr += InstructionHistogram.size();
210 std::copy(InstructionPairHistogram.begin(), InstructionPairHistogram.end(),
215 return !TFIR2NativeModelPath.empty();
222 std::vector<TensorSpec> InputSpecs{TensorSpec::createSpec<int32_t>(
223 "serving_default_input_1",
224 {1,
static_cast<int64_t
>(
225 IRToNativeSizeLearning::FunctionFeatures::FeatureCount)})};
226 std::vector<TensorSpec> OutputSpecs{
227 TensorSpec::createSpec<float>(
"StatefulPartitionedCall", {1})};
228 Evaluator = std::make_unique<TFModelEvaluator>(
229 TFIR2NativeModelPath.getValue().c_str(), InputSpecs, OutputSpecs);
241 auto Features = IRToNativeSizeLearning::getFunctionFeatures(
243 int32_t *V =
Evaluator->getInput<int32_t>(0);
244 Features.fillTensor(V);
248 float Ret = *ER->getTensorValue<
float>(0);
251 return static_cast<size_t>(
Ret);
278 OS <<
"[InlineSizeEstimatorAnalysis] size estimate for " <<
F.getName()