[NFC][lldb][trace] Rename trace session to trace bundle

[wallace]

Summary

As previously discussed with @jj10306, we didn't really have a name for
the post-mortem (or offline) trace session representation, which is in
fact a folder with a bunch of files. We decided to call this folder
"trace bundle", and the main JSON file in it "trace bundle description
file". This naming is pretty decent, so I'm refactoring all the existing
code to account for that.

[jj10306]

lgtm - thanks for doing this renaming 🙂

lldb/include/lldb/Core/PluginManager.h

346

nit: FromBundle makes more sense than ForBundle imo

[wallace]

lldb/include/lldb/Core/PluginManager.h

346

makes sense! will do

lldb/include/lldb/Core/PluginManager.h

public:
   static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
 
   static SymbolVendorCreateInstance
   GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
 
   // Trace
   static bool RegisterPlugin(
       llvm::StringRef name, llvm::StringRef description,
-      TraceCreateInstanceForSessionFile create_callback_for_session_file,
+      TraceCreateInstanceFromBundle create_callback_from_bundle,
       TraceCreateInstanceForLiveProcess create_callback_for_live_process,
       llvm::StringRef schema);
 
   static bool
-  UnregisterPlugin(TraceCreateInstanceForSessionFile create_callback);
+  UnregisterPlugin(TraceCreateInstanceFromBundle create_callback);
 
-  static TraceCreateInstanceForSessionFile
+  static TraceCreateInstanceFromBundle
   GetTraceCreateCallback(llvm::StringRef plugin_name);
 
   static TraceCreateInstanceForLiveProcess
   GetTraceCreateCallbackForLiveProcess(llvm::StringRef plugin_name);
 
-  /// Get the JSON schema for a trace session file corresponding to the given
-  /// plugin.
+  /// Get the JSON schema for a trace bundle description file corresponding to
+  /// the given plugin.
   ///
   /// \param[in] plugin_name
   ///     The name of the plugin.
   ///
   /// \return
   ///     An empty \a StringRef if no plugin was found with that plugin name,
   ///     otherwise the actual schema is returned.
   static llvm::StringRef GetTraceSchema(llvm::StringRef plugin_name);
 
-  /// Get the JSON schema for a trace session file corresponding to the plugin
-  /// given by its index.
+  /// Get the JSON schema for a trace bundle description file corresponding to
+  /// the plugin given by its index.
   ///
   /// \param[in] index
   ///     The index of the plugin to get the schema of.
   ///
   /// \return
   ///     An empty \a StringRef if the index is greater than or equal to the
   ///     number plugins, otherwise the actual schema is returned.
   static llvm::StringRef GetTraceSchema(size_t index);

lldb/include/lldb/Target/Trace.h

public:
   ///     - CPU information
   ///     - Custom plug-in information needed to decode the trace information
   ///       correctly.
   ///
   /// \param[in] debugger
   ///     The debugger instance where new Targets will be created as part of the
   ///     JSON data parsing.
   ///
-  /// \param[in] trace_session_file
-  ///     The contents of the trace session file describing the trace session.
-  ///     See \a TraceSessionFileParser::BuildSchema for more information about
-  ///     the schema of this JSON file.
-  ///
-  /// \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.
+  /// \param[in] bundle_description
+  ///     The trace bundle description object describing the trace session.
+  ///
+  /// \param[in] bundle_dir
+  ///     The path to the directory that contains the trace bundle.
   static llvm::Expected<lldb::TraceSP>
   FindPluginForPostMortemProcess(Debugger &debugger,
-                                 const llvm::json::Value &trace_session_file,
+                                 const llvm::json::Value &bundle_description,
                                  llvm::StringRef session_file_dir);
 
   /// Find a trace plug-in to trace a live process.
   ///
   /// \param[in] plugin_name
   ///     Plug-in name to search.
   ///
   /// \param[in] process

lldb/include/lldb/lldb-private-interfaces.h

 typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,
                                            lldb::LanguageType language,
                                            Debugger *debugger, Target *target,
                                            const char *repl_options);
 typedef int (*ComparisonFunction)(const void *, const void *);
 typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
 /// Trace
 /// \{
-typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForSessionFile)(
-    const llvm::json::Value &trace_session_file,
+typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceFromBundle)(
+    const llvm::json::Value &trace_bundle_description,
     llvm::StringRef session_file_dir, lldb_private::Debugger &debugger);
 typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstanceForLiveProcess)(
     Process &process);
 typedef llvm::Expected<lldb::TraceExporterUP> (*TraceExporterCreateInstance)();
 typedef lldb::CommandObjectSP (*ThreadTraceExportCommandCreator)(
     CommandInterpreter &interpreter);
 /// \}
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_INTERFACES_H

lldb/source/Commands/CommandObjectTrace.cpp

public:
     ArrayRef<OptionDefinition> GetDefinitions() override {
       return makeArrayRef(g_trace_load_options);
     }
 
     bool m_verbose; // Enable verbose logging for debugging purposes.
   };
 
   CommandObjectTraceLoad(CommandInterpreter &interpreter)
-      : CommandObjectParsed(interpreter, "trace load",
-                            "Load a processor trace session from a JSON file.",
-                            "trace load") {}
+      : CommandObjectParsed(
+            interpreter, "trace load",
+            "Load a post-mortem processor trace session from a trace bundle.",
 
   ~CommandObjectTraceLoad() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (command.size() != 1) {
-      result.AppendError(
-          "a single path to a JSON file containing a trace session"
-          " is required");
+      result.AppendError("a single path to a JSON file containing a the "
+                         "description of the trace bundle is required");
       return false;
     }
 
     const FileSpec trace_description_file(command[0].ref());
 
     llvm::Expected<lldb::TraceSP> trace_or_err =
         Trace::LoadPostMortemTraceFromFile(GetDebugger(),
                                            trace_description_file);

lldb/source/Core/PluginManager.cpp

 SymbolVendorCreateInstance
 PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
   return GetSymbolVendorInstances().GetCallbackAtIndex(idx);
 }
 
 #pragma mark Trace
 
 struct TraceInstance
-    : public PluginInstance<TraceCreateInstanceForSessionFile> {
+    : public PluginInstance<TraceCreateInstanceFromBundle> {
   TraceInstance(
       llvm::StringRef name, llvm::StringRef description,
-      CallbackType create_callback_for_session_file,
+      CallbackType create_callback_from_bundle,
       TraceCreateInstanceForLiveProcess create_callback_for_live_process,
       llvm::StringRef schema)
-      : PluginInstance<TraceCreateInstanceForSessionFile>(
-            name, description, create_callback_for_session_file),
+      : PluginInstance<TraceCreateInstanceFromBundle>(
+            name, description, create_callback_from_bundle),
         schema(schema),
         create_callback_for_live_process(create_callback_for_live_process) {}
 
   llvm::StringRef schema;
   TraceCreateInstanceForLiveProcess create_callback_for_live_process;
 };
 
 typedef PluginInstances<TraceInstance> TraceInstances;
 
 static TraceInstances &GetTracePluginInstances() {
   static TraceInstances g_instances;
   return g_instances;
 }
 
 bool PluginManager::RegisterPlugin(
     llvm::StringRef name, llvm::StringRef description,
-    TraceCreateInstanceForSessionFile create_callback_for_session_file,
+    TraceCreateInstanceFromBundle create_callback_from_bundle,
     TraceCreateInstanceForLiveProcess create_callback_for_live_process,
     llvm::StringRef schema) {
   return GetTracePluginInstances().RegisterPlugin(
-      name, description, create_callback_for_session_file,
+      name, description, create_callback_from_bundle,
       create_callback_for_live_process, schema);
 }
 
 bool PluginManager::UnregisterPlugin(
-    TraceCreateInstanceForSessionFile create_callback_for_session_file) {
+    TraceCreateInstanceFromBundle create_callback_from_bundle) {
   return GetTracePluginInstances().UnregisterPlugin(
-      create_callback_for_session_file);
+      create_callback_from_bundle);
 }
 
-TraceCreateInstanceForSessionFile
+TraceCreateInstanceFromBundle
 PluginManager::GetTraceCreateCallback(llvm::StringRef plugin_name) {
   return GetTracePluginInstances().GetCallbackForName(plugin_name);
 }
 
 TraceCreateInstanceForLiveProcess
 PluginManager::GetTraceCreateCallbackForLiveProcess(llvm::StringRef plugin_name) {
   for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
     if (instance.name == plugin_name)

lldb/source/Plugins/Trace/common/ThreadPostMortemTrace.h

 
 namespace lldb_private {
 
 /// \class ThreadPostMortemTrace ThreadPostMortemTrace.h
 ///
 /// Thread implementation used for representing threads gotten from trace
 /// session files, which are similar to threads from core files.
 ///
-/// See \a TraceSessionFileParser for more information regarding trace session
-/// files.
 class ThreadPostMortemTrace : public Thread {
 public:
   /// \param[in] process
   ///     The process who owns this thread.
   ///
   /// \param[in] tid
   ///     The tid of this thread.
   ///

lldb/source/Plugins/Trace/intel-pt/CMakeLists.txt

add_lldb_library(lldbPluginTraceIntelPT PLUGIN
   TaskTimer.cpp
   LibiptDecoder.cpp
   PerfContextSwitchDecoder.cpp
   ThreadDecoder.cpp
   TraceCursorIntelPT.cpp
   TraceIntelPT.cpp
   TraceIntelPTJSONStructs.cpp
   TraceIntelPTMultiCpuDecoder.cpp
-  TraceIntelPTSessionFileParser.cpp
-  TraceIntelPTSessionSaver.cpp
+  TraceIntelPTBundleLoader.cpp
+  TraceIntelPTBundleSaver.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbTarget
     lldbPluginTraceCommon
     ${LIBIPT_LIBRARY}
   LINK_COMPONENTS
     Support
   )
 
 
 add_dependencies(lldbPluginTraceIntelPT TraceIntelPTOptionsGen)

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

 //===-- TraceCursorIntelPT.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_TRACECURSORINTELPT_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACECURSORINTELPT_H
 
 #include "ThreadDecoder.h"
-#include "TraceIntelPTSessionFileParser.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceCursorIntelPT : public TraceCursor {
 public:
   TraceCursorIntelPT(lldb::ThreadSP thread_sp,
                      DecodedThreadSP decoded_thread_sp);

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

 //===-- TraceIntelPT.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_TRACEINTELPT_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H
 
 #include "TaskTimer.h"
 #include "ThreadDecoder.h"
 #include "TraceIntelPTMultiCpuDecoder.h"
-#include "TraceIntelPTSessionFileParser.h"
+#include "TraceIntelPTBundleLoader.h"
 
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
public:
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   static void Initialize();
 
   static void Terminate();
 
   /// 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] trace_bundle_description
+  ///     The description of the trace bundle. 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.
+  /// \param[in] bundle_dir
+  ///     The path to the directory that contains the trace bundle.
   ///
   /// \param[in] debugger
   ///     The debugger instance where new Targets will be created as part of the
   ///     JSON data parsing.
   ///
   /// \return
   ///     A trace instance or an error in case of failures.
   static llvm::Expected<lldb::TraceSP>
-  CreateInstanceForSessionFile(const llvm::json::Value &trace_session_file,
-                               llvm::StringRef session_file_dir,
+  CreateInstanceForTraceBundle(const llvm::json::Value &trace_bundle_description,
+                               llvm::StringRef bundle_dir,
                                Debugger &debugger);
 
   static llvm::Expected<lldb::TraceSP>
   CreateInstanceForLiveProcess(Process &process);
 
   static llvm::StringRef GetPluginNameStatic() { return "intel-pt"; }
   /// \}
 
public:
 
   /// \return
   ///     The timer object for this trace.
   TaskTimer &GetTimer();
 
   TraceIntelPTSP GetSharedPtr();
 
 private:
-  friend class TraceIntelPTSessionFileParser;
+  friend class TraceIntelPTBundleLoader;
 
   llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
 
   /// Postmortem trace constructor
   ///
-  /// \param[in] session
-  ///     The definition file for the postmortem session.
+  /// \param[in] bundle_description
+  ///     The definition file for the postmortem bundle.
   ///
   /// \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.
   ///
   /// \return
   ///     A TraceIntelPT shared pointer instance.
   /// \{
   static TraceIntelPTSP CreateInstanceForPostmortemTrace(
-      JSONTraceSession &session,
+      JSONTraceBundleDescription &bundle_description,
       llvm::ArrayRef<lldb::ProcessSP> traced_processes,
       llvm::ArrayRef<lldb::ThreadPostMortemTraceSP> traced_threads);
 
   /// This constructor is used by CreateInstanceForPostmortemTrace to get the
   /// instance ready before using shared pointers, which is a limitation of C++.
-  TraceIntelPT(JSONTraceSession &session,
+  TraceIntelPT(JSONTraceBundleDescription &bundle_description,
                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.
private:
   /// This variable should only be accessed directly by constructores or live
   /// process data refreshers.
   struct Storage {
     llvm::Optional<TraceIntelPTMultiCpuDecoder> multicpu_decoder;
     /// These decoders are used for the non-per-cpu case
     llvm::DenseMap<lldb::tid_t, std::unique_ptr<ThreadDecoder>> thread_decoders;
     /// Helper variable used to track long running operations for telemetry.
     TaskTimer task_timer;
-    /// It is provided by either a session file or a live process to convert TSC
+    /// It is provided by either a trace bundle or a live process to convert TSC
     /// counters to and from nanos. It might not be available on all hosts.
     llvm::Optional<LinuxPerfZeroTscConversion> tsc_conversion;
   } m_storage;
 
-  /// It is provided by either a session file or a live process' "cpuInfo"
+  /// It is provided by either a trace bundle or a live process' "cpuInfo"
   /// binary data. We don't put it in the Storage because this variable doesn't
   /// change.
   llvm::Optional<pt_cpu> m_cpu_info;
 
   /// Get the storage after refreshing the data in the case of a live process.
   Storage &GetUpdatedStorage();
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H

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

 //===-- TraceIntelPT.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 "TraceIntelPT.h"
 
 #include "../common/ThreadPostMortemTrace.h"
 #include "CommandObjectTraceStartIntelPT.h"
 #include "DecodedThread.h"
 #include "TraceIntelPTConstants.h"
-#include "TraceIntelPTSessionFileParser.h"
-#include "TraceIntelPTSessionSaver.h"
+#include "TraceIntelPTBundleLoader.h"
+#include "TraceIntelPTBundleSaver.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "llvm/ADT/None.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;

 lldb::CommandObjectSP
 TraceIntelPT::GetThreadTraceStartCommand(CommandInterpreter &interpreter) {
   return CommandObjectSP(
       new CommandObjectThreadTraceStartIntelPT(*this, interpreter));
 }
 
 void TraceIntelPT::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "Intel Processor Trace",
-                                CreateInstanceForSessionFile,
+                                CreateInstanceForTraceBundle,
                                 CreateInstanceForLiveProcess,
-                                TraceIntelPTSessionFileParser::GetSchema());
+                                TraceIntelPTBundleLoader::GetSchema());
 }
 
 void TraceIntelPT::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstanceForSessionFile);
+  PluginManager::UnregisterPlugin(CreateInstanceForTraceBundle);
 }
 
 StringRef TraceIntelPT::GetSchema() {
-  return TraceIntelPTSessionFileParser::GetSchema();
+  return TraceIntelPTBundleLoader::GetSchema();
 }
 
 void TraceIntelPT::Dump(Stream *s) const {}
 
 llvm::Error TraceIntelPT::SaveLiveTraceToDisk(FileSpec directory) {
   RefreshLiveProcessState();
-  return TraceIntelPTSessionSaver().SaveToDisk(*this, directory);
+  return TraceIntelPTBundleSaver().SaveToDisk(*this, directory);
 }
 
-Expected<TraceSP> TraceIntelPT::CreateInstanceForSessionFile(
-    const json::Value &trace_session_file, StringRef session_file_dir,
+Expected<TraceSP> TraceIntelPT::CreateInstanceForTraceBundle(
+    const json::Value &bundle_description, StringRef bundle_dir,
     Debugger &debugger) {
-  return TraceIntelPTSessionFileParser(debugger, trace_session_file,
-                                       session_file_dir)
-      .Parse();
+  return TraceIntelPTBundleLoader(debugger, bundle_description,
+                                       bundle_dir)
+      .Load();
 }
 
 Expected<TraceSP> TraceIntelPT::CreateInstanceForLiveProcess(Process &process) {
   TraceSP instance(new TraceIntelPT(process));
   process.GetTarget().SetTrace(instance);
   return instance;
 }
 
 TraceIntelPTSP TraceIntelPT::GetSharedPtr() {
   return std::static_pointer_cast<TraceIntelPT>(shared_from_this());
 }
 
 TraceIntelPTSP TraceIntelPT::CreateInstanceForPostmortemTrace(
-    JSONTraceSession &session, ArrayRef<ProcessSP> traced_processes,
+    JSONTraceBundleDescription &bundle_description, 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;
+  TraceIntelPTSP trace_sp(new TraceIntelPT(bundle_description, traced_processes));
+  trace_sp->m_storage.tsc_conversion = bundle_description.tsc_perf_zero_conversion;
 
-  if (session.cpus) {
+  if (bundle_description.cpus) {
     std::vector<cpu_id_t> cpus;
 
-    for (const JSONCpu &cpu : *session.cpus) {
+    for (const JSONCpu &cpu : *bundle_description.cpus) {
       trace_sp->SetPostMortemCpuDataFile(cpu.id, IntelPTDataKinds::kIptTrace,
                                          FileSpec(cpu.ipt_trace));
 
       trace_sp->SetPostMortemCpuDataFile(
           cpu.id, IntelPTDataKinds::kPerfContextSwitchTrace,
           FileSpec(cpu.context_switch_trace));
       cpus.push_back(cpu.id);
     }
 
     std::vector<tid_t> tids;
-    for (const JSONProcess &process : session.processes)
+    for (const JSONProcess &process : bundle_description.processes)
       for (const JSONThread &thread : process.threads)
         tids.push_back(thread.tid);
 
     trace_sp->m_storage.multicpu_decoder.emplace(trace_sp);
   } else {
     for (const ThreadPostMortemTraceSP &thread : traced_threads) {
       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()) {
         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,
+TraceIntelPT::TraceIntelPT(JSONTraceBundleDescription &bundle_description,
                            ArrayRef<ProcessSP> traced_processes)
-    : Trace(traced_processes, session.GetCpuIds()),
-      m_cpu_info(session.cpu_info) {}
+    : Trace(traced_processes, bundle_description.GetCpuIds()),
+      m_cpu_info(bundle_description.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();

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

-//===-- TraceIntelPTSessionFileParser.h -----------------------*- C++ //-*-===//
+//===-- TraceIntelPTBundleLoader.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_TRACEINTELPTSESSIONFILEPARSER_H
-#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H
+#ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLELOADER_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLELOADER_H
 
 #include "../common/ThreadPostMortemTrace.h"
 #include "TraceIntelPTJSONStructs.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT;
 
-class TraceIntelPTSessionFileParser {
+class TraceIntelPTBundleLoader {
 public:
   /// Helper struct holding the objects created when parsing a process
   struct ParsedProcess {
     lldb::TargetSP target_sp;
     std::vector<lldb::ThreadPostMortemTraceSP> threads;
   };
 
   /// \param[in] debugger
   ///   The debugger that will own the targets to create.
   ///
-  /// \param[in] trace_session_file
-  ///   The contents of the main trace session definition file that follows the
-  ///   schema of the intel pt trace plug-in.
-  ///
-  /// \param[in] session_file_dir
-  ///   The folder where the trace session file is located.
-  TraceIntelPTSessionFileParser(Debugger &debugger,
-                                const llvm::json::Value &trace_session_file,
-                                llvm::StringRef session_file_dir)
-      : m_debugger(debugger), m_trace_session_file(trace_session_file),
-        m_session_file_dir(session_file_dir) {}
+  /// \param[in] bundle_description
+  ///   The JSON description of a trace bundle that follows the schema of the intel pt trace plug-in.
+  ///
+  /// \param[in] bundle_dir
+  ///   The folder where the trace bundle is located.
+  TraceIntelPTBundleLoader(Debugger &debugger,
+                                const llvm::json::Value &bundle_description,
+                                llvm::StringRef bundle_dir)
+      : m_debugger(debugger), m_bundle_description(bundle_description),
+        m_bundle_dir(bundle_dir) {}
 
   /// \return
-  ///   The JSON schema for the session data.
+  ///   The JSON schema for the bundle description.
   static llvm::StringRef GetSchema();
 
-  /// Parse the structured data trace session and create the corresponding \a
+  /// Parse the trace bundle description and create the corresponding \a
   /// Target objects. In case of an error, no targets are created.
   ///
   /// \return
-  ///   A \a lldb::TraceSP instance with the trace session data. In case of
+  ///   A \a lldb::TraceSP instance created according to the trace bundle information. In case of
   ///   errors, return a null pointer.
-  llvm::Expected<lldb::TraceSP> Parse();
+  llvm::Expected<lldb::TraceSP> Load();
 
 private:
-  /// Resolve non-absolute paths relative to the session file folder.
+  /// Resolve non-absolute paths relative to the bundle folder.
   FileSpec NormalizePath(const std::string &path);
 
   /// Create a post-mortem thread associated with the given \p process
   /// using the definition from \p thread.
   lldb::ThreadPostMortemTraceSP ParseThread(Process &process,
                                             const JSONThread &thread);
 
-  /// Given a session description and a list of fully parsed processes,
+  /// Given a bundle description and a list of fully parsed processes,
   /// create an actual Trace instance that "traces" these processes.
   llvm::Expected<lldb::TraceSP>
-  CreateTraceIntelPTInstance(JSONTraceSession &session,
+  CreateTraceIntelPTInstance(JSONTraceBundleDescription &bundle_description,
                              std::vector<ParsedProcess> &parsed_processes);
 
   /// Create the corresponding Threads and Process objects given the JSON
   /// process definition.
   ///
   /// \param[in] process
   ///   The JSON process definition
   llvm::Expected<ParsedProcess> ParseProcess(const JSONProcess &process);
 
-  /// Create a moddule associated with the given \p target
-  /// using the definition from \p module.
+  /// Create a module associated with the given \p target using the definition from \p module.
   llvm::Error ParseModule(Target &target, const JSONModule &module);
 
   /// Create a user-friendly error message upon a JSON-parsing failure using the
   /// \a json::ObjectMapper functionality.
   ///
   /// \param[in] root
   ///   The \a llvm::json::Path::Root used to parse the JSON \a value.
   ///
   /// \param[in] value
   ///   The json value that failed to parse.
   ///
   /// \return
   ///   An \a llvm::Error containing the user-friendly error message.
   llvm::Error CreateJSONError(llvm::json::Path::Root &root,
                               const llvm::json::Value &value);
 
   /// Create the corresponding Process, Thread and Module objects given this
-  /// session file.
+  /// bundle description.
   llvm::Expected<std::vector<ParsedProcess>>
-  ParseSessionFile(const JSONTraceSession &session);
+  LoadBundle(const JSONTraceBundleDescription &bundle_description);
 
-  /// When applicable, augment the list of threads in the session file by
+  /// When applicable, augment the list of threads in the trace bundle by
   /// inspecting the context switch trace. This only applies for threads of
-  /// processes already specified in this session file.
+  /// processes already specified in this bundle description.
   ///
   /// \return
   ///   An \a llvm::Error in case if failures, or \a llvm::Error::success
   ///   otherwise.
-  llvm::Error AugmentThreadsFromContextSwitches(JSONTraceSession &session);
+  llvm::Error AugmentThreadsFromContextSwitches(JSONTraceBundleDescription &bundle_description);
 
-  /// Modifiy the session file by normalizing all the paths relative to the
+  /// Modifiy the bundle description by normalizing all the paths relative to the
   /// session file directory.
-  void NormalizeAllPaths(JSONTraceSession &session);
+  void NormalizeAllPaths(JSONTraceBundleDescription &bundle_description);
 
   Debugger &m_debugger;
-  const llvm::json::Value &m_trace_session_file;
-  const std::string m_session_file_dir;
+  const llvm::json::Value &m_bundle_description;
+  const std::string m_bundle_dir;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 
-#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLELOADER_H

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

-//===-- TraceIntelPTSessionFileParser.cpp ---------------------------------===//
+//===-- TraceIntelPTBundleLoader.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 "TraceIntelPTSessionFileParser.h"
+#include "TraceIntelPTBundleLoader.h"
 
 #include "../common/ThreadPostMortemTrace.h"
 #include "TraceIntelPT.h"
 #include "TraceIntelPTJSONStructs.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
-FileSpec TraceIntelPTSessionFileParser::NormalizePath(const std::string &path) {
+FileSpec TraceIntelPTBundleLoader::NormalizePath(const std::string &path) {
   FileSpec file_spec(path);
   if (file_spec.IsRelative())
-    file_spec.PrependPathComponent(m_session_file_dir);
+    file_spec.PrependPathComponent(m_bundle_dir);
   return file_spec;
 }
 
-Error TraceIntelPTSessionFileParser::ParseModule(Target &target,
+Error TraceIntelPTBundleLoader::ParseModule(Target &target,
                                                  const JSONModule &module) {
   auto do_parse = [&]() -> Error {
     FileSpec system_file_spec(module.system_path);
 
     FileSpec local_file_spec(module.file.hasValue() ? *module.file
                                                     : module.system_path);
 
     ModuleSpec module_spec;
Error TraceIntelPTBundleLoader::ParseModule(Target &target,
   };
   if (Error err = do_parse())
     return createStringError(
         inconvertibleErrorCode(), "Error when parsing module %s. %s",
         module.system_path.c_str(), toString(std::move(err)).c_str());
   return Error::success();
 }
 
-Error TraceIntelPTSessionFileParser::CreateJSONError(json::Path::Root &root,
+Error TraceIntelPTBundleLoader::CreateJSONError(json::Path::Root &root,
                                                      const json::Value &value) {
   std::string err;
   raw_string_ostream os(err);
   root.printErrorContext(value, os);
   return createStringError(
       std::errc::invalid_argument, "%s\n\nContext:\n%s\n\nSchema:\n%s",
       toString(root.getError()).c_str(), os.str().c_str(), GetSchema().data());
 }
 
 ThreadPostMortemTraceSP
-TraceIntelPTSessionFileParser::ParseThread(Process &process,
+TraceIntelPTBundleLoader::ParseThread(Process &process,
                                            const JSONThread &thread) {
   lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
 
   Optional<FileSpec> trace_file;
   if (thread.ipt_trace)
     trace_file = FileSpec(*thread.ipt_trace);
 
   ThreadPostMortemTraceSP thread_sp =
       std::make_shared<ThreadPostMortemTrace>(process, tid, trace_file);
   process.GetThreadList().AddThread(thread_sp);
   return thread_sp;
 }
 
-Expected<TraceIntelPTSessionFileParser::ParsedProcess>
-TraceIntelPTSessionFileParser::ParseProcess(const JSONProcess &process) {
+Expected<TraceIntelPTBundleLoader::ParsedProcess>
+TraceIntelPTBundleLoader::ParseProcess(const JSONProcess &process) {
   TargetSP target_sp;
   Status error = m_debugger.GetTargetList().CreateTarget(
       m_debugger, /*user_exe_path*/ StringRef(), process.triple.getValueOr(""),
       eLoadDependentsNo,
       /*platform_options*/ nullptr, target_sp);
 
   if (!target_sp)
     return error.ToError();
TraceIntelPTBundleLoader::ParseProcess(const JSONProcess &process) {
   // We invoke DidAttach to create a correct stopped state for the process and
   // its threads.
   ArchSpec process_arch;
   process_sp->DidAttach(process_arch);
 
   return parsed_process;
 }
 
-Expected<std::vector<TraceIntelPTSessionFileParser::ParsedProcess>>
-TraceIntelPTSessionFileParser::ParseSessionFile(
-    const JSONTraceSession &session) {
+Expected<std::vector<TraceIntelPTBundleLoader::ParsedProcess>>
+TraceIntelPTBundleLoader::LoadBundle(
+    const JSONTraceBundleDescription &bundle_description) {
   std::vector<ParsedProcess> parsed_processes;
 
   auto HandleError = [&](Error &&err) {
     // Delete all targets that were created so far in case of failures
     for (ParsedProcess &parsed_process : parsed_processes)
       m_debugger.GetTargetList().DeleteTarget(parsed_process.target_sp);
     return std::move(err);
   };
 
-  for (const JSONProcess &process : session.processes) {
+  for (const JSONProcess &process : bundle_description.processes) {
     if (Expected<ParsedProcess> parsed_process = ParseProcess(process))
       parsed_processes.push_back(std::move(*parsed_process));
     else
       return HandleError(parsed_process.takeError());
   }
 
   return parsed_processes;
 }
 
-StringRef TraceIntelPTSessionFileParser::GetSchema() {
+StringRef TraceIntelPTBundleLoader::GetSchema() {
   static std::string schema;
   if (schema.empty()) {
     schema = R"({
   "type": "intel-pt",
   "cpuInfo": {
     // CPU information gotten from, for example, /proc/cpuinfo.
 
     "vendor": "GenuineIntel" | "unknown",
"tscPerfZeroConversion"?: {
     "timeMult": integer,
     "timeShift": integer,
     "timeZero": integer | string decimal | hex string,
   }
 }
 
 Notes:
 
-- All paths are either absolute or relative to folder containing the session file.
+- All paths are either absolute or relative to folder containing the bundle description file.
 - "cpus" is provided if and only if processes[].threads[].iptTrace is not provided.
 - "tscPerfZeroConversion" must be provided if "cpus" is provided.
  })";
   }
   return schema;
 }
 
-Error TraceIntelPTSessionFileParser::AugmentThreadsFromContextSwitches(
-    JSONTraceSession &session) {
-  if (!session.cpus)
+Error TraceIntelPTBundleLoader::AugmentThreadsFromContextSwitches(
+    JSONTraceBundleDescription &bundle_description) {
+  if (!bundle_description.cpus)
     return Error::success();
 
-  if (!session.tsc_perf_zero_conversion)
+  if (!bundle_description.tsc_perf_zero_conversion)
     return createStringError(inconvertibleErrorCode(),
                              "TSC to nanos conversion values are needed when "
                              "context switch information is provided.");
 
   DenseMap<lldb::pid_t, JSONProcess *> indexed_processes;
   DenseMap<JSONProcess *, DenseSet<tid_t>> indexed_threads;
 
-  for (JSONProcess &process : session.processes) {
+  for (JSONProcess &process : bundle_description.processes) {
     indexed_processes[process.pid] = &process;
     for (JSONThread &thread : process.threads)
       indexed_threads[&process].insert(thread.tid);
   }
 
   auto on_thread_seen = [&](lldb::pid_t pid, tid_t tid) {
     auto proc = indexed_processes.find(pid);
     if (proc == indexed_processes.end())
       return;
     if (indexed_threads[proc->second].count(tid))
       return;
     indexed_threads[proc->second].insert(tid);
     proc->second->threads.push_back({tid, /*ipt_trace=*/None});
   };
 
-  for (const JSONCpu &cpu : *session.cpus) {
+  for (const JSONCpu &cpu : *bundle_description.cpus) {
     Error err = Trace::OnDataFileRead(
         FileSpec(cpu.context_switch_trace),
         [&](ArrayRef<uint8_t> data) -> Error {
           Expected<std::vector<ThreadContinuousExecution>> executions =
               DecodePerfContextSwitchTrace(data, cpu.id,
-                                           *session.tsc_perf_zero_conversion);
+                                           *bundle_description.tsc_perf_zero_conversion);
           if (!executions)
             return executions.takeError();
           for (const ThreadContinuousExecution &execution : *executions)
             on_thread_seen(execution.pid, execution.tid);
           return Error::success();
         });
     if (err)
       return err;
   }
   return Error::success();
 }
 
-Expected<TraceSP> TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
-    JSONTraceSession &session, std::vector<ParsedProcess> &parsed_processes) {
+Expected<TraceSP> TraceIntelPTBundleLoader::CreateTraceIntelPTInstance(
+    JSONTraceBundleDescription &bundle_description, std::vector<ParsedProcess> &parsed_processes) {
   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 = TraceIntelPT::CreateInstanceForPostmortemTrace(
-      session, processes, threads);
+      bundle_description, processes, threads);
   for (const ParsedProcess &parsed_process : parsed_processes)
     parsed_process.target_sp->SetTrace(trace_instance);
 
   return trace_instance;
 }
 
-void TraceIntelPTSessionFileParser::NormalizeAllPaths(
-    JSONTraceSession &session) {
-  for (JSONProcess &process : session.processes) {
+void TraceIntelPTBundleLoader::NormalizeAllPaths(
+    JSONTraceBundleDescription &bundle_description) {
+  for (JSONProcess &process : bundle_description.processes) {
     for (JSONModule &module : process.modules) {
       module.system_path = NormalizePath(module.system_path).GetPath();
       if (module.file)
         module.file = NormalizePath(*module.file).GetPath();
     }
     for (JSONThread &thread : process.threads) {
       if (thread.ipt_trace)
         thread.ipt_trace = NormalizePath(*thread.ipt_trace).GetPath();
     }
   }
-  if (session.cpus) {
-    for (JSONCpu &cpu : *session.cpus) {
+  if (bundle_description.cpus) {
+    for (JSONCpu &cpu : *bundle_description.cpus) {
       cpu.context_switch_trace =
           NormalizePath(cpu.context_switch_trace).GetPath();
       cpu.ipt_trace = NormalizePath(cpu.ipt_trace).GetPath();
     }
   }
 }
 
-Expected<TraceSP> TraceIntelPTSessionFileParser::Parse() {
-  json::Path::Root root("traceSession");
-  JSONTraceSession session;
-  if (!fromJSON(m_trace_session_file, session, root))
-    return CreateJSONError(root, m_trace_session_file);
+Expected<TraceSP> TraceIntelPTBundleLoader::Load() {
+  json::Path::Root root("traceBundle");
+  JSONTraceBundleDescription bundle_description;
+  if (!fromJSON(m_bundle_description, bundle_description, root))
+    return CreateJSONError(root, m_bundle_description);
 
-  NormalizeAllPaths(session);
+  NormalizeAllPaths(bundle_description);
 
-  if (Error err = AugmentThreadsFromContextSwitches(session))
+  if (Error err = AugmentThreadsFromContextSwitches(bundle_description))
     return std::move(err);
 
   if (Expected<std::vector<ParsedProcess>> parsed_processes =
-          ParseSessionFile(session))
-    return CreateTraceIntelPTInstance(session, *parsed_processes);
+          LoadBundle(bundle_description))
+    return CreateTraceIntelPTInstance(bundle_description, *parsed_processes);
   else
     return parsed_processes.takeError();
 }

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

-//===-- TraceIntelPTSessionSaver.h ---------------------------*- C++ //-*-===//
+//===-- TraceIntelPTBundleSaver.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_TRACEINTELPTSESSIONSAVER_H
-#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H
+#ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLESAVER_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLESAVER_H
 
 #include "TraceIntelPT.h"
 
 #include "TraceIntelPTJSONStructs.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-class TraceIntelPTSessionSaver {
+class TraceIntelPTBundleSaver {
 public:
   /// Save the Intel PT trace of a live process to the specified directory,
   /// which will be created if needed. This will also create a file
-  /// \a <directory>/trace.json with the main properties of the trace
-  /// session, along with others files which contain the actual trace data.
+  /// \a <directory>/trace.json with the description of the trace
+  /// bundle, along with others files which contain the actual trace data.
   /// The trace.json file can be used later as input for the "trace load"
   /// command to load the trace in LLDB.
   ///
   /// \param[in] trace_ipt
   ///     The Intel PT trace to be saved to disk.
   ///
   /// \param[in] directory
-  ///     The directory where the trace files will be saved.
+  ///     The directory where the trace bundle will be created.
   ///
   /// \return
   ///     \a llvm::success if the operation was successful, or an \a llvm::Error
   ///     otherwise.
   llvm::Error SaveToDisk(TraceIntelPT &trace_ipt, FileSpec directory);
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
-#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTBUNDLESAVER_H

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

-//===-- TraceIntelPTSessionSaver.cpp --------------------------------------===//
+//===-- TraceIntelPTBundleSaver.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 "TraceIntelPTSessionSaver.h"
+#include "TraceIntelPTBundleSaver.h"
 #include "TraceIntelPT.h"
 #include "TraceIntelPTJSONStructs.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadList.h"
static llvm::Error WriteBytesToDisk(FileSpec &output_file,
   out_fs.close();
   if (!out_fs)
     return createStringError(inconvertibleErrorCode(),
                              formatv("couldn't write to the file {0}",
                                      output_file.GetPath().c_str()));
   return Error::success();
 }
 
-/// Save the trace session description JSON object inside the given directory
+/// Save the trace bundle description JSON object inside the given directory
 /// as a file named \a trace.json.
 ///
-/// \param[in] trace_session_json
-///     The trace's session, as JSON Object.
+/// \param[in] trace_bundle_description
+///     The trace bundle description as JSON Object.
 ///
 /// \param[in] directory
 ///     The directory where the JSON file will be saved.
 ///
 /// \return
 ///     \a llvm::Success if the operation was successful, or an \a llvm::Error
 ///     otherwise.
 static llvm::Error
-WriteSessionToFile(const llvm::json::Value &trace_session_json,
+SaveTraceBundleDescription(const llvm::json::Value &trace_bundle_description,
                    const FileSpec &directory) {
   FileSpec trace_path = directory;
   trace_path.AppendPathComponent("trace.json");
   std::ofstream os(trace_path.GetPath());
-  os << formatv("{0:2}", trace_session_json).str();
+  os << formatv("{0:2}", trace_bundle_description).str();
   os.close();
   if (!os)
     return createStringError(inconvertibleErrorCode(),
                              formatv("couldn't write to the file {0}",
                                      trace_path.GetPath().c_str()));
   return Error::success();
 }
 
-/// Build the threads sub-section of the trace session description file.
+/// Build the threads sub-section of the trace bundle description file.
 /// Any associated binary files are created inside the given directory.
 ///
 /// \param[in] process
 ///     The process being traced.
 ///
 /// \param[in] directory
 ///     The directory where files will be saved when building the threads
 ///     section.
json_cpu.id = cpu_id;
       if (err)
         return std::move(err);
     }
     json_cpus.push_back(std::move(json_cpu));
   }
   return json_cpus;
 }
 
-/// Build modules sub-section of the trace's session. The original modules
+/// Build modules sub-section of the trace bundle. The original modules
 /// will be copied over to the \a <directory/modules> folder. Invalid modules
 /// are skipped.
-/// Copying the modules has the benefit of making these trace session
+/// Copying the modules has the benefit of making these
 /// directories self-contained, as the raw traces and modules are part of the
 /// output directory and can be sent to another machine, where lldb can load
 /// them and replicate exactly the same trace session.
 ///
 /// \param[in] process
 ///     The process being traced.
 ///
 /// \param[in] directory
for (size_t i = 0; i < module_list.GetSize(); ++i) {
 
     json_modules.push_back(
         JSONModule{system_path, path_to_copy_module.GetPath(),
                    JSONUINT64{load_addr}, module_sp->GetUUID().GetAsString()});
   }
   return json_modules;
 }
 
-/// Build the processes section of the trace session description file. Besides
+/// Build the processes section of the trace bundle description object. Besides
 /// returning the processes information, this method saves to disk all modules
 /// and raw traces corresponding to the traced threads of the given process.
 ///
 /// \param[in] process
 ///     The process being traced.
 ///
 /// \param[in] directory
 ///     The directory where files will be saved when building the processes
if (llvm::Expected<JSONProcess> json_process =
             BuildProcessSection(*process, directory))
       processes.push_back(std::move(*json_process));
     else
       return json_process.takeError();
   }
   return processes;
 }
 
-Error TraceIntelPTSessionSaver::SaveToDisk(TraceIntelPT &trace_ipt,
+Error TraceIntelPTBundleSaver::SaveToDisk(TraceIntelPT &trace_ipt,
                                            FileSpec directory) {
   if (std::error_code ec =
           sys::fs::create_directories(directory.GetPath().c_str()))
     return llvm::errorCodeToError(ec);
 
   Expected<pt_cpu> cpu_info = trace_ipt.GetCPUInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
   FileSystem::Instance().Resolve(directory);
 
   Expected<std::vector<JSONProcess>> json_processes =
       BuildProcessesSection(trace_ipt, directory);
 
   if (!json_processes)
     return json_processes.takeError();
 
   Expected<Optional<std::vector<JSONCpu>>> json_cpus =
       BuildCpusSection(trace_ipt, directory);
   if (!json_cpus)
     return json_cpus.takeError();
 
-  JSONTraceSession json_intel_pt_session{"intel-pt", *cpu_info, *json_processes,
+  JSONTraceBundleDescription json_intel_pt_bundle_desc{"intel-pt", *cpu_info, *json_processes,
                                          *json_cpus,
                                          trace_ipt.GetPerfZeroTscConversion()};
 
-  return WriteSessionToFile(toJSON(json_intel_pt_session), directory);
+  return SaveTraceBundleDescription(toJSON(json_intel_pt_bundle_desc), directory);
 }

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

 };
 
 struct JSONCpu {
   lldb::cpu_id_t id;
   std::string ipt_trace;
   std::string context_switch_trace;
 };
 
-struct JSONTraceSession {
+struct JSONTraceBundleDescription {
   std::string type;
   pt_cpu cpu_info;
   std::vector<JSONProcess> processes;
   llvm::Optional<std::vector<JSONCpu>> cpus;
   llvm::Optional<LinuxPerfZeroTscConversion> tsc_perf_zero_conversion;
 
   llvm::Optional<std::vector<lldb::cpu_id_t>> GetCpuIds();
 };
 
 llvm::json::Value toJSON(const JSONModule &module);
 
 llvm::json::Value toJSON(const JSONThread &thread);
 
 llvm::json::Value toJSON(const JSONProcess &process);
 
 llvm::json::Value toJSON(const JSONCpu &cpu);
 
 llvm::json::Value toJSON(const pt_cpu &cpu_info);
 
-llvm::json::Value toJSON(const JSONTraceSession &session);
+llvm::json::Value toJSON(const JSONTraceBundleDescription &bundle_description);
 
 bool fromJSON(const llvm::json::Value &value, JSONModule &module,
               llvm::json::Path path);
 
 bool fromJSON(const llvm::json::Value &value, JSONThread &thread,
               llvm::json::Path path);
 
 bool fromJSON(const llvm::json::Value &value, JSONProcess &process,
               llvm::json::Path path);
 
 bool fromJSON(const llvm::json::Value &value, JSONCpu &cpu,
               llvm::json::Path path);
 
 bool fromJSON(const llvm::json::Value &value, pt_cpu &cpu_info,
               llvm::json::Path path);
 
-bool fromJSON(const llvm::json::Value &value, JSONTraceSession &session,
+bool fromJSON(const llvm::json::Value &value, JSONTraceBundleDescription &bundle_description,
               llvm::json::Path path);
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H

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

 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 using namespace llvm::json;
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
-Optional<std::vector<lldb::cpu_id_t>> JSONTraceSession::GetCpuIds() {
+Optional<std::vector<lldb::cpu_id_t>> JSONTraceBundleDescription::GetCpuIds() {
   if (!cpus)
     return None;
   std::vector<lldb::cpu_id_t> cpu_ids;
   for (const JSONCpu &cpu : *cpus)
     cpu_ids.push_back(cpu.id);
   return cpu_ids;
 }
 
if (!(o && o.map("vendor", vendor) && o.map("family", family) &&
     return false;
   cpu_info.vendor = vendor == "GenuineIntel" ? pcv_intel : pcv_unknown;
   cpu_info.family = family;
   cpu_info.model = model;
   cpu_info.stepping = stepping;
   return true;
 }
 
-json::Value toJSON(const JSONTraceSession &session) {
-  return Object{{"type", session.type},
-                {"processes", session.processes},
+json::Value toJSON(const JSONTraceBundleDescription &bundle_description) {
+  return Object{{"type", bundle_description.type},
+                {"processes", bundle_description.processes},
                 // We have to do this because the compiler fails at doing it
                 // automatically because pt_cpu is not in a namespace
-                {"cpuInfo", toJSON(session.cpu_info)},
-                {"cpus", session.cpus},
-                {"tscPerfZeroConversion", session.tsc_perf_zero_conversion}};
+                {"cpuInfo", toJSON(bundle_description.cpu_info)},
+                {"cpus", bundle_description.cpus},
+                {"tscPerfZeroConversion", bundle_description.tsc_perf_zero_conversion}};
 }
 
-bool fromJSON(const json::Value &value, JSONTraceSession &session, Path path) {
+bool fromJSON(const json::Value &value, JSONTraceBundleDescription &bundle_description, Path path) {
   ObjectMapper o(value, path);
-  if (!(o && o.map("processes", session.processes) &&
-        o.map("type", session.type) && o.map("cpus", session.cpus) &&
-        o.map("tscPerfZeroConversion", session.tsc_perf_zero_conversion)))
+  if (!(o && o.map("processes", bundle_description.processes) &&
+        o.map("type", bundle_description.type) && o.map("cpus", bundle_description.cpus) &&
+        o.map("tscPerfZeroConversion", bundle_description.tsc_perf_zero_conversion)))
     return false;
-  if (session.cpus && !session.tsc_perf_zero_conversion) {
+  if (bundle_description.cpus && !bundle_description.tsc_perf_zero_conversion) {
     path.report(
         "\"tscPerfZeroConversion\" is required when \"cpus\" is provided");
     return false;
   }
   // We have to do this because the compiler fails at doing it automatically
   // because pt_cpu is not in a namespace
-  if (!fromJSON(*value.getAsObject()->get("cpuInfo"), session.cpu_info,
+  if (!fromJSON(*value.getAsObject()->get("cpuInfo"), bundle_description.cpu_info,
                 path.field("cpuInfo")))
     return false;
   return true;
 }
 
 } // namespace trace_intel_pt
 } // namespace lldb_private

lldb/source/Target/Trace.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
-// Helper structs used to extract the type of a trace session json without
-// having to parse the entire object.
+// Helper structs used to extract the type of a JSON trace bundle description
+// object without having to parse the entire object.
 
-struct JSONSimpleTraceSession {
+struct JSONSimpleTraceBundleDescription {
   std::string type;
 };
 
 namespace llvm {
 namespace json {
 
-bool fromJSON(const Value &value, JSONSimpleTraceSession &session, Path path) {
+bool fromJSON(const Value &value, JSONSimpleTraceBundleDescription &bundle,
+              Path path) {
   json::ObjectMapper o(value, path);
-  return o && o.map("type", session.type);
+  return o && o.map("type", bundle.type);
 }
 
 } // namespace json
 } // namespace llvm
 
 /// Helper functions for fetching data in maps and returning Optionals or
 /// pointers instead of iterators for simplicity. It's worth mentioning that the
 /// Optionals version can't return the inner data by reference because of
if (!session_file) {
     return session_file.takeError();
   }
 
   return Trace::FindPluginForPostMortemProcess(
       debugger, *session_file,
       trace_description_file.GetDirectory().AsCString());
 }
 
-Expected<lldb::TraceSP>
-Trace::FindPluginForPostMortemProcess(Debugger &debugger,
-                                      const json::Value &trace_session_file,
-                                      StringRef session_file_dir) {
-  JSONSimpleTraceSession json_session;
-  json::Path::Root root("traceSession");
-  if (!json::fromJSON(trace_session_file, json_session, root))
+Expected<lldb::TraceSP> Trace::FindPluginForPostMortemProcess(
+    Debugger &debugger, const json::Value &trace_bundle_description,
+    StringRef bundle_dir) {
+  JSONSimpleTraceBundleDescription json_bundle;
+  json::Path::Root root("traceBundle");
+  if (!json::fromJSON(trace_bundle_description, json_bundle, root))
     return root.getError();
 
   if (auto create_callback =
-          PluginManager::GetTraceCreateCallback(json_session.type))
-    return create_callback(trace_session_file, session_file_dir, debugger);
+          PluginManager::GetTraceCreateCallback(json_bundle.type))
+    return create_callback(trace_bundle_description, bundle_dir, debugger);
 
-  return createInvalidPlugInError(json_session.type);
+  return createInvalidPlugInError(json_bundle.type);
 }
 
 Expected<lldb::TraceSP> Trace::FindPluginForLiveProcess(llvm::StringRef name,
                                                         Process &process) {
   if (!process.IsLiveDebugSession())
     return createStringError(inconvertibleErrorCode(),
                              "Can't trace non-live processes");
 

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

Errors:
     Number of TSC decoding errors: 0'''])
 
     @testSBAPIAndCommands
     def testLoadInvalidTraces(self):
         src_dir = self.getSourceDir()
 
         # We test first an invalid type
         trace_description_file_path = os.path.join(src_dir, "intelpt-trace", "trace_bad.json")
-        expected_substrs = ['''error: expected object at traceSession.processes[0]
+        expected_substrs = ['''error: expected object at traceBundle.processes[0]
 
 Context:
 {
   "cpuInfo": { ... },
   "processes": [
     /* error: expected object */
     123
   ],
"cpuInfo": {
     "vendor": "GenuineIntel" | "unknown",
     "family": integer,
     "model": integer,
     "stepping": integer
   },''']
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, error=True, substrs=expected_substrs)
 
 
-        # Now we test a wrong cpu family field in the global session file
+        # Now we test a wrong cpu family field in the global bundle description file
         trace_description_file_path = os.path.join(src_dir, "intelpt-trace", "trace_bad2.json")
-        expected_substrs = ['error: expected uint64_t at traceSession.cpuInfo.family', "Context", "Schema"]
+        expected_substrs = ['error: expected uint64_t at traceBundle.cpuInfo.family', "Context", "Schema"]
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, error=True, substrs=expected_substrs)
 
 
         # Now we test a missing field in the intel-pt settings
         trace_description_file_path = os.path.join(src_dir, "intelpt-trace", "trace_bad4.json")
-        expected_substrs = ['''error: missing value at traceSession.cpuInfo.family
+        expected_substrs = ['''error: missing value at traceBundle.cpuInfo.family
 
 Context:
 {
   "cpuInfo": /* error: missing value */ {
     "model": 79,
     "stepping": 1,
     "vendor": "GenuineIntel"
   },
   "processes": [],
   "type": "intel-pt"
 }''', "Schema"]
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, error=True, substrs=expected_substrs)
 
 
         # Now we test an incorrect load address in the intel-pt settings
         trace_description_file_path = os.path.join(src_dir, "intelpt-trace", "trace_bad5.json")
-        expected_substrs = ['error: missing value at traceSession.processes[1].pid', "Schema"]
+        expected_substrs = ['error: missing value at traceBundle.processes[1].pid', "Schema"]
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, error=True, substrs=expected_substrs)
 
 
         # The following wrong schema will have a valid target and an invalid one. In the case of failure,
         # no targets should be created.
         self.assertEqual(self.dbg.GetNumTargets(), 0)
         trace_description_file_path = os.path.join(src_dir, "intelpt-trace", "trace_bad3.json")
-        expected_substrs = ['error: missing value at traceSession.processes[1].pid']
+        expected_substrs = ['error: missing value at traceBundle.processes[1].pid']
         self.traceLoad(traceDescriptionFilePath=trace_description_file_path, error=True, substrs=expected_substrs)
         self.assertEqual(self.dbg.GetNumTargets(), 0)