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 150