Add modules stats into the "statistics dump" command.

[clayborg]

Summary

The new module stats adds the ability to measure the time it takes to parse and index the symbol tables for each module, and reports modules statistics in the output of "statistics dump" along with the path, UUID and triple of the module. The time it takes to parse and index the symbol tables are also aggregated into new top level key/value pairs at the target level.

[clayborg]

The new output looks like:

(lldb) statistics dump
{
  "expressionEvaluation": {
    "failures": 0,
    "successes": 0
  },
  "firstStopTime": 0.35030829200000002,
  "frameVariable": {
    "failures": 0,
    "successes": 0
  },
  "launchOrAttachTime": 0.32964795800000002,
  "modules": [
    {
      "path": "/Users/gclayton/Documents/src/args/build/a.out",
      "symbolTableIndexTime": 1.375e-05,
      "symbolTableParseTime": 0.000191375,
      "triple": "arm64-apple-macosx11.0.0",
      "uuid": "B7F60DCD-68BF-3F2D-AE27-85253725636A"
    },
    {
      "path": "/usr/lib/dyld",
      "symbolTableIndexTime": 0.011123958999999999,
      "symbolTableParseTime": 0.0067836249999999997,
      "triple": "arm64e-apple-macosx11.6.0",
      "uuid": "38657979-1ABE-3C9A-BF64-EF3B746216AB"
    },
    {
      "path": "/usr/lib/libc++.1.dylib",
      "symbolTableIndexTime": 0.014424457999999999,
      "symbolTableParseTime": 0.0095513330000000004,
      "triple": "arm64e-apple-macosx11.6.0",
      "uuid": "BED05B96-CCAE-365A-B3F5-F8D72F5E77E1"
    },
    ...
  ],
  "targetCreateTime": 0.16556795899999999,
  "totalSymbolTableIndexTime": 0.047531957999999992,
  "totalSymbolTableParseTime": 0.073819333000000015
}

[wallace]

looks good, does anyone else have any objections?

[JDevlieghere]

lldb/include/lldb/Target/Statistics.h

106

As modules can span (and survive) targets, I'm confused this is part of the target stats?

[clayborg]

lldb/include/lldb/Target/Statistics.h

106

In order to create performance tests that can track and identify regressions, and because modules have no backlink to the lldb_private::Target object that is eventually might get added to, we can't get any signal in how long a target takes to load up and parse the modules (and soon debug info) that the target contains without asking each module to report the time it took the parse/index itself.

The stats of how long it took to load the module in the first place is very important information for tracking regressions. Not sure if there is a better way to do this.

We could iterate over all of the modules from the global module list, but I do like the idea of adding up the contributions for a given target by iterating over its current modules. But if you have more than one debug session going, I would hate to report all of the modules from both targets, possibly including all of the .o files from DWARF in .o files and then try to make any sense of the information.

One idea would be to emit stats on all modules in a top level list like "modules", which would contain all of the stats for all modules loaded into LLDB in the global module list, and then have a "targetModules" which could just be an array of UUID values that refer to the modules in the global "modules" list of dicts? But this still doesn't change the fact that aggregating the values at the target level would be off.

I am open to ideas on how to report this better.

[clayborg]

After reading Jonas' comment about the module information being at the wrong level, I came up with a solution I think will work well. Instead of "statistics dump" emitting a dictionary for a single target when --all isn't specified, and then emitting a dictionary with a top level "targets" array when it is, we can always emit the top level dictionary that is equivalent to the DebuggerStats object. This top level dictionary will contain "modules" which is the global list of all modules that is currently loaded into LLDB, including all .o files from DWARF in .o, "targets" which is a list of target JSON stats, and then the total symbol table index/parse times are aggregated at this top level instead of in the target. The actual output now looks like:

{
  "modules": [
    {
      "identifier": 5837856648,
      "path": "/Users/gclayton/Documents/src/args/build/a.out",
      "symbolTableIndexTime": 1.4625e-05,
      "symbolTableParseTime": 0.00064383300000000001,
      "triple": "arm64-apple-macosx11.0.0",
      "uuid": "B7F60DCD-68BF-3F2D-AE27-85253725636A"
    },
    {
      "identifier": 5837128360,
      "path": "/usr/lib/dyld",
      "symbolTableIndexTime": 0.011349625,
      "symbolTableParseTime": 0.0066760420000000001,
      "triple": "arm64e-apple-macosx11.6.0",
      "uuid": "38657979-1ABE-3C9A-BF64-EF3B746216AB"
    },
  ],
  "targets": [
    {
      "expressionEvaluation": {
        "failures": 0,
        "successes": 0
      },
      "firstStopTime": 0.35298558299999999,
      "frameVariable": {
        "failures": 0,
        "successes": 0
      },
      "launchOrAttachTime": 0.33194058300000001,
      "moduleIdentifiers": [
        5837856648,
        5837128360
      ],
      "targetCreateTime": 0.16910445800000001
    }
  ],
  "totalSymbolTableIndexTime": 0.048417122000000014,
  "totalSymbolTableParseTime": 0.076428670000000004
}

Then each "target contains a "moduleIdentifiers" array, that identify the modules that are currently part of that target. Each module JSON now has a new "identifier" that can be matched up. We can't use the "UUID" from the module since not all modules have UUIDs.

Jonas, does this alleviate your concerns and fix the representation for the statistics?

[clayborg]

Updated "statistics dump" command to always outout a dictionary that represents DebuggerStats. This means a top level dictionary will contain "modules", a list of all modules from the global module list, and "targets" which will be one target, or multiple if "--all" was supplied. With "modules" at the top level, it represents how modules are represented in LLDB better having them at the DebuggerStats level. Then target dictionaries can refer to these modules with "identifiers" which are unique integers.

[clayborg]

Jonas, let me know if this new layout works for you! I updated the tests for the new output format.

[wallace]

this seems like a better solution. I like it

[JDevlieghere]

Can we use the UUID as the module identifier (at least in the JSON)? Other than that, this LGTM.

[clayborg]

In D112279#3084758, @JDevlieghere wrote:

Can we use the UUID as the module identifier (at least in the JSON)? Other than that, this LGTM.

Some binaries don't have UUID values and I didn't want to use a UUID when it was there and something else when the UUID wasn't there. The main example is all .o files don't have UUID values and many linux binaries may or may not have them.

lldb/include/lldb/Core/Module.h

 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/PathMappingList.h"
+#include "lldb/Target/Statistics.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
public:
   ///     The newly remapped filespec that is may or may not exist if
   ///     \a path was successfully located.
   llvm::Optional<std::string> RemapSourceFile(llvm::StringRef path) const;
   bool RemapSourceFile(const char *, std::string &) const = delete;
 
   /// Update the ArchSpec to a more specific variant.
   bool MergeArchitecture(const ArchSpec &arch_spec);
 
+  /// Accessor for the symbol table parse time metric.
+  ///
+  /// The value is returned as a reference to allow it to be updated by the
+  /// ElapsedTime RAII object.
+  StatsDuration &GetSymtabParseTime() { return m_symtab_parse_time; }
+  
+  /// Accessor for the symbol table index time metric.
+  ///
+  /// The value is returned as a reference to allow it to be updated by the
+  /// ElapsedTime RAII object.
+  StatsDuration &GetSymtabIndexTime() { return m_symtab_index_time; }
+
   /// \class LookupInfo Module.h "lldb/Core/Module.h"
   /// A class that encapsulates name lookup information.
   ///
   /// Users can type a wide variety of partial names when setting breakpoints
   /// by name or when looking for functions by name. The SymbolFile object is
   /// only required to implement name lookup for function basenames and for
   /// fully mangled names. This means if the user types in a partial name, we
   /// must reduce this to a name lookup that will work with all SymbolFile
lldb::SectionListUP m_sections_up; ///< Unified section list for module that
                                      /// ObjectFile instances for the debug info
 
   std::atomic<bool> m_did_load_objfile{false};
   std::atomic<bool> m_did_load_symfile{false};
   std::atomic<bool> m_did_set_uuid{false};
   mutable bool m_file_has_changed : 1,
       m_first_file_changed_log : 1; /// See if the module was modified after it
                                     /// was initially opened.
+  /// We store a symbol table parse time duration here because we might have
+  /// an object file and a symbol file which both have symbol tables. The parse
+  /// time for the symbol tables can be aggregated here.
+  StatsDuration m_symtab_parse_time{0.0};
+  /// We store a symbol named index time duration here because we might have
+  /// an object file and a symbol file which both have symbol tables. The parse
+  /// time for the symbol tables can be aggregated here.
+  StatsDuration m_symtab_index_time{0.0};
 
   /// Resolve a file or load virtual address.
   ///
   /// Tries to resolve \a vm_addr as a file address (if \a
   /// vm_addr_is_file_addr is true) or as a load address if \a
   /// vm_addr_is_file_addr is false) in the symbol vendor. \a resolve_scope
   /// indicates what clients wish to resolve and can be used to limit the
   /// scope of what is parsed.

lldb/include/lldb/Target/Statistics.h

struct StatsSuccessFail {
   void NotifyFailure() { ++failures; }
 
   llvm::json::Value ToJSON() const;
   std::string name;
   uint32_t successes = 0;
   uint32_t failures = 0;
 };
 
+/// A class that represents statistics for a since lldb_private::Module.
+struct ModuleStats {
+  llvm::json::Value ToJSON() const;
+  intptr_t identifier;
+  std::string path;
+  std::string uuid;
+  std::string triple;
+  double symtab_parse_time = 0.0;
+  double symtab_index_time = 0.0;
+};
+
 /// A class that represents statistics for a since lldb_private::Target.
 class TargetStats {
 public:
-  llvm::json::Value ToJSON();
+  llvm::json::Value ToJSON(Target &target);
 
   void SetLaunchOrAttachTime();
   void SetFirstPrivateStopTime();
   void SetFirstPublicStopTime();
 
   StatsDuration &GetCreateTime() { return m_create_time; }
   StatsSuccessFail &GetExpressionStats() { return m_expr_eval; }
   StatsSuccessFail &GetFrameVariableStats() { return m_frame_var; }
 
 protected:
   StatsDuration m_create_time{0.0};
   llvm::Optional<StatsTimepoint> m_launch_or_attach_time;
   llvm::Optional<StatsTimepoint> m_first_private_stop_time;
   llvm::Optional<StatsTimepoint> m_first_public_stop_time;
   StatsSuccessFail m_expr_eval{"expressionEvaluation"};
   StatsSuccessFail m_frame_var{"frameVariable"};
+  std::vector<intptr_t> m_module_identifiers;
+  void CollectStats(Target &target);
 };
 
 class DebuggerStats {
 public:
   static void SetCollectingStats(bool enable) { g_collecting_stats = enable; }
   static bool GetCollectingStats() { return g_collecting_stats; }
 
-  /// Get metrics associated with all targets in a debugger in JSON format.
+  /// Get metrics associated with one or all targets in a debugger in JSON
+  /// format.
+  ///
+  /// \param debugger
+  ///   The debugger to get the target list from if \a target is NULL.
+  ///
+  /// \param target
+  ///   The single target to emit statistics for if non NULL, otherwise dump
+  ///   statistics only for the specified target.
   ///
   /// \return
   ///     Returns a JSON value that contains all target metrics.
-  static llvm::json::Value ReportStatistics(Debugger &debugger);
+  static llvm::json::Value ReportStatistics(Debugger &debugger, Target *target);
 
 protected:
   // Collecting stats can be set to true to collect stats that are expensive
   // to collect. By default all stats that are cheap to collect are enabled.
   // This settings is here to maintain compatibility with "statistics enable"
   // and "statistics disable".
   static bool g_collecting_stats;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_STATISTICS_H

lldb/source/API/SBTarget.cpp

 SBStructuredData SBTarget::GetStatistics() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
 
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return LLDB_RECORD_RESULT(data);
   std::string json_str =
-      llvm::formatv("{0:2}", target_sp->ReportStatistics()).str();
+      llvm::formatv("{0:2}", 
+          DebuggerStats::ReportStatistics(target_sp->GetDebugger(), 
+                                          target_sp.get())).str();
   data.m_impl_up->SetObjectSP(StructuredData::ParseJSON(json_str));
   return LLDB_RECORD_RESULT(data);
 }
 
 void SBTarget::SetCollectingStats(bool v) {
   LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v);
 
   TargetSP target_sp(GetSP());

lldb/source/Commands/CommandObjectStats.cpp

CommandObjectStatsDump(CommandInterpreter &interpreter)
             "statistics dump [<options>]", eCommandRequiresTarget) {}
 
   ~CommandObjectStatsDump() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
-    if (m_options.m_all_targets) {
-      result.AppendMessageWithFormatv(
-          "{0:2}", DebuggerStats::ReportStatistics(GetDebugger()));
-    } else {
-      Target &target = m_exe_ctx.GetTargetRef();
-      result.AppendMessageWithFormatv("{0:2}", target.ReportStatistics());
-    }
+    Target *target = nullptr;
+    if (!m_options.m_all_targets)
+      target = m_exe_ctx.GetTargetPtr();
+
+        "{0:2}", DebuggerStats::ReportStatistics(GetDebugger(), target));
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
   CommandOptions m_options;
 };
 
 CommandObjectStats::CommandObjectStats(CommandInterpreter &interpreter)

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
   return 0;
 }
 
 Symtab *ObjectFileELF::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (!module_sp)
     return nullptr;
 
-  Progress progress(llvm::formatv("Parsing symbol table for {0}",
-                                  m_file.GetFilename().AsCString("<Unknown>")));
-
   // We always want to use the main object file so we (hopefully) only have one
   // cached copy of our symtab, dynamic sections, etc.
   ObjectFile *module_obj_file = module_sp->GetObjectFile();
   if (module_obj_file && module_obj_file != this)
     return module_obj_file->GetSymtab();
 
   if (m_symtab_up == nullptr) {
+    Progress progress(
+        llvm::formatv("Parsing symbol table for {0}",
+                      m_file.GetFilename().AsCString("<Unknown>")));
+    ElapsedTime elapsed(module_sp->GetSymtabParseTime());
     SectionList *section_list = module_sp->GetSectionList();
     if (!section_list)
       return nullptr;
 
     uint64_t symbol_id = 0;
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
     // Sharable objects and dynamic executables usually have 2 distinct symbol

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

uint32_t ObjectFileJIT::GetAddressByteSize() const {
   return m_data.GetAddressByteSize();
 }
 
 Symtab *ObjectFileJIT::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
+      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> symtab_guard(
           m_symtab_up->GetMutex());
       ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
       if (delegate_sp)
         delegate_sp->PopulateSymtab(this, *m_symtab_up);
       // TODO: get symbols from delegate
       m_symtab_up->Finalize();

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
   return AddressClass::eUnknown;
 }
 
 Symtab *ObjectFileMachO::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
+      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> symtab_guard(
           m_symtab_up->GetMutex());
       ParseSymtab();
       m_symtab_up->Finalize();
     }
   }
   return m_symtab_up.get();

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 }
 
 // GetNListSymtab
 Symtab *ObjectFilePECOFF::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
+      ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       SectionList *sect_list = GetSectionList();
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> guard(m_symtab_up->GetMutex());
 
       const uint32_t num_syms = m_coff_header.nsyms;
 
       if (m_file && num_syms > 0 && m_coff_header.symoff > 0) {
         const uint32_t symbol_size = 18;

lldb/source/Symbol/Symtab.cpp

static bool lldb_skip_name(llvm::StringRef mangled,
   }
   llvm_unreachable("unknown scheme!");
 }
 
 void Symtab::InitNameIndexes() {
   // Protected function, no need to lock mutex...
   if (!m_name_indexes_computed) {
     m_name_indexes_computed = true;
+    ElapsedTime elapsed(m_objfile->GetModule()->GetSymtabIndexTime());
     LLDB_SCOPED_TIMER();
 
     // Collect all loaded language plugins.
     std::vector<Language *> languages;
     Language::ForEach([&languages](Language *l) {
       languages.push_back(l);
       return true;
     });

lldb/source/Target/Statistics.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
+static void EmplaceSafeString(llvm::json::Object &obj, llvm::StringRef key,
+                              const std::string &str) {
+  if (str.empty())
+    return;
+  if (LLVM_LIKELY(llvm::json::isUTF8(str)))
+    obj.try_emplace(key, str);
+  else
+    obj.try_emplace(key, llvm::json::fixUTF8(str));
+}
+
 json::Value StatsSuccessFail::ToJSON() const {
   return json::Object{{"successes", successes}, {"failures", failures}};
 }
 
 static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end) {
   StatsDuration elapsed = end.time_since_epoch() - start.time_since_epoch();
   return elapsed.count();
 }
 
-json::Value TargetStats::ToJSON() {
-  json::Object target_metrics_json{{m_expr_eval.name, m_expr_eval.ToJSON()},
-                                   {m_frame_var.name, m_frame_var.ToJSON()}};
+void TargetStats::CollectStats(Target &target) {
+  m_module_identifiers.clear();
+  for (ModuleSP module_sp : target.GetImages().Modules())
+    m_module_identifiers.emplace_back((intptr_t)module_sp.get());
+}
+
+json::Value ModuleStats::ToJSON() const {
+  json::Object module;
+  EmplaceSafeString(module, "path", path);
+  EmplaceSafeString(module, "uuid", uuid);
+  EmplaceSafeString(module, "triple", triple);
+  module.try_emplace("identifier", identifier);
+  module.try_emplace("symbolTableParseTime", symtab_parse_time);
+  module.try_emplace("symbolTableIndexTime", symtab_index_time);
+  return module;
+}
+
+json::Value TargetStats::ToJSON(Target &target) {
+  CollectStats(target);
+
+  json::Array json_module_uuid_array;
+  for (auto module_identifier : m_module_identifiers)
+    json_module_uuid_array.emplace_back(module_identifier);
+
+  json::Object target_metrics_json{
+      {m_expr_eval.name, m_expr_eval.ToJSON()},
+      {m_frame_var.name, m_frame_var.ToJSON()},
+      {"moduleIdentifiers", std::move(json_module_uuid_array)}};
+
   if (m_launch_or_attach_time && m_first_private_stop_time) {
     double elapsed_time =
         elapsed(*m_launch_or_attach_time, *m_first_private_stop_time);
     target_metrics_json.try_emplace("launchOrAttachTime", elapsed_time);
   }
   if (m_launch_or_attach_time && m_first_public_stop_time) {
     double elapsed_time =
         elapsed(*m_launch_or_attach_time, *m_first_public_stop_time);
void TargetStats::SetFirstPublicStopTime() {
   // was used or if we are stopping at the entry point or not. Only set the
   // first stop time if it hasn't already been set.
   if (!m_first_public_stop_time)
     m_first_public_stop_time = StatsClock::now();
 }
 
 bool DebuggerStats::g_collecting_stats = false;
 
-llvm::json::Value DebuggerStats::ReportStatistics(Debugger &debugger) {
-  json::Array targets;
-  for (const auto &target : debugger.GetTargetList().Targets()) {
-    targets.emplace_back(target->ReportStatistics());
+llvm::json::Value DebuggerStats::ReportStatistics(Debugger &debugger,
+                                                  Target *target) {
+  json::Array json_targets;
+  json::Array json_modules;
+  double symtab_parse_time = 0.0;
+  double symtab_index_time = 0.0;
+  if (target) {
+    json_targets.emplace_back(target->ReportStatistics());
+  } else {
+    for (const auto &target : debugger.GetTargetList().Targets())
+      json_targets.emplace_back(target->ReportStatistics());
+  }
+  std::vector<ModuleStats> modules;
+  std::lock_guard<std::recursive_mutex> guard(
+      Module::GetAllocationModuleCollectionMutex());
+  const size_t num_modules = Module::GetNumberAllocatedModules();
+  ModuleSP module_sp;
+  for (size_t image_idx = 0; image_idx < num_modules; ++image_idx) {
+    Module *module = Module::GetAllocatedModuleAtIndex(image_idx);
+    ModuleStats module_stat;
+    module_stat.identifier = (intptr_t)module;
+    module_stat.path = module->GetFileSpec().GetPath();
+    module_stat.uuid = module->GetUUID().GetAsString();
+    module_stat.triple = module->GetArchitecture().GetTriple().str();
+    module_stat.symtab_parse_time = module->GetSymtabParseTime().count();
+    module_stat.symtab_index_time = module->GetSymtabIndexTime().count();
+    symtab_parse_time += module_stat.symtab_parse_time;
+    symtab_index_time += module_stat.symtab_index_time;
+    json_modules.emplace_back(module_stat.ToJSON());
   }
+
   json::Object global_stats{
-      {"targets", std::move(targets)},
+      {"targets", std::move(json_targets)},
+      {"modules", std::move(json_modules)},
+      {"totalSymbolTableParseTime", symtab_parse_time},
+      {"totalSymbolTableIndexTime", symtab_index_time},
   };
   return std::move(global_stats);
 }

lldb/source/Target/Target.cpp

 std::recursive_mutex &Target::GetAPIMutex() {
   if (GetProcessSP() && GetProcessSP()->CurrentThreadIsPrivateStateThread())
     return m_private_mutex;
   else
     return m_mutex;
 }
 
 /// Get metrics associated with this target in JSON format.
-llvm::json::Value Target::ReportStatistics() { return m_stats.ToJSON(); }
+llvm::json::Value Target::ReportStatistics() { return m_stats.ToJSON(*this); }

lldb/test/API/commands/statistics/basic/TestStats.py

def get_stats(self, options=None, log_path=None):
         if f:
             f.write('(lldb) %s\n' % (command))
         self.ci.HandleCommand(command, return_obj, False)
         metrics_json = return_obj.GetOutput()
         if f:
             f.write(metrics_json)
         return json.loads(metrics_json)
 
+
+    def get_target_stats(self, debug_stats):
+        if "targets" in debug_stats:
+            return debug_stats["targets"][0]
+        return None
+
     def test_expressions_frame_var_counts(self):
         lldbutil.run_to_source_breakpoint(self, "// break here",
                                           lldb.SBFileSpec("main.c"))
 
         self.expect("expr patatino", substrs=['27'])
-        stats = self.get_stats()
+        stats = self.get_target_stats(self.get_stats())
         self.verify_success_fail_count(stats, 'expressionEvaluation', 1, 0)
         self.expect("expr doesnt_exist", error=True,
                     substrs=["undeclared identifier 'doesnt_exist'"])
         # Doesn't successfully execute.
         self.expect("expr int *i = nullptr; *i", error=True)
         # Interpret an integer as an array with 3 elements is a failure for
         # the "expr" command, but the expression evaluation will succeed and
         # be counted as a success even though the "expr" options will for the
         # command to fail. It is more important to track expression evaluation
         # from all sources instead of just through the command, so this was
         # changed. If we want to track command success and fails, we can do
         # so using another metric.
         self.expect("expr -Z 3 -- 1", error=True,
                     substrs=["expression cannot be used with --element-count"])
         # We should have gotten 3 new failures and the previous success.
-        stats = self.get_stats()
+        stats = self.get_target_stats(self.get_stats())
         self.verify_success_fail_count(stats, 'expressionEvaluation', 2, 2)
 
         self.expect("statistics enable")
         # 'frame var' with enabled statistics will change stats.
         self.expect("frame var", substrs=['27'])
-        stats = self.get_stats()
+        stats = self.get_target_stats(self.get_stats())
         self.verify_success_fail_count(stats, 'frameVariable', 1, 0)
 
     def test_default_no_run(self):
         """Test "statistics dump" without running the target.
 
         When we don't run the target, we expect to not see any 'firstStopTime'
         or 'launchOrAttachTime' top level keys that measure the launch or
         attach of the target.
 
         Output expected to be something like:
 
         (lldb) statistics dump
         {
+          "modules" : [...],
+          "targets" : [
+            {
                 "targetCreateTime": 0.26566899599999999,
                 "expressionEvaluation": {
                     "failures": 0,
                     "successes": 0
                 },
                 "frameVariable": {
                     "failures": 0,
                     "successes": 0
                 },
+                "moduleIdentifiers": [...],
+            }
+          ],
+          "totalSymbolTableParseTime": 0.123,
+          "totalSymbolTableIndexTime": 0.234,
         }
         """
         target = self.createTestTarget()
-        stats = self.get_stats()
+        debug_stats = self.get_stats()
+        debug_stat_keys = [
+            'modules', 
+            'targets',
+            'totalSymbolTableParseTime',
+            'totalSymbolTableIndexTime',
+        ]
+        self.verify_keys(debug_stats, '"debug_stats"', debug_stat_keys, None)
+        stats = debug_stats['targets'][0]
         keys_exist = [
             'expressionEvaluation',
             'frameVariable',
+            'moduleIdentifiers',
             'targetCreateTime',
         ]
         keys_missing = [
             'firstStopTime',
             'launchOrAttachTime'
         ]
         self.verify_keys(stats, '"stats"', keys_exist, keys_missing)
         self.assertGreater(stats['targetCreateTime'], 0.0)
 
     def test_default_with_run(self):
         """Test "statistics dump" when running the target to a breakpoint.
 
         When we run the target, we expect to see 'launchOrAttachTime' and
         'firstStopTime' top level keys.
 
         Output expected to be something like:
 
         (lldb) statistics dump
         {
+          "modules" : [...],
+          "targets" : [
+                {
                     "firstStopTime": 0.34164492800000001,
                     "launchOrAttachTime": 0.31969605400000001,
+                    "moduleIdentifiers": [...],
                     "targetCreateTime": 0.0040863039999999998
                     "expressionEvaluation": {
                         "failures": 0,
                         "successes": 0
                     },
                     "frameVariable": {
                         "failures": 0,
                         "successes": 0
                     },
                 }
+            ],
+            "totalSymbolTableParseTime": 0.123,
+            "totalSymbolTableIndexTime": 0.234,
+        }
 
         """
         target = self.createTestTarget()
         lldbutil.run_to_source_breakpoint(self, "// break here",
                                           lldb.SBFileSpec("main.c"))
-        stats = self.get_stats()
+        debug_stats = self.get_stats()
+        debug_stat_keys = [
+            'modules', 
+            'targets',
+            'totalSymbolTableParseTime',
+            'totalSymbolTableIndexTime',
+        ]
+        self.verify_keys(debug_stats, '"debug_stats"', debug_stat_keys, None)
+        stats = debug_stats['targets'][0]
         keys_exist = [
             'expressionEvaluation',
             'firstStopTime',
             'frameVariable',
             'launchOrAttachTime',
+            'moduleIdentifiers',
             'targetCreateTime',
         ]
         self.verify_keys(stats, '"stats"', keys_exist, None)
         self.assertGreater(stats['firstStopTime'], 0.0)
         self.assertGreater(stats['launchOrAttachTime'], 0.0)
         self.assertGreater(stats['targetCreateTime'], 0.0)
+
+    def find_module_in_metrics(self, path, stats):
+        modules = stats['modules']
+        for module in modules:
+            if module['path'] == path:
+                return module
+        return None
+
+    def test_modules(self):
+        """
+            Test "statistics dump" and the module information.
+        """
+        exe = self.getBuildArtifact("a.out")
+        target = self.createTestTarget(file_path=exe)
+        debug_stats = self.get_stats()
+        debug_stat_keys = [
+            'modules', 
+            'targets',
+            'totalSymbolTableParseTime',
+            'totalSymbolTableIndexTime',
+        ]
+        self.verify_keys(debug_stats, '"debug_stats"', debug_stat_keys, None)
+        stats = debug_stats['targets'][0]
+        keys_exist = [
+            'moduleIdentifiers',
+        ]
+        self.verify_keys(stats, '"stats"', keys_exist, None)
+        exe_module = self.find_module_in_metrics(exe, debug_stats)
+        module_keys = [
+            'identifier',
+            'path',
+            'symbolTableIndexTime',
+            'symbolTableParseTime',
+            'triple',
+            'uuid',
+        ]
+        self.assertNotEqual(exe_module, None)
+        self.verify_keys(exe_module, 'module dict for "%s"' % (exe), module_keys)

lldb/test/API/functionalities/stats_api/TestStatisticsAPI.py

def test_stats_api(self):
         self.assertTrue(target.GetCollectingStats())
         target.SetCollectingStats(False)
         self.assertFalse(target.GetCollectingStats())
 
         # Test the function to get the statistics in JSON'ish.
         stats = target.GetStatistics()
         stream = lldb.SBStream()
         res = stats.GetAsJSON(stream)
-        stats_json = json.loads(stream.GetData())
+        debug_stats = json.loads(stream.GetData())
+        self.assertEqual('targets' in debug_stats, True,
+                'Make sure the "targets" key in in target.GetStatistics()')
+        self.assertEqual('modules' in debug_stats, True,
+                'Make sure the "modules" key in in target.GetStatistics()')
+        stats_json = debug_stats['targets'][0]
         self.assertEqual('expressionEvaluation' in stats_json, True,
-                'Make sure the "expressionEvaluation" key in in target.GetStatistics()')
+                'Make sure the "expressionEvaluation" key in in target.GetStatistics()["targets"][0]')
         self.assertEqual('frameVariable' in stats_json, True,
-                'Make sure the "frameVariable" key in in target.GetStatistics()')
+                'Make sure the "frameVariable" key in in target.GetStatistics()["targets"][0]')
         expressionEvaluation = stats_json['expressionEvaluation']
         self.assertEqual('successes' in expressionEvaluation, True,
                 'Make sure the "successes" key in in "expressionEvaluation" dictionary"')
         self.assertEqual('failures' in expressionEvaluation, True,
                 'Make sure the "failures" key in in "expressionEvaluation" dictionary"')
         frameVariable = stats_json['frameVariable']
         self.assertEqual('successes' in frameVariable, True,
                 'Make sure the "successes" key in in "frameVariable" dictionary"')
         self.assertEqual('failures' in frameVariable, True,
                 'Make sure the "failures" key in in "frameVariable" dictionary"')