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::OF_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     ProfileSymbolList List;
 100     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
 101       List.add("zoo", true);
 102       List.add("moo", true);
 103     }
 104     Writer->setProfileSymbolList(&List);
 105
 106     std::error_code EC;
 107     EC = Writer->write(Profiles);
 108     ASSERT_TRUE(NoError(EC));
 109
 110     Writer->getOutputStream().flush();
 111
 112     readProfile(M, Profile);
 113
 114     EC = Reader->read();
 115     ASSERT_TRUE(NoError(EC));
 116
 117     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
 118       std::unique_ptr<ProfileSymbolList> ReaderList =
 119           Reader->getProfileSymbolList();
 120       ReaderList->contains("zoo");
 121       ReaderList->contains("moo");
 122     }
 123
 124     if (Remap) {
 125       auto MemBuffer = llvm::MemoryBuffer::getMemBuffer(R"(
 126         # Types 'int' and 'long' are equivalent
 127         type i l
 128         # Function names 'foo' and 'faux' are equivalent
 129         name 3foo 4faux
 130       )");
 131       Reader.reset(new SampleProfileReaderItaniumRemapper(
 132           std::move(MemBuffer), Context, std::move(Reader)));
 133       FooName = "_Z4fauxi";
 134       BarName = "_Z3barl";
 135
 136       EC = Reader->read();
 137       ASSERT_TRUE(NoError(EC));
 138     }
 139
 140     ASSERT_EQ(2u, Reader->getProfiles().size());
 141
 142     FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
 143     ASSERT_TRUE(ReadFooSamples != nullptr);
 144     if (Format != SampleProfileFormat::SPF_Compact_Binary) {
 145       ASSERT_EQ("_Z3fooi", ReadFooSamples->getName());
 146     }
 147     ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
 148     ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
 149
 150     FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName);
 151     ASSERT_TRUE(ReadBarSamples != nullptr);
 152     if (Format != SampleProfileFormat::SPF_Compact_Binary) {
 153       ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
 154     }
 155     ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
 156     ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
 157     ErrorOr<SampleRecord::CallTargetMap> CTMap =
 158         ReadBarSamples->findCallTargetMapAt(1, 0);
 159     ASSERT_FALSE(CTMap.getError());
 160
 161     std::string MconstructGUID;
 162     StringRef MconstructRep =
 163         getRepInFormat(MconstructName, Format, MconstructGUID);
 164     std::string StringviewGUID;
 165     StringRef StringviewRep =
 166         getRepInFormat(StringviewName, Format, StringviewGUID);
 167     ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
 168     ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
 169
 170     auto VerifySummary = [](ProfileSummary &Summary) mutable {
 171       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
 172       ASSERT_EQ(123603u, Summary.getTotalCount());
 173       ASSERT_EQ(6u, Summary.getNumCounts());
 174       ASSERT_EQ(2u, Summary.getNumFunctions());
 175       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
 176       ASSERT_EQ(60351u, Summary.getMaxCount());
 177
 178       uint32_t Cutoff = 800000;
 179       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
 180         return PE.Cutoff == Cutoff;
 181       };
 182       std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary();
 183       auto EightyPerc = find_if(Details, Predicate);
 184       Cutoff = 900000;
 185       auto NinetyPerc = find_if(Details, Predicate);
 186       Cutoff = 950000;
 187       auto NinetyFivePerc = find_if(Details, Predicate);
 188       Cutoff = 990000;
 189       auto NinetyNinePerc = find_if(Details, Predicate);
 190       ASSERT_EQ(60000u, EightyPerc->MinCount);
 191       ASSERT_EQ(60000u, NinetyPerc->MinCount);
 192       ASSERT_EQ(60000u, NinetyFivePerc->MinCount);
 193       ASSERT_EQ(610u, NinetyNinePerc->MinCount);
 194     };
 195
 196     ProfileSummary &Summary = Reader->getSummary();
 197     VerifySummary(Summary);
 198
 199     // Test that conversion of summary to and from Metadata works.
 200     Metadata *MD = Summary.getMD(Context);
 201     ASSERT_TRUE(MD);
 202     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
 203     ASSERT_TRUE(PS);
 204     VerifySummary(*PS);
 205     delete PS;
 206
 207     // Test that summary can be attached to and read back from module.
 208     M.setProfileSummary(MD, ProfileSummary::PSK_Sample);
 209     MD = M.getProfileSummary(/* IsCS */ false);
 210     ASSERT_TRUE(MD);
 211     PS = ProfileSummary::getFromMD(MD);
 212     ASSERT_TRUE(PS);
 213     VerifySummary(*PS);
 214     delete PS;
 215   }
 216
 217   void addFunctionSamples(StringMap<FunctionSamples> *Smap, const char *Fname,
 218                           uint64_t TotalSamples, uint64_t HeadSamples) {
 219     StringRef Name(Fname);
 220     FunctionSamples FcnSamples;
 221     FcnSamples.setName(Name);
 222     FcnSamples.addTotalSamples(TotalSamples);
 223     FcnSamples.addHeadSamples(HeadSamples);
 224     FcnSamples.addBodySamples(1, 0, HeadSamples);
 225     (*Smap)[Name] = FcnSamples;
 226   }
 227
 228   StringMap<FunctionSamples> setupFcnSamplesForElisionTest(StringRef Policy) {
 229     StringMap<FunctionSamples> Smap;
 230     addFunctionSamples(&Smap, "foo", uint64_t(20301), uint64_t(1437));
 231     if (Policy == "" || Policy == "all")
 232       return Smap;
 233     addFunctionSamples(&Smap, "foo.bar", uint64_t(20303), uint64_t(1439));
 234     if (Policy == "selected")
 235       return Smap;
 236     addFunctionSamples(&Smap, "foo.llvm.2465", uint64_t(20305), uint64_t(1441));
 237     return Smap;
 238   }
 239
 240   void createFunctionWithSampleProfileElisionPolicy(Module *M,
 241                                                     const char *Fname,
 242                                                     StringRef Policy) {
 243     FunctionType *FnType =
 244         FunctionType::get(Type::getVoidTy(Context), {}, false);
 245     auto Inserted = M->getOrInsertFunction(Fname, FnType);
 246     auto Fcn = cast<Function>(Inserted.getCallee());
 247     if (Policy != "")
 248       Fcn->addFnAttr("sample-profile-suffix-elision-policy", Policy);
 249   }
 250
 251   void setupModuleForElisionTest(Module *M, StringRef Policy) {
 252     createFunctionWithSampleProfileElisionPolicy(M, "foo", Policy);
 253     createFunctionWithSampleProfileElisionPolicy(M, "foo.bar", Policy);
 254     createFunctionWithSampleProfileElisionPolicy(M, "foo.llvm.2465", Policy);
 255   }
 256
 257   void testSuffixElisionPolicy(SampleProfileFormat Format, StringRef Policy,
 258                                const StringMap<uint64_t> &Expected) {
 259     SmallVector<char, 128> ProfilePath;
 260     std::error_code EC;
 261     EC = llvm::sys::fs::createTemporaryFile("profile", "", ProfilePath);
 262     ASSERT_TRUE(NoError(EC));
 263     StringRef ProfileFile(ProfilePath.data(), ProfilePath.size());
 264
 265     Module M("my_module", Context);
 266     setupModuleForElisionTest(&M, Policy);
 267     StringMap<FunctionSamples> ProfMap = setupFcnSamplesForElisionTest(Policy);
 268
 269     // write profile
 270     createWriter(Format, ProfileFile);
 271     EC = Writer->write(ProfMap);
 272     ASSERT_TRUE(NoError(EC));
 273     Writer->getOutputStream().flush();
 274
 275     // read profile
 276     readProfile(M, ProfileFile);
 277     EC = Reader->read();
 278     ASSERT_TRUE(NoError(EC));
 279
 280     for (auto I = Expected.begin(); I != Expected.end(); ++I) {
 281       uint64_t Esamples = uint64_t(-1);
 282       FunctionSamples *Samples = Reader->getSamplesFor(I->getKey());
 283       if (Samples != nullptr)
 284         Esamples = Samples->getTotalSamples();
 285       ASSERT_EQ(I->getValue(), Esamples);
 286     }
 287   }
 288 };
 289
 290 TEST_F(SampleProfTest, roundtrip_text_profile) {
 291   testRoundTrip(SampleProfileFormat::SPF_Text, false);
 292 }
 293
 294 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
 295   testRoundTrip(SampleProfileFormat::SPF_Binary, false);
 296 }
 297
 298 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
 299   testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false);
 300 }
 301
 302 TEST_F(SampleProfTest, roundtrip_ext_binary_profile) {
 303   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false);
 304 }
 305
 306 TEST_F(SampleProfTest, remap_text_profile) {
 307   testRoundTrip(SampleProfileFormat::SPF_Text, true);
 308 }
 309
 310 TEST_F(SampleProfTest, remap_raw_binary_profile) {
 311   testRoundTrip(SampleProfileFormat::SPF_Binary, true);
 312 }
 313
 314 TEST_F(SampleProfTest, remap_ext_binary_profile) {
 315   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, true);
 316 }
 317
 318 TEST_F(SampleProfTest, sample_overflow_saturation) {
 319   const uint64_t Max = std::numeric_limits<uint64_t>::max();
 320   sampleprof_error Result;
 321
 322   FunctionSamples FooSamples;
 323   Result = FooSamples.addTotalSamples(1);
 324   ASSERT_EQ(Result, sampleprof_error::success);
 325
 326   Result = FooSamples.addHeadSamples(1);
 327   ASSERT_EQ(Result, sampleprof_error::success);
 328
 329   Result = FooSamples.addBodySamples(10, 0, 1);
 330   ASSERT_EQ(Result, sampleprof_error::success);
 331
 332   Result = FooSamples.addTotalSamples(Max);
 333   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 334   ASSERT_EQ(FooSamples.getTotalSamples(), Max);
 335
 336   Result = FooSamples.addHeadSamples(Max);
 337   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 338   ASSERT_EQ(FooSamples.getHeadSamples(), Max);
 339
 340   Result = FooSamples.addBodySamples(10, 0, Max);
 341   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 342   ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0);
 343   ASSERT_FALSE(BodySamples.getError());
 344   ASSERT_EQ(BodySamples.get(), Max);
 345 }
 346
 347 TEST_F(SampleProfTest, default_suffix_elision_text) {
 348   // Default suffix elision policy: strip everything after first dot.
 349   // This implies that all suffix variants will map to "foo", so
 350   // we don't expect to see any entries for them in the sample
 351   // profile.
 352   StringMap<uint64_t> Expected;
 353   Expected["foo"] = uint64_t(20301);
 354   Expected["foo.bar"] = uint64_t(-1);
 355   Expected["foo.llvm.2465"] = uint64_t(-1);
 356   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "", Expected);
 357 }
 358
 359 TEST_F(SampleProfTest, default_suffix_elision_compact_binary) {
 360   // Default suffix elision policy: strip everything after first dot.
 361   // This implies that all suffix variants will map to "foo", so
 362   // we don't expect to see any entries for them in the sample
 363   // profile.
 364   StringMap<uint64_t> Expected;
 365   Expected["foo"] = uint64_t(20301);
 366   Expected["foo.bar"] = uint64_t(-1);
 367   Expected["foo.llvm.2465"] = uint64_t(-1);
 368   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "",
 369                           Expected);
 370 }
 371
 372 TEST_F(SampleProfTest, selected_suffix_elision_text) {
 373   // Profile is created and searched using the "selected"
 374   // suffix elision policy: we only strip a .XXX suffix if
 375   // it matches a pattern known to be generated by the compiler
 376   // (e.g. ".llvm.<digits>").
 377   StringMap<uint64_t> Expected;
 378   Expected["foo"] = uint64_t(20301);
 379   Expected["foo.bar"] = uint64_t(20303);
 380   Expected["foo.llvm.2465"] = uint64_t(-1);
 381   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "selected", Expected);
 382 }
 383
 384 TEST_F(SampleProfTest, selected_suffix_elision_compact_binary) {
 385   // Profile is created and searched using the "selected"
 386   // suffix elision policy: we only strip a .XXX suffix if
 387   // it matches a pattern known to be generated by the compiler
 388   // (e.g. ".llvm.<digits>").
 389   StringMap<uint64_t> Expected;
 390   Expected["foo"] = uint64_t(20301);
 391   Expected["foo.bar"] = uint64_t(20303);
 392   Expected["foo.llvm.2465"] = uint64_t(-1);
 393   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "selected",
 394                           Expected);
 395 }
 396
 397 TEST_F(SampleProfTest, none_suffix_elision_text) {
 398   // Profile is created and searched using the "none"
 399   // suffix elision policy: no stripping of suffixes at all.
 400   // Here we expect to see all variants in the profile.
 401   StringMap<uint64_t> Expected;
 402   Expected["foo"] = uint64_t(20301);
 403   Expected["foo.bar"] = uint64_t(20303);
 404   Expected["foo.llvm.2465"] = uint64_t(20305);
 405   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "none", Expected);
 406 }
 407
 408 TEST_F(SampleProfTest, none_suffix_elision_compact_binary) {
 409   // Profile is created and searched using the "none"
 410   // suffix elision policy: no stripping of suffixes at all.
 411   // Here we expect to see all variants in the profile.
 412   StringMap<uint64_t> Expected;
 413   Expected["foo"] = uint64_t(20301);
 414   Expected["foo.bar"] = uint64_t(20303);
 415   Expected["foo.llvm.2465"] = uint64_t(20305);
 416   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "none",
 417                           Expected);
 418 }
 419
 420 } // end anonymous namespace