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/ADT/StringMap.h" 11 #include "llvm/ADT/StringRef.h" 12 #include "llvm/IR/LLVMContext.h" 13 #include "llvm/IR/Metadata.h" 14 #include "llvm/IR/Module.h" 15 #include "llvm/ProfileData/ProfileCommon.h" 16 #include "llvm/ProfileData/SampleProf.h" 17 #include "llvm/ProfileData/SampleProfReader.h" 18 #include "llvm/ProfileData/SampleProfWriter.h" 19 #include "llvm/Support/Casting.h" 20 #include "llvm/Support/ErrorOr.h" 21 #include "llvm/Support/MemoryBuffer.h" 22 #include "llvm/Support/raw_ostream.h" 23 #include "gtest/gtest.h" 24 #include <algorithm> 25 #include <cstdint> 26 #include <limits> 27 #include <memory> 28 #include <string> 29 #include <system_error> 30 #include <vector> 31 32 using namespace llvm; 33 using namespace sampleprof; 34 35 static ::testing::AssertionResult NoError(std::error_code EC) { 36 if (!EC) 37 return ::testing::AssertionSuccess(); 38 return ::testing::AssertionFailure() << "error " << EC.value() << ": " 39 << EC.message(); 40 } 41 42 namespace { 43 44 struct SampleProfTest : ::testing::Test { 45 std::string Data; 46 LLVMContext Context; 47 std::unique_ptr<raw_ostream> OS; 48 std::unique_ptr<SampleProfileWriter> Writer; 49 std::unique_ptr<SampleProfileReader> Reader; 50 51 SampleProfTest() 52 : Data(), OS(new raw_string_ostream(Data)), Writer(), Reader() {} 53 54 void createWriter(SampleProfileFormat Format) { 55 auto WriterOrErr = SampleProfileWriter::create(OS, Format); 56 ASSERT_TRUE(NoError(WriterOrErr.getError())); 57 Writer = std::move(WriterOrErr.get()); 58 } 59 60 void readProfile(std::unique_ptr<MemoryBuffer> &Profile) { 61 auto ReaderOrErr = SampleProfileReader::create(Profile, Context); 62 ASSERT_TRUE(NoError(ReaderOrErr.getError())); 63 Reader = std::move(ReaderOrErr.get()); 64 } 65 66 void testRoundTrip(SampleProfileFormat Format) { 67 createWriter(Format); 68 69 StringRef FooName("_Z3fooi"); 70 FunctionSamples FooSamples; 71 FooSamples.setName(FooName); 72 FooSamples.addTotalSamples(7711); 73 FooSamples.addHeadSamples(610); 74 FooSamples.addBodySamples(1, 0, 610); 75 FooSamples.addBodySamples(2, 0, 600); 76 FooSamples.addBodySamples(4, 0, 60000); 77 FooSamples.addBodySamples(8, 0, 60351); 78 FooSamples.addBodySamples(10, 0, 605); 79 80 StringRef BarName("_Z3bari"); 81 FunctionSamples BarSamples; 82 BarSamples.setName(BarName); 83 BarSamples.addTotalSamples(20301); 84 BarSamples.addHeadSamples(1437); 85 BarSamples.addBodySamples(1, 0, 1437); 86 87 StringMap<FunctionSamples> Profiles; 88 Profiles[FooName] = std::move(FooSamples); 89 Profiles[BarName] = std::move(BarSamples); 90 91 std::error_code EC; 92 EC = Writer->write(Profiles); 93 ASSERT_TRUE(NoError(EC)); 94 95 Writer->getOutputStream().flush(); 96 97 auto Profile = MemoryBuffer::getMemBufferCopy(Data); 98 readProfile(Profile); 99 100 EC = Reader->read(); 101 ASSERT_TRUE(NoError(EC)); 102 103 StringMap<FunctionSamples> &ReadProfiles = Reader->getProfiles(); 104 ASSERT_EQ(2u, ReadProfiles.size()); 105 106 FunctionSamples &ReadFooSamples = ReadProfiles[FooName]; 107 ASSERT_EQ(7711u, ReadFooSamples.getTotalSamples()); 108 ASSERT_EQ(610u, ReadFooSamples.getHeadSamples()); 109 110 FunctionSamples &ReadBarSamples = ReadProfiles[BarName]; 111 ASSERT_EQ(20301u, ReadBarSamples.getTotalSamples()); 112 ASSERT_EQ(1437u, ReadBarSamples.getHeadSamples()); 113 114 auto VerifySummary = [](SampleProfileSummary &Summary) mutable { 115 ASSERT_EQ(123603u, Summary.getTotalSamples()); 116 ASSERT_EQ(6u, Summary.getNumLinesWithSamples()); 117 ASSERT_EQ(2u, Summary.getNumFunctions()); 118 ASSERT_EQ(1437u, Summary.getMaxFunctionCount()); 119 ASSERT_EQ(60351u, Summary.getMaxSamplesPerLine()); 120 121 uint32_t Cutoff = 800000; 122 auto Predicate = [&Cutoff](const ProfileSummaryEntry &PE) { 123 return PE.Cutoff == Cutoff; 124 }; 125 std::vector<ProfileSummaryEntry> &Details = Summary.getDetailedSummary(); 126 auto EightyPerc = std::find_if(Details.begin(), Details.end(), Predicate); 127 Cutoff = 900000; 128 auto NinetyPerc = std::find_if(Details.begin(), Details.end(), Predicate); 129 Cutoff = 950000; 130 auto NinetyFivePerc = 131 std::find_if(Details.begin(), Details.end(), Predicate); 132 Cutoff = 990000; 133 auto NinetyNinePerc = 134 std::find_if(Details.begin(), Details.end(), Predicate); 135 ASSERT_EQ(60000u, EightyPerc->MinCount); 136 ASSERT_EQ(60000u, NinetyPerc->MinCount); 137 ASSERT_EQ(60000u, NinetyFivePerc->MinCount); 138 ASSERT_EQ(610u, NinetyNinePerc->MinCount); 139 }; 140 141 SampleProfileSummary &Summary = Reader->getSummary(); 142 VerifySummary(Summary); 143 144 // Test that conversion of summary to and from Metadata works. 145 Metadata *MD = Summary.getMD(Context); 146 ASSERT_TRUE(MD); 147 ProfileSummary *PS = ProfileSummary::getFromMD(MD); 148 ASSERT_TRUE(PS); 149 ASSERT_TRUE(isa<SampleProfileSummary>(PS)); 150 SampleProfileSummary *SPS = cast<SampleProfileSummary>(PS); 151 VerifySummary(*SPS); 152 delete SPS; 153 154 // Test that summary can be attached to and read back from module. 155 Module M("my_module", Context); 156 M.setProfileSummary(MD); 157 MD = M.getProfileSummary(); 158 ASSERT_TRUE(MD); 159 PS = ProfileSummary::getFromMD(MD); 160 ASSERT_TRUE(PS); 161 ASSERT_TRUE(isa<SampleProfileSummary>(PS)); 162 SPS = cast<SampleProfileSummary>(PS); 163 VerifySummary(*SPS); 164 delete SPS; 165 } 166 }; 167 168 TEST_F(SampleProfTest, roundtrip_text_profile) { 169 testRoundTrip(SampleProfileFormat::SPF_Text); 170 } 171 172 TEST_F(SampleProfTest, roundtrip_binary_profile) { 173 testRoundTrip(SampleProfileFormat::SPF_Binary); 174 } 175 176 TEST_F(SampleProfTest, sample_overflow_saturation) { 177 const uint64_t Max = std::numeric_limits<uint64_t>::max(); 178 sampleprof_error Result; 179 180 StringRef FooName("_Z3fooi"); 181 FunctionSamples FooSamples; 182 Result = FooSamples.addTotalSamples(1); 183 ASSERT_EQ(Result, sampleprof_error::success); 184 185 Result = FooSamples.addHeadSamples(1); 186 ASSERT_EQ(Result, sampleprof_error::success); 187 188 Result = FooSamples.addBodySamples(10, 0, 1); 189 ASSERT_EQ(Result, sampleprof_error::success); 190 191 Result = FooSamples.addTotalSamples(Max); 192 ASSERT_EQ(Result, sampleprof_error::counter_overflow); 193 ASSERT_EQ(FooSamples.getTotalSamples(), Max); 194 195 Result = FooSamples.addHeadSamples(Max); 196 ASSERT_EQ(Result, sampleprof_error::counter_overflow); 197 ASSERT_EQ(FooSamples.getHeadSamples(), Max); 198 199 Result = FooSamples.addBodySamples(10, 0, Max); 200 ASSERT_EQ(Result, sampleprof_error::counter_overflow); 201 ErrorOr<uint64_t> BodySamples = FooSamples.findSamplesAt(10, 0); 202 ASSERT_FALSE(BodySamples.getError()); 203 ASSERT_EQ(BodySamples.get(), Max); 204 } 205 206 } // end anonymous namespace 207