[trace] [intel pt] Create a "thread trace dump stats" command

[hanbingwang]

Summary

When the user types that command 'thread trace dump info' and there's a running Trace session in LLDB, a raw trace in bytes should be printed; the command 'thread trace dump info all' should print the info for all the threads.

[wallace]

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

118

the presentation of this line could be better. Something like this would look nicer

thread 1: tid = 123123
  
  - Tracing technology: Intel PT
  - Raw trace size: 1231232 bytes

[clayborg]

lldb/include/lldb/Target/Trace.h

155

Are any statistics being dumped here? Maybe DumpTraceSummary(...) or DumpTraceInfo(...) would be better?

lldb/source/Commands/CommandObjectThread.cpp

2206–2208

Since we are iterating on this new command, I am wondering if we should have just a "thread trace dump" command with options?

(lldb) thread trace dump --stats
(lldb) thread trace dump --instructions

This way the user could dump more than one thing at a time with a single command?:

(lldb) thread trace dump --stats --instructions

Just thinking out loud here, so no worries if you feel this is already correct and should stay this way

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

118

The "Tracing technology: Intel PT" should probably come before any of the thread infos if it is added:

Tracing technology: Intel PT
thread 1: tid = 111, size = 0x1000
thread 2: tid = 222, size = 0x1000

[wallace]

lldb/source/Commands/CommandObjectThread.cpp

2206–2208

I think that's a bit too much for this patch, but I'll keep it in mind if we end up having more dumpers.

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

118

That's a pretty good idea.

@hanbingwang , you can invoke trace_sp->GetPluginName() for getting the name of the tracing technology being used

[hanbingwang]

1. rename "thread trace dump stats" to "thread trace dump info"
2. Additionally, print out the tracing plugin name.

[hanbingwang]

lldb/include/lldb/Target/Trace.h

155

@clayborg Sorry I didn't turn on the notification! Just saw your comments yesterday.
I agree "DumpTraceInfo()" is a better name.

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

118

Hi @wallace @clayborg,

I'm wondering how to let the string "Tracing technology: Intel PT" printed out exactly once, when there are more than one threads? It looks like that HandleOneThread() will be called multiple times, which will then call DumpTraceInfo() which does the printout.

It seems that it'll be easy to print the string if we know if a thread is the *first* to be handled. However the threads are not indexed though?

[wallace]

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

118

You need to override CommandObjectIterateOverThreads::DoExecute in your command object. Something like this (figure out the correct function names)

bool CommandObjectTraceDumpInfo::DoExecute(Args &command,
                                              CommandReturnObject &result) {
   Target &target = m_exe_ctx.GetTargetRef();
   result.GetOutput().Printf("trace technology: %s", target.GetTrace().GetPluginName().Data());
  
   return CommandObjectIterateOverThreads::DoExecute(command, result);
}

that way that piece of code is executed before iterating over the threads

[hanbingwang]

print out the tracing plugin name exactly once when there are one or more than one threads.

[wallace]

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

113

add an empty line before this to clearly separate the output of each thread

118

Add 2 empty spaces before the text to have some sort of indentation

[hanbingwang]

add two spaces before the string "Raw trace size : xxx"; add new line between each thread.

[hanbingwang]

This comment has been deleted.

[hanbingwang]

• create a "thread trace dump info" command.
• the string "Trace technology: xxx" should be only printed out once when there are more than one thread.
• add two spaces before the string "Raw trace size : xxx"; add new line between each thread.

[JDevlieghere]

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

125–126

No else after return. Seems like a good candidate for a ternary operator.

[wallace]

Committed on behalf of @hanbingwang. Commit hash 345ace026b6e5cdbc38d207291e4b399d72e62ee

lldb/include/lldb/Target/Trace.h

public:
   ///     The thread that owns the trace in question.
   ///
   /// \param[in] s
   ///     The stream object where the info will be printed printed.
   ///
   /// \param[in] verbose
   ///     If \b true, print detailed info
   ///     If \b false, print compact info
-  ///
-  /// \param[in] plugin_name
-  ///     The name of the tracing technology being used being used
-  virtual void DumpTraceInfo(Thread &thread, Stream &s, bool verbose, lldb_private::ConstString plugin_name) = 0;
+  virtual void DumpTraceInfo(Thread &thread, Stream &s, bool verbose) = 0;
 
   /// Check if a thread is currently traced by this object.
   ///
   /// \param[in] thread
   ///     The thread in question.
   ///
   /// \return
   ///     \b true if the thread is traced by this instance, \b false otherwise.

lldb/source/Commands/CommandObjectThread.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/Trace.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // CommandObjectThreadBacktrace
 #define LLDB_OPTIONS_thread_backtrace
 #include "CommandOptions.inc"
public:
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_thread_trace_dump_info_options);
     }
 
     // Instance variables to hold the values for command options.
     bool m_verbose;
   };
 
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    Target &target = m_exe_ctx.GetTargetRef();
+    result.GetOutputStream().Printf(
+        "Trace technology: %s\n",
+        target.GetTrace()->GetPluginName().AsCString());
+    return CommandObjectIterateOverThreads::DoExecute(command, result);
+  }
+
   CommandObjectTraceDumpInfo(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
             interpreter, "thread trace dump info",
-            "Dump the traced info for one thread.", nullptr,
+            "Dump the traced information for one or more threads.  If no "
+            "threads are specified, show the current thread.  Use the "
+            "thread-index \"all\" to see all threads.",
+            nullptr,
             eCommandRequiresProcess | eCommandTryTargetAPILock |
                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
                 eCommandProcessMustBeTraced),
         m_options() {}
 
   ~CommandObjectTraceDumpInfo() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     const TraceSP &trace_sp = m_exe_ctx.GetTargetSP()->GetTrace();
     ThreadSP thread_sp =
         m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
     trace_sp->DumpTraceInfo(*thread_sp, result.GetOutputStream(),
-                             m_options.m_verbose,  trace_sp->GetPluginName());
+                            m_options.m_verbose);
     return true;
   }
 
   CommandOptions m_options;
 };
 
 // CommandObjectMultiwordTraceDump
 class CommandObjectMultiwordTraceDump : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordTraceDump(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "dump",
             "Commands for displaying trace information of the threads "
             "in the current process.",
             "thread trace dump <subcommand> [<subcommand objects>]") {
     LoadSubCommand(
         "instructions",
         CommandObjectSP(new CommandObjectTraceDumpInstructions(interpreter)));
     LoadSubCommand(
         "info", CommandObjectSP(new CommandObjectTraceDumpInfo(interpreter)));
   }
   ~CommandObjectMultiwordTraceDump() override = default;
 };
 
 // CommandObjectMultiwordTrace
 class CommandObjectMultiwordTrace : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordTrace(CommandInterpreter &interpreter)
       : CommandObjectMultiword(

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.h

public:
 
   lldb::CommandObjectSP
   GetThreadTraceStartCommand(CommandInterpreter &interpreter) override;
 
   llvm::StringRef GetSchema() override;
 
   lldb::TraceCursorUP GetCursor(Thread &thread) override;
 
-  void DumpTraceInfo(Thread &thread, Stream &s, bool verbose, lldb_private::ConstString plugin_name) override;
+  void DumpTraceInfo(Thread &thread, Stream &s, bool verbose) override;
 
   llvm::Optional<size_t> GetRawTraceSize(Thread &thread);
 
   void DoRefreshLiveProcessState(
       llvm::Expected<TraceGetStateResponse> state) override;
 
   bool IsTraced(const Thread &thread) override;
 

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

return std::make_shared<DecodedThread>(
         createStringError(inconvertibleErrorCode(), "thread not traced"));
   return it->second->Decode();
 }
 
 lldb::TraceCursorUP TraceIntelPT::GetCursor(Thread &thread) {
   return Decode(thread)->GetCursor();
 }
 
-void TraceIntelPT::DumpTraceInfo(Thread &thread, Stream &s, bool verbose, lldb_private::ConstString plugin_name) {
+void TraceIntelPT::DumpTraceInfo(Thread &thread, Stream &s, bool verbose) {
   Optional<size_t> raw_size = GetRawTraceSize(thread);
-  s.Printf("Tracing technology: %s\nthread #%u: tid = %" PRIu64, plugin_name.AsCString(), thread.GetIndexID(), thread.GetID());
+  s.Printf("thread #%u: tid = %" PRIu64, thread.GetIndexID(), thread.GetID());
   if (!raw_size) {
     s.Printf(", not traced\n");
     return;
   }
   s.Printf("\nRaw trace size: %zu bytes\n", *raw_size);
   return;
 }
 
 Optional<size_t> TraceIntelPT::GetRawTraceSize(Thread &thread) {
   if (IsTraced(thread))
     return Decode(thread)->GetRawTraceSize();
   else
     return None;
 }
 
 Expected<pt_cpu> TraceIntelPT::GetCPUInfoForLiveProcess() {
   Expected<std::vector<uint8_t>> cpu_info = GetLiveProcessBinaryData("cpuInfo");
   if (!cpu_info)
     return cpu_info.takeError();
 
   int64_t cpu_family = -1;

lldb/test/API/commands/trace/TestTraceDumpInfo.py

def testErrorMessages(self):
             error=True)
 
     def testDumpRawTraceSize(self):
         self.expect("trace load -v " +
         os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json"),
         substrs=["intel-pt"])
 
         self.expect("thread trace dump info",
-            substrs=['''Tracing technology: intel-pt
+            substrs=['''Trace technology: intel-pt
 thread #1: tid = 3842849
 Raw trace size: 4096 bytes'''])

lldb/test/API/commands/trace/TestTraceLoad.py

def testLoadTrace(self):
         self.assertGreater(module.GetNumSections(), 0)
         self.assertEqual(module.GetSectionAtIndex(0).GetFileAddress(), 0x400000)
 
         self.assertEqual("6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A", module.GetUUIDString())
 
         # check that the Process and Thread objects were created correctly
         self.expect("thread info", substrs=["tid = 3842849"])
         self.expect("thread list", substrs=["Process 1234 stopped", "tid = 3842849"])
-        self.expect("thread trace dump info", substrs=['''Tracing technology: intel-pt
+        self.expect("thread trace dump info", substrs=['''Trace technology: intel-pt
 thread #1: tid = 3842849
 Raw trace size: 4096 bytes'''])
 
     def testLoadInvalidTraces(self):
         src_dir = self.getSourceDir()
         # We test first an invalid type
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad.json"), error=True,
           substrs=['''error: expected object at traceSession.processes[0]