1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- InlineOrder.h - Inlining order abstraction -*- C++ ---*-------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
#ifndef LLVM_ANALYSIS_INLINEORDER_H
#define LLVM_ANALYSIS_INLINEORDER_H
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include <algorithm>
#include <utility>
namespace llvm {
class CallBase;
class Function;
template <typename T> class InlineOrder {
public:
using reference = T &;
using const_reference = const T &;
virtual ~InlineOrder() = default;
virtual size_t size() = 0;
virtual void push(const T &Elt) = 0;
virtual T pop() = 0;
virtual const_reference front() = 0;
virtual void erase_if(function_ref<bool(T)> Pred) = 0;
bool empty() { return !size(); }
};
template <typename T, typename Container = SmallVector<T, 16>>
class DefaultInlineOrder : public InlineOrder<T> {
using reference = T &;
using const_reference = const T &;
public:
size_t size() override { return Calls.size() - FirstIndex; }
void push(const T &Elt) override { Calls.push_back(Elt); }
T pop() override {
assert(size() > 0);
return Calls[FirstIndex++];
}
const_reference front() override {
assert(size() > 0);
return Calls[FirstIndex];
}
void erase_if(function_ref<bool(T)> Pred) override {
Calls.erase(std::remove_if(Calls.begin() + FirstIndex, Calls.end(), Pred),
Calls.end());
}
private:
Container Calls;
size_t FirstIndex = 0;
};
class InlineSizePriority {
public:
InlineSizePriority(int Size) : Size(Size) {}
static bool isMoreDesirable(const InlineSizePriority &S1,
const InlineSizePriority &S2) {
return S1.Size < S2.Size;
}
static InlineSizePriority evaluate(CallBase *CB) {
Function *Callee = CB->getCalledFunction();
return InlineSizePriority(Callee->getInstructionCount());
}
int Size;
};
template <typename PriorityT>
class PriorityInlineOrder : public InlineOrder<std::pair<CallBase *, int>> {
using T = std::pair<CallBase *, int>;
using HeapT = std::pair<CallBase *, PriorityT>;
using reference = T &;
using const_reference = const T &;
static bool cmp(const HeapT &P1, const HeapT &P2) {
return PriorityT::isMoreDesirable(P2.second, P1.second);
}
// A call site could become less desirable for inlining because of the size
// growth from prior inlining into the callee. This method is used to lazily
// update the desirability of a call site if it's decreasing. It is only
// called on pop() or front(), not every time the desirability changes. When
// the desirability of the front call site decreases, an updated one would be
// pushed right back into the heap. For simplicity, those cases where
// the desirability of a call site increases are ignored here.
void adjust() {
bool Changed = false;
do {
CallBase *CB = Heap.front().first;
const PriorityT PreviousGoodness = Heap.front().second;
const PriorityT CurrentGoodness = PriorityT::evaluate(CB);
Changed = PriorityT::isMoreDesirable(PreviousGoodness, CurrentGoodness);
if (Changed) {
std::pop_heap(Heap.begin(), Heap.end(), cmp);
Heap.pop_back();
Heap.push_back({CB, CurrentGoodness});
std::push_heap(Heap.begin(), Heap.end(), cmp);
}
} while (Changed);
}
public:
size_t size() override { return Heap.size(); }
void push(const T &Elt) override {
CallBase *CB = Elt.first;
const int InlineHistoryID = Elt.second;
const PriorityT Goodness = PriorityT::evaluate(CB);
Heap.push_back({CB, Goodness});
std::push_heap(Heap.begin(), Heap.end(), cmp);
InlineHistoryMap[CB] = InlineHistoryID;
}
T pop() override {
assert(size() > 0);
adjust();
CallBase *CB = Heap.front().first;
T Result = std::make_pair(CB, InlineHistoryMap[CB]);
InlineHistoryMap.erase(CB);
std::pop_heap(Heap.begin(), Heap.end(), cmp);
Heap.pop_back();
return Result;
}
const_reference front() override {
assert(size() > 0);
adjust();
CallBase *CB = Heap.front().first;
return *InlineHistoryMap.find(CB);
}
void erase_if(function_ref<bool(T)> Pred) override {
auto PredWrapper = [=](HeapT P) -> bool {
return Pred(std::make_pair(P.first, 0));
};
llvm::erase_if(Heap, PredWrapper);
std::make_heap(Heap.begin(), Heap.end(), cmp);
}
private:
SmallVector<HeapT, 16> Heap;
DenseMap<CallBase *, int> InlineHistoryMap;
};
} // namespace llvm
#endif // LLVM_ANALYSIS_INLINEORDER_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
