LLDB mainline
Statistics.h
Go to the documentation of this file.
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
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
24namespace lldb_private {
25
26using StatsClock = std::chrono::high_resolution_clock;
27using StatsTimepoint = std::chrono::time_point<StatsClock>;
28
30public:
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
39 value.fetch_add(std::chrono::duration_cast<InternalDuration>(dur).count(),
40 std::memory_order_relaxed);
41 return *this;
42 }
43
44private:
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.
69public:
70 /// Set to the start time when the object is created.
72 /// Elapsed time in seconds to increment when this object goes out of scope.
74
75public:
76 ElapsedTime(StatsDuration &opt_time) : m_elapsed_time(opt_time) {
77 m_start_time = StatsClock::now();
78 }
80 StatsClock::duration elapsed = StatsClock::now() - m_start_time;
82 }
83};
84
85/// A class to count success/fail statistics.
87 StatsSuccessFail(llvm::StringRef n) : name(n.str()) {}
88
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.
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;
123 bool symtab_stripped = false;
126};
127
129 llvm::json::Value ToJSON() const;
131};
132
134 bool summary_only = false;
136};
137
138/// A class that represents statistics for a since lldb_private::Target.
140public:
141 llvm::json::Value ToJSON(Target &target,
142 const lldb_private::StatisticsOptions &options);
143
148
152
153protected:
155 std::optional<StatsTimepoint> m_launch_or_attach_time;
156 std::optional<StatsTimepoint> m_first_private_stop_time;
157 std::optional<StatsTimepoint> m_first_public_stop_time;
158 StatsSuccessFail m_expr_eval{"expressionEvaluation"};
160 std::vector<intptr_t> m_module_identifiers;
162 void CollectStats(Target &target);
163};
164
166public:
167 static void SetCollectingStats(bool enable) { g_collecting_stats = enable; }
168 static bool GetCollectingStats() { return g_collecting_stats; }
169
170 /// Get metrics associated with one or all targets in a debugger in JSON
171 /// format.
172 ///
173 /// \param debugger
174 /// The debugger to get the target list from if \a target is NULL.
175 ///
176 /// \param target
177 /// The single target to emit statistics for if non NULL, otherwise dump
178 /// statistics only for the specified target.
179 ///
180 /// \param summary_only
181 /// If true, only report high level summary statistics without
182 /// targets/modules/breakpoints etc.. details.
183 ///
184 /// \return
185 /// Returns a JSON value that contains all target metrics.
186 static llvm::json::Value
187 ReportStatistics(Debugger &debugger, Target *target,
188 const lldb_private::StatisticsOptions &options);
189
190protected:
191 // Collecting stats can be set to true to collect stats that are expensive
192 // to collect. By default all stats that are cheap to collect are enabled.
193 // This settings is here to maintain compatibility with "statistics enable"
194 // and "statistics disable".
196};
197
198} // namespace lldb_private
199
200#endif // LLDB_TARGET_STATISTICS_H
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
Definition: Statistics.cpp:38
static MemoryStats GetMemoryStats()
static void SetCollectingStats(bool enable)
Definition: Statistics.h:167
static bool GetCollectingStats()
Definition: Statistics.h:168
static bool g_collecting_stats
Definition: Statistics.h:195
static llvm::json::Value ReportStatistics(Debugger &debugger, Target *target, const lldb_private::StatisticsOptions &options)
Get metrics associated with one or all targets in a debugger in JSON format.
Definition: Statistics.cpp:222
A class to manage flag bits.
Definition: Debugger.h:79
A class that measures elapsed time in an exception safe way.
Definition: Statistics.h:68
StatsDuration & m_elapsed_time
Elapsed time in seconds to increment when this object goes out of scope.
Definition: Statistics.h:73
ElapsedTime(StatsDuration &opt_time)
Definition: Statistics.h:76
StatsTimepoint m_start_time
Set to the start time when the object is created.
Definition: Statistics.h:71
Duration get() const
Definition: Statistics.h:33
std::atomic< uint64_t > value
Definition: Statistics.h:46
std::chrono::duration< double > Duration
Definition: Statistics.h:31
StatsDuration & operator+=(Duration dur)
Definition: Statistics.h:38
std::chrono::duration< uint64_t, std::micro > InternalDuration
Definition: Statistics.h:45
A class that represents statistics for a since lldb_private::Target.
Definition: Statistics.h:139
StatsSuccessFail m_frame_var
Definition: Statistics.h:159
std::optional< StatsTimepoint > m_launch_or_attach_time
Definition: Statistics.h:155
uint32_t m_source_map_deduce_count
Definition: Statistics.h:161
void CollectStats(Target &target)
Definition: Statistics.cpp:44
StatsSuccessFail & GetFrameVariableStats()
Definition: Statistics.h:151
llvm::json::Value ToJSON(Target &target, const lldb_private::StatisticsOptions &options)
Definition: Statistics.cpp:105
StatsDuration m_create_time
Definition: Statistics.h:154
std::optional< StatsTimepoint > m_first_public_stop_time
Definition: Statistics.h:157
StatsDuration & GetCreateTime()
Definition: Statistics.h:149
StatsSuccessFail & GetExpressionStats()
Definition: Statistics.h:150
StatsSuccessFail m_expr_eval
Definition: Statistics.h:158
std::vector< intptr_t > m_module_identifiers
Definition: Statistics.h:160
std::optional< StatsTimepoint > m_first_private_stop_time
Definition: Statistics.h:156
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
std::chrono::time_point< StatsClock > StatsTimepoint
Definition: Statistics.h:27
std::chrono::high_resolution_clock StatsClock
Definition: Statistics.h:26
ConstString::MemoryStats stats
Definition: Statistics.h:130
llvm::json::Value ToJSON() const
Definition: Statistics.cpp:96
A class that represents statistics for a since lldb_private::Module.
Definition: Statistics.h:99
llvm::json::Value ToJSON() const
Definition: Statistics.cpp:50
llvm::StringMap< llvm::json::Value > type_system_stats
Definition: Statistics.h:112
std::vector< intptr_t > symfile_modules
Definition: Statistics.h:111
A class to count success/fail statistics.
Definition: Statistics.h:86
StatsSuccessFail(llvm::StringRef n)
Definition: Statistics.h:87
llvm::json::Value ToJSON() const
Definition: Statistics.cpp:34