|
147
|
1 //===- Profile.h - XRay Profile Abstraction -------------------------------===//
|
|
|
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 //
|
|
|
9 // Defines the XRay Profile class representing the latency profile generated by
|
|
|
10 // XRay's profiling mode.
|
|
|
11 //
|
|
|
12 //===----------------------------------------------------------------------===//
|
|
|
13 #ifndef LLVM_XRAY_PROFILE_H
|
|
|
14 #define LLVM_XRAY_PROFILE_H
|
|
|
15
|
|
|
16 #include "llvm/ADT/DenseMap.h"
|
|
|
17 #include "llvm/ADT/SmallVector.h"
|
|
|
18 #include "llvm/ADT/StringRef.h"
|
|
|
19 #include "llvm/Support/Error.h"
|
|
|
20 #include <list>
|
|
|
21 #include <utility>
|
|
|
22 #include <vector>
|
|
|
23
|
|
|
24 namespace llvm {
|
|
|
25 namespace xray {
|
|
|
26
|
|
|
27 class Profile;
|
|
|
28
|
|
|
29 // We forward declare the Trace type for turning a Trace into a Profile.
|
|
|
30 class Trace;
|
|
|
31
|
|
|
32 /// This function will attempt to load an XRay Profiling Mode profile from the
|
|
|
33 /// provided |Filename|.
|
|
|
34 ///
|
|
|
35 /// For any errors encountered in the loading of the profile data from
|
|
|
36 /// |Filename|, this function will return an Error condition appropriately.
|
|
|
37 Expected<Profile> loadProfile(StringRef Filename);
|
|
|
38
|
|
|
39 /// This algorithm will merge two Profile instances into a single Profile
|
|
|
40 /// instance, aggregating blocks by Thread ID.
|
|
|
41 Profile mergeProfilesByThread(const Profile &L, const Profile &R);
|
|
|
42
|
|
|
43 /// This algorithm will merge two Profile instances into a single Profile
|
|
|
44 /// instance, aggregating blocks by function call stack.
|
|
|
45 Profile mergeProfilesByStack(const Profile &L, const Profile &R);
|
|
|
46
|
|
|
47 /// This function takes a Trace and creates a Profile instance from it.
|
|
|
48 Expected<Profile> profileFromTrace(const Trace &T);
|
|
|
49
|
|
|
50 /// Profile instances are thread-compatible.
|
|
|
51 class Profile {
|
|
|
52 public:
|
|
|
53 using ThreadID = uint64_t;
|
|
|
54 using PathID = unsigned;
|
|
|
55 using FuncID = int32_t;
|
|
|
56
|
|
|
57 struct Data {
|
|
|
58 uint64_t CallCount;
|
|
|
59 uint64_t CumulativeLocalTime;
|
|
|
60 };
|
|
|
61
|
|
|
62 struct Block {
|
|
|
63 ThreadID Thread;
|
|
|
64 std::vector<std::pair<PathID, Data>> PathData;
|
|
|
65 };
|
|
|
66
|
|
|
67 /// Provides a sequence of function IDs from a previously interned PathID.
|
|
|
68 ///
|
|
|
69 /// Returns an error if |P| had not been interned before into the Profile.
|
|
|
70 ///
|
|
|
71 Expected<std::vector<FuncID>> expandPath(PathID P) const;
|
|
|
72
|
|
|
73 /// The stack represented in |P| must be in stack order (leaf to root). This
|
|
|
74 /// will always return the same PathID for |P| that has the same sequence.
|
|
|
75 PathID internPath(ArrayRef<FuncID> P);
|
|
|
76
|
|
|
77 /// Appends a fully-formed Block instance into the Profile.
|
|
|
78 ///
|
|
|
79 /// Returns an error condition in the following cases:
|
|
|
80 ///
|
|
|
81 /// - The PathData component of the Block is empty
|
|
|
82 ///
|
|
|
83 Error addBlock(Block &&B);
|
|
|
84
|
|
|
85 Profile() = default;
|
|
|
86 ~Profile() = default;
|
|
|
87
|
|
|
88 Profile(Profile &&O) noexcept
|
|
|
89 : Blocks(std::move(O.Blocks)), NodeStorage(std::move(O.NodeStorage)),
|
|
|
90 Roots(std::move(O.Roots)), PathIDMap(std::move(O.PathIDMap)),
|
|
|
91 NextID(O.NextID) {}
|
|
|
92
|
|
|
93 Profile &operator=(Profile &&O) noexcept {
|
|
|
94 Blocks = std::move(O.Blocks);
|
|
|
95 NodeStorage = std::move(O.NodeStorage);
|
|
|
96 Roots = std::move(O.Roots);
|
|
|
97 PathIDMap = std::move(O.PathIDMap);
|
|
|
98 NextID = O.NextID;
|
|
|
99 return *this;
|
|
|
100 }
|
|
|
101
|
|
|
102 Profile(const Profile &);
|
|
|
103 Profile &operator=(const Profile &);
|
|
|
104
|
|
|
105 friend void swap(Profile &L, Profile &R) {
|
|
|
106 using std::swap;
|
|
|
107 swap(L.Blocks, R.Blocks);
|
|
|
108 swap(L.NodeStorage, R.NodeStorage);
|
|
|
109 swap(L.Roots, R.Roots);
|
|
|
110 swap(L.PathIDMap, R.PathIDMap);
|
|
|
111 swap(L.NextID, R.NextID);
|
|
|
112 }
|
|
|
113
|
|
|
114 private:
|
|
|
115 using BlockList = std::list<Block>;
|
|
|
116
|
|
|
117 struct TrieNode {
|
|
|
118 FuncID Func = 0;
|
|
|
119 std::vector<TrieNode *> Callees{};
|
|
|
120 TrieNode *Caller = nullptr;
|
|
|
121 PathID ID = 0;
|
|
|
122 };
|
|
|
123
|
|
|
124 // List of blocks associated with a Profile.
|
|
|
125 BlockList Blocks;
|
|
|
126
|
|
|
127 // List of TrieNode elements we've seen.
|
|
|
128 std::list<TrieNode> NodeStorage;
|
|
|
129
|
|
|
130 // List of call stack roots.
|
|
|
131 SmallVector<TrieNode *, 4> Roots;
|
|
|
132
|
|
|
133 // Reverse mapping between a PathID to a TrieNode*.
|
|
|
134 DenseMap<PathID, TrieNode *> PathIDMap;
|
|
|
135
|
|
|
136 // Used to identify paths.
|
|
|
137 PathID NextID = 1;
|
|
|
138
|
|
|
139 public:
|
|
|
140 using const_iterator = BlockList::const_iterator;
|
|
|
141 const_iterator begin() const { return Blocks.begin(); }
|
|
|
142 const_iterator end() const { return Blocks.end(); }
|
|
|
143 bool empty() const { return Blocks.empty(); }
|
|
|
144 };
|
|
|
145
|
|
|
146 } // namespace xray
|
|
|
147 } // namespace llvm
|
|
|
148
|
|
|
149 #endif
|
