1 //===- unittest/ProfileData/SampleProfTest.cpp ------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/ProfileData/SampleProf.h" 11 #include "llvm/ADT/StringMap.h" 12 #include "llvm/ADT/StringRef.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/MemoryBuffer.h" 21 #include "llvm/Support/raw_ostream.h" 22 #include "gtest/gtest.h" 23 #include <string> 24 #include <vector> 25 26 using namespace llvm; 27 using namespace sampleprof; 28 29 static ::testing::AssertionResult NoError(std::error_code EC) { 30 if (!EC) 31 return ::testing::AssertionSuccess(); 32 return ::testing::AssertionFailure() << "error " << EC.value() << ": " 33 << EC.message(); 34 } 35 36 namespace { 37 38 struct SampleProfTest : ::testing::Test { 39 LLVMContext Context; 40 std::unique_ptr<SampleProfileWriter> Writer; 41 std::unique_ptr<SampleProfileReader> Reader; 42 43 SampleProfTest() : Writer(), Reader() {} 44 45 void createWriter(SampleProfileFormat Format, StringRef Profile) { 46 std::error_code EC; 47 std::unique_ptr<raw_ostream> OS( 48 new raw_fd_ostream(Profile, EC, sys::fs::F_None)); 49 auto WriterOrErr = SampleProfileWriter::create(OS, Format); 50 ASSERT_TRUE(NoError(WriterOrErr.getError())); 51 Writer = std::move(WriterOrErr.get()); 52 } 53 54 void readProfile(const Module &M, StringRef Profile) { 55 auto ReaderOrErr = SampleProfileReader::create(Profile, Context); 56 ASSERT_TRUE(NoError(ReaderOrErr.getError())); 57 Reader = std::move(ReaderOrErr.get()); 58 Reader->collectFuncsToUse(M); 59 } 60 61 void testRoundTrip(SampleProfileFormat Format, bool Remap) { 62 SmallVector<char, 128> ProfilePath; 63 ASSERT_TRUE(NoError(llvm::sys::fs::createTemporaryFile("profile", "", ProfilePath))); 64 StringRef Profile(ProfilePath.data(), ProfilePath.size()); 65 createWriter(Format, Profile); 66 67 StringRef FooName("_Z3fooi"); 68 FunctionSamples FooSamples; 69 FooSamples.setName(FooName); 70 FooSamples.addTotalSamples(7711); 71 FooSamples.addHeadSamples(610); 72 FooSamples.addBodySamples(1, 0, 610); 73 FooSamples.addBodySamples(2, 0, 600); 74 FooSamples.addBodySamples(4, 0, 60000); 75 FooSamples.addBodySamples(8, 0, 60351); 76 FooSamples.addBodySamples(10, 0, 605); 77 78 StringRef BarName("_Z3bari"); 79 FunctionSamples BarSamples; 80 BarSamples.setName(BarName); 81 BarSamples.addTotalSamples(20301); 82 BarSamples.addHeadSamples(1437); 83 BarSamples.addBodySamples(1, 0, 1437); 84 // Test how reader/writer handles unmangled names. 85 StringRef MconstructName("_M_construct<char *>"); 86 StringRef StringviewName("string_view<std::allocator<char> >"); 87 BarSamples.addCalledTargetSamples(1, 0, MconstructName, 1000); 88 BarSamples.addCalledTargetSamples(1, 0, StringviewName, 437); 89 90 Module M("my_module", Context); 91 FunctionType *fn_type = 92 FunctionType::get(Type::getVoidTy(Context), {}, false); 93 M.getOrInsertFunction(FooName, fn_type); 94 M.getOrInsertFunction(BarName, fn_type); 95 96 StringMap<FunctionSamples> Profiles; 97 Profiles[FooName] = std::move(FooSamples); 98 Profiles[BarName] = std::move(BarSamples); 99 100 std::error_code EC; 101 EC = Writer->write(Profiles); 102 ASSERT_TRUE(NoError(EC)); 103 104 Writer->getOutputStream().flush(); 105 106 readProfile(M, Profile); 107 108 EC = Reader->read(); 109 ASSERT_TRUE(NoError(EC)); 110 111 if (Remap) { 112 auto MemBuffer = llvm::MemoryBuffer::getMemBuffer(R"( 113 # Types 'int' and 'long' are equivalent 114 type i l 115 # Function names 'foo' and 'faux' are equivalent 116 name 3foo 4faux 117 )"); 118 Reader.reset(new SampleProfileReaderItaniumRemapper( 119 std::move(MemBuffer), Context, std::move(Reader))); 120 FooName = "_Z4fauxi"; 121 BarName = "_Z3barl"; 122 123 EC = Reader->read(); 124 ASSERT_TRUE(NoError(EC)); 125 } 126 127 ASSERT_EQ(2u, Reader->getProfiles().size()); 128 129 FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName); 130 ASSERT_TRUE(ReadFooSamples != nullptr); 131 if (Format != SampleProfileFormat::SPF_Compact_Binary) { 132 ASSERT_EQ("_Z3fooi", ReadFooSamples->getName()); 133 } 134 ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples()); 135 ASSERT_EQ(610u, ReadFooSamples->getHeadSamples()); 136 137 FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName); 138 ASSERT_TRUE(ReadBarSamples != nullptr); 139 if (Format != SampleProfileFormat::SPF_Compact_Binary) { 140 ASSERT_EQ("_Z3bari", ReadBarSamples->getName()); 141 } 142 ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples()); 143 ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples()); 144 ErrorOr<SampleRecord::CallTargetMap> CTMap = 145 ReadBarSamples->findCallTargetMapAt(1, 0); 146 ASSERT_FALSE(CTMap.getError()); 147 148 std::string MconstructGUID; 149 StringRef MconstructRep = 150 getRepInFormat(MconstructName, Format, MconstructGUID); 151 std::string StringviewGUID; 152 StringRef StringviewRep = 153 getRepInFormat(StringviewName, Format, StringviewGUID); 154 ASSERT_EQ(1000u, CTMap.get()[MconstructRep]); 155 ASSERT_EQ(437u, CTMap.get()[StringviewRep]); 156 157 auto VerifySummary = [](ProfileSummary &Summary) mutable { 158 ASSERT_EQ(ProfileSummary::PSK_Sample, Summary.getKind()); 159 ASSERT_EQ(123603u, Summary.getTotalCount()); 160 ASSERT_EQ(6u, Summary.getNumCounts()); 161 ASSERT_EQ(2u, Summary.getNumFunctions()); 162 ASSERT_EQ(1437u, Summary.getMaxFunctionCount()); 163 ASSERT_EQ(60351u, Summary.getMaxCount()); 164 165 uint32_t Cutoff = 800000; 166 auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) { 167 return PE.Cutoff == Cutoff; 168 }; 169 std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary(); 170 auto EightyPerc = find_if(Details, Predicate); 171 Cutoff = 900000; 172 auto NinetyPerc = find_if(Details, Predicate); 173 Cutoff = 950000; 174 auto NinetyFivePerc = find_if(Details, Predicate); 175 Cutoff = 990000; 176 auto NinetyNinePerc = find_if(Details, Predicate); 177 ASSERT_EQ(60000u, EightyPerc->MinCount); 178 ASSERT_EQ(60000u, NinetyPerc->MinCount); 179 ASSERT_EQ(60000u, NinetyFivePerc->MinCount); 180 ASSERT_EQ(610u, NinetyNinePerc->MinCount); 181 }; 182 183 ProfileSummary &Summary = Reader->getSummary(); 184 VerifySummary(Summary); 185 186 // Test that conversion of summary to and from Metadata works. 187 Metadata *MD = Summary.getMD(Context); 188 ASSERT_TRUE(MD); 189 ProfileSummary *PS = ProfileSummary::getFromMD(MD); 190 ASSERT_TRUE(PS); 191 VerifySummary(*PS); 192 delete PS; 193 194 // Test that summary can be attached to and read back from module. 195 M.setProfileSummary(MD); 196 MD = M.getProfileSummary(); 197 ASSERT_TRUE(MD); 198 PS = ProfileSummary::getFromMD(MD); 199 ASSERT_TRUE(PS); 200 VerifySummary(*PS); 201 delete PS; 202 } 203 }; 204 205 TEST_F(SampleProfTest, roundtrip_text_profile) { 206 testRoundTrip(SampleProfileFormat::SPF_Text, false); 207 } 208 209 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) { 210 testRoundTrip(SampleProfileFormat::SPF_Binary, false); 211 } 212 213 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) { 214 testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false); 215 } 216 217 TEST_F(SampleProfTest, remap_text_profile) { 218 testRoundTrip(SampleProfileFormat::SPF_Text, true); 219 } 220 221 TEST_F(SampleProfTest, remap_raw_binary_profile) { 222 testRoundTrip(SampleProfileFormat::SPF_Binary, true); 223 } 224 225 TEST_F(SampleProfTest, sample_overflow_saturation) { 226 const uint64_t Max = std::numeric_limits<uint64_t>::max(); 227 sampleprof_error Result; 228 229 StringRef FooName("_Z3fooi"); 230 FunctionSamples FooSamples; 231 Result = FooSamples.addTotalSamples(1); 232 ASSERT_EQ(Result, sampleprof_error::success); 233 234 Result = FooSamples.addHeadSamples(1); 235 ASSERT_EQ(Result, sampleprof_error::success); 236 237 Result = FooSamples.addBodySamples(10, 0, 1); 238 ASSERT_EQ(Result, sampleprof_error::success); 239 240 Result = FooSamples.addTotalSamples(Max); 241 ASSERT_EQ(Result, sampleprof_error::counter_overflow); 242 ASSERT_EQ(FooSamples.getTotalSamples(), Max); 243 244 Result = FooSamples.addHeadSamples(Max); 245 ASSERT_EQ(Result, sampleprof_error::counter_overflow); 246 ASSERT_EQ(FooSamples.getHeadSamples(), Max); 247 248 Result = FooSamples.addBodySamples(10, 0, Max); 249 ASSERT_EQ(Result, sampleprof_error::counter_overflow); 250 ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0); 251 ASSERT_FALSE(BodySamples.getError()); 252 ASSERT_EQ(BodySamples.get(), Max); 253 } 254 255 } // end anonymous namespace 256