[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

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

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.

compiler-rt/include/profile/MemProfData.inc

PACKED(struct SegmentEntry {
 
   bool operator==(const SegmentEntry& S) const {
     return Start == S.Start &&
            End == S.End &&
            Offset == S.Offset;
   }
 });
 
+
+
+// Packed struct definition for MSVC. We can't use the PACKED macro defined in
+// MemProfData.inc since it would mean we are embedding a directive (the
+// #include for MIBEntryDef) into the macros which is undefined behaviour.
+#ifdef _MSC_VER
+__pragma(pack(push,1))
+#endif
+
 // A struct representing the heap allocation characteristics of a particular
 // runtime context. This struct is shared between the compiler-rt runtime and
 // the raw profile reader. The indexed format uses a separate, self-describing
 // backwards compatible format.
-PACKED(struct MemInfoBlock {
-  uint32_t alloc_count;
-  uint64_t total_access_count, min_access_count, max_access_count;
-  uint64_t total_size;
-  uint32_t min_size, max_size;
-  uint32_t alloc_timestamp, dealloc_timestamp;
-  uint64_t total_lifetime;
-  uint32_t min_lifetime, max_lifetime;
-  uint32_t alloc_cpu_id, dealloc_cpu_id;
-  uint32_t num_migrated_cpu;
-
-  // Only compared to prior deallocated object currently.
-  uint32_t num_lifetime_overlaps;
-  uint32_t num_same_alloc_cpu;
-  uint32_t num_same_dealloc_cpu;
+struct MemInfoBlock{
 
-  uint64_t data_type_id; // TODO: hash of type name
+#define MIBEntryDef(NameTag, Name, TypeTag, Type) Type Name;
+#include "MemProfMIB.inc"
+#undef MIBEntryDef
 
-  MemInfoBlock() : alloc_count(0) {}
+MemInfoBlock() : AllocCount(0) {}
 
-  MemInfoBlock(uint32_t size, uint64_t access_count, uint32_t alloc_timestamp,
-               uint32_t dealloc_timestamp, uint32_t alloc_cpu, uint32_t dealloc_cpu)
-      : alloc_count(1), total_access_count(access_count),
-        min_access_count(access_count), max_access_count(access_count),
-        total_size(size), min_size(size), max_size(size),
-        alloc_timestamp(alloc_timestamp), dealloc_timestamp(dealloc_timestamp),
-        total_lifetime(dealloc_timestamp - alloc_timestamp),
-        min_lifetime(total_lifetime), max_lifetime(total_lifetime),
-        alloc_cpu_id(alloc_cpu), dealloc_cpu_id(dealloc_cpu),
-        num_lifetime_overlaps(0), num_same_alloc_cpu(0),
-        num_same_dealloc_cpu(0) {
-    num_migrated_cpu = alloc_cpu_id != dealloc_cpu_id;
-  }
+    : AllocCount(1), TotalAccessCount(access_count),
+      MinAccessCount(access_count), MaxAccessCount(access_count),
+      TotalSize(size), MinSize(size), MaxSize(size),
+      AllocTimestamp(alloc_timestamp), DeallocTimestamp(dealloc_timestamp),
+      TotalLifetime(dealloc_timestamp - alloc_timestamp),
+      MinLifetime(TotalLifetime), MaxLifetime(TotalLifetime),
+      AllocCpuId(alloc_cpu), DeallocCpuId(dealloc_cpu),
+      NumLifetimeOverlaps(0), NumSameAllocCpu(0),
+      NumSameDeallocCpu(0) {
+  NumMigratedCpu = AllocCpuId != DeallocCpuId;
 
-  void Merge(const MemInfoBlock &newMIB) {
-    alloc_count += newMIB.alloc_count;
+  AllocCount += newMIB.AllocCount;
 
-    total_access_count += newMIB.total_access_count;
-    min_access_count = newMIB.min_access_count < min_access_count ? newMIB.min_access_count : min_access_count;
-    max_access_count = newMIB.max_access_count < max_access_count ? newMIB.max_access_count : max_access_count;
-
-    total_size += newMIB.total_size;
-    min_size = newMIB.min_size < min_size ? newMIB.min_size : min_size;
-    max_size = newMIB.max_size < max_size ? newMIB.max_size : max_size;
-
-    total_lifetime += newMIB.total_lifetime;
-    min_lifetime = newMIB.min_lifetime < min_lifetime ? newMIB.min_lifetime : min_lifetime;
-    max_lifetime = newMIB.max_lifetime > max_lifetime ? newMIB.max_lifetime : max_lifetime;
+  TotalAccessCount += newMIB.TotalAccessCount;
+  MinAccessCount = newMIB.MinAccessCount < MinAccessCount ? newMIB.MinAccessCount : MinAccessCount;
+  MaxAccessCount = newMIB.MaxAccessCount < MaxAccessCount ? newMIB.MaxAccessCount : MaxAccessCount;
+
+  TotalSize += newMIB.TotalSize;
+  MinSize = newMIB.MinSize < MinSize ? newMIB.MinSize : MinSize;
+  MaxSize = newMIB.MaxSize < MaxSize ? newMIB.MaxSize : MaxSize;
+
+  TotalLifetime += newMIB.TotalLifetime;
+  MinLifetime = newMIB.MinLifetime < MinLifetime ? newMIB.MinLifetime : MinLifetime;
+  MaxLifetime = newMIB.MaxLifetime > MaxLifetime ? newMIB.MaxLifetime : MaxLifetime;
 
-    // We know newMIB was deallocated later, so just need to check if it was
-    // allocated before last one deallocated.
-    num_lifetime_overlaps += newMIB.alloc_timestamp < dealloc_timestamp;
-    alloc_timestamp = newMIB.alloc_timestamp;
-    dealloc_timestamp = newMIB.dealloc_timestamp;
-
-    num_same_alloc_cpu += alloc_cpu_id == newMIB.alloc_cpu_id;
-    num_same_dealloc_cpu += dealloc_cpu_id == newMIB.dealloc_cpu_id;
-    alloc_cpu_id = newMIB.alloc_cpu_id;
-    dealloc_cpu_id = newMIB.dealloc_cpu_id;
-  }
-});
+  NumLifetimeOverlaps += newMIB.AllocTimestamp < DeallocTimestamp;
+  AllocTimestamp = newMIB.AllocTimestamp;
+  DeallocTimestamp = newMIB.DeallocTimestamp;
+
+  NumSameAllocCpu += AllocCpuId == newMIB.AllocCpuId;
+  NumSameDeallocCpu += DeallocCpuId == newMIB.DeallocCpuId;
+  AllocCpuId = newMIB.AllocCpuId;
+  DeallocCpuId = newMIB.DeallocCpuId;
+
+#ifdef _MSC_VER
+} __pragma(pack(pop));
+#else
+} __attribute__((__packed__));
+#endif
 
 } // namespace memprof
 } // namespace llvm
 
 #endif

compiler-rt/include/profile/MemProfMIB.inc

+#ifndef MIBEntryDef
+#define MIBEntryDef(NameTag, Name, TypeTag, Type)
+#endif
+
+MIBEntryDef(AllocCount = 1, AllocCount,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(TotalAccessCount = 2, TotalAccessCount,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MinAccessCount = 3, MinAccessCount,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MaxAccessCount = 4, MaxAccessCount,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(TotalSize = 5, TotalSize,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MinSize = 6, MinSize,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(MaxSize = 7, MaxSize,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(AllocTimestamp = 8, AllocTimestamp,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(DeallocTimestamp = 9, DeallocTimestamp,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(TotalLifetime = 10, TotalLifetime,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MinLifetime = 11, MinLifetime,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(MaxLifetime = 12, MaxLifetime,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(AllocCpuId = 13, AllocCpuId,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(DeallocCpuId = 14, DeallocCpuId,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumMigratedCpu = 15, NumMigratedCpu,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumLifetimeOverlaps = 16, NumLifetimeOverlaps,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumSameAllocCpu = 17, NumSameAllocCpu,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumSameDeallocCpu = 18, NumSameDeallocCpu,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(DataTypeId = 19, DataTypeId,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+
+
+

compiler-rt/lib/memprof/memprof_allocator.cpp

 namespace __memprof {
 namespace {
 using ::llvm::memprof::MemInfoBlock;
 
 void Print(const MemInfoBlock &M, const u64 id, bool print_terse) {
   u64 p;
 
   if (print_terse) {
-    p = M.total_size * 100 / M.alloc_count;
-    Printf("MIB:%llu/%u/%llu.%02llu/%u/%u/", id, M.alloc_count, p / 100,
-           p % 100, M.min_size, M.max_size);
-    p = M.total_access_count * 100 / M.alloc_count;
-    Printf("%llu.%02llu/%llu/%llu/", p / 100, p % 100, M.min_access_count,
-           M.max_access_count);
-    p = M.total_lifetime * 100 / M.alloc_count;
-    Printf("%llu.%02llu/%u/%u/", p / 100, p % 100, M.min_lifetime,
-           M.max_lifetime);
-    Printf("%u/%u/%u/%u\n", M.num_migrated_cpu, M.num_lifetime_overlaps,
-           M.num_same_alloc_cpu, M.num_same_dealloc_cpu);
+    p = M.TotalSize * 100 / M.AllocCount;
+    Printf("MIB:%llu/%u/%llu.%02llu/%u/%u/", id, M.AllocCount, p / 100, p % 100,
+           M.MinSize, M.MaxSize);
+    p = M.TotalAccessCount * 100 / M.AllocCount;
+    Printf("%llu.%02llu/%llu/%llu/", p / 100, p % 100, M.MinAccessCount,
+           M.MaxAccessCount);
+    p = M.TotalLifetime * 100 / M.AllocCount;
+    Printf("%llu.%02llu/%u/%u/", p / 100, p % 100, M.MinLifetime,
+           M.MaxLifetime);
+    Printf("%u/%u/%u/%u\n", M.NumMigratedCpu, M.NumLifetimeOverlaps,
+           M.NumSameAllocCpu, M.NumSameDeallocCpu);
   } else {
-    p = M.total_size * 100 / M.alloc_count;
+    p = M.TotalSize * 100 / M.AllocCount;
     Printf("Memory allocation stack id = %llu\n", id);
     Printf("\talloc_count %u, size (ave/min/max) %llu.%02llu / %u / %u\n",
-           M.alloc_count, p / 100, p % 100, M.min_size, M.max_size);
-    p = M.total_access_count * 100 / M.alloc_count;
+           M.AllocCount, p / 100, p % 100, M.MinSize, M.MaxSize);
+    p = M.TotalAccessCount * 100 / M.AllocCount;
     Printf("\taccess_count (ave/min/max): %llu.%02llu / %llu / %llu\n", p / 100,
-           p % 100, M.min_access_count, M.max_access_count);
-    p = M.total_lifetime * 100 / M.alloc_count;
+           p % 100, M.MinAccessCount, M.MaxAccessCount);
+    p = M.TotalLifetime * 100 / M.AllocCount;
     Printf("\tlifetime (ave/min/max): %llu.%02llu / %u / %u\n", p / 100,
-           p % 100, M.min_lifetime, M.max_lifetime);
+           p % 100, M.MinLifetime, M.MaxLifetime);
     Printf("\tnum migrated: %u, num lifetime overlaps: %u, num same alloc "
            "cpu: %u, num same dealloc_cpu: %u\n",
-           M.num_migrated_cpu, M.num_lifetime_overlaps, M.num_same_alloc_cpu,
-           M.num_same_dealloc_cpu);
+           M.NumMigratedCpu, M.NumLifetimeOverlaps, M.NumSameAllocCpu,
+           M.NumSameDeallocCpu);
   }
 }
 } // namespace
 
 static int GetCpuId(void) {
   // _memprof_preinit is called via the preinit_array, which subsequently calls
   // malloc. Since this is before _dl_init calls VDSO_SETUP, sched_getcpu
   // will seg fault as the address of __vdso_getcpu will be null.

compiler-rt/lib/memprof/tests/rawprofile.cpp

TEST(MemProf, Basic) {
 
   EXPECT_CALL(Layout, Reset).Times(2);
 
   MIBMapTy FakeMap;
   MemInfoBlock FakeMIB;
   // Since we want to override the constructor set vals to make it easier to
   // test.
   memset(&FakeMIB, 0, sizeof(MemInfoBlock));
-  FakeMIB.alloc_count = 0x1;
-  FakeMIB.total_access_count = 0x2;
+  FakeMIB.AllocCount = 0x1;
+  FakeMIB.TotalAccessCount = 0x2;
 
   uint64_t FakeIds[2];
   FakeIds[0] = PopulateFakeMap(FakeMIB, /*StackPCBegin=*/2, FakeMap);
   FakeIds[1] = PopulateFakeMap(FakeMIB, /*StackPCBegin=*/3, FakeMap);
 
   char *Ptr = nullptr;
   uint64_t NumBytes = SerializeToRawProfile(FakeMap, Layout, Ptr);
   const char *Buffer = Ptr;

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/Support/raw_ostream.h"
 
 namespace llvm {
 namespace memprof {
 
+enum class Meta {
+  Start = 0,
+#define MIBEntryDef(NameTag, Name, TypeTag, Type) NameTag,
+#include "llvm/ProfileData/MemProfMIB.inc"
+#undef MIBEntryDef
+  Size
+};
+
+struct PortableMemInfoBlock {
+  PortableMemInfoBlock() {}
+  PortableMemInfoBlock(const MemInfoBlock &Block) : Info(Block) {}
+  PortableMemInfoBlock(const llvm::SmallVectorImpl<Meta> &Schema, char *Ptr) {
+    for (const Meta Id : Schema) {
+      switch (Id) {
+#define MIBEntryDef(NameTag, Name, TypeTag, Type)                              \
+  case Meta::Name: {                                                           \
+    Info.Name = *reinterpret_cast<Type *>(Ptr);                                \
+    Ptr += sizeof(Type);                                                       \
+  } break;
+#include "llvm/ProfileData/MemProfMIB.inc"
+#undef MIBEntryDef
+      default:
+        llvm_unreachable("Unknown meta type id, is the profile collected from "
+                         "a newer version of the runtime?");
+      }
+    }
+  }
+
+  void serialize(const llvm::SmallVectorImpl<Meta> &Schema, char *Ptr) {
+    for (const Meta Id : Schema) {
+      switch (Id) {
+#define MIBEntryDef(NameTag, Name, TypeTag, Type)                              \
+  case Meta::Name: {                                                           \
+    *(Type *)Ptr = Info.Name;                                                  \
+    Ptr += sizeof(Type);                                                       \
+  } break;
+#include "llvm/ProfileData/MemProfMIB.inc"
+#undef MIBEntryDef
+      default:
+        llvm_unreachable("Unknown meta type id, invalid input?");
+      }
+    }
+  }
+
+  void printYAML(raw_ostream &OS) const {
+    OS << "    MemInfoBlock:\n";
+#define MIBEntryDef(NameTag, Name, TypeTag, Type)                              \
+  OS << "      " << #Name << ": " << Info.Name << "\n";
+#include "llvm/ProfileData/MemProfMIB.inc"
+#undef MIBEntryDef
+  }
+
+  // Define getters for each type which can be called by analyses.
+#define MIBEntryDef(NameTag, Name, TypeTag, Type)                              \
+  Type get##Name() { return Info.Name; }
+#include "llvm/ProfileData/MemProfMIB.inc"
+#undef MIBEntryDef
+
+  void clear() { Info = MemInfoBlock(); }
+
+private:
+  MemInfoBlock Info;
+};
+
 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";
     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.
-#define PRINT(Field) OS << "      " #Field ": " << Info.Field << "\n"
-    PRINT(alloc_count);
-    PRINT(total_access_count);
-    PRINT(min_access_count);
-    PRINT(max_access_count);
-    PRINT(total_size);
-    PRINT(min_size);
-    PRINT(max_size);
-    PRINT(alloc_timestamp);
-    PRINT(dealloc_timestamp);
-    PRINT(total_lifetime);
-    PRINT(min_lifetime);
-    PRINT(max_lifetime);
-    PRINT(alloc_cpu_id);
-    PRINT(dealloc_cpu_id);
-    PRINT(num_migrated_cpu);
-    PRINT(num_lifetime_overlaps);
-    PRINT(num_same_alloc_cpu);
-    PRINT(num_same_dealloc_cpu);
-#undef PRINT
+    Info.printYAML(OS);
   }
 };
 
 } // namespace memprof
 } // namespace llvm
 
 #endif // LLVM_PROFILEDATA_MEMPROF_H_

llvm/include/llvm/ProfileData/MemProfData.inc

PACKED(struct SegmentEntry {
 
   bool operator==(const SegmentEntry& S) const {
     return Start == S.Start &&
            End == S.End &&
            Offset == S.Offset;
   }
 });
 
+
+
+// Packed struct definition for MSVC. We can't use the PACKED macro defined in
+// MemProfData.inc since it would mean we are embedding a directive (the
+// #include for MIBEntryDef) into the macros which is undefined behaviour.
+#ifdef _MSC_VER
+__pragma(pack(push,1))
+#endif
+
 // A struct representing the heap allocation characteristics of a particular
 // runtime context. This struct is shared between the compiler-rt runtime and
 // the raw profile reader. The indexed format uses a separate, self-describing
 // backwards compatible format.
-PACKED(struct MemInfoBlock {
-  uint32_t alloc_count;
-  uint64_t total_access_count, min_access_count, max_access_count;
-  uint64_t total_size;
-  uint32_t min_size, max_size;
-  uint32_t alloc_timestamp, dealloc_timestamp;
-  uint64_t total_lifetime;
-  uint32_t min_lifetime, max_lifetime;
-  uint32_t alloc_cpu_id, dealloc_cpu_id;
-  uint32_t num_migrated_cpu;
-
-  // Only compared to prior deallocated object currently.
-  uint32_t num_lifetime_overlaps;
-  uint32_t num_same_alloc_cpu;
-  uint32_t num_same_dealloc_cpu;
+struct MemInfoBlock{
 
-  uint64_t data_type_id; // TODO: hash of type name
+#define MIBEntryDef(NameTag, Name, TypeTag, Type) Type Name;
+#include "MemProfMIB.inc"
+#undef MIBEntryDef
+
+bool operator==(const MemInfoBlock& Other) const {
+  bool IsEqual = true;
+#define MIBEntryDef(NameTag, Name, TypeTag, Type) \
+  IsEqual = (IsEqual && Name == Other.Name);
+#include "MemProfMIB.inc"
+#undef MIBEntryDef
+  return IsEqual;
+}
 
-  MemInfoBlock() : alloc_count(0) {}
+MemInfoBlock() : AllocCount(0) {}
 
-  MemInfoBlock(uint32_t size, uint64_t access_count, uint32_t alloc_timestamp,
-               uint32_t dealloc_timestamp, uint32_t alloc_cpu, uint32_t dealloc_cpu)
-      : alloc_count(1), total_access_count(access_count),
-        min_access_count(access_count), max_access_count(access_count),
-        total_size(size), min_size(size), max_size(size),
-        alloc_timestamp(alloc_timestamp), dealloc_timestamp(dealloc_timestamp),
-        total_lifetime(dealloc_timestamp - alloc_timestamp),
-        min_lifetime(total_lifetime), max_lifetime(total_lifetime),
-        alloc_cpu_id(alloc_cpu), dealloc_cpu_id(dealloc_cpu),
-        num_lifetime_overlaps(0), num_same_alloc_cpu(0),
-        num_same_dealloc_cpu(0) {
-    num_migrated_cpu = alloc_cpu_id != dealloc_cpu_id;
-  }
+    : AllocCount(1), TotalAccessCount(access_count),
+      MinAccessCount(access_count), MaxAccessCount(access_count),
+      TotalSize(size), MinSize(size), MaxSize(size),
+      AllocTimestamp(alloc_timestamp), DeallocTimestamp(dealloc_timestamp),
+      TotalLifetime(dealloc_timestamp - alloc_timestamp),
+      MinLifetime(TotalLifetime), MaxLifetime(TotalLifetime),
+      AllocCpuId(alloc_cpu), DeallocCpuId(dealloc_cpu),
+      NumLifetimeOverlaps(0), NumSameAllocCpu(0),
+      NumSameDeallocCpu(0) {
+  NumMigratedCpu = AllocCpuId != DeallocCpuId;
 
-  void Merge(const MemInfoBlock &newMIB) {
-    alloc_count += newMIB.alloc_count;
+  AllocCount += newMIB.AllocCount;
 
-    total_access_count += newMIB.total_access_count;
-    min_access_count = newMIB.min_access_count < min_access_count ? newMIB.min_access_count : min_access_count;
-    max_access_count = newMIB.max_access_count < max_access_count ? newMIB.max_access_count : max_access_count;
-
-    total_size += newMIB.total_size;
-    min_size = newMIB.min_size < min_size ? newMIB.min_size : min_size;
-    max_size = newMIB.max_size < max_size ? newMIB.max_size : max_size;
-
-    total_lifetime += newMIB.total_lifetime;
-    min_lifetime = newMIB.min_lifetime < min_lifetime ? newMIB.min_lifetime : min_lifetime;
-    max_lifetime = newMIB.max_lifetime > max_lifetime ? newMIB.max_lifetime : max_lifetime;
+  TotalAccessCount += newMIB.TotalAccessCount;
+  MinAccessCount = newMIB.MinAccessCount < MinAccessCount ? newMIB.MinAccessCount : MinAccessCount;
+  MaxAccessCount = newMIB.MaxAccessCount < MaxAccessCount ? newMIB.MaxAccessCount : MaxAccessCount;
+
+  TotalSize += newMIB.TotalSize;
+  MinSize = newMIB.MinSize < MinSize ? newMIB.MinSize : MinSize;
+  MaxSize = newMIB.MaxSize < MaxSize ? newMIB.MaxSize : MaxSize;
+
+  TotalLifetime += newMIB.TotalLifetime;
+  MinLifetime = newMIB.MinLifetime < MinLifetime ? newMIB.MinLifetime : MinLifetime;
+  MaxLifetime = newMIB.MaxLifetime > MaxLifetime ? newMIB.MaxLifetime : MaxLifetime;
 
-    // We know newMIB was deallocated later, so just need to check if it was
-    // allocated before last one deallocated.
-    num_lifetime_overlaps += newMIB.alloc_timestamp < dealloc_timestamp;
-    alloc_timestamp = newMIB.alloc_timestamp;
-    dealloc_timestamp = newMIB.dealloc_timestamp;
-
-    num_same_alloc_cpu += alloc_cpu_id == newMIB.alloc_cpu_id;
-    num_same_dealloc_cpu += dealloc_cpu_id == newMIB.dealloc_cpu_id;
-    alloc_cpu_id = newMIB.alloc_cpu_id;
-    dealloc_cpu_id = newMIB.dealloc_cpu_id;
-  }
-});
+  NumLifetimeOverlaps += newMIB.AllocTimestamp < DeallocTimestamp;
+  AllocTimestamp = newMIB.AllocTimestamp;
+  DeallocTimestamp = newMIB.DeallocTimestamp;
+
+  NumSameAllocCpu += AllocCpuId == newMIB.AllocCpuId;
+  NumSameDeallocCpu += DeallocCpuId == newMIB.DeallocCpuId;
+  AllocCpuId = newMIB.AllocCpuId;
+  DeallocCpuId = newMIB.DeallocCpuId;
+
+#ifdef _MSC_VER
+} __pragma(pack(pop));
+#else
+} __attribute__((__packed__));
+#endif
 
 } // namespace memprof
 } // namespace llvm
 
 #endif

llvm/include/llvm/ProfileData/MemProfMIB.inc

+/*===-- MemProfMIB.inc - MemProf profiling primitives -*- 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
+|*
+\*===----------------------------------------------------------------------===*/
+/*
+ * This file has two identical copies. The primary copy lives in LLVM and
+ * the other one sits in compiler-rt/include/profile directory. To make changes
+ * in this file, first modify the primary copy and copy it over to compiler-rt.
+ * Testing of any change in this file can start only after the two copies are
+ * synced up.
+ * 
+ * This file defines the primitives for data structures used in the profiling
+ * runtime and the serialized profile file.
+ * E.g. To declare the fields in a struct  
+ *
+ * struct MemInfoBlock {  
+ *   #define MIBEntryDef(NameTag, Name, TypeTag, Type) Type Tag; 
+ *   #include "MemProfMIB.inc"
+ *   #undef MIBEntryDef
+ * };
+\*===----------------------------------------------------------------------===*/
+
+// If the MIBEntryDef macro has not been defined then define it to silently
+// consume the arguments. 
+#ifndef MIBEntryDef
+#define MIBEntryDef(NameTag, Name, TypeTag, Type)
+#endif
+
+// Ensure that the constructor and methods of MemInfoBlock in MemProfData.inc
+// are updated if new members are added.
+MIBEntryDef(AllocCount = 1, AllocCount,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(TotalAccessCount = 2, TotalAccessCount,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MinAccessCount = 3, MinAccessCount,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MaxAccessCount = 4, MaxAccessCount,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(TotalSize = 5, TotalSize,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MinSize = 6, MinSize,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(MaxSize = 7, MaxSize,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(AllocTimestamp = 8, AllocTimestamp,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(DeallocTimestamp = 9, DeallocTimestamp,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(TotalLifetime = 10, TotalLifetime,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)
+MIBEntryDef(MinLifetime = 11, MinLifetime,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(MaxLifetime = 12, MaxLifetime,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(AllocCpuId = 13, AllocCpuId,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(DeallocCpuId = 14, DeallocCpuId,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumMigratedCpu = 15, NumMigratedCpu,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumLifetimeOverlaps = 16, NumLifetimeOverlaps,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumSameAllocCpu = 17, NumSameAllocCpu,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(NumSameDeallocCpu = 18, NumSameDeallocCpu,
+            MIBMeta::MIBFieldType::UINT32, uint32_t)
+MIBEntryDef(DataTypeId = 19, DataTypeId,
+            MIBMeta::MIBFieldType::UINT64, uint64_t)

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

 CHECK-NEXT:       Column: 3
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     -
 CHECK-NEXT:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 0
 CHECK-NEXT:       Column: 0
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     MemInfoBlock:
-CHECK-NEXT:       alloc_count: 1
-CHECK-NEXT:       total_access_count: 0
-CHECK-NEXT:       min_access_count: 0
-CHECK-NEXT:       max_access_count: 0
-CHECK-NEXT:       total_size: 53
-CHECK-NEXT:       min_size: 53
-CHECK-NEXT:       max_size: 53
-CHECK-NEXT:       alloc_timestamp: 0
-CHECK-NEXT:       dealloc_timestamp: 987
-CHECK-NEXT:       total_lifetime: 987
-CHECK-NEXT:       min_lifetime: 987
-CHECK-NEXT:       max_lifetime: 987
-CHECK-NEXT:       alloc_cpu_id: 4294967295
-CHECK-NEXT:       dealloc_cpu_id: 56
-CHECK-NEXT:       num_migrated_cpu: 1
-CHECK-NEXT:       num_lifetime_overlaps: 0
-CHECK-NEXT:       num_same_alloc_cpu: 0
-CHECK-NEXT:       num_same_dealloc_cpu: 0
+CHECK-NEXT:       AllocCount: 1
+CHECK-NEXT:       TotalAccessCount: 0
+CHECK-NEXT:       MinAccessCount: 0
+CHECK-NEXT:       MaxAccessCount: 0
+CHECK-NEXT:       TotalSize: 53
+CHECK-NEXT:       MinSize: 53
+CHECK-NEXT:       MaxSize: 53
+CHECK-NEXT:       AllocTimestamp: 0
+CHECK-NEXT:       DeallocTimestamp: 987
+CHECK-NEXT:       TotalLifetime: 987
+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:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 1
 CHECK-NEXT:       Column: 21
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     -
 CHECK-NEXT:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 0
 CHECK-NEXT:       Column: 0
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     MemInfoBlock:
-CHECK-NEXT:       alloc_count: 1
-CHECK-NEXT:       total_access_count: 2
-CHECK-NEXT:       min_access_count: 2
-CHECK-NEXT:       max_access_count: 2
-CHECK-NEXT:       total_size: 10
-CHECK-NEXT:       min_size: 10
-CHECK-NEXT:       max_size: 10
-CHECK-NEXT:       alloc_timestamp: 986
-CHECK-NEXT:       dealloc_timestamp: 986
-CHECK-NEXT:       total_lifetime: 0
-CHECK-NEXT:       min_lifetime: 0
-CHECK-NEXT:       max_lifetime: 0
-CHECK-NEXT:       alloc_cpu_id: 56
-CHECK-NEXT:       dealloc_cpu_id: 56
-CHECK-NEXT:       num_migrated_cpu: 0
-CHECK-NEXT:       num_lifetime_overlaps: 0
-CHECK-NEXT:       num_same_alloc_cpu: 0
-CHECK-NEXT:       num_same_dealloc_cpu: 0
+CHECK-NEXT:       AllocCount: 1
+CHECK-NEXT:       TotalAccessCount: 2
+CHECK-NEXT:       MinAccessCount: 2
+CHECK-NEXT:       MaxAccessCount: 2
+CHECK-NEXT:       TotalSize: 10
+CHECK-NEXT:       MinSize: 10
+CHECK-NEXT:       MaxSize: 10
+CHECK-NEXT:       AllocTimestamp: 986
+CHECK-NEXT:       DeallocTimestamp: 986
+CHECK-NEXT:       TotalLifetime: 0
+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:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 5
 CHECK-NEXT:       Column: 15
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     -
 CHECK-NEXT:       Function: {{[0-9]+}}
 CHECK-NEXT:       LineOffset: 0
 CHECK-NEXT:       Column: 0
 CHECK-NEXT:       Inline: 0
 CHECK-NEXT:     MemInfoBlock:
-CHECK-NEXT:       alloc_count: 1
-CHECK-NEXT:       total_access_count: 2
-CHECK-NEXT:       min_access_count: 2
-CHECK-NEXT:       max_access_count: 2
-CHECK-NEXT:       total_size: 10
-CHECK-NEXT:       min_size: 10
-CHECK-NEXT:       max_size: 10
-CHECK-NEXT:       alloc_timestamp: 987
-CHECK-NEXT:       dealloc_timestamp: 987
-CHECK-NEXT:       total_lifetime: 0
-CHECK-NEXT:       min_lifetime: 0
-CHECK-NEXT:       max_lifetime: 0
-CHECK-NEXT:       alloc_cpu_id: 56
-CHECK-NEXT:       dealloc_cpu_id: 56
-CHECK-NEXT:       num_migrated_cpu: 0
-CHECK-NEXT:       num_lifetime_overlaps: 0
-CHECK-NEXT:       num_same_alloc_cpu: 0
-CHECK-NEXT:       num_same_dealloc_cpu: 0
+CHECK-NEXT:       AllocCount: 1
+CHECK-NEXT:       TotalAccessCount: 2
+CHECK-NEXT:       MinAccessCount: 2
+CHECK-NEXT:       MaxAccessCount: 2
+CHECK-NEXT:       TotalSize: 10
+CHECK-NEXT:       MinSize: 10
+CHECK-NEXT:       MaxSize: 10
+CHECK-NEXT:       AllocTimestamp: 987
+CHECK-NEXT:       DeallocTimestamp: 987
+CHECK-NEXT:       TotalLifetime: 0
+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

 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::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:
EXPECT_CALL(*Symbolizer, symbolizeInlinedCode(SectionedAddress{0x6000},
           {"qux.llvm.12345", 75, 70, 10},
       })));
 
   CallStackMap CSM;
   CSM[0x1] = {0x2000};
   CSM[0x2] = {0x6000, 0x2000};
 
   llvm::MapVector<uint64_t, MemInfoBlock> Prof;
-  Prof[0x1].alloc_count = 1;
-  Prof[0x2].alloc_count = 2;
+  Prof[0x1].AllocCount = 1;
+  Prof[0x2].AllocCount = 2;
 
   auto Seg = makeSegments();
 
   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.alloc_count, 1U);
-  EXPECT_EQ(Records[1].Info.alloc_count, 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);
+
+  llvm::SmallVector<Meta, static_cast<size_t>(Meta::Size)> Schema;
+#define MIBEntryDef(NameTag, Name, TypeTag, Type) Schema.push_back(Meta::Name);
+#include "llvm/ProfileData/MemProfMIB.inc"
+#undef MIBEntryDef
+
+  PortableMemInfoBlock Block(Schema, reinterpret_cast<char *>(&Info));
+
+  EXPECT_EQ(Block.getAllocCount(), Info.AllocCount);
+  EXPECT_EQ(Block.getTotalAccessCount(), Info.MaxAccessCount);
+  EXPECT_EQ(Block.getAllocCpuId(), Info.AllocCpuId);
+
+  char Output[sizeof(MemInfoBlock)] = {0};
+  Block.serialize(Schema, Output);
+
+  EXPECT_EQ(*reinterpret_cast<MemInfoBlock *>(Output), Info);
+}
+
 } // namespace