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
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===-- ImportedFunctionsInliningStatistics.h -------------------*- 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
//
//===----------------------------------------------------------------------===//
// Generating inliner statistics for imported functions, mostly useful for
// ThinLTO.
//===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_UTILS_IMPORTEDFUNCTIONSINLININGSTATISTICS_H
#define LLVM_TRANSFORMS_UTILS_IMPORTEDFUNCTIONSINLININGSTATISTICS_H
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include <string>
#include <vector>
namespace llvm {
class Module;
class Function;
/// Calculate and dump ThinLTO specific inliner stats.
/// The main statistics are:
/// (1) Number of inlined imported functions,
/// (2) Number of imported functions inlined into importing module (indirect),
/// (3) Number of non imported functions inlined into importing module
/// (indirect).
/// The difference between first and the second is that first stat counts
/// all performed inlines on imported functions, but the second one only the
/// functions that have been eventually inlined to a function in the importing
/// module (by a chain of inlines). Because llvm uses bottom-up inliner, it is
/// possible to e.g. import function `A`, `B` and then inline `B` to `A`,
/// and after this `A` might be too big to be inlined into some other function
/// that calls it. It calculates this statistic by building graph, where
/// the nodes are functions, and edges are performed inlines and then by marking
/// the edges starting from not imported function.
///
/// If `Verbose` is set to true, then it also dumps statistics
/// per each inlined function, sorted by the greatest inlines count like
/// - number of performed inlines
/// - number of performed inlines to importing module
class ImportedFunctionsInliningStatistics {
private:
/// InlineGraphNode represents node in graph of inlined functions.
struct InlineGraphNode {
// Default-constructible and movable.
InlineGraphNode() = default;
InlineGraphNode(InlineGraphNode &&) = default;
InlineGraphNode &operator=(InlineGraphNode &&) = default;
llvm::SmallVector<InlineGraphNode *, 8> InlinedCallees;
/// Incremented every direct inline.
int32_t NumberOfInlines = 0;
/// Number of inlines into non imported function (possibly indirect via
/// intermediate inlines). Computed based on graph search.
int32_t NumberOfRealInlines = 0;
bool Imported = false;
bool Visited = false;
};
public:
ImportedFunctionsInliningStatistics() = default;
ImportedFunctionsInliningStatistics(
const ImportedFunctionsInliningStatistics &) = delete;
/// Set information like AllFunctions, ImportedFunctions, ModuleName.
void setModuleInfo(const Module &M);
/// Record inline of @param Callee to @param Caller for statistis.
void recordInline(const Function &Caller, const Function &Callee);
/// Dump stats computed with InlinerStatistics class.
/// If @param Verbose is true then separate statistics for every inlined
/// function will be printed.
void dump(bool Verbose);
private:
/// Creates new Node in NodeMap and sets attributes, or returns existed one.
InlineGraphNode &createInlineGraphNode(const Function &);
void calculateRealInlines();
void dfs(InlineGraphNode &GraphNode);
using NodesMapTy =
llvm::StringMap<std::unique_ptr<InlineGraphNode>>;
using SortedNodesTy =
std::vector<const NodesMapTy::MapEntryTy*>;
/// Returns vector of elements sorted by
/// (-NumberOfInlines, -NumberOfRealInlines, FunctionName).
SortedNodesTy getSortedNodes();
private:
/// This map manage life of all InlineGraphNodes. Unique pointer to
/// InlineGraphNode used since the node pointers are also saved in the
/// InlinedCallees vector. If it would store InlineGraphNode instead then the
/// address of the node would not be invariant.
NodesMapTy NodesMap;
/// Non external functions that have some other function inlined inside.
std::vector<StringRef> NonImportedCallers;
int AllFunctions = 0;
int ImportedFunctions = 0;
StringRef ModuleName;
};
enum class InlinerFunctionImportStatsOpts {
No = 0,
Basic = 1,
Verbose = 2,
};
} // llvm
#endif // LLVM_TRANSFORMS_UTILS_IMPORTEDFUNCTIONSINLININGSTATISTICS_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
