[trace][intelpt] Server side changes for TSC to wall time conversion

[jj10306]

Summary

• Add updated schema documentation to lldb-gdb-remote.txt
• Add support for counter values in trace
• Add TSC conversion logic: cache the perf
• Move conversion calculation from Perf.h to TraceIntelPTGDBRemotePackets.h to remove dependency on linux specific headers
  • Update PerfTests to accommodate these changes
• Add TraceGDBRemotePackets unittests

Third of the series of smaller diffs that split https://reviews.llvm.org/D120595 up

[wallace]

pretty good. Just some work to do with the documentation, some naming, and using a dictionary instead of a list for the counter info kinds.

lldb/docs/lldb-gdb-remote.txt

455–462

let's use a dictionary instead of an array

465

let's delete this so that we inline the documentation in the schema above

472

let's not call it kind, because tsc-perf-conversion is not a kind of counter, but kind of information of a counter

473

let's include the word zero to distinguish from the other formula that doesn't use the time_zero value.

475

482–488

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

120

131

What about Convert?

140–141

nice

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

14–15

you can remove this one

55

let's include the word Zero in the name

71

75

88

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

532–533

yes, you need to log it. Create a new entry in the enum POSIXLog called 'Trace` and log here the reason why we couldn't get the tsc conversion values

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

11

all good

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

12–13

i imagine you can remove these

47–49

what about just inlining ToWallTime here? This indirection is not really that useful because it's private

104

this will need to be an object now

[wallace]

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

68–96

We have to change these because of our new structure. I'll include an idea

"counter": {"tsc-perf-zero-conversion": {conversion values...}}

an important detail is that the json structure is not reflected in the struct

struct TraceIntelPTGetStateResponse : TraceGetStateResponse {
  /// TSC conversion params if they exists, otherwise `nullptr`.
  TraceTscConversionSP tsc_conversion;
} ;

We don't have an intermediate Counters structure, and it might not very useful to have it. That means that you have to do some manual things.

[jj10306]

• update documentation
• update schema to use dictionary instead of array
• add Trace type to PosixLog
• rename to LinuxPerfZeroTscConversion
• clean up includes

Working on adding unittest to test the new schema's serialization/deserialization logic.

[wallace]

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

532

TIL

[clayborg]

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

142

std::unique_ptr<> instead? I am guessing we don't need to share this pointer with anyone else, just delete it when it goes out of scope? If so, std::unique_ptr is a better fit and TraceTscConversionUP would be the name to use.

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

89

TraceTscConversionUP is we switch to unique pointer

93

Might be nice to just pass in a reference to the TraceTscConversion since the value should never be NULL right?

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

239

TraceTscConversionUP is we switch to unique pointer

[jj10306]

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

93

This value is NULL when no TSC to wall time conversion exists.
Given this, what would your recommendation be for passing the TraceTscConversion data to this method to be populated?

[davidca]

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

122

this can be a normal class and only have Convert to be templated. That's simpler and let's you use the same pointer to store any instance of this class. Simplifying code that uses this class.

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

22–23

nit on last diff that I probably missed. This is loading, or reading, not fetching :D . Fetching means getting the data from somewhere else, this is reading from the same host.

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

58

this casting is not safe, I know json sucks and has not unsigned, but you should assert that the casting will not cause overflow. You can use std::numeric_limits (https://en.cppreference.com/w/cpp/types/numeric_limits)

74

unsafe casting, check for overflow, alternatively, you could have LinuxPerfZeroTscConversion have a constructor that take all ints and checks for overflow and properly casts.

[wallace]

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

93

I think it's fine passing the shared pointer in this case, given what Jakob just explained

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

58

I think in this case we are fine with numeric overflows. Doing uint64_t -> int64_t -> uint64_t starting with a positive integer larger than what int64_t can represent correctly will end up having a negative int64_t that is later converted into a uint64_t exactly the same as the the initial number. We don't want to throw or anything in this case. We want to to be able to transmit the number in any representation possible.
Another possibility is to send the number as a string, which is what JS developers do for 64 bit ints, but in this case the unsafe cast is correct.

[jj10306]

• use unique pointer instead of shared pointer, per @clayborg's suggestion
• rename FetchPerfTscConversion to LoadPerfTscConversion per @davidca's suggestion
• replace C-style casting with static_cast<>in fromJSON

[jj10306]

Add unittests for the serialization/deserialization of TraceIntelPTGetStateResponse. One tests an "empty" response and the other a non-empty response.
The non-empty response tests that the serialization to JSON isn't lossy when casting from unsigned values, followup to the discussions with @davidca and @wallace on this topic.

The newly added file currently only includes tests for the packet response this diff affects - future work could add unittests for all trace related packets to this file.

[jj10306]

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

122

From my understanding, virtual member functions cannot be templated so this forces us to make the class a template. Let me know if I'm misunderstanding your comment or if that is not the case!

[jj10306]

remove accidentally included patch file

[wallace]

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

529–530

you don't need a unique_ptr for this variable in the collector. An Optional is enough

lldb/unittests/Utility/TraceGDBRemotePacketsTest.cpp

23–26

we can make it simple with some new functions

56–57

make_unique is able to pass the arguments and construct the pointer by itself in place

76

better do

ASSERT_EQ(pre_serialization_conversion, <actual value>);
ASSERT_EQ(post_serialization_conversion, <actual value>);

I just want to prevent something breaking and returning 0 for all conversions and passing this test

[jj10306]

address comments

[wallace]

lgtm. Can we revisit the serialization of ints in a new diff if needed

lldb/docs/lldb-gdb-remote.txt

 //    "processBinaryData": [
 //      {
 //        "kind": <string>,
 //            Identifier for some binary data related to this process to
 //            fetch with the jLLDBTraceGetBinaryData packet.
 //        "size": <decimal integer>,
 //            Size in bytes of this thread 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.
+//    }
 //  }
 //
 // NOTES
 //   - "traceThreads" includes all thread traced by both "process tracing" and
 //     "thread tracing".
 //
 // INTEL PT
 //
 //  Binary data kinds:
 //    - threadTraceBuffer: trace buffer for a thread.
 //    - cpuInfo: contents of the /proc/cpuinfo file.
+//
+//  Counter info kinds:
+//    tsc-perf-zero-conversion:
+//
+//    This field allows converting Intel processor's TSC values to a wall time.
+//    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:
+//
+//    {
+//      "tsc-perf-zero-conversion": {
+//        "time_mult": <decimal integer>,
+//        "time_shift": <decimal integer>,
+//        "time_zero": <decimal integer>,
+//      }
+//    }
 //----------------------------------------------------------------------
 
 send packet: jLLDBTraceGetState:{"type":<type>}]
 read packet: {...object}/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jLLDBTraceGetBinaryData
 //

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

 //===-- TraceGDBRemotePackets.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_UTILITY_TRACEGDBREMOTEPACKETS_H
 #define LLDB_UTILITY_TRACEGDBREMOTEPACKETS_H
 
 #include "llvm/Support/JSON.h"
+#include <chrono>
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 
 /// See docs/lldb-gdb-remote.txt for more information.
 namespace lldb_private {
 
 /// jLLDBTraceSupported gdb-remote packet
struct TraceThreadState {
   std::vector<TraceBinaryData> binaryData;
 };
 
 bool fromJSON(const llvm::json::Value &value, TraceThreadState &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceThreadState &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> tracedThreads;
   std::vector<TraceBinaryData> processBinaryData;
 };
 
 bool fromJSON(const llvm::json::Value &value, TraceGetStateResponse &packet,
               llvm::json::Path path);
 

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

 //===-- TraceIntelPTGDBRemotePackets.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_UTILITY_TRACEINTELPTGDBREMOTEPACKETS_H
 #define LLDB_UTILITY_TRACEINTELPTGDBREMOTEPACKETS_H
 
 #include "lldb/Utility/TraceGDBRemotePackets.h"
 
+#include "llvm/Support/JSON.h"
+
+#include <chrono>
+
 /// See docs/lldb-gdb-remote.txt for more information.
 namespace lldb_private {
 
 /// jLLDBTraceStart gdb-remote packet
 /// \{
 struct TraceIntelPTStartRequest : TraceStartRequest {
   /// Size in bytes to use for each thread's trace buffer.
   int64_t threadBufferSize;

 };
 
 bool fromJSON(const llvm::json::Value &value, TraceIntelPTStartRequest &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceIntelPTStartRequest &packet);
 /// \}
 
+/// 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) {}
+
+  /// 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;
+
+private:
+  uint32_t m_time_mult;
+  uint16_t m_time_shift;
+  uint64_t m_time_zero;
+};
+
+struct TraceIntelPTGetStateResponse : TraceGetStateResponse {
+  /// The TSC to wall time conversion if it exists, otherwise \b nullptr.
+  TraceTscConversionUP tsc_conversion;
+};
+
+bool fromJSON(const llvm::json::Value &value,
+              TraceTscConversionUP &tsc_conversion, llvm::json::Path path);
+
+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:
   IntelPTThreadTraceCollection m_thread_traces;
   /// Params used to trace threads when the user started "process tracing".
   TraceIntelPTStartRequest m_tracing_params;
 };
 
 /// Main class that manages intel-pt process and thread tracing.
 class IntelPTCollector {
 public:
-  IntelPTCollector(lldb::pid_t pid) : m_pid(pid), m_thread_traces(pid) {}
+  IntelPTCollector(lldb::pid_t pid);
 
   static bool IsSupported();
 
   /// If "process tracing" is enabled, then trace the given thread.
   llvm::Error OnThreadCreated(lldb::tid_t tid);
 
   /// Stops tracing a tracing upon a destroy event.
   llvm::Error OnThreadDestroyed(lldb::tid_t tid);
private:
   void ClearProcessTracing();
 
   lldb::pid_t m_pid;
   /// Threads traced due to "thread tracing"
   IntelPTThreadTraceCollection m_thread_traces;
   /// Threads traced due to "process tracing". Only one active "process tracing"
   /// instance is assumed for a single process.
   llvm::Optional<IntelPTProcessTrace> m_process_trace;
+  /// TSC to wall time conversion.
+  TraceTscConversionUP m_tsc_conversion;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTCollector_H_

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

 
 const IntelPTThreadTraceCollection &
 IntelPTProcessTrace::GetThreadTraces() const {
   return m_thread_traces;
 }
 
 /// IntelPTCollector
 
+IntelPTCollector::IntelPTCollector(lldb::pid_t pid)
+    : m_pid(pid), m_thread_traces(pid) {
+  if (Expected<LinuxPerfZeroTscConversion> tsc_conversion =
+          LoadPerfTscConversionParameters())
+    m_tsc_conversion =
+        std::make_unique<LinuxPerfZeroTscConversion>(*tsc_conversion);
+  else
+    LLDB_LOG_ERROR(GetLog(POSIXLog::Trace), tsc_conversion.takeError(),
+                   "unable to load TSC to wall time conversion: {0}");
+}
+
 Error IntelPTCollector::TraceStop(lldb::tid_t tid) {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->TraceStop(tid);
   return m_thread_traces.TraceStop(tid);
 }
 
 Error IntelPTCollector::TraceStop(const TraceStopRequest &request) {
   if (request.IsProcessTracing()) {

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

 /// and classes to handle the destruction of file descriptors
 /// and mmap pointers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H
 
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/Support/Error.h"
 
 #include <chrono>
 #include <cstdint>
 #include <linux/perf_event.h>
 
private:
   resource_handle::FileDescriptorUP m_fd;
   /// Metadata page and data section where perf samples are stored.
   resource_handle::MmapUP m_metadata_data_base;
   /// AUX buffer is a separate region for high-bandwidth data streams
   /// such as IntelPT.
   resource_handle::MmapUP m_aux_base;
 };
 
-/// TSC to nanoseconds conversion values defined by the Linux perf_event API
-/// when the capibilities 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.
-struct PerfTscConversionParameters {
-  uint32_t m_time_mult;
-  uint16_t m_time_shift;
-  uint64_t m_time_zero;
-
-  /// Convert TSC value to nanosecond wall time.
-  ///
-  /// \a param[in] tsc
-  ///   The TSC value to be converted.
-  ///
-  /// \return
-  ///   Nanosecond wall time.
-  std::chrono::nanoseconds ToWallTime(uint64_t tsc);
-};
-
-/// Fetch \a PerfTscConversionParameters from \a perf_event_mmap_page, if
+/// Load \a PerfTscConversionParameters from \a perf_event_mmap_page, if
 /// available.
-llvm::Expected<PerfTscConversionParameters> FetchPerfTscConversionParameters();
+llvm::Expected<LinuxPerfZeroTscConversion> LoadPerfTscConversionParameters();
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H

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

 //===-- Perf.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 "Perf.h"
 
-#include "lldb/lldb-types.h"
-
-#include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 
-#include <chrono>
-#include <cstdint>
-#include <linux/perf_event.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
-Expected<PerfTscConversionParameters>
-lldb_private::process_linux::FetchPerfTscConversionParameters() {
+Expected<LinuxPerfZeroTscConversion>
+lldb_private::process_linux::LoadPerfTscConversionParameters() {
   lldb::pid_t pid = getpid();
   perf_event_attr attr;
   memset(&attr, 0, sizeof(attr));
   attr.size = sizeof(attr);
   attr.type = PERF_TYPE_SOFTWARE;
   attr.config = PERF_COUNT_SW_DUMMY;
 
   Expected<PerfEvent> perf_event = PerfEvent::Init(attr, pid);
   if (!perf_event)
     return perf_event.takeError();
   if (Error mmap_err = perf_event->MmapMetadataAndBuffers(/*num_data_pages*/ 0,
                                                           /*num_aux_pages*/ 0))
     return std::move(mmap_err);
 
   perf_event_mmap_page &mmap_metada = perf_event->GetMetadataPage();
   if (mmap_metada.cap_user_time && mmap_metada.cap_user_time_zero) {
-    return PerfTscConversionParameters{
+    return LinuxPerfZeroTscConversion{
         mmap_metada.time_mult, mmap_metada.time_shift, mmap_metada.time_zero};
   } else {
     auto err_cap =
         !mmap_metada.cap_user_time ? "cap_user_time" : "cap_user_time_zero";
     std::string err_msg =
         llvm::formatv("Can't get TSC to real time conversion values. "
                       "perf_event capability '{0}' not supported.",
                       err_cap);
     return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg);
   }
 }
 
-std::chrono::nanoseconds PerfTscConversionParameters::ToWallTime(uint64_t tsc) {
-  // See 'time_zero' section of
-  // https://man7.org/linux/man-pages/man2/perf_event_open.2.html
-  uint64_t quot = tsc >> m_time_shift;
-  uint64_t rem_flag = (((uint64_t)1 << m_time_shift) - 1);
-  uint64_t rem = tsc & rem_flag;
-  return std::chrono::nanoseconds{m_time_zero + quot * m_time_mult +
-                                  ((rem * m_time_mult) >> m_time_shift)};
-}
-
 void resource_handle::MmapDeleter::operator()(void *ptr) {
   if (m_bytes && ptr != nullptr)
     munmap(ptr, m_bytes);
 }
 
 void resource_handle::FileDescriptorDeleter::operator()(long *ptr) {
   if (ptr == nullptr)
     return;

lldb/source/Plugins/Process/POSIX/ProcessPOSIXLog.h

 enum class POSIXLog : Log::MaskType {
   Breakpoints = Log::ChannelFlag<0>,
   Memory = Log::ChannelFlag<1>,
   Process = Log::ChannelFlag<2>,
   Ptrace = Log::ChannelFlag<3>,
   Registers = Log::ChannelFlag<4>,
   Thread = Log::ChannelFlag<5>,
   Watchpoints = Log::ChannelFlag<6>,
-  LLVM_MARK_AS_BITMASK_ENUM(Watchpoints)
+  Trace = Log::ChannelFlag<7>,
+  LLVM_MARK_AS_BITMASK_ENUM(Trace)
 };
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 class ProcessPOSIXLog {
 public:
   static void Initialize();
 };
 
 template <> Log::Channel &LogChannelFor<POSIXLog>();
 } // namespace lldb_private
 
 #endif // liblldb_ProcessPOSIXLog_h_

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

 //===-- TraceIntelPTGDBRemotePackets.cpp ------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 
 using namespace llvm;
 using namespace llvm::json;
 
 namespace lldb_private {
 
 bool fromJSON(const json::Value &value, TraceIntelPTStartRequest &packet,
               Path path) {
   ObjectMapper o(value, path);
   if (!o || !fromJSON(value, (TraceStartRequest &)packet, path) ||
       !o.map("enableTsc", packet.enableTsc) ||
       !o.map("psbPeriod", packet.psbPeriod) ||
json::Value toJSON(const TraceIntelPTStartRequest &packet) {
   base.getAsObject()->try_emplace("threadBufferSize", packet.threadBufferSize);
   base.getAsObject()->try_emplace("processBufferSizeLimit",
                                   packet.processBufferSizeLimit);
   base.getAsObject()->try_emplace("psbPeriod", packet.psbPeriod);
   base.getAsObject()->try_emplace("enableTsc", packet.enableTsc);
   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)};
+}
+
+json::Value LinuxPerfZeroTscConversion::toJSON() {
+  return json::Value(json::Object{
+      {"kind", "tsc-perf-zero-conversion"},
+      {"time_mult", static_cast<int64_t>(m_time_mult)},
+      {"time_shift", static_cast<int64_t>(m_time_shift)},
+      {"time_zero", static_cast<int64_t>(m_time_zero)},
+  });
+}
+
+bool fromJSON(const json::Value &value, TraceTscConversionUP &tsc_conversion,
+              json::Path path) {
+  ObjectMapper o(value, path);
+
+  int64_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))
+    return false;
+
+  tsc_conversion =
+      std::make_unique<LinuxPerfZeroTscConversion>(LinuxPerfZeroTscConversion{
+          static_cast<uint32_t>(time_mult), static_cast<uint16_t>(time_shift),
+          static_cast<uint64_t>(time_zero)});
+
+  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;
+}
+
+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()}});
+  }
+
+  return base;
+}
+
 } // namespace lldb_private

lldb/unittests/Process/Linux/PerfTests.cpp

TEST(Perf, TscConversion) {
   // finally ensuring the difference is approximately equal to the sleep time.
   //
   // There will be slight overhead associated with the sleep call, so it isn't
   // reasonable to expect the difference to be exactly equal to the sleep time.
 
   const int SLEEP_SECS = 1;
   std::chrono::nanoseconds SLEEP_NANOS{std::chrono::seconds(SLEEP_SECS)};
 
-  Expected<PerfTscConversionParameters> params =
-      FetchPerfTscConversionParameters();
+  Expected<LinuxPerfZeroTscConversion> params =
+      LoadPerfTscConversionParameters();
 
   // Skip the test if the conversion parameters aren't available.
   if (!params)
     GTEST_SKIP() << toString(params.takeError());
 
   Expected<uint64_t> tsc_before_sleep = readTsc();
   sleep(SLEEP_SECS);
   Expected<uint64_t> tsc_after_sleep = readTsc();
 
   // 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->ToWallTime(*tsc_after_sleep) -
-      params->ToWallTime(*tsc_before_sleep);
+      params->Convert(*tsc_after_sleep) - params->Convert(*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());
 }
 
 #endif // __x86_64__

lldb/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests
   StringExtractorTest.cpp
   StringLexerTest.cpp
   StringListTest.cpp
   StructuredDataTest.cpp
   SubsystemRAIITest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   TimerTest.cpp
+  TraceGDBRemotePacketsTest.cpp
   UriParserTest.cpp
   UserIDResolverTest.cpp
   UUIDTest.cpp
   VASprintfTest.cpp
   VMRangeTest.cpp
   XcodeSDKTest.cpp
 
   LINK_LIBS

lldb/unittests/Utility/TraceGDBRemotePacketsTest.cpp

+//===-- TraceGDBRemotePacketsTest.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 "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
+
+#include "gtest/gtest.h"
+
+#include <limits>
+
+using namespace lldb_private;
+using namespace llvm;
+
+// Helper function to serialize a reponse, and then deserialize that serialized
+// response.
+static Expected<TraceIntelPTGetStateResponse>
+SerializeThenDeserialize(TraceIntelPTGetStateResponse &response) {
+  // Serialize
+  json::Value value = toJSON(response);
+  std::string json_string;
+  raw_string_ostream os(json_string);
+  os << value;
+  // Deserialize
+  return json::parse<TraceIntelPTGetStateResponse>(
+      json_string, "TraceIntelPTGetStateResponse");
+}
+
+// Test serialization and deserialization of a non-empty
+// TraceIntelPTGetStateResponse.
+TEST(TraceGDBRemotePacketsTest, IntelPTGetStateResponse) {
+  // This test works as follows:
+  //  1. Create a non-empty TraceIntelPTGetStateResponse
+  //  2. Serialize to JSON
+  //  3. Deserialize the serialized JSON value
+  //  4. Ensure the original value and the deserialized value are equivalent
+  //
+  //  Notes:
+  //    - We intentionally set an integer value out of its signed range
+  //      to ensure the serialization/deserialization isn't lossy since JSON
+  //      operates on signed values
+
+  // Choose arbitrary values for time_mult and time_shift
+  uint32_t test_time_mult = 1076264588;
+  uint16_t test_time_shift = 31;
+  // Intentionally set time_zero value out of the signed type's range.
+  uint64_t test_time_zero =
+      static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + 1;
+
+  // Create TraceIntelPTGetStateResponse
+  TraceIntelPTGetStateResponse response;
+  response.tsc_conversion =
+      std::make_unique<LinuxPerfZeroTscConversion>(LinuxPerfZeroTscConversion(
+          test_time_mult, test_time_shift, test_time_zero));
+
+  Expected<TraceIntelPTGetStateResponse> deserialized_response =
+      SerializeThenDeserialize(response);
+  if (!deserialized_response)
+    FAIL() << toString(deserialized_response.takeError());
+
+  // Choose arbitrary TSC value to test the Convert function.
+  const uint64_t TSC = std::numeric_limits<uint32_t>::max();
+  uint64_t pre_serialization_conversion =
+      response.tsc_conversion->Convert(TSC).count();
+  uint64_t post_serialization_conversion =
+      deserialized_response->tsc_conversion->Convert(TSC).count();
+
+  // Check equality:
+  // Ensure that both the TraceGetStateResponse and TraceIntelPTGetStateResponse
+  // portions of the JSON representation are unchanged.
+  ASSERT_EQ(toJSON(response), toJSON(*deserialized_response));
+  // Ensure the result of the Convert function is unchanged.
+  ASSERT_EQ(pre_serialization_conversion, post_serialization_conversion);
+}
+
+// Test serialization and deserialization of an empty
+// TraceIntelPTGetStateResponse.
+TEST(TraceGDBRemotePacketsTest, IntelPTGetStateResponseEmpty) {
+  // This test works as follows:
+  //  1. Create an empty TraceIntelPTGetStateResponse
+  //  2. Serialize to JSON
+  //  3. Deserialize the serialized JSON value
+  //  4. Ensure the original value and the deserialized value are equivalent
+
+  // Create TraceIntelPTGetStateResponse
+  TraceIntelPTGetStateResponse response;
+
+  Expected<TraceIntelPTGetStateResponse> deserialized_response =
+      SerializeThenDeserialize(response);
+  if (!deserialized_response)
+    FAIL() << toString(deserialized_response.takeError());
+
+  // Check equality:
+  // Ensure that both the TraceGetStateResponse and TraceIntelPTGetStateResponse
+  // portions of the JSON representation are unchanged.
+  ASSERT_EQ(toJSON(response), toJSON(*deserialized_response));
+  // Ensure that the tsc_conversion's are nullptr
+  ASSERT_EQ(response.tsc_conversion.get(), nullptr);
+  ASSERT_EQ(response.tsc_conversion.get(),
+            deserialized_response->tsc_conversion.get());
+}