[trace][intelpt] Support system-wide tracing [19] - Some other minor improvements

[wallace]

Summary

This addresses the issues in diffs [13], [14] and [16]

• Add better documentation
• Fix some castings by making them safer
• Simplify CorrelateContextSwitchesAndIntelPtTraces
• Rename some functions

[jj10306]

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

53

isn't this really an out param?

[wallace]

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

53

you're too good

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

 #include "PerfContextSwitchDecoder.h"
 #include "forward-declarations.h"
 
 #include "intel-pt.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
+/// This struct represents a point in the intel pt trace that the decoder can start decoding from without errors.
 struct IntelPTThreadSubtrace {
-  uint64_t tsc;
+  /// The memory offset of a PSB packet that is a synchronization point for the decoder. A decoder normally looks first
+  /// for a PSB packet and then it starts decoding.
   uint64_t psb_offset;
+  /// The timestamp associated with the PSB packet above.
+  uint64_t tsc;
 };
 
 /// This struct represents a continuous execution of a thread in a core,
 /// delimited by a context switch in and out, and a list of Intel PT subtraces
 /// that belong to this execution.
 struct IntelPTThreadContinousExecution {
   ThreadContinuousExecution thread_execution;
   std::vector<IntelPTThreadSubtrace> intelpt_subtraces;
 
   IntelPTThreadContinousExecution(
       const ThreadContinuousExecution &thread_execution)
       : thread_execution(thread_execution) {}
 
   /// Comparator by time
   bool operator<(const IntelPTThreadContinousExecution &o) const;
 };
 
-/// Decode a raw Intel PT trace given in \p buffer and append the decoded
+/// 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 DecodeTrace(DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
+void DecodeSingleTraceForThread(DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
                  llvm::ArrayRef<uint8_t> buffer);
 
-void DecodeTrace(
+/// 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[in] trace_intel_pt
+///   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.
+void DecodeSystemWideTraceForThread(
     DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
     const llvm::DenseMap<lldb::core_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.
+///
+/// \param[in] trace_intel_pt
+///   The main Trace object that contains all the information related to the trace session.
+///
+/// \param[in] buffer
+///   The intel pt buffer that belongs to a single thread or to a single cpu core.
+///
+/// \return
+///   A list of continuous executions sorted by time, or an \a llvm::Error in case of failures.
 llvm::Expected<std::vector<IntelPTThreadSubtrace>>
 SplitTraceInContinuousExecutions(TraceIntelPT &trace_intel_pt,
                                  llvm::ArrayRef<uint8_t> buffer);
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_LIBIPT_DECODER_H

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

private:
 
   /// Decode all the instructions and events until an error is found, the end
   /// of the trace is reached, or optionally a new PSB is reached.
   ///
   /// \param[in] status
   ///   The status that was result of synchronizing to the most recent PSB.
   ///
   /// \param[in] stop_on_psb_change
-  ///   If \b true, decoding
-  ///   An optional offset to a given PSB. Decoding stops if a different PSB is
-  ///   reached.
+  ///   If \b true, decoding stops if a different PSB is reached.
   void DecodeInstructionsAndEvents(int status,
                                    bool stop_on_psb_change = false) {
     uint64_t psb_offset;
     pt_insn_get_sync_offset(&m_decoder,
                             &psb_offset); // this can't fail because we got here
 
     while (true) {
       DecodedInstruction insn = ProcessPTEvents(status);
static Error SetupMemoryImage(PtInsnDecoderUP &decoder_up, Process &process) {
 
   int status = pte_ok;
   if (IsLibiptError(
           status = pt_image_set_callback(image, ReadProcessMemory, &process)))
     return make_error<IntelPTError>(status);
   return Error::success();
 }
 
-void lldb_private::trace_intel_pt::DecodeTrace(DecodedThread &decoded_thread,
+void lldb_private::trace_intel_pt::DecodeSingleTraceForThread(DecodedThread &decoded_thread,
                                                TraceIntelPT &trace_intel_pt,
                                                ArrayRef<uint8_t> buffer) {
   Expected<PtInsnDecoderUP> decoder_up =
       CreateInstructionDecoder(trace_intel_pt, buffer);
   if (!decoder_up)
     return decoded_thread.SetAsFailed(decoder_up.takeError());
 
   if (Error err = SetupMemoryImage(*decoder_up,
                                    *decoded_thread.GetThread()->GetProcess()))
     return decoded_thread.SetAsFailed(std::move(err));
 
   LibiptDecoder libipt_decoder(*decoder_up.get(), decoded_thread);
   libipt_decoder.DecodeUntilEndOfTrace();
 }
 
-void lldb_private::trace_intel_pt::DecodeTrace(
+void lldb_private::trace_intel_pt::DecodeSystemWideTraceForThread(
     DecodedThread &decoded_thread, TraceIntelPT &trace_intel_pt,
     const DenseMap<lldb::core_id_t, llvm::ArrayRef<uint8_t>> &buffers,
     const std::vector<IntelPTThreadContinousExecution> &executions) {
   DenseMap<lldb::core_id_t, LibiptDecoder> decoders;
   for (auto &core_id_buffer : buffers) {
     Expected<PtInsnDecoderUP> decoder_up =
         CreateInstructionDecoder(trace_intel_pt, core_id_buffer.second);
     if (!decoder_up)
if (IsLibiptError(pt_insn_time(decoder, &tsc, nullptr, nullptr)))
       return createStringError(inconvertibleErrorCode(),
                                "intel pt trace doesn't have TSC timestamps");
 
     uint64_t psb_offset;
     pt_insn_get_sync_offset(decoder,
                             &psb_offset); // this can't fail because we got here
 
     executions.push_back({
-        tsc,
         psb_offset,
+        tsc,
     });
   }
   return executions;
 }

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

 private:
   /// We keep this constructor private to force the usage of the static named
   /// constructors.
   ThreadContinuousExecution(lldb::core_id_t core_id, lldb::tid_t tid,
                             lldb::pid_t pid)
       : core_id(core_id), tid(tid), pid(pid) {}
 };
 
-/// Decodes a context switch trace gotten with perf_event_open.
+/// Decodes a context switch trace collected with perf_event_open.
 ///
 /// \param[in] data
 ///   The context switch trace in binary format.
 ///
 /// \param[i] core_id
 ///   The core_id where the trace were gotten from.
 ///
 /// \param[in] tsc_conversion

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

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 /// Copied from <linux/perf_event.h> to avoid depending on perf_event.h on
 /// non-linux platforms.
 /// \{
-struct perf_event_header {
-  uint32_t type;
-  uint16_t misc;
-  uint16_t size;
-};
-
 #define PERF_RECORD_MISC_SWITCH_OUT (1 << 13)
 #define PERF_RECORD_MAX 19
 #define PERF_RECORD_SWITCH_CPU_WIDE 15
-/// \}
-
-/// Record found in the perf_event context switch traces. It might contain
-/// additional fields in memory, but header.size should have the actual size
-/// of the record.
-struct PerfContextSwitchRecord {
-  struct perf_event_header header;
-  uint32_t next_prev_pid;
-  uint32_t next_prev_tid;
-  uint32_t pid, tid;
-  uint64_t time_in_nanos;
-
-  bool IsOut() const { return header.misc & PERF_RECORD_MISC_SWITCH_OUT; }
 
-  bool IsContextSwitchRecord() const {
-    return header.type == PERF_RECORD_SWITCH_CPU_WIDE;
-  }
+struct perf_event_header {
+  uint32_t type;
+  uint16_t misc;
+  uint16_t size;
 
   /// \return
   ///   An \a llvm::Error if the record looks obviously wrong, or \a
   ///   llvm::Error::success() otherwise.
   Error SanityCheck() const {
+    // The following checks are based on visual inspection of the records and
+    // enums in
+    // https://elixir.bootlin.com/linux/v4.8/source/include/uapi/linux/perf_event.h
+    // See PERF_RECORD_MAX, PERF_RECORD_SWITCH and the data similar records
+    // hold.
+
     // A record of too many uint64_t's or more should mean that the data is
     // wrong
-    if (header.size == 0 || header.size > sizeof(uint64_t) * 1000)
+    const uint64_t max_valid_size_bytes = 8000;
+    if (size == 0 || size > max_valid_size_bytes)
       return createStringError(
           inconvertibleErrorCode(),
-          formatv("A record of {0} bytes was found.", header.size));
+          formatv("A record of {0} bytes was found.", size));
 
     // We add some numbers to PERF_RECORD_MAX because some systems might have
     // custom records. In any case, we are looking only for abnormal data.
-    if (header.type >= PERF_RECORD_MAX + 100)
+    if (type >= PERF_RECORD_MAX + 100)
       return createStringError(
           inconvertibleErrorCode(),
-          formatv("Invalid record type {0} was found.", header.type));
+          formatv("Invalid record type {0} was found.", type));
     return Error::success();
   }
+
+  bool IsContextSwitchRecord() const {
+    return type == PERF_RECORD_SWITCH_CPU_WIDE;
+  }
+};
+/// \}
+
+/// Record found in the perf_event context switch traces. It might contain
+/// additional fields in memory, but header.size should have the actual size
+/// of the record.
+struct PerfContextSwitchRecord {
+  struct perf_event_header header;
+  uint32_t next_prev_pid;
+  uint32_t next_prev_tid;
+  uint32_t pid, tid;
+  uint64_t time_in_nanos;
+
+  bool IsOut() const { return header.misc & PERF_RECORD_MISC_SWITCH_OUT; }
 };
 
 /// Record produced after parsing the raw context switch trace produce by
 /// perf_event. A major difference between this struct and
 /// PerfContextSwitchRecord is that this one uses tsc instead of nanos.
 struct ContextSwitchRecord {
   uint64_t tsc;
   /// Whether the switch is in or out
if (current_record.pid == prev.pid && current_record.tid == prev.tid) {
       on_new_execution(ThreadContinuousExecution::CreateHintedStartExecution(
           core_id, current_record.tid, current_record.pid, prev.tsc + 1,
           current_record.tsc));
     }
   }
   return Error::success();
 }
 
-#include <fstream>
-
 Expected<std::vector<ThreadContinuousExecution>>
 lldb_private::trace_intel_pt::DecodePerfContextSwitchTrace(
     ArrayRef<uint8_t> data, core_id_t core_id,
     const LinuxPerfZeroTscConversion &tsc_conversion) {
 
   std::vector<ThreadContinuousExecution> executions;
 
   // This offset is used to create the error message in case of failures.
   size_t offset = 0;
 
   auto do_decode = [&]() -> Error {
     Optional<ContextSwitchRecord> prev_record;
     while (offset < data.size()) {
-      const PerfContextSwitchRecord &perf_record =
-          *reinterpret_cast<const PerfContextSwitchRecord *>(data.data() +
-                                                             offset);
+      const perf_event_header &perf_record =
+          *reinterpret_cast<const perf_event_header *>(data.data() + offset);
       if (Error err = perf_record.SanityCheck())
         return err;
 
       if (perf_record.IsContextSwitchRecord()) {
+        const PerfContextSwitchRecord &context_switch_record =
+            *reinterpret_cast<const PerfContextSwitchRecord *>(data.data() +
+                                                               offset);
         ContextSwitchRecord record{
-            tsc_conversion.ToTSC(perf_record.time_in_nanos),
-            perf_record.IsOut(), static_cast<lldb::pid_t>(perf_record.pid),
-            static_cast<lldb::tid_t>(perf_record.tid)};
+            tsc_conversion.ToTSC(context_switch_record.time_in_nanos),
+            context_switch_record.IsOut(),
+            static_cast<lldb::pid_t>(context_switch_record.pid),
+            static_cast<lldb::tid_t>(context_switch_record.tid)};
 
         if (Error err = RecoverExecutionsFromConsecutiveRecords(
                 core_id, tsc_conversion, record, prev_record,
                 [&](const ThreadContinuousExecution &execution) {
                   executions.push_back(execution);
                 }))
           return err;
 
         prev_record = record;
       }
-      offset += perf_record.header.size;
+      offset += perf_record.size;
     }
 
     // We might have an incomplete last record
     if (prev_record && prev_record->IsIn())
       executions.push_back(ThreadContinuousExecution::CreateOnlyStartExecution(
           core_id, prev_record->tid, prev_record->pid, prev_record->tsc));
     return Error::success();
   };

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

DecodedThreadSP ThreadDecoder::DoDecode() {
   return m_trace.GetTimer()
       .ForThread(m_thread_sp->GetID())
       .TimeTask<DecodedThreadSP>("Decoding instructions", [&]() {
         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) {
-              DecodeTrace(*decoded_thread_sp, m_trace, data);
+              DecodeSingleTraceForThread(*decoded_thread_sp, m_trace, data);
               return Error::success();
             });
 
         if (err)
           decoded_thread_sp->SetAsFailed(std::move(err));
         return decoded_thread_sp;
       });
 }

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

public:
   ///   The number of continuous executions found for the given \p tid.
   size_t GetNumContinuousExecutionsForThread(lldb::tid_t tid) const;
 
   /// \return
   ///   The total number of continuous executions found across CPUs.
   size_t GetTotalContinuousExecutionsCount() const;
 
 private:
-  /// Traverse the context switch traces and recover the continuous executions
-  /// by thread.
-  llvm::Error DecodeContextSwitchTraces();
+  /// Traverse the context switch traces and the basic intel pt continuous subtraces
+  /// and produce a list of continuous executions for each process and thread.
+  ///
+  /// See \a DoCorrelateContextSwitchesAndIntelPtTraces.
+  ///
+  /// Any errors are stored in \a m_setup_error.
+  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>>>
-  CorrelateContextSwitchesAndIntelPtTraces();
+  DoCorrelateContextSwitchesAndIntelPtTraces();
 
   TraceIntelPT *m_trace;
   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

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

TraceIntelPTMultiCoreDecoder::TraceIntelPTMultiCoreDecoder(TraceIntelPT &trace)
   }
 }
 
 bool TraceIntelPTMultiCoreDecoder::TracesThread(lldb::tid_t tid) const {
   return m_tids.count(tid);
 }
 
 DecodedThreadSP TraceIntelPTMultiCoreDecoder::Decode(Thread &thread) {
-  if (Error err = DecodeContextSwitchTraces())
+  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->OnAllCoresBinaryDataRead(
       IntelPTDataKinds::kTraceBuffer,
-      [&](const DenseMap<core_id_t, ArrayRef<uint8_t>> buffers) -> Error {
+      [&](const DenseMap<core_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())
-          DecodeTrace(*decoded_thread_sp, *m_trace, buffers, it->second);
+          DecodeSystemWideTraceForThread(*decoded_thread_sp, *m_trace, 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);
   return decoded_thread_sp;
 }
 
-llvm::Expected<
-    llvm::DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>>
-TraceIntelPTMultiCoreDecoder::CorrelateContextSwitchesAndIntelPtTraces() {
-  llvm::DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>
+static Expected<std::vector<IntelPTThreadSubtrace>>
+GetIntelPTSubtracesForCore(TraceIntelPT &trace, core_id_t core_id) {
+  std::vector<IntelPTThreadSubtrace> intel_pt_subtraces;
+  Error err = trace.OnCoreBinaryDataRead(
+      core_id, IntelPTDataKinds::kTraceBuffer,
+      [&](ArrayRef<uint8_t> data) -> Error {
+        Expected<std::vector<IntelPTThreadSubtrace>> split_trace =
+            SplitTraceInContinuousExecutions(trace, data);
+        if (!split_trace)
+          return split_trace.takeError();
+
+        intel_pt_subtraces = std::move(*split_trace);
+        return Error::success();
+      });
+  if (err)
+    return std::move(err);
+  return intel_pt_subtraces;
+}
+
+Expected<
+    DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>>
+TraceIntelPTMultiCoreDecoder::DoCorrelateContextSwitchesAndIntelPtTraces() {
+  DenseMap<lldb::tid_t, std::vector<IntelPTThreadContinousExecution>>
       continuous_executions_per_thread;
 
   Optional<LinuxPerfZeroTscConversion> conv_opt =
       m_trace->GetPerfZeroTscConversion();
   if (!conv_opt)
     return createStringError(
         inconvertibleErrorCode(),
         "TSC to nanoseconds conversion values were not found");
 
   LinuxPerfZeroTscConversion tsc_conversion = *conv_opt;
 
   for (core_id_t core_id : m_trace->GetTracedCores()) {
-    std::vector<IntelPTThreadSubtrace> intel_pt_executions;
-
-    Error err = m_trace->OnCoreBinaryDataRead(
-        core_id, IntelPTDataKinds::kTraceBuffer,
-        [&](ArrayRef<uint8_t> data) -> Error {
-          Expected<std::vector<IntelPTThreadSubtrace>> split_trace =
-              SplitTraceInContinuousExecutions(*m_trace, data);
-          if (!split_trace)
-            return split_trace.takeError();
-
-          intel_pt_executions = std::move(*split_trace);
-          return Error::success();
-        });
-    if (err)
-      return std::move(err);
+    Expected<std::vector<IntelPTThreadSubtrace>> intel_pt_subtraces =
+        GetIntelPTSubtracesForCore(*m_trace, core_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_executions.begin();
+    auto it = intel_pt_subtraces->begin();
     auto on_new_thread_execution =
-        [&](ThreadContinuousExecution thread_execution) {
+        [&](const ThreadContinuousExecution& thread_execution) {
           IntelPTThreadContinousExecution execution(thread_execution);
 
-          for (; it != intel_pt_executions.end() &&
+          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);
         };
-    err = m_trace->OnCoreBinaryDataRead(
+    Error err = m_trace->OnCoreBinaryDataRead(
         core_id, IntelPTDataKinds::kPerfContextSwitchTrace,
         [&](ArrayRef<uint8_t> data) -> Error {
           Expected<std::vector<ThreadContinuousExecution>> executions =
               DecodePerfContextSwitchTrace(data, core_id, tsc_conversion);
           if (!executions)
             return executions.takeError();
           for (const ThreadContinuousExecution &exec : *executions)
             on_new_thread_execution(exec);
           return Error::success();
         });
     if (err)
       return std::move(err);
   }
   // We now sort the executions of each thread to have them ready for
   // instruction decoding
   for (auto &tid_executions : continuous_executions_per_thread)
     std::sort(tid_executions.second.begin(), tid_executions.second.end());
 
   return continuous_executions_per_thread;
 }
 
-Error TraceIntelPTMultiCoreDecoder::DecodeContextSwitchTraces() {
+Error TraceIntelPTMultiCoreDecoder::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>(
       "Context switch and Intel PT traces correlation", [&]() -> Error {
-        if (auto correlation = CorrelateContextSwitchesAndIntelPtTraces()) {
+        if (auto correlation = DoCorrelateContextSwitchesAndIntelPtTraces()) {
           m_continuous_executions_per_thread.emplace(std::move(*correlation));
           return Error::success();
         } else {
           return correlation.takeError();
         }
       });
   if (err) {
     m_setup_error = toString(std::move(err));

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

"processes": [
     {
       "pid": integer,
       "triple"?: string,
           // Optional clang/llvm target triple.
       "threads": [
           // A list of known threads for the given process. When context switch
           // data is provided, LLDB will automatically create threads for the
           // this process whenever it finds new threads when traversing the
-          // context switches.
+          // context switches, so passing values to this list in this case is
+          // optional.
         {
           "tid": integer,
           "traceBuffer"?: string
               // Path to the raw Intel PT buffer file for this thread.
         }
       ],
       "modules": [
         {
"tscPerfZeroConversion"?: {
     // Values used to convert between TSCs and nanoseconds. See the time_zero
     // section in https://man7.org/linux/man-pages/man2/perf_event_open.2.html
     // for for information.
 
     "timeMult": integer,
     "timeShift": integer,
     "timeZero": integer,
   }
-  "dontCreateThreadsFromContextSwitches"?: boolean,
-    // If this is true, then the automatic creation of threads from context switch
-    // data is disabled, and thus only the threads provided in the "processes.threads"
-    // section will be created.
 }
 
 Notes:
 
 - All paths are either absolute or relative to folder containing the session file.
 - "cores" is provided if and only if processes[].threads[].traceBuffer is not provided.
 - "tscPerfZeroConversion" must be provided if "cores" is provided.
  })";