1 //===-- Statistics.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 9 #ifndef LLDB_TARGET_STATISTICS_H 10 #define LLDB_TARGET_STATISTICS_H 11 12 #include "lldb/Utility/ConstString.h" 13 #include "lldb/Utility/Stream.h" 14 #include "lldb/lldb-forward.h" 15 #include "llvm/ADT/StringMap.h" 16 #include "llvm/Support/JSON.h" 17 #include <atomic> 18 #include <chrono> 19 #include <optional> 20 #include <ratio> 21 #include <string> 22 #include <vector> 23 24 namespace lldb_private { 25 26 using StatsClock = std::chrono::high_resolution_clock; 27 using StatsTimepoint = std::chrono::time_point<StatsClock>; 28 29 class StatsDuration { 30 public: 31 using Duration = std::chrono::duration<double>; 32 33 Duration get() const { 34 return Duration(InternalDuration(value.load(std::memory_order_relaxed))); 35 } 36 operator Duration() const { return get(); } 37 38 StatsDuration &operator+=(Duration dur) { 39 value.fetch_add(std::chrono::duration_cast<InternalDuration>(dur).count(), 40 std::memory_order_relaxed); 41 return *this; 42 } 43 44 private: 45 using InternalDuration = std::chrono::duration<uint64_t, std::micro>; 46 std::atomic<uint64_t> value{0}; 47 }; 48 49 /// A class that measures elapsed time in an exception safe way. 50 /// 51 /// This is a RAII class is designed to help gather timing statistics within 52 /// LLDB where objects have optional Duration variables that get updated with 53 /// elapsed times. This helps LLDB measure statistics for many things that are 54 /// then reported in LLDB commands. 55 /// 56 /// Objects that need to measure elapsed times should have a variable of type 57 /// "StatsDuration m_time_xxx;" which can then be used in the constructor of 58 /// this class inside a scope that wants to measure something: 59 /// 60 /// ElapsedTime elapsed(m_time_xxx); 61 /// // Do some work 62 /// 63 /// This class will increment the m_time_xxx variable with the elapsed time 64 /// when the object goes out of scope. The "m_time_xxx" variable will be 65 /// incremented when the class goes out of scope. This allows a variable to 66 /// measure something that might happen in stages at different times, like 67 /// resolving a breakpoint each time a new shared library is loaded. 68 class ElapsedTime { 69 public: 70 /// Set to the start time when the object is created. 71 StatsTimepoint m_start_time; 72 /// Elapsed time in seconds to increment when this object goes out of scope. 73 StatsDuration &m_elapsed_time; 74 75 public: 76 ElapsedTime(StatsDuration &opt_time) : m_elapsed_time(opt_time) { 77 m_start_time = StatsClock::now(); 78 } 79 ~ElapsedTime() { 80 StatsClock::duration elapsed = StatsClock::now() - m_start_time; 81 m_elapsed_time += elapsed; 82 } 83 }; 84 85 /// A class to count success/fail statistics. 86 struct StatsSuccessFail { 87 StatsSuccessFail(llvm::StringRef n) : name(n.str()) {} 88 89 void NotifySuccess() { ++successes; } 90 void NotifyFailure() { ++failures; } 91 92 llvm::json::Value ToJSON() const; 93 std::string name; 94 uint32_t successes = 0; 95 uint32_t failures = 0; 96 }; 97 98 /// A class that represents statistics for a since lldb_private::Module. 99 struct ModuleStats { 100 llvm::json::Value ToJSON() const; 101 intptr_t identifier; 102 std::string path; 103 std::string uuid; 104 std::string triple; 105 // Path separate debug info file, or empty if none. 106 std::string symfile_path; 107 // If the debug info is contained in multiple files where each one is 108 // represented as a separate lldb_private::Module, then these are the 109 // identifiers of these modules in the global module list. This allows us to 110 // track down all of the stats that contribute to this module. 111 std::vector<intptr_t> symfile_modules; 112 llvm::StringMap<llvm::json::Value> type_system_stats; 113 double symtab_parse_time = 0.0; 114 double symtab_index_time = 0.0; 115 double debug_parse_time = 0.0; 116 double debug_index_time = 0.0; 117 uint64_t debug_info_size = 0; 118 bool symtab_loaded_from_cache = false; 119 bool symtab_saved_to_cache = false; 120 bool debug_info_index_loaded_from_cache = false; 121 bool debug_info_index_saved_to_cache = false; 122 bool debug_info_enabled = true; 123 bool symtab_stripped = false; 124 bool debug_info_had_variable_errors = false; 125 bool debug_info_had_incomplete_types = false; 126 }; 127 128 struct ConstStringStats { 129 llvm::json::Value ToJSON() const; 130 ConstString::MemoryStats stats = ConstString::GetMemoryStats(); 131 }; 132 133 /// A class that represents statistics for a since lldb_private::Target. 134 class TargetStats { 135 public: 136 llvm::json::Value ToJSON(Target &target); 137 138 void SetLaunchOrAttachTime(); 139 void SetFirstPrivateStopTime(); 140 void SetFirstPublicStopTime(); 141 void IncreaseSourceMapDeduceCount(); 142 143 StatsDuration &GetCreateTime() { return m_create_time; } 144 StatsSuccessFail &GetExpressionStats() { return m_expr_eval; } 145 StatsSuccessFail &GetFrameVariableStats() { return m_frame_var; } 146 147 protected: 148 StatsDuration m_create_time; 149 std::optional<StatsTimepoint> m_launch_or_attach_time; 150 std::optional<StatsTimepoint> m_first_private_stop_time; 151 std::optional<StatsTimepoint> m_first_public_stop_time; 152 StatsSuccessFail m_expr_eval{"expressionEvaluation"}; 153 StatsSuccessFail m_frame_var{"frameVariable"}; 154 std::vector<intptr_t> m_module_identifiers; 155 uint32_t m_source_map_deduce_count = 0; 156 void CollectStats(Target &target); 157 }; 158 159 class DebuggerStats { 160 public: 161 static void SetCollectingStats(bool enable) { g_collecting_stats = enable; } 162 static bool GetCollectingStats() { return g_collecting_stats; } 163 164 /// Get metrics associated with one or all targets in a debugger in JSON 165 /// format. 166 /// 167 /// \param debugger 168 /// The debugger to get the target list from if \a target is NULL. 169 /// 170 /// \param target 171 /// The single target to emit statistics for if non NULL, otherwise dump 172 /// statistics only for the specified target. 173 /// 174 /// \return 175 /// Returns a JSON value that contains all target metrics. 176 static llvm::json::Value ReportStatistics(Debugger &debugger, Target *target); 177 178 protected: 179 // Collecting stats can be set to true to collect stats that are expensive 180 // to collect. By default all stats that are cheap to collect are enabled. 181 // This settings is here to maintain compatibility with "statistics enable" 182 // and "statistics disable". 183 static bool g_collecting_stats; 184 }; 185 186 } // namespace lldb_private 187 188 #endif // LLDB_TARGET_STATISTICS_H 189