[XRay] Add TSC to NewCPUId Records

[dberris]

Summary

This more correctly reflects the data written by the FDR mode runtime.

This is a continuation of the work in D50441.

[mboerger]

llvm/include/llvm/XRay/FDRRecords.h

127 ↗

(On Diff #164807)

-explicit

[dberris]

Remove explicit from constructor.

[mboerger]

LGTM

llvm/trunk/include/llvm/XRay/FDRRecords.h

public:
   uint64_t seconds() const { return Seconds; }
   uint32_t nanos() const { return Nanos; }
 
   Error apply(RecordVisitor &V) override;
 };
 
 class NewCPUIDRecord : public MetadataRecord {
   uint16_t CPUId = 0;
+  uint64_t TSC = 0;
   friend class RecordInitializer;
 
 public:
   NewCPUIDRecord() = default;
-  explicit NewCPUIDRecord(uint16_t C) : MetadataRecord(), CPUId(C) {}
+  NewCPUIDRecord(uint16_t C, uint64_t T) : MetadataRecord(), CPUId(C), TSC(T) {}
 
   MetadataType metadataType() const override { return MetadataType::NewCPUId; }
 
   uint16_t cpuid() const { return CPUId; }
 
+  uint64_t tsc() const { return TSC; }
+
   Error apply(RecordVisitor &V) override;
 };
 
 class TSCWrapRecord : public MetadataRecord {
   uint64_t BaseTSC = 0;
   friend class RecordInitializer;
 
 public:

llvm/trunk/lib/XRay/RecordInitializer.cpp

 }
 
 Error RecordInitializer::visit(NewCPUIDRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a new cpu id record (%d).",
                              OffsetPtr);
+  auto BeginOffset = OffsetPtr;
   auto PreReadOffset = OffsetPtr;
   R.CPUId = E.getU16(&OffsetPtr);
   if (OffsetPtr == PreReadOffset)
     return createStringError(std::make_error_code(std::errc::bad_message),
                              "Cannot read CPU id at offset %d.", OffsetPtr);
 
-  OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - PreReadOffset);
+  PreReadOffset = OffsetPtr;
+  R.TSC = E.getU64(&OffsetPtr);
+  if (OffsetPtr == PreReadOffset)
+    return createStringError(std::make_error_code(std::errc::bad_message),
+                             "Cannot read CPU TSC at offset %d.", OffsetPtr);
+
+  OffsetPtr += MetadataRecord::kMetadataBodySize - (OffsetPtr - BeginOffset);
   return Error::success();
 }
 
 Error RecordInitializer::visit(TSCWrapRecord &R) {
   if (!E.isValidOffsetForDataOfSize(OffsetPtr,
                                     MetadataRecord::kMetadataBodySize))
     return createStringError(std::make_error_code(std::errc::bad_address),
                              "Invalid offset for a new TSC wrap record (%d).",

llvm/trunk/lib/XRay/RecordPrinter.cpp

 
 Error RecordPrinter::visit(WallclockRecord &R) {
   OS << formatv("<Wall Time: seconds = {0}.{1,0+6}>", R.seconds(), R.nanos())
      << Delim;
   return Error::success();
 }
 
 Error RecordPrinter::visit(NewCPUIDRecord &R) {
-  OS << formatv("<CPU ID: {0}>", R.cpuid()) << Delim;
+  OS << formatv("<CPU: id = {0}, tsc = {1}>", R.cpuid(), R.tsc()) << Delim;
   return Error::success();
 }
 
 Error RecordPrinter::visit(TSCWrapRecord &R) {
   OS << formatv("<TSC Wrap: base = {0}>", R.tsc()) << Delim;
   return Error::success();
 }
 

llvm/trunk/test/tools/llvm-xray/X86/fdr-dump-arg1-version-3.txt

 ; RUN: llvm-xray fdr-dump -verify %S/Inputs/fdr-log-arg1-version-3.xray \
 ; RUN:     | FileCheck %s
 
 ; CHECK:      [New Block]
 ; CHECK-NEXT: Preamble:
 ; CHECK-NEXT: <Thread ID: 2631>
 ; CHECK-NEXT: <Wall Time: seconds = 599605.032403>
 ; CHECK-NEXT: <PID: 2631>
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Body:
-; CHECK-NEXT:  <CPU ID: 6>
-; CHECK-NEXT:  <CPU ID: 6>
+; CHECK-NEXT:  <CPU: id = 6, tsc = 2034042117104344>
+; CHECK-NEXT:  <CPU: id = 6, tsc = 2034042117104344>
 ; CHECK-NEXT:  <TSC Wrap: base = 2034042117104344>
 ; CHECK-EMPTY:
 ; CHECK-NEXT: -  <Function Enter: #3 delta = +3>
 ; CHECK-NEXT: -  <Function Exit: #3 delta = +3>
 ; CHECK-NEXT: -  <Function Enter: #2 delta = +2>
 ; CHECK-NEXT: -  <Function Exit: #2 delta = +2>
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Metadata: <TSC Wrap: base = 2034049739853430>
 ; CHECK-EMPTY:
 ; CHECK-NEXT: -  <Function Enter: #1 delta = +1>
 ; CHECK-NEXT:  : <Call Argument: data = 67 (hex = 0x43)>
 ; CHECK-NEXT: -  <Function Exit: #1 delta = +1>
 

llvm/trunk/test/tools/llvm-xray/X86/fdr-dump-arg1.txt

 ; RUN: llvm-xray fdr-dump -verify %S/Inputs/fdr-log-arg1.xray | FileCheck %s
 
 ; CHECK:      [New Block]
 ; CHECK-NEXT: Preamble:
 ; CHECK-NEXT: <Thread ID: 14648>
 ; CHECK-NEXT: <Wall Time: seconds = 1452786.250689>
 ; CHECK-EMPTY:
 ; CHECK-NEXT: Body:
-; CHECK-NEXT:  <CPU ID: 49>
+; CHECK-NEXT:  <CPU: id = 49, tsc = 18828908666540172>
 ; CHECK-NEXT:  <TSC Wrap: base = 18828908666540172>
 ; CHECK-EMPTY:
 ; CHECK-NEXT: -  <Function Enter: #1 delta = +1>
 ; CHECK-NEXT:  : <Call Argument: data = 1 (hex = 0x1)>
 ; CHECK-NEXT: -  <Function Exit: #1 delta = +1>
 ; CHECK-NEXT:  *** <End of Buffer>
 

llvm/trunk/unittests/XRay/FDRBlockIndexerTest.cpp

 // This test ensures that we can index blocks that follow version 3 of the log
 // format.
 TEST(FDRBlockIndexerTest, IndexBlocksV3) {
   auto Block0 = LogBuilder()
                     .add<BufferExtents>(80)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   auto Block1 = LogBuilder()
                     .add<BufferExtents>(80)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   auto Block2 = LogBuilder()
                     .add<BufferExtents>(80)
                     .add<NewBufferRecord>(2)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(2)
+                    .add<NewCPUIDRecord>(2, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   BlockIndexer::Index Index;
   BlockIndexer Indexer(Index);
   // Iterate through the contrived blocks we have created above.
   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {
     // For each record in the block, we apply the indexer.

llvm/trunk/unittests/XRay/FDRBlockVerifierTest.cpp

 using ::testing::SizeIs;
 
 TEST(FDRBlockVerifierTest, ValidBlocksV3) {
   auto Block0 = LogBuilder()
                     .add<BufferExtents>(80)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   auto Block1 = LogBuilder()
                     .add<BufferExtents>(80)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   auto Block2 = LogBuilder()
                     .add<BufferExtents>(80)
                     .add<NewBufferRecord>(2)
                     .add<WallclockRecord>(1, 2)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(2)
+                    .add<NewCPUIDRecord>(2, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   BlockIndexer::Index Index;
   BlockIndexer Indexer(Index);
   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {
     for (auto &R : B.get())
       ASSERT_FALSE(errorToBool(R->apply(Indexer)));
TEST(FDRBlockVerifierTest, ValidBlocksV3) {
   }
 }
 
 TEST(FDRBlockVerifierTest, MissingPIDRecord) {
   auto Block = LogBuilder()
                    .add<BufferExtents>(20)
                    .add<NewBufferRecord>(1)
                    .add<WallclockRecord>(1, 2)
-                   .add<NewCPUIDRecord>(1)
+                   .add<NewCPUIDRecord>(1, 2)
                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                    .consume();
   BlockVerifier Verifier;
   for (auto &R : Block)
     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
   ASSERT_FALSE(errorToBool(Verifier.verify()));
 }
 
 TEST(FDRBlockVerifierTest, MissingBufferExtents) {
   auto Block = LogBuilder()
                    .add<NewBufferRecord>(1)
                    .add<WallclockRecord>(1, 2)
-                   .add<NewCPUIDRecord>(1)
+                   .add<NewCPUIDRecord>(1, 2)
                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                    .consume();
   BlockVerifier Verifier;
   for (auto &R : Block)
     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
   ASSERT_FALSE(errorToBool(Verifier.verify()));
 }
 
 TEST(FDRBlockVerifierTest, IgnoreRecordsAfterEOB) {
   auto Block = LogBuilder()
                    .add<NewBufferRecord>(1)
                    .add<WallclockRecord>(1, 2)
-                   .add<NewCPUIDRecord>(1)
+                   .add<NewCPUIDRecord>(1, 2)
                    .add<EndBufferRecord>()
                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                    .consume();
   BlockVerifier Verifier;
   for (auto &R : Block)
     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
   ASSERT_FALSE(errorToBool(Verifier.verify()));
 }
 
 TEST(FDRBlockVerifierTest, MalformedV2) {
   auto Block = LogBuilder()
                    .add<NewBufferRecord>(1)
                    .add<WallclockRecord>(1, 2)
-                   .add<NewCPUIDRecord>(1)
+                   .add<NewCPUIDRecord>(1, 2)
                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                    .add<NewBufferRecord>(2)
                    .consume();
   BlockVerifier Verifier;
 
   ASSERT_THAT(Block, SizeIs(6u));
   EXPECT_THAT_ERROR(Block[0]->apply(Verifier), Succeeded());

llvm/trunk/unittests/XRay/FDRProducerConsumerTest.cpp

template <> std::unique_ptr<Record> MakeRecord<BufferExtents>() {
   return make_unique<BufferExtents>(1);
 }
 
 template <> std::unique_ptr<Record> MakeRecord<NewBufferRecord>() {
   return make_unique<NewBufferRecord>(1);
 }
 
 template <> std::unique_ptr<Record> MakeRecord<NewCPUIDRecord>() {
-  return make_unique<NewCPUIDRecord>(1);
+  return make_unique<NewCPUIDRecord>(1, 2);
 }
 
 template <> std::unique_ptr<Record> MakeRecord<TSCWrapRecord>() {
   return make_unique<TSCWrapRecord>(1);
 }
 
 template <> std::unique_ptr<Record> MakeRecord<WallclockRecord>() {
   return make_unique<WallclockRecord>(1, 2);

llvm/trunk/unittests/XRay/FDRRecordPrinterTest.cpp

static std::unique_ptr<Record> construct() {
     return make_unique<WallclockRecord>(1, 2);
   }
 
   static const char *expected() { return "<Wall Time: seconds = 1.000002>"; }
 };
 
 template <> struct Helper<NewCPUIDRecord> {
   static std::unique_ptr<Record> construct() {
-    return make_unique<NewCPUIDRecord>(1);
+    return make_unique<NewCPUIDRecord>(1, 2);
   }
 
-  static const char *expected() { return "<CPU ID: 1>"; }
+  static const char *expected() { return "<CPU: id = 1, tsc = 2>"; }
 };
 
 template <> struct Helper<TSCWrapRecord> {
   static std::unique_ptr<Record> construct() {
     return make_unique<TSCWrapRecord>(1);
   }
 
   static const char *expected() { return "<TSC Wrap: base = 1>"; }

llvm/trunk/unittests/XRay/FDRRecordsTest.cpp

 }
 
 TEST(XRayFDRTest, BuilderAndBlockVerifier) {
   auto Block = LogBuilder()
                    .add<BufferExtents>(48)
                    .add<NewBufferRecord>(1)
                    .add<WallclockRecord>(1, 1)
                    .add<PIDRecord>(1)
-                   .add<NewCPUIDRecord>(1)
+                   .add<NewCPUIDRecord>(1, 2)
                    .consume();
   BlockVerifier Verifier;
   for (auto &R : Block)
     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
   ASSERT_FALSE(errorToBool(Verifier.verify()));
 }
 
 TEST(XRayFDRTest, IndexAndVerifyBlocks) {
   auto Block0 = LogBuilder()
                     .add<BufferExtents>(64)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   auto Block1 = LogBuilder()
                     .add<BufferExtents>(64)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
   auto Block2 = LogBuilder()
                     .add<BufferExtents>(64)
                     .add<NewBufferRecord>(1)
                     .add<WallclockRecord>(1, 1)
                     .add<PIDRecord>(1)
-                    .add<NewCPUIDRecord>(1)
+                    .add<NewCPUIDRecord>(1, 2)
                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                     .consume();
 
   // First, index the records in different blocks.
   BlockIndexer::Index Index;
   BlockIndexer Indexer(Index);
   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {

llvm/trunk/unittests/XRay/FDRTraceWriterTest.cpp

TEST(FDRTraceWriterTest, WriteToStringBufferVersion3) {
   H.NonstopTSC = true;
   H.CycleFrequency = 3e9;
   FDRTraceWriter Writer(OS, H);
   auto L = LogBuilder()
                .add<BufferExtents>(80)
                .add<NewBufferRecord>(1)
                .add<WallclockRecord>(1, 1)
                .add<PIDRecord>(1)
-               .add<NewCPUIDRecord>(1)
+               .add<NewCPUIDRecord>(1, 2)
                .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                .consume();
   for (auto &P : L)
     ASSERT_FALSE(errorToBool(P->apply(Writer)));
   OS.flush();
 
   // Then from here we load the Trace file.
TEST(FDRTraceWriterTest, WriteToStringBufferVersion2) {
   H.ConstantTSC = true;
   H.NonstopTSC = true;
   H.CycleFrequency = 3e9;
   FDRTraceWriter Writer(OS, H);
   auto L = LogBuilder()
                .add<BufferExtents>(64)
                .add<NewBufferRecord>(1)
                .add<WallclockRecord>(1, 1)
-               .add<NewCPUIDRecord>(1)
+               .add<NewCPUIDRecord>(1, 2)
                .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                .consume();
   for (auto &P : L)
     ASSERT_FALSE(errorToBool(P->apply(Writer)));
   OS.flush();
 
   // Then from here we load the Trace file.
TEST(FDRTraceWriterTest, WriteToStringBufferVersion1) {
   OS.flush();
 
   // Ensure that at this point the Data buffer has the file header serialized
   // size.
   ASSERT_THAT(Data.size(), Eq(32u));
   auto L = LogBuilder()
                .add<NewBufferRecord>(1)
                .add<WallclockRecord>(1, 1)
-               .add<NewCPUIDRecord>(1)
+               .add<NewCPUIDRecord>(1, 2)
                .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
                .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
                .add<EndBufferRecord>()
                .consume();
   for (auto &P : L)
     ASSERT_FALSE(errorToBool(P->apply(Writer)));
 
   // We need to pad the buffer with 4016 (4096 - 80) bytes of zeros.