Implement parallel module loading for ModuleList DYLD

Summary:
In H1, parallel module loading was introduced to PosixDYLD.
https://github.com/llvm/llvm-project/pull/130912/files#diff-a697476e39fd57edf84295d97876820763cd80570d0a64f7f0145c5e24442cbf
However for coredump debugging, we are using this ModuleList DYLD internally.

We want to implement similar approach for ModuleList DYLD, to speed up core file loading.

Test Plan:
Found a big hhvm core oelpwa5ueda300nh:
lldb -c oelpwa5ueda300nh -O symrv

Before this change:
first run: P1879168794 -> 143s to load core
second run: P1879180294 -> 21s to load core
After this change:
first run P1879227037 -> 54s to load core
second run P1879228346 -> 16s to load core

Rollback Plan:

Reviewers: jalalonde, #lldb_team, gclayton, toyang

Reviewed By: jalalonde

Subscribers: #lldb_team

Differential Revision: https://phabricator.intern.facebook.com/D77804090

Author: George Hu

lldb/source/Plugins/DynamicLoader/ModuleList-DYLD/DynamicLoaderDumpWithModuleList.cpp

@@ -9,13 +9,16 @@
 // Main header include
 #include "DynamicLoaderDumpWithModuleList.h"
 
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
+#include "llvm/Support/ThreadPool.h"
 
 #include "Plugins/ObjectFile/Placeholder/ObjectFilePlaceholder.h"
+#include <mutex>
 #include <regex>
 
 using namespace lldb;
@@ -53,6 +56,26 @@ DynamicLoaderDumpWithModuleList::DynamicLoaderDumpWithModuleList(
 
 DynamicLoaderDumpWithModuleList::~DynamicLoaderDumpWithModuleList() {}
 
+void DynamicLoaderDumpWithModuleList::SetLoadedModule(const ModuleSP &module_sp,
+                                                      addr_t link_map_addr) {
+  llvm::sys::ScopedWriter lock(m_loaded_modules_rw_mutex);
+  m_loaded_modules[module_sp] = link_map_addr;
+}
+
+void DynamicLoaderDumpWithModuleList::UnloadModule(const ModuleSP &module_sp) {
+  llvm::sys::ScopedWriter lock(m_loaded_modules_rw_mutex);
+  m_loaded_modules.erase(module_sp);
+}
+
+std::optional<lldb::addr_t>
+DynamicLoaderDumpWithModuleList::GetLoadedModuleLinkAddr(const ModuleSP &module_sp) {
+  llvm::sys::ScopedReader lock(m_loaded_modules_rw_mutex);
+  auto it = m_loaded_modules.find(module_sp);
+  if (it != m_loaded_modules.end())
+    return it->second;
+  return std::nullopt;
+}
+
 std::optional<const LoadedModuleInfoList::LoadedModuleInfo>
 DynamicLoaderDumpWithModuleList::GetModuleInfo(lldb::addr_t module_base_addr) {
   if (m_module_addr_to_info_map.empty()) {
@@ -201,11 +224,23 @@ void DynamicLoaderDumpWithModuleList::DidAttach() {
   LoadVDSO();
 
   ModuleList module_list;
+  
+  // Collect module information first
+  std::vector<ModuleInfo> module_info_list;
   LoadAllModules([&](const std::string &name, addr_t base_addr,
                      addr_t module_size, addr_t link_map_addr) {
     // vdso module has already been loaded.
     if (base_addr == m_vdso_base)
       return;
+    module_info_list.emplace_back(ModuleInfo{name, base_addr, module_size, link_map_addr});
+  });
+
+  // Load modules in parallel or sequentially based on target setting
+  auto load_module_fn = [this, &module_list, &log](const ModuleInfo &module_info) {
+    const std::string &name = module_info.name;
+    addr_t base_addr = module_info.base_addr;
+    addr_t module_size = module_info.module_size;
+    addr_t link_map_addr = module_info.link_map_addr;
 
     FileSpec file(name, m_process->GetTarget().GetArchitecture().GetTriple());
     const bool base_addr_is_offset = false;
@@ -214,6 +249,10 @@ void DynamicLoaderDumpWithModuleList::DidAttach() {
     if (module_sp.get()) {
       LLDB_LOGF(log, "LoadAllCurrentModules loading module at 0x%lX: %s",
                 base_addr, name.c_str());
+      // Note: in a multi-threaded environment, these module lists may be
+      // appended to out-of-order. This is fine, since there's no
+      // expectation for `module_list` to be in any particular order, and
+      // appending to the module list is thread-safe.
       module_list.Append(module_sp);
     } else {
       LLDB_LOGF(
@@ -229,8 +268,18 @@ void DynamicLoaderDumpWithModuleList::DidAttach() {
                            base_addr_is_offset);
       m_process->GetTarget().GetImages().Append(module_sp, /*notify*/ true);
     }
-    m_loaded_modules[module_sp] = link_map_addr;
-  });
+    SetLoadedModule(module_sp, link_map_addr);
+  };
+
+  if (m_process->GetTarget().GetParallelModuleLoad()) {
+    llvm::ThreadPoolTaskGroup task_group(Debugger::GetThreadPool());
+    for (const auto &module_info : module_info_list)
+      task_group.async(load_module_fn, module_info);
+    task_group.wait();
+  } else {
+    for (const auto &module_info : module_info_list)
+      load_module_fn(module_info);
+  }
 
   m_process->GetTarget().ModulesDidLoad(module_list);
 }
@@ -273,15 +322,15 @@ lldb::addr_t DynamicLoaderDumpWithModuleList::GetThreadLocalData(
     const lldb::ModuleSP module_sp, const lldb::ThreadSP thread,
     lldb::addr_t tls_file_addr) {
   Log *log = GetLog(LLDBLog::DynamicLoader);
-  auto it = m_loaded_modules.find(module_sp);
-  if (it == m_loaded_modules.end()) {
+  std::optional<addr_t> link_map_addr_opt = GetLoadedModuleLinkAddr(module_sp);
+  if (!link_map_addr_opt.has_value()) {
     LLDB_LOGF(
         log, "GetThreadLocalData error: module(%s) not found in loaded modules",
         module_sp->GetObjectName().AsCString());
     return LLDB_INVALID_ADDRESS;
   }
 
-  addr_t link_map = it->second;
+  addr_t link_map = link_map_addr_opt.value();
   if (link_map == LLDB_INVALID_ADDRESS || link_map == 0) {
     LLDB_LOGF(log,
               "GetThreadLocalData error: invalid link map address=0x%" PRIx64,

lldb/source/Plugins/DynamicLoader/ModuleList-DYLD/DynamicLoaderDumpWithModuleList.h

@@ -14,6 +14,7 @@
 #include "Plugins/Process/Utility/AuxVector.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/DynamicLoader.h"
+#include "llvm/Support/RWMutex.h"
 
 /**
  * Dynamic loader for dump process with module list available.
@@ -70,6 +71,14 @@ class DynamicLoaderDumpWithModuleList : public lldb_private::DynamicLoader {
   const DynamicLoaderDumpWithModuleList &
   operator=(const DynamicLoaderDumpWithModuleList &) = delete;
 
+  // Structure to hold module information
+  struct ModuleInfo {
+    std::string name;
+    lldb::addr_t base_addr;
+    lldb::addr_t module_size;
+    lldb::addr_t link_map_addr;
+  };
+
   typedef std::function<void(const std::string &, lldb::addr_t, lldb::addr_t,
                              lldb::addr_t)>
       LoadModuleCallback;
@@ -109,8 +118,17 @@ class DynamicLoaderDumpWithModuleList : public lldb_private::DynamicLoader {
   // TODO: merge with DynamicLoaderPOSIXDYLD::m_loaded_modules
   // The same as DynamicLoaderPOSIXDYLD::m_loaded_modules to track all loaded
   // module's link map addresses. It is used by TLS to get DTV data structure.
+  /// This may be accessed in a multi-threaded context. Use the accessor methods
+  /// to access `m_loaded_modules` safely.
   std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>>
       m_loaded_modules;
+  mutable llvm::sys::RWMutex m_loaded_modules_rw_mutex;
+
+  void SetLoadedModule(const lldb::ModuleSP &module_sp,
+                       lldb::addr_t link_map_addr);
+  void UnloadModule(const lldb::ModuleSP &module_sp);
+  std::optional<lldb::addr_t>
+  GetLoadedModuleLinkAddr(const lldb::ModuleSP &module_sp);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MODULELIST_DYLD_DYNAMICLOADERDUMPWITHMODULELIST_H