[memprof] Introduce a wrapper around MemInfoBlock.

[snehasish]

Summary

Use the macro based format to add a wrapper around the MemInfoBlock
when stored in the MemProfRecord. This wrapped block can then be
serialized/deserialized based on a schema specified by a list of enums.

[vitalybuka]

This patch has two parts:

Can this be done as two patches then?

[snehasish]

In D117256#3242050, @vitalybuka wrote:

This patch has two parts:

Can this be done as two patches then?

I did start out with two commits but then merged them into one before putting it up for review since it seemed easier. I'll wait for @tejohnson / @davidxl to chime in before splitting it into two.

[tejohnson]

lgtm but I think it would be nice to split into 2 patches, i.e. first the rename, which unfortunately does cause a little bit of extra churn on your end. But then it makes the new wrapper and inc file changes a little cleaner.

[hiraditya]

compiler-rt/include/profile/MemProfData.inc

86 ↗

(On Diff #399800)

by MemProfData.inc, do we mean 'compiler-rt/include/profile/MemProfData.inc' the current file, or 'include/llvm/ProfileData/MemProfData.inc'?

[snehasish]

Rebase after splitting out changes to MemInfoBlock (D117722).

[snehasish]

In D117256#3246296, @tejohnson wrote:

lgtm but I think it would be nice to split into 2 patches, i.e. first the rename, which unfortunately does cause a little bit of extra churn on your end. But then it makes the new wrapper and inc file changes a little cleaner.

Done, uploaded the rename patch as D117722.

by MemProfData.inc, do we mean 'compiler-rt/include/profile/MemProfData.inc' the current file, or 'include/llvm/ProfileData/MemProfData.inc'?

@hiraditya Both files since they should be kept in sync. Instead of having dependencies across llvm and compiler-rt we use a .inc file (similar to InstrProfData.inc).

PTAL thanks!

compiler-rt/include/profile/MemProfData.inc

86 ↗

(On Diff #399800)

by MemProfData.inc, do we mean 'compiler-rt/include/profile/MemProfData.inc' the current file, or 'include/llvm/ProfileData/MemProfData.inc'?

[tejohnson]

lgtm

[snehasish]

Rebase and update with some fixes for unaligned reads.
Also update the unittest.

llvm/include/llvm/ProfileData/MemProf.h

 #ifndef LLVM_PROFILEDATA_MEMPROF_H_
 #define LLVM_PROFILEDATA_MEMPROF_H_
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ProfileData/MemProfData.inc"
+#include "llvm/ProfileData/ProfileCommon.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/EndianStream.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace memprof {
 
+enum class Meta : uint64_t {
+  Start = 0,
+#define MIBEntryDef(NameTag, Name, Type) NameTag,
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+  Size
+};
+
+using MemProfSchema = llvm::SmallVector<Meta, static_cast<int>(Meta::Size)>;
+
+// Holds the actual MemInfoBlock data with all fields. Contents may be read or
+// written partially by providing an appropriate schema to the serialize and
+// deserialize methods.
+struct PortableMemInfoBlock {
+  PortableMemInfoBlock() = default;
+  explicit PortableMemInfoBlock(const MemInfoBlock &Block) {
+#define MIBEntryDef(NameTag, Name, Type) Name = Block.Name;
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+  }
+
+  PortableMemInfoBlock(const MemProfSchema &Schema, const unsigned char *Ptr) {
+    deserialize(Schema, Ptr);
+  }
+
+  // Read the contents of \p Ptr based on the \p Schema to populate the
+  // MemInfoBlock member.
+  void deserialize(const MemProfSchema &Schema, const unsigned char *Ptr) {
+    using namespace support;
+
+    for (const Meta Id : Schema) {
+      switch (Id) {
+#define MIBEntryDef(NameTag, Name, Type)                                       \
+  case Meta::Name: {                                                           \
+    Name = endian::readNext<Type, little, unaligned>(Ptr);                     \
+  } break;
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+      default:
+        llvm_unreachable("Unknown meta type id, is the profile collected from "
+                         "a newer version of the runtime?");
+      }
+    }
+  }
+
+  // Write the contents of the MemInfoBlock based on the \p Schema provided to
+  // the raw_ostream \p OS.
+  void serialize(const MemProfSchema &Schema, raw_ostream &OS) const {
+    using namespace support;
+
+    endian::Writer LE(OS, little);
+    for (const Meta Id : Schema) {
+      switch (Id) {
+#define MIBEntryDef(NameTag, Name, Type)                                       \
+  case Meta::Name: {                                                           \
+    LE.write<Type>(Name);                                                      \
+  } break;
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+      default:
+        llvm_unreachable("Unknown meta type id, invalid input?");
+      }
+    }
+  }
+
+  // Print out the contents of the MemInfoBlock in YAML format.
+  void printYAML(raw_ostream &OS) const {
+    OS << "    MemInfoBlock:\n";
+#define MIBEntryDef(NameTag, Name, Type)                                       \
+  OS << "      " << #Name << ": " << Name << "\n";
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+  }
+
+  // Define getters for each type which can be called by analyses.
+#define MIBEntryDef(NameTag, Name, Type)                                       \
+  Type get##Name() const { return Name; }
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+
+  void clear() { *this = PortableMemInfoBlock(); }
+
+  // Returns the full schema currently in use.
+  static MemProfSchema getSchema() {
+    MemProfSchema List;
+#define MIBEntryDef(NameTag, Name, Type) List.push_back(Meta::Name);
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+    return List;
+  }
+
+  bool operator==(const PortableMemInfoBlock &Other) const {
+#define MIBEntryDef(NameTag, Name, Type)                                       \
+  if (Other.get##Name() != get##Name())                                        \
+    return false;
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+    return true;
+  }
+
+  bool operator!=(const PortableMemInfoBlock &Other) const {
+    return !operator==(Other);
+  }
+
+  static constexpr size_t serializedSize() {
+    size_t Result = 0;
+#define MIBEntryDef(NameTag, Name, Type) Result += sizeof(Type);
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+    return Result;
+  }
+
+private:
+#define MIBEntryDef(NameTag, Name, Type) Type Name = Type();
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+};
+
 struct MemProfRecord {
   struct Frame {
     std::string Function;
     uint32_t LineOffset;
     uint32_t Column;
     bool IsInlineFrame;
 
     Frame(std::string Str, uint32_t Off, uint32_t Col, bool Inline)
         : Function(std::move(Str)), LineOffset(Off), Column(Col),
           IsInlineFrame(Inline) {}
   };
 
   std::vector<Frame> CallStack;
-  // TODO: Replace this with the entry format described in the RFC so
-  // that the InstrProfRecord reader and writer do not have to be concerned
-  // about backwards compat.
-  MemInfoBlock Info;
+  PortableMemInfoBlock Info;
 
   void clear() {
     CallStack.clear();
-    Info = MemInfoBlock();
+    Info.clear();
   }
 
   // Prints out the contents of the memprof record in YAML.
   void print(llvm::raw_ostream &OS) const {
     OS << "    Callstack:\n";
     // TODO: Print out the frame on one line with to make it easier for deep
     // callstacks once we have a test to check valid YAML is generated.
     for (const auto &Frame : CallStack) {
       OS << "    -\n"
          << "      Function: " << Frame.Function << "\n"
          << "      LineOffset: " << Frame.LineOffset << "\n"
          << "      Column: " << Frame.Column << "\n"
          << "      Inline: " << Frame.IsInlineFrame << "\n";
     }
 
-    OS << "    MemInfoBlock:\n";
-
-    // TODO: Replace this once the format is updated to be version agnostic.
-    OS << "      "
-       << "AllocCount: " << Info.AllocCount << "\n";
-    OS << "      "
-       << "TotalAccessCount: " << Info.TotalAccessCount << "\n";
-    OS << "      "
-       << "MinAccessCount: " << Info.MinAccessCount << "\n";
-    OS << "      "
-       << "MaxAccessCount: " << Info.MaxAccessCount << "\n";
-    OS << "      "
-       << "TotalSize: " << Info.TotalSize << "\n";
-    OS << "      "
-       << "MinSize: " << Info.MinSize << "\n";
-    OS << "      "
-       << "MaxSize: " << Info.MaxSize << "\n";
-    OS << "      "
-       << "AllocTimestamp: " << Info.AllocTimestamp << "\n";
-    OS << "      "
-       << "DeallocTimestamp: " << Info.DeallocTimestamp << "\n";
-    OS << "      "
-       << "TotalLifetime: " << Info.TotalLifetime << "\n";
-    OS << "      "
-       << "MinLifetime: " << Info.MinLifetime << "\n";
-    OS << "      "
-       << "MaxLifetime: " << Info.MaxLifetime << "\n";
-    OS << "      "
-       << "AllocCpuId: " << Info.AllocCpuId << "\n";
-    OS << "      "
-       << "DeallocCpuId: " << Info.DeallocCpuId << "\n";
-    OS << "      "
-       << "NumMigratedCpu: " << Info.NumMigratedCpu << "\n";
-    OS << "      "
-       << "NumLifetimeOverlaps: " << Info.NumLifetimeOverlaps << "\n";
-    OS << "      "
-       << "NumSameAllocCpu: " << Info.NumSameAllocCpu << "\n";
-    OS << "      "
-       << "NumSameDeallocCpu: " << Info.NumSameDeallocCpu << "\n";
+    Info.printYAML(OS);
   }
 };
 
 } // namespace memprof
 } // namespace llvm
 
 #endif // LLVM_PROFILEDATA_MEMPROF_H_

llvm/lib/ProfileData/RawMemProfReader.cpp

for (size_t I = 0; I < DI.getNumberOfFrames(); I++) {
       const auto &Frame = DI.getFrame(I);
       Record.CallStack.emplace_back(
           std::to_string(llvm::MD5Hash(trimSuffix(Frame.FunctionName))),
           Frame.Line - Frame.StartLine, Frame.Column,
           // Only the first entry is not an inlined location.
           I != 0);
     }
   }
-  Record.Info = MIB;
+  Record.Info = PortableMemInfoBlock(MIB);
   return Error::success();
 }
 
 Error RawMemProfReader::readNextRecord(MemProfRecord &Record) {
   if (ProfileData.empty())
     return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
 
   if (Iter == ProfileData.end())

llvm/test/tools/llvm-profdata/memprof-basic.test

 CHECK-NEXT:       MinLifetime: 987
 CHECK-NEXT:       MaxLifetime: 987
 CHECK-NEXT:       AllocCpuId: 4294967295
 CHECK-NEXT:       DeallocCpuId: 56
 CHECK-NEXT:       NumMigratedCpu: 1
 CHECK-NEXT:       NumLifetimeOverlaps: 0
 CHECK-NEXT:       NumSameAllocCpu: 0
 CHECK-NEXT:       NumSameDeallocCpu: 0
+CHECK-NEXT:       DataTypeId: {{[0-9]+}}
 CHECK-NEXT:   -
 CHECK-NEXT:     Callstack:
 CHECK-NEXT:     -
 CHECK-NEXT:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 57
 CHECK-NEXT:       Column: 3
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     -

 CHECK-NEXT:       MinLifetime: 0
 CHECK-NEXT:       MaxLifetime: 0
 CHECK-NEXT:       AllocCpuId: 56
 CHECK-NEXT:       DeallocCpuId: 56
 CHECK-NEXT:       NumMigratedCpu: 0
 CHECK-NEXT:       NumLifetimeOverlaps: 0
 CHECK-NEXT:       NumSameAllocCpu: 0
 CHECK-NEXT:       NumSameDeallocCpu: 0
+CHECK-NEXT:       DataTypeId: {{[0-9]+}}
 CHECK-NEXT:   -
 CHECK-NEXT:     Callstack:
 CHECK-NEXT:     -
 CHECK-NEXT:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 57
 CHECK-NEXT:       Column: 3
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     -

 CHECK-NEXT:       MinLifetime: 0
 CHECK-NEXT:       MaxLifetime: 0
 CHECK-NEXT:       AllocCpuId: 56
 CHECK-NEXT:       DeallocCpuId: 56
 CHECK-NEXT:       NumMigratedCpu: 0
 CHECK-NEXT:       NumLifetimeOverlaps: 0
 CHECK-NEXT:       NumSameAllocCpu: 0
 CHECK-NEXT:       NumSameDeallocCpu: 0
+CHECK-NEXT:       DataTypeId: {{[0-9]+}}

llvm/unittests/ProfileData/MemProfTest.cpp

 #include "llvm/ProfileData/MemProf.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/ProfileData/MemProfData.inc"
 #include "llvm/ProfileData/RawMemProfReader.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
+#include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include <initializer_list>
 
 namespace {
 
 using ::llvm::DIGlobal;
 using ::llvm::DIInliningInfo;
 using ::llvm::DILineInfo;
 using ::llvm::DILineInfoSpecifier;
 using ::llvm::DILocal;
 using ::llvm::memprof::CallStackMap;
 using ::llvm::memprof::MemInfoBlock;
 using ::llvm::memprof::MemProfRecord;
+using ::llvm::memprof::MemProfSchema;
+using ::llvm::memprof::Meta;
+using ::llvm::memprof::PortableMemInfoBlock;
 using ::llvm::memprof::RawMemProfReader;
 using ::llvm::memprof::SegmentEntry;
 using ::llvm::object::SectionedAddress;
 using ::llvm::symbolize::SymbolizableModule;
 using ::testing::Return;
 
 class MockSymbolizer : public SymbolizableModule {
 public:
MATCHER_P4(FrameContains, Function, LineOffset, Column, Inline, "") {
   if (arg.LineOffset == LineOffset && arg.Column == Column &&
       arg.IsInlineFrame == Inline) {
     return true;
   }
   *result_listener << "LineOffset, Column or Inline mismatch";
   return false;
 }
 
+MemProfSchema getFullSchema() {
+  MemProfSchema Schema;
+#define MIBEntryDef(NameTag, Name, Type) Schema.push_back(Meta::Name);
+#include "llvm/ProfileData/MIBEntryDef.inc"
+#undef MIBEntryDef
+  return Schema;
+}
+
 TEST(MemProf, FillsValue) {
   std::unique_ptr<MockSymbolizer> Symbolizer(new MockSymbolizer());
 
   EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x2000},
                                                 specifier(), false))
       .Times(2)
       .WillRepeatedly(Return(makeInliningInfo({
           {"foo", 10, 5, 30},
TEST(MemProf, FillsValue) {
   RawMemProfReader Reader(std::move(Symbolizer), Seg, Prof, CSM);
 
   std::vector<MemProfRecord> Records;
   for (const MemProfRecord &R : Reader) {
     Records.push_back(R);
   }
   EXPECT_EQ(Records.size(), 2U);
 
-  EXPECT_EQ(Records[0].Info.AllocCount, 1U);
-  EXPECT_EQ(Records[1].Info.AllocCount, 2U);
+  EXPECT_EQ(Records[0].Info.getAllocCount(), 1U);
+  EXPECT_EQ(Records[1].Info.getAllocCount(), 2U);
   EXPECT_THAT(Records[0].CallStack[0], FrameContains("foo", 5U, 30U, false));
   EXPECT_THAT(Records[0].CallStack[1], FrameContains("bar", 51U, 20U, true));
 
   EXPECT_THAT(Records[1].CallStack[0], FrameContains("baz", 5U, 30U, false));
   EXPECT_THAT(Records[1].CallStack[1], FrameContains("qux", 5U, 10U, true));
   EXPECT_THAT(Records[1].CallStack[2], FrameContains("foo", 5U, 30U, false));
   EXPECT_THAT(Records[1].CallStack[3], FrameContains("bar", 51U, 20U, true));
 }
 
+TEST(MemProf, PortableWrapper) {
+  MemInfoBlock Info(/*size=*/16, /*access_count=*/7, /*alloc_timestamp=*/1000,
+                    /*dealloc_timestamp=*/2000, /*alloc_cpu=*/3,
+                    /*dealloc_cpu=*/4);
+
+  const auto Schema = getFullSchema();
+  PortableMemInfoBlock WriteBlock(Info);
+
+  std::string Buffer;
+  llvm::raw_string_ostream OS(Buffer);
+  WriteBlock.serialize(Schema, OS);
+  OS.flush();
+
+  PortableMemInfoBlock ReadBlock(
+      Schema, reinterpret_cast<const unsigned char *>(Buffer.data()));
+
+  EXPECT_EQ(ReadBlock, WriteBlock);
+  // Here we compare directly with the actual counts instead of MemInfoBlock
+  // members. Since the MemInfoBlock struct is packed and the EXPECT_EQ macros
+  // take a reference to the params, this results in unaligned accesses.
+  EXPECT_EQ(1, ReadBlock.getAllocCount());
+  EXPECT_EQ(7, ReadBlock.getTotalAccessCount());
+  EXPECT_EQ(3, ReadBlock.getAllocCpuId());
+}
+
 } // namespace