llvm/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/DebugInfoMetadata.h"
  13 #include "llvm/IR/LLVMContext.h"
  14 #include "llvm/IR/Metadata.h"
  15 #include "llvm/IR/Module.h"
  16 #include "llvm/ProfileData/SampleProfReader.h"
  17 #include "llvm/ProfileData/SampleProfWriter.h"
  18 #include "llvm/Support/Casting.h"
  19 #include "llvm/Support/ErrorOr.h"
  20 #include "llvm/Support/FileSystem.h"
  21 #include "llvm/Support/MemoryBuffer.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include "llvm/Testing/Support/SupportHelpers.h"
  24 #include "gtest/gtest.h"
  25 #include <string>
  26 #include <vector>
  27
  28 using namespace llvm;
  29 using namespace sampleprof;
  30
  31 using llvm::unittest::TempFile;
  32
  33 static ::testing::AssertionResult NoError(std::error_code EC) {
  34   if (!EC)
  35     return ::testing::AssertionSuccess();
  36   return ::testing::AssertionFailure() << "error " << EC.value() << ": "
  37                                        << EC.message();
  38 }
  39
  40 namespace {
  41
  42 struct SampleProfTest : ::testing::Test {
  43   LLVMContext Context;
  44   std::unique_ptr<SampleProfileWriter> Writer;
  45   std::unique_ptr<SampleProfileReader> Reader;
  46
  47   SampleProfTest() : Writer(), Reader() {}
  48
  49   void createWriter(SampleProfileFormat Format, StringRef Profile) {
  50     std::error_code EC;
  51     std::unique_ptr<raw_ostream> OS(
  52         new raw_fd_ostream(Profile, EC, sys::fs::OF_None));
  53     auto WriterOrErr = SampleProfileWriter::create(OS, Format);
  54     ASSERT_TRUE(NoError(WriterOrErr.getError()));
  55     Writer = std::move(WriterOrErr.get());
  56   }
  57
  58   void readProfile(const Module &M, StringRef Profile,
  59                    StringRef RemapFile = "") {
  60     auto ReaderOrErr = SampleProfileReader::create(
  61         std::string(Profile), Context, FSDiscriminatorPass::Base,
  62         std::string(RemapFile));
  63     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
  64     Reader = std::move(ReaderOrErr.get());
  65     Reader->setModule(&M);
  66   }
  67
  68   TempFile createRemapFile() {
  69     return TempFile("remapfile", "", R"(
  70       # Types 'int' and 'long' are equivalent
  71       type i l
  72       # Function names 'foo' and 'faux' are equivalent
  73       name 3foo 4faux
  74     )",
  75                     /*Unique*/ true);
  76   }
  77
  78   // Verify profile summary is consistent in the roundtrip to and from
  79   // Metadata. \p AddPartialField is to choose whether the Metadata
  80   // contains the IsPartialProfile field which is optional.
  81   void verifyProfileSummary(ProfileSummary &Summary, Module &M,
  82                             const bool AddPartialField,
  83                             const bool AddPartialProfileRatioField) {
  84     LLVMContext &Context = M.getContext();
  85     const bool IsPartialProfile = Summary.isPartialProfile();
  86     const double PartialProfileRatio = Summary.getPartialProfileRatio();
  87     auto VerifySummary = [IsPartialProfile, PartialProfileRatio](
  88                              ProfileSummary &Summary) mutable {
  89       ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind());
  90       ASSERT_EQ(138211u, Summary.getTotalCount());
  91       ASSERT_EQ(10u, Summary.getNumCounts());
  92       ASSERT_EQ(4u, Summary.getNumFunctions());
  93       ASSERT_EQ(1437u, Summary.getMaxFunctionCount());
  94       ASSERT_EQ(60351u, Summary.getMaxCount());
  95       ASSERT_EQ(IsPartialProfile, Summary.isPartialProfile());
  96       ASSERT_EQ(PartialProfileRatio, Summary.getPartialProfileRatio());
  97
  98       uint32_t Cutoff = 800000;
  99       auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) {
 100         return PE.Cutoff == Cutoff;
 101       };
 102       const std::vector<ProfileSummaryEntry> &Details =
 103           Summary.getDetailedSummary();
 104       auto EightyPerc = find_if(Details, Predicate);
 105       Cutoff = 900000;
 106       auto NinetyPerc = find_if(Details, Predicate);
 107       Cutoff = 950000;
 108       auto NinetyFivePerc = find_if(Details, Predicate);
 109       Cutoff = 990000;
 110       auto NinetyNinePerc = find_if(Details, Predicate);
 111       ASSERT_EQ(60000u, EightyPerc->MinCount);
 112       ASSERT_EQ(12557u, NinetyPerc->MinCount);
 113       ASSERT_EQ(12557u, NinetyFivePerc->MinCount);
 114       ASSERT_EQ(600u, NinetyNinePerc->MinCount);
 115     };
 116     VerifySummary(Summary);
 117
 118     // Test that conversion of summary to and from Metadata works.
 119     Metadata *MD =
 120         Summary.getMD(Context, AddPartialField, AddPartialProfileRatioField);
 121     ASSERT_TRUE(MD);
 122     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
 123     ASSERT_TRUE(PS);
 124     VerifySummary(*PS);
 125     delete PS;
 126
 127     // Test that summary can be attached to and read back from module.
 128     M.eraseNamedMetadata(M.getOrInsertModuleFlagsMetadata());
 129     M.setProfileSummary(MD, ProfileSummary::PSK_Sample);
 130     MD = M.getProfileSummary(/* IsCS */ false);
 131     ASSERT_TRUE(MD);
 132     PS = ProfileSummary::getFromMD(MD);
 133     ASSERT_TRUE(PS);
 134     VerifySummary(*PS);
 135     delete PS;
 136   }
 137
 138   void testRoundTrip(SampleProfileFormat Format, bool Remap, bool UseMD5) {
 139     TempFile ProfileFile("profile", "", "", /*Unique*/ true);
 140     createWriter(Format, ProfileFile.path());
 141     if (Format == SampleProfileFormat::SPF_Ext_Binary && UseMD5)
 142       static_cast<SampleProfileWriterExtBinary *>(Writer.get())->setUseMD5();
 143
 144     StringRef FooName("_Z3fooi");
 145     FunctionSamples FooSamples;
 146     FooSamples.setName(FooName);
 147     FooSamples.addTotalSamples(7711);
 148     FooSamples.addHeadSamples(610);
 149     FooSamples.addBodySamples(1, 0, 610);
 150     FooSamples.addBodySamples(2, 0, 600);
 151     FooSamples.addBodySamples(4, 0, 60000);
 152     FooSamples.addBodySamples(8, 0, 60351);
 153     FooSamples.addBodySamples(10, 0, 605);
 154
 155     // Add inline instance with name "_Z3gooi".
 156     StringRef GooName("_Z3gooi");
 157     auto &GooSamples =
 158         FooSamples.functionSamplesAt(LineLocation(7, 0))[GooName.str()];
 159     GooSamples.setName(GooName);
 160     GooSamples.addTotalSamples(502);
 161     GooSamples.addBodySamples(3, 0, 502);
 162
 163     // Add inline instance with name "_Z3hooi".
 164     StringRef HooName("_Z3hooi");
 165     auto &HooSamples =
 166         GooSamples.functionSamplesAt(LineLocation(9, 0))[HooName.str()];
 167     HooSamples.setName(HooName);
 168     HooSamples.addTotalSamples(317);
 169     HooSamples.addBodySamples(4, 0, 317);
 170
 171     StringRef BarName("_Z3bari");
 172     FunctionSamples BarSamples;
 173     BarSamples.setName(BarName);
 174     BarSamples.addTotalSamples(20301);
 175     BarSamples.addHeadSamples(1437);
 176     BarSamples.addBodySamples(1, 0, 1437);
 177     // Test how reader/writer handles unmangled names.
 178     StringRef MconstructName("_M_construct<char *>");
 179     StringRef StringviewName("string_view<std::allocator<char> >");
 180     BarSamples.addCalledTargetSamples(1, 0, MconstructName, 1000);
 181     BarSamples.addCalledTargetSamples(1, 0, StringviewName, 437);
 182
 183     StringRef BazName("_Z3bazi");
 184     FunctionSamples BazSamples;
 185     BazSamples.setName(BazName);
 186     BazSamples.addTotalSamples(12557);
 187     BazSamples.addHeadSamples(1257);
 188     BazSamples.addBodySamples(1, 0, 12557);
 189
 190     StringRef BooName("_Z3booi");
 191     FunctionSamples BooSamples;
 192     BooSamples.setName(BooName);
 193     BooSamples.addTotalSamples(1232);
 194     BooSamples.addHeadSamples(1);
 195     BooSamples.addBodySamples(1, 0, 1232);
 196
 197     SampleProfileMap Profiles;
 198     Profiles[FooName] = std::move(FooSamples);
 199     Profiles[BarName] = std::move(BarSamples);
 200     Profiles[BazName] = std::move(BazSamples);
 201     Profiles[BooName] = std::move(BooSamples);
 202
 203     Module M("my_module", Context);
 204     FunctionType *fn_type =
 205         FunctionType::get(Type::getVoidTy(Context), {}, false);
 206
 207     TempFile RemapFile(createRemapFile());
 208     if (Remap) {
 209       FooName = "_Z4fauxi";
 210       BarName = "_Z3barl";
 211       GooName = "_Z3gool";
 212       HooName = "_Z3hool";
 213     }
 214
 215     M.getOrInsertFunction(FooName, fn_type);
 216     M.getOrInsertFunction(BarName, fn_type);
 217     M.getOrInsertFunction(BooName, fn_type);
 218
 219     ProfileSymbolList List;
 220     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
 221       List.add("zoo", true);
 222       List.add("moo", true);
 223     }
 224     Writer->setProfileSymbolList(&List);
 225
 226     std::error_code EC;
 227     EC = Writer->write(Profiles);
 228     ASSERT_TRUE(NoError(EC));
 229
 230     Writer->getOutputStream().flush();
 231
 232     readProfile(M, ProfileFile.path(), RemapFile.path());
 233     EC = Reader->read();
 234     ASSERT_TRUE(NoError(EC));
 235
 236     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
 237       std::unique_ptr<ProfileSymbolList> ReaderList =
 238           Reader->getProfileSymbolList();
 239       ReaderList->contains("zoo");
 240       ReaderList->contains("moo");
 241     }
 242
 243     FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
 244     ASSERT_TRUE(ReadFooSamples != nullptr);
 245     if (!UseMD5) {
 246       ASSERT_EQ("_Z3fooi", ReadFooSamples->getName());
 247     }
 248     ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
 249     ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
 250
 251     // Try to find a FunctionSamples with GooName at given callsites containing
 252     // inline instance for GooName. Test the correct FunctionSamples can be
 253     // found with Remapper support.
 254     const FunctionSamples *ReadGooSamples =
 255         ReadFooSamples->findFunctionSamplesAt(LineLocation(7, 0), GooName,
 256                                               Reader->getRemapper());
 257     ASSERT_TRUE(ReadGooSamples != nullptr);
 258     ASSERT_EQ(502u, ReadGooSamples->getTotalSamples());
 259
 260     // Try to find a FunctionSamples with GooName at given callsites containing
 261     // no inline instance for GooName. Test no FunctionSamples will be
 262     // found with Remapper support.
 263     const FunctionSamples *ReadGooSamplesAgain =
 264         ReadFooSamples->findFunctionSamplesAt(LineLocation(9, 0), GooName,
 265                                               Reader->getRemapper());
 266     ASSERT_TRUE(ReadGooSamplesAgain == nullptr);
 267
 268     // The inline instance of Hoo is inside of the inline instance of Goo.
 269     // Try to find a FunctionSamples with HooName at given callsites containing
 270     // inline instance for HooName. Test the correct FunctionSamples can be
 271     // found with Remapper support.
 272     const FunctionSamples *ReadHooSamples =
 273         ReadGooSamples->findFunctionSamplesAt(LineLocation(9, 0), HooName,
 274                                               Reader->getRemapper());
 275     ASSERT_TRUE(ReadHooSamples != nullptr);
 276     ASSERT_EQ(317u, ReadHooSamples->getTotalSamples());
 277
 278     FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName);
 279     ASSERT_TRUE(ReadBarSamples != nullptr);
 280     if (!UseMD5) {
 281       ASSERT_EQ("_Z3bari", ReadBarSamples->getName());
 282     }
 283     ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
 284     ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
 285     ErrorOr<SampleRecord::CallTargetMap> CTMap =
 286         ReadBarSamples->findCallTargetMapAt(1, 0);
 287     ASSERT_FALSE(CTMap.getError());
 288
 289     // Because _Z3bazi is not defined in module M, expect _Z3bazi's profile
 290     // is not loaded when the profile is ExtBinary or Compact format because
 291     // these formats support loading function profiles on demand.
 292     FunctionSamples *ReadBazSamples = Reader->getSamplesFor(BazName);
 293     if (Format == SampleProfileFormat::SPF_Ext_Binary ||
 294         Format == SampleProfileFormat::SPF_Compact_Binary) {
 295       ASSERT_TRUE(ReadBazSamples == nullptr);
 296       ASSERT_EQ(3u, Reader->getProfiles().size());
 297     } else {
 298       ASSERT_TRUE(ReadBazSamples != nullptr);
 299       ASSERT_EQ(12557u, ReadBazSamples->getTotalSamples());
 300       ASSERT_EQ(4u, Reader->getProfiles().size());
 301     }
 302
 303     FunctionSamples *ReadBooSamples = Reader->getSamplesFor(BooName);
 304     ASSERT_TRUE(ReadBooSamples != nullptr);
 305     ASSERT_EQ(1232u, ReadBooSamples->getTotalSamples());
 306
 307     std::string MconstructGUID;
 308     StringRef MconstructRep =
 309         getRepInFormat(MconstructName, UseMD5, MconstructGUID);
 310     std::string StringviewGUID;
 311     StringRef StringviewRep =
 312         getRepInFormat(StringviewName, UseMD5, StringviewGUID);
 313     ASSERT_EQ(1000u, CTMap.get()[MconstructRep]);
 314     ASSERT_EQ(437u, CTMap.get()[StringviewRep]);
 315
 316
 317     ProfileSummary &Summary = Reader->getSummary();
 318     Summary.setPartialProfile(true);
 319     verifyProfileSummary(Summary, M, true, false);
 320
 321     Summary.setPartialProfile(false);
 322     verifyProfileSummary(Summary, M, true, false);
 323
 324     verifyProfileSummary(Summary, M, false, false);
 325
 326     Summary.setPartialProfile(true);
 327     Summary.setPartialProfileRatio(0.5);
 328     verifyProfileSummary(Summary, M, true, true);
 329   }
 330
 331   void addFunctionSamples(SampleProfileMap *Smap, const char *Fname,
 332                           uint64_t TotalSamples, uint64_t HeadSamples) {
 333     StringRef Name(Fname);
 334     FunctionSamples FcnSamples;
 335     FcnSamples.setName(Name);
 336     FcnSamples.addTotalSamples(TotalSamples);
 337     FcnSamples.addHeadSamples(HeadSamples);
 338     FcnSamples.addBodySamples(1, 0, HeadSamples);
 339     (*Smap)[Name] = FcnSamples;
 340   }
 341
 342   SampleProfileMap setupFcnSamplesForElisionTest(StringRef Policy) {
 343     SampleProfileMap Smap;
 344     addFunctionSamples(&Smap, "foo", uint64_t(20301), uint64_t(1437));
 345     if (Policy == "" || Policy == "all")
 346       return Smap;
 347     addFunctionSamples(&Smap, "foo.bar", uint64_t(20303), uint64_t(1439));
 348     if (Policy == "selected")
 349       return Smap;
 350     addFunctionSamples(&Smap, "foo.llvm.2465", uint64_t(20305), uint64_t(1441));
 351     return Smap;
 352   }
 353
 354   void createFunctionWithSampleProfileElisionPolicy(Module *M,
 355                                                     const char *Fname,
 356                                                     StringRef Policy) {
 357     FunctionType *FnType =
 358         FunctionType::get(Type::getVoidTy(Context), {}, false);
 359     auto Inserted = M->getOrInsertFunction(Fname, FnType);
 360     auto Fcn = cast<Function>(Inserted.getCallee());
 361     if (Policy != "")
 362       Fcn->addFnAttr("sample-profile-suffix-elision-policy", Policy);
 363   }
 364
 365   void setupModuleForElisionTest(Module *M, StringRef Policy) {
 366     createFunctionWithSampleProfileElisionPolicy(M, "foo", Policy);
 367     createFunctionWithSampleProfileElisionPolicy(M, "foo.bar", Policy);
 368     createFunctionWithSampleProfileElisionPolicy(M, "foo.llvm.2465", Policy);
 369   }
 370
 371   void testSuffixElisionPolicy(SampleProfileFormat Format, StringRef Policy,
 372                                const StringMap<uint64_t> &Expected) {
 373     TempFile ProfileFile("profile", "", "", /*Unique*/ true);
 374
 375     Module M("my_module", Context);
 376     setupModuleForElisionTest(&M, Policy);
 377     SampleProfileMap ProfMap = setupFcnSamplesForElisionTest(Policy);
 378
 379     // write profile
 380     createWriter(Format, ProfileFile.path());
 381     std::error_code EC;
 382     EC = Writer->write(ProfMap);
 383     ASSERT_TRUE(NoError(EC));
 384     Writer->getOutputStream().flush();
 385
 386     // read profile
 387     readProfile(M, ProfileFile.path());
 388     EC = Reader->read();
 389     ASSERT_TRUE(NoError(EC));
 390
 391     for (auto I = Expected.begin(); I != Expected.end(); ++I) {
 392       uint64_t Esamples = uint64_t(-1);
 393       FunctionSamples *Samples = Reader->getSamplesFor(I->getKey());
 394       if (Samples != nullptr)
 395         Esamples = Samples->getTotalSamples();
 396       ASSERT_EQ(I->getValue(), Esamples);
 397     }
 398   }
 399 };
 400
 401 TEST_F(SampleProfTest, roundtrip_text_profile) {
 402   testRoundTrip(SampleProfileFormat::SPF_Text, false, false);
 403 }
 404
 405 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
 406   testRoundTrip(SampleProfileFormat::SPF_Binary, false, false);
 407 }
 408
 409 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
 410   testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false, true);
 411 }
 412
 413 TEST_F(SampleProfTest, roundtrip_ext_binary_profile) {
 414   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, false);
 415 }
 416
 417 TEST_F(SampleProfTest, roundtrip_md5_ext_binary_profile) {
 418   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, true);
 419 }
 420
 421 TEST_F(SampleProfTest, remap_text_profile) {
 422   testRoundTrip(SampleProfileFormat::SPF_Text, true, false);
 423 }
 424
 425 TEST_F(SampleProfTest, remap_raw_binary_profile) {
 426   testRoundTrip(SampleProfileFormat::SPF_Binary, true, false);
 427 }
 428
 429 TEST_F(SampleProfTest, remap_ext_binary_profile) {
 430   testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, true, false);
 431 }
 432
 433 TEST_F(SampleProfTest, sample_overflow_saturation) {
 434   const uint64_t Max = std::numeric_limits<uint64_t>::max();
 435   sampleprof_error Result;
 436
 437   FunctionSamples FooSamples;
 438   Result = FooSamples.addTotalSamples(1);
 439   ASSERT_EQ(Result, sampleprof_error::success);
 440
 441   Result = FooSamples.addHeadSamples(1);
 442   ASSERT_EQ(Result, sampleprof_error::success);
 443
 444   Result = FooSamples.addBodySamples(10, 0, 1);
 445   ASSERT_EQ(Result, sampleprof_error::success);
 446
 447   Result = FooSamples.addTotalSamples(Max);
 448   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 449   ASSERT_EQ(FooSamples.getTotalSamples(), Max);
 450
 451   Result = FooSamples.addHeadSamples(Max);
 452   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 453   ASSERT_EQ(FooSamples.getHeadSamples(), Max);
 454
 455   Result = FooSamples.addBodySamples(10, 0, Max);
 456   ASSERT_EQ(Result, sampleprof_error::counter_overflow);
 457   ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0);
 458   ASSERT_FALSE(BodySamples.getError());
 459   ASSERT_EQ(BodySamples.get(), Max);
 460 }
 461
 462 TEST_F(SampleProfTest, default_suffix_elision_text) {
 463   // Default suffix elision policy: strip everything after first dot.
 464   // This implies that all suffix variants will map to "foo", so
 465   // we don't expect to see any entries for them in the sample
 466   // profile.
 467   StringMap<uint64_t> Expected;
 468   Expected["foo"] = uint64_t(20301);
 469   Expected["foo.bar"] = uint64_t(-1);
 470   Expected["foo.llvm.2465"] = uint64_t(-1);
 471   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "", Expected);
 472 }
 473
 474 TEST_F(SampleProfTest, default_suffix_elision_compact_binary) {
 475   // Default suffix elision policy: strip everything after first dot.
 476   // This implies that all suffix variants will map to "foo", so
 477   // we don't expect to see any entries for them in the sample
 478   // profile.
 479   StringMap<uint64_t> Expected;
 480   Expected["foo"] = uint64_t(20301);
 481   Expected["foo.bar"] = uint64_t(-1);
 482   Expected["foo.llvm.2465"] = uint64_t(-1);
 483   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "",
 484                           Expected);
 485 }
 486
 487 TEST_F(SampleProfTest, selected_suffix_elision_text) {
 488   // Profile is created and searched using the "selected"
 489   // suffix elision policy: we only strip a .XXX suffix if
 490   // it matches a pattern known to be generated by the compiler
 491   // (e.g. ".llvm.<digits>").
 492   StringMap<uint64_t> Expected;
 493   Expected["foo"] = uint64_t(20301);
 494   Expected["foo.bar"] = uint64_t(20303);
 495   Expected["foo.llvm.2465"] = uint64_t(-1);
 496   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "selected", Expected);
 497 }
 498
 499 TEST_F(SampleProfTest, selected_suffix_elision_compact_binary) {
 500   // Profile is created and searched using the "selected"
 501   // suffix elision policy: we only strip a .XXX suffix if
 502   // it matches a pattern known to be generated by the compiler
 503   // (e.g. ".llvm.<digits>").
 504   StringMap<uint64_t> Expected;
 505   Expected["foo"] = uint64_t(20301);
 506   Expected["foo.bar"] = uint64_t(20303);
 507   Expected["foo.llvm.2465"] = uint64_t(-1);
 508   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "selected",
 509                           Expected);
 510 }
 511
 512 TEST_F(SampleProfTest, none_suffix_elision_text) {
 513   // Profile is created and searched using the "none"
 514   // suffix elision policy: no stripping of suffixes at all.
 515   // Here we expect to see all variants in the profile.
 516   StringMap<uint64_t> Expected;
 517   Expected["foo"] = uint64_t(20301);
 518   Expected["foo.bar"] = uint64_t(20303);
 519   Expected["foo.llvm.2465"] = uint64_t(20305);
 520   testSuffixElisionPolicy(SampleProfileFormat::SPF_Text, "none", Expected);
 521 }
 522
 523 TEST_F(SampleProfTest, none_suffix_elision_compact_binary) {
 524   // Profile is created and searched using the "none"
 525   // suffix elision policy: no stripping of suffixes at all.
 526   // Here we expect to see all variants in the profile.
 527   StringMap<uint64_t> Expected;
 528   Expected["foo"] = uint64_t(20301);
 529   Expected["foo.bar"] = uint64_t(20303);
 530   Expected["foo.llvm.2465"] = uint64_t(20305);
 531   testSuffixElisionPolicy(SampleProfileFormat::SPF_Compact_Binary, "none",
 532                           Expected);
 533 }
 534
 535 } // end anonymous namespace