LLVM  6.0.0svn
ImportedFunctionsInliningStatistics.h
Go to the documentation of this file.
1 //===-- ImportedFunctionsInliningStats.h ------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 // Generating inliner statistics for imported functions, mostly useful for
10 // ThinLTO.
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_TRANSFORMS_UTILS_IMPORTEDFUNCTIONSINLININGSTATISTICS_H
14 #define LLVM_TRANSFORMS_UTILS_IMPORTEDFUNCTIONSINLININGSTATISTICS_H
15 
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringMap.h"
18 #include "llvm/ADT/StringRef.h"
19 #include <string>
20 #include <vector>
21 
22 namespace llvm {
23 class Module;
24 class Function;
25 /// \brief Calculate and dump ThinLTO specific inliner stats.
26 /// The main statistics are:
27 /// (1) Number of inlined imported functions,
28 /// (2) Number of imported functions inlined into importing module (indirect),
29 /// (3) Number of non imported functions inlined into importing module
30 /// (indirect).
31 /// The difference between first and the second is that first stat counts
32 /// all performed inlines on imported functions, but the second one only the
33 /// functions that have been eventually inlined to a function in the importing
34 /// module (by a chain of inlines). Because llvm uses bottom-up inliner, it is
35 /// possible to e.g. import function `A`, `B` and then inline `B` to `A`,
36 /// and after this `A` might be too big to be inlined into some other function
37 /// that calls it. It calculates this statistic by building graph, where
38 /// the nodes are functions, and edges are performed inlines and then by marking
39 /// the edges starting from not imported function.
40 ///
41 /// If `Verbose` is set to true, then it also dumps statistics
42 /// per each inlined function, sorted by the greatest inlines count like
43 /// - number of performed inlines
44 /// - number of performed inlines to importing module
46 private:
47  /// InlineGraphNode represents node in graph of inlined functions.
48  struct InlineGraphNode {
49  // Default-constructible and movable.
50  InlineGraphNode() = default;
51  InlineGraphNode(InlineGraphNode &&) = default;
52  InlineGraphNode &operator=(InlineGraphNode &&) = default;
53 
55  /// Incremented every direct inline.
56  int32_t NumberOfInlines = 0;
57  /// Number of inlines into non imported function (possibly indirect via
58  /// intermediate inlines). Computed based on graph search.
59  int32_t NumberOfRealInlines = 0;
60  bool Imported = false;
61  bool Visited = false;
62  };
63 
64 public:
67  const ImportedFunctionsInliningStatistics &) = delete;
68 
69  /// Set information like AllFunctions, ImportedFunctions, ModuleName.
70  void setModuleInfo(const Module &M);
71  /// Record inline of @param Callee to @param Caller for statistis.
72  void recordInline(const Function &Caller, const Function &Callee);
73  /// Dump stats computed with InlinerStatistics class.
74  /// If @param Verbose is true then separate statistics for every inlined
75  /// function will be printed.
76  void dump(bool Verbose);
77 
78 private:
79  /// Creates new Node in NodeMap and sets attributes, or returns existed one.
80  InlineGraphNode &createInlineGraphNode(const Function &);
81  void calculateRealInlines();
82  void dfs(InlineGraphNode &GraphNode);
83 
84  using NodesMapTy =
86  using SortedNodesTy =
87  std::vector<const NodesMapTy::MapEntryTy*>;
88  /// Returns vector of elements sorted by
89  /// (-NumberOfInlines, -NumberOfRealInlines, FunctionName).
90  SortedNodesTy getSortedNodes();
91 
92 private:
93  /// This map manage life of all InlineGraphNodes. Unique pointer to
94  /// InlineGraphNode used since the node pointers are also saved in the
95  /// InlinedCallees vector. If it would store InlineGraphNode instead then the
96  /// address of the node would not be invariant.
97  NodesMapTy NodesMap;
98  /// Non external functions that have some other function inlined inside.
99  std::vector<StringRef> NonImportedCallers;
100  int AllFunctions = 0;
101  int ImportedFunctions = 0;
102  StringRef ModuleName;
103 };
104 
105 } // llvm
106 
107 #endif // LLVM_TRANSFORMS_UTILS_IMPORTEDFUNCTIONSINLININGSTATISTICS_H
void setModuleInfo(const Module &M)
Set information like AllFunctions, ImportedFunctions, ModuleName.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
void recordInline(const Function &Caller, const Function &Callee)
Record inline of.
Calculate and dump ThinLTO specific inliner stats.
amdgpu Simplify well known AMD library false Value * Callee
void dump(bool Verbose)
Dump stats computed with InlinerStatistics class.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49