[trace][intelpt] Support system-wide tracing [10] - Return warnings and tsc information from lldb-server.

[wallace]

Summary

• Add a warnings field in the jLLDBGetState response, for warnings to be delivered to the client for troubleshooting. This removes the need to silently log lldb-server's llvm::Errors and not expose them easily to the user
• Simplify the tscPerfZeroConversion struct and schema. It used to extend a base abstract class, but I'm doubting that we'll ever add other conversion mechanisms because all modern kernels support perf zero. It is also the one who is supposed to work with the timestamps produced by the context switch trace, so expecting it is imperative.
• Force tsc collection for cpu tracing.
• Add a test checking that tscPerfZeroConversion is returned by the GetState request
• Add a pre-check for cpu tracing that makes sure that perf zero values are available.

[jj10306]

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

40

Don't we want to always reload the parameters here (ie not do this check) since they could potentially change or is that not the case?
We had discussions about this when I initially added the tsc conversion logic but I can't remember so maybe you can help refresh my memory:

[wallace]

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

40

ahh, that's a good point. We should favor the most recent instructions, which means favoring the most recent conversion params

[jj10306]

sending this back to you based on the one minor thing we discussed related to reloading. If this is addressed in one of the cleanup diffs, lmk and I'll accept this.

[wallace]

This was improved https://reviews.llvm.org/D127456

lldb/docs/lldb-gdb-remote.txt

 //          "kind": <string>,
 //              Identifier for some binary data related to this thread to
 //              fetch with the jLLDBTraceGetBinaryData packet.
 //          "size": <decimal integer>,
 //              Size in bytes of this cpu core data.
 //        },
 //      ]
 //    ],
-//    "counters"?: {
-//      "info_kind": {...parameters specific to the provided counter info kind},
-//          Each entry includes information related to counters associated with
-//          the trace. They are described below.
-//    }
+//    "warnings"?: [<string>],
+//        Non-fatal messages useful for troubleshooting.
+//
+//    ... other attributes specific to the given tracing technology
 //  }
 //
 // NOTES
 //   - "traceThreads" includes all thread traced by both "process tracing" and
 //     "thread tracing".
 //
 // INTEL PT
 //
 //  If per-core process tracing is enabled, "tracedThreads" will contain all
 //  the threads of the process without any trace buffers. Besides that, the
 //  "cores" field will also be returned with per core trace buffers.
 //  A side effect of per-core tracing is that all the threads of unrelated
 //  processes will also be traced, thus polluting the tracing data.
 //
 //  Binary data kinds:
 //    - traceBuffer: trace buffer for a thread or a core.
 //    - perfContextSwitchTrace: context switch trace for a core generated by
 //                              perf_event_open.
 //    - procfsCpuInfo: contents of the /proc/cpuinfo file.
 //
-//  Counter info kinds:
-//    tsc-perf-zero-conversion:
+//  Additional attributes:
+//    tscPerfZeroConversion:
 //
-//    This field allows converting Intel processor's TSC values to a wall time.
+//    This field allows converting Intel processor's TSC values to nanoseconds.
 //    It is available through the Linux perf_event API when cap_user_time and cap_user_time_zero
 //    are set.
 //    See the documentation of time_zero in
 //    https://man7.org/linux/man-pages/man2/perf_event_open.2.html for more information about
 //    the calculation and the meaning of the values in the schema below.
 ///
-//    Sub-schema for this field:
+//    Schema for this field:
 //
-//    {
-//      "tsc-perf-zero-conversion": {
-//        "time_mult": <decimal integer>,
-//        "time_shift": <decimal integer>,
-//        "time_zero": <decimal integer>,
-//      }
+//    "tscPerfZeroConversion": {
+//      "timeMult": <decimal integer>,
+//      "timeShift": <decimal integer>,
+//      "timeSero": <decimal integer>,
 //    }
 //----------------------------------------------------------------------
 
 send packet: jLLDBTraceGetState:{"type":<type>}]
 read packet: {...object}/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jLLDBTraceGetBinaryData

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

struct TraceCoreState {
   std::vector<TraceBinaryData> binary_data;
 };
 
 bool fromJSON(const llvm::json::Value &value, TraceCoreState &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceCoreState &packet);
 
-/// Interface for different algorithms used to convert trace
-/// counters into different units.
-template <typename ToType> class TraceCounterConversion {
-public:
-  virtual ~TraceCounterConversion() = default;
-
-  /// Convert from raw counter value to the target type.
-  ///
-  /// \param[in] raw_counter_value
-  ///   The raw counter value to be converted.
-  ///
-  /// \return
-  ///   The converted counter value.
-  virtual ToType Convert(uint64_t raw_counter_value) = 0;
-
-  /// Serialize trace counter conversion values to JSON.
-  ///
-  /// \return
-  ///   \a llvm::json::Value representing the trace counter conversion object.
-  virtual llvm::json::Value toJSON() = 0;
-};
-
-using TraceTscConversionUP =
-    std::unique_ptr<TraceCounterConversion<std::chrono::nanoseconds>>;
-
 struct TraceGetStateResponse {
   std::vector<TraceThreadState> traced_threads;
   std::vector<TraceBinaryData> process_binary_data;
   llvm::Optional<std::vector<TraceCoreState>> cores;
+  std::vector<std::string> warnings;
 };
 
 bool fromJSON(const llvm::json::Value &value, TraceGetStateResponse &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceGetStateResponse &packet);
 /// \}
 

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

 /// jLLDBTraceGetState gdb-remote packet
 /// \{
 
 /// TSC to wall time conversion values defined in the Linux perf_event_open API
 /// when the capibilities cap_user_time and cap_user_time_zero are set. See the
 /// See the documentation of `time_zero` in
 /// https://man7.org/linux/man-pages/man2/perf_event_open.2.html for more
 /// information.
-class LinuxPerfZeroTscConversion
-    : public TraceCounterConversion<std::chrono::nanoseconds> {
-public:
-  /// Create new \a LinuxPerfZeroTscConversion object from the conversion values
-  /// defined in the Linux perf_event_open API.
-  LinuxPerfZeroTscConversion(uint32_t time_mult, uint16_t time_shift,
-                             uint64_t time_zero)
-      : m_time_mult(time_mult), m_time_shift(time_shift),
-        m_time_zero(time_zero) {}
-
+struct LinuxPerfZeroTscConversion {
   /// Convert TSC value to nanosecond wall time. The beginning of time (0
   /// nanoseconds) is defined by the kernel at boot time and has no particularly
   /// useful meaning. On the other hand, this value is constant for an entire
   /// trace session.
   //  See 'time_zero' section of
   //  https://man7.org/linux/man-pages/man2/perf_event_open.2.html
   ///
   /// \param[in] tsc
   ///   The TSC value to be converted.
   ///
   /// \return
   ///   Nanosecond wall time.
-  std::chrono::nanoseconds Convert(uint64_t raw_counter_value) override;
-
-  llvm::json::Value toJSON() override;
+  std::chrono::nanoseconds ToNanos(uint64_t tsc);
 
-private:
-  uint32_t m_time_mult;
-  uint16_t m_time_shift;
-  uint64_t m_time_zero;
+  uint32_t time_mult;
+  uint16_t time_shift;
+  uint64_t time_zero;
 };
 
 struct TraceIntelPTGetStateResponse : TraceGetStateResponse {
   /// The TSC to wall time conversion if it exists, otherwise \b nullptr.
-  TraceTscConversionUP tsc_conversion;
+  llvm::Optional<LinuxPerfZeroTscConversion> tsc_perf_zero_conversion;
 };
 
 bool fromJSON(const llvm::json::Value &value,
-              TraceTscConversionUP &tsc_conversion, llvm::json::Path path);
+              LinuxPerfZeroTscConversion &packet, llvm::json::Path path);
+
+llvm::json::Value toJSON(const LinuxPerfZeroTscConversion &packet);
 
 bool fromJSON(const llvm::json::Value &value,
               TraceIntelPTGetStateResponse &packet, llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceIntelPTGetStateResponse &packet);
 /// \}
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_TRACEINTELPTGDBREMOTEPACKETS_H

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

 
 private:
   llvm::Error TraceStop(lldb::tid_t tid);
 
   /// Start tracing a specific thread.
   llvm::Error TraceStart(lldb::tid_t tid,
                          const TraceIntelPTStartRequest &request);
 
+  /// \return
+  ///   The conversion object between TSC and wall time. It caches the result
+  ///   upon success.
+  llvm::Expected<LinuxPerfZeroTscConversion &>
+  FetchPerfTscConversionParameters();
+
   /// The target process.
   NativeProcessProtocol &m_process;
   /// Threads traced due to "thread tracing"
   IntelPTThreadTraceCollection m_thread_traces;
 
   /// Only one instance of "process trace" can be active at a given time.
   /// It might be \b nullptr.
   IntelPTProcessTraceUP m_process_trace_up;
 
-  /// TSC to wall time conversion.
-  TraceTscConversionUP m_tsc_conversion;
+  /// Cached TSC to and from wall time conversion.
+  llvm::Optional<LinuxPerfZeroTscConversion> m_cached_tsc_conversion;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTCollector_H_

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

 #include <sys/syscall.h>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
 IntelPTCollector::IntelPTCollector(NativeProcessProtocol &process)
-    : m_process(process) {
+    : m_process(process) {}
+
+llvm::Expected<LinuxPerfZeroTscConversion &>
+IntelPTCollector::FetchPerfTscConversionParameters() {
+  if (!m_cached_tsc_conversion) {
     if (Expected<LinuxPerfZeroTscConversion> tsc_conversion =
             LoadPerfTscConversionParameters())
-    m_tsc_conversion =
-        std::make_unique<LinuxPerfZeroTscConversion>(*tsc_conversion);
+      m_cached_tsc_conversion = std::move(*tsc_conversion);
     else
-    LLDB_LOG_ERROR(GetLog(POSIXLog::Trace), tsc_conversion.takeError(),
-                   "unable to load TSC to wall time conversion: {0}");
+      return createStringError(inconvertibleErrorCode(),
+                               "Unable to load TSC to wall time conversion: %s",
+                               toString(tsc_conversion.takeError()).c_str());
+  }
+  return *m_cached_tsc_conversion;
 }
 
 Error IntelPTCollector::TraceStop(lldb::tid_t tid) {
   if (m_process_trace_up && m_process_trace_up->TracesThread(tid))
     return m_process_trace_up->TraceStop(tid);
   return m_thread_traces.TraceStop(tid);
 }
 
if (m_process_trace_up) {
           inconvertibleErrorCode(),
           "Process currently traced. Stop process tracing first");
     }
     if (request.IsPerCoreTracing()) {
       if (m_thread_traces.GetTracedThreadsCount() > 0)
         return createStringError(
             inconvertibleErrorCode(),
             "Threads currently traced. Stop tracing them first.");
+      // CPU tracing is useless if we can't convert tsc to nanos.
+      Expected<LinuxPerfZeroTscConversion &> tsc_conversion =
+          FetchPerfTscConversionParameters();
+      if (!tsc_conversion)
+        return tsc_conversion.takeError();
+
+      // We force the enabledment of TSCs, which is needed for correlating the
+      // cpu traces.
+      TraceIntelPTStartRequest effective_request = request;
+      effective_request.enable_tsc = true;
+
       if (Expected<IntelPTProcessTraceUP> trace =
-              IntelPTMultiCoreTrace::StartOnAllCores(request, m_process)) {
+              IntelPTMultiCoreTrace::StartOnAllCores(effective_request,
+                                                     m_process)) {
         m_process_trace_up = std::move(*trace);
         return Error::success();
       } else {
         return trace.takeError();
       }
     } else {
       std::vector<lldb::tid_t> process_threads;
       for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
Error IntelPTCollector::OnThreadDestroyed(lldb::tid_t tid) {
   return Error::success();
 }
 
 Expected<json::Value> IntelPTCollector::GetState() {
   Expected<ArrayRef<uint8_t>> cpu_info = GetProcfsCpuInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
-  TraceGetStateResponse state;
+  TraceIntelPTGetStateResponse state;
   if (m_process_trace_up)
     state = m_process_trace_up->GetState();
 
   state.process_binary_data.push_back(
       {IntelPTDataKinds::kProcFsCpuInfo, cpu_info->size()});
 
   m_thread_traces.ForEachThread(
       [&](lldb::tid_t tid, const IntelPTSingleBufferTrace &thread_trace) {
         state.traced_threads.push_back({tid,
                                         {{IntelPTDataKinds::kTraceBuffer,
                                           thread_trace.GetTraceBufferSize()}}});
       });
+
+  if (Expected<LinuxPerfZeroTscConversion &> tsc_conversion =
+          FetchPerfTscConversionParameters())
+    state.tsc_perf_zero_conversion = *tsc_conversion;
+  else
+    state.warnings.push_back(toString(tsc_conversion.takeError()));
   return toJSON(state);
 }
 
 Expected<std::vector<uint8_t>>
 IntelPTCollector::GetBinaryData(const TraceGetBinaryDataRequest &request) {
   if (request.kind == IntelPTDataKinds::kTraceBuffer) {
     if (!request.tid)
       return createStringError(

lldb/source/Plugins/Process/Linux/IntelPTMultiCoreTrace.h

void ForEachCore(std::function<void(lldb::core_id_t core_id,
                                       IntelPTSingleBufferTrace &intelpt_trace,
                                       PerfEvent &context_switch_trace)>
                        callback);
 
   void ProcessDidStop() override;
 
   void ProcessWillResume() override;
 
-  TraceGetStateResponse GetState() override;
+  TraceIntelPTGetStateResponse GetState() override;
 
   bool TracesThread(lldb::tid_t tid) const override;
 
   llvm::Error TraceStart(lldb::tid_t tid) override;
 
   llvm::Error TraceStop(lldb::tid_t tid) override;
 
   llvm::Expected<std::vector<uint8_t>>

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

void IntelPTMultiCoreTrace::ProcessWillResume() {
   ForEachCore([](core_id_t core_id, IntelPTSingleBufferTrace &core_trace) {
     if (Error err = core_trace.Resume()) {
       LLDB_LOG_ERROR(GetLog(POSIXLog::Trace), std::move(err),
                      "Unable to resume the core trace for core {0}", core_id);
     }
   });
 }
 
-TraceGetStateResponse IntelPTMultiCoreTrace::GetState() {
-  TraceGetStateResponse state;
+TraceIntelPTGetStateResponse IntelPTMultiCoreTrace::GetState() {
+  TraceIntelPTGetStateResponse state;
 
   for (size_t i = 0; m_process.GetThreadAtIndex(i); i++)
     state.traced_threads.push_back(
         TraceThreadState{m_process.GetThreadAtIndex(i)->GetID(), {}});
 
   state.cores.emplace();
   ForEachCore([&](lldb::core_id_t core_id,
                   const IntelPTSingleBufferTrace &core_trace,

lldb/source/Plugins/Process/Linux/IntelPTPerThreadProcessTrace.h

Start(const TraceIntelPTStartRequest &request,
         llvm::ArrayRef<lldb::tid_t> current_tids);
 
   bool TracesThread(lldb::tid_t tid) const override;
 
   llvm::Error TraceStart(lldb::tid_t tid) override;
 
   llvm::Error TraceStop(lldb::tid_t tid) override;
 
-  TraceGetStateResponse GetState() override;
+  TraceIntelPTGetStateResponse GetState() override;
 
   llvm::Expected<std::vector<uint8_t>>
   GetBinaryData(const TraceGetBinaryDataRequest &request) override;
 
 private:
   IntelPTPerThreadProcessTrace(const TraceIntelPTStartRequest &request)
       : m_tracing_params(request) {}
 

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

return createStringError(
         "Thread %" PRIu64 " can't be traced as the process trace size limit "
         "has been reached. Consider retracing with a higher "
         "limit.",
         tid);
 
   return m_thread_traces.TraceStart(tid, m_tracing_params);
 }
 
-TraceGetStateResponse IntelPTPerThreadProcessTrace::GetState() {
-  TraceGetStateResponse state;
+TraceIntelPTGetStateResponse IntelPTPerThreadProcessTrace::GetState() {
+  TraceIntelPTGetStateResponse state;
   m_thread_traces.ForEachThread(
       [&](lldb::tid_t tid, const IntelPTSingleBufferTrace &thread_trace) {
         state.traced_threads.push_back({tid,
                                         {{IntelPTDataKinds::kTraceBuffer,
                                           thread_trace.GetTraceBufferSize()}}});
       });
   return state;
 }

lldb/source/Plugins/Process/Linux/IntelPTProcessTrace.h

 public:
   virtual ~IntelPTProcessTrace() = default;
 
   virtual void ProcessDidStop() {}
 
   virtual void ProcessWillResume() {}
 
   /// Construct a minimal jLLDBTraceGetState response for this process trace.
-  virtual TraceGetStateResponse GetState() = 0;
+  virtual TraceIntelPTGetStateResponse GetState() = 0;
 
   virtual bool TracesThread(lldb::tid_t tid) const = 0;
 
   /// \copydoc IntelPTThreadTraceCollection::TraceStart()
   virtual llvm::Error TraceStart(lldb::tid_t tid) = 0;
 
   /// \copydoc IntelPTThreadTraceCollection::TraceStop()
   virtual llvm::Error TraceStop(lldb::tid_t tid) = 0;

lldb/source/Utility/TraceGDBRemotePackets.cpp

return json::Value(
       Object{{"tid", packet.tid}, {"binaryData", packet.binary_data}});
 }
 
 bool fromJSON(const json::Value &value, TraceGetStateResponse &packet,
               Path path) {
   ObjectMapper o(value, path);
   return o && o.map("tracedThreads", packet.traced_threads) &&
          o.map("processBinaryData", packet.process_binary_data) &&
-         o.map("cores", packet.cores);
+         o.map("cores", packet.cores) &&
+         o.mapOptional("warnings", packet.warnings);
 }
 
 json::Value toJSON(const TraceGetStateResponse &packet) {
   return json::Value(Object{{"tracedThreads", packet.traced_threads},
                             {"processBinaryData", packet.process_binary_data},
-                            {"cores", packet.cores}});
+                            {"cores", packet.cores},
+                            {"warnings", packet.warnings}});
 }
 
 bool fromJSON(const json::Value &value, TraceCoreState &packet,
               json::Path path) {
   ObjectMapper o(value, path);
   int64_t core_id;
   if (!o || !o.map("coreId", core_id) ||
       !o.map("binaryData", packet.binary_data))

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

json::Value toJSON(const TraceIntelPTStartRequest &packet) {
   obj.try_emplace("traceBufferSize", packet.trace_buffer_size);
   obj.try_emplace("processBufferSizeLimit", packet.process_buffer_size_limit);
   obj.try_emplace("psbPeriod", packet.psb_period);
   obj.try_emplace("enableTsc", packet.enable_tsc);
   obj.try_emplace("perCoreTracing", packet.per_core_tracing);
   return base;
 }
 
-std::chrono::nanoseconds
-LinuxPerfZeroTscConversion::Convert(uint64_t raw_counter_value) {
-  uint64_t quot = raw_counter_value >> m_time_shift;
-  uint64_t rem_flag = (((uint64_t)1 << m_time_shift) - 1);
-  uint64_t rem = raw_counter_value & rem_flag;
-  return std::chrono::nanoseconds{m_time_zero + quot * m_time_mult +
-                                  ((rem * m_time_mult) >> m_time_shift)};
+std::chrono::nanoseconds LinuxPerfZeroTscConversion::ToNanos(uint64_t tsc) {
+  uint64_t quot = tsc >> time_shift;
+  uint64_t rem_flag = (((uint64_t)1 << time_shift) - 1);
+  uint64_t rem = tsc & rem_flag;
+  return std::chrono::nanoseconds{time_zero + quot * time_mult +
+                                  ((rem * time_mult) >> time_shift)};
 }
 
-json::Value LinuxPerfZeroTscConversion::toJSON() {
+json::Value toJSON(const LinuxPerfZeroTscConversion &packet) {
   return json::Value(json::Object{
-      {"kind", "tsc-perf-zero-conversion"},
-      {"time_mult", m_time_mult},
-      {"time_shift", m_time_shift},
-      {"time_zero", m_time_zero},
+      {"kind", "tscPerfZeroConversion"},
+      {"timeMult", packet.time_mult},
+      {"timeShift", packet.time_shift},
+      {"timeZero", packet.time_zero},
   });
 }
 
-bool fromJSON(const json::Value &value, TraceTscConversionUP &tsc_conversion,
+bool fromJSON(const json::Value &value, LinuxPerfZeroTscConversion &packet,
               json::Path path) {
   ObjectMapper o(value, path);
-
   uint64_t time_mult, time_shift, time_zero;
-  if (!o || !o.map("time_mult", time_mult) ||
-      !o.map("time_shift", time_shift) || !o.map("time_zero", time_zero))
+  if (!o || !o.map("timeMult", time_mult) || !o.map("timeShift", time_shift) ||
+      !o.map("timeZero", time_zero))
     return false;
-
-  tsc_conversion = std::make_unique<LinuxPerfZeroTscConversion>(
-      static_cast<uint32_t>(time_mult), static_cast<uint16_t>(time_shift),
-      time_zero);
-
+  packet.time_mult = time_mult;
+  packet.time_zero = time_zero;
+  packet.time_shift = time_shift;
   return true;
 }
 
 bool fromJSON(const json::Value &value, TraceIntelPTGetStateResponse &packet,
               json::Path path) {
   ObjectMapper o(value, path);
-  if (!o || !fromJSON(value, (TraceGetStateResponse &)packet, path))
-    return false;
-
-  const Object &obj = *(value.getAsObject());
-  if (const json::Value *counters = obj.get("counters")) {
-    json::Path subpath = path.field("counters");
-    ObjectMapper ocounters(*counters, subpath);
-    if (!ocounters || !ocounters.mapOptional("tsc-perf-zero-conversion",
-                                             packet.tsc_conversion))
-      return false;
-  }
-  return true;
+  return o && fromJSON(value, (TraceGetStateResponse &)packet, path) &&
+         o.map("tscPerfZeroConversion", packet.tsc_perf_zero_conversion);
 }
 
 json::Value toJSON(const TraceIntelPTGetStateResponse &packet) {
   json::Value base = toJSON((const TraceGetStateResponse &)packet);
-
-  if (packet.tsc_conversion) {
-    std::vector<json::Value> counters{};
-    base.getAsObject()->try_emplace(
-        "counters", json::Object{{"tsc-perf-zero-conversion",
-                                  packet.tsc_conversion->toJSON()}});
-  }
-
+  base.getAsObject()->insert(
+      {"tscPerfZeroConversion", packet.tsc_perf_zero_conversion});
   return base;
 }
 
 } // namespace lldb_private

lldb/test/API/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.py

def testStartPerCoreSession(self):
         # We can't stop individual thread when per core is enabled.
         self.traceStopThread(error="True",
             substrs=["Can't stop tracing an individual thread when per-core process tracing is enabled"])
 
         # We move forward a little bit to collect some data
         self.expect("b 19")
         self.expect("c")
 
-        # We will assert that the trace state will contain valid context switch and trace buffer entries
+        # We will assert that the trace state will contain valid context switch and trace buffer entries.
+        # Besides that, we need to get tsc-to-nanos conversion information.
 
         # We first parse the json response from the custom packet
         self.runCmd("""process plugin packet send 'jLLDBTraceGetState:{"type":"intel-pt"}]'""")
         response_header = 'response: '
         output = None
         for line in self.res.GetOutput().splitlines():
             if line.find(response_header) != -1:
                 response = line[line.find(response_header) + len(response_header):].strip()
                 output = json.loads(response)
 
         self.assertTrue(output is not None)
         self.assertIn("cores", output)
+        self.assertIn("tscPerfZeroConversion", output)
         found_non_empty_context_switch = False
 
         for core in output["cores"]:
             context_switch_size = None
             trace_buffer_size = None
             for binary_data in core["binaryData"]:
                 if binary_data["kind"] == "traceBuffer":
                     trace_buffer_size = binary_data["size"]

lldb/unittests/Process/Linux/PerfTests.cpp

TEST(Perf, TscConversion) {
 
   // Skip the test if we are unable to read the TSC value.
   if (!tsc_before_sleep)
     GTEST_SKIP() << toString(tsc_before_sleep.takeError());
   if (!tsc_after_sleep)
     GTEST_SKIP() << toString(tsc_after_sleep.takeError());
 
   std::chrono::nanoseconds converted_tsc_diff =
-      params->Convert(*tsc_after_sleep) - params->Convert(*tsc_before_sleep);
+      params->ToNanos(*tsc_after_sleep) - params->ToNanos(*tsc_before_sleep);
 
   std::chrono::microseconds acceptable_overhead(500);
 
   ASSERT_GE(converted_tsc_diff.count(), SLEEP_NANOS.count());
   ASSERT_LT(converted_tsc_diff.count(),
             (SLEEP_NANOS + acceptable_overhead).count());
 }