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(m: std::memory_order_relaxed))); |
35 | } |
36 | operator Duration() const { return get(); } |
37 | |
38 | StatsDuration &operator+=(Duration dur) { |
39 | value.fetch_add(i: std::chrono::duration_cast<InternalDuration>(d: dur).count(), |
40 | m: 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 | struct StatisticsOptions { |
134 | bool summary_only = false; |
135 | }; |
136 | |
137 | /// A class that represents statistics for a since lldb_private::Target. |
138 | class TargetStats { |
139 | public: |
140 | llvm::json::Value ToJSON(Target &target, |
141 | const lldb_private::StatisticsOptions &options); |
142 | |
143 | void SetLaunchOrAttachTime(); |
144 | void SetFirstPrivateStopTime(); |
145 | void SetFirstPublicStopTime(); |
146 | void IncreaseSourceMapDeduceCount(); |
147 | |
148 | StatsDuration &GetCreateTime() { return m_create_time; } |
149 | StatsSuccessFail &GetExpressionStats() { return m_expr_eval; } |
150 | StatsSuccessFail &GetFrameVariableStats() { return m_frame_var; } |
151 | |
152 | protected: |
153 | StatsDuration m_create_time; |
154 | std::optional<StatsTimepoint> m_launch_or_attach_time; |
155 | std::optional<StatsTimepoint> m_first_private_stop_time; |
156 | std::optional<StatsTimepoint> m_first_public_stop_time; |
157 | StatsSuccessFail m_expr_eval{"expressionEvaluation" }; |
158 | StatsSuccessFail m_frame_var{"frameVariable" }; |
159 | std::vector<intptr_t> m_module_identifiers; |
160 | uint32_t m_source_map_deduce_count = 0; |
161 | void CollectStats(Target &target); |
162 | }; |
163 | |
164 | class DebuggerStats { |
165 | public: |
166 | static void SetCollectingStats(bool enable) { g_collecting_stats = enable; } |
167 | static bool GetCollectingStats() { return g_collecting_stats; } |
168 | |
169 | /// Get metrics associated with one or all targets in a debugger in JSON |
170 | /// format. |
171 | /// |
172 | /// \param debugger |
173 | /// The debugger to get the target list from if \a target is NULL. |
174 | /// |
175 | /// \param target |
176 | /// The single target to emit statistics for if non NULL, otherwise dump |
177 | /// statistics only for the specified target. |
178 | /// |
179 | /// \param summary_only |
180 | /// If true, only report high level summary statistics without |
181 | /// targets/modules/breakpoints etc.. details. |
182 | /// |
183 | /// \return |
184 | /// Returns a JSON value that contains all target metrics. |
185 | static llvm::json::Value |
186 | ReportStatistics(Debugger &debugger, Target *target, |
187 | const lldb_private::StatisticsOptions &options); |
188 | |
189 | protected: |
190 | // Collecting stats can be set to true to collect stats that are expensive |
191 | // to collect. By default all stats that are cheap to collect are enabled. |
192 | // This settings is here to maintain compatibility with "statistics enable" |
193 | // and "statistics disable". |
194 | static bool g_collecting_stats; |
195 | }; |
196 | |
197 | } // namespace lldb_private |
198 | |
199 | #endif // LLDB_TARGET_STATISTICS_H |
200 | |