unittests/ProfileData/SampleProfTest.cpp

   1 //===- unittest/ProfileData/SampleProfTest.cpp ------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ProfileData/SampleProf.h"
  10 #include "llvm/ADT/StringMap.h"
  11 #include "llvm/ADT/StringRef.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Metadata.h"
  14 #include "llvm/IR/Module.h"
  15 #include "llvm/ProfileData/SampleProfReader.h"
  16 #include "llvm/ProfileData/SampleProfWriter.h"
  17 #include "llvm/Support/Casting.h"
  18 #include "llvm/Support/ErrorOr.h"
  19 #include "llvm/Support/MemoryBuffer.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 #include "gtest/gtest.h"
  22 #include <string>
  23 #include <vector>
  24
  25 using namespace llvm;
  26 using namespace sampleprof;
  27
  28 static ::testing::AssertionResult NoError(std::error_code EC) {
  29   if (!EC)
  30     return ::testing::AssertionSuccess();
  31   return ::testing::AssertionFailure() << "error " << EC.value() << ": "
  32                                        << EC.message();
  33 }
  34
  35 namespace {
  36
  37 struct SampleProfTest : ::testing::Test {
  38   LLVMContext Context;
  39   std::unique_ptr<SampleProfileWriter> Writer;
  40   std::unique_ptr<SampleProfileReader> Reader;
  41
  42   SampleProfTest() : Writer(), Reader() {}
  43
  44   void createWriter(SampleProfileFormat Format, StringRef Profile) {
  45     std::error_code EC;
  46     std::unique_ptr<raw_ostream> OS(
  47         new raw_fd_ostream(Profile, EC, sys::fs::F_None));
  48     auto WriterOrErr = SampleProfileWriter::create(OS, Format);
  49     ASSERT_TRUE(NoError(WriterOrErr.getError()));
  50     Writer = std::move(WriterOrErr.get());
  51   }
  52
  53   void readProfile(const Module &M, StringRef Profile) {
  54     auto ReaderOrErr = SampleProfileReader::create(Profile, Context);
  55     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
  56     Reader = std::move(ReaderOrErr.get());
  57     Reader->collectFuncsToUse(M);
  58   }
  59
  60   void testRoundTrip(SampleProfileFormat Format, bool Remap) {
  61     SmallVector<char, 128> ProfilePath;
  62     ASSERT_TRUE(NoError(llvm::sys::fs::createTemporaryFile("profile", "", ProfilePath)));
  63     StringRef Profile(ProfilePath.data(), ProfilePath.size());
  64     createWriter(Format, Profile);
  65
  66     StringRef FooName("_Z3fooi");
  67     FunctionSamples FooSamples;
  68     FooSamples.setName(FooName);
  69     FooSamples.addTotalSamples(7711);
  70     FooSamples.addHeadSamples(610);
  71     FooSamples.addBodySamples(1, 0, 610);
  72     FooSamples.addBodySamples(2, 0, 600);
  73     FooSamples.addBodySamples(4, 0, 60000);
  74     FooSamples.addBodySamples(8, 0, 60351);
  75     FooSamples.addBodySamples(10, 0, 605);
  76
  77     StringRef BarName("_Z3bari");
  78     FunctionSamples BarSamples;
  79     BarSamples.setName(BarName);
  80     BarSamples.addTotalSamples(20301);
  81     BarSamples.addHeadSamples(1437);
  82     BarSamples.addBodySamples(1, 0, 1437);
  83     // Test how reader/writer handles unmangled names.
  84     StringRef MconstructName("_M_construct<char *>");
  85     StringRef StringviewName("string_view<std::allocator<char> >");
  86     BarSamples.addCalledTargetSamples(1, 0, MconstructName, 1000);
  87     BarSamples.addCalledTargetSamples(1, 0, StringviewName, 437);
  88
  89     Module M("my_module", Context);
  90     FunctionType *fn_type =
  91         FunctionType::get(Type::getVoidTy(Context), {}, false);
  92     M.getOrInsertFunction(FooName, fn_type);
  93     M.getOrInsertFunction(BarName, fn_type);
  94
  95     StringMap<FunctionSamples> Profiles;
  96     Profiles[FooName] = std::move(FooSamples);
  97     Profiles[BarName] = std::move(BarSamples);
  98
  99     std::error_code EC;
 100     EC = Writer->write(Profiles);
 101     ASSERT_TRUE(NoError(EC));
 102
 103     Writer->getOutputStream().flush();
 104
 105     readProfile(M, Profile);
 106
 107     EC = Reader->read();
 108     ASSERT_TRUE(NoError(EC));
 109
 110     if (Remap) {
 111       auto MemBuffer = llvm::MemoryBuffer::getMemBuffer(R"(
 112         # Types 'int' and 'long' are equivalent
 113         type i l
 114         # Function names 'foo' and 'faux' are equivalent
 115         name 3foo 4faux
 116       )");
 117       Reader.reset(new SampleProfileReaderItaniumRemapper(
 118           std::move(MemBuffer), Context, std::move(Reader)));
 119       FooName = "_Z4fauxi";
 120       BarName = "_Z3barl";
 121
 122       EC = Reader->read();
 123       ASSERT_TRUE(NoError(EC));
 124     }
 125
 126     ASSERT_EQ(2u, Reader->getProfiles().size());
 127
 128     FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
 129     ASSERT_TRUE(ReadFooSamples != nullptr);
 130     if (Format != SampleProfileFormat::SPF_Compact_Binary) {
 131       ASSERT_EQ("_Z3fooi", ReadFooSamples->getName());
 132     }
 133     ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
 134     ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
 135
 136     FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName);
 137     ASSERT_TRUE(ReadBarSamples != nullptr);
 138     if (Format != SampleProfileFormat::SPF_Compact_Binary) {
 139       ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
 140     }
 141     ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
 142     ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
 143     ErrorOr<SampleRecord::CallTargetMap> CTMap =
 144         ReadBarSamples->findCallTargetMapAt(1, 0);
 145     ASSERT_FALSE(CTMap.getError());
 146
 147     std::string MconstructGUID;
 148     StringRef MconstructRep =
 149         getRepInFormat(MconstructName, Format, MconstructGUID);
 150     std::string StringviewGUID;
 151     StringRef StringviewRep =
 152         getRepInFormat(StringviewName, Format, StringviewGUID);
 153     ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
 154     ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
 155
 156     auto VerifySummary = [](ProfileSummary &Summary) mutable {
 157       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
 158       ASSERT_EQ(123603u, Summary.getTotalCount());
 159       ASSERT_EQ(6u, Summary.getNumCounts());
 160       ASSERT_EQ(2u, Summary.getNumFunctions());
 161       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
 162       ASSERT_EQ(60351u, Summary.getMaxCount());
 163
 164       uint32_t Cutoff = 800000;
 165       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
 166         return PE.Cutoff == Cutoff;
 167       };
 168       std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();
 169       auto EightyPerc = find_if(Details, Predicate);
 170       Cutoff = 900000;
 171       auto NinetyPerc = find_if(Details, Predicate);
 172       Cutoff = 950000;
 173       auto NinetyFivePerc = find_if(Details, Predicate);
 174       Cutoff = 990000;
 175       auto NinetyNinePerc = find_if(Details, Predicate);
 176       ASSERT_EQ(60000u, EightyPerc->MinCount);
 177       ASSERT_EQ(60000u, NinetyPerc->MinCount);
 178       ASSERT_EQ(60000u, NinetyFivePerc->MinCount);
 179       ASSERT_EQ(610u, NinetyNinePerc->MinCount);
 180     };
 181
 182     ProfileSummary &Summary = Reader->getSummary();
 183     VerifySummary(Summary);
 184
 185     // Test that conversion of summary to and from Metadata works.
 186     Metadata *MD = Summary.getMD(Context);
 187     ASSERT_TRUE(MD);
 188     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
 189     ASSERT_TRUE(PS);
 190     VerifySummary(*PS);
 191     delete PS;
 192
 193     // Test that summary can be attached to and read back from module.
 194     M.setProfileSummary(MD);
 195     MD = M.getProfileSummary();
 196     ASSERT_TRUE(MD);
 197     PS = ProfileSummary::getFromMD(MD);
 198     ASSERT_TRUE(PS);
 199     VerifySummary(*PS);
 200     delete PS;
 201   }
 202 };
 203
 204 TEST_F(SampleProfTest, roundtrip_text_profile) {
 205   testRoundTrip(SampleProfileFormat::SPF_Text, false);
 206 }
 207
 208 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
 209   testRoundTrip(SampleProfileFormat::SPF_Binary, false);
 210 }
 211
 212 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
 213   testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false);
 214 }
 215
 216 TEST_F(SampleProfTest, remap_text_profile) {
 217   testRoundTrip(SampleProfileFormat::SPF_Text, true);
 218 }
 219
 220 TEST_F(SampleProfTest, remap_raw_binary_profile) {
 221   testRoundTrip(SampleProfileFormat::SPF_Binary, true);
 222 }
 223
 224 TEST_F(SampleProfTest, sample_overflow_saturation) {
 225   const uint64_t Max = std::numeric_limits<uint64_t>::max();
 226   sampleprof_error Result;
 227
 228   StringRef FooName("_Z3fooi");
 229   FunctionSamples FooSamples;
 230   Result = FooSamples.addTotalSamples(1);
 231   ASSERT_EQ(Result, sampleprof_error::success);
 232
 233   Result = FooSamples.addHeadSamples(1);
 234   ASSERT_EQ(Result, sampleprof_error::success);
 235
 236   Result = FooSamples.addBodySamples(10, 0, 1);
 237   ASSERT_EQ(Result, sampleprof_error::success);
 238
 239   Result = FooSamples.addTotalSamples(Max);
 240   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 241   ASSERT_EQ(FooSamples.getTotalSamples(), Max);
 242
 243   Result = FooSamples.addHeadSamples(Max);
 244   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 245   ASSERT_EQ(FooSamples.getHeadSamples(), Max);
 246
 247   Result = FooSamples.addBodySamples(10, 0, Max);
 248   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 249   ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0);
 250   ASSERT_FALSE(BodySamples.getError());
 251   ASSERT_EQ(BodySamples.get(), Max);
 252 }
 253
 254 } // end anonymous namespace