[trace][intelpt] Support system-wide tracing [22] - Some final touches

[wallace]

Summary

Having a member variable TraceIntelPT * makes it look as if it was
optional. I'm using instead a weak_ptr to indicate that it's not
optional and the object is under the ownership of TraceIntelPT.

Besides that, I've simplified the Perf aux and data buffers copying by
using vector.insert.

I'm also renaming Lookup2 to Lookup. The 2 in the name is confusing.

[wallace]

.

lldb/source/Plugins/Process/Linux/Perf.cpp

Expected<std::vector<uint8_t>> PerfEvent::GetReadOnlyDataBuffer() {
   ArrayRef<uint8_t> data = GetDataBuffer();
   uint64_t data_head = mmap_metadata.data_head;
   uint64_t data_size = mmap_metadata.data_size;
   std::vector<uint8_t> output;
   output.reserve(data.size());
 
   if (data_head > data_size) {
     uint64_t actual_data_head = data_head % data_size;
-    // The buffer has wrapped
-    for (uint64_t i = actual_data_head; i < data_size; i++)
-      output.push_back(data[i]);
-
-    for (uint64_t i = 0; i < actual_data_head; i++)
-      output.push_back(data[i]);
+    // The buffer has wrapped, so we first the oldest chunk of data
+    output.insert(output.end(), data.begin() + actual_data_head, data.end());
+    // And we we read the most recent chunk of data
+    output.insert(output.end(), data.begin(), data.begin() + actual_data_head);
   } else {
-    for (uint64_t i = 0; i < data_head; i++)
-      output.push_back(data[i]);
+    // There's been no wrapping, so we just read linearly
+    output.insert(output.end(), data.begin(), data.begin() + data_head);
   }
 
   if (was_enabled) {
     if (Error err = EnableWithIoctl())
       return std::move(err);
   }
 
   return output;
 }
 
 Expected<std::vector<uint8_t>> PerfEvent::GetReadOnlyAuxBuffer() {
   // The following code assumes that the protection level of the AUX page
   // is PROT_READ. If PROT_WRITE is used, then reading would require that
   // this piece of code updates some pointers. See more about aux_tail
   // in https://man7.org/linux/man-pages/man2/perf_event_open.2.html.
 
   bool was_enabled = m_enabled;
   if (Error err = DisableWithIoctl())
     return std::move(err);
 
   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
 
   ArrayRef<uint8_t> data = GetAuxBuffer();
   uint64_t aux_head = mmap_metadata.aux_head;
-  uint64_t aux_size = mmap_metadata.aux_size;
   std::vector<uint8_t> output;
   output.reserve(data.size());
 
   /**
    * When configured as ring buffer, the aux buffer keeps wrapping around
    * the buffer and its not possible to detect how many times the buffer
    * wrapped. Initially the buffer is filled with zeros,as shown below
    * so in order to get complete buffer we first copy firstpartsize, followed
    * by any left over part from beginning to aux_head
    *
    * aux_offset [d,d,d,d,d,d,d,d,0,0,0,0,0,0,0,0,0,0,0] aux_size
    *                 aux_head->||<- firstpartsize  ->|
    *
    * */
 
-  for (uint64_t i = aux_head; i < aux_size; i++)
-    output.push_back(data[i]);
-
-  for (uint64_t i = 0; i < aux_head; i++)
-    output.push_back(data[i]);
+  output.insert(output.end(), data.begin() + aux_head, data.end());
+  output.insert(output.end(), data.begin(), data.begin() + aux_head);
 
   if (was_enabled) {
     if (Error err = EnableWithIoctl())
       return std::move(err);
   }
 
   return output;
 }

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

 };
 
 /// Decode a raw Intel PT trace for a single thread given in \p buffer and append the decoded
 /// instructions and errors in \p decoded_thread. It uses the low level libipt
 /// library underneath.
 void DecodeSingleTraceForThread(DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
                  llvm::ArrayRef<uint8_t> buffer);
 
-/// Decode a raw Intel PT trace for a single thread that was collected in a per cpu core basis.
+/// Decode a raw Intel PT trace for a single thread that was collected in a per
+/// cpu core basis.
 ///
-/// \param[in] decoded_thread
-///   All decoded instructions, errors and events will be appended to this object.
+/// \param[out] decoded_thread
+///   All decoded instructions, errors and events will be appended to this
+///   object.
 ///
 /// \param[in] trace_intel_pt
-///   The main Trace object that contains all the information related to the trace session.
+///   The main Trace object that contains all the information related to the
+///   trace session.
 ///
 /// \param[in] buffers
 ///   A map from cpu core id to raw intel pt buffers.
 ///
 /// \param[in] executions
-///   A list of chunks of timed executions of the same given thread. It is used to identify if
-///   some executions have missing intel pt data and also to determine in which core a certain
-///   part of the execution ocurred.
+///   A list of chunks of timed executions of the same given thread. It is used
+///   to identify if some executions have missing intel pt data and also to
+///   determine in which core a certain part of the execution ocurred.
 void DecodeSystemWideTraceForThread(
     DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
     const llvm::DenseMap<lldb::cpu_id_t, llvm::ArrayRef<uint8_t>> &buffers,
     const std::vector<IntelPTThreadContinousExecution> &executions);
 
 /// Given an intel pt trace, split it in chunks delimited by PSB packets. Each of these chunks
 /// is guaranteed to have been executed continuously.
 ///

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

public:
   /// PluginInterface protocol
   /// \{
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   static void Initialize();
 
   static void Terminate();
 
-  /// Create an instance of this class.
+  /// Create an instance of this class from a trace bundle.
   ///
   /// \param[in] trace_session_file
   ///     The contents of the trace session file. See \a Trace::FindPlugin.
   ///
   /// \param[in] session_file_dir
   ///     The path to the directory that contains the session file. It's used to
   ///     resolved relative paths in the session file.
   ///
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();
 
+  TraceIntelPTSP GetSharedPtr();
+
 private:
   friend class TraceIntelPTSessionFileParser;
 
   llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
 
   /// Postmortem trace constructor
   ///
   /// \param[in] session
   ///     The definition file for the postmortem session.
   ///
   /// \param[in] traced_processes
   ///     The processes traced in the live session.
   ///
   /// \param[in] trace_threads
   ///     The threads traced in the live session. They must belong to the
   ///     processes mentioned above.
-  TraceIntelPT(JSONTraceSession &session,
-               llvm::ArrayRef<lldb::ProcessSP> traced_processes,
-               llvm::ArrayRef<lldb::ThreadPostMortemTraceSP> traced_threads);
+  ///
+  /// \return
+  ///     A TraceIntelPT shared pointer instance.
+  /// \{
+  static TraceIntelPTSP CreateInstanceForPostmortemTrace(
+      JSONTraceSession &session,
 
+  /// This constructor is used by CreateInstanceForPostmortemTrace to get the
+  /// instance ready before using shared pointers, which is a limitation of C++.
+  TraceIntelPT(JSONTraceSession &session,
+               llvm::ArrayRef<lldb::ProcessSP> traced_processes);
+  /// \}
+
   /// Constructor for live processes
   TraceIntelPT(Process &live_process) : Trace(live_process){};
 
   /// Decode the trace of the given thread that, i.e. recontruct the traced
   /// instructions.
   ///
   /// \param[in] thread
   ///     If \a thread is a \a ThreadTrace, then its internal trace file will be

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

 }
 
 Expected<TraceSP> TraceIntelPT::CreateInstanceForLiveProcess(Process &process) {
   TraceSP instance(new TraceIntelPT(process));
   process.GetTarget().SetTrace(instance);
   return instance;
 }
 
-TraceIntelPT::TraceIntelPT(JSONTraceSession &session,
-                           ArrayRef<ProcessSP> traced_processes,
-                           ArrayRef<ThreadPostMortemTraceSP> traced_threads)
-    : Trace(traced_processes, session.GetCpuIds()),
-      m_cpu_info(session.cpu_info) {
-  m_storage.tsc_conversion = session.tsc_perf_zero_conversion;
+TraceIntelPTSP TraceIntelPT::GetSharedPtr() {
+  return std::static_pointer_cast<TraceIntelPT>(shared_from_this());
+}
+
+TraceIntelPTSP TraceIntelPT::CreateInstanceForPostmortemTrace(
+    JSONTraceSession &session, ArrayRef<ProcessSP> traced_processes,
+    ArrayRef<ThreadPostMortemTraceSP> traced_threads) {
+  TraceIntelPTSP trace_sp(new TraceIntelPT(session, traced_processes));
+  trace_sp->m_storage.tsc_conversion = session.tsc_perf_zero_conversion;
 
   if (session.cpus) {
     std::vector<cpu_id_t> cpus;
 
     for (const JSONCpu &cpu : *session.cpus) {
-      SetPostMortemCpuDataFile(cpu.id, IntelPTDataKinds::kIptTrace,
+      trace_sp->SetPostMortemCpuDataFile(cpu.id, IntelPTDataKinds::kIptTrace,
                                          FileSpec(cpu.ipt_trace));
 
-      SetPostMortemCpuDataFile(cpu.id,
-                               IntelPTDataKinds::kPerfContextSwitchTrace,
-                               FileSpec(cpu.context_switch_trace));
+      trace_sp->SetPostMortemCpuDataFile(
+          cpu.id, IntelPTDataKinds::kPerfContextSwitchTrace,
       cpus.push_back(cpu.id);
     }
 
     std::vector<tid_t> tids;
     for (const JSONProcess &process : session.processes)
       for (const JSONThread &thread : process.threads)
         tids.push_back(thread.tid);
 
-    m_storage.multicpu_decoder.emplace(*this);
+    trace_sp->m_storage.multicpu_decoder.emplace(trace_sp);
   } else {
     for (const ThreadPostMortemTraceSP &thread : traced_threads) {
-      m_storage.thread_decoders.try_emplace(
-          thread->GetID(), std::make_unique<ThreadDecoder>(thread, *this));
+      trace_sp->m_storage.thread_decoders.try_emplace(
+          thread->GetID(), std::make_unique<ThreadDecoder>(thread, *trace_sp));
       if (const Optional<FileSpec> &trace_file = thread->GetTraceFile()) {
-        SetPostMortemThreadDataFile(thread->GetID(),
-                                    IntelPTDataKinds::kIptTrace, *trace_file);
+        trace_sp->SetPostMortemThreadDataFile(
+            thread->GetID(), IntelPTDataKinds::kIptTrace, *trace_file);
       }
     }
   }
+
+  for (const ProcessSP &process_sp : traced_processes)
+    process_sp->GetTarget().SetTrace(trace_sp);
+  return trace_sp;
 }
 
+TraceIntelPT::TraceIntelPT(JSONTraceSession &session,
+                           ArrayRef<ProcessSP> traced_processes)
+    : Trace(traced_processes, session.GetCpuIds()),
+      m_cpu_info(session.cpu_info) {}
+
 DecodedThreadSP TraceIntelPT::Decode(Thread &thread) {
   if (const char *error = RefreshLiveProcessState())
     return std::make_shared<DecodedThread>(
         thread.shared_from_this(),
         createStringError(inconvertibleErrorCode(), error));
 
   Storage &storage = GetUpdatedStorage();
   if (storage.multicpu_decoder)
if (!intelpt_state->cpus) {
 
     std::vector<tid_t> tids;
     for (const TraceThreadState &thread : intelpt_state->traced_threads)
       tids.push_back(thread.tid);
 
     if (!intelpt_state->tsc_perf_zero_conversion)
       return createStringError(inconvertibleErrorCode(),
                                "Missing perf time_zero conversion values");
-    m_storage.multicpu_decoder.emplace(*this);
+    m_storage.multicpu_decoder.emplace(GetSharedPtr());
   }
 
   if (m_storage.tsc_conversion) {
     Log *log = GetLog(LLDBLog::Target);
     LLDB_LOG(log, "TraceIntelPT found TSC conversion information");
   }
   return Error::success();
 }

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

 //===-- TraceIntelPTMultiCpuDecoder.h ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTMULTICPUDECODER_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTMULTICPUDECODER_H
 
 #include "LibiptDecoder.h"
 #include "PerfContextSwitchDecoder.h"
 #include "ThreadDecoder.h"
+#include "forward-declarations.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 /// Class used to decode a multi-cpu Intel PT trace. It assumes that each
 /// thread could have potentially been executed on different cpu cores. It uses
 /// a context switch trace per CPU with timestamps to identify which thread owns
 /// each Intel PT decoded instruction and in which order. It also assumes that
 /// the Intel PT data and context switches might have gaps in their traces due
 /// to contention or race conditions. Finally, it assumes that a tid is not
 /// repeated twice for two different threads because of the shortness of the
 /// intel pt trace.
 ///
 /// This object should be recreated after every stop in the case of live
 /// processes.
 class TraceIntelPTMultiCpuDecoder {
 public:
   /// \param[in] TraceIntelPT
   ///   The trace object to be decoded
-  TraceIntelPTMultiCpuDecoder(TraceIntelPT &trace);
+  TraceIntelPTMultiCpuDecoder(TraceIntelPTSP trace_sp);
 
   /// \return
   ///   A \a DecodedThread for the \p thread by decoding its instructions on all
   ///   CPUs, sorted by TSCs.
   DecodedThreadSP Decode(Thread &thread);
 
   /// \return
   ///   \b true if the given \p tid is managed by this decoder, regardless of
private:
   llvm::Error CorrelateContextSwitchesAndIntelPtTraces();
 
   /// Produce a mapping from thread ids to the list of continuos executions with
   /// their associated intel pt subtraces.
   llvm::Expected<
       llvm::DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>>
   DoCorrelateContextSwitchesAndIntelPtTraces();
 
-  TraceIntelPT *m_trace;
+  TraceIntelPTSP GetTrace();
+
+  std::weak_ptr<TraceIntelPT> m_trace_wp;
   std::set<lldb::tid_t> m_tids;
   llvm::Optional<
       llvm::DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>>
       m_continuous_executions_per_thread;
   llvm::DenseMap<lldb::tid_t, DecodedThreadSP> m_decoded_threads;
   /// This variable will be non-None if a severe error happened during the setup
   /// of the decoder and we don't want decoding to be reattempted.
   llvm::Optional<std::string> m_setup_error;
   uint64_t m_unattributed_intelpt_subtraces;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTMULTICPUDECODER_H

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

 
 #include "llvm/Support/Error.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
-TraceIntelPTMultiCpuDecoder::TraceIntelPTMultiCpuDecoder(TraceIntelPT &trace)
-    : m_trace(&trace) {
-  for (Process *proc : trace.GetAllProcesses()) {
+TraceIntelPTMultiCpuDecoder::TraceIntelPTMultiCpuDecoder(
+    TraceIntelPTSP trace_sp)
+    : m_trace_wp(trace_sp) {
+  for (Process *proc : trace_sp->GetAllProcesses()) {
     for (ThreadSP thread_sp : proc->GetThreadList().Threads()) {
       m_tids.insert(thread_sp->GetID());
     }
   }
 }
 
+TraceIntelPTSP TraceIntelPTMultiCpuDecoder::GetTrace() {
+  return m_trace_wp.lock();
+}
+
 bool TraceIntelPTMultiCpuDecoder::TracesThread(lldb::tid_t tid) const {
   return m_tids.count(tid);
 }
 
 DecodedThreadSP TraceIntelPTMultiCpuDecoder::Decode(Thread &thread) {
   if (Error err = CorrelateContextSwitchesAndIntelPtTraces())
     return std::make_shared<DecodedThread>(thread.shared_from_this(),
                                            std::move(err));
   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());
 
-  Error err = m_trace->OnAllCpusBinaryDataRead(
+  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());
         if (it != m_continuous_executions_per_thread->end())
-          DecodeSystemWideTraceForThread(*decoded_thread_sp, *m_trace, buffers,
+          DecodeSystemWideTraceForThread(*decoded_thread_sp, *trace_sp, buffers,
                                          it->second);
 
         return Error::success();
       });
   if (err)
     decoded_thread_sp->SetAsFailed(std::move(err));
 
   m_decoded_threads.try_emplace(thread.GetID(), decoded_thread_sp);
if (err)
     return std::move(err);
   return intel_pt_subtraces;
 }
 
 Expected<DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>>
 TraceIntelPTMultiCpuDecoder::DoCorrelateContextSwitchesAndIntelPtTraces() {
   DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>
       continuous_executions_per_thread;
+  TraceIntelPTSP trace_sp = GetTrace();
 
   Optional<LinuxPerfZeroTscConversion> conv_opt =
-      m_trace->GetPerfZeroTscConversion();
+      trace_sp->GetPerfZeroTscConversion();
   if (!conv_opt)
     return createStringError(
         inconvertibleErrorCode(),
         "TSC to nanoseconds conversion values were not found");
 
   LinuxPerfZeroTscConversion tsc_conversion = *conv_opt;
 
-  for (cpu_id_t cpu_id : m_trace->GetTracedCpus()) {
+  for (cpu_id_t cpu_id : trace_sp->GetTracedCpus()) {
     Expected<std::vector<IntelPTThreadSubtrace>> intel_pt_subtraces =
-        GetIntelPTSubtracesForCpu(*m_trace, cpu_id);
+        GetIntelPTSubtracesForCpu(*trace_sp, cpu_id);
     if (!intel_pt_subtraces)
       return intel_pt_subtraces.takeError();
 
     // We'll be iterating through the thread continuous executions and the intel
     // pt subtraces sorted by time.
     auto it = intel_pt_subtraces->begin();
     auto on_new_thread_execution =
         [&](const ThreadContinuousExecution &thread_execution) {
           IntelPTThreadContinousExecution execution(thread_execution);
 
           for (; it != intel_pt_subtraces->end() &&
                  it->tsc < thread_execution.GetEndTSC();
                it++) {
             if (it->tsc > thread_execution.GetStartTSC()) {
               execution.intelpt_subtraces.push_back(*it);
             } else {
               m_unattributed_intelpt_subtraces++;
             }
           }
           continuous_executions_per_thread[thread_execution.tid].push_back(
               execution);
         };
-    Error err = m_trace->OnCpuBinaryDataRead(
+    Error err = trace_sp->OnCpuBinaryDataRead(
         cpu_id, IntelPTDataKinds::kPerfContextSwitchTrace,
         [&](ArrayRef<uint8_t> data) -> Error {
           Expected<std::vector<ThreadContinuousExecution>> executions =
               DecodePerfContextSwitchTrace(data, cpu_id, tsc_conversion);
           if (!executions)
             return executions.takeError();
           for (const ThreadContinuousExecution &exec : *executions)
             on_new_thread_execution(exec);

 
 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 = m_trace->GetTimer().ForGlobal().TimeTask<Error>(
+  Error err = GetTrace()->GetTimer().ForGlobal().TimeTask<Error>(
       "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();
         }
       });

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

Expected<TraceSP> TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
   std::vector<ThreadPostMortemTraceSP> threads;
   std::vector<ProcessSP> processes;
   for (const ParsedProcess &parsed_process : parsed_processes) {
     processes.push_back(parsed_process.target_sp->GetProcessSP());
     threads.insert(threads.end(), parsed_process.threads.begin(),
                    parsed_process.threads.end());
   }
 
-  TraceSP trace_instance(new TraceIntelPT(session, processes, threads));
+  TraceSP trace_instance = TraceIntelPT::CreateInstanceForPostmortemTrace(
+      session, processes, threads);
   for (const ParsedProcess &parsed_process : parsed_processes)
     parsed_process.target_sp->SetTrace(trace_instance);
 
   return trace_instance;
 }
 
 void TraceIntelPTSessionFileParser::NormalizeAllPaths(
     JSONTraceSession &session) {

lldb/source/Plugins/Trace/intel-pt/forward-declarations.h

 //===-- forward-declarations.h ----------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_FORWARD_DECLARATIONS_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_FORWARD_DECLARATIONS_H
 
+#include <memory>
+
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT;
 class ThreadDecoder;
 
+using TraceIntelPTSP = std::shared_ptr<TraceIntelPT>;
+
 } // namespace trace_intel_pt
 } // namespace lldb_private
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_FORWARD_DECLARATIONS_H

lldb/source/Target/Trace.cpp

 template <typename K, typename V>
 static V *LookupAsPtr(DenseMap<K, V> &map, K k) {
   auto it = map.find(k);
   if (it == map.end())
     return nullptr;
   return &it->second;
 }
 
+/// Similar to the methods above but it looks for an item in a map of maps.
 template <typename K1, typename K2, typename V>
-static Optional<V> Lookup2(DenseMap<K1, DenseMap<K2, V>> &map, K1 k1, K2 k2) {
+static Optional<V> Lookup(DenseMap<K1, DenseMap<K2, V>> &map, K1 k1, K2 k2) {
   auto it = map.find(k1);
   if (it == map.end())
     return None;
   return Lookup(it->second, k2);
 }
 
+/// Similar to the methods above but it looks for an item in a map of maps.
 template <typename K1, typename K2, typename V>
-static V *Lookup2AsPtr(DenseMap<K1, DenseMap<K2, V>> &map, K1 k1, K2 k2) {
+static V *LookupAsPtr(DenseMap<K1, DenseMap<K2, V>> &map, K1 k1, K2 k2) {
   auto it = map.find(k1);
   if (it == map.end())
     return nullptr;
   return LookupAsPtr(it->second, k2);
 }
 /// \}
 
 static Error createInvalidPlugInError(StringRef plugin_name) {
return createStringError(
         inconvertibleErrorCode(),
         "Attempted to fetch live trace information without a live process.");
   return m_live_process->TraceGetState(GetPluginName());
 }
 
 Optional<uint64_t> Trace::GetLiveThreadBinaryDataSize(lldb::tid_t tid,
                                                       llvm::StringRef kind) {
   Storage &storage = GetUpdatedStorage();
-  return Lookup2(storage.live_thread_data, tid, ConstString(kind));
+  return Lookup(storage.live_thread_data, tid, ConstString(kind));
 }
 
 Optional<uint64_t> Trace::GetLiveCpuBinaryDataSize(lldb::cpu_id_t cpu_id,
                                                    llvm::StringRef kind) {
   Storage &storage = GetUpdatedStorage();
-  return Lookup2(storage.live_cpu_data_sizes, cpu_id, ConstString(kind));
+  return Lookup(storage.live_cpu_data_sizes, cpu_id, ConstString(kind));
 }
 
 Optional<uint64_t> Trace::GetLiveProcessBinaryDataSize(llvm::StringRef kind) {
   Storage &storage = GetUpdatedStorage();
   return Lookup(storage.live_process_data, ConstString(kind));
 }
 
 Expected<std::vector<uint8_t>>
uint32_t Trace::GetStopID() {
   RefreshLiveProcessState();
   return m_stop_id;
 }
 
 llvm::Expected<FileSpec>
 Trace::GetPostMortemThreadDataFile(lldb::tid_t tid, llvm::StringRef kind) {
   Storage &storage = GetUpdatedStorage();
   if (Optional<FileSpec> file =
-          Lookup2(storage.postmortem_thread_data, tid, ConstString(kind)))
+          Lookup(storage.postmortem_thread_data, tid, ConstString(kind)))
     return *file;
   else
     return createStringError(
         inconvertibleErrorCode(),
         formatv("The thread with tid={0} doesn't have the tracing data {1}",
                 tid, kind));
 }
 
 llvm::Expected<FileSpec> Trace::GetPostMortemCpuDataFile(lldb::cpu_id_t cpu_id,
                                                          llvm::StringRef kind) {
   Storage &storage = GetUpdatedStorage();
   if (Optional<FileSpec> file =
-          Lookup2(storage.postmortem_cpu_data, cpu_id, ConstString(kind)))
+          Lookup(storage.postmortem_cpu_data, cpu_id, ConstString(kind)))
     return *file;
   else
     return createStringError(
         inconvertibleErrorCode(),
         formatv("The cpu with id={0} doesn't have the tracing data {1}", cpu_id,
                 kind));
 }
 
Trace::OnLiveThreadBinaryDataRead(lldb::tid_t tid, llvm::StringRef kind,
   return callback(*data);
 }
 
 llvm::Error Trace::OnLiveCpuBinaryDataRead(lldb::cpu_id_t cpu_id,
                                            llvm::StringRef kind,
                                            OnBinaryDataReadCallback callback) {
   Storage &storage = GetUpdatedStorage();
   if (std::vector<uint8_t> *cpu_data =
-          Lookup2AsPtr(storage.live_cpu_data, cpu_id, ConstString(kind)))
+          LookupAsPtr(storage.live_cpu_data, cpu_id, ConstString(kind)))
     return callback(*cpu_data);
 
   Expected<std::vector<uint8_t>> data = GetLiveCpuBinaryData(cpu_id, kind);
   if (!data)
     return data.takeError();
   auto it = storage.live_cpu_data[cpu_id].insert(
       {ConstString(kind), std::move(*data)});
   return callback(it.first->second);