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

   1 #include "memprof/memprof_rawprofile.h"
   2
   3 #include <cstdint>
   4 #include <memory>
   5
   6 #include "profile/MemProfData.inc"
   7 #include "sanitizer_common/sanitizer_array_ref.h"
   8 #include "sanitizer_common/sanitizer_common.h"
   9 #include "sanitizer_common/sanitizer_procmaps.h"
  10 #include "sanitizer_common/sanitizer_stackdepot.h"
  11 #include "sanitizer_common/sanitizer_stacktrace.h"
  12 #include "gmock/gmock.h"
  13 #include "gtest/gtest.h"
  14
  15 namespace {
  16
  17 using ::__memprof::MIBMapTy;
  18 using ::__memprof::SerializeToRawProfile;
  19 using ::__sanitizer::StackDepotPut;
  20 using ::__sanitizer::StackTrace;
  21 using ::llvm::memprof::MemInfoBlock;
  22
  23 uint64_t PopulateFakeMap(const MemInfoBlock &FakeMIB, uintptr_t StackPCBegin,
  24                          MIBMapTy &FakeMap) {
  25   constexpr int kSize = 5;
  26   uintptr_t array[kSize];
  27   for (int i = 0; i < kSize; i++) {
  28     array[i] = StackPCBegin + i;
  29   }
  30   StackTrace St(array, kSize);
  31   uint32_t Id = StackDepotPut(St);
  32
  33   InsertOrMerge(Id, FakeMIB, FakeMap);
  34   return Id;
  35 }
  36
  37 template <class T = uint64_t> T Read(char *&Buffer) {
  38   static_assert(std::is_pod<T>::value, "Must be a POD type.");
  39   assert(reinterpret_cast<size_t>(Buffer) % sizeof(T) == 0 &&
  40          "Unaligned read!");
  41   T t = *reinterpret_cast<T *>(Buffer);
  42   Buffer += sizeof(T);
  43   return t;
  44 }
  45
  46 TEST(MemProf, Basic) {
  47   __sanitizer::LoadedModule FakeModule;
  48   FakeModule.addAddressRange(/*begin=*/0x10, /*end=*/0x20, /*executable=*/true,
  49                              /*writable=*/false, /*name=*/"");
  50   const char uuid[MEMPROF_BUILDID_MAX_SIZE] = {0xC, 0x0, 0xF, 0xF, 0xE, 0xE};
  51   FakeModule.setUuid(uuid, MEMPROF_BUILDID_MAX_SIZE);
  52   __sanitizer::ArrayRef<__sanitizer::LoadedModule> Modules(&FakeModule,
  53                                                            (&FakeModule) + 1);
  54
  55   MIBMapTy FakeMap;
  56   MemInfoBlock FakeMIB;
  57   // Since we want to override the constructor set vals to make it easier to
  58   // test.
  59   memset(&FakeMIB, 0, sizeof(MemInfoBlock));
  60   FakeMIB.AllocCount = 0x1;
  61   FakeMIB.TotalAccessCount = 0x2;
  62
  63   uint64_t FakeIds[2];
  64   FakeIds[0] = PopulateFakeMap(FakeMIB, /*StackPCBegin=*/2, FakeMap);
  65   FakeIds[1] = PopulateFakeMap(FakeMIB, /*StackPCBegin=*/3, FakeMap);
  66
  67   char *Ptr = nullptr;
  68   uint64_t NumBytes = SerializeToRawProfile(FakeMap, Modules, Ptr);
  69   const char *Buffer = Ptr;
  70
  71   ASSERT_GT(NumBytes, 0ULL);
  72   ASSERT_TRUE(Ptr);
  73
  74   // Check the header.
  75   EXPECT_THAT(Read(Ptr), MEMPROF_RAW_MAGIC_64);
  76   EXPECT_THAT(Read(Ptr), MEMPROF_RAW_VERSION);
  77   const uint64_t TotalSize = Read(Ptr);
  78   const uint64_t SegmentOffset = Read(Ptr);
  79   const uint64_t MIBOffset = Read(Ptr);
  80   const uint64_t StackOffset = Read(Ptr);
  81
  82   // ============= Check sizes and padding.
  83   EXPECT_EQ(TotalSize, NumBytes);
  84   EXPECT_EQ(TotalSize % 8, 0ULL);
  85
  86   // Should be equal to the size of the raw profile header.
  87   EXPECT_EQ(SegmentOffset, 48ULL);
  88
  89   // We expect only 1 segment entry, 8b for the count and 64b for SegmentEntry
  90   // in memprof_rawprofile.cpp.
  91   EXPECT_EQ(MIBOffset - SegmentOffset, 72ULL);
  92
  93   EXPECT_EQ(MIBOffset, 120ULL);
  94   // We expect 2 mib entry, 8b for the count and sizeof(uint64_t) +
  95   // sizeof(MemInfoBlock) contains stack id + MeminfoBlock.
  96   EXPECT_EQ(StackOffset - MIBOffset, 8 + 2 * (8 + sizeof(MemInfoBlock)));
  97
  98   EXPECT_EQ(StackOffset, 408ULL);
  99   // We expect 2 stack entries, with 5 frames - 8b for total count,
 100   // 2 * (8b for id, 8b for frame count and 5*8b for fake frames).
 101   // Since this is the last section, there may be additional padding at the end
 102   // to make the total profile size 8b aligned.
 103   EXPECT_GE(TotalSize - StackOffset, 8ULL + 2 * (8 + 8 + 5 * 8));
 104
 105   // ============= Check contents.
 106   unsigned char ExpectedSegmentBytes[72] = {
 107       0x01, 0,   0,   0,   0,   0,  0, 0, // Number of entries
 108       0x10, 0,   0,   0,   0,   0,  0, 0, // Start
 109       0x20, 0,   0,   0,   0,   0,  0, 0, // End
 110       0x0,  0,   0,   0,   0,   0,  0, 0, // Offset
 111       0x20, 0,   0,   0,   0,   0,  0, 0, // UuidSize
 112       0xC,  0x0, 0xF, 0xF, 0xE, 0xE       // Uuid
 113   };
 114   EXPECT_EQ(memcmp(Buffer + SegmentOffset, ExpectedSegmentBytes, 72), 0);
 115
 116   // Check that the number of entries is 2.
 117   EXPECT_EQ(*reinterpret_cast<const uint64_t *>(Buffer + MIBOffset), 2ULL);
 118   // Check that stack id is set.
 119   EXPECT_EQ(*reinterpret_cast<const uint64_t *>(Buffer + MIBOffset + 8),
 120             FakeIds[0]);
 121
 122   // Only check a few fields of the first MemInfoBlock.
 123   unsigned char ExpectedMIBBytes[sizeof(MemInfoBlock)] = {
 124       0x01, 0, 0, 0, // Alloc count
 125       0x02, 0, 0, 0, // Total access count
 126   };
 127   // Compare contents of 1st MIB after skipping count and stack id.
 128   EXPECT_EQ(
 129       memcmp(Buffer + MIBOffset + 16, ExpectedMIBBytes, sizeof(MemInfoBlock)),
 130       0);
 131   // Compare contents of 2nd MIB after skipping count and stack id for the first
 132   // and only the id for the second.
 133   EXPECT_EQ(memcmp(Buffer + MIBOffset + 16 + sizeof(MemInfoBlock) + 8,
 134                    ExpectedMIBBytes, sizeof(MemInfoBlock)),
 135             0);
 136
 137   // Check that the number of entries is 2.
 138   EXPECT_EQ(*reinterpret_cast<const uint64_t *>(Buffer + StackOffset), 2ULL);
 139   // Check that the 1st stack id is set.
 140   EXPECT_EQ(*reinterpret_cast<const uint64_t *>(Buffer + StackOffset + 8),
 141             FakeIds[0]);
 142   // Contents are num pcs, value of each pc - 1.
 143   unsigned char ExpectedStackBytes[2][6 * 8] = {
 144       {
 145           0x5, 0, 0, 0, 0, 0, 0, 0, // Number of PCs
 146           0x1, 0, 0, 0, 0, 0, 0, 0, // PC ...
 147           0x2, 0, 0, 0, 0, 0, 0, 0, 0x3, 0, 0, 0, 0, 0, 0, 0,
 148           0x4, 0, 0, 0, 0, 0, 0, 0, 0x5, 0, 0, 0, 0, 0, 0, 0,
 149       },
 150       {
 151           0x5, 0, 0, 0, 0, 0, 0, 0, // Number of PCs
 152           0x2, 0, 0, 0, 0, 0, 0, 0, // PC ...
 153           0x3, 0, 0, 0, 0, 0, 0, 0, 0x4, 0, 0, 0, 0, 0, 0, 0,
 154           0x5, 0, 0, 0, 0, 0, 0, 0, 0x6, 0, 0, 0, 0, 0, 0, 0,
 155       },
 156   };
 157   EXPECT_EQ(memcmp(Buffer + StackOffset + 16, ExpectedStackBytes[0],
 158                    sizeof(ExpectedStackBytes[0])),
 159             0);
 160
 161   // Check that the 2nd stack id is set.
 162   EXPECT_EQ(
 163       *reinterpret_cast<const uint64_t *>(Buffer + StackOffset + 8 + 6 * 8 + 8),
 164       FakeIds[1]);
 165
 166   EXPECT_EQ(memcmp(Buffer + StackOffset + 16 + 6 * 8 + 8, ExpectedStackBytes[1],
 167                    sizeof(ExpectedStackBytes[1])),
 168             0);
 169 }
 170 } // namespace