[lldb-vscode] Reduce chattiness of progress events

[wallace]

Summary

Progress events internally have a completed count and a total count, which can mean that for a job with 20000 total counts, then there will be 20000 events fired. Sending all these events to the IDE can break it. For example, debugging a huge binary resulted in around 50 million messages, which rendered the IDE useless, as it was spending all of its resources simply parsing messages and updating the UI.

A way to fix this is to send unique percentage updates, which are at most 100 per job, which is not much. I was able to debug that big target and confirm that only unique percentage notifications are sent. I can't write a test for this because the current test is flaky. I'll figure out later how to make the test reliable, but fixing this will unblock us from deploy a new version of lldb-vscode.

These are the unique progress events in the logs

The progress UI in VSCode looks like this

[wallace]

lldb/tools/lldb-vscode/ProgressEvent.cpp

39–79

all of this is just moved from the existing code

lldb/tools/lldb-vscode/CMakeLists.txt

add_lldb_tool(lldb-vscode
   lldb-vscode.cpp
   BreakpointBase.cpp
   ExceptionBreakpoint.cpp
   FifoFiles.cpp
   FunctionBreakpoint.cpp
   IOStream.cpp
   JSONUtils.cpp
   LLDBUtils.cpp
+  ProgressEvent.cpp
   RunInTerminal.cpp
   SourceBreakpoint.cpp
   VSCode.cpp
 
   LINK_LIBS
     liblldb
     ${host_lib}
     ${extra_libs}

lldb/tools/lldb-vscode/ProgressEvent.h

+//===-- ProgressEvent.cpp ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "VSCodeForward.h"
+
+#include "llvm/Support/JSON.h"
+
+namespace lldb_vscode {
+
+enum ProgressEventType {
+  progressInvalid,
+  progressStart,
+  progressUpdate,
+  progressEnd
+};
+
+class ProgressEvent {
+public:
+  ProgressEvent() {}
+
+  ProgressEvent(uint64_t progress_id, const char *message, uint64_t completed,
+                uint64_t total);
+
+  llvm::json::Value ToJSON() const;
+
+  /// This operator returns \b true if two event messages
+  /// would result in the same event for the IDE, e.g.
+  /// same rounded percentage.
+  bool operator==(const ProgressEvent &other) const;
+
+  const char *GetEventName() const;
+
+  bool IsValid() const;
+
+  uint64_t GetID() const;
+
+private:
+  uint64_t m_progress_id;
+  const char *m_message;
+  ProgressEventType m_event_type;
+  llvm::Optional<uint32_t> m_percentage;
+};
+
+/// Class that filters out progress event messages that shouldn't be reported
+/// to the IDE, either because they are invalid or because they are too chatty.
+class ProgressEventFilterQueue {
+public:
+  ProgressEventFilterQueue(std::function<void(ProgressEvent)> callback);
+
+  void Push(const ProgressEvent &event);
+
+private:
+  std::function<void(ProgressEvent)> m_callback;
+  std::map<uint64_t, ProgressEvent> m_last_events;
+};
+
+} // namespace lldb_vscode

lldb/tools/lldb-vscode/ProgressEvent.cpp

+//===-- ProgressEvent.cpp ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ProgressEvent.h"
+
+#include "JSONUtils.h"
+
+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)
+    m_event_type = progressStart;
+  else if (completed < total)
+    m_event_type = progressUpdate;
+  else
+    m_event_type = progressInvalid;
+
+  if (0 < total && total < UINT64_MAX)
+    m_percentage = (uint32_t)(((float)completed / (float)total) * 100.0);
+}
+
+bool ProgressEvent::operator==(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 {
+  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";
+}
+
+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;
+
+  std::string progress_id_str;
+  llvm::raw_string_ostream progress_id_strm(progress_id_str);
+  progress_id_strm << m_progress_id;
+  progress_id_strm.flush();
+  body.try_emplace("progressId", progress_id_str);
+
+  if (m_event_type == progressStart) {
+    EmplaceSafeString(body, "title", m_message);
+    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()));
+  EmplaceSafeString(body, "timestamp", timestamp);
+
+  if (m_percentage)
+    body.try_emplace("percentage", *m_percentage);
+
+  event.try_emplace("body", std::move(body));
+  return json::Value(std::move(event));
+}
+
+ProgressEventFilterQueue::ProgressEventFilterQueue(
+    std::function<void(ProgressEvent)> callback)
+    : m_callback(callback) {}
+
+void ProgressEventFilterQueue::Push(const ProgressEvent &event) {
+  if (!event.IsValid())
+    return;
+
+  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);
+  }
+}

lldb/tools/lldb-vscode/VSCode.h

 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 
 #include "ExceptionBreakpoint.h"
 #include "FunctionBreakpoint.h"
 #include "IOStream.h"
+#include "ProgressEvent.h"
 #include "RunInTerminal.h"
 #include "SourceBreakpoint.h"
 #include "SourceReference.h"
 
 #define VARREF_LOCALS (int64_t)1
 #define VARREF_GLOBALS (int64_t)2
 #define VARREF_REGS (int64_t)3
 #define VARREF_FIRST_VAR_IDX (int64_t)4
struct VSCode {
   std::vector<std::string> terminate_commands;
   lldb::tid_t focus_tid;
   bool sent_terminated_event;
   bool stop_at_entry;
   bool is_attach;
   uint32_t reverse_request_seq;
   std::map<std::string, RequestCallback> request_handlers;
   bool waiting_for_run_in_terminal;
+  ProgressEventFilterQueue progress_event_queue;
   // Keep track of the last stop thread index IDs as threads won't go away
   // unless we send a "thread" event to indicate the thread exited.
   llvm::DenseSet<lldb::tid_t> thread_ids;
   VSCode();
   ~VSCode();
   VSCode(const VSCode &rhs) = delete;
   void operator=(const VSCode &rhs) = delete;
   int64_t GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const;
   ExceptionBreakpoint *GetExceptionBreakpoint(const std::string &filter);
   ExceptionBreakpoint *GetExceptionBreakpoint(const lldb::break_id_t bp_id);
   // Send the JSON in "json_str" to the "out" stream. Correctly send the
   // "Content-Length:" field followed by the length, followed by the raw
   // JSON bytes.
   void SendJSON(const std::string &json_str);
 
   // Serialize the JSON value into a string and send the JSON packet to
   // the "out" stream.
   void SendJSON(const llvm::json::Value &json);
 
   std::string ReadJSON();
 
   void SendOutput(OutputType o, const llvm::StringRef output);
 
-  void SendProgressEvent(uint64_t progress_id, const char *message,
-                         uint64_t completed, uint64_t total);
+  void SendProgressEvent(const ProgressEvent &event);
 
   void __attribute__((format(printf, 3, 4)))
   SendFormattedOutput(OutputType o, const char *format, ...);
 
   static int64_t GetNextSourceReference();
 
   ExceptionBreakpoint *GetExceptionBPFromStopReason(lldb::SBThread &thread);
 

lldb/tools/lldb-vscode/VSCode.cpp

: variables(), broadcaster("lldb-vscode"), num_regs(0), num_locals(0),
       exception_breakpoints(
           {{"cpp_catch", "C++ Catch", lldb::eLanguageTypeC_plus_plus},
            {"cpp_throw", "C++ Throw", lldb::eLanguageTypeC_plus_plus},
            {"objc_catch", "Objective C Catch", lldb::eLanguageTypeObjC},
            {"objc_throw", "Objective C Throw", lldb::eLanguageTypeObjC},
            {"swift_catch", "Swift Catch", lldb::eLanguageTypeSwift},
            {"swift_throw", "Swift Throw", lldb::eLanguageTypeSwift}}),
       focus_tid(LLDB_INVALID_THREAD_ID), sent_terminated_event(false),
-      stop_at_entry(false), is_attach(false),
-      reverse_request_seq(0), waiting_for_run_in_terminal(false) {
+      stop_at_entry(false), is_attach(false), reverse_request_seq(0),
+      waiting_for_run_in_terminal(false),
+      progress_event_queue(
+          [&](const ProgressEvent &event) { SendJSON(event.ToJSON()); }) {
   const char *log_file_path = getenv("LLDBVSCODE_LOG");
 #if defined(_WIN32)
   // Windows opens stdout and stdin in text mode which converts \n to 13,10
   // while the value is just 10 on Darwin/Linux. Setting the file mode to binary
   // fixes this.
   int result = _setmode(fileno(stdout), _O_BINARY);
   assert(result);
   result = _setmode(fileno(stdin), _O_BINARY);

 //     /**
 //      * Optional, more detailed progress message. If omitted, the previous
 //      * message (if any) is used.
 //      */
 //     message?: string;
 //   };
 // }
 
-void VSCode::SendProgressEvent(uint64_t progress_id, const char *message,
-                               uint64_t completed, uint64_t total) {
-  enum ProgressEventType {
-    progressInvalid,
-    progressStart,
-    progressUpdate,
-    progressEnd
-  };
-  const char *event_name = nullptr;
-  ProgressEventType event_type = progressInvalid;
-  if (completed == 0) {
-    event_type = progressStart;
-    event_name = "progressStart";
-  } else if (completed == total) {
-    event_type = progressEnd;
-    event_name = "progressEnd";
-  } else if (completed < total) {
-    event_type = progressUpdate;
-    event_name = "progressUpdate";
-  }
-  if (event_type == progressInvalid)
-    return;
-
-  llvm::json::Object event(CreateEventObject(event_name));
-  llvm::json::Object body;
-  std::string progress_id_str;
-  llvm::raw_string_ostream progress_id_strm(progress_id_str);
-  progress_id_strm << progress_id;
-  progress_id_strm.flush();
-  body.try_emplace("progressId", progress_id_str);
-  if (event_type == progressStart) {
-    EmplaceSafeString(body, "title", message);
-    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()));
-  EmplaceSafeString(body, "timestamp", timestamp);
-
-  if (0 < total && total < UINT64_MAX) {
-    uint32_t percentage = (uint32_t)(((float)completed / (float)total) * 100.0);
-    body.try_emplace("percentage", percentage);
-  }
-  event.try_emplace("body", std::move(body));
-  SendJSON(llvm::json::Value(std::move(event)));
+void VSCode::SendProgressEvent(const ProgressEvent &event) {
+  progress_event_queue.Push(event);
 }
 
 void __attribute__((format(printf, 3, 4)))
 VSCode::SendFormattedOutput(OutputType o, const char *format, ...) {
   char buffer[1024];
   va_list args;
   va_start(args, format);
   int actual_length = vsnprintf(buffer, sizeof(buffer), format, args);

lldb/tools/lldb-vscode/lldb-vscode.cpp

if (listener.WaitForEvent(1, event)) {
       } else {
         uint64_t progress_id = 0;
         uint64_t completed = 0;
         uint64_t total = 0;
         bool is_debugger_specific = false;
         const char *message = lldb::SBDebugger::GetProgressFromEvent(
             event, progress_id, completed, total, is_debugger_specific);
         if (message)
-          g_vsc.SendProgressEvent(progress_id, message, completed, total);
+          g_vsc.SendProgressEvent(
+              ProgressEvent(progress_id, message, completed, total));
       }
     }
   }
 }
 
 // All events from the debugger, target, process, thread and frames are
 // received in this function that runs in its own thread. We are using a
 // "FILE *" to output packets back to VS Code and they have mutexes in them