Coverage Report

Created: 2019-07-24 05:18

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