[trace][intel pt] Measure the time it takes to decode a thread in per-cpu mode

[wallace]

Summary

This metric was missing. We were only measuring in per-thread mode, and
this completes the work.

For a sample trace I have, the dump info command shows

Timing for this thread:
    Decoding instructions: 0.12s

I also improved a bit the TaskTime function so that callers don't need to
specify the template argument

[jj10306]

lgtm

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

public:
   /// \param[in] name
   ///     The name used to identify this task for reporting.
   ///
   /// \param[in] task
   ///     The task function.
   ///
   /// \return
   ///     The return value of the task.
-  template <class R> R TimeTask(llvm::StringRef name, std::function<R()> task) {
+  template <typename C> auto TimeTask(llvm::StringRef name, C task) {
     auto start = std::chrono::steady_clock::now();
-    R result = task();
+    auto result = task();
     auto end = std::chrono::steady_clock::now();
     std::chrono::milliseconds duration =
         std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
     m_timed_tasks.insert({name.str(), duration});
     return result;
   }
 
   /// Executive the given \p callback on each recorded task.

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

if (!m_decoded_thread.hasValue()) {
     } else {
       return decoded_thread.takeError();
     }
   }
   return *m_decoded_thread;
 }
 
 llvm::Expected<DecodedThreadSP> ThreadDecoder::DoDecode() {
-  return m_trace.GetTimer()
-      .ForThread(m_thread_sp->GetID())
-      .TimeTask<Expected<DecodedThreadSP>>(
+  return m_trace.GetThreadTimer(m_thread_sp->GetID())
+      .TimeTask(
           "Decoding instructions", [&]() -> Expected<DecodedThreadSP> {
             DecodedThreadSP decoded_thread_sp =
                 std::make_shared<DecodedThread>(m_thread_sp);
 
             Error err = m_trace.OnThreadBufferRead(
                 m_thread_sp->GetID(), [&](llvm::ArrayRef<uint8_t> data) {
                   return DecodeSingleTraceForThread(*decoded_thread_sp, m_trace,
                                                     data);
                 });
 
             if (err)
               return std::move(err);
             return decoded_thread_sp;
           });
 }

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

public:
 
   /// Get or fetch the values used to convert to and from TSCs and nanos.
   llvm::Optional<LinuxPerfZeroTscConversion> GetPerfZeroTscConversion();
 
   /// \return
   ///     The timer object for this trace.
   TaskTimer &GetTimer();
 
+  /// \return
+  ///     The ScopedTaskTimer object for the given thread in this trace.
+  ScopedTaskTimer &GetThreadTimer(lldb::tid_t tid);
+
+  /// \return
+  ///     The global copedTaskTimer object for this trace.
+  ScopedTaskTimer &GetGlobalTimer();
+
   TraceIntelPTSP GetSharedPtr();
 
 private:
   friend class TraceIntelPTBundleLoader;
 
   llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
 
   /// Postmortem trace constructor

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

void TraceIntelPT::DumpTraceInfo(Thread &thread, Stream &s, bool verbose) {
 
   // Timing
   {
     s << "\n  Timing for this thread:\n";
     auto print_duration = [&](const std::string &name,
                               std::chrono::milliseconds duration) {
       s.Format("    {0}: {1:2}s\n", name, duration.count() / 1000.0);
     };
-    GetTimer().ForThread(tid).ForEachTimedTask(print_duration);
+    GetThreadTimer(tid).ForEachTimedTask(print_duration);
 
     s << "\n  Timing for global tasks:\n";
-    GetTimer().ForGlobal().ForEachTimedTask(print_duration);
+    GetGlobalTimer().ForEachTimedTask(print_duration);
   }
 
   // Instruction events stats
   {
     const DecodedThread::EventsStats &events_stats =
         decoded_thread_sp->GetEventsStats();
     s << "\n  Events:\n";
     s.Format("    Number of individual events: {0}\n",

 }
 
 Error TraceIntelPT::OnThreadBufferRead(lldb::tid_t tid,
                                        OnBinaryDataReadCallback callback) {
   return OnThreadBinaryDataRead(tid, IntelPTDataKinds::kIptTrace, callback);
 }
 
 TaskTimer &TraceIntelPT::GetTimer() { return GetUpdatedStorage().task_timer; }
+
+ScopedTaskTimer &TraceIntelPT::GetThreadTimer(lldb::tid_t tid) {
+  return GetTimer().ForThread(tid);
+}
+
+ScopedTaskTimer &TraceIntelPT::GetGlobalTimer() {
+  return GetTimer().ForGlobal();
+}

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

 bool TraceIntelPTMultiCpuDecoder::TracesThread(lldb::tid_t tid) const {
   return m_tids.count(tid);
 }
 
 Expected<DecodedThreadSP> TraceIntelPTMultiCpuDecoder::Decode(Thread &thread) {
   if (Error err = CorrelateContextSwitchesAndIntelPtTraces())
     return std::move(err);
 
+  TraceIntelPTSP trace_sp = GetTrace();
+
+  return trace_sp
+      ->GetThreadTimer(thread.GetID())
+      .TimeTask("Decoding instructions", [&]() -> Expected<DecodedThreadSP> {
         auto it = m_decoded_threads.find(thread.GetID());
         if (it != m_decoded_threads.end())
           return it->second;
 
         DecodedThreadSP decoded_thread_sp =
             std::make_shared<DecodedThread>(thread.shared_from_this());
 
-  TraceIntelPTSP trace_sp = GetTrace();
-
         Error err = trace_sp->OnAllCpusBinaryDataRead(
             IntelPTDataKinds::kIptTrace,
             [&](const DenseMap<cpu_id_t, ArrayRef<uint8_t>> &buffers) -> Error {
-        auto it = m_continuous_executions_per_thread->find(thread.GetID());
+              auto it =
+                  m_continuous_executions_per_thread->find(thread.GetID());
               if (it != m_continuous_executions_per_thread->end())
-          return DecodeSystemWideTraceForThread(*decoded_thread_sp, *trace_sp,
-                                                buffers, it->second);
+                return DecodeSystemWideTraceForThread(
+                    *decoded_thread_sp, *trace_sp, buffers, it->second);
 
               return Error::success();
             });
         if (err)
           return std::move(err);
 
         m_decoded_threads.try_emplace(thread.GetID(), decoded_thread_sp);
         return decoded_thread_sp;
+      });
 }
 
 static Expected<std::vector<IntelPTThreadSubtrace>>
 GetIntelPTSubtracesForCpu(TraceIntelPT &trace, cpu_id_t cpu_id) {
   std::vector<IntelPTThreadSubtrace> intel_pt_subtraces;
   Error err = trace.OnCpuBinaryDataRead(
       cpu_id, IntelPTDataKinds::kIptTrace,
       [&](ArrayRef<uint8_t> data) -> Error {

 
 Error TraceIntelPTMultiCpuDecoder::CorrelateContextSwitchesAndIntelPtTraces() {
   if (m_setup_error)
     return createStringError(inconvertibleErrorCode(), m_setup_error->c_str());
 
   if (m_continuous_executions_per_thread)
     return Error::success();
 
-  Error err = GetTrace()->GetTimer().ForGlobal().TimeTask<Error>(
+  Error err = GetTrace()->GetGlobalTimer().TimeTask(
       "Context switch and Intel PT traces correlation", [&]() -> Error {
         if (auto correlation = DoCorrelateContextSwitchesAndIntelPtTraces()) {
           m_continuous_executions_per_thread.emplace(std::move(*correlation));
           return Error::success();
         } else {
           return correlation.takeError();
         }
       });