1 //===- ProfileSummaryInfoTest.cpp - ProfileSummaryInfo unit tests ---------===//
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/Analysis/ProfileSummaryInfo.h"
10 #include "llvm/Analysis/BlockFrequencyInfo.h"
11 #include "llvm/Analysis/BranchProbabilityInfo.h"
12 #include "llvm/Analysis/LoopInfo.h"
13 #include "llvm/AsmParser/Parser.h"
14 #include "llvm/IR/BasicBlock.h"
15 #include "llvm/IR/Dominators.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/LLVMContext.h"
18 #include "llvm/IR/MDBuilder.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/DataTypes.h"
21 #include "llvm/Support/FormatVariadic.h"
22 #include "llvm/Support/SourceMgr.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include "gtest/gtest.h"
25 
26 extern llvm::cl::opt<bool> ScalePartialSampleProfileWorkingSetSize;
27 
28 namespace llvm {
29 namespace {
30 
31 class ProfileSummaryInfoTest : public testing::Test {
32 protected:
33   LLVMContext C;
34   std::unique_ptr<BranchProbabilityInfo> BPI;
35   std::unique_ptr<DominatorTree> DT;
36   std::unique_ptr<LoopInfo> LI;
37 
38   ProfileSummaryInfo buildPSI(Module *M) {
39     return ProfileSummaryInfo(*M);
40   }
41   BlockFrequencyInfo buildBFI(Function &F) {
42     DT.reset(new DominatorTree(F));
43     LI.reset(new LoopInfo(*DT));
44     BPI.reset(new BranchProbabilityInfo(F, *LI));
45     return BlockFrequencyInfo(F, *BPI, *LI);
46   }
47   std::unique_ptr<Module> makeLLVMModule(const char *ProfKind = nullptr,
48                                          uint64_t NumCounts = 3,
49                                          uint64_t IsPartialProfile = 0,
50                                          double PartialProfileRatio = 0.0,
51                                          uint64_t HotNumCounts = 3,
52                                          uint64_t ColdNumCounts = 10) {
53     const char *ModuleString =
54         "define i32 @g(i32 %x) !prof !21 {{\n"
55         "  ret i32 0\n"
56         "}\n"
57         "define i32 @h(i32 %x) !prof !22 {{\n"
58         "  ret i32 0\n"
59         "}\n"
60         "define i32 @f(i32 %x) !prof !20 {{\n"
61         "bb0:\n"
62         "  %y1 = icmp eq i32 %x, 0 \n"
63         "  br i1 %y1, label %bb1, label %bb2, !prof !23 \n"
64         "bb1:\n"
65         "  %z1 = call i32 @g(i32 %x)\n"
66         "  br label %bb3\n"
67         "bb2:\n"
68         "  %z2 = call i32 @h(i32 %x)\n"
69         "  br label %bb3\n"
70         "bb3:\n"
71         "  %y2 = phi i32 [0, %bb1], [1, %bb2] \n"
72         "  ret i32 %y2\n"
73         "}\n"
74         "define i32 @l(i32 %x) {{\n"
75         "bb0:\n"
76         "  %y1 = icmp eq i32 %x, 0 \n"
77         "  br i1 %y1, label %bb1, label %bb2, !prof !23 \n"
78         "bb1:\n"
79         "  %z1 = call i32 @g(i32 %x)\n"
80         "  br label %bb3\n"
81         "bb2:\n"
82         "  %z2 = call i32 @h(i32 %x)\n"
83         "  br label %bb3\n"
84         "bb3:\n"
85         "  %y2 = phi i32 [0, %bb1], [1, %bb2] \n"
86         "  ret i32 %y2\n"
87         "}\n"
88         "!20 = !{{!\"function_entry_count\", i64 400}\n"
89         "!21 = !{{!\"function_entry_count\", i64 1}\n"
90         "!22 = !{{!\"function_entry_count\", i64 100}\n"
91         "!23 = !{{!\"branch_weights\", i32 64, i32 4}\n"
92         "{0}";
93     const char *SummaryString =
94         "!llvm.module.flags = !{{!1}\n"
95         "!1 = !{{i32 1, !\"ProfileSummary\", !2}\n"
96         "!2 = !{{!3, !4, !5, !6, !7, !8, !9, !10, !11, !12}\n"
97         "!3 = !{{!\"ProfileFormat\", !\"{0}\"}\n"
98         "!4 = !{{!\"TotalCount\", i64 10000}\n"
99         "!5 = !{{!\"MaxCount\", i64 10}\n"
100         "!6 = !{{!\"MaxInternalCount\", i64 1}\n"
101         "!7 = !{{!\"MaxFunctionCount\", i64 1000}\n"
102         "!8 = !{{!\"NumCounts\", i64 {1}}\n"
103         "!9 = !{{!\"NumFunctions\", i64 3}\n"
104         "!10 = !{{!\"IsPartialProfile\", i64 {2}}\n"
105         "!11 = !{{!\"PartialProfileRatio\", double {3}}\n"
106         "!12 = !{{!\"DetailedSummary\", !13}\n"
107         "!13 = !{{!14, !15, !16}\n"
108         "!14 = !{{i32 10000, i64 1000, i32 1}\n"
109         "!15 = !{{i32 990000, i64 300, i32 {4}}\n"
110         "!16 = !{{i32 999999, i64 5, i32 {5}}\n";
111     SMDiagnostic Err;
112     if (ProfKind) {
113       auto Summary =
114           formatv(SummaryString, ProfKind, NumCounts, IsPartialProfile,
115                   PartialProfileRatio, HotNumCounts, ColdNumCounts)
116               .str();
117       return parseAssemblyString(formatv(ModuleString, Summary).str(), Err, C);
118     } else
119       return parseAssemblyString(formatv(ModuleString, "").str(), Err, C);
120   }
121 };
122 
123 TEST_F(ProfileSummaryInfoTest, TestNoProfile) {
124   auto M = makeLLVMModule(/*ProfKind=*/nullptr);
125   Function *F = M->getFunction("f");
126 
127   ProfileSummaryInfo PSI = buildPSI(M.get());
128   EXPECT_FALSE(PSI.hasProfileSummary());
129   EXPECT_FALSE(PSI.hasSampleProfile());
130   EXPECT_FALSE(PSI.hasInstrumentationProfile());
131   // In the absence of profiles, is{Hot|Cold}X methods should always return
132   // false.
133   EXPECT_FALSE(PSI.isHotCount(1000));
134   EXPECT_FALSE(PSI.isHotCount(0));
135   EXPECT_FALSE(PSI.isColdCount(1000));
136   EXPECT_FALSE(PSI.isColdCount(0));
137 
138   EXPECT_FALSE(PSI.isFunctionEntryHot(F));
139   EXPECT_FALSE(PSI.isFunctionEntryCold(F));
140 
141   BasicBlock &BB0 = F->getEntryBlock();
142   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
143 
144   BlockFrequencyInfo BFI = buildBFI(*F);
145   EXPECT_FALSE(PSI.isHotBlock(&BB0, &BFI));
146   EXPECT_FALSE(PSI.isColdBlock(&BB0, &BFI));
147 
148   CallBase &CS1 = cast<CallBase>(*BB1->getFirstNonPHI());
149   EXPECT_FALSE(PSI.isHotCallSite(CS1, &BFI));
150   EXPECT_FALSE(PSI.isColdCallSite(CS1, &BFI));
151 }
152 TEST_F(ProfileSummaryInfoTest, TestCommon) {
153   auto M = makeLLVMModule("InstrProf");
154   Function *F = M->getFunction("f");
155   Function *G = M->getFunction("g");
156   Function *H = M->getFunction("h");
157 
158   ProfileSummaryInfo PSI = buildPSI(M.get());
159   EXPECT_TRUE(PSI.hasProfileSummary());
160   EXPECT_TRUE(PSI.isHotCount(400));
161   EXPECT_TRUE(PSI.isColdCount(2));
162   EXPECT_FALSE(PSI.isColdCount(100));
163   EXPECT_FALSE(PSI.isHotCount(100));
164 
165   EXPECT_TRUE(PSI.isHotCountNthPercentile(990000, 400));
166   EXPECT_FALSE(PSI.isHotCountNthPercentile(990000, 100));
167   EXPECT_FALSE(PSI.isHotCountNthPercentile(990000, 2));
168 
169   EXPECT_FALSE(PSI.isColdCountNthPercentile(990000, 400));
170   EXPECT_TRUE(PSI.isColdCountNthPercentile(990000, 100));
171   EXPECT_TRUE(PSI.isColdCountNthPercentile(990000, 2));
172 
173   EXPECT_TRUE(PSI.isHotCountNthPercentile(999999, 400));
174   EXPECT_TRUE(PSI.isHotCountNthPercentile(999999, 100));
175   EXPECT_FALSE(PSI.isHotCountNthPercentile(999999, 2));
176 
177   EXPECT_FALSE(PSI.isColdCountNthPercentile(999999, 400));
178   EXPECT_FALSE(PSI.isColdCountNthPercentile(999999, 100));
179   EXPECT_TRUE(PSI.isColdCountNthPercentile(999999, 2));
180 
181   EXPECT_FALSE(PSI.isHotCountNthPercentile(10000, 400));
182   EXPECT_FALSE(PSI.isHotCountNthPercentile(10000, 100));
183   EXPECT_FALSE(PSI.isHotCountNthPercentile(10000, 2));
184 
185   EXPECT_TRUE(PSI.isColdCountNthPercentile(10000, 400));
186   EXPECT_TRUE(PSI.isColdCountNthPercentile(10000, 100));
187   EXPECT_TRUE(PSI.isColdCountNthPercentile(10000, 2));
188 
189   EXPECT_TRUE(PSI.isFunctionEntryHot(F));
190   EXPECT_FALSE(PSI.isFunctionEntryHot(G));
191   EXPECT_FALSE(PSI.isFunctionEntryHot(H));
192 }
193 
194 TEST_F(ProfileSummaryInfoTest, InstrProf) {
195   auto M = makeLLVMModule("InstrProf");
196   Function *F = M->getFunction("f");
197   ProfileSummaryInfo PSI = buildPSI(M.get());
198   EXPECT_TRUE(PSI.hasProfileSummary());
199   EXPECT_TRUE(PSI.hasInstrumentationProfile());
200 
201   BasicBlock &BB0 = F->getEntryBlock();
202   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
203   BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
204   BasicBlock *BB3 = BB1->getSingleSuccessor();
205 
206   BlockFrequencyInfo BFI = buildBFI(*F);
207   EXPECT_TRUE(PSI.isHotBlock(&BB0, &BFI));
208   EXPECT_TRUE(PSI.isHotBlock(BB1, &BFI));
209   EXPECT_FALSE(PSI.isHotBlock(BB2, &BFI));
210   EXPECT_TRUE(PSI.isHotBlock(BB3, &BFI));
211 
212   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
213   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
214   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
215   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
216 
217   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
218   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
219   EXPECT_TRUE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
220   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
221 
222   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, &BB0, &BFI));
223   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB1, &BFI));
224   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB2, &BFI));
225   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB3, &BFI));
226 
227   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, &BB0, &BFI));
228   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB1, &BFI));
229   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB2, &BFI));
230   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB3, &BFI));
231 
232   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, &BB0, &BFI));
233   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB1, &BFI));
234   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB2, &BFI));
235   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB3, &BFI));
236 
237   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, &BB0, &BFI));
238   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB1, &BFI));
239   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB2, &BFI));
240   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB3, &BFI));
241 
242   CallBase &CS1 = cast<CallBase>(*BB1->getFirstNonPHI());
243   auto *CI2 = BB2->getFirstNonPHI();
244   CallBase &CS2 = cast<CallBase>(*CI2);
245 
246   EXPECT_TRUE(PSI.isHotCallSite(CS1, &BFI));
247   EXPECT_FALSE(PSI.isHotCallSite(CS2, &BFI));
248 
249   // Test that adding an MD_prof metadata with a hot count on CS2 does not
250   // change its hotness as it has no effect in instrumented profiling.
251   MDBuilder MDB(M->getContext());
252   CI2->setMetadata(llvm::LLVMContext::MD_prof, MDB.createBranchWeights({400}));
253   EXPECT_FALSE(PSI.isHotCallSite(CS2, &BFI));
254 
255   EXPECT_TRUE(PSI.isFunctionHotInCallGraphNthPercentile(990000, F, BFI));
256   EXPECT_FALSE(PSI.isFunctionColdInCallGraphNthPercentile(990000, F, BFI));
257   EXPECT_FALSE(PSI.isFunctionHotInCallGraphNthPercentile(10000, F, BFI));
258   EXPECT_TRUE(PSI.isFunctionColdInCallGraphNthPercentile(10000, F, BFI));
259 }
260 
261 TEST_F(ProfileSummaryInfoTest, InstrProfNoFuncEntryCount) {
262   auto M = makeLLVMModule("InstrProf");
263   Function *F = M->getFunction("l");
264   ProfileSummaryInfo PSI = buildPSI(M.get());
265   EXPECT_TRUE(PSI.hasProfileSummary());
266   EXPECT_TRUE(PSI.hasInstrumentationProfile());
267 
268   BasicBlock &BB0 = F->getEntryBlock();
269   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
270   BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
271   BasicBlock *BB3 = BB1->getSingleSuccessor();
272 
273   BlockFrequencyInfo BFI = buildBFI(*F);
274 
275   // Without the entry count, all should return false.
276   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
277   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
278   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
279   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
280   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
281   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
282   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
283   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
284 
285   EXPECT_FALSE(PSI.isFunctionHotInCallGraphNthPercentile(990000, F, BFI));
286   EXPECT_FALSE(PSI.isFunctionColdInCallGraphNthPercentile(990000, F, BFI));
287 }
288 
289 TEST_F(ProfileSummaryInfoTest, SampleProf) {
290   auto M = makeLLVMModule("SampleProfile");
291   Function *F = M->getFunction("f");
292   ProfileSummaryInfo PSI = buildPSI(M.get());
293   EXPECT_TRUE(PSI.hasProfileSummary());
294   EXPECT_TRUE(PSI.hasSampleProfile());
295   EXPECT_FALSE(PSI.hasPartialSampleProfile());
296 
297   BasicBlock &BB0 = F->getEntryBlock();
298   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
299   BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
300   BasicBlock *BB3 = BB1->getSingleSuccessor();
301 
302   BlockFrequencyInfo BFI = buildBFI(*F);
303   EXPECT_TRUE(PSI.isHotBlock(&BB0, &BFI));
304   EXPECT_TRUE(PSI.isHotBlock(BB1, &BFI));
305   EXPECT_FALSE(PSI.isHotBlock(BB2, &BFI));
306   EXPECT_TRUE(PSI.isHotBlock(BB3, &BFI));
307 
308   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
309   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
310   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
311   EXPECT_TRUE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
312 
313   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
314   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
315   EXPECT_TRUE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
316   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
317 
318   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, &BB0, &BFI));
319   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB1, &BFI));
320   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB2, &BFI));
321   EXPECT_TRUE(PSI.isHotBlockNthPercentile(999900, BB3, &BFI));
322 
323   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, &BB0, &BFI));
324   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB1, &BFI));
325   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB2, &BFI));
326   EXPECT_FALSE(PSI.isColdBlockNthPercentile(999900, BB3, &BFI));
327 
328   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, &BB0, &BFI));
329   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB1, &BFI));
330   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB2, &BFI));
331   EXPECT_FALSE(PSI.isHotBlockNthPercentile(10000, BB3, &BFI));
332 
333   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, &BB0, &BFI));
334   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB1, &BFI));
335   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB2, &BFI));
336   EXPECT_TRUE(PSI.isColdBlockNthPercentile(10000, BB3, &BFI));
337 
338   CallBase &CS1 = cast<CallBase>(*BB1->getFirstNonPHI());
339   auto *CI2 = BB2->getFirstNonPHI();
340   // Manually attach branch weights metadata to the call instruction.
341   SmallVector<uint32_t, 1> Weights;
342   Weights.push_back(1000);
343   MDBuilder MDB(M->getContext());
344   CI2->setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
345   CallBase &CS2 = cast<CallBase>(*CI2);
346 
347   EXPECT_FALSE(PSI.isHotCallSite(CS1, &BFI));
348   EXPECT_TRUE(PSI.isHotCallSite(CS2, &BFI));
349 
350   // Test that CS2 is considered hot when it gets an MD_prof metadata with
351   // weights that exceed the hot count threshold.
352   CI2->setMetadata(llvm::LLVMContext::MD_prof, MDB.createBranchWeights({400}));
353   EXPECT_TRUE(PSI.isHotCallSite(CS2, &BFI));
354 
355   EXPECT_TRUE(PSI.isFunctionHotInCallGraphNthPercentile(990000, F, BFI));
356   EXPECT_FALSE(PSI.isFunctionColdInCallGraphNthPercentile(990000, F, BFI));
357   EXPECT_FALSE(PSI.isFunctionHotInCallGraphNthPercentile(10000, F, BFI));
358   EXPECT_TRUE(PSI.isFunctionColdInCallGraphNthPercentile(10000, F, BFI));
359 }
360 
361 TEST_F(ProfileSummaryInfoTest, SampleProfNoFuncEntryCount) {
362   auto M = makeLLVMModule("SampleProfile");
363   Function *F = M->getFunction("l");
364   ProfileSummaryInfo PSI = buildPSI(M.get());
365   EXPECT_TRUE(PSI.hasProfileSummary());
366   EXPECT_TRUE(PSI.hasSampleProfile());
367 
368   BasicBlock &BB0 = F->getEntryBlock();
369   BasicBlock *BB1 = BB0.getTerminator()->getSuccessor(0);
370   BasicBlock *BB2 = BB0.getTerminator()->getSuccessor(1);
371   BasicBlock *BB3 = BB1->getSingleSuccessor();
372 
373   BlockFrequencyInfo BFI = buildBFI(*F);
374 
375   // Without the entry count, all should return false.
376   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, &BB0, &BFI));
377   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB1, &BFI));
378   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB2, &BFI));
379   EXPECT_FALSE(PSI.isHotBlockNthPercentile(990000, BB3, &BFI));
380   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, &BB0, &BFI));
381   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB1, &BFI));
382   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB2, &BFI));
383   EXPECT_FALSE(PSI.isColdBlockNthPercentile(990000, BB3, &BFI));
384 
385   EXPECT_FALSE(PSI.isFunctionHotInCallGraphNthPercentile(990000, F, BFI));
386   EXPECT_FALSE(PSI.isFunctionColdInCallGraphNthPercentile(990000, F, BFI));
387 }
388 
389 TEST_F(ProfileSummaryInfoTest, PartialSampleProfWorkingSetSize) {
390   ScalePartialSampleProfileWorkingSetSize.setValue(true);
391 
392   // With PartialProfileRatio unset (zero.)
393   auto M1 = makeLLVMModule("SampleProfile", /*NumCounts*/ 3,
394                            /*IsPartialProfile*/ 1,
395                            /*PartialProfileRatio*/ 0.0,
396                            /*HotNumCounts*/ 3, /*ColdNumCounts*/ 10);
397   ProfileSummaryInfo PSI1 = buildPSI(M1.get());
398   EXPECT_TRUE(PSI1.hasProfileSummary());
399   EXPECT_TRUE(PSI1.hasSampleProfile());
400   EXPECT_TRUE(PSI1.hasPartialSampleProfile());
401   EXPECT_FALSE(PSI1.hasHugeWorkingSetSize());
402   EXPECT_FALSE(PSI1.hasLargeWorkingSetSize());
403 
404   // With PartialProfileRatio set (non-zero) and a small working set size.
405   auto M2 = makeLLVMModule("SampleProfile", /*NumCounts*/ 27493235,
406                            /*IsPartialProfile*/ 1,
407                            /*PartialProfileRatio*/ 0.00000012,
408                            /*HotNumCounts*/ 3102082,
409                            /*ColdNumCounts*/ 18306149);
410   ProfileSummaryInfo PSI2 = buildPSI(M2.get());
411   EXPECT_TRUE(PSI2.hasProfileSummary());
412   EXPECT_TRUE(PSI2.hasSampleProfile());
413   EXPECT_TRUE(PSI2.hasPartialSampleProfile());
414   EXPECT_FALSE(PSI2.hasHugeWorkingSetSize());
415   EXPECT_FALSE(PSI2.hasLargeWorkingSetSize());
416 
417   // With PartialProfileRatio is set (non-zero) and a large working set size.
418   auto M3 = makeLLVMModule("SampleProfile", /*NumCounts*/ 27493235,
419                            /*IsPartialProfile*/ 1,
420                            /*PartialProfileRatio*/ 0.9,
421                            /*HotNumCounts*/ 3102082,
422                            /*ColdNumCounts*/ 18306149);
423   ProfileSummaryInfo PSI3 = buildPSI(M3.get());
424   EXPECT_TRUE(PSI3.hasProfileSummary());
425   EXPECT_TRUE(PSI3.hasSampleProfile());
426   EXPECT_TRUE(PSI3.hasPartialSampleProfile());
427   EXPECT_TRUE(PSI3.hasHugeWorkingSetSize());
428   EXPECT_TRUE(PSI3.hasLargeWorkingSetSize());
429 }
430 
431 } // end anonymous namespace
432 } // end namespace llvm
433