Add unix signal hit counts to the target statistics.

[clayborg]

Summary

Android and other platforms make wide use of signals when running applications and this can slow down debug sessions. Tracking this statistic can help us to determine why a debug session is slow.

The new data appears inside each target object and reports the signal hit counts:

"signals": [
  {
    "SIGSTOP": 1
  },
  {
    "SIGUSR1": 1
  }
],

[wallace]

great!

lldb/include/lldb/Target/UnixSignals.h

 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/JSON.h"
 
 namespace lldb_private {
 
 class UnixSignals {
 public:
   static lldb::UnixSignalsSP Create(const ArchSpec &arch);
   static lldb::UnixSignalsSP CreateForHost();
 
public:
   // method before you return the UnixSignal object.
 
   void AddSignal(int signo, const char *name, bool default_suppress,
                  bool default_stop, bool default_notify,
                  const char *description, const char *alias = nullptr);
 
   void RemoveSignal(int signo);
 
+  /// Track how many times signals are hit as stop reasons.
+  void IncrementSignalHitCount(int signo);
+
+  /// Get the hit count statistics for signals.
+  ///
+  /// Gettings statistics on the hit counts of signals can help explain why some
+  /// debug sessions are slow since each stop takes a few hundred ms and some
+  /// software use signals a lot and can cause slow debugging performance if
+  /// they are used too often. Even if a signal is not stopped at, it will auto
+  /// continue the process and a delay will happen.
+  llvm::json::Value GetHitCountStatistics() const;
+
   // Returns a current version of the data stored in this class. Version gets
   // incremented each time Set... method is called.
   uint64_t GetVersion() const;
 
   // Returns a vector of signals that meet criteria provided in arguments. Each
   // should_[suppress|stop|notify] flag can be None  - no filtering by this
   // flag true  - only signals that have it set to true are returned false -
   // only signals that have it set to true are returned
   std::vector<int32_t> GetFilteredSignals(llvm::Optional<bool> should_suppress,
                                           llvm::Optional<bool> should_stop,
                                           llvm::Optional<bool> should_notify);
 
 protected:
   // Classes that inherit from UnixSignals can see and modify these
 
   struct Signal {
     ConstString m_name;
     ConstString m_alias;
     std::string m_description;
+    uint32_t m_hit_count = 0;
     bool m_suppress : 1, m_stop : 1, m_notify : 1;
 
     Signal(const char *name, bool default_suppress, bool default_stop,
            bool default_notify, const char *description, const char *alias);
 
     ~Signal() = default;
   };
 

lldb/source/Target/Statistics.cpp

 //===-- Statistics.cpp ----------------------------------------------------===//
 //
 // 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 "lldb/Target/Statistics.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/UnixSignals.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())
for (int i = 0; i < 2; ++i) {
     size_t num_breakpoints = breakpoints.GetSize();
     for (size_t i = 0; i < num_breakpoints; i++) {
       Breakpoint *bp = breakpoints.GetBreakpointAtIndex(i).get();
       breakpoints_array.push_back(bp->GetStatistics());
       totalBreakpointResolveTime += bp->GetResolveTime().count();
     }
   }
 
+  ProcessSP process_sp = target.GetProcessSP();
+  if (process_sp) {
+    UnixSignalsSP unix_signals_sp = process_sp->GetUnixSignals();
+    if (unix_signals_sp)
+      target_metrics_json.try_emplace("signals",
+                                      unix_signals_sp->GetHitCountStatistics());
+  }
   target_metrics_json.try_emplace("breakpoints", std::move(breakpoints_array));
   target_metrics_json.try_emplace("totalBreakpointResolveTime",
                                   totalBreakpointResolveTime);
 
   return target_metrics_json;
 }
 
 void TargetStats::SetLaunchOrAttachTime() {

lldb/source/Target/StopInfo.cpp

if (thread_sp) {
           // restarts the target by putting "continue" in the callback, then
           // we're going to restart, without running the rest of the callbacks.
           // And in this case we will end up not stopping even if another
           // location said we should stop. But that's better than not running
           // all the callbacks.
 
           // There's one other complication here.  We may have run an async
           // breakpoint callback that said we should stop.  We only want to
-          // override that if another breakpoint action says we shouldn't 
+          // override that if another breakpoint action says we shouldn't
           // stop.  If nobody else has an opinion, then we should stop if the
           // async callback says we should.  An example of this is the async
           // shared library load notification breakpoint and the setting
           // stop-on-sharedlibrary-events.
           // We'll keep the async value in async_should_stop, and track whether
           // anyone said we should NOT stop in actually_said_continue.
           bool async_should_stop = false;
           if (m_should_stop_is_valid)
if (thread_sp) {
                           "for this thread, continuing.",
                           loc_desc.GetData(),
                           static_cast<unsigned long long>(thread_sp->GetID()));
               }
               continue;
             }
 
             internal_breakpoint = bp_loc_sp->GetBreakpoint().IsInternal();
-            
             // First run the precondition, but since the precondition is per
             // breakpoint, only run it once per breakpoint.
             std::pair<std::unordered_set<break_id_t>::iterator, bool> result =
                 precondition_breakpoints.insert(
                     bp_loc_sp->GetBreakpoint().GetID());
             if (!result.second)
               continue;
 
if (thread_sp) {
 
               debugger.SetAsyncExecution(old_async);
 
               if (callback_says_stop && auto_continue_says_stop)
                 m_should_stop = true;
               else
                 actually_said_continue = true;
             }
-                  
             // If we are going to stop for this breakpoint, then remove the
             // breakpoint.
             if (callback_says_stop && bp_loc_sp &&
                 bp_loc_sp->GetBreakpoint().IsOneShot()) {
               thread_sp->GetProcess()->GetTarget().RemoveBreakpointByID(
                   bp_loc_sp->GetBreakpoint().GetID());
             }
             // Also make sure that the callback hasn't continued the target. If
if (thread_sp) {
       }
 
       if ((!m_should_stop || internal_breakpoint) &&
           thread_sp->CompletedPlanOverridesBreakpoint()) {
 
         // Override should_stop decision when we have completed step plan
         // additionally to the breakpoint
         m_should_stop = true;
-        
         // We know we're stopping for a completed plan and we don't want to
         // show the breakpoint stop, so compute the public stop info immediately
         // here.
         thread_sp->CalculatePublicStopInfo();
       }
 
       LLDB_LOGF(log,
                 "Process::%s returning from action with m_should_stop: %d.",

 // StopInfoWatchpoint
 
 class StopInfoWatchpoint : public StopInfo {
 public:
   // Make sure watchpoint is properly disabled and subsequently enabled while
   // performing watchpoint actions.
   class WatchpointSentry {
   public:
-    WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp), 
+    WatchpointSentry(ProcessSP p_sp, WatchpointSP w_sp) : process_sp(p_sp),
                      watchpoint_sp(w_sp) {
       if (process_sp && watchpoint_sp) {
         const bool notify = false;
         watchpoint_sp->TurnOnEphemeralMode();
         process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
         process_sp->AddPreResumeAction(SentryPreResumeAction, this);
       }
     }
-    
     void DoReenable() {
       if (process_sp && watchpoint_sp) {
         bool was_disabled = watchpoint_sp->IsDisabledDuringEphemeralMode();
         watchpoint_sp->TurnOffEphemeralMode();
         const bool notify = false;
         if (was_disabled) {
           process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
         } else {
           process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
         }
       }
     }
-    
     ~WatchpointSentry() {
         DoReenable();
         if (process_sp)
             process_sp->ClearPreResumeAction(SentryPreResumeAction, this);
     }
-    
     static bool SentryPreResumeAction(void *sentry_void) {
         WatchpointSentry *sentry = (WatchpointSentry *) sentry_void;
         sentry->DoReenable();
         return true;
     }
 
   private:
     ProcessSP process_sp;
protected:
   }
 
   void PerformAction(Event *event_ptr) override {
     Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS);
     // We're going to calculate if we should stop or not in some way during the
     // course of this code.  Also by default we're going to stop, so set that
     // here.
     m_should_stop = true;
-    
 
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp) {
 
       WatchpointSP wp_sp(
           thread_sp->CalculateTarget()->GetWatchpointList().FindByID(
-              GetValue()));      
+              GetValue()));
       if (wp_sp) {
         ExecutionContext exe_ctx(thread_sp->GetStackFrameAtIndex(0));
         ProcessSP process_sp = exe_ctx.GetProcessSP();
 
         {
           // check if this process is running on an architecture where
           // watchpoints trigger before the associated instruction runs. if so,
           // disable the WP, single-step and then re-enable the watchpoint
if (thread_sp) {
             // FIXME: For now the callbacks have to run in async mode - the
             // first time we restart we need
             // to get out of there.  So set it here.
             // When we figure out how to nest watchpoint hits then this will
             // change.
 
           bool old_async = debugger.GetAsyncExecution();
           debugger.SetAsyncExecution(true);
-          
           StoppointCallbackContext context(event_ptr, exe_ctx, false);
           bool stop_requested = wp_sp->InvokeCallback(&context);
-          
           debugger.SetAsyncExecution(old_async);
-          
           // Also make sure that the callback hasn't continued the target. If
           // it did, when we'll set m_should_stop to false and get out of here.
           if (HasTargetRunSinceMe())
             m_should_stop = false;
 
           if (m_should_stop && !stop_requested) {
             // We have been vetoed by the callback mechanism.
             m_should_stop = false;

 StopInfoSP
 StopInfo::CreateStopReasonWithWatchpointID(Thread &thread, break_id_t watch_id,
                                            lldb::addr_t watch_hit_addr) {
   return StopInfoSP(new StopInfoWatchpoint(thread, watch_id, watch_hit_addr));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithSignal(Thread &thread, int signo,
                                                 const char *description) {
+  thread.GetProcess()->GetUnixSignals()->IncrementSignalHitCount(signo);
   return StopInfoSP(new StopInfoUnixSignal(thread, signo, description));
 }
 
 StopInfoSP StopInfo::CreateStopReasonToTrace(Thread &thread) {
   return StopInfoSP(new StopInfoTrace(thread));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithPlan(

lldb/source/Target/UnixSignals.cpp

 #include "Plugins/Process/Utility/FreeBSDSignals.h"
 #include "Plugins/Process/Utility/LinuxSignals.h"
 #include "Plugins/Process/Utility/MipsLinuxSignals.h"
 #include "Plugins/Process/Utility/NetBSDSignals.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 
 using namespace lldb_private;
+using namespace llvm;
 
 UnixSignals::Signal::Signal(const char *name, bool default_suppress,
                             bool default_stop, bool default_notify,
                             const char *description, const char *alias)
     : m_name(name), m_alias(alias), m_description(),
       m_suppress(default_suppress), m_stop(default_stop),
       m_notify(default_notify) {
   if (description)
for (int32_t signo = GetFirstSignalNumber();
     if (should_notify.hasValue() && signal_notify != should_notify.getValue())
       continue;
 
     result.push_back(signo);
   }
 
   return result;
 }
+
+void UnixSignals::IncrementSignalHitCount(int signo) {
+  collection::iterator pos = m_signals.find(signo);
+  if (pos != m_signals.end())
+    pos->second.m_hit_count += 1;
+}
+
+json::Value UnixSignals::GetHitCountStatistics() const {
+  json::Array json_signals;
+  for (const auto &pair: m_signals) {
+    if (pair.second.m_hit_count > 0)
+      json_signals.emplace_back(json::Object{
+        { pair.second.m_name.GetCString(), pair.second.m_hit_count }
+      });
+  }
+  return std::move(json_signals);
+}

lldb/test/API/functionalities/signal/TestSendSignal.py

def test_with_run_command(self):
 
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There was data in the event.")
         self.assertEqual(
             thread.GetStopReasonDataAtIndex(0), lldbutil.get_signal_number('SIGUSR1'),
             "The stop signal was SIGUSR1")
 
+        self.match("statistics dump",
+                   [r'"signals": \[', r'"SIGUSR1": 1'])
+
+
     def match_state(self, process_listener, expected_state):
         num_seconds = 5
         broadcaster = self.process().GetBroadcaster()
         event_type_mask = lldb.SBProcess.eBroadcastBitStateChanged
         event = lldb.SBEvent()
         got_event = process_listener.WaitForEventForBroadcasterWithType(
             num_seconds, broadcaster, event_type_mask, event)
         self.assertTrue(got_event, "Got an event")
         state = lldb.SBProcess.GetStateFromEvent(event)
         self.assertEquals(state, expected_state,
                         "It was the %s state." %
                         lldb.SBDebugger_StateAsCString(expected_state))