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