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(x&: L.Blocks, y&: R.Blocks); |
108 | swap(x&: L.NodeStorage, y&: R.NodeStorage); |
109 | swap(LHS&: L.Roots, RHS&: R.Roots); |
110 | swap(a&: L.PathIDMap, b&: R.PathIDMap); |
111 | swap(a&: L.NextID, b&: 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 |
150 | |