lldb/source/Core/Progress.cpp

   1 //===-- Progress.cpp ------------------------------------------------------===//
   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 #include "lldb/Core/Progress.h"
  10
  11 #include "lldb/Core/Debugger.h"
  12 #include "lldb/Utility/StreamString.h"
  13 #include "llvm/Support/Signposts.h"
  14 #include <atomic>
  15 #include <chrono>
  16 #include <cstdint>
  17 #include <mutex>
  18 #include <optional>
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22
  23 std::atomic<uint64_t> Progress::g_id(0);
  24
  25 // Instrument progress events with signposts when supported.
  26 static llvm::ManagedStatic<llvm::SignpostEmitter> g_progress_signposts;
  27
  28 Progress::Progress(std::string title, std::string details,
  29                    std::optional<uint64_t> total,
  30                    lldb_private::Debugger *debugger,
  31                    Timeout<std::nano> minimum_report_time)
  32     : m_total(total.value_or(Progress::kNonDeterministicTotal)),
  33       m_minimum_report_time(minimum_report_time),
  34       m_progress_data{title, ++g_id,
  35                       debugger ? std::optional<user_id_t>(debugger->GetID())
  36                                : std::nullopt},
  37       m_last_report_time_ns(
  38           std::chrono::nanoseconds(
  39               std::chrono::steady_clock::now().time_since_epoch())
  40               .count()),
  41       m_details(std::move(details)) {
  42   std::lock_guard<std::mutex> guard(m_mutex);
  43   ReportProgress();
  44
  45   // Report to the ProgressManager if that subsystem is enabled.
  46   if (ProgressManager::Enabled())
  47     ProgressManager::Instance().Increment(m_progress_data);
  48
  49   // Start signpost interval right before the meaningful work starts.
  50   g_progress_signposts->startInterval(this, m_progress_data.title);
  51 }
  52
  53 Progress::~Progress() {
  54   // End signpost interval as soon as possible.
  55   g_progress_signposts->endInterval(this, m_progress_data.title);
  56
  57   // Make sure to always report progress completed when this object is
  58   // destructed so it indicates the progress dialog/activity should go away.
  59   std::lock_guard<std::mutex> guard(m_mutex);
  60   m_completed = m_total;
  61   ReportProgress();
  62
  63   // Report to the ProgressManager if that subsystem is enabled.
  64   if (ProgressManager::Enabled())
  65     ProgressManager::Instance().Decrement(m_progress_data);
  66 }
  67
  68 void Progress::Increment(uint64_t amount,
  69                          std::optional<std::string> updated_detail) {
  70   if (amount == 0)
  71     return;
  72
  73   m_completed.fetch_add(amount, std::memory_order_relaxed);
  74
  75   if (m_minimum_report_time) {
  76     using namespace std::chrono;
  77
  78     nanoseconds now;
  79     uint64_t last_report_time_ns =
  80         m_last_report_time_ns.load(std::memory_order_relaxed);
  81
  82     do {
  83       now = steady_clock::now().time_since_epoch();
  84       if (now < nanoseconds(last_report_time_ns) + *m_minimum_report_time)
  85         return; // Too little time has passed since the last report.
  86
  87     } while (!m_last_report_time_ns.compare_exchange_weak(
  88         last_report_time_ns, now.count(), std::memory_order_relaxed,
  89         std::memory_order_relaxed));
  90   }
  91
  92   std::lock_guard<std::mutex> guard(m_mutex);
  93   if (updated_detail)
  94     m_details = std::move(updated_detail.value());
  95   ReportProgress();
  96 }
  97
  98 void Progress::ReportProgress() {
  99   // NB: Comparisons with optional<T> rely on the fact that std::nullopt is
 100   // "smaller" than zero.
 101   if (m_prev_completed >= m_total)
 102     return; // We've reported completion already.
 103
 104   uint64_t completed =
 105       std::min(m_completed.load(std::memory_order_relaxed), m_total);
 106   if (completed < m_prev_completed)
 107     return; // An overflow in the m_completed counter. Just ignore these events.
 108
 109   Debugger::ReportProgress(m_progress_data.progress_id, m_progress_data.title,
 110                            m_details, completed, m_total,
 111                            m_progress_data.debugger_id);
 112   m_prev_completed = completed;
 113 }
 114
 115 ProgressManager::ProgressManager()
 116     : m_entries(), m_alarm(std::chrono::milliseconds(100)) {}
 117
 118 ProgressManager::~ProgressManager() {}
 119
 120 void ProgressManager::Initialize() {
 121   assert(!InstanceImpl() && "Already initialized.");
 122   InstanceImpl().emplace();
 123 }
 124
 125 void ProgressManager::Terminate() {
 126   assert(InstanceImpl() && "Already terminated.");
 127   InstanceImpl().reset();
 128 }
 129
 130 bool ProgressManager::Enabled() { return InstanceImpl().operator bool(); }
 131
 132 ProgressManager &ProgressManager::Instance() {
 133   assert(InstanceImpl() && "ProgressManager must be initialized");
 134   return *InstanceImpl();
 135 }
 136
 137 std::optional<ProgressManager> &ProgressManager::InstanceImpl() {
 138   static std::optional<ProgressManager> g_progress_manager;
 139   return g_progress_manager;
 140 }
 141
 142 void ProgressManager::Increment(const Progress::ProgressData &progress_data) {
 143   std::lock_guard<std::mutex> lock(m_entries_mutex);
 144
 145   llvm::StringRef key = progress_data.title;
 146   bool new_entry = !m_entries.contains(key);
 147   Entry &entry = m_entries[progress_data.title];
 148
 149   if (new_entry) {
 150     // This is a new progress event. Report progress and store the progress
 151     // data.
 152     ReportProgress(progress_data, EventType::Begin);
 153     entry.data = progress_data;
 154   } else if (entry.refcount == 0) {
 155     // This is an existing entry that was scheduled to be deleted but a new one
 156     // came in before the timer expired.
 157     assert(entry.handle != Alarm::INVALID_HANDLE);
 158
 159     if (!m_alarm.Cancel(entry.handle)) {
 160       // The timer expired before we had a chance to cancel it. We have to treat
 161       // this as an entirely new progress event.
 162       ReportProgress(progress_data, EventType::Begin);
 163     }
 164     // Clear the alarm handle.
 165     entry.handle = Alarm::INVALID_HANDLE;
 166   }
 167
 168   // Regardless of how we got here, we need to bump the reference count.
 169   entry.refcount++;
 170 }
 171
 172 void ProgressManager::Decrement(const Progress::ProgressData &progress_data) {
 173   std::lock_guard<std::mutex> lock(m_entries_mutex);
 174   llvm::StringRef key = progress_data.title;
 175
 176   auto it = m_entries.find(key);
 177   if (it == m_entries.end())
 178     return;
 179
 180   Entry &entry = it->second;
 181   entry.refcount--;
 182
 183   if (entry.refcount == 0) {
 184     assert(entry.handle == Alarm::INVALID_HANDLE);
 185
 186     // Copy the key to a std::string so we can pass it by value to the lambda.
 187     // The underlying StringRef will not exist by the time the callback is
 188     // called.
 189     std::string key_str = std::string(key);
 190
 191     // Start a timer. If it expires before we see another progress event, it
 192     // will be reported.
 193     entry.handle = m_alarm.Create([=]() { Expire(key_str); });
 194   }
 195 }
 196
 197 void ProgressManager::ReportProgress(
 198     const Progress::ProgressData &progress_data, EventType type) {
 199   // The category bit only keeps track of when progress report categories have
 200   // started and ended, so clear the details and reset other fields when
 201   // broadcasting to it since that bit doesn't need that information.
 202   const uint64_t completed =
 203       (type == EventType::Begin) ? 0 : Progress::kNonDeterministicTotal;
 204   Debugger::ReportProgress(progress_data.progress_id, progress_data.title, "",
 205                            completed, Progress::kNonDeterministicTotal,
 206                            progress_data.debugger_id,
 207                            lldb::eBroadcastBitProgressCategory);
 208 }
 209
 210 void ProgressManager::Expire(llvm::StringRef key) {
 211   std::lock_guard<std::mutex> lock(m_entries_mutex);
 212
 213   // This shouldn't happen but be resilient anyway.
 214   if (!m_entries.contains(key))
 215     return;
 216
 217   // A new event came in and the alarm fired before we had a chance to restart
 218   // it.
 219   if (m_entries[key].refcount != 0)
 220     return;
 221
 222   // We're done with this entry.
 223   ReportProgress(m_entries[key].data, EventType::End);
 224   m_entries.erase(key);
 225 }