[lldb-vscode] only report long running progress events

When the number of shared libs is massive, there could be hundreds of
thousands of short lived progress events sent to the IDE, which makes it
irresponsive while it's processing all this data. As these small jobs
take less than a second to process, the user doesn't even see them,
because the IDE only display the progress of long operations. So it's
better not to send these events.

I'm fixing that by sending only the events that are taking longer than 5
seconds to process.
In a specific run, I got the number of events from ~500k to 100, because
there was only 1 big lib to parse.

I've tried this on several small and massive targets, and it seems to
work fine.

Differential Revision: https://reviews.llvm.org/D101128

Author: walter-erquinigo

lldb/tools/lldb-vscode/ProgressEvent.cpp

@@ -13,43 +13,88 @@
 using namespace lldb_vscode;
 using namespace llvm;
 
-ProgressEvent::ProgressEvent(uint64_t progress_id, const char *message,
-                             uint64_t completed, uint64_t total)
-    : m_progress_id(progress_id), m_message(message) {
-  if (completed == total)
-    m_event_type = progressEnd;
-  else if (completed == 0)
+// The minimum duration of an event for it to be reported
+const std::chrono::duration<double> kStartProgressEventReportDelay =
+    std::chrono::seconds(1);
+// The minimum time interval between update events for reporting. If multiple
+// updates fall within the same time interval, only the latest is reported.
+const std::chrono::duration<double> kUpdateProgressEventReportDelay =
+    std::chrono::milliseconds(250);
+
+ProgressEvent::ProgressEvent(uint64_t progress_id, Optional<StringRef> message,
+                             uint64_t completed, uint64_t total,
+                             const ProgressEvent *prev_event)
+    : m_progress_id(progress_id) {
+  if (message)
+    m_message = message->str();
+
+  const bool calculate_percentage = total != UINT64_MAX;
+  if (completed == 0) {
+    // Start event
     m_event_type = progressStart;
-  else if (completed < total)
-    m_event_type = progressUpdate;
-  else
-    m_event_type = progressInvalid;
+    // Wait a bit before reporting the start event in case in completes really
+    // quickly.
+    m_minimum_allowed_report_time =
+        m_creation_time + kStartProgressEventReportDelay;
+    if (calculate_percentage)
+      m_percentage = 0;
+  } else if (completed == total) {
+    // End event
+    m_event_type = progressEnd;
+    // We should report the end event right away.
+    m_minimum_allowed_report_time = std::chrono::seconds::zero();
+    if (calculate_percentage)
+      m_percentage = 100;
+  } else {
+    // Update event
+    assert(prev_event);
+    m_percentage = std::min(
+        (uint32_t)((double)completed / (double)total * 100.0), (uint32_t)99);
+    if (prev_event->Reported()) {
+      // Add a small delay between reports
+      m_minimum_allowed_report_time =
+          prev_event->m_minimum_allowed_report_time +
+          kUpdateProgressEventReportDelay;
+    } else {
+      // We should use the previous timestamp, as it's still pending
+      m_minimum_allowed_report_time = prev_event->m_minimum_allowed_report_time;
+    }
+  }
+}
+
+Optional<ProgressEvent> ProgressEvent::Create(uint64_t progress_id,
+                                              Optional<StringRef> message,
+                                              uint64_t completed,
+                                              uint64_t total,
+                                              const ProgressEvent *prev_event) {
+  ProgressEvent event(progress_id, message, completed, total, prev_event);
+  // We shouldn't show unnamed start events in the IDE
+  if (event.GetEventType() == progressStart && event.GetEventName().empty())
+    return None;
 
-  if (0 < total && total < UINT64_MAX)
-    m_percentage = (uint32_t)(((float)completed / (float)total) * 100.0);
+  if (prev_event && prev_event->EqualsForIDE(event))
+    return None;
+
+  return event;
 }
 
-bool ProgressEvent::operator==(const ProgressEvent &other) const {
+bool ProgressEvent::EqualsForIDE(const ProgressEvent &other) const {
   return m_progress_id == other.m_progress_id &&
          m_event_type == other.m_event_type &&
          m_percentage == other.m_percentage;
 }
 
-const char *ProgressEvent::GetEventName() const {
+ProgressEventType ProgressEvent::GetEventType() const { return m_event_type; }
+
+StringRef ProgressEvent::GetEventName() const {
   if (m_event_type == progressStart)
     return "progressStart";
   else if (m_event_type == progressEnd)
     return "progressEnd";
-  else if (m_event_type == progressUpdate)
-    return "progressUpdate";
   else
-    return "progressInvalid";
+    return "progressUpdate";
 }
 
-bool ProgressEvent::IsValid() const { return m_event_type != progressInvalid; }
-
-uint64_t ProgressEvent::GetID() const { return m_progress_id; }
-
 json::Value ProgressEvent::ToJSON() const {
   llvm::json::Object event(CreateEventObject(GetEventName()));
   llvm::json::Object body;
@@ -65,9 +110,7 @@ json::Value ProgressEvent::ToJSON() const {
     body.try_emplace("cancellable", false);
   }
 
-  auto now = std::chrono::duration<double>(
-      std::chrono::system_clock::now().time_since_epoch());
-  std::string timestamp(llvm::formatv("{0:f9}", now.count()));
+  std::string timestamp(llvm::formatv("{0:f9}", m_creation_time.count()));
   EmplaceSafeString(body, "timestamp", timestamp);
 
   if (m_percentage)
@@ -77,17 +120,108 @@ json::Value ProgressEvent::ToJSON() const {
   return json::Value(std::move(event));
 }
 
-ProgressEventFilterQueue::ProgressEventFilterQueue(
-    std::function<void(ProgressEvent)> callback)
-    : m_callback(callback) {}
+bool ProgressEvent::Report(ProgressEventReportCallback callback) {
+  if (Reported())
+    return true;
+  if (std::chrono::system_clock::now().time_since_epoch() <
+      m_minimum_allowed_report_time)
+    return false;
+
+  m_reported = true;
+  callback(*this);
+  return true;
+}
+
+bool ProgressEvent::Reported() const { return m_reported; }
+
+ProgressEventManager::ProgressEventManager(
+    const ProgressEvent &start_event,
+    ProgressEventReportCallback report_callback)
+    : m_start_event(start_event), m_finished(false),
+      m_report_callback(report_callback) {}
+
+bool ProgressEventManager::ReportIfNeeded() {
+  // The event finished before we were able to report it.
+  if (!m_start_event.Reported() && Finished())
+    return true;
+
+  if (!m_start_event.Report(m_report_callback))
+    return false;
+
+  if (m_last_update_event)
+    m_last_update_event->Report(m_report_callback);
+  return true;
+}
+
+const ProgressEvent &ProgressEventManager::GetMostRecentEvent() const {
+  return m_last_update_event ? *m_last_update_event : m_start_event;
+}
+
+void ProgressEventManager::Update(uint64_t progress_id, uint64_t completed,
+                                  uint64_t total) {
+  if (Optional<ProgressEvent> event = ProgressEvent::Create(
+          progress_id, None, completed, total, &GetMostRecentEvent())) {
+    if (event->GetEventType() == progressEnd)
+      m_finished = true;
+
+    m_last_update_event = *event;
+    ReportIfNeeded();
+  }
+}
+
+bool ProgressEventManager::Finished() const { return m_finished; }
+
+ProgressEventReporter::ProgressEventReporter(
+    ProgressEventReportCallback report_callback)
+    : m_report_callback(report_callback) {
+  m_thread_should_exit = false;
+  m_thread = std::thread([&] {
+    while (!m_thread_should_exit) {
+      std::this_thread::sleep_for(kUpdateProgressEventReportDelay);
+      ReportStartEvents();
+    }
+  });
+}
+
+ProgressEventReporter::~ProgressEventReporter() {
+  m_thread_should_exit = true;
+  m_thread.join();
+}
 
-void ProgressEventFilterQueue::Push(const ProgressEvent &event) {
-  if (!event.IsValid())
-    return;
+void ProgressEventReporter::ReportStartEvents() {
+  std::lock_guard<std::mutex> locker(m_mutex);
+
+  while (!m_unreported_start_events.empty()) {
+    ProgressEventManagerSP event_manager = m_unreported_start_events.front();
+    if (event_manager->Finished())
+      m_unreported_start_events.pop();
+    else if (event_manager->ReportIfNeeded())
+      m_unreported_start_events
+          .pop(); // we remove it from the queue as it started reporting
+                  // already, the Push method will be able to continue its
+                  // reports.
+    else
+      break; // If we couldn't report it, then the next event in the queue won't
+             // be able as well, as it came later.
+  }
+}
 
-  auto it = m_last_events.find(event.GetID());
-  if (it == m_last_events.end() || !(it->second == event)) {
-    m_last_events[event.GetID()] = event;
-    m_callback(event);
+void ProgressEventReporter::Push(uint64_t progress_id, const char *message,
+                                 uint64_t completed, uint64_t total) {
+  std::lock_guard<std::mutex> locker(m_mutex);
+
+  auto it = m_event_managers.find(progress_id);
+  if (it == m_event_managers.end()) {
+    if (Optional<ProgressEvent> event =
+            ProgressEvent::Create(progress_id, StringRef(message), completed, total)) {
+      ProgressEventManagerSP event_manager =
+          std::make_shared<ProgressEventManager>(*event, m_report_callback);
+      m_event_managers.insert({progress_id, event_manager});
+      m_unreported_start_events.push(event_manager);
+    }
+  } else {
+    it->second->Update(progress_id, completed, total);
+    if (it->second->Finished())
+      m_event_managers.erase(it);
   }
 }