[WIP][trace][intelpt] Add TSC to Nanosecond conversion for IntelPT traces

[jj10306]

Summary

TSC to timestamp conversion for IntelPT traces and other minor improvements:

• Add TimestampCounterRate abstract class and concrete implementation PerfTimestampCounterRate that gets conversion values from Linux's perf event API - perf_event_mmap_page
• Add resource_handle namespace to allow for reuse of file descriptor and munmap resource handles
• Cache TimestampCounterRateSP on server side in IntelPTCollector and client side in TraceIntelPT
• Update DecodedThread to allow for access to the conversion values from the TraceCursor
• Add GetNanos (to be renamed) API to TraceCursor to allow for conversion of a trace instruction's TSC value to nanoseconds
• Update trace schema and trace save commands to accommodate schema changes
• Rename IntelPTManager to IntelPTCollector

TODO:

• add unittests
• Decide on an descriptive name and other minor comments from @wallace @davidca on previous version of diff
  • Make naming consistent across all changes after the naming is decided upon
• Decide how to utilize the new TraceCursor::toNanos() API in instruction dump output
• Make documentation in lldb-gdb-remote.txt` and GetSchema() clean and descriptive given the potential for different flavors of TimestampCounterRate

[jj10306]

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

50

What is the suggested way to serialize a u64 into JSON? I thought of two approaches:

1. Store two separate u32
2. store the integer as a string

@wallace wdyt?

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

22

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

192

Not sure TraceIntelPT is the correct spot to cache the converter on the client side. It will depend on how this new logic is integrated with the decoders, but curious to get your initial feedback on this.

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

75–76

[wallace]

you got the flow correct. I left comments regarding specific details, but good job overall!!

lldb/docs/lldb-gdb-remote.txt

454–502

don't forget to f

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

50

you don't need to use int64_t here. You can use the real types here and do the conversion in the fromJson and toJson methods

54

TscToWallTimeConverter is a better name

54

use a class and not a struct. A struct has all its member public and we don't want that

57

ToNanos() is also okay. Up to you

62

63–65

you can get rid of the constructors a

69

you don't need this struct. You should just put the 3 fields here.

85

it's weird for a bag of data to contain a field transmitted by json called coverter. Just call it TimestampCounterRate. Because that's what it is. Then each TimestampCounterRate subclass can have a ToNanos(uint64_t tsc) method that converts to that.
Your documentation should specific if this ToNanos method returns the since the start of the computer, or since the start of the program, or anything else

88

Create a typedef in this file called TimestampCounterRateSP for readability. You can use tsc_rate as your variable names

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

49

remove it from here

261–263

notice the case is which g_tsc_rate is not None but nullptr. That means that the computation was performed but no rate was found, so the computation won't happen again. We have to make the code in that way because it's possible that checking for some rates is not a no-op. E.g. you can run a little 10ms program and calculate the difference in TSC to get an estimated rate.

Besides that, put all of this in a new function

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

252

static llvm::Optional<TimestampCounterRateSP> g_tsc_rate; // by default this is None

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

22

memory should be defined as a new include block between lines 9 and 11. That's just the pattern we follow

218

just replace the converter if you got a new one from the state. IT's cheap

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

191

this is null by default, no need to mention it

192

this is the right place to cache it, right next to m_cpu_info

lldb/source/Target/Trace.cpp

193–203

you can combine these blocks

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

56

fail fast whenever you can

59

you don't need to pass PerfTscConverter. make_shared should be smart enough to create the object by itself

59–60

if you do this, then you can fail fast and do the int conversions here, without polluting your class

66–68

delete this

69

return false; if you got here, then you have a kind that is not available

74

o.mapOptional is what you need here. That will return true if "tsc_conversion" is not available or if it's well-formed.

84–86

here you should cast to int64_t

[jj10306]

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

50

What is the suggested way to serialize a u64 into JSON? I thought of two approaches:

1. Store two separate u32
2. store the integer as a string

@wallace wdyt?

63–65

Need the 3 arg constructor to create an instance of this class in IntelPTManager.cpp and need the default constructor for when we create an uninitialized instance of the class before mapping the values from JSON in the fromJSON method.

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

49

Without a definition of the static member outside of the class, a linker error occurs.

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

252

Is the idea of wrapping the SP in an Optional here allows us to represent 3 different states?

1. None: we have not yet attempted to fetch/calculate the tsc rate.
2. nullptr: we tried to fetch the rate but one does not exist
3. <non-null SP>: the rate that was successfully fetched

Without the Optional, we cannot distinguish between the first two cases.

Please let me know if my understanding is correct.

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

69

in this case should we also set the SP value to be nullptr? Otherwise that value will still be None which, from my understanding, indicates that the TscRate has not yet been fetched whereas nullptr indicates that the we have tried to fetch the rate but it does not exist.

74

From looking at the source of map and mapOptional it appears that the only difference is that map sets Out to None whereas mapOptional leaves it unchanged, they both return true in the case that the property doesn't exist.

Given this, it's not immediately obvious to me which we should be using in this case - do we want the tsc_conversion to be set to None or left unchanged in the case that it's not present in the JSON?

84–86

How should we handle serializing m_time_zero since it's uint64_t and the JSON library only supports int64_t for number types?

[jj10306]

Address comments, still need to handle uint64_t JSON serialization correctly. I plan to proceed with decoder and schema changes now that initial feedback has been received and addressed.

[wallace]

in terms of functionality, everything is right, but you need to do some improvements

lldb/docs/lldb-gdb-remote.txt

454–502

you have to improve the documentation and formatting following the existing documentation's format

lldb/include/lldb/Target/Trace.h

306

JSON string representing the jLLDBTraceGetState response. It might be invalid.

310

you don't need to return a unique_ptr for this. There's nothing that you want to forbid copies of. Just return

llvm::Optional<TraceGetStateResponse>

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

14

undo this

42

TSC is not a very well known concept, so better be very explanatory in the documentation

Class that can be extended to represent different CPU Time Stamp Counter (TSC) frequency rates, which can be used to convert TSCs to common units of time, such as nanoseconds. More on TSCs can be found here https://en.wikipedia.org/wiki/Time_Stamp_Counter.

46

[wallace]

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

50

i'll respond below

52

modern c++ uses the using keyword.

using TimestampCounterRateSP = std::shared_ptr<TimestampCounterRate>;

use the version you want

54–55

You have to make the documentation very friendly to newcomers.

58

do you need this?

60

why do you do static_cast<int64_t>?

65–67

having the correct types here is the right thing to do

71

The response contains the frequency rate. Whether it's used to convert to nanos or not is a different topic.

Just delete this line.

73

avoid using nullptr when you have an Optional.

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

49

makes sense

261

sadly you can't put this here. If you do this, then GetState() will only work correctly if StartTrace() was invoked first. What if in the future we have a different flow in which lldb-server uses an additional tracing function besides StartTrace() and that new function forgets to set the tsc_rate?
This is called coupling and should be avoided.

What you should do instead is to create a new static function called llvm::Optional<TimestampCounterRateSP >GetTscRate() that will perform the perf_event request or reuse a previously saved value. It should work regardless of when it's invoked.

652

only set it if not None

if (Optional<...> tsc_rate_sp = IntelPTManager::GetTSCRate())
  state.tsc_rate = tsc_rate_sp;

699

GetTscRate is a better name, because eventually we might want to include other fallback mechanisms

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

216

don't forget to add documentation here

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

199

return None

209

None

218

make sure that everything works when lldb-server doesn't have support for the perf zero cap

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

191

use the same documentation I suggest above for the state object

lldb/source/Target/Trace.cpp

193–194

you are not storing live_process_state elsewhere. Just use an optional. That's all you need

193–194

you can fail faster to keep everything cleaner

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

60

int64_t, and give proper names

65

path.report("unsupported TSC rate kind");

make sure to write a test with malformed data

70

just return the bool

80

this kind of casting is all fine. Look at this code

#include <iostream>
#include <climits>
using namespace std;

int main() {
  uint64_t x = ULONG_MAX; // 0xFFFFFFFF;
  cout << x << endl;
  cout << (int64_t)x << endl;
  cout << (uint64_t)(int64_t)x << endl;
}

and the output is

18446744073709551615
-1
18446744073709551615

The same works for ULONG_MAX - 1, which is equivalent to -2.

So that means that there's no conversion loss

86–91

the code is simpler is you make strict use of the shared pointer only for valid cases

[labath]

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

73

Ideally this would be a plain TimestampCounterRateSP variable and nullptr would denote emptyness. Since (shared) pointers already have a natural empty state, it's best to use that. Adding an extra Optional layer just creates ambiguity.

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

22

It's actually a pattern we should not follow. When all of the includes are grouped in one block, then clang-format automatically reorders them to conform to the llvm coding standards.

[davidca]

lldb/docs/lldb-gdb-remote.txt

477

why is all this called tsc rate? there is also offset in this conversion. What about something like tsc_conversion_params or tsc_conv

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

43

nit, Intel documentation and kernel refers this as TSC, not TimestampCounter, in order to differentiate this awful name from everywhere else that "Timestamp" and "Counter" is used. Perhaps embrace TSC to make it easier to google info?

46

To be precise, it's number of nanoseconds since boot. You should also add that this nanoseconds clock is sched_clock https://www.kernel.org/doc/html/latest/timers/timekeeping.html

In fact, you may want to use sched_clock as the name for this clock, rather than Nanos as in the next lines.

77–79

should this two be static factory methods?

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

261

1. this is not a Get* method. This is populating a global. Get* are inexpensive methods that return a value.

2. if the TSC conversion parameters will be stored in a global, why not to use the Singleton pattern?

3. TSC parameters change over time. I really think that should be stored within IntelPTManager. Obtaining this parameters is a ~10 microseconds operation, so it's fine if they need to be read next time an IntelPTManager is created.

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

216

how is ti

[wallace]

Thanks @davidca and @labath for chiming in.
@jj10306, please rename IntelPTManager to IntelPTCollector for clarity.

lldb/docs/lldb-gdb-remote.txt

477

tsc_conversion_params seems like a good idea

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

43

Ahh!! Then let's do what David says. Let's call it tsc everywhere

73

Good idea

77–79

That's just the pattern most json conversion utils follow. It helps with some templating stuff

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

261

Can tsc frequency rates change even in modern cpus?. In this case, it's no brainer we need to calculate this number all the time.

I also agree with point number 1.

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

216

@davidca, i think you didn't finish your comment

[jj10306]

Will update naming and other issues once the couple minor discussions with @wallace and @davidca in the comments are complete.

lldb/docs/lldb-gdb-remote.txt

477

Agreed, making that change!

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

43

Which do you think is a better name to replace TimestampCounterRate with - TscConversionParams (as mentioned in the previous comment, "tsc_conversion_params" will be the new key in the TraceGetState packet schema, so this would be consistent with that) or TscConversioninfo or TscConverter (since the function of the class is to provide functionality to convert Tsc to time)?
@davidca @wallace wdyt?

46

Chapter 17.7 of Intel's software developer manual (volume 3) states the following:
"The time-stamp counter (as implemented in the P6 family, Pentium, Pentium M, Pentium 4, Intel Xeon, Intel Core
Solo and Intel Core Duo processors and later processors) is a 64-bit counter that is set to 0 following a RESET of
the processor."

Does a reset only occur when the system is rebooted? I mentioned the reset in the documentation here to be very specific, but if reset is always the same as boot then I agree it makes sense to change it to "nanoseconds since boot".

I'll add in the documentation that the nanoseconds being referred to here are from the the sched_clock and add the link you shared for reference.

73

Agreed, will revert back to the plain SP.

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

261

I agree that in its current state this isn't acting as a Get* function at all. However, after the comments @wallace left above, this function acts more like a Get* method as it returns the value of SP inside of the g_tsc_rate to be stored by tsc_rate

@davidca in point 3, are you suggesting that we move this field to be a member variable of IntelPTManager as opposed to a static variable because these conversion params change and thus should be fetched for each instance of the class?

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

218

Definitely, added that to the list of planned tests (in addition to malformed response JSON)

[jj10306]

Addressed most of the previous diff's comments (other than the ones from @wallace and @davidca that were explicitly mentioned in my previous comment). The naming of the conversion values is currently inconsistent, but I will update the naming and make it consistent across all the new changes once the name is agreed upon.

• Add client and server side caching of conversion values
• Update DecodedThread to allow for access to the conversion values from the TraceCursor
• Add GetNanos (to be renamed) API to TraceCursor to allow for conversion of a trace instruction's TSC value to nanoseconds
• Update trace schema and trace save commands to accommodate schema changes
• Add resource_handle namespace to allow for reuse of file descriptor and munmap resource handles
• Rename IntelPTManager to IntelPTCollector

[wallace]

lldb/docs/lldb-gdb-remote.txt

455

The ? After the key name makes Optional<> redundant. Just keep the ?

457

perf-linux might be a better name

458

All the supported kinds must be present below in the documentation, so no need to mention c++ classes here

lldb/include/lldb/Target/TraceCursor.h

193

What about just naming it GetTimestamp and return std::chrono::nanoseconds? That way we use c++ time conversion libraries and we don't include the time granularity in the name

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

46

This class is generic, so better not enforce the meaning of the zero tsc. Each trace plugin might be opinionated regarding this timestamp

64

Return a std:: Chrono type. You might want rename this to ToWallTime

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

53

Nice

223

Now that we don't have caching, try to move this method to Process Linux, as an static, so that others can use that method more easily.

253

We don't need caching anymore. Just calculate it every time we request the state, following the information that David gave that the rate might change over time.

[jj10306]

lldb/include/lldb/Target/TraceCursor.h

193

sgtm - do you think the GetTimestampCounter API's name should remain the same or change it to something like GetTsc? This file is trace agnostic so tying it to TSC could be confusing since, afaiu, TSC is intel specific, but I noticed the docs of that method mention "TSC", so curious to hear your thoughts.

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

43

Bumping this discussion related to naming

46

Good point. Given that this class is generic, would it make more sense to move it from this trace specific file TraceIntelPTGDBRemotePackets.h to TraceGDBRemotePackets.h since that file is trace agnostic?

[wallace]

The main change is to make the counter conversion generic, so that we don't need to add more APIs in the future. Besides that, you don't need to make any drastic change. Good job so far!

lldb/docs/lldb-gdb-remote.txt

455

let's make this more generic for any kind of counter we might want to include in a trace, including ones that could come from PT_WRITE, so let's call it counter_conversion

455–463

476–502

someone who wants to know more about these fields can simply open the perf_event documentation, so let's just point to it to reduce the amount of text here

lldb/include/lldb/Target/Trace.h

312

json_string is not a good name. Let's call it json_response

lldb/include/lldb/Target/TraceCursor.h

183–190

refactor this into a new function generic for all possible counters

you will need to create a new enum in lldb-enumerations.h

enum TraceCounter {

// Timestamp counter (TSC), like the one offered by Intel CPUs.
eTraceCounterTSC,

};

193

just replied above about having a generic method for all kinds of counter. Regarding this one, let's refactor it into

// Get the timestamp associated with the current instruction.
//
// Each trace plug-in might use a different 0 timestamp, e.g. time since last clock reset, time since the program started, etc.
// Also, it might happen that only some instructions of the entire trace have a timestamp associated with them.
//
//   \return
//      The timestamp associated with the current instruction, or llvm::None if not available.
virtual llvm::Optional<std::chrono::nanoseconds> GetTimestamp() = 0;

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

46

I imagine that with generic counter conversions we can't have a simple class that works for everything, but we might be able to do this:

template<typename ToType>
class TraceCounterConversion {
  virtual ~TraceCounterConversion() = default;
  virtual ToType ToNanos(uint64_t raw_counter) = 0;
  virtual llvm::json::Value toJSON() = 0;
}

also move it to TraceGDBRemotePackets as you mentioned.

Then the using statement from below could be specific for TSCs

using TraceTSCCounterRateSP = std::shared_ptr<TraceCounterConversion<uint64_t>> ;

That should work, as the intel pt plugin might explicit want a conversion type to uint64_t for its time conversions. Other hypothetical counters might be converted to double or int64_t, for example.

60

class LinuxPerfTscConversion: public TraceCounterConversion<uint64_t> {

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

1

rename this file to IntelPTCollector

699

rename this to FetchTscRate and move it to a new file lldb/source/Plugins/Process/Linux/Perf.h
you might want to move all the resource_handle functions to that file as well

700

This is the incorrect logging type. Create a new logging type POSIXLog::Trace. Ptrace is the name of the low-level linux tool used for debugging programs. Also change the logging type of the TraceStart method to match this new one

714

append the message of the errno with std::strerror(errno)

now that i think of it, you don't need to log anything here. Just return descriptive error messages and the caller should decide what to do with the errors.

724–725

return the error. The caller should decide whether to fail or to ignore the error

727

include the strerror

738–739

don't log, just return the error

747–754

we don't have caching, so the code should be like

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

315

nice

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

94–99

instead of having the decoded thread hand the tsc conversion params all the way up to here, you can create a new method llvm::Optional<std::chrono::nanoseconds> GetTimestamp(uint64_t insn_index)

let's try to have this method as simple as possible and put the implementation details at a lower level when possible

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

34–39

lldb/source/Target/TraceInstructionDumper.cpp

188–191

just like the m_show_tsc boolean there, you should add a m_show_realtime boolean. We can print the times in milliseconds, just like

[123.23ms]

printing in nanoseconds might be too much granularity for being readable

[wallace]

lldb/docs/lldb-gdb-remote.txt

455

After some more thoughts, let's just call this field 'counters'. And we can put any information related to any kind of counters.

So, we have something like

"counters"?: [{

... The tsc conversion object

}]

[jj10306]

Due to the size and expanding scope of this diff, I'm going to split this into several smaller diffs.

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.
 //      },
-//    }]
+//    }],
+//    "tsc_conversion"?: Optional<{
+//      "kind": <string>,
+//           Timestamp counter conversion rate kind, e.g. perf.
+//           The kind strings can be found in the overriden toJSON method
+//           of each TimestampCounterRate subclass. The kind determines
+//           what fields are available in the remainder of the response.
+//
+//      ... additional parameters specific to the provided tracing type and tsc_conversion kind
+//    }>
 //  }
 //
 // 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.
+//
+//  Additional params in the tsc_conversion output schema when kind == "perf":
+//   {
+//     "time_mult": <decimal integer>,
+//         time_mult field of the Linux perf_event_mmap_page struct available when
+//         cap_usr_time is set. Used in TSC to nanosecond conversion calculation defined
+//         by the Linux perf_event API.
+//
+//     "time_shift": <decimal integer>,
+//         time_shift field of the Linux perf_event_mmap_page struct available when
+//         cap_usr_time is set. Used in TSC to nanosecond conversion calculation defined
+//         by the Linux perf_event API.
+//
+//     "time_zero": <decimal integer>,
+//         time_zero field of the Linux perf_event_mmap_page struct available when
+//         cap_usr_time_zero is set. Used in TSC to nanosecond conversion calculation defined
+//         by the Linux perf_event API.
+//   }
+//
+//  Notes:
+//   - See https://en.wikipedia.org/wiki/Time_Stamp_Counter for information on the timestamp counter (TSC).
+//   - "tsc_conversion" optionally represents the information for converting the timestamp counter to the
+//     number of nanoseconds since its reset.
+//   - "time_mult", "time_shift" and "time_zero" are the three values needed to convert TSC to nanoseconds defined by
+//     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 the conversion calculation.
+//
 //----------------------------------------------------------------------
 
 send packet: jLLDBTraceGetState:{"type":<type>}]
 read packet: {...object}/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // jLLDBTraceGetBinaryData
 //
 // BRIEF

lldb/include/lldb/Target/Trace.h

protected:
   ///     A JSON object string with custom data depending on the trace
   ///     technology, or an \a llvm::Error in case of errors.
   llvm::Expected<std::string> GetLiveProcessState();
 
   /// Method to be overriden by the plug-in to refresh its own state.
   ///
   /// This is invoked by RefreshLiveProcessState when a new state is found.
   ///
-  /// \param[in] state
-  ///     The jLLDBTraceGetState response.
-  virtual void
-  DoRefreshLiveProcessState(llvm::Expected<TraceGetStateResponse> state) = 0;
+  /// \param[in] json_string
+  ///     JSON string representing the jLLDBTraceGetState response,
+  ///     it may be invalid.
+  ///
+  /// \return
+  ///     The packet response, None if response parsing failed.
+  virtual llvm::Optional<TraceGetStateResponse>
+  DoRefreshLiveProcessState(llvm::Expected<std::string> json_string) = 0;
 
   /// Method to be invoked by the plug-in to refresh the live process state.
   ///
   /// The result is cached through the same process stop.
   void RefreshLiveProcessState();
 
   uint32_t m_stop_id = LLDB_INVALID_STOP_ID;
   /// Process traced by this object if doing live tracing. Otherwise it's null.

lldb/include/lldb/Target/TraceCursor.h

public:
   virtual llvm::Error GetError() = 0;
 
   /// \return
   ///     The load address of the instruction the cursor is pointing at. If the
   ///     cursor points to an error in the trace, return \b
   ///     LLDB_INVALID_ADDRESS.
   virtual lldb::addr_t GetLoadAddress() = 0;
 
   /// Get the timestamp counter associated with the current instruction.
   /// Modern Intel, ARM and AMD processors support this counter. However, a
   /// trace plugin might decide to use a different time unit instead of an
   /// actual TSC.
   ///
   /// \return
   ///     The timestamp or \b llvm::None if not available.
   virtual llvm::Optional<uint64_t> GetTimestampCounter() = 0;
 
+  // TODO: add docs and rename once naming convention is agreed upon
+  virtual llvm::Optional<uint64_t> GetNanos() = 0;
+
   /// \return
   ///     The \a lldb::TraceInstructionControlFlowType categories the
   ///     instruction the cursor is pointing at falls into. If the cursor points
   ///     to an error in the trace, return \b 0.
   virtual lldb::TraceInstructionControlFlowType
   GetInstructionControlFlowType() = 0;
   /// \}
 

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"
 
 /// 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;
 
struct TraceIntelPTStartRequest : TraceStartRequest {
   /// then a "tracing" stop event is triggered.
   llvm::Optional<int64_t> processBufferSizeLimit;
 };
 
 bool fromJSON(const llvm::json::Value &value, TraceIntelPTStartRequest &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceIntelPTStartRequest &packet);
+
+/// Class that can be extended to represent different CPU Timestamp Counter (TSC) conversion
+/// rates, which can be used to convert TSCs to common units of time, such as nanoseconds. More
+/// on TSCs can be found here https://en.wikipedia.org/wiki/Time_Stamp_Counter.
+// TODO: update after naming convention is agreed upon
+class TimestampCounterRate {
+  public:
+    virtual ~TimestampCounterRate() = default;
+    /// Convert a TSC value to nanoseconds. This represents the number of nanoseconds since
+    /// the TSC's reset.
+    virtual uint64_t ToNanos(uint64_t tsc) = 0;
+    virtual llvm::json::Value toJSON() = 0;
+};
+
+using TimestampCounterRateSP = std::shared_ptr<TimestampCounterRate> ;
+
+/// 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.
+class PerfTimestampCounterRate : public TimestampCounterRate {
+  public:
+    PerfTimestampCounterRate(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) {}
+    uint64_t ToNanos(uint64_t tsc) override;
+    llvm::json::Value toJSON() override;
+
+  private:
+    uint32_t m_time_mult;
+    uint16_t m_time_shift;
+    uint64_t m_time_zero;
+};
+
+/// jLLDBTraceGetState gdb-remote packet
+struct TraceIntelPTGetStateResponse : TraceGetStateResponse {
+  /// Timestamp counter rate if one exists, otherwise `nullptr`.
+  TimestampCounterRateSP tsc_rate;
+};
+
+bool fromJSON(const llvm::json::Value &value, TimestampCounterRateSP &tsc_converter, 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/IntelPTManager.h

 #include <linux/perf_event.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
 namespace lldb_private {
 
 namespace process_linux {
 
-/// This class keeps track of one tracing instance of
-/// Intel(R) Processor Trace on Linux OS at thread level.
-///
-/// The kernel interface for us is the perf_event_open.
-class IntelPTThreadTrace;
-typedef std::unique_ptr<IntelPTThreadTrace> IntelPTThreadTraceUP;
-
-class IntelPTThreadTrace {
+namespace resource_handle {
 
-  class munmap_delete {
-    size_t m_length;
 
-  public:
-    munmap_delete(size_t length) : m_length(length) {}
-    void operator()(void *ptr) {
-      if (m_length)
-        munmap(ptr, m_length);
-    }
-  };
 
-  class file_close {
 
-  public:
-    file_close() = default;
-    void operator()(int *ptr) {
-      if (ptr == nullptr)
-        return;
-      if (*ptr == -1)
-        return;
-      close(*ptr);
-      std::default_delete<int>()(ptr);
-    }
-  };
 
-  std::unique_ptr<perf_event_mmap_page, munmap_delete> m_mmap_meta;
-  std::unique_ptr<uint8_t, munmap_delete> m_mmap_aux;
-  std::unique_ptr<int, file_close> m_fd;
+} // namespace resource_handle
+
+
+/// This class keeps track of one tracing instance of
+/// Intel(R) Processor Trace on Linux OS at thread level.
+///
+/// The kernel interface for us is the perf_event_open.
+class IntelPTThreadTrace;
+typedef std::unique_ptr<IntelPTThreadTrace> IntelPTThreadTraceUP;
+
+class IntelPTThreadTrace {
+
+  std::unique_ptr<perf_event_mmap_page, resource_handle::munmap_delete> m_mmap_meta;
+  std::unique_ptr<uint8_t, resource_handle::munmap_delete> m_mmap_aux;
+  std::unique_ptr<int, resource_handle::file_close> m_fd;
   lldb::tid_t m_tid;
 
   /// Start tracing a thread
   ///
   /// \param[in] pid
   ///     The pid of the process whose thread will be traced.
   ///
   /// \param[in] buffer_size
class IntelPTThreadTrace {
   ///     \a llvm::Error otherwise.
   llvm::Error StartTrace(lldb::pid_t pid, lldb::tid_t tid, uint64_t buffer_size,
                          bool enable_tsc, llvm::Optional<size_t> psb_period);
 
   llvm::MutableArrayRef<uint8_t> GetAuxBuffer() const;
   llvm::MutableArrayRef<uint8_t> GetDataBuffer() const;
 
   IntelPTThreadTrace()
-      : m_mmap_meta(nullptr, munmap_delete(0)),
-        m_mmap_aux(nullptr, munmap_delete(0)), m_fd(nullptr, file_close()) {}
+      : m_mmap_meta(nullptr, resource_handle::munmap_delete(0)),
+        m_mmap_aux(nullptr, resource_handle::munmap_delete(0)), m_fd(nullptr, resource_handle::file_close()) {}
 
 public:
   /// Get the content of /proc/cpuinfo that can be later used to decode traces.
   static llvm::Expected<llvm::ArrayRef<uint8_t>> GetCPUInfo();
 
   /// Start tracing a thread.
   ///
   /// See \a StartTrace.

 
 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 IntelPTManager {
+class IntelPTCollector {
 public:
-  IntelPTManager(lldb::pid_t pid) : m_pid(pid), m_thread_traces(pid) {}
+  IntelPTCollector(lldb::pid_t pid) : m_pid(pid), m_thread_traces(pid) {}
 
   static bool IsSupported();
+  /// Start tracing a thread
+  ///
+  /// \param[in] pid
+  ///     The process id of the thread being traced.
+  ///
+  /// \return
+  ///     \a The timestamp counter rate if one exists, \a nullptr if no conversion exists.
+  static TimestampCounterRateSP GetTscRate(lldb::pid_t pid);
+
 
   /// 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);
 
   /// Implementation of the jLLDBTraceStop packet
public:
 
   /// Implementation of the jLLDBTraceGetBinaryData packet
   llvm::Expected<std::vector<uint8_t>>
   GetBinaryData(const TraceGetBinaryDataRequest &request) const;
 
   /// Dispose of all traces
   void Clear();
 
+  /// Server-side cache of timestamp counter rate
+  static llvm::Optional<TimestampCounterRateSP> g_tsc_rate;
+
 private:
   llvm::Error TraceStop(lldb::tid_t tid);
 
   /// Start tracing a specific thread.
   llvm::Error TraceStart(lldb::tid_t tid,
                          const TraceIntelPTStartRequest &request);
 
   llvm::Expected<const IntelPTThreadTrace &>

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

 //===-- IntelPTManager.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 <algorithm>
 #include <fstream>
+#include <linux/perf_event.h>
 #include <sstream>
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 
 #include "IntelPTManager.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-types.h"
 
 #include <sys/ioctl.h>
+#include <sys/mman.h>
 #include <sys/syscall.h>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
 const char *kOSEventIntelPTTypeFile =
     "/sys/bus/event_source/devices/intel_pt/type";
 
 const char *kPSBPeriodCapFile =
     "/sys/bus/event_source/devices/intel_pt/caps/psb_cyc";
 
 const char *kPSBPeriodValidValuesFile =
     "/sys/bus/event_source/devices/intel_pt/caps/psb_periods";
 
 const char *kTSCBitOffsetFile =
     "/sys/bus/event_source/devices/intel_pt/format/tsc";
 
 const char *kPSBPeriodBitOffsetFile =
     "/sys/bus/event_source/devices/intel_pt/format/psb_period";
 
+llvm::Optional<TimestampCounterRateSP> IntelPTCollector::g_tsc_rate = llvm::None;
+
 enum IntelPTConfigFileType {
   Hex = 0,
   // 0 or 1
   ZeroOne,
   Decimal,
   // a bit index file always starts with the prefix config: following by an int,
   // which represents the offset of the perf_event_attr.config value where to
   // store a given configuration.
#else
   auto fd =
       syscall(SYS_perf_event_open, &attr, static_cast<::tid_t>(tid), -1, -1, 0);
   if (fd == -1) {
     LLDB_LOG(log, "syscall error {0}", errno);
     return createStringError(inconvertibleErrorCode(),
                              "perf event syscall failed");
   }
 
-  m_fd = std::unique_ptr<int, file_close>(new int(fd), file_close());
+  m_fd = std::unique_ptr<int, resource_handle::file_close>(new int(fd), resource_handle::file_close());
 
   errno = 0;
   auto base =
       mmap(nullptr, (buffer_size + page_size), PROT_WRITE, MAP_SHARED, fd, 0);
 
   if (base == MAP_FAILED) {
     LLDB_LOG(log, "mmap base error {0}", errno);
     return createStringError(inconvertibleErrorCode(),
                              "Meta buffer allocation failed");
   }
 
-  m_mmap_meta = std::unique_ptr<perf_event_mmap_page, munmap_delete>(
+  m_mmap_meta = std::unique_ptr<perf_event_mmap_page, resource_handle::munmap_delete>(
       reinterpret_cast<perf_event_mmap_page *>(base),
-      munmap_delete(buffer_size + page_size));
+      resource_handle::munmap_delete(buffer_size + page_size));
 
   m_mmap_meta->aux_offset = m_mmap_meta->data_offset + m_mmap_meta->data_size;
   m_mmap_meta->aux_size = buffer_size;
 
   errno = 0;
   auto mmap_aux = mmap(nullptr, buffer_size, PROT_READ, MAP_SHARED, fd,
                        static_cast<long int>(m_mmap_meta->aux_offset));
 
   if (mmap_aux == MAP_FAILED) {
     LLDB_LOG(log, "second mmap done {0}", errno);
     return createStringError(inconvertibleErrorCode(),
                              "Trace buffer allocation failed");
   }
-  m_mmap_aux = std::unique_ptr<uint8_t, munmap_delete>(
-      reinterpret_cast<uint8_t *>(mmap_aux), munmap_delete(buffer_size));
+  m_mmap_aux = std::unique_ptr<uint8_t, resource_handle::munmap_delete>(
+      reinterpret_cast<uint8_t *>(mmap_aux), resource_handle::munmap_delete(buffer_size));
   return Error::success();
 #endif
 }
 
 llvm::MutableArrayRef<uint8_t> IntelPTThreadTrace::GetDataBuffer() const {
 #ifndef PERF_ATTR_SIZE_VER5
   llvm_unreachable("Intel PT Linux perf event not supported");
 #else
Error IntelPTProcessTrace::TraceStart(lldb::tid_t tid) {
   return m_thread_traces.TraceStart(tid, m_tracing_params);
 }
 
 const IntelPTThreadTraceCollection &
 IntelPTProcessTrace::GetThreadTraces() const {
   return m_thread_traces;
 }
 
-/// IntelPTManager
+/// IntelPTCollector
 
-Error IntelPTManager::TraceStop(lldb::tid_t tid) {
+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 IntelPTManager::TraceStop(const TraceStopRequest &request) {
+Error IntelPTCollector::TraceStop(const TraceStopRequest &request) {
   if (request.IsProcessTracing()) {
     Clear();
     return Error::success();
   } else {
     Error error = Error::success();
     for (int64_t tid : *request.tids)
       error = joinErrors(std::move(error),
                          TraceStop(static_cast<lldb::tid_t>(tid)));
     return error;
   }
 }
 
-Error IntelPTManager::TraceStart(
+Error IntelPTCollector::TraceStart(
     const TraceIntelPTStartRequest &request,
     const std::vector<lldb::tid_t> &process_threads) {
   if (request.IsProcessTracing()) {
     if (IsProcessTracingEnabled()) {
       return createStringError(
           inconvertibleErrorCode(),
           "Process currently traced. Stop process tracing first");
     }
     m_process_trace = IntelPTProcessTrace(m_pid, request);
 
     Error error = Error::success();
     for (lldb::tid_t tid : process_threads)
       error = joinErrors(std::move(error), m_process_trace->TraceStart(tid));
     return error;
   } else {
     Error error = Error::success();
     for (int64_t tid : *request.tids)
       error = joinErrors(std::move(error),
                          m_thread_traces.TraceStart(tid, request));
     return error;
   }
 }
 
-Error IntelPTManager::OnThreadCreated(lldb::tid_t tid) {
+Error IntelPTCollector::OnThreadCreated(lldb::tid_t tid) {
   if (!IsProcessTracingEnabled())
     return Error::success();
   return m_process_trace->TraceStart(tid);
 }
 
-Error IntelPTManager::OnThreadDestroyed(lldb::tid_t tid) {
+Error IntelPTCollector::OnThreadDestroyed(lldb::tid_t tid) {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->TraceStop(tid);
   else if (m_thread_traces.TracesThread(tid))
     return m_thread_traces.TraceStop(tid);
   return Error::success();
 }
 
-Expected<json::Value> IntelPTManager::GetState() const {
+Expected<json::Value> IntelPTCollector::GetState() const {
   Expected<ArrayRef<uint8_t>> cpu_info = IntelPTThreadTrace::GetCPUInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
-  TraceGetStateResponse state;
+  TraceIntelPTGetStateResponse state;
   state.processBinaryData.push_back(
       {"cpuInfo", static_cast<int64_t>(cpu_info->size())});
 
   std::vector<TraceThreadState> thread_states =
       m_thread_traces.GetThreadStates();
   state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
                              thread_states.end());
 
   if (IsProcessTracingEnabled()) {
     thread_states = m_process_trace->GetThreadTraces().GetThreadStates();
     state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
                                thread_states.end());
   }
+
+  state.tsc_rate = IntelPTCollector::GetTscRate(m_pid);
   return toJSON(state);
 }
 
 Expected<const IntelPTThreadTrace &>
-IntelPTManager::GetTracedThread(lldb::tid_t tid) const {
+IntelPTCollector::GetTracedThread(lldb::tid_t tid) const {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->GetThreadTraces().GetTracedThread(tid);
   return m_thread_traces.GetTracedThread(tid);
 }
 
 Expected<std::vector<uint8_t>>
-IntelPTManager::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
+IntelPTCollector::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
   if (request.kind == "threadTraceBuffer") {
     if (Expected<const IntelPTThreadTrace &> trace =
             GetTracedThread(*request.tid))
       return trace->GetIntelPTBuffer(request.offset, request.size);
     else
       return trace.takeError();
   } else if (request.kind == "cpuInfo") {
     return IntelPTThreadTrace::GetCPUInfo();
   }
   return createStringError(inconvertibleErrorCode(),
                            "Unsuported trace binary data kind: %s",
                            request.kind.c_str());
 }
 
-void IntelPTManager::ClearProcessTracing() { m_process_trace = None; }
+void IntelPTCollector::ClearProcessTracing() { m_process_trace = None; }
 
-bool IntelPTManager::IsSupported() {
+bool IntelPTCollector::IsSupported() {
   Expected<uint32_t> intel_pt_type = GetOSEventType();
   if (!intel_pt_type) {
     llvm::consumeError(intel_pt_type.takeError());
     return false;
   }
   return true;
 }
 
-bool IntelPTManager::IsProcessTracingEnabled() const {
+bool IntelPTCollector::IsProcessTracingEnabled() const {
   return (bool)m_process_trace;
 }
 
-void IntelPTManager::Clear() {
+void IntelPTCollector::Clear() {
   ClearProcessTracing();
   m_thread_traces.Clear();
 }
+
+llvm::Expected<TimestampCounterRateSP> PerfGetTscRate(lldb::pid_t pid) {
+    Log *log = GetLog(POSIXLog::Ptrace);
+    perf_event_attr attr;
+    memset(&attr, 0, sizeof(attr));
+    // Set the minimum attributes necessary to access the mmap metadata page.
+    attr.size = sizeof(attr);
+    attr.type = PERF_TYPE_SOFTWARE;
+    attr.config = PERF_COUNT_SW_DUMMY;
+    attr.sample_type = PERF_SAMPLE_TIME;
+
+    errno = 0;
+    auto fd =
+        syscall(SYS_perf_event_open, &attr, pid, -1, -1, 0);
+    if (fd == -1) {
+      LLDB_LOG(log, "syscall error {0}", errno);
+      return createStringError(inconvertibleErrorCode(), "perf event syscall failed");
+    }
+    auto fd_handle = std::unique_ptr<int, resource_handle::file_close>(new int(fd), resource_handle::file_close());
+
+    uint64_t page_size = getpagesize();
+    errno = 0;
+    auto base =
+        mmap(nullptr, page_size, PROT_READ, MAP_SHARED, fd, 0);
+
+    if (base == MAP_FAILED) {
+      // TODO: should logging be done in this function or should the error just be returned here and let
+      // the caller log/consume the error?
+      LLDB_LOG(log, "mmap base error {0}", errno);
+      return createStringError(inconvertibleErrorCode(), "perf mmap meta allocation failed");
+    }
+    auto perf_mmap_meta_handle =
+          std::unique_ptr<perf_event_mmap_page, resource_handle::munmap_delete>(
+            reinterpret_cast<perf_event_mmap_page *>(base),
+            resource_handle::munmap_delete(page_size));
+
+    if (perf_mmap_meta_handle->cap_user_time && perf_mmap_meta_handle->cap_user_time_zero) {
+      return std::make_shared<PerfTimestampCounterRate>(perf_mmap_meta_handle->time_mult, perf_mmap_meta_handle->time_shift, perf_mmap_meta_handle->time_zero);
+    } else {
+      auto err_cap = !perf_mmap_meta_handle->cap_user_time ? "cap_user_time" : "cap_user_time_zero";
+      LLDB_LOG(log, "{0} not supported. TSC cannot be converted to time unit", err_cap);
+      return createStringError(inconvertibleErrorCode(), "TSC cannot be converted to time unit due to unsupported capabilities");
+    }
+}
+
+TimestampCounterRateSP IntelPTCollector::GetTscRate(lldb::pid_t pid) {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
+  if (!g_tsc_rate) {
+    g_tsc_rate = nullptr;
+    // Try to get a TSC rate from each different source until one succeeds
+    // Add additional sources of TSC rate, as necessary
+    if (llvm::Expected<TimestampCounterRateSP> perf_tsc_rate = PerfGetTscRate(pid))
+      g_tsc_rate = *perf_tsc_rate;
+  }
+  return *g_tsc_rate;
+#endif
+}

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

private:
 
   void ThreadWasCreated(NativeThreadLinux &thread);
 
   void SigchldHandler();
 
   Status PopulateMemoryRegionCache();
 
   /// Manages Intel PT process and thread traces.
-  IntelPTManager m_intel_pt_manager;
+  IntelPTCollector m_intel_pt_collector;
 
   // Handle a clone()-like event.
   bool MonitorClone(NativeThreadLinux &parent, lldb::pid_t child_pid,
                     int event);
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

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

 
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)
     : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
-      m_main_loop(mainloop), m_intel_pt_manager(pid) {
+      m_main_loop(mainloop), m_intel_pt_collector(pid) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
Status NativeProcessLinux::Detach() {
 
   for (const auto &thread : m_threads) {
     Status e = Detach(thread->GetID());
     if (e.Fail())
       error =
           e; // Save the error, but still attempt to detach from other threads.
   }
 
-  m_intel_pt_manager.Clear();
+  m_intel_pt_collector.Clear();
 
   return error;
 }
 
 Status NativeProcessLinux::Signal(int signo) {
   Status error;
 
   Log *log = GetLog(POSIXLog::Process);
void NativeProcessLinux::StopTrackingThread(NativeThreadLinux &thread) {
   m_threads.erase(it);
 
   NotifyTracersOfThreadDestroyed(thread_id);
   SignalIfAllThreadsStopped();
 }
 
 Status NativeProcessLinux::NotifyTracersOfNewThread(lldb::tid_t tid) {
   Log *log = GetLog(POSIXLog::Thread);
-  Status error(m_intel_pt_manager.OnThreadCreated(tid));
+  Status error(m_intel_pt_collector.OnThreadCreated(tid));
   if (error.Fail())
     LLDB_LOG(log, "Failed to trace a new thread with intel-pt, tid = {0}. {1}",
              tid, error.AsCString());
   return error;
 }
 
 Status NativeProcessLinux::NotifyTracersOfThreadDestroyed(lldb::tid_t tid) {
   Log *log = GetLog(POSIXLog::Thread);
-  Status error(m_intel_pt_manager.OnThreadDestroyed(tid));
+  Status error(m_intel_pt_collector.OnThreadDestroyed(tid));
   if (error.Fail())
     LLDB_LOG(log,
              "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}",
              tid, error.AsCString());
   return error;
 }
 
 NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id,
Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
 
   if (error.Fail())
     LLDB_LOG(log, "ptrace() failed: {0}", error);
 
   return error;
 }
 
 llvm::Expected<TraceSupportedResponse> NativeProcessLinux::TraceSupported() {
-  if (IntelPTManager::IsSupported())
+  if (IntelPTCollector::IsSupported())
     return TraceSupportedResponse{"intel-pt", "Intel Processor Trace"};
   return NativeProcessProtocol::TraceSupported();
 }
 
 Error NativeProcessLinux::TraceStart(StringRef json_request, StringRef type) {
   if (type == "intel-pt") {
     if (Expected<TraceIntelPTStartRequest> request =
             json::parse<TraceIntelPTStartRequest>(json_request,
                                                   "TraceIntelPTStartRequest")) {
       std::vector<lldb::tid_t> process_threads;
       for (auto &thread : m_threads)
         process_threads.push_back(thread->GetID());
-      return m_intel_pt_manager.TraceStart(*request, process_threads);
+      return m_intel_pt_collector.TraceStart(*request, process_threads);
     } else
       return request.takeError();
   }
 
   return NativeProcessProtocol::TraceStart(json_request, type);
 }
 
 Error NativeProcessLinux::TraceStop(const TraceStopRequest &request) {
   if (request.type == "intel-pt")
-    return m_intel_pt_manager.TraceStop(request);
+    return m_intel_pt_collector.TraceStop(request);
   return NativeProcessProtocol::TraceStop(request);
 }
 
 Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
   if (type == "intel-pt")
-    return m_intel_pt_manager.GetState();
+    return m_intel_pt_collector.GetState();
   return NativeProcessProtocol::TraceGetState(type);
 }
 
 Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
     const TraceGetBinaryDataRequest &request) {
   if (request.type == "intel-pt")
-    return m_intel_pt_manager.GetBinaryData(request);
+    return m_intel_pt_collector.GetBinaryData(request);
   return NativeProcessProtocol::TraceGetBinaryData(request);
 }

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

 #include "lldb/Target/Trace.h"
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 
 #include "intel-pt.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
+// Forward declaration for use in DecodedThread class
+class TraceIntelPT;
+
 /// Class for representing a libipt decoding error.
 class IntelPTError : public llvm::ErrorInfo<IntelPTError> {
 public:
   static char ID;
 
   /// \param[in] libipt_error_code
   ///     Negative number returned by libipt when decoding the trace and
   ///     signaling errors.

 /// the trace.
 ///
 /// Each decoded thread contains a cursor to the current position the user is
 /// stopped at. See \a Trace::GetCursorPosition for more information.
 class DecodedThread : public std::enable_shared_from_this<DecodedThread> {
 public:
   DecodedThread(lldb::ThreadSP thread_sp,
                 std::vector<IntelPTInstruction> &&instructions,
-                size_t raw_trace_size);
+                size_t raw_trace_size,
+                TraceIntelPT &trace);
 
   /// Constructor with a single error signaling a complete failure of the
   /// decoding process.
   DecodedThread(lldb::ThreadSP thread_sp, llvm::Error error);
 
   /// Get the instructions from the decoded trace. Some of them might indicate
   /// errors (i.e. gaps) in the trace.
   ///
   /// \return
   ///   The instructions of the trace.
   llvm::ArrayRef<IntelPTInstruction> GetInstructions() const;
 
   /// Get a new cursor for the decoded thread.
   lldb::TraceCursorUP GetCursor();
 
+  /// Get the TSC conversion params for the decoded thread.
+  TimestampCounterRateSP GetTscConversionParams() const;
+
   /// Get the size in bytes of the corresponding Intel PT raw trace
   ///
   /// \return
   ///   The size of the trace.
   size_t GetRawTraceSize() const;
 
 private:
   lldb::ThreadSP m_thread_sp;
   std::vector<IntelPTInstruction> m_instructions;
   size_t m_raw_trace_size;
+  TimestampCounterRateSP m_tsc_conversion_params;
 };
 
 using DecodedThreadSP = std::shared_ptr<DecodedThread>;
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_DECODEDTHREAD_H

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

 
 DecodedThread::DecodedThread(ThreadSP thread_sp, Error error)
     : m_thread_sp(thread_sp) {
   m_instructions.emplace_back(std::move(error));
 }
 
 DecodedThread::DecodedThread(ThreadSP thread_sp,
                              std::vector<IntelPTInstruction> &&instructions,
-                             size_t raw_trace_size)
+                             size_t raw_trace_size,
+                             TraceIntelPT &trace)
     : m_thread_sp(thread_sp), m_instructions(std::move(instructions)),
-      m_raw_trace_size(raw_trace_size) {
+      m_raw_trace_size(raw_trace_size), m_tsc_conversion_params(trace.GetTimestampCounterRate()) {
   if (m_instructions.empty())
     m_instructions.emplace_back(
         createStringError(inconvertibleErrorCode(), "empty trace"));
 }
 
 lldb::TraceCursorUP DecodedThread::GetCursor() {
   return std::make_unique<TraceCursorIntelPT>(m_thread_sp, shared_from_this());
 }
+
+TimestampCounterRateSP DecodedThread::GetTscConversionParams() const {
+  return m_tsc_conversion_params;
+}

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

 
 DecodedThreadSP PostMortemThreadDecoder::DoDecode() {
   size_t raw_trace_size = 0;
   if (Expected<std::vector<IntelPTInstruction>> instructions =
           DecodeTraceFile(*m_trace_thread->GetProcess(), m_trace,
                           m_trace_thread->GetTraceFile(), raw_trace_size))
     return std::make_shared<DecodedThread>(m_trace_thread->shared_from_this(),
                                            std::move(*instructions),
-                                           raw_trace_size);
+                                           raw_trace_size, m_trace);
   else
     return std::make_shared<DecodedThread>(m_trace_thread->shared_from_this(),
                                            instructions.takeError());
 }
 
 LiveThreadDecoder::LiveThreadDecoder(Thread &thread, TraceIntelPT &trace)
     : m_thread_sp(thread.shared_from_this()), m_trace(trace) {}
 
 DecodedThreadSP LiveThreadDecoder::DoDecode() {
   size_t raw_trace_size = 0;
   if (Expected<std::vector<IntelPTInstruction>> instructions =
           DecodeLiveThread(*m_thread_sp, m_trace, raw_trace_size))
     return std::make_shared<DecodedThread>(
-        m_thread_sp, std::move(*instructions), raw_trace_size);
+        m_thread_sp, std::move(*instructions), raw_trace_size, m_trace);
   else
     return std::make_shared<DecodedThread>(m_thread_sp,
                                            instructions.takeError());
 }

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

public:
   virtual bool Next() override;
 
   llvm::Error GetError() override;
 
   lldb::addr_t GetLoadAddress() override;
 
   llvm::Optional<uint64_t> GetTimestampCounter() override;
 
+  llvm::Optional<uint64_t> GetNanos() override;
+
   lldb::TraceInstructionControlFlowType
   GetInstructionControlFlowType() override;
 
   bool IsError() override;
 
 private:
   size_t GetInternalInstructionSize();
 

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

 //===-- TraceCursorIntelPT.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 "TraceCursorIntelPT.h"
+
 #include "DecodedThread.h"
-#include "TraceIntelPT.h"
 
+#include <cstdint>
 #include <cstdlib>
 
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 TraceCursorIntelPT::TraceCursorIntelPT(ThreadSP thread_sp,
                                        DecodedThreadSP decoded_thread_sp)
     : TraceCursor(thread_sp), m_decoded_thread_sp(decoded_thread_sp) {

 lldb::addr_t TraceCursorIntelPT::GetLoadAddress() {
   return m_decoded_thread_sp->GetInstructions()[m_pos].GetLoadAddress();
 }
 
 Optional<uint64_t> TraceCursorIntelPT::GetTimestampCounter() {
   return m_decoded_thread_sp->GetInstructions()[m_pos].GetTimestampCounter();
 }
 
+Optional<uint64_t> TraceCursorIntelPT::GetNanos() {
+  if (Optional<uint64_t> tsc = GetTimestampCounter()) {
+    if (TimestampCounterRateSP conversion_params_sp = m_decoded_thread_sp->GetTscConversionParams())
+      return conversion_params_sp->ToNanos(*tsc);
+  }
+  return llvm::None;
+}
+
 TraceInstructionControlFlowType
 TraceCursorIntelPT::GetInstructionControlFlowType() {
   lldb::addr_t next_load_address =
       m_pos + 1 < GetInternalInstructionSize()
           ? m_decoded_thread_sp->GetInstructions()[m_pos + 1].GetLoadAddress()
           : LLDB_INVALID_ADDRESS;
   return m_decoded_thread_sp->GetInstructions()[m_pos].GetControlFlowType(
       next_load_address);
 }

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 "IntelPTDecoder.h"
 #include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "lldb/lldb-types.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT : public Trace {
 public:
public:
   llvm::StringRef GetSchema() override;
 
   lldb::TraceCursorUP GetCursor(Thread &thread) override;
 
   void DumpTraceInfo(Thread &thread, Stream &s, bool verbose) override;
 
   llvm::Optional<size_t> GetRawTraceSize(Thread &thread);
 
-  void DoRefreshLiveProcessState(
-      llvm::Expected<TraceGetStateResponse> state) override;
+  llvm::Optional<TraceGetStateResponse> DoRefreshLiveProcessState(
+      llvm::Expected<std::string> json_string) override;
 
   bool IsTraced(lldb::tid_t tid) override;
 
   const char *GetStartConfigurationHelp() override;
 
   /// Start tracing a live process.
   ///
   /// \param[in] thread_buffer_size
llvm::Error Start(llvm::ArrayRef<lldb::tid_t> tids,
                     StructuredData::ObjectSP configuration =
                         StructuredData::ObjectSP()) override;
 
   /// Get the thread buffer content for a live thread
   llvm::Expected<std::vector<uint8_t>> GetLiveThreadBuffer(lldb::tid_t tid);
 
   llvm::Expected<pt_cpu> GetCPUInfo();
 
+  // TODO: rename and add docs after naming convention is agreed upon
+  TimestampCounterRateSP GetTimestampCounterRate();
+
   /// Get the current traced live process.
   ///
   /// \return
   ///     The current traced live process. If it's not a live process,
   ///     return \a nullptr.
   Process *GetLiveProcess();
 
 private:
   friend class TraceIntelPTSessionFileParser;
 
   llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
 
   /// \param[in] trace_threads
   ///     ThreadTrace instances, which are not live-processes and whose trace
   ///     files are fixed.
   TraceIntelPT(
       const pt_cpu &cpu_info,
-      const std::vector<lldb::ThreadPostMortemTraceSP> &traced_threads);
+      const std::vector<lldb::ThreadPostMortemTraceSP> &traced_threads,
+      const TimestampCounterRateSP tsc_conversion_params_sp);
 
   /// Constructor for live processes
   TraceIntelPT(Process &live_process)
       : Trace(live_process), m_thread_decoders(){};
 
   /// Decode the trace of the given thread that, i.e. recontruct the traced
   /// instructions.
   ///
   /// \param[in] thread
   ///     If \a thread is a \a ThreadTrace, then its internal trace file will be
   ///     decoded. Live threads are not currently supported.
   ///
   /// \return
   ///     A \a DecodedThread shared pointer with the decoded instructions. Any
   ///     errors are embedded in the instruction list.
   DecodedThreadSP Decode(Thread &thread);
 
   /// It is provided by either a session file or a live process' "cpuInfo"
   /// binary data.
   llvm::Optional<pt_cpu> m_cpu_info;
   std::map<lldb::tid_t, std::unique_ptr<ThreadDecoder>> m_thread_decoders;
   /// Error gotten after a failed live process update, if any.
   llvm::Optional<std::string> m_live_refresh_error;
+  /// \a llvm::None indicates that the program has not yet attempted to fetch the timestamp conversion rate.
+  /// After attempting to fetch, this represents the timestamp counter rate if one exists, otherwise `nullptr`.
+  llvm::Optional<TimestampCounterRateSP> m_tsc_rate;
 };
 
+using TraceIntelPTSP = std::shared_ptr<TraceIntelPT>;
+
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H

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

 #include "CommandObjectTraceStartIntelPT.h"
 #include "DecodedThread.h"
 #include "TraceIntelPTConstants.h"
 #include "TraceIntelPTSessionFileParser.h"
 #include "TraceIntelPTSessionSaver.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "llvm/ADT/None.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 LLDB_PLUGIN_DEFINE(TraceIntelPT)
 
 lldb::CommandObjectSP

 Expected<TraceSP> TraceIntelPT::CreateInstanceForLiveProcess(Process &process) {
   TraceSP instance(new TraceIntelPT(process));
   process.GetTarget().SetTrace(instance);
   return instance;
 }
 
 TraceIntelPT::TraceIntelPT(
     const pt_cpu &cpu_info,
-    const std::vector<ThreadPostMortemTraceSP> &traced_threads)
-    : m_cpu_info(cpu_info) {
+    const std::vector<ThreadPostMortemTraceSP> &traced_threads,
+    const TimestampCounterRateSP tsc_conversion_params_sp)
+    : m_cpu_info(cpu_info), m_tsc_rate(tsc_conversion_params_sp) {
   for (const ThreadPostMortemTraceSP &thread : traced_threads)
     m_thread_decoders.emplace(
         thread->GetID(),
         std::make_unique<PostMortemThreadDecoder>(thread, *this));
 }
 
 DecodedThreadSP TraceIntelPT::Decode(Thread &thread) {
   RefreshLiveProcessState();
if (!m_cpu_info) {
     if (llvm::Expected<pt_cpu> cpu_info = GetCPUInfoForLiveProcess())
       m_cpu_info = *cpu_info;
     else
       return cpu_info.takeError();
   }
   return *m_cpu_info;
 }
 
+TimestampCounterRateSP TraceIntelPT::GetTimestampCounterRate() {
+  return m_tsc_rate ? *m_tsc_rate : nullptr;
+}
+
 Process *TraceIntelPT::GetLiveProcess() { return m_live_process; }
 
-void TraceIntelPT::DoRefreshLiveProcessState(
-    Expected<TraceGetStateResponse> state) {
+llvm::Optional<TraceGetStateResponse> TraceIntelPT::DoRefreshLiveProcessState(
+    Expected<std::string> json_string) {
+
+  if (!json_string) {
+    m_live_refresh_error = toString(json_string.takeError());
+    return llvm::None;
+  }
+
   m_thread_decoders.clear();
 
+  Expected<TraceIntelPTGetStateResponse> state =
+      json::parse<TraceIntelPTGetStateResponse>(*json_string, "TraceIntelPTGetStateResponse");
+
   if (!state) {
     m_live_refresh_error = toString(state.takeError());
-    return;
+    return llvm::None;
   }
 
   for (const TraceThreadState &thread_state : state->tracedThreads) {
     Thread &thread =
         *m_live_process->GetThreadList().FindThreadByID(thread_state.tid);
     m_thread_decoders.emplace(
         thread_state.tid, std::make_unique<LiveThreadDecoder>(thread, *this));
   }
+  m_tsc_rate = state->tsc_rate;
+  return state.get();
 }
 
 bool TraceIntelPT::IsTraced(lldb::tid_t tid) {
   RefreshLiveProcessState();
   return m_thread_decoders.count(tid);
 }
 
 // The information here should match the description of the intel-pt section

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

 //===-- TraceIntelPTJSONStructs.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_TRACEINTELPTJSONSTRUCTS_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H
 
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "../common/TraceJSONStructs.h"
 #include <intel-pt.h>
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 struct JSONTraceIntelPTCPUInfo {
   JSONTraceIntelPTCPUInfo() = default;
struct JSONTraceIntelPTCPUInfo {
   int64_t model;
   int64_t stepping;
   std::string vendor;
 };
 
 struct JSONTraceIntelPTTrace {
   std::string type;
   JSONTraceIntelPTCPUInfo cpuInfo;
+  TimestampCounterRateSP tsc_conversion_params;
 };
 
 struct JSONTraceIntelPTSession {
   JSONTraceIntelPTTrace ipt_trace;
   JSONTraceSessionBase session_base;
 };
 
 struct JSONTraceIntelPTSettings : JSONTracePluginSettings {
   JSONTraceIntelPTCPUInfo cpuInfo;
+  TimestampCounterRateSP tsc_conversion_params;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 namespace llvm {
 namespace json {
 

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

 using namespace llvm;
 
 namespace llvm {
 namespace json {
 
 bool fromJSON(const Value &value, JSONTraceIntelPTSettings &plugin_settings,
               Path path) {
   ObjectMapper o(value, path);
-  return o && o.map("cpuInfo", plugin_settings.cpuInfo) &&
-         fromJSON(value, (JSONTracePluginSettings &)plugin_settings, path);
+  return o && o.map("cpuInfo", plugin_settings.cpuInfo)
+         && o.mapOptional("tsc_conversion_params", plugin_settings.tsc_conversion_params)
+         && fromJSON(value, (JSONTracePluginSettings &)plugin_settings, path);
 }
 
 bool fromJSON(const json::Value &value, JSONTraceIntelPTCPUInfo &cpu_info,
               Path path) {
   ObjectMapper o(value, path);
   return o && o.map("vendor", cpu_info.vendor) &&
          o.map("family", cpu_info.family) && o.map("model", cpu_info.model) &&
          o.map("stepping", cpu_info.stepping);
 }
 
 Value toJSON(const JSONTraceIntelPTCPUInfo &cpu_info) {
   return Value(Object{{"family", cpu_info.family},
                       {"model", cpu_info.model},
                       {"stepping", cpu_info.stepping},
                       {"vendor", cpu_info.vendor}});
 }
 
 llvm::json::Value toJSON(const JSONTraceIntelPTTrace &trace) {
   llvm::json::Object json_trace;
   json_trace["type"] = trace.type;
   json_trace["cpuInfo"] = toJSON(trace.cpuInfo);
+  json_trace["tsc_conversion_params"] = trace.tsc_conversion_params->toJSON();
   return std::move(json_trace);
 }
 
 llvm::json::Value toJSON(const JSONTraceIntelPTSession &session) {
   llvm::json::Object json_session;
   json_session["trace"] = toJSON(session.ipt_trace);
   json_session["processes"] = toJSON(session.session_base);
   return std::move(json_session);
 }
 
 } // namespace json
 } // namespace llvm

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

public:
   ///
   /// \return
   ///   A \a lldb::TraceSP instance with the trace session data. In case of
   ///   errors, return a null pointer.
   llvm::Expected<lldb::TraceSP> Parse();
 
   lldb::TraceSP
   CreateTraceIntelPTInstance(const pt_cpu &cpu_info,
-                             std::vector<ParsedProcess> &parsed_processes);
+                             std::vector<ParsedProcess> &parsed_processes,
+                             TimestampCounterRateSP tsc_conversion_params_sp);
 
 private:
   static pt_cpu ParsePTCPU(const JSONTraceIntelPTCPUInfo &cpu_info);
 
   const llvm::json::Value &m_trace_session_file;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H

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

 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 StringRef TraceIntelPTSessionFileParser::GetSchema() {
   static std::string schema;
   if (schema.empty()) {
+    // TODO: how to cleanly describe tsc_conversion_params in the schema strings
+    // given its potential different variants and it being optional?
+    // For now just putting perf variant until
+    // feedback is gathered
     schema = TraceSessionFileParser::BuildSchema(R"({
     "type": "intel-pt",
     "cpuInfo": {
       "vendor": "intel" | "unknown",
       "family": integer,
       "model": integer,
       "stepping": integer
+    },
+    "tsc_conversion_params"?: {
+        "kind": "perf",
+        "time_mult": integer,
+        "time_shift": integer,
+        "time_zero": integer
     }
   })");
   }
   return schema;
 }
 
 pt_cpu TraceIntelPTSessionFileParser::ParsePTCPU(
     const JSONTraceIntelPTCPUInfo &cpu_info) {
   return {cpu_info.vendor.compare("intel") == 0 ? pcv_intel : pcv_unknown,
           static_cast<uint16_t>(cpu_info.family),
           static_cast<uint8_t>(cpu_info.model),
           static_cast<uint8_t>(cpu_info.stepping)};
 }
 
 TraceSP TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
-    const pt_cpu &cpu_info, std::vector<ParsedProcess> &parsed_processes) {
+    const pt_cpu &cpu_info, std::vector<ParsedProcess> &parsed_processes,
+    TimestampCounterRateSP tsc_conversion_params_sp) {
   std::vector<ThreadPostMortemTraceSP> threads;
   for (const ParsedProcess &parsed_process : parsed_processes)
     threads.insert(threads.end(), parsed_process.threads.begin(),
                    parsed_process.threads.end());
 
-  TraceSP trace_instance(new TraceIntelPT(cpu_info, threads));
+  TraceSP trace_instance(new TraceIntelPT(cpu_info, threads, tsc_conversion_params_sp));
   for (const ParsedProcess &parsed_process : parsed_processes)
     parsed_process.target_sp->SetTrace(trace_instance);
 
   return trace_instance;
 }
 
 Expected<TraceSP> TraceIntelPTSessionFileParser::Parse() {
   json::Path::Root root("traceSession");
   JSONTraceSession<JSONTraceIntelPTSettings> session;
   if (!json::fromJSON(m_trace_session_file, session, root))
     return CreateJSONError(root, m_trace_session_file);
 
   if (Expected<std::vector<ParsedProcess>> parsed_processes =
           ParseCommonSessionFile(session))
     return CreateTraceIntelPTInstance(ParsePTCPU(session.trace.cpuInfo),
-                                      *parsed_processes);
+                                      *parsed_processes, session.trace.tsc_conversion_params);
   else
     return parsed_processes.takeError();
 }

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

 
 llvm::Expected<JSONTraceIntelPTTrace>
 TraceIntelPTSessionSaver::BuildTraceSection(TraceIntelPT &trace_ipt) {
   llvm::Expected<pt_cpu> cpu_info = trace_ipt.GetCPUInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
   return JSONTraceIntelPTTrace{"intel-pt",
-                               JSONTraceIntelPTCPUInfo(cpu_info.get())};
+                               JSONTraceIntelPTCPUInfo(cpu_info.get()),
+                               trace_ipt.GetTimestampCounterRate()};
 }

lldb/source/Target/Trace.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/Utility/TraceGDBRemotePackets.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.
 
void Trace::RefreshLiveProcessState() {
 
   uint32_t new_stop_id = m_live_process->GetStopID();
   if (new_stop_id == m_stop_id)
     return;
 
   m_stop_id = new_stop_id;
   m_live_thread_data.clear();
 
-  Expected<std::string> json_string = GetLiveProcessState();
-  if (!json_string) {
-    DoRefreshLiveProcessState(json_string.takeError());
+  llvm::Optional<TraceGetStateResponse> live_process_state = DoRefreshLiveProcessState(GetLiveProcessState());
+  if (!live_process_state)
     return;
-  }
-  Expected<TraceGetStateResponse> live_process_state =
-      json::parse<TraceGetStateResponse>(*json_string, "TraceGetStateResponse");
-  if (!live_process_state) {
-    DoRefreshLiveProcessState(live_process_state.takeError());
-    return;
-  }
 
   for (const TraceThreadState &thread_state :
-       live_process_state->tracedThreads) {
     for (const TraceBinaryData &item : thread_state.binaryData)
       m_live_thread_data[thread_state.tid][item.kind] = item.size;
   }
 
   for (const TraceBinaryData &item : live_process_state->processBinaryData)
     m_live_process_data[item.kind] = item.size;
 
-  DoRefreshLiveProcessState(std::move(live_process_state));
 }
 
 uint32_t Trace::GetStopID() {
   RefreshLiveProcessState();
   return m_stop_id;
 }

lldb/source/Target/TraceInstructionDumper.cpp

void TraceInstructionDumper::DumpInstructions(Stream &s, size_t count) {
   auto printInstructionIndex = [&]() {
     s.Printf("    [%*d] ", digits_count, m_index);
 
     if (m_show_tsc) {
       s.Printf("[tsc=");
 
       if (Optional<uint64_t> timestamp = m_cursor_up->GetTimestampCounter())
         s.Printf("0x%016" PRIx64, *timestamp);
+      // TODO: temporary hacky way to see new timestamp functionality
+      // How do we want to incorporate the nanosecon values into the dump output?
+      if (Optional<uint64_t> timestamp_nanos = m_cursor_up->GetNanos())
+        s.Printf(" NANOS 0x%016" PRIx64, *timestamp_nanos);
       else
         s.Printf("unavailable");
 
       s.Printf("] ");
     }
   };
 
   InstructionSymbolInfo prev_insn_info;

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"
+#include "lldb/Utility/TraceGDBRemotePackets.h"
 
 using namespace llvm;
 using namespace llvm::json;
 
 namespace lldb_private {
 
 bool fromJSON(const json::Value &value, TraceIntelPTStartRequest &packet,
               Path path) {
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;
 }
 
+uint64_t PerfTimestampCounterRate::ToNanos(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 m_time_zero + quot * m_time_mult + ((rem * m_time_mult) >> m_time_shift);
+}
+
+bool fromJSON(const llvm::json::Value &value, TimestampCounterRateSP &tsc_rate, llvm::json::Path path) {
+  std::string tsc_rate_kind;
+  ObjectMapper o(value, path);
+
+  if(!o.map("kind", tsc_rate_kind))
+    return false;
+
+  if (tsc_rate_kind == "perf") {
+    int64_t time_mult, time_shift, time_zero;
+    if (!o.map("time_mult", time_mult) || !o.map("time_shift", time_shift) || !o.map("time_zero", time_zero))
+      return false;
+    tsc_rate = std::make_shared<PerfTimestampCounterRate>((uint32_t)time_mult, (uint16_t)time_shift, (uint64_t)time_zero);
+    return true;
+  }
+  path.report("Unsupported TSC rate kind");
+  return false;
+}
+
+bool fromJSON(const json::Value &value, TraceIntelPTGetStateResponse &packet, Path path) {
+  ObjectMapper o(value, path);
+  return o && fromJSON(value, (TraceGetStateResponse &)packet, path) && o.mapOptional("tsc_rate", packet.tsc_rate);
+}
+
+llvm::json::Value PerfTimestampCounterRate::toJSON() {
+  return json::Value(json::Object{
+    {"kind", "perf"},
+    {"time_mult", (int64_t) m_time_mult},
+    {"time_shift", (int64_t) m_time_shift},
+    {"time_zero", (int64_t) m_time_zero},
+  });
+}
+
+json::Value toJSON(const TraceIntelPTGetStateResponse &packet) {
+  json::Value base = toJSON((const TraceGetStateResponse &)packet);
+  if (packet.tsc_rate)
+    base.getAsObject()->try_emplace("tsc_rate", packet.tsc_rate->toJSON());
+
+  return base;
+}
 } // namespace lldb_private