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
NoError(std::error_code EC)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
SampleProfTest__anon99df410f0111::SampleProfTest47 SampleProfTest() : Writer(), Reader() {}
48
createWriter__anon99df410f0111::SampleProfTest49 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
readProfile__anon99df410f0111::SampleProfTest58 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
createRemapFile__anon99df410f0111::SampleProfTest68 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.
verifyProfileSummary__anon99df410f0111::SampleProfTest81 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
testRoundTrip__anon99df410f0111::SampleProfTest138 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
addFunctionSamples__anon99df410f0111::SampleProfTest331 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
setupFcnSamplesForElisionTest__anon99df410f0111::SampleProfTest342 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
createFunctionWithSampleProfileElisionPolicy__anon99df410f0111::SampleProfTest354 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
setupModuleForElisionTest__anon99df410f0111::SampleProfTest365 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
testSuffixElisionPolicy__anon99df410f0111::SampleProfTest371 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
TEST_F(SampleProfTest,roundtrip_text_profile)401 TEST_F(SampleProfTest, roundtrip_text_profile) {
402 testRoundTrip(SampleProfileFormat::SPF_Text, false, false);
403 }
404
TEST_F(SampleProfTest,roundtrip_raw_binary_profile)405 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
406 testRoundTrip(SampleProfileFormat::SPF_Binary, false, false);
407 }
408
TEST_F(SampleProfTest,roundtrip_compact_binary_profile)409 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
410 testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false, true);
411 }
412
TEST_F(SampleProfTest,roundtrip_ext_binary_profile)413 TEST_F(SampleProfTest, roundtrip_ext_binary_profile) {
414 testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, false);
415 }
416
TEST_F(SampleProfTest,roundtrip_md5_ext_binary_profile)417 TEST_F(SampleProfTest, roundtrip_md5_ext_binary_profile) {
418 testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, false, true);
419 }
420
TEST_F(SampleProfTest,remap_text_profile)421 TEST_F(SampleProfTest, remap_text_profile) {
422 testRoundTrip(SampleProfileFormat::SPF_Text, true, false);
423 }
424
TEST_F(SampleProfTest,remap_raw_binary_profile)425 TEST_F(SampleProfTest, remap_raw_binary_profile) {
426 testRoundTrip(SampleProfileFormat::SPF_Binary, true, false);
427 }
428
TEST_F(SampleProfTest,remap_ext_binary_profile)429 TEST_F(SampleProfTest, remap_ext_binary_profile) {
430 testRoundTrip(SampleProfileFormat::SPF_Ext_Binary, true, false);
431 }
432
TEST_F(SampleProfTest,sample_overflow_saturation)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
TEST_F(SampleProfTest,default_suffix_elision_text)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
TEST_F(SampleProfTest,default_suffix_elision_compact_binary)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
TEST_F(SampleProfTest,selected_suffix_elision_text)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
TEST_F(SampleProfTest,selected_suffix_elision_compact_binary)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
TEST_F(SampleProfTest,none_suffix_elision_text)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
TEST_F(SampleProfTest,none_suffix_elision_compact_binary)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
536