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